public async Task ShouldFailWithAuthenticationError() { Exception exception = null; using (var driver = GraphDatabase.Driver(RoutingServer, AuthTokens.Basic("fake", "fake"))) { var session = driver.AsyncSession(); try { exception = await Record.ExceptionAsync(() => session.RunAsync("RETURN 1")); } finally { await session.CloseAsync(); } } exception.Should().BeOfType <AuthenticationException>(); exception.Message.Should().Be("The client is unauthorized due to authentication failure."); }
public virtual IDriver GetDriver() { if (Instance == null) { Instance = new DriverDecorator(GraphDatabase.Driver(Uri, AuthToken, Config), Manager); } else { try { Instance.Session().Dispose(); } catch { Instance = new DriverDecorator(GraphDatabase.Driver(Uri, AuthToken, Config), Manager); } } return(Instance); }
public void ShouldNotPackBytes() { // Given byte[] byteArray = PackStreamBitConverter.GetBytes("hello, world"); // When using (var driver = GraphDatabase.Driver("bolt://127.0.0.1:7687", AuthToken)) using (var session = driver.Session()) { var exception = Record.Exception(() => session.Run("CREATE (a {value:{value}})", new Dictionary <string, object> { { "value", byteArray } })); // Then exception.Should().BeOfType <ProtocolException>(); exception.Message.Should().Be("Cannot understand values with type System.Byte[]"); } }
private (IDriver, ConcurrentQueue <IPooledConnection>) SetupMonitoredDriver() { var configBuilder = Config.Builder .WithMetricsEnabled(true) .WithConnectionAcquisitionTimeout(TimeSpan.FromMinutes(5)) .WithConnectionTimeout(Config.InfiniteInterval) .WithMaxConnectionPoolSize(100) .WithLogger(new StressTestLogger(_output, LoggingEnabled)); _configure?.Invoke(configBuilder); var config = configBuilder.Build(); var connectionSettings = new ConnectionSettings(_databaseUri, _authToken, config); var bufferSettings = new BufferSettings(config); var connectionFactory = new MonitoredPooledConnectionFactory( new PooledConnectionFactory(connectionSettings, bufferSettings, config.Logger)); return((Internal.Driver)GraphDatabase.CreateDriver(_databaseUri, config, connectionFactory), connectionFactory.Connections); }
public async Task ShouldThrowServiceUnavailableExceptionIfNoServer() { using (var driver = GraphDatabase.Driver(WrongServer, AuthTokens.Basic("fake", "fake"))) { var session = driver.AsyncSession(); try { var exc = await Record.ExceptionAsync(() => session.RunAsync("RETURN 1")); exc.Should().BeOfType <ServiceUnavailableException>().Which .Message.Should() .Be( "Failed to connect to any routing server. Please make sure that the cluster is up and can be accessed by the driver and retry."); } finally { await session.CloseAsync(); } } }
protected async Task AssertRestoredDatabase(string boltEndpoint) { using (var driver = GraphDatabase.Driver(boltEndpoint)) { var session = driver.AsyncSession(); try { var result = await session.RunAsync("MATCH (p:Person) RETURN p.FirstName as FirstName, p.LastName AS LastName"); var record = await result.SingleAsync(); Assert.AreEqual("Foo", record["FirstName"].As <string>()); Assert.AreEqual("Bar", record["LastName"].As <string>()); } finally { await session.CloseAsync(); } } }
public void ShouldAllowMoreTxAfterSessionReset() { using (var driver = GraphDatabase.Driver(_serverEndPoint, _authToken)) { using (var session = driver.Session()) { using (var tx = session.BeginTransaction()) { tx.Run("Return 1"); tx.Success(); } session.Reset(); using (var tx = session.BeginTransaction()) { tx.Run("RETURN 2"); tx.Success(); } } } }
public void ShouldFailIfCommitFailsDueToBrokenConnection(string boltVersion) { using (BoltStubServer.Start($"{boltVersion}/connection_error_on_commit", 9001)) { using (var driver = GraphDatabase.Driver("bolt://127.0.0.1:9001", AuthTokens.None, NoEncryptionAndShortRetry)) { using (var session = driver.Session(o => o.WithDefaultAccessMode(AccessMode.Write))) { var txc = session.BeginTransaction(); var result = txc.Run("CREATE (n {name: 'Bob'})"); var exc = Record.Exception(() => txc.Commit()); exc.Should().BeOfType <ServiceUnavailableException>().Which .HasCause <IOException>().Should().BeTrue(); } } } }
public void ShouldLoadBalanceBetweenServers() { using (var driver = GraphDatabase.Driver(RoutingServer, AuthToken)) { string addr1, addr2; for (int i = 0; i < 10; i++) { using (var session = driver.Session(AccessMode.Read)) { var result = session.Run("RETURN 1"); addr1 = result.Summary.Server.Address; } using (var session = driver.Session(AccessMode.Read)) { addr2 = session.Run("RETURN 2").Summary.Server.Address; } addr1.Should().NotBe(addr2); } } }
public void ResultsHaveReceivedButNotBeenReadGetBufferedAfterSessionClosed() { using (var driver = GraphDatabase.Driver(_serverEndPoint, _authToken)) { IStatementResult result; using (var session = driver.Session()) { result = session.Run("unwind range(1,3) as n RETURN n"); } var resultAll = result.ToList(); // Records that has not been read inside session still saved resultAll.Count.Should().Be(3); resultAll.Select(r => r.Values["n"].ValueAs <int>()).Should().ContainInOrder(1, 2, 3); // Summary is still saved result.Summary.Statement.Text.Should().Be("unwind range(1,3) as n RETURN n"); result.Summary.StatementType.Should().Be(StatementType.ReadOnly); } }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddSingleton(s => GraphDatabase.Driver(Configuration.GetConnectionString("DefaultConnection"), AuthTokens.Basic("neo4j", "neo4j"))); services.AddScoped(s => s.GetService <IDriver>().AsyncSession()); services.AddIdentity <ApplicationUser, Neo4jIdentityRole>() .AddNeo4jDataStores() .AddDefaultTokenProviders(); services.AddMvc() .AddRazorPagesOptions(options => { options.Conventions.AuthorizeFolder("/Account/Manage"); options.Conventions.AuthorizePage("/Account/Logout"); }); // Register no-op EmailSender used by account confirmation and password reset during development // For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=532713 services.AddSingleton <IEmailSender, EmailSender>(); }
static void Main(string[] args) { using (var _driver = GraphDatabase.Driver("bolt://localhost:7687", AuthTokens.Basic("neo4j", "Neo4j"))) { using (var session = _driver.Session()) { var response = session.ReadTransaction(tx => tx.Run("match (a:Actor) return a limit 100")); foreach (var result in response) { var firstValue = result.Values.First().Value; Console.WriteLine(((INode)firstValue) .Properties["name"].As <string>()); } } } Console.ReadKey(); }
public async Task ShouldNotBeAbleToAccessRecordsAfterSessionClose() { using (var driver = GraphDatabase.Driver(ServerEndPoint, AuthToken)) { var session = driver.AsyncSession(); IStatementResultCursor cursor; try { cursor = await session.RunAsync("RETURN 1 As X"); } finally { await session.CloseAsync(); } var records = await cursor.ToListAsync(); records.Count.Should().Be(0); } }
private IDriver GetDriver(IServiceProvider provider) { //We're creating a logger here that the IDriver can use, that also hooks into the ASPNET logger var logger = new Neo4jAspNetCoreLogger(provider.GetService <ILogger <IDriver> >()) { //LogLevel is pulled from the ASP NET default logging level Level = Enum.Parse <LogLevel>(Configuration["Logging:LogLevel:Default"]) }; //Setup our IDriver instance to be injected var driver = GraphDatabase.Driver( Configuration["Neo4j:Host"], AuthTokens.Basic( Configuration["Neo4j:User"], Configuration["Neo4j:Pass"]), config => config.WithLogger(logger) ); return(driver); }
public void ShouldCreateCustomAuthToken() { var oldAuthToken = _authToken.AsDictionary(); var newAuthToken = AuthTokens.Custom( oldAuthToken["principal"].ValueAs <string>(), oldAuthToken["credentials"].ValueAs <string>(), "native", "basic"); using (var driver = GraphDatabase.Driver(_serverEndPoint, newAuthToken)) { using (var session = driver.Session()) { var result = session.Run("RETURN 2 as Number"); result.Consume(); result.Keys.Should().Contain("Number"); result.Keys.Count.Should().Be(1); } } }
public async void KeysShouldBeAvailableJustAfterConsecutiveRunAsyncWithConsumptionInBetween() { using (var driver = GraphDatabase.Driver(ServerEndPoint, AuthToken)) { using (var session = driver.Session()) { var cursor1 = await session.RunAsync("RETURN 1 As X"); var cursor2 = await session.RunAsync("RETURN 1 As Y"); await cursor1.ConsumeAsync(); cursor1.Keys.Should().HaveCount(1); cursor1.Keys.Should().Contain("X"); cursor2.Keys.Should().HaveCount(1); cursor2.Keys.Should().Contain("Y"); } } }
public async Task KeysShouldBeAvailableAfterConsecutiveRunNoOrder() { using var driver = GraphDatabase.Driver(ServerEndPoint, AuthToken); var session = driver.AsyncSession(); await using (session.ConfigureAwait(false)) { var cursor1 = await session.RunAsync("RETURN 1 As X"); var cursor2 = await session.RunAsync("RETURN 1 As Y"); var keys2 = await cursor2.KeysAsync(); keys2.Should().BeEquivalentTo("Y"); var keys1 = await cursor1.KeysAsync(); keys1.Should().BeEquivalentTo("X"); } }
private void SetupMonitoredDriver() { var config = new Config { MetricsFactory = new DefaultMetricsFactory(), ConnectionAcquisitionTimeout = TimeSpan.FromMinutes(5), ConnectionTimeout = Config.InfiniteInterval, MaxConnectionPoolSize = 100, DriverLogger = new TestDriverLogger(Output) }; var connectionSettings = new ConnectionSettings(AuthToken, config); var bufferSettings = new BufferSettings(config); var connectionFactory = new MonitoredPooledConnectionFactory( new PooledConnectionFactory(connectionSettings, bufferSettings, config.DriverLogger)); _driver = (Internal.Driver)GraphDatabase.CreateDriver(new Uri(RoutingServer), config, connectionFactory); _connections = connectionFactory.Connections; _metrics = _driver.GetMetrics(); }
public async Task ShouldConnectIPv6AddressIfEnabled() { using (var driver = GraphDatabase.Driver("bolt://[::1]:7687", AuthToken, o => o.WithIpv6Enabled(true))) { var session = driver.AsyncSession(); try { var cursor = await session.RunAsync("RETURN 1"); var result = await cursor.SingleAsync(r => r[0].As <int>()); result.Should().Be(1); } finally { await session.CloseAsync(); } } }
public async Task ShouldNotBeAbleToAccessRecordsAfterSessionClose() { using (var driver = GraphDatabase.Driver(ServerEndPoint, AuthToken)) { var session = driver.AsyncSession(); IResultCursor cursor; try { cursor = await session.RunAsync("RETURN 1 As X"); } finally { await session.CloseAsync(); } var error = await Record.ExceptionAsync(async() => await cursor.ToListAsync()); error.Should().BeOfType <ResultConsumedException>(); } }
public void csvtographdbfunction(int ID, string word) { Console.WriteLine("word without synonym {0}", word); string id = ID.ToString(); using (var driver = GraphDatabase.Driver("bolt://*****:*****@"merge(p:doc" + id + "{name:{WORD},detect:{DETECT}}) with p match(m:doc" + id + "),(n:doc" + id + ") merge (m)-[:next]-(n)", new Dictionary <string, object> { { "WORD", "" + word + "" }, { "DETECT", "" + id + "" } }); Console.WriteLine("yoyoyoy"); session.Run(@"match(a) match(b) where a.name=b.name merge (a)<-[r:same]->(b) with a,b match(a) match(b) where a=b match (a)<-[r]->(b) delete r"); Console.WriteLine("reached the end of elsegraph"); } }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes config.MapHttpAttributeRoutes(); config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); config.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore; var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml"); config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType); //Use an IoC container and register as a Singleton var url = ConfigurationManager.AppSettings["GraphDBUrl"]; var driver = GraphDatabase.Driver(url); Neo4jDriver = driver; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void mixingPeriodicCommitAndLoadCSVShouldWorkWithLists() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void MixingPeriodicCommitAndLoadCSVShouldWorkWithLists() { using (Driver driver = GraphDatabase.driver(GraphDb.boltURI(), Configuration()), Session session = driver.session()) { StatementResult result = session.run("USING PERIODIC COMMIT " + (_lineCountInCSV - 1) + "\n" + "LOAD CSV FROM \"" + _url + "\" as row fieldterminator \" \"\n" + "MERGE (currentnode:Label2 {uuid:row[0]})\n" + "RETURN [currentnode];"); int countOfNodes = 0; while (result.hasNext()) { IEnumerator <object> iterator = result.next().get(0).asList().GetEnumerator(); while (iterator.MoveNext()) { Node node = ( Node )iterator.Current; assertTrue(node.hasLabel("Label2")); assertEquals(countOfNodes.ToString(), node.get("uuid").asString()); countOfNodes++; } } assertEquals(_lineCountInCSV, countOfNodes); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void mixingPeriodicCommitAndLoadCSVShouldWork() public virtual void MixingPeriodicCommitAndLoadCSVShouldWork() { for (int i = _lineCountInCSV - 1; i < _lineCountInCSV + 1; i++) // test with different periodic commit sizes { using (Driver driver = GraphDatabase.driver(GraphDb.boltURI(), Configuration()), Session session = driver.session()) { StatementResult result = session.run("USING PERIODIC COMMIT " + i + "\n" + "LOAD CSV FROM \"" + _url + "\" as row fieldterminator \" \"\n" + "MERGE (currentnode:Label1 {uuid:row[0]})\n" + "RETURN currentnode;"); int countOfNodes = 0; while (result.hasNext()) { Node node = result.next().get(0).asNode(); assertTrue(node.hasLabel("Label1")); assertEquals(countOfNodes.ToString(), node.get("uuid").asString()); countOfNodes++; } assertEquals(_lineCountInCSV, countOfNodes); session.reset(); } } }
public static IDriver ConnectToNeo(NeoConfiguration config, Config neo4jconfig) { try { if (string.IsNullOrWhiteSpace(config.DB_Password) || string.IsNullOrWhiteSpace(config.DB_Username)) { return(GraphDatabase.Driver(config.DB_URI, neo4jconfig)); } else { return(GraphDatabase.Driver(config.DB_URI, AuthTokens.Basic(config.DB_Username, config.DB_Password), neo4jconfig)); } } catch (Exception e) { Console.WriteLine("Error connecting to Neo4j: " + e.Message); Environment.Exit(1002); } return(null); }
private static async Task VerifyConnectivity(Uri address, IAuthToken token) { using (var driver = GraphDatabase.Driver(address, token)) { var session = driver.AsyncSession(); try { var cursor = await session.RunAsync("RETURN 2 as Number"); var records = await cursor.ToListAsync(r => r["Number"].As <int>()); records.Should().BeEquivalentTo(2); } finally { await session.CloseAsync(); } } }
public void ShouldNotThrowExceptionWhenDisposeSessionAfterDriver() { var driver = GraphDatabase.Driver(_serverEndPoint, _authToken); var session = driver.Session(); using (var tx = session.BeginTransaction()) { var ex = Record.Exception(() => tx.Run("Invalid Cypher").Consume()); ex.Should().BeOfType <ClientException>(); ex.Message.Should().StartWith("Invalid input 'I'"); } var result = session.Run("RETURN 1"); result.Single()[0].ValueAs <int>().Should().Be(1); driver.Dispose(); session.Dispose(); }
static void Main(string[] args) { WczytajBazeNeo4j(); var Start = WybierzStacjeStartowa(); var Stop = WybierzStacjeDocelowa(); Console.WriteLine(); using (var driver = GraphDatabase.Driver("bolt://localhost", AuthTokens.Basic(_login, _pass))) { using (var session = driver.Session()) { string st = $@"MATCH (start:Loc{{name:'{Start}'}}), (end:Loc{{name:'{Stop}'}}) CALL algo.shortestPath(start, end, 'cost',{{write:true,writeProperty:'sssp'}}) YIELD writeMillis,loadMillis,nodeCount, totalCost RETURN writeMillis,loadMillis,nodeCount,totalCost"; var result = session.Run(st); foreach (var record in result) { Console.WriteLine($"{record["nodeCount"].As<string>()} przystankow i {record["totalCost"].As<string>()} jednostek czasowych do pokonania trasy z {Start} do {Stop}"); } } } using (var driver = GraphDatabase.Driver("bolt://localhost", AuthTokens.Basic(_login, _pass))) { using (var session = driver.Session()) { string st = $@"MATCH(n: Loc {{ name: '{Start}'}}) CALL algo.shortestPath.deltaStepping.stream(n, 'cost', 3.0) YIELD nodeId, distance RETURN algo.asNode(nodeId).name AS destination, distance ORDER BY distance ASC"; var result = session.Run(st); Console.WriteLine(); foreach (var record in result) { Console.WriteLine($"{record["destination"].As<string>()} {record["distance"].As<string>()}"); } } } Console.ReadKey(); }
public async Task CanSendMultipleBookmarks() { var bookmarks = new[] { "neo4j:bookmark:v1:tx5", "neo4j:bookmark:v1:tx29", "neo4j:bookmark:v1:tx94", "neo4j:bookmark:v1:tx56", "neo4j:bookmark:v1:tx16", "neo4j:bookmark:v1:tx68" }; using (BoltStubServer.Start("V4/multiple_bookmarks", 9001)) { var uri = new Uri("bolt://127.0.0.1:9001"); using (var driver = GraphDatabase.Driver(uri, SetupConfig)) { var session = driver.AsyncSession(o => o.WithBookmarks(Bookmark.From(bookmarks))); try { var txc = await session.BeginTransactionAsync(); try { await txc.RunAsync("CREATE (n {name:'Bob'})"); await txc.CommitAsync(); } catch { await txc.RollbackAsync(); throw; } } finally { await session.CloseAsync(); } session.LastBookmark.Should().Be(Bookmark.From("neo4j:bookmark:v1:tx95")); } } }
public void ConfigureServices(IServiceCollection services) { services.AddCors(); services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2); services.AddHttpContextAccessor(); // configure strongly typed settings objects var appSettingsSection = Configuration.GetSection("AppSettings"); services.Configure <AppSettings>(appSettingsSection); services.AddSingleton(GraphDatabase.Driver("bolt://localhost:7687", AuthTokens.Basic("neo4j", "password"))); //7474 services.AddDbContext <AppDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"))); // configure jwt authentication var appSettings = appSettingsSection.Get <AppSettings>(); var key = Encoding.ASCII.GetBytes(appSettings.Secret); services.AddAuthentication(x => { x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme; x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme; }) .AddJwtBearer(x => { x.RequireHttpsMetadata = false; x.SaveToken = true; x.TokenValidationParameters = new TokenValidationParameters { ValidateIssuerSigningKey = true, IssuerSigningKey = new SymmetricSecurityKey(key), ValidateIssuer = false, ValidateAudience = false }; }); // configure DI for application services services.AddScoped <IUserService, UserService>(); }