private static async Task SimpleService()
{
//setup basic "network" streams (you can use network streams of course)
using var m1 = new BlockingStream();
using var m2 = new BlockingStream();
//setup server
using var server = new ApiServer <SimpleServiceServer>(m1, m2);
server.Start(); //this will start the polling
//setup client
using var client = new ApiClient <SimpleServiceClient>(m2, m1);
client.Start(); //this will start the polling
//fetch some numbers
var numbers = (await client.Api.GetRandomNumber(new RandonNumberRequest()
{
Count = 5,
MinValue = 0,
MaxValue = 100,
})).Number.ToArray();
//output the numbers
Console.WriteLine($"Your random numbers are: {string.Join(", ", numbers)}");
}
public void WaitForExitBlocksWhenStillReading()
{
var blockingStream = new BlockingStream();
var sr = new StreamReader(blockingStream);
var sw = new StringWriter();
var handler = new AsyncTwoWayStreamsHandler(sr, sw);
var stopWatch = new Stopwatch();
stopWatch.Start();
new Task(() =>
{
Thread.Sleep(100);
blockingStream.Unblock();
}).Start();
handler.WaitForExit();
stopWatch.Stop();
if (stopWatch.ElapsedMilliseconds < 100)
{
Assert.Fail("WaitForExit returned before the timer finished");
}
else
{
Assert.Pass("Successfully waited for the stream to end");
}
}
public void Test_Transaction_ReleaseWhenFailToStart()
{
var blockingStream = new BlockingStream();
var db = new LiteDatabase(blockingStream)
{
Timeout = TimeSpan.FromSeconds(1)
};
Thread lockerThread = null;
try
{
lockerThread = new Thread(() =>
{
db.GetCollection <Person>().Insert(new Person());
blockingStream.ShouldBlock = true;
db.Checkpoint();
db.Dispose();
});
lockerThread.Start();
blockingStream.Blocked.WaitOne(1000).Should().BeTrue();
Assert.Throws <LiteException>(() => db.GetCollection <Person>().Insert(new Person())).Message.Should().Contain("timeout");
Assert.Throws <LiteException>(() => db.GetCollection <Person>().Insert(new Person())).Message.Should().Contain("timeout");
}
finally
{
blockingStream.ShouldUnblock.Set();
lockerThread?.Join();
}
}
private void RunCore(
Benchmark benchmark, IRunnableBenchmark runnableBenchmark,
ILogger logger, IDiagnoser diagnoser,
BlockingStream outputStream)
{
var outputWriter = new StreamWriter(outputStream);
var process = Process.GetCurrentProcess();
try
{
runnableBenchmark.Init(benchmark, outputWriter);
diagnoser?.ProcessStarted(process);
runnableBenchmark.Run();
diagnoser?.AfterBenchmarkHasRun(benchmark, process);
}
catch (Exception ex)
{
logger.WriteLineError($"// ! {GetType().Name}, exception: {ex}");
}
finally
{
diagnoser?.ProcessStopped(process);
outputWriter.Flush();
outputStream.CompleteWriting();
}
}
public async Task Streams_Bidi_FetchNumbersTest()
{
using var m1 = new BlockingStream();
using var m2 = new BlockingStream();
using var server = new ApiServer <SimpleServiceClient, Server>(m1, m2);
server.Start();
using var client = new ApiClient <SimpleServiceClient, Server>(m2, m1);
client.Start();
var testNumbers = new[]
{
1.0,
Math.PI,
0.0,
-10.0
};
foreach (var num in testNumbers)
{
var check = num < 0 ? double.NaN : Math.Sqrt(num);
var response = await client.RequestApi.Sqrt(value : num);
Assert.AreEqual(check, response.Value);
}
foreach (var num in testNumbers)
{
var check = num < 0 ? double.NaN : Math.Sqrt(num);
var response = await server.RequestApi.Sqrt(value : num);
Assert.AreEqual(check, response.Value);
}
}
public async Task <FileHeader> Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
var pipe = new BlockingStream(10);
Task.Run(() => StreamWriter(pipe))
.ContinueWith(x => pipe.CompleteWriting())
.ConfigureAwait(false);
if (sessionOperations.EntityChanged(Filename))
{
if (!sessionOperations.IsDeleted(Filename))
{
var fileHeaderInCache = await session.LoadFileAsync(Filename);
Metadata = fileHeaderInCache.Metadata;
}
}
await commands.UploadAsync(Filename, pipe, Metadata, Size, null)
.ConfigureAwait(false);
var metadata = await commands.GetMetadataForAsync(Filename);
if (metadata == null)
{
return(null);
}
return(new FileHeader(Filename, metadata));
}
public void ReadUntilTimeoutThrows()
{
var stream = new BlockingStream();
var sr = new StreamReader(stream);
var sw = new StringWriter();
var handler = new AsyncTwoWayStreamsHandler(sr, sw);
Assert.That(handler.ReadUntil(0.1, "MARKER"), Is.EqualTo("This line should be taken because it includes MARKER in it"));
}
private void OnMenuClickCreateNewCSV(object sender, EventArgs e)
{
if (!(this.dataGrid.DataSource is DataTable table))
{
MessageBox.Show("No results available to convert");
return;
}
var initialSettings = this._lastGenerateSettings ?? new CsvSettings(Main.Settings.DefaultSeparator.Unescape(),
Main.Settings.DefaultQuoteChar, '\0', true);
var settingsDialog = new ParseSettings(initialSettings)
{
btnReparse = { Text = "&Ok" },
MainLabel = { Text = "How should the CSV be generated?" },
hasHeaderCheckbox = { ThreeState = false, Text = "Create header row" },
txbCommentChar = { Visible = false },
CommentCharLabel = { Visible = false },
};
if (settingsDialog.ShowDialog() == DialogResult.Cancel)
{
return;
}
var settings = settingsDialog.Settings;
var watch = new DiagnosticTimer();
try
{
// Create new tab for results
Win32.SendMessage(PluginBase.nppData._nppHandle, (uint)NppMsg.NPPM_MENUCOMMAND, 0, NppMenuCmd.IDM_FILE_NEW);
watch.Checkpoint("New document created");
var headerLookup = Main.Settings.UseOriginalColumnHeadersOnGeneratedCsv &&
table.ExtendedProperties.ContainsKey("bufferId") &&
table.ExtendedProperties["bufferId"] is IntPtr bufferId
? Main.DataStorage.GetUnsafeColumnMaps(bufferId)
: null;
using (var stream = new BlockingStream(10))
{
var producer = stream.StartProducer(s => settings.GenerateToStream(this.dataGrid.DataSource as DataTable, s, headerLookup));
var consumer = stream.StartConsumer(s => PluginBase.CurrentScintillaGateway.AddText(s));
Task.WaitAll(producer, consumer);
}
}
catch (Exception ex)
{
Trace.TraceInformation("CSV gen: Exception: " + ex.GetType().Name + " - " + ex.Message);
}
this._lastGenerateSettings = settings;
Trace.TraceInformation(watch.LastCheckpoint("CSV Done"));
}
private static void CloseConnectionAndUnblockStream(TcpClient client, BlockingStream blockingStream)
{
try
{
client.Close();
}
finally
{
blockingStream.UnblockForOneRead();
}
}
public void ReadUntilTimeoutThrows()
{
var stream = new BlockingStream();
var stdout = new StreamReader(stream);
var stdin = new StringWriter();
var handler = new AsyncStreamsHandler(stdout, new StringReader(""), stdin);
handler.Invoking(h => h.ReadUntil(0.1, "MARKER"))
.Should()
.Throw <TimeoutException>()
.WithMessage("No result in alloted time: 00:00:00.1000000");
}
public async Task Execute(IAsyncFilesSession session)
{
var commands = session.Commands;
var pipe = new BlockingStream(10);
var task = Task.Run(() => StreamWriter(pipe))
.ContinueWith(x => { pipe.CompleteWriting(); })
.ConfigureAwait(false);
await commands.UploadAsync(Path, pipe, Metadata, Size, null)
.ConfigureAwait(false);
}
// TODO: replace outputStream with something better?
// WAITINGFOR: https://github.com/PerfDotNet/BenchmarkDotNet/issues/177
/// <summary>Executes the specified benchmark.</summary>
/// <param name="buildResult">The build result.</param>
/// <param name="benchmark">The benchmark.</param>
/// <param name="logger">The logger.</param>
/// <param name="diagnoser">The diagnoser.</param>
/// <returns>Execution result.</returns>
public ExecuteResult Execute(
BuildResult buildResult,
Benchmark benchmark,
ILogger logger,
IDiagnoser diagnoser = null)
{
var runnableBenchmark = RunnableBenchmarkFactory.Create(benchmark);
var outputStream = new BlockingStream(10000);
var runThread = new Thread(
() => RunCore(benchmark, runnableBenchmark, logger, diagnoser, outputStream));
RunWithPriority(
ProcessPriorityClass.RealTime,
benchmark.Job.Affinity,
logger,
() =>
{
runThread.IsBackground = true;
runThread.Priority = ThreadPriority.Highest;
runThread.Start();
if (!runThread.Join(ExecutionTimeout))
{
throw new InvalidOperationException(
"Benchmark takes to long to run. " +
"Prefer to use out-of-process toolchains for long-running benchmarks.");
}
});
var outputReader = new StreamReader(outputStream);
var lines = new List <string>();
string line;
while ((line = outputReader.ReadLine()) != null)
{
if (LogOutput)
{
logger.WriteLine(line);
}
if (!line.StartsWith("//") && !string.IsNullOrEmpty(line))
{
lines.Add(line);
}
}
return(new ExecuteResult(true, lines.ToArray()));
}
public async Task Streams_CancelRequest()
{
using var m1 = new BlockingStream();
using var m2 = new BlockingStream();
using var server = new ApiServer <Server>(m1, m2);
server.Start();
using var client = new ApiClient <SimpleServiceClient>(m2, m1);
client.Start();
await Assert.ThrowsExceptionAsync <TaskCanceledException>(async() =>
{
await client.Api.Indefinite(TimeSpan.FromMilliseconds(100));
});
}
public async Task HttpConnectionFailsAfterFirstRetryFailsServerSentEvents()
{
var testHttpHandler = new TestHttpMessageHandler(autoNegotiate: false);
var accessTokenCallCount = 0;
testHttpHandler.OnNegotiate((_, cancellationToken) =>
{
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationContent()));
});
testHttpHandler.OnSocketSend((_, _) =>
{
return(ResponseUtils.CreateResponse(HttpStatusCode.Unauthorized));
});
var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var stream = new BlockingStream(tcs);
testHttpHandler.OnRequest((request, next, token) =>
{
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(stream))));
});
Task <string> AccessTokenProvider()
{
accessTokenCallCount++;
return(Task.FromResult(accessTokenCallCount.ToString(CultureInfo.InvariantCulture)));
}
await WithConnectionAsync(
CreateConnection(testHttpHandler, transportType : HttpTransportType.ServerSentEvents, accessTokenProvider : AccessTokenProvider),
async (connection) =>
{
await connection.StartAsync().DefaultTimeout();
await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello world 1"));
await Assert.ThrowsAsync <HttpRequestException>(async() => await connection.Transport.Input.ReadAllAsync());
});
// 1 negotiate + 1 retry stream request
Assert.Equal(2, accessTokenCallCount);
}
protected virtual BlockingStream GetTarStream(IAsset asset)
{
const int chunk = 4096;
BlockingStream blockingStream = new BlockingStream(1000);
asset.GetStreamable().GetStreamAsync()
.ContinueWith(task =>
{
var stream = task.GetAwaiter().GetResult();
Task.Factory.StartNew(() =>
{
int read;
var buffer = new byte[chunk];
do
{
read = stream.Read(buffer, 0, chunk);
blockingStream.Write(buffer, 0, read);
} while (read == chunk);
blockingStream.Close();
});
});
return(blockingStream);
}
public void Should_return_SendFailure_code_when_socket_closed_while_sending_large_body()
{
if (!RuntimeDetector.IsDotNetCore21AndNewer)
{
return;
}
var contentLargerThanTcpPacket = ThreadSafeRandom.NextBytes(64 * 1024 + 10);
using (var stream = new BlockingStream(contentLargerThanTcpPacket))
{
using (var server = SocketTestServer.StartNew("",
// ReSharper disable once AccessToDisposedClosure
onBeforeRequestReading: c => CloseConnectionAndUnblockStream(c, stream)))
{
var request = Request
.Put(server.Url)
.WithContent(stream);
var response = Send(request);
response.Code.Should().Be(ResponseCode.SendFailure);
}
}
}
public ConsoleRepl(IExecutor exe)
{
InitializeComponent();
var inpoutStream = new BlockingStream(new MemoryStream());
var outputStream = new BlockingStream(new MemoryStream());
var replThread = new Thread(() => ClojureInit.REPL2(inpoutStream, outputStream, outputStream, exe));
replThread.Start();
var inputWriter = new StreamWriter(inpoutStream);
var outputReader = new StreamReader(outputStream);
outputReader.InitializeLifetimeService();
inputWriter.InitializeLifetimeService();
TextBoxStreamWriter textBoxStreamWriter = new TextBoxStreamWriter(this.richTextBox1);
new Thread(() => {
while (true)
{
var output = outputReader.Read();
if ((char)output != '\r')
{
textBoxStreamWriter.Write((char)output);
}
}
}).Start();
CommandInput.KeyDown += (sender, args) =>
{
if (args.KeyData == Keys.Enter)
{
try
{
args.SuppressKeyPress = true;
string code = CommandInput.Text.Trim('\r', '\n', ' ');
CommandHistory.Add(code);
index = CommandHistory.Count - 1;
inputWriter.WriteLine(code);
textBoxStreamWriter.WriteLine(code);
inputWriter.Flush();
}
catch (Exception ex)
{
CommandInput.Text = String.Empty;
}
}
if (args.KeyData == Keys.Up)
{
try
{
args.SuppressKeyPress = true;
if (indexInRange(index))
{
index--;
}
CommandInput.Text = CommandHistory[index];
}
catch (Exception ex)
{
CommandInput.Text = String.Empty;
}
}
if (args.KeyData == Keys.Down)
{
try
{
args.SuppressKeyPress = true;
if (indexInRange(index))
{
index++;
}
CommandInput.Text = CommandHistory[index];
}
catch (Exception ex)
{
CommandInput.Text = String.Empty;
}
}
};
}
/// <summary>
/// Extractes a <c>tar</c> archive to the specified directory.
/// </summary>
/// <param name="tarStream">The <i>.tar</i> to extract.</param>
/// <param name="outputDir">Output directory to write the files.</param>
public Task <IDictionary <string, IAsset> > ExtractTar(Stream tarStream, Func <TarEntryAsset, IDestination, CarrierManager, Task <IAsset> > tarEntryAction, IDestination destination, CarrierManager carrierManager)
{
Dictionary <string, IAsset> extractedAssets = new Dictionary <string, IAsset>();
string longLink = null;
while (true)
{
var buffer = new byte[100];
tarStream.Read(buffer, 0, 100);
var name = Encoding.ASCII.GetString(buffer);
if (name.IndexOf('\0') >= 0)
{
name = name.Substring(0, name.IndexOf('\0'));
}
if (String.IsNullOrWhiteSpace(name))
{
break;
}
buffer = new byte[24];
tarStream.Read(buffer, 0, 24);
buffer = new byte[12];
tarStream.Read(buffer, 0, 12);
string sizestr = Encoding.UTF8.GetString(buffer, 0, 12).Trim('\0').Trim();
int size = 0;
if (!string.IsNullOrEmpty(sizestr))
{
size = Convert.ToInt32(sizestr, 8);
}
buffer = new byte[376];
tarStream.Read(buffer, 0, 376);
if (longLink != null)
{
name = longLink;
longLink = null;
}
if (name.Contains("@LongLink"))
{
buffer = new byte[size];
tarStream.Read(buffer, 0, size);
longLink = Encoding.ASCII.GetString(buffer);
longLink = longLink.Substring(0, longLink.IndexOf('\0'));
size = 0;
}
if (size > 0)
{
BlockingStream blockingStream = new BlockingStream(Convert.ToUInt64(size));
TarEntryAsset tarEntryAsset = new TarEntryAsset(name, Convert.ToUInt64(size), blockingStream);
const int chunk = 81920;
long totalRead = 0;
var extractTask = Task.Factory.StartNew((state) =>
{
int chunkSize = chunk;
int read = 0;
if (size < chunk)
{
chunkSize = Convert.ToInt32(size);
}
var buffer = new byte[chunk];
do
{
try
{
read = tarStream.Read(buffer, 0, chunkSize);
blockingStream.Write(buffer, 0, read);
}
catch (Exception e)
{
logger.LogWarning(e.Message);
}
totalRead += read;
if (size < (totalRead + chunk))
{
chunkSize = Convert.ToInt32(size - totalRead);
}
buffer = new byte[chunk];
} while (totalRead < size);
blockingStream.Close();
}, null, TaskCreationOptions.AttachedToParent);
extractedAssets.Add(name, tarEntryAction(tarEntryAsset, destination, carrierManager).GetAwaiter().GetResult());
if (!extractTask.IsCompleted)
{
// Read until the end of the entry
blockingStream.CopyTo(Stream.Null);
}
}
var pos = tarStream.Position;
int offset = Convert.ToInt32(512 - (pos % 512));
if (offset == 512)
{
offset = 0;
}
if (offset > 0)
{
var offsetBuf = new byte[offset];
tarStream.Read(offsetBuf, 0, offset);
}
}
return(Task.FromResult <IDictionary <string, IAsset> >(extractedAssets));
}
protected override void Given()
{
_stream = new BlockingStream();
}
public TarEntryAsset(string name, ulong size, BlockingStream blockingStream)
{
this.name = name;
this.size = size;
this.blockingStream = blockingStream;
}
public async Task HttpConnectionRetriesAccessTokenProviderWhenAuthFailsServerSentEvents()
{
var testHttpHandler = new TestHttpMessageHandler(autoNegotiate: false);
var requestsExecuted = false;
var accessTokenCallCount = 0;
testHttpHandler.OnNegotiate((_, cancellationToken) =>
{
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationContent()));
});
var sendRequestExecuted = false;
var sendFinishedTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
testHttpHandler.OnSocketSend((_, _) =>
{
if (!sendRequestExecuted)
{
sendRequestExecuted = true;
return(ResponseUtils.CreateResponse(HttpStatusCode.Unauthorized));
}
sendFinishedTcs.SetResult();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK));
});
var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var stream = new BlockingStream(tcs);
testHttpHandler.OnRequest((request, next, token) =>
{
if (!requestsExecuted)
{
requestsExecuted = true;
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.Unauthorized)));
}
Assert.Equal("Bearer", request.Headers.Authorization.Scheme);
Assert.Equal(accessTokenCallCount.ToString(CultureInfo.InvariantCulture), request.Headers.Authorization.Parameter);
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(stream))));
});
Task <string> AccessTokenProvider()
{
accessTokenCallCount++;
return(Task.FromResult(accessTokenCallCount.ToString(CultureInfo.InvariantCulture)));
}
await WithConnectionAsync(
CreateConnection(testHttpHandler, transportType : HttpTransportType.ServerSentEvents, accessTokenProvider : AccessTokenProvider),
async (connection) =>
{
await connection.StartAsync().DefaultTimeout();
await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello world 1"));
await sendFinishedTcs.Task;
tcs.TrySetResult();
await connection.Transport.Input.ReadAllAsync();
});
// 1 negotiate + 1 retry stream request + 1 retry send
Assert.Equal(3, accessTokenCallCount);
}
