private static async Task CreateGateToRestaurant(IGremlinClient client, string gate, string restaurant, int distanceInMinutes)
{
string gremlinCode = $@"
g.V()
.has('id', '{gate}')
.addE('gateToRestaurant')
.property('distanceInMinutes', {distanceInMinutes})
.to(
g.V()
.has('id', '{restaurant}'))" ;
await client.SubmitAsync(gremlinCode);
Console.WriteLine($"Created edge: GateToRestaurant '{gate}' > '{restaurant}'");
gremlinCode = $@"
g.V()
.has('id', '{restaurant}')
.addE('restaurantToGate')
.property('distanceInMinutes', {distanceInMinutes})
.to(
g.V()
.has('id', '{gate}'))" ;
await client.SubmitAsync(gremlinCode);
Console.WriteLine($"Created edge: RestaurantToGate '{restaurant}' > '{gate}'");
}
private static async Task CreateTerminalToTerminal(IGremlinClient client, string terminal1, string terminal2, int distanceInMinutes)
{
string gremlinCode = $@"
g.V()
.has('id', '{terminal1}')
.addE('terminalToNextTerminal')
.property('distanceInMinutes', {distanceInMinutes})
.to(
g.V()
.has('id', '{terminal2}'))" ;
await client.SubmitAsync(gremlinCode);
Console.WriteLine($"Created edge: TerminalToNextTerminal '{terminal1}' > '{terminal2}'");
gremlinCode = $@"
g.V()
.has('id', '{terminal2}')
.addE('terminalToPrevTerminal')
.property('distanceInMinutes', {distanceInMinutes})
.to(
g.V()
.has('id', '{terminal1}'))" ;
await client.SubmitAsync(gremlinCode);
Console.WriteLine($"Created edge: TerminalToPrevTerminal '{terminal2}' > '{terminal1}'");
}
private static async Task CreateGateToGate(IGremlinClient client, string gate1, string gate2, int distanceInMinutes)
{
string gremlinCode = $@"
g.V()
.has('id', '{gate1}')
.addE('gateToNextGate')
.property('distanceInMinutes', {distanceInMinutes})
.to(
g.V()
.has('id', '{gate2}'))" ;
await client.SubmitAsync(gremlinCode);
Console.WriteLine($"Created edge: GateToNextGate '{gate1}' > '{gate2}'");
gremlinCode = $@"
g.V()
.has('id', '{gate2}')
.addE('gateToPrevGate')
.property('distanceInMinutes', {distanceInMinutes})
.to(
g.V()
.has('id', '{gate1}'))" ;
await client.SubmitAsync(gremlinCode);
Console.WriteLine($"Created edge: GateToPrevGate '{gate2}' > '{gate1}'");
}
/// <summary>
/// Submits the given gremlin query to the Cosmos Db instance and returns the results.
/// </summary>
/// <param name="gremlinQuery">The gremlin query.</param>
/// <returns>Returns the results</returns>
/// <exception cref="ArgumentNullException">gremlinQuery</exception>
public async Task <GraphResult> QueryAsync(string gremlinQuery)
{
if (gremlinQuery == null)
{
throw new ArgumentNullException(nameof(gremlinQuery));
}
var rawResultSet = await _gremlinClient.SubmitAsync <JToken>(gremlinQuery);
// Because SubmitAsync() above handles JToken differently from all other types, we
// have to do the normal processing (that it would do for any other type) here.
var resultList = new List <JToken>();
foreach (var rawJToken in rawResultSet)
{
var processedJToken = (JToken)this._graphSONReader.ToObject(rawJToken);
foreach (var d in processedJToken)
{
resultList.Add(d);
}
}
var newResultSet = new ResultSet <JToken>(resultList, rawResultSet.StatusAttributes);
return(new GraphResult(newResultSet));
}
/// <summary>
/// Submits a request message as an asynchronous operation where only a single result gets returned.
/// </summary>
/// <remarks>If multiple results are received from Gremlin Server, then only the first gets returned. Use <see cref="SubmitAsync{T}"/> instead when you expect a collection of results.</remarks>
/// <typeparam name="T">The type of the expected result.</typeparam>
/// <param name="gremlinClient">The <see cref="IGremlinClient"/> that submits the request.</param>
/// <param name="requestMessage">The <see cref="ScriptRequestMessage"/> to send.</param>
/// <returns>A single result received from the Gremlin Server.</returns>
/// <exception cref="Exceptions.ResponseException">Thrown when a response is received from Gremlin Server that indicates that an error occurred.</exception>
public static async Task <T> SubmitWithSingleResultAsync <T>(this IGremlinClient gremlinClient,
ScriptRequestMessage requestMessage)
{
var resultCollection = await gremlinClient.SubmitAsync <T>(requestMessage).ConfigureAwait(false);
return(resultCollection.FirstOrDefault());
}
private async Task <IEnumerable <Traverser> > SubmitBytecodeAsync(Guid requestid, Bytecode bytecode)
{
var requestMsg =
RequestMessage.Build(Tokens.OpsBytecode)
.Processor(Processor)
.OverrideRequestId(requestid)
.AddArgument(Tokens.ArgsGremlin, bytecode)
.AddArgument(Tokens.ArgsAliases, new Dictionary <string, string> {
{ "g", _traversalSource }
});
if (IsSessionBound)
{
requestMsg.AddArgument(Tokens.ArgsSession, _sessionId);
}
var optionsStrategyInst = bytecode.SourceInstructions.Find(
s => s.OperatorName == "withStrategies" && s.Arguments[0] is OptionsStrategy);
if (optionsStrategyInst != null)
{
OptionsStrategy optionsStrategy = optionsStrategyInst.Arguments[0];
foreach (KeyValuePair <string, dynamic> pair in optionsStrategy.Configuration)
{
if (_allowedKeys.Contains(pair.Key))
{
requestMsg.AddArgument(pair.Key, pair.Value);
}
}
}
return(await _client.SubmitAsync <Traverser>(requestMsg.Create()).ConfigureAwait(false));
}
/// <summary>
/// Submits the request to Cosmos DB.
/// </summary>
/// <param name="gremlinClient">The gremlin client.</param>
/// <param name="query">The query.</param>
/// <returns></returns>
private static Task <ResultSet <dynamic> > SubmitRequest(IGremlinClient gremlinClient,
KeyValuePair <string, string> query)
{
try
{
return(gremlinClient.SubmitAsync <dynamic>(query.Value));
}
catch (ResponseException e)
{
Console.WriteLine("\tRequest Error!");
// Print the Gremlin status code.
Console.WriteLine($"\tStatusCode: {e.StatusCode}");
// On error, ResponseException.StatusAttributes will include the common StatusAttributes for successful requests, as well as
// additional attributes for retry handling and diagnostics.
// These include:
// x-ms-retry-after-ms : The number of milliseconds to wait to retry the operation after an initial operation was throttled. This will be populated when
// : attribute 'x-ms-status-code' returns 429.
// x-ms-activity-id : Represents a unique identifier for the operation. Commonly used for troubleshooting purposes.
PrintStatusAttributes(e.StatusAttributes);
Console.WriteLine(
$"\t[\"x-ms-retry-after-ms\"] : {GetValueAsString(e.StatusAttributes, "x-ms-retry-after-ms")}");
Console.WriteLine(
$"\t[\"x-ms-activity-id\"] : {GetValueAsString(e.StatusAttributes, "x-ms-activity-id")}");
throw;
}
}
private static async Task ClearGraph(IGremlinClient client)
{
string gremlinCode = @"g.V().drop()";
await client.SubmitAsync(gremlinCode);
Console.WriteLine("Graph has been cleared");
}
/// <summary>
/// Submits a request message that consists of a script with bindings as an asynchronous operation where only a single result gets returned.
/// </summary>
/// <remarks>If multiple results are received from Gremlin Server, then only the first gets returned. Use <see cref="SubmitAsync{T}"/> instead when you expect a collection of results.</remarks>
/// <typeparam name="T">The type of the expected result.</typeparam>
/// <param name="gremlinClient">The <see cref="IGremlinClient"/> that submits the request.</param>
/// <param name="requestScript">The Gremlin request script to send.</param>
/// <param name="bindings">Bindings for parameters used in the requestScript.</param>
/// <returns>A single result received from the Gremlin Server.</returns>
/// <exception cref="Exceptions.ResponseException">Thrown when a response is received from Gremlin Server that indicates that an error occurred.</exception>
public static async Task <T> SubmitWithSingleResultAsync <T>(this IGremlinClient gremlinClient,
string requestScript,
Dictionary <string, object> bindings = null)
{
var resultCollection = await gremlinClient.SubmitAsync <T>(requestScript, bindings).ConfigureAwait(false);
return(resultCollection.FirstOrDefault());
}
public async Task <ResultSet <TResult> > SubmitAsync <TResult>(RequestMessage requestMessage)
{
var resultSet = await _baseClient.SubmitAsync <TResult>(requestMessage);
_observer(requestMessage, resultSet.StatusAttributes);
return(resultSet);
}
/// <summary>
/// Submits the given gremlin query to the Cosmos Db instance.
/// </summary>
/// <param name="gremlinQuery">The gremlin query.</param>
/// <returns>Returns the results</returns>
/// <exception cref="ArgumentNullException">gremlinQuery</exception>
public Task <IReadOnlyCollection <JToken> > SubmitAsync(string gremlinQuery)
{
if (gremlinQuery == null)
{
throw new ArgumentNullException(nameof(gremlinQuery));
}
return(_gremlinClient.SubmitAsync <JToken>(gremlinQuery));
}
private static async Task CreateGate(IGremlinClient client, string id)
{
string gremlinCode = $@"
g.addV('gate')
.property('id', '{id}')
.property('city', 'LA')" ;
await client.SubmitAsync(gremlinCode);
Console.WriteLine($"Created vertex: Gate '{id}'");
}
/// <summary>
/// Submits the given gremlin query to the Cosmos Db instance and returns the results.
/// </summary>
/// <param name="gremlinQuery">The gremlin query.</param>
/// <returns>Returns the results</returns>
/// <exception cref="ArgumentNullException">gremlinQuery</exception>
public async Task <GraphResult> QueryAsync(string gremlinQuery)
{
if (gremlinQuery == null)
{
throw new ArgumentNullException(nameof(gremlinQuery));
}
var resultSet = await _gremlinClient.SubmitAsync <JToken>(gremlinQuery);
return(new GraphResult(resultSet));
}
/// <summary>
/// Submits a request message that consists of a script with bindings as an asynchronous operation.
/// </summary>
/// <typeparam name="T">The type of the expected results.</typeparam>
/// <param name="gremlinClient">The <see cref="IGremlinClient"/> that submits the request.</param>
/// <param name="requestScript">The Gremlin request script to send.</param>
/// <param name="bindings">Bindings for parameters used in the requestScript.</param>
/// <returns>An enumerable collection of the data returned from the server.</returns>
/// <exception cref="Exceptions.ResponseException">Thrown when a response is received from Gremlin Server that indicates that an error occurred.</exception>
public static async Task <IEnumerable <T> > SubmitAsync <T>(this IGremlinClient gremlinClient, string requestScript,
Dictionary <string, object> bindings = null)
{
var requestMessage = new ScriptRequestMessage
{
Arguments = new ScriptRequestArguments {
GremlinScript = requestScript, Bindings = bindings
}
};
return(await gremlinClient.SubmitAsync <T>(requestMessage).ConfigureAwait(false));
}
public async Task <IEnumerable <Dictionary <string, object> > > ExecuteQuery(string query)
{
try
{
IGremlinClient graphclient = GremlinClient();
return(await graphclient.SubmitAsync <Dictionary <string, object> >(query));
}
catch (ResponseException e)
{
throw new GraphRepositoryException(e.Message, e);
}
}
private async Task ExecuteMultipleLongRunningRequestsInParallel(IGremlinClient gremlinClient, int nrRequests,
int requestRunningTimeInMs)
{
var tasks = new List <Task>(nrRequests);
for (var i = 0; i < nrRequests; i++)
{
tasks.Add(gremlinClient.SubmitAsync(_requestMessageProvider.GetSleepMessage(requestRunningTimeInMs)));
}
await Task.WhenAll(tasks);
}
private static async Task CreateRestaurant(IGremlinClient client, string id, decimal rating, decimal averagePrice)
{
string gremlinCode = $@"
g.addV('restaurant')
.property('id', '{id}')
.property('city', 'LA')
.property('rating', {rating})
.property('averagePrice', {averagePrice})" ;
await client.SubmitAsync(gremlinCode);
Console.WriteLine($"Created vertex: Restaurant '{id}'");
}
private async Task <IEnumerable <Traverser> > SubmitBytecodeAsync(Guid requestid, Bytecode bytecode)
{
var requestMsg =
RequestMessage.Build(Tokens.OpsBytecode)
.Processor(Tokens.ProcessorTraversal)
.OverrideRequestId(requestid)
.AddArgument(Tokens.ArgsGremlin, bytecode)
.AddArgument(Tokens.ArgsAliases, new Dictionary <string, string> {
{ "g", _traversalSource }
})
.Create();
return(await _client.SubmitAsync <Traverser>(requestMsg).ConfigureAwait(false));
}
/// <summary>
/// Submits a request message that consists of a script with bindings as an asynchronous operation.
/// </summary>
/// <typeparam name="T">The type of the expected results.</typeparam>
/// <param name="gremlinClient">The <see cref="IGremlinClient" /> that submits the request.</param>
/// <param name="requestScript">The Gremlin request script to send.</param>
/// <param name="bindings">Bindings for parameters used in the requestScript.</param>
/// <returns>A collection of the data returned from the server.</returns>
/// <exception cref="Exceptions.ResponseException">
/// Thrown when a response is received from Gremlin Server that indicates
/// that an error occurred.
/// </exception>
public static async Task <IReadOnlyCollection <T> > SubmitAsync <T>(this IGremlinClient gremlinClient,
string requestScript,
Dictionary <string, object> bindings = null)
{
var msgBuilder = RequestMessage.Build(Tokens.OpsEval).AddArgument(Tokens.ArgsGremlin, requestScript);
if (bindings != null)
{
msgBuilder.AddArgument(Tokens.ArgsBindings, bindings);
}
var msg = msgBuilder.Create();
return(await gremlinClient.SubmitAsync <T>(msg).ConfigureAwait(false));
}
/// <summary>
/// Submits the given gremlin query to the Cosmos Db instance and returns the results.
/// </summary>
/// <param name="gremlinQuery">The gremlin query.</param>
/// <returns>Returns the results</returns>
/// <param name="caller">Method name or property name of the caller.</param>
/// <param name="filePath">Full path of the source file that contains the caller. The full path is the path at compile time.</param>
/// <param name="sourceLineNumber">Line number in the source file from which the method is called.</param>
/// <exception cref="ArgumentNullException">gremlinQuery</exception>
public async Task <GraphResult> QueryAsync(
string gremlinQuery,
[CallerMemberName] string caller = "",
[CallerFilePath] string filePath = "",
[CallerLineNumber] int sourceLineNumber = 0)
{
if (gremlinQuery == null)
{
throw new ArgumentNullException(nameof(gremlinQuery));
}
var resultSet = await _gremlinClient.SubmitAsync <JToken>(gremlinQuery);
return(new GraphResult(resultSet));
}
private static async Task RunAirportQuery(IGremlinClient client, string gremlinCode)
{
IReadOnlyCollection <dynamic> results = await client.SubmitAsync <dynamic>(gremlinCode);
int count = 0;
foreach (dynamic result in results)
{
count++;
dynamic jResult = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(result));
JArray steps = (JArray)jResult["objects"];
int userStep = 0;
int totalDistanceInMinutes = 0;
int i = 0;
Console.WriteLine();
Console.WriteLine($"Choice # {count}");
foreach (JToken step in steps)
{
i++;
if (step["type"].Value <string>() == "vertex")
{
userStep++;
string userStepCaption = (userStep == 1 ? "Start at" : (i == steps.Count ? "Arrive at" : "Go to"));
string vertexInfo = $"{userStep}. {userStepCaption} {step["label"]} = {step["id"]}";
if (step["label"].Value <string>() == "restaurant")
{
vertexInfo += $", rating = {step["properties"]["rating"][0]["value"]}";
vertexInfo += $", avg price = {step["properties"]["averagePrice"][0]["value"]}";
}
vertexInfo += $" ({totalDistanceInMinutes} min)";
Console.WriteLine(vertexInfo);
}
else
{
int distanceInMinutes = step["properties"]["distanceInMinutes"].Value <int>();
totalDistanceInMinutes += distanceInMinutes;
string edgeInfo = $" ({step["label"]} = {distanceInMinutes} min)";
Console.WriteLine(edgeInfo);
}
}
}
}
/// <summary>
/// Submits a request message as an asynchronous operation without returning the result received from the Gremlin
/// Server.
/// </summary>
/// <param name="gremlinClient">The <see cref="IGremlinClient" /> that submits the request.</param>
/// <param name="requestMessage">The <see cref="RequestMessage" /> to send.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <exception cref="Exceptions.ResponseException">
/// Thrown when a response is received from Gremlin Server that indicates
/// that an error occurred.
/// </exception>
public static async Task <GremlinResponse> SubmitAsync(this IGremlinClient gremlinClient, RequestMessage requestMessage)
{
return(await gremlinClient.SubmitAsync <object>(requestMessage).ConfigureAwait(false));
}
public async Task <ResultSet <TResult> > SubmitAsync <TResult>(RequestMessage requestMessage)
{
return(await _baseClient.SubmitAsync <TResult>(await _transformation(requestMessage)));
}
/// <summary>
/// Submits a request message as an asynchronous operation without returning the result received from the Gremlin Server.
/// </summary>
/// <param name="gremlinClient">The <see cref="IGremlinClient"/> that submits the request.</param>
/// <param name="requestMessage">The <see cref="ScriptRequestMessage"/> to send.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <exception cref="Exceptions.ResponseException">Thrown when a response is received from Gremlin Server that indicates that an error occurred.</exception>
public static async Task SubmitAsync(this IGremlinClient gremlinClient, ScriptRequestMessage requestMessage)
{
await gremlinClient.SubmitAsync <object>(requestMessage).ConfigureAwait(false);
}
/// <summary>
/// Submits a request message that consists of a script with bindings as an asynchronous operation without returning the result received from the Gremlin Server.
/// </summary>
/// <param name="gremlinClient">The <see cref="IGremlinClient"/> that submits the request.</param>
/// <param name="requestScript">The Gremlin request script to send.</param>
/// <param name="bindings">Bindings for parameters used in the requestScript.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <exception cref="Exceptions.ResponseException">Thrown when a response is received from Gremlin Server that indicates that an error occurred.</exception>
public static async Task SubmitAsync(this IGremlinClient gremlinClient, string requestScript,
Dictionary <string, object> bindings = null)
{
await gremlinClient.SubmitAsync <object>(requestScript, bindings).ConfigureAwait(false);
}
private IEnumerable <string> RetrieveKeys()
{
return(_gremlinClient.SubmitAsync <string>(SideEffectKeysMessage()).Result);
}