internal static GroovyGremlinQuery?TryToGroovy(this ISerializedGremlinQuery serializedGremlinQuery)
{
return(serializedGremlinQuery switch
{
GroovyGremlinQuery serializedQuery => serializedQuery,
BytecodeGremlinQuery byteCodeQuery => byteCodeQuery.ToGroovy(),
_ => default
});
public IAsyncEnumerable <object> Execute(ISerializedGremlinQuery serializedQuery, IGremlinQueryEnvironment environment)
{
return(new object[]
{
JsonConvert.DeserializeObject <JToken>(
_json,
new JsonSerializerSettings()
{
DateParseHandling = DateParseHandling.None
}) !
}.ToAsyncEnumerable());
public IAsyncEnumerable <object> Execute(ISerializedGremlinQuery serializedQuery, IGremlinQueryEnvironment environment)
{
return(AsyncEnumerable.Create(Core));
async IAsyncEnumerator <object> Core(CancellationToken ct)
{
var hasSeenFirst = false;
for (var i = 0; i < int.MaxValue; i++)
{
await using (var enumerator = _baseExecutor.Execute(serializedQuery, environment).GetAsyncEnumerator(ct))
{
while (true)
{
try
{
if (!await enumerator.MoveNextAsync())
{
yield break;
}
hasSeenFirst = true;
}
catch (ResponseException ex)
{
if (hasSeenFirst)
{
throw;
}
if (!_shouldRetry(i, ex))
{
throw;
}
//This is done not to end up with the same seeds if many of these
//requests fail roughly at the same time
await Task.Delay((_rnd ??= new Random((int)(DateTime.Now.Ticks & int.MaxValue) ^ Thread.CurrentThread.ManagedThreadId)).Next(i + 2) * 16, ct);
var newSerializedQuery = serializedQuery.WithNewId();
environment.Logger.LogInformation($"Retrying serialized query {serializedQuery.Id} with new {nameof(ISerializedGremlinQuery.Id)} {newSerializedQuery.Id}.");
serializedQuery = newSerializedQuery;
break;
}
yield return(enumerator.Current);
}
}
}
}
}
public IAsyncEnumerable <object> Execute(ISerializedGremlinQuery serializedQuery, IGremlinQueryEnvironment environment)
{
return(AsyncEnumerable.Create(Core));
async IAsyncEnumerator <object> Core(CancellationToken ct)
{
var maybeResults = default(ResultSet <JToken>?);
var clientTask = _lazyGremlinClient.GetValue(environment.Logger);
if (!Guid.TryParse(serializedQuery.Id, out var requestId))
{
requestId = Guid.NewGuid();
environment.Logger.LogInformation($"Mapping query id {serializedQuery.Id} to request id {requestId}.");
}
var requestMessage = serializedQuery switch
{
GroovyGremlinQuery groovyScript => RequestMessage
.Build(Tokens.OpsEval)
.AddArgument(Tokens.ArgsGremlin, groovyScript.Script)
.AddArgument(Tokens.ArgsAliases, _aliasArgs)
.AddArgument(Tokens.ArgsBindings, groovyScript.Bindings)
.OverrideRequestId(requestId)
.Create(),
BytecodeGremlinQuery bytecodeQuery => RequestMessage
.Build(Tokens.OpsBytecode)
.Processor(Tokens.ProcessorTraversal)
.AddArgument(Tokens.ArgsGremlin, bytecodeQuery.Bytecode)
.AddArgument(Tokens.ArgsAliases, _aliasArgs)
.OverrideRequestId(requestId)
.Create(),
_ => throw new ArgumentException($"Cannot handle serialized query of type {serializedQuery.GetType()}.")
};
maybeResults = await(await clientTask)
.SubmitAsync <JToken>(requestMessage)
.ConfigureAwait(false);
if (maybeResults is { } results)
{
foreach (var obj in results)
{
yield return(obj);
}
}
}
}
}
public IAsyncEnumerable <object> Execute(ISerializedGremlinQuery serializedQuery, IGremlinQueryEnvironment environment)
{
return(AsyncEnumerable.Create(Core));
async IAsyncEnumerator <object> Core(CancellationToken ct)
{
IAsyncEnumerator <object> enumerator;
try
{
enumerator = _baseExecutor
.Execute(serializedQuery, environment)
.GetAsyncEnumerator(ct);
}
catch (Exception ex)
{
throw _exceptionTransformation(ex);
}
await using (enumerator)
{
while (true)
{
try
{
if (!await enumerator.MoveNextAsync())
{
yield break;
}
}
catch (Exception ex)
{
throw _exceptionTransformation(ex);
}
yield return(enumerator.Current);
}
}
}
}
public IAsyncEnumerable <object> Execute(ISerializedGremlinQuery serializedQuery, IGremlinQueryEnvironment environment)
{
return(AsyncEnumerable.Create(Core));
async IAsyncEnumerator <object> Core(CancellationToken ct)
{
await using (var enumerator = _executor.Execute(serializedQuery, environment).GetAsyncEnumerator(ct))
{
try
{
var moveNext = enumerator.MoveNextAsync();
var logger = Loggers.GetValue(
environment,
static environment => GetLoggingFunction(environment));
logger(serializedQuery, serializedQuery.Id);
if (!await moveNext)
{
yield break;
}
}
catch (Exception ex)
{
environment.Logger.LogError($"Error executing Gremlin query with id {serializedQuery.Id}: {ex}");
throw;
}
do
{
yield return(enumerator.Current);
} while (await enumerator.MoveNextAsync());
}
}
}
public static GroovyGremlinQuery ToGroovy(this ISerializedGremlinQuery serializedGremlinQuery)
{
return(serializedGremlinQuery.TryToGroovy() ?? throw new NotSupportedException($"Can't convert serialized query of type {serializedGremlinQuery.GetType()} to {nameof(GroovyGremlinQuery)}."));
}
public string?TryToString(ISerializedGremlinQuery serializedQuery, IGremlinQueryEnvironment environment)
{
return(_overridingDebugger.TryToString(serializedQuery, environment) ?? _baseDebugger.TryToString(serializedQuery, environment));
}
public IAsyncEnumerable <object> Execute(ISerializedGremlinQuery serializedQuery, IGremlinQueryEnvironment environment)
{
return(_transformation(_baseExecutor.Execute(serializedQuery, environment)));
}
public IAsyncEnumerable <object> Execute(ISerializedGremlinQuery serializedQuery, IGremlinQueryEnvironment environment)
{
return(_factory(serializedQuery, environment));
}