Пример #1
0
        private GremlinServer InitiateGraph()
        {
            string containerLink = "/dbs/" + database + "/colls/" + container;
            var    gremlinServer = new GremlinServer(hostname: host, port: port, enableSsl: true, username: containerLink, password: key);

            return(gremlinServer);
        }
        static void Main(string[] args)
        {
            var authKey = "YOURKEYHERE";

            var gremlinServer = new GremlinServer(
                "YOURURLHERE.gremlin.cosmosdb.azure.com",
                443,
                enableSsl: true,
                username: $"/dbs/cloudguru/colls/people",
                password: authKey);

            using (var gremlinClient = new GremlinClient(gremlinServer, new GraphSON2Reader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType))
            {
                var query = "g.V()";
                var task  = gremlinClient.SubmitAsync <dynamic>(query);
                task.Wait();

                foreach (var result in task.Result)
                {
                    string output = JsonConvert.SerializeObject(result);
                    Console.WriteLine(String.Format("\tResult:\n\t{0}", output));
                }
            }

            Console.ReadKey();
        }
Пример #3
0
        private void ExecuteQuery(GremlinServer gremlinServer, string query)
        {
            using (var client = new GremlinClient(gremlinServer, new GraphSON3Reader(), new GraphSON3Writer(),
                                                  GremlinClient.GraphSON2MimeType))
            {
                // Create async task to execute the Gremlin query.
                var resultSet = SubmitRequest(client, query).Result;
                if (resultSet.Count > 0)
                {
                    Console.WriteLine("\tResult:");
                    foreach (var result in resultSet)
                    {
                        // The vertex results are formed as Dictionaries with a nested dictionary for their properties
                        string output = JsonConvert.SerializeObject(result);
                        Console.WriteLine($"\t{output}");
                    }
                    Console.WriteLine();
                }

                // Print the status attributes for the result set.
                // This includes the following:
                //  x-ms-status-code            : This is the sub-status code which is specific to Cosmos DB.
                //  x-ms-total-request-charge   : The total request units charged for processing a request.
                //  x-ms-total-server-time-ms   : The total time executing processing the request on the server.
                //PrintStatusAttributes(resultSet.StatusAttributes);
                Console.WriteLine();
            }
        }
Пример #4
0
        public async Task ShouldUseSpecifiedEvaluationTimeout()
        {
            var gremlinServer = new GremlinServer(TestHost, TestPort);

            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                const long timeOutInMs         = 1L;
                const int  scriptSleepTimeInMs = 5000;
                var        sleepScript         = _requestMessageProvider.GetSleepGremlinScript(scriptSleepTimeInMs);

                var requestMsg =
                    RequestMessage.Build(Tokens.OpsEval)
                    .AddArgument(Tokens.ArgsGremlin, sleepScript)
                    .AddArgument(Tokens.ArgsEvalTimeout, timeOutInMs)
                    .Create();
                var evaluationStopWatch = new Stopwatch();
                evaluationStopWatch.Start();

                var thrownException =
                    await Assert.ThrowsAsync <ResponseException>(() => gremlinClient.SubmitAsync(requestMsg));

                evaluationStopWatch.Stop();
                Assert.Contains("ServerTimeout", thrownException.Message);
                Assert.Contains(timeOutInMs.ToString(), thrownException.Message);
                Assert.True(evaluationStopWatch.ElapsedMilliseconds < scriptSleepTimeInMs);
            }
        }
Пример #5
0
        public async Task ResponseBatchesShouldBeReassembled()
        {
            const int batchSize      = 2;
            var       expectedResult = new List <int> {
                1, 2, 3, 4, 5
            };
            var requestScript = $"{nameof(expectedResult)}";
            var bindings      = new Dictionary <string, object> {
                { nameof(expectedResult), expectedResult }
            };
            var requestMessage = new ScriptRequestMessage
            {
                Arguments =
                    new ScriptRequestArguments
                {
                    BatchSize     = batchSize,
                    GremlinScript = requestScript,
                    Bindings      = bindings
                }
            };
            var gremlinServer = new GremlinServer(TestHost, TestPort);

            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                var response = await gremlinClient.SubmitAsync <int>(requestMessage);

                Assert.Equal(expectedResult, response);
            }
        }
Пример #6
0
 public GremlinNetLanguageConnector(string gremlinHostname, string username, string password, int port = 8182,
                                    bool enableSsl = true, ILogging logger = null) : base(logger)
 {
     _key    = $"{gremlinHostname.ToLower()}.{username.ToLower()}.{port}";
     _server = new GremlinServer(gremlinHostname, port, enableSsl, username, password);
     InitializeClient();
 }
        public void Configure(IWebJobsBuilder builder)
        {
            builder.AddSwashBuckle(Assembly.GetExecutingAssembly());

            builder.AddAzureFunctionsToken(new TokenAzureB2COptions()
            {
                AzureB2CSingingKeyUri = new Uri(Env.GetEnvironmentVariable("AuthSigningKey")),
                Audience = Env.GetEnvironmentVariable("AuthAudience"),
                Issuer   = Env.GetEnvironmentVariable("AuthIssuer")
            });

            builder.Services.AddHttpClient();

            builder.Services.AddSingleton((s) =>
            {
                GremlinServer gremlinServer = new GremlinServer(Env.GetEnvironmentVariable("CosmosGremlinHost"),
                                                                int.Parse(Env.GetEnvironmentVariable("CosmosPort")),
                                                                enableSsl: true,
                                                                username: "******" + Env.GetEnvironmentVariable("CosmosDatabaseName") + "/colls/" + Env.GetEnvironmentVariable("CosmosGraphName"),
                                                                password: Env.GetEnvironmentVariable("CosmosKey"));

                IGremlinClient gremlinClient = new GremlinClient(gremlinServer, new GraphSON2Reader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType);

                return(gremlinClient);
            });

            builder.Services.AddSingleton((s) =>
            {
                IB2CGraphClient b2CGraphClient = new B2CGraphClient();

                return(b2CGraphClient);
            });
        }
            public WebSocketGremlinQueryExecutor(
                GremlinServer gremlinServer,
                IGremlinClientFactory clientFactory,
                string alias = "g")
            {
                _alias     = alias;
                _aliasArgs = new Dictionary <string, string> {
                    { "g", _alias }
                };

                _lazyGremlinClient = new SmarterLazy <IGremlinClient>(
                    async logger =>
                {
                    try
                    {
                        return(await Task.Run(() => clientFactory.Create(
                                                  gremlinServer,
                                                  JsonNetMessageSerializer.GraphSON3,
                                                  new ConnectionPoolSettings(),
                                                  _ => { })));
                    }
                    catch (Exception ex)
                    {
                        logger.LogError(ex, $"Failure creating an instance of {nameof(IGremlinClient)}.");

                        throw;
                    }
                });
            }
Пример #9
0
        public async Task ShouldReturnResultWithoutDeserializingItForJsonElementType()
        {
            var gremlinServer = new GremlinServer(TestHost, TestPort);

            using var gremlinClient = new GremlinClient(gremlinServer);
            const string gremlinScript = "'someString'";

            var response = await gremlinClient.SubmitWithSingleResultAsync <JsonElement>(gremlinScript);

            //Expected:

            /* {
             *    "@type": "g:List",
             *    "@value": [
             *      "someString"
             *    ]
             *  }*/

            Assert.IsType <JsonElement>(response);
            Assert.Equal("g:List", response.GetProperty("@type").GetString());

            var valueProperty = response.GetProperty("@value");

            Assert.NotNull(valueProperty);
            Assert.Equal(1, valueProperty.GetArrayLength());
            Assert.Equal("someString", (valueProperty[0].GetString()));
        }
        private static async Task InsertInGraph(IEnumerable <string> tags, dynamic doc, KeyVault kvService, TraceWriter log)
        {
            var hostname = await GetSecret("gremlin_endpoint", kvService);

            var port = await GetSecret("gremlin_port", kvService);

            var database   = "pets";
            var collection = "checks";
            var authKey    = Environment.GetEnvironmentVariable("gremlin_key");
            var portToUse  = 443;

            portToUse = int.TryParse(port, out portToUse) ? portToUse : 443;

            var gremlinServer = new GremlinServer(hostname, portToUse, enableSsl: true,
                                                  username: "******" + database + "/colls/" + collection,
                                                  password: authKey);
            var gremlinClient = new GremlinClient(gremlinServer, new GraphSON2Reader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType);

            foreach (var tag in tags)
            {
                log.Info("--- --- Checking vertex for tag " + tag);
                await TryAddTag(gremlinClient, tag, log);
            }

            var queries = AddPetToGraphQueries(doc, tags);

            log.Info("--- --- Adding vertex for pet checkin ");
            foreach (string query in queries)
            {
                await gremlinClient.SubmitAsync <dynamic>(query);
            }
        }
Пример #11
0
        public async Task ShouldSaveVariableBetweenRequestsInSession()
        {
            var gremlinServer = new GremlinServer(TestHost, TestPort);
            var sessionId     = Guid.NewGuid().ToString();

            using (var gremlinClient = new GremlinClient(gremlinServer, sessionId: sessionId))
            {
                await gremlinClient.SubmitAsync <int>("x = 1");

                var expectedResult = new List <int> {
                    3
                };
                var response = await gremlinClient.SubmitAsync <int>("x + 2");

                Assert.Equal(expectedResult, response);
            }

            using (var gremlinClient = new GremlinClient(gremlinServer, sessionId: sessionId))
            {
                try
                {
                    await gremlinClient.SubmitAsync <int>("x");

                    Assert.True(false, "The 'x' variable should not exist after session close");
                }
                catch (Exception)
                {
                    // do nothing
                }
            }
        }
Пример #12
0
        private static async Task ExecutePartitionedGraphQueriesAsync()
        {
            try
            {
                GremlinServer server = new GremlinServer(
                    ConfigurationManager.AppSettings["GremlinServerEndPoint"],
                    int.Parse(ConfigurationManager.AppSettings["GremlinServerPort"]),
                    true,
                    "/dbs/" + ConfigurationManager.AppSettings["Database"] + "/colls/" + ConfigurationManager.AppSettings["Collection"],
                    ConfigurationManager.AppSettings["PrimaryKey"]);

                using (GremlinClient gClient = new GremlinClient(server))
                {
                    Console.WriteLine("---------------------------------------------------------------------");
                    foreach (KeyValuePair <string, string> gremlinQuery in Program.gremlinQueries)
                    {
                        Console.WriteLine("Executing: " + gremlinQuery.Key);
                        Console.WriteLine("---------------------------------------------------------------------");
                        await ExecuteGremlinServerQueryAsync(gClient, gremlinQuery.Value);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
Пример #13
0
        public IActionResult Gremlin(string query)
        {
            try
            {
                // var hostname = _configuration.GetSection("AzureCosmos").GetSection("HostName").Value;
                // var port = int.Parse(_configuration.GetSection("AzureCosmos").GetSection("Port").Value);
                // var authKey = _configuration.GetSection("AzureCosmos").GetSection("AuthKey").Value;
                // var database = _configuration.GetSection("AzureCosmos").GetSection("Database").Value;
                // var graph = _configuration.GetSection("AzureCosmos").GetSection("Graph").Value;

                // var gremlinServer = new GremlinServer(hostname, port, enableSsl: true, username: "******" + database + "/colls/" + graph, password: authKey);
                // var gremlinClient = new GremlinClient(gremlinServer, new GraphSON2Reader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType);

                var endpoint      = _configuration.GetSection("AWS").GetSection("NeptuneEndpoint").Value;
                var gremlinServer = new GremlinServer(endpoint, 8182, enableSsl: true);
                var gremlinClient = new GremlinClient(gremlinServer);


                var users = gremlinClient.SubmitAsync <dynamic>(query).Result;

                //return Json(users);
                string res = JsonConvert.SerializeObject(users);
                string pre = JsonFormatter.Format(res);
                return(Content(pre, "application/json"));
            }
            catch (Exception ex)
            {
                string res = JsonConvert.SerializeObject(new { message = ex.Message, stackTrace = ex.StackTrace });
                string pre = JsonFormatter.Format(res);
                return(Content(pre, "application/json"));
            }
        }
Пример #14
0
        public async Task ConnectingViaDriversTest()
        {
// tag::connectingViaDrivers[]
// script
            var gremlinServer = new GremlinServer("localhost", 8182);

            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                var bindings = new Dictionary <string, object>
                {
                    { "name", "marko" }
                };

                var response =
                    await gremlinClient.SubmitWithSingleResultAsync <object>("g.V().has('person','name',name).out('knows')",
                                                                             bindings);
            }

// bytecode
            using (var gremlinClient = new GremlinClient(new GremlinServer("localhost", 8182)))
            {
                var g    = Traversal().WithRemote(new DriverRemoteConnection(gremlinClient));
                var list = g.V().Has("person", "name", "marko").Out("knows").ToList();
            }
// end::connectingViaDrivers[]
        }
Пример #15
0
        public GremlinClientFactory(ICosmosGraphDbSettings settings)
        {
            Guard.ArgumentNotNull(settings, nameof(settings));
            Guard.IsNullOrWhiteSpace(settings.EndPointUrl, nameof(settings.EndPointUrl));
            Guard.IsNullOrWhiteSpace(settings.ApiKey, nameof(settings.ApiKey));
            Guard.IsNullOrWhiteSpace(settings.ContainerPath, nameof(settings.ContainerPath));

            _server = new GremlinServer(settings.EndPointUrl,
                                        settings.Port,
                                        true,
                                        settings.ContainerPath,
                                        settings.ApiKey);

            _connectionPoolSettings = new ConnectionPoolSettings()
            {
                MaxInProcessPerConnection = settings.MaxInProcessPerConnection ?? 32,
                PoolSize              = settings.PoolSize ?? 4,
                ReconnectionAttempts  = settings.ReconnectionAttempts ?? 4,
                ReconnectionBaseDelay = TimeSpan.FromMilliseconds(settings.ReconnectionBaseDelay ?? 500)
            };

            _webSocketConfiguration =
                new Action <ClientWebSocketOptions>(options =>
            {
                options.KeepAliveInterval = TimeSpan.FromSeconds(settings.KeepAliveInterval ?? 10);
            });
        }
        public async Task <dynamic> Get(string query, string collectionId)
        {
            List <dynamic> results = new List <dynamic>();
            GremlinServer  server  = GetServer(collectionId);

            using (GremlinClient gremlinClient = new GremlinClient(server, new GraphSON2Reader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType))
            {
                List <Task> tasks   = new List <Task>();
                string[]    queries = query.Split(';');
                //split query on ; to allow for multiple queries
                foreach (string q in queries)
                {
                    if (!string.IsNullOrEmpty(q))
                    {
                        string singleQuery = q.Trim();

                        await ExecuteQuery(gremlinClient, singleQuery)
                        .ContinueWith(
                            (task) =>
                        {
                            results.Add(new { queryText = singleQuery, queryResult = task.Result });
                        }
                            );
                    }
                }
            }
            return(results);
        }
Пример #17
0
 public GremlinExecutor(CosmosDbConnection config, IConsole console)
 {
     _console      = console;
     _server       = GremlinExecutor.GetGremlinServer(config);
     _partitionKey = config.PartitionKey;
     _client       = new GremlinClient(_server, new GraphSON2Reader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType);
 }
Пример #18
0
        public async Task ShouldReturnResultWithoutDeserializingItForJTokenType()
        {
            var gremlinServer = new GremlinServer(TestHost, TestPort);

            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                var gremlinScript = "'someString'";

                var response = await gremlinClient.SubmitWithSingleResultAsync <JToken>(gremlinScript);

                //Expected:

                /* {
                 * "@type": "g:List",
                 * "@value": [
                 *  "someString"
                 * ]
                 * }*/

                Assert.IsType <JObject>(response);
                Assert.Equal("g:List", response["@type"]);

                var jArray = response["@value"] as JArray;
                Assert.NotNull(jArray);
                Assert.Equal(1, jArray.Count);
                Assert.Equal("someString", (jArray[0] as JValue)?.Value);
            }
        }
        // Starts a console application that executes every Gremlin query in the gremlinQueries dictionary.
        static void Main(string[] args)
        {
            var gremlinServer = new GremlinServer(hostname, port, enableSsl: true,
                                                  username: "******" + database + "/colls/" + collection,
                                                  password: authKey);

            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                foreach (var query in gremlinQueries)
                {
                    Console.WriteLine(String.Format("Running this query: {0}: {1}", query.Key, query.Value));

                    // Create async task to execute the Gremlin query.
                    var task = gremlinClient.SubmitAsync <dynamic>(query.Value);
                    task.Wait();

                    foreach (var result in task.Result)
                    {
                        // The vertex results are formed as Dictionaries with a nested dictionary for their properties
                        string output = JsonConvert.SerializeObject(result);
                        Console.WriteLine(String.Format("\tResult:\n\t{0}", output));
                    }
                    Console.WriteLine();
                }
            }

            // Exit program
            Console.WriteLine("Done. Press any key to exit...");
            Console.ReadLine();
        }
Пример #20
0
        /// <summary>
        /// Initializes a new instance of the <see cref="GraphClient"/> class.
        /// </summary>
        /// <param name="gremlinHostname">The hostname.</param>
        /// <param name="databaseName">Name of the database (case-sensitive).</param>
        /// <param name="graphName">Name of the graph.</param>
        /// <param name="accessKey">The access key.</param>
        /// <param name="port">The port number.</param>
        /// <param name="useSSL"><c>True</c> to use SSL.</param>
        public GraphClient(string gremlinHostname, string databaseName, string graphName, string accessKey,
                           int port = 443, bool useSSL = true)
        {
            var server = new GremlinServer(gremlinHostname, port, useSSL, $"/dbs/{databaseName}/colls/{graphName}", accessKey);

            _gremlinClient = new GremlinClient(server, new GraphSONJTokenReader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType);
        }
        public GremlinHealthCheck(GremlinOptions options)
        {
            _ = options ?? throw new ArgumentNullException(nameof(options));
            _ = options.Hostname ?? throw new ArgumentNullException(nameof(options.Hostname));

            _server = new GremlinServer(options.Hostname, options.Port, options.EnableSsl);
        }
Пример #22
0
        public async Task ShouldReassembleResponseBatches()
        {
            const int batchSize      = 2;
            var       expectedResult = new List <int> {
                1, 2, 3, 4, 5
            };
            var requestScript = $"{nameof(expectedResult)}";
            var bindings      = new Dictionary <string, object> {
                { nameof(expectedResult), expectedResult }
            };
            var requestMessage =
                RequestMessage.Build(Tokens.OpsEval)
                .AddArgument(Tokens.ArgsBatchSize, batchSize)
                .AddArgument(Tokens.ArgsGremlin, requestScript)
                .AddArgument(Tokens.ArgsBindings, bindings)
                .Create();
            var gremlinServer = new GremlinServer(TestHost, TestPort);

            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                var response = await gremlinClient.SubmitAsync <int>(requestMessage);

                Assert.Equal(expectedResult, response);
            }
        }
Пример #23
0
        private static void ProcessGremlinCommandsFile(string infile)
        {
            List <string> commands      = ReadLines(infile);
            GremlinServer gremlinServer = CreateGremlinServer();

            using (var gremlinClient = new GremlinClient(
                       gremlinServer,
                       new GraphSON2Reader(),
                       new GraphSON2Writer(),
                       GremlinClient.GraphSON2MimeType))
            {
                Console.WriteLine($"gremlinClient: {gremlinClient}");

                for (int i = 0; i < commands.Count(); i++)
                {
                    string command = commands.ElementAt(i);
                    Console.WriteLine("---");
                    Console.WriteLine($"{i} Command: {command}");

                    var resultSet = SubmitRequest(gremlinClient, command).Result;
                    if (resultSet.Count > 0)
                    {
                        Console.WriteLine("Result:");
                        foreach (var result in resultSet)
                        {
                            string output = JsonConvert.SerializeObject(result);
                            Console.WriteLine($"{output}");
                        }
                        Console.WriteLine();
                    }
                    PrintStatusAttributes(resultSet.StatusAttributes);
                    Console.WriteLine();
                }
            }
        }
Пример #24
0
        public ProfileContext()
        {
            ConnectionPoolSettings connectionPoolSettings = new ConnectionPoolSettings()
            {
                MaxInProcessPerConnection = 10,
                PoolSize              = 30,
                ReconnectionAttempts  = 3,
                ReconnectionBaseDelay = TimeSpan.FromMilliseconds(500)
            };

            var webSocketConfiguration =
                new Action <ClientWebSocketOptions>(options =>
            {
                options.KeepAliveInterval = TimeSpan.FromSeconds(10);
            });

            var gremlinServer = new GremlinServer(_host, 443, enableSsl: true,
                                                  username: ContainerLink,
                                                  password: _primaryKey);

            _client = new GremlinClient(
                gremlinServer,
                new GraphSON2Reader(),
                new GraphSON2Writer(),
                GremlinClient.GraphSON2MimeType,
                connectionPoolSettings,
                webSocketConfiguration);
        }
Пример #25
0
        public static void CreateClient()
        {
            var gremlinServer = new GremlinServer(hostname, port, enableSsl: true,
                                                  username: "******" + database + "/colls/" + collection,
                                                  password: authKey);

            gremlinClient = new GremlinClient(gremlinServer, new GraphSON2Reader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType);
        }
Пример #26
0
        public void SubmittingScriptsWithAuthenticationTest()
        {
// tag::submittingScriptsWithAuthentication[]
            var username      = "******";
            var password      = "******";
            var gremlinServer = new GremlinServer("localhost", 8182, true, username, password);
// end::submittingScriptsWithAuthentication[]
        }
Пример #27
0
 public ConnectionFactory(GremlinServer gremlinServer, IMessageSerializer messageSerializer,
                          WebSocketSettings webSocketSettings, string sessionId)
 {
     _gremlinServer     = gremlinServer;
     _messageSerializer = messageSerializer;
     _sessionId         = sessionId;
     _webSocketSettings = webSocketSettings;
 }
Пример #28
0
        public void ShouldBuildCorrectUri(string host, int port)
        {
            var gremlinServer = new GremlinServer(host, port);

            var uri = gremlinServer.Uri;

            Assert.Equal($"ws://{host}:{port}/gremlin", uri.AbsoluteUri);
        }
Пример #29
0
        public GraphClientWrapper()
        {
            var gremlinServer = new GremlinServer(EndpointUrl,
                                                  Port, true, "/dbs/" + Database + "/colls/" + Collection, PrimaryKey);

            _gremlinClient = new GremlinClient(gremlinServer, new GraphSON2Reader(),
                                               new GraphSON2Writer(), GremlinClient.GraphSON2MimeType);
        }
Пример #30
0
        protected override void BeginProcessing()
        {
            WriteVerbose("Connecting GremlinClient");

            var server = new GremlinServer(Hostname, Port, EnableSsl, Credential.UserName, Credential.GetNetworkCredential().Password);

            Client = new GremlinClient(server, new GraphSON2Reader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType);
        }