public async Task <ExecutionResult> Post([FromBody] GraphQLRequest request)
{
var queryNumber = Interlocked.Increment(ref _queryNumber);
Console.WriteLine();
Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId.ToString().PadLeft(2, ' ')} - Running query {queryNumber}...");
var sw = Stopwatch.StartNew();
var result = await DataLoaderContext.Run(loadCtx => _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = request.Query;
_.UserContext = new GraphQLUserContext(loadCtx);
}));
sw.Stop();
var msg = result.Errors != null
? $"Error executing query {queryNumber}: {result.Errors.Aggregate("", (s, e) => s + Environment.NewLine + e.ToString())}"
: $"Executed query {queryNumber} ({sw.ElapsedMilliseconds}ms)";
Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId.ToString().PadLeft(2, ' ')} - {msg}");
return(result);
}
public async Task FlowsLikeSyncContext()
{
var checkpoints = 0;
await DataLoaderContext.Run(async _ =>
{
var ctx = DataLoaderContext.Current;
// Should flow over `Task.Yield`
await Task.Yield();
DataLoaderContext.Current.ShouldBe(ctx);
checkpoints++; // 1
// Should flow over `Task.Delay`
await Task.Delay(100);
DataLoaderContext.Current.ShouldBe(ctx);
checkpoints++; // 2
// Shouldn't flow into Task.Run
await Task.Run(() => DataLoaderContext.Current.ShouldBe(null));
DataLoaderContext.Current.ShouldBe(ctx);
checkpoints++; // 3
// Shouldn't flow into a new Thread
var thread = new Thread(() => { DataLoaderContext.Current.ShouldBe(null); });
thread.Start();
thread.Join();
DataLoaderContext.Current.ShouldBe(ctx);
checkpoints++; // 4
});
checkpoints.ShouldBe(4);
}
private async Task ExecuteAsync(HttpContext context, ISchema schema)
{
string body;
using (var streamReader = new StreamReader(context.Request.Body))
{
body = await streamReader.ReadToEndAsync().ConfigureAwait(true);
}
var request = JsonConvert.DeserializeObject <GraphQLRequest>(body);
var validationRules = new List <IValidationRule>()
{
new RequiresAuthValidationRule()
};
var result = await DataLoaderContext.Run(ctx => _executer.ExecuteAsync(_ =>
{
_.OperationName = request.OperationName;
_.Schema = schema;
_.Query = request.Query;
_.Inputs = request.Variables.ToInputs();
_.ValidationRules = validationRules.Concat(DocumentValidator.CoreRules());
_.UserContext = new GraphQLUserContext(ctx, context.User);
}));
await WriteResponseAsync(context, result);
}
public async Task DataLoaderContext_Run_AllowsParallelContexts()
{
const int n = 2;
var barrier = new Barrier(n);
var contexts = new ConcurrentBag <DataLoaderContext>();
Func <Task> action = async() =>
{
await DataLoaderContext.Run(ctx =>
{
barrier.SignalAndWait();
ctx.ShouldBe(DataLoaderContext.Current);
contexts.Add(DataLoaderContext.Current);
return(Task.FromResult(1));
});
};
var t1 = Task.Run(action);
var t2 = Task.Run(action);
await Task.WhenAll(t1, t2);
contexts.Count.ShouldBe(n);
contexts.ShouldBeUnique();
}
public async Task TriggersConsecutiveLoads()
{
var loadCount = 0;
await DataLoaderContext.Run(async ctx =>
{
var loader = ctx.GetOrCreateLoader <int, int>(
"somekey",
async ids =>
{
await Task.Delay(100);
loadCount++;
return(ids.ToDictionary(id => id));
});
var one = await loader.LoadAsync(1);
var two = await loader.LoadAsync(2);
var three = await loader.LoadAsync(3);
var fourfivesix = await Task.WhenAll(
loader.LoadAsync(4),
loader.LoadAsync(5),
loader.LoadAsync(6)
);
});
loadCount.ShouldBe(4);
}
public async Task DataLoaderContext_Run_FlowsCurrentContext()
{
var checkpoints = 0;
await DataLoaderContext.Run(async() =>
{
var ctx = DataLoaderContext.Current;
// Test with `Task.Yield`.
await Task.Yield();
DataLoaderContext.Current.ShouldBe(ctx);
checkpoints++; // 1
// Test with `Task.Delay`.
await Task.Delay(100);
DataLoaderContext.Current.ShouldBe(ctx);
checkpoints++; // 2
// Test with `Task.Run`.
await Task.Run(() => DataLoaderContext.Current.ShouldBe(ctx));
checkpoints++; // 3
// Test with `Thread`.
var thread = new Thread(() =>
{
DataLoaderContext.Current.ShouldBe(ctx);
checkpoints++; // 4
});
thread.Start();
thread.Join();
});
checkpoints.ShouldBe(4);
}
public async Task SetsCurrent()
{
await DataLoaderContext.Run(() =>
{
DataLoaderContext.Current.ShouldNotBeNull();
return(Task.CompletedTask);
});
}
public void DataLoader_ReflectsCurrentContext()
{
var loader = new DataLoader <object, object>(_ => null);
loader.Context.ShouldBeNull();
DataLoaderContext.Run(ctx => { loader.Context.ShouldBe(ctx); return(Task.CompletedTask); });
loader.Context.ShouldBeNull();
}
public Task <ExecutionResult> DataLoader()
{
_dataLoaderOptions.UserContext = _userContext;
return(DataLoaderContext.Run(loadCtx =>
{
_userContext.LoadContext = loadCtx;
return _executer.ExecuteAsync(_dataLoaderOptions);
}));
}
public async Task DataLoaderContext_Run_UnsetsCurrent()
{
var task = DataLoaderContext.Run(() => {});
DataLoaderContext.Current.ShouldBeNull();
await task;
DataLoaderContext.Current.ShouldBeNull();
}
public async Task DataLoaderContext_Run_SetsCurrentContext()
{
DataLoaderContext.Current.ShouldBeNull();
await DataLoaderContext.Run(ctx =>
{
DataLoaderContext.Current.ShouldBe(ctx);
DataLoaderContext.Current.ShouldNotBeNull();
return(Task.CompletedTask);
});
DataLoaderContext.Current.ShouldBeNull();
}
public async Task <ExecutionResult> Post([FromBody] GraphQLRequest request)
{
var watch = Stopwatch.StartNew();
Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} - Executing GraphQL query");
var result = await DataLoaderContext.Run(loadCtx =>
_executer.ExecuteAsync(_schema, null, request.Query, null, userContext: new GraphQLUserContext {
LoadContext = loadCtx
}));
Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} - Finished query ({watch.ElapsedMilliseconds}ms)");
return(result);
}
public Task <ExecutionResult> Execute(GraphQLQuery query)
{
return(DataLoaderContext.Run(loadCtx =>
{
serviceProvider.GetRequiredService <DataLoaderContextStore>().LoadContext = loadCtx;
var executionOptions = new ExecutionOptions
{
Schema = schema,
Query = query.Query,
Inputs = GetInputs(query.Variables),
UserContext = serviceProvider,
};
return documentExecuter.ExecuteAsync(executionOptions);
}));
}
public async Task CanBeNested()
{
await DataLoaderContext.Run(async outerCtx =>
{
await DataLoaderContext.Run(async innerCtx =>
{
innerCtx.ShouldNotBe(outerCtx);
innerCtx.ShouldBe(DataLoaderContext.Current);
await Task.Yield();
innerCtx.ShouldBe(DataLoaderContext.Current);
});
DataLoaderContext.Current.ShouldBe(outerCtx);
});
}
public async Task DataLoaderContext_Run_CanBeNested()
{
await DataLoaderContext.Run(async outerCtx =>
{
DataLoaderContext.Current.ShouldBe(outerCtx);
var task = DataLoaderContext.Run(innerCtx =>
{
innerCtx.ShouldNotBe(outerCtx);
innerCtx.ShouldBe(DataLoaderContext.Current);
});
DataLoaderContext.Current.ShouldBe(outerCtx);
await task;
DataLoaderContext.Current.ShouldBe(outerCtx);
});
}
public void CanBeCancelled()
{
var cts = new CancellationTokenSource();
cts.CancelAfter(50);
var didRun = false;
var task = DataLoaderContext.Run(async token =>
{
didRun = true;
await Task.Delay(300, token);
}, cts.Token);
didRun.ShouldBeTrue();
task.ShouldThrow <TaskCanceledException>();
}
public void RespectsAlreadyCancelledToken()
{
var cts = new CancellationTokenSource();
cts.Cancel();
var didRun = false;
var task = DataLoaderContext.Run(token =>
{
didRun = true;
return(null);
}, cts.Token);
didRun.ShouldBe(false);
task.IsCanceled.ShouldBe(true);
}
public async Task DataLoader_WithoutBoundContext_ReflectsCurrentContext()
{
var loader = new DataLoader <object, object>(_ => null);
loader.Context.ShouldBeNull();
var task = DataLoaderContext.Run(async ctx =>
{
loader.Context.ShouldBe(ctx);
await Task.Delay(200);
loader.Context.ShouldBe(ctx);
});
loader.Context.ShouldBeNull();
await task;
loader.Context.ShouldBeNull();
}
public async Task <ExecutionResult> Post([FromBody] GraphQLRequest request)
{
var queryNumber = Interlocked.Increment(ref _queryNumber);
Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId.ToString().PadLeft(2, ' ')} - Running query {queryNumber}...");
var sw = Stopwatch.StartNew();
var result = await DataLoaderContext.Run(ctx => _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = request.Query;
_.UserContext = new GraphQLUserContext(ctx);
}));
sw.Stop();
Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId.ToString().PadLeft(2, ' ')} - Executed query {queryNumber} ({sw.ElapsedMilliseconds}ms)");
return(result);
}
public async Task DataLoaderContext_Run_CanBeNested()
{
await DataLoaderContext.Run(async outerCtx =>
{
DataLoaderContext.Current.ShouldBe(outerCtx);
await DataLoaderContext.Run(innerCtx =>
{
innerCtx.ShouldNotBe(outerCtx);
innerCtx.ShouldBe(DataLoaderContext.Current);
return(Task.CompletedTask);
});
DataLoaderContext.Current.ShouldBe(outerCtx);
});
DataLoaderContext.Current.ShouldBeNull();
}
public void DataLoaderContext_Run_TriggersConsecutiveLoads()
{
var loadCount = 0;
var loader = new DataLoader <int, int>(async ids =>
{
await Task.Delay(150);
loadCount++;
return(ids.ToLookup(id => id));
});
var task = DataLoaderContext.Run(async() =>
{
var one = await loader.LoadAsync(1);
var two = await loader.LoadAsync(2);
var three = await loader.LoadAsync(3);
var fourfivesix = await Task.WhenAll(
loader.LoadAsync(4),
loader.LoadAsync(5),
loader.LoadAsync(6)
);
var t7 = loader.LoadAsync(7);
var t8 = loader.LoadAsync(8);
var t9 = loader.LoadAsync(9);
Thread.Sleep(200);
var ten = await loader.LoadAsync(10);
t7.IsCompleted.ShouldBeTrue();
t8.IsCompleted.ShouldBeTrue();
t9.IsCompleted.ShouldBeTrue();
return(true);
});
Should.CompleteIn(task, TimeSpan.FromSeconds(10));
loadCount.ShouldBe(5);
}
public async Task HandlesUnrelatedAwaits()
{
var loadCount = 0;
await DataLoaderContext.Run(async ctx =>
{
var loader = ctx.GetOrCreateLoader <int, int>(
"somekey",
async ids =>
{
await Task.Delay(50);
loadCount++;
return(ids.ToDictionary(id => id));
});
var one = await loader.LoadAsync(1);
await Task.Delay(50);
var two = await loader.LoadAsync(2);
});
loadCount.ShouldBe(2);
}
public void DataLoaderContext_Run_AllowsParallelContexts()
{
const int n = 2;
var barrier = new Barrier(n);
var contexts = new ConcurrentBag <DataLoaderContext>();
Action <int> action = _ =>
{
DataLoaderContext.Run(ctx =>
{
barrier.SignalAndWait();
ctx.ShouldBe(DataLoaderContext.Current);
contexts.Add(DataLoaderContext.Current);
return(Task.FromResult(1));
}).Wait();
};
var result = Parallel.For(0, n, action);
result.IsCompleted.ShouldBeTrue();
contexts.Count.ShouldBe(n);
contexts.ShouldBeUnique();
}
public async Task DataLoaderContext_Run_FlowsCurrentContext()
{
await DataLoaderContext.Run(async() =>
{
var ctx = DataLoaderContext.Current;
var threadId = Thread.CurrentThread.ManagedThreadId;
// Test with `Task.Yield`.
await Task.Yield();
DataLoaderContext.Current.ShouldBe(ctx);
// Test with `Task.Delay`.
await Task.Delay(100);
DataLoaderContext.Current.ShouldBe(ctx);
// Test with `Task.Run`.
await Task.Run(() => DataLoaderContext.Current.ShouldBe(ctx));
// Test with `Thread`.
var thread = new Thread(() => DataLoaderContext.Current.ShouldBe(ctx));
thread.Start();
thread.Join();
});
}
public async Task UnsetsCurrent()
{
await DataLoaderContext.Run(() => Task.CompletedTask);
DataLoaderContext.Current.ShouldBeNull();
}
public async Task DataLoaderContext_Run_SetsCurrent()
{
await DataLoaderContext.Run(() => DataLoaderContext.Current.ShouldNotBeNull());
await DataLoaderContext.Run(ctx => DataLoaderContext.Current.ShouldBe(ctx));
}