public OrderingDbDataSeeder(
ILogger <OrderingDbDataSeeder> logger,
IExecutionPolicy policy,
IDbDataProvider <IEnumerable <OrderStatus> > orderStatusDataProvider,
IDbDataProvider <IEnumerable <CardType> > cardTypesDataProvider)
{
_logger = logger;
_policy = policy;
_orderStatusDataProvider = orderStatusDataProvider;
_cardTypesDataProvider = cardTypesDataProvider;
}
protected override async Task <BoltResponse> RunQuery(BoltGraphClient graphClient, CypherQuery query,
IExecutionPolicy policy, string commandDescription)
{
var result = await BoltTransaction.DriverTransaction.RunAsync(query, graphClient).ConfigureAwait(false);
var resp = new BoltResponse {
StatementResult = result
};
return(resp);
}
private void CheckTransactionEnvironmentWithPolicy(IExecutionPolicy policy)
{
var inTransaction = InTransaction;
if (inTransaction && policy.TransactionExecutionPolicy == TransactionExecutionPolicy.Denied)
{
throw new InvalidOperationException("Cannot be done inside a transaction scope.");
}
if (!inTransaction && policy.TransactionExecutionPolicy == TransactionExecutionPolicy.Required)
{
throw new InvalidOperationException("Cannot be done outside a transaction scope.");
}
}
public static Uri AddPath(this Uri startUri, object startReference, IExecutionPolicy policy)
{
return(policy.AddPath(startUri, startReference));
}
public JobExecutor(IJobExecutionEngine defaultExecutionEngine)
{
_defaultPolicy = new ApplyToAllPolicy(defaultExecutionEngine);
}
public Task<HttpResponseMessage> EnqueueTask(string commandDescription, IGraphClient client, IExecutionPolicy policy, CypherQuery query)
{
// grab the endpoint in the same thread
var txBaseEndpoint = policy.BaseEndpoint;
var serializedQuery = policy.SerializeRequest(query);
var task = new Task<HttpResponseMessage>(() =>
Request.With(client.ExecutionConfiguration)
.Post(Endpoint ?? txBaseEndpoint)
.WithJsonContent(serializedQuery)
// HttpStatusCode.Created may be returned when emitting the first query on a transaction
.WithExpectedStatusCodes(HttpStatusCode.OK, HttpStatusCode.Created)
.ExecuteAsync(
commandDescription,
responseTask =>
{
// we need to check for errors returned by the transaction. The difference with a normal REST cypher
// query is that the errors are embedded within the result object, instead of having a 400 bad request
// status code.
var response = responseTask.Result;
policy.AfterExecution(TransactionHttpUtils.GetMetadataFromResponse(response), this);
return response;
})
.Result
);
_taskQueue.Add(task, _cancellationTokenSource.Token);
if (_consumer == null)
{
_consumer = () =>
{
while (true)
{
try
{
Task queuedTask;
if (!_taskQueue.TryTake(out queuedTask, 0, _cancellationTokenSource.Token))
{
// no items to consume
_consumer = null;
break;
}
queuedTask.RunSynchronously();
}
catch (InvalidOperationException)
{
// we are done, CompleteAdding has been called
break;
}
catch (OperationCanceledException)
{
// we are done, we were canceled
break;
}
}
};
_consumer.BeginInvoke(null, null);
}
return task;
}
public Task <BoltResponse> EnqueueTask(string commandDescription, BoltGraphClient graphClient, IExecutionPolicy policy, CypherQuery query)
{
var task = new Task <BoltResponse>(() =>
{
var result = BoltTransaction.DriverTransaction.Run(query, graphClient);
var resp = new BoltResponse {
StatementResult = result
};
return(resp);
}
);
taskQueue.Add(task, cancellationTokenSource.Token);
if (consumer == null)
{
consumer = () =>
{
while (true)
{
try
{
Task queuedTask;
if (!taskQueue.TryTake(out queuedTask, 0, cancellationTokenSource.Token))
{
// no items to consume
consumer = null;
break;
}
queuedTask.RunSynchronously();
}
catch (InvalidOperationException)
{
// we are done, CompleteAdding has been called
break;
}
catch (OperationCanceledException)
{
// we are done, we were canceled
break;
}
}
};
consumer.BeginInvoke(null, null);
}
return(task);
}
public Task <HttpResponseMessage> EnqueueTask(string commandDescription, IGraphClient client, IExecutionPolicy policy, CypherQuery query)
{
// grab the endpoint in the same thread
var txBaseEndpoint = policy.BaseEndpoint;
var serializedQuery = policy.SerializeRequest(query);
CustomHeaders = query.CustomHeaders;
var task = new Task <HttpResponseMessage>(() =>
Request.With(client.ExecutionConfiguration, query.CustomHeaders, query.MaxExecutionTime)
.Post(Endpoint ?? txBaseEndpoint)
.WithJsonContent(serializedQuery)
// HttpStatusCode.Created may be returned when emitting the first query on a transaction
.WithExpectedStatusCodes(HttpStatusCode.OK, HttpStatusCode.Created)
.ExecuteAsync(
commandDescription,
responseTask =>
{
// we need to check for errors returned by the transaction. The difference with a normal REST cypher
// query is that the errors are embedded within the result object, instead of having a 400 bad request
// status code.
var response = responseTask.Result;
policy.AfterExecution(TransactionHttpUtils.GetMetadataFromResponse(response), this);
return(response);
})
.Result
);
taskQueue.Add(task, cancellationTokenSource.Token);
if (consumer == null)
{
consumer = () =>
{
while (true)
{
try
{
Task queuedTask;
if (!taskQueue.TryTake(out queuedTask, 0, cancellationTokenSource.Token))
{
// no items to consume
consumer = null;
break;
}
queuedTask.RunSynchronously();
}
catch (InvalidOperationException)
{
// we are done, CompleteAdding has been called
break;
}
catch (OperationCanceledException)
{
// we are done, we were canceled
break;
}
}
};
consumer.BeginInvoke(null, null);
}
return(task);
}
public static Uri AddPath(this Uri startUri, object startReference, IExecutionPolicy policy)
{
return policy.AddPath(startUri, startReference);
}
public async Task <TResponse> EnqueueTask(string commandDescription, TClient graphClient, IExecutionPolicy policy, CypherQuery query)
{
var taskCompletion = new TaskCompletionSource <TResponse>();
try
{
var localPreviousTask = Interlocked.Exchange(ref previousTask, taskCompletion.Task);
if (localPreviousTask != null)
{
await localPreviousTask.ConfigureAwait(false);
}
var resp = await RunQuery(graphClient, query, policy, commandDescription).ConfigureAwait(false);
taskCompletion.SetResult(resp);
}
catch (OperationCanceledException)
{
taskCompletion.SetCanceled();
}
catch (Exception e)
{
taskCompletion.SetException(e);
}
return(await taskCompletion.Task.ConfigureAwait(false));
}
protected abstract Task <TResponse> RunQuery(TClient client, CypherQuery query, IExecutionPolicy policy, string commandDescription);
protected override Task <HttpResponseMessage> RunQuery(IGraphClient client, CypherQuery query, IExecutionPolicy policy, string commandDescription)
{
var txBaseEndpoint = policy.BaseEndpoint((policy.InTransaction) ? policy.Database : query.Database, !policy.InTransaction);
var serializedQuery = policy.SerializeRequest(query);
CustomHeaders = query.CustomHeaders;
return(Request.With(client.ExecutionConfiguration, query.CustomHeaders, query.MaxExecutionTime)
.Post(Endpoint ?? txBaseEndpoint)
.WithJsonContent(serializedQuery)
// HttpStatusCode.Created may be returned when emitting the first query on a transaction
.WithExpectedStatusCodes(HttpStatusCode.OK, HttpStatusCode.Created)
.ExecuteAsync(
commandDescription,
response =>
{
// we need to check for errors returned by the transaction. The difference with a normal REST cypher
// query is that the errors are embedded within the result object, instead of having a 400 bad request
// status code.
policy.AfterExecution(TransactionHttpUtils.GetMetadataFromResponse(response), this);
return response;
}));
}
