public void Send_ExecutesDelegate_NoThrow()
{
var syncContext = new SingleThreadedSynchronizationContext();
int?executingThread = null;
syncContext.Send(s => executingThread = Environment.CurrentManagedThreadId, null);
Assert.Equal(Environment.CurrentManagedThreadId, executingThread);
}
public void Send_ExecutesDelegate_Throws()
{
var syncContext = new SingleThreadedSynchronizationContext();
Exception expected = new InvalidOperationException();
TargetInvocationException?actual = Assert.Throws <TargetInvocationException>(() => syncContext.Send(s => throw expected, null));
Assert.Same(expected, actual.InnerException);
}
public override ScenarioInstance <SyncContextConfiguration> CreateInstance()
{
var syncContext = new SingleThreadedSynchronizationContext();
var instance = new ScenarioInstance <SyncContextConfiguration>(new SyncContextConfiguration());
instance.Disposing += (s, e) => syncContext.Dispose();
return(instance);
}
public void TesSend()
{
var sendComplete = false;
var sync = new SingleThreadedSynchronizationContext();
sync.Send(state =>
{
sendComplete = true;
}, null);
Assert.IsTrue(sendComplete);
}
public void TestPost()
{
var postComplete = false;
var sync = new SingleThreadedSynchronizationContext();
var latch = new ManualResetEvent(false);
sync.Post(state =>
{
postComplete = true;
latch.Set();
}, null);
Assert.IsFalse(postComplete);
latch.WaitOne();
Assert.IsTrue(postComplete);
}
public void Send_OnDifferentThread_ExecutesDelegateAndWaits_Throws()
{
int originalThreadId = Environment.CurrentManagedThreadId;
var syncContext = new SingleThreadedSynchronizationContext();
var frame = new SingleThreadedSynchronizationContext.Frame();
var task = Task.Run(delegate
{
try
{
var expectedException = new InvalidOperationException();
var actualException = Assert.Throws <TargetInvocationException>(() => syncContext.Send(s => throw expectedException, null));
Assert.Same(expectedException, actualException.InnerException);
}
finally
{
frame.Continue = false;
}
});
public void AddHttpClient_GetAwaiterAndResult_InSingleThreadedSynchronizationContext_ShouldNotHangs()
{
// Arrange
using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
var token = cts.Token;
token.Register(() => throw new OperationCanceledException(token));
var serviceCollection = new ServiceCollection();
serviceCollection.AddHttpClient("example.com")
.ConfigurePrimaryHttpMessageHandler(() =>
{
var mockHandler = new Mock <HttpMessageHandler>();
mockHandler
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
.Returns(async() =>
{
await Task.Delay(1).ConfigureAwait(false);
return(new HttpResponseMessage(HttpStatusCode.OK));
});
return(mockHandler.Object);
});
var services = serviceCollection.BuildServiceProvider();
var factory = services.GetRequiredService <IHttpClientFactory>();
var client = factory.CreateClient("example.com");
var hangs = true;
SingleThreadedSynchronizationContext.Run(() =>
{
// Act
client.GetAsync("http://example.com", token).GetAwaiter().GetResult();
hangs = false;
});
// Assert
Assert.False(hangs);
}
}
public static void Run(Action action)
{
var previous = Current;
var context = new SingleThreadedSynchronizationContext();
SetSynchronizationContext(context);
try
{
action();
while (context._queue.Count > 0)
{
var item = context._queue.Dequeue();
item.Callback(item.State);
}
}
finally
{
SetSynchronizationContext(previous);
}
}
public void Send_OnDifferentThread_ExecutesDelegateAndWaits()
{
int originalThreadId = Environment.CurrentManagedThreadId;
var syncContext = new SingleThreadedSynchronizationContext();
var frame = new SingleThreadedSynchronizationContext.Frame();
var task = Task.Run(delegate
{
try
{
int?observedThreadId = null;
syncContext.Send(s => observedThreadId = Environment.CurrentManagedThreadId, null);
Assert.Equal(originalThreadId, observedThreadId);
}
finally
{
frame.Continue = false;
}
});
syncContext.PushFrame(frame);
task.GetAwaiter().GetResult();
}
public ReentrantSemaphoreTestBase(ITestOutputHelper logger)
: base(logger)
{
this.Dispatcher = SingleThreadedSynchronizationContext.New();
}
internal async Task GeneratedMethods_WithOutParams_DoNotCauseDeadlocks(string fixture)
{
var traceWriter = new TestTraceWriter(TraceLevel.Verbose);
ScriptHostConfiguration config = new ScriptHostConfiguration()
{
RootScriptPath = @"TestScripts\FunctionGeneration",
TraceWriter = traceWriter
};
string secretsPath = Path.Combine(Path.GetTempPath(), @"FunctionTests\Secrets");
ISecretsRepository repository = new FileSystemSecretsRepository(secretsPath);
WebHostSettings webHostSettings = new WebHostSettings();
webHostSettings.SecretsPath = secretsPath;
var secretManager = new SecretManager(SettingsManager, repository, NullTraceWriter.Instance);
using (var manager = new WebScriptHostManager(config, new TestSecretManagerFactory(secretManager), SettingsManager, webHostSettings))
{
Thread runLoopThread = new Thread(_ =>
{
manager.RunAndBlock(CancellationToken.None);
});
runLoopThread.IsBackground = true;
runLoopThread.Start();
await TestHelpers.Await(() =>
{
return(manager.State == ScriptHostState.Running);
});
var request = new HttpRequestMessage(HttpMethod.Get, string.Format("http://localhost/api/httptrigger-{0}", fixture));
FunctionDescriptor function = manager.GetHttpFunctionOrNull(request);
SynchronizationContext currentContext = SynchronizationContext.Current;
var resetEvent = new ManualResetEventSlim();
try
{
var requestThread = new Thread(() =>
{
var context = new SingleThreadedSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(context);
manager.HandleRequestAsync(function, request, CancellationToken.None)
.ContinueWith(task => resetEvent.Set());
Thread.Sleep(500);
context.Run();
});
requestThread.IsBackground = true;
requestThread.Start();
bool threadSignaled = resetEvent.Wait(TimeSpan.FromSeconds(10));
requestThread.Abort();
Assert.True(threadSignaled, "Thread execution did not complete");
}
finally
{
SynchronizationContext.SetSynchronizationContext(currentContext);
manager.Stop();
}
}
}
public void CreateCopy_ReturnsInstanceOfCorrectType()
{
var syncContext = new SingleThreadedSynchronizationContext();
Assert.IsType <SingleThreadedSynchronizationContext>(syncContext.CreateCopy());
}
public static void SendAsyncHttpClientRequests(HttpClient client, bool tracingDisabled, string url, string requestContent)
{
void Invoke()
{
// Insert a call to the Tracer.Instance to include an AssemblyRef to Datadog.Trace assembly in the final executable
Console.WriteLine($"[HttpClient] sending requests to {url}");
if (tracingDisabled)
{
client.DefaultRequestHeaders.Add(HttpHeaderNames.TracingEnabled, "false");
}
using (Tracer.Instance.StartActive("HttpClientRequestAsync"))
{
using (Tracer.Instance.StartActive("DeleteAsync"))
{
client.DeleteAsync(url).Wait();
Console.WriteLine("Received response for client.DeleteAsync(String)");
client.DeleteAsync(new Uri(url)).Wait();
Console.WriteLine("Received response for client.DeleteAsync(Uri)");
client.DeleteAsync(url, CancellationToken.None).Wait();
Console.WriteLine("Received response for client.DeleteAsync(String, CancellationToken)");
client.DeleteAsync(new Uri(url), CancellationToken.None).Wait();
Console.WriteLine("Received response for client.DeleteAsync(Uri, CancellationToken)");
}
using (Tracer.Instance.StartActive("GetAsync"))
{
client.GetAsync(url).Wait();
Console.WriteLine("Received response for client.GetAsync(String)");
client.GetAsync(new Uri(url)).Wait();
Console.WriteLine("Received response for client.GetAsync(Uri)");
client.GetAsync(url, CancellationToken.None).Wait();
Console.WriteLine("Received response for client.GetAsync(String, CancellationToken)");
client.GetAsync(new Uri(url), CancellationToken.None).Wait();
Console.WriteLine("Received response for client.GetAsync(Uri, CancellationToken)");
client.GetAsync(url, HttpCompletionOption.ResponseContentRead).Wait();
Console.WriteLine("Received response for client.GetAsync(String, HttpCompletionOption)");
client.GetAsync(new Uri(url), HttpCompletionOption.ResponseContentRead).Wait();
Console.WriteLine("Received response for client.GetAsync(Uri, HttpCompletionOption)");
client.GetAsync(url, HttpCompletionOption.ResponseContentRead, CancellationToken.None).Wait();
Console.WriteLine("Received response for client.GetAsync(String, HttpCompletionOption, CancellationToken)");
client.GetAsync(new Uri(url), HttpCompletionOption.ResponseContentRead, CancellationToken.None).Wait();
Console.WriteLine("Received response for client.GetAsync(Uri, HttpCompletionOption, CancellationToken)");
}
using (Tracer.Instance.StartActive("GetByteArrayAsync"))
{
client.GetByteArrayAsync(url).Wait();
Console.WriteLine("Received response for client.GetByteArrayAsync(String)");
client.GetByteArrayAsync(new Uri(url)).Wait();
Console.WriteLine("Received response for client.GetByteArrayAsync(Uri)");
}
using (Tracer.Instance.StartActive("GetStreamAsync"))
{
using Stream stream1 = client.GetStreamAsync(url).Result;
Console.WriteLine("Received response for client.GetStreamAsync(String)");
using Stream stream2 = client.GetStreamAsync(new Uri(url)).Result;
Console.WriteLine("Received response for client.GetStreamAsync(Uri)");
}
using (Tracer.Instance.StartActive("GetStringAsync"))
{
client.GetStringAsync(url).Wait();
Console.WriteLine("Received response for client.GetStringAsync(String)");
client.GetStringAsync(new Uri(url)).Wait();
Console.WriteLine("Received response for client.GetStringAsync(Uri)");
}
#if NETCOREAPP
using (Tracer.Instance.StartActive("PatchAsync"))
{
client.PatchAsync(url, new StringContent(requestContent, Utf8)).Wait();
Console.WriteLine("Received response for client.PatchAsync(String, HttpContent)");
client.PatchAsync(new Uri(url), new StringContent(requestContent, Utf8)).Wait();
Console.WriteLine("Received response for client.PatchAsync(Uri, HttpContent)");
client.PatchAsync(url, new StringContent(requestContent, Utf8), CancellationToken.None).Wait();
Console.WriteLine("Received response for client.PatchAsync(String, HttpContent, CancellationToken)");
client.PatchAsync(new Uri(url), new StringContent(requestContent, Utf8), CancellationToken.None).Wait();
Console.WriteLine("Received response for client.PatchAsync(Uri, HttpContent, CancellationToken)");
}
#endif
using (Tracer.Instance.StartActive("PostAsync"))
{
client.PostAsync(url, new StringContent(requestContent, Utf8)).Wait();
Console.WriteLine("Received response for client.PostAsync(String, HttpContent)");
client.PostAsync(new Uri(url), new StringContent(requestContent, Utf8)).Wait();
Console.WriteLine("Received response for client.PostAsync(Uri, HttpContent)");
client.PostAsync(url, new StringContent(requestContent, Utf8), CancellationToken.None).Wait();
Console.WriteLine("Received response for client.PostAsync(String, HttpContent, CancellationToken)");
client.PostAsync(new Uri(url), new StringContent(requestContent, Utf8), CancellationToken.None).Wait();
Console.WriteLine("Received response for client.PostAsync(Uri, HttpContent, CancellationToken)");
}
using (Tracer.Instance.StartActive("PutAsync"))
{
client.PutAsync(url, new StringContent(requestContent, Utf8)).Wait();
Console.WriteLine("Received response for client.PutAsync(String, HttpContent)");
client.PutAsync(new Uri(url), new StringContent(requestContent, Utf8)).Wait();
Console.WriteLine("Received response for client.PutAsync(Uri, HttpContent)");
client.PutAsync(url, new StringContent(requestContent, Utf8), CancellationToken.None).Wait();
Console.WriteLine("Received response for client.PutAsync(String, HttpContent, CancellationToken)");
client.PutAsync(new Uri(url), new StringContent(requestContent, Utf8), CancellationToken.None).Wait();
Console.WriteLine("Received response for client.PutAsync(Uri, HttpContent, CancellationToken)");
}
using (Tracer.Instance.StartActive("SendAsync"))
{
client.SendAsync(new HttpRequestMessage(HttpMethod.Get, url)).Wait();
Console.WriteLine("Received response for client.SendAsync(HttpRequestMessage)");
client.SendAsync(new HttpRequestMessage(HttpMethod.Get, url), CancellationToken.None).Wait();
Console.WriteLine("Received response for client.SendAsync(HttpRequestMessage, CancellationToken)");
client.SendAsync(new HttpRequestMessage(HttpMethod.Get, url), HttpCompletionOption.ResponseContentRead).Wait();
Console.WriteLine("Received response for client.SendAsync(HttpRequestMessage, HttpCompletionOption)");
client.SendAsync(new HttpRequestMessage(HttpMethod.Get, url), HttpCompletionOption.ResponseContentRead, CancellationToken.None).Wait();
Console.WriteLine("Received response for client.SendAsync(HttpRequestMessage, HttpCompletionOption, CancellationToken)");
}
using (Tracer.Instance.StartActive("ErrorSpanBelow"))
{
client.GetAsync($"{url}HttpErrorCode").Wait();
Console.WriteLine("Received response for client.GetAsync Error Span");
}
}
}
// Wait for the tasks in a single threaded synchronization context, to detect potential deadlocks
var synchronizationContext = new SingleThreadedSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(synchronizationContext);
synchronizationContext.Send(_ => Invoke(), null);
SynchronizationContext.SetSynchronizationContext(null);
}
