private HostnamePort AddressForConnector(string name) { DependencyResolver resolver = _server.database.Graph.DependencyResolver; ConnectorPortRegister portRegister = resolver.ResolveDependency(typeof(ConnectorPortRegister)); return(portRegister.GetLocalAddress(name)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldConvertListsAndMapsWhenPassingFromScalaToJava() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldConvertListsAndMapsWhenPassingFromScalaToJava() { GraphDatabaseQueryService graph = new GraphDatabaseCypherService(this.Database.GraphDatabaseAPI); DependencyResolver resolver = graph.DependencyResolver; Monitors monitors = resolver.ResolveDependency(typeof(Monitors)); NullLogProvider nullLogProvider = NullLogProvider.Instance; Config config = resolver.ResolveDependency(typeof(Config)); CypherConfiguration cypherConfig = CypherConfiguration.fromConfig(config); CommunityCompilerFactory compilerFactory = new CommunityCompilerFactory(graph, monitors, nullLogProvider, cypherConfig.toCypherPlannerConfiguration(config), cypherConfig.toCypherRuntimeConfiguration()); ExecutionEngine executionEngine = new ExecutionEngine(graph, nullLogProvider, compilerFactory); Result result; using (InternalTransaction tx = graph.BeginTransaction(KernelTransaction.Type.@implicit, LoginContext.AUTH_DISABLED)) { string query = "RETURN { key : 'Value' , collectionKey: [{ inner: 'Map1' }, { inner: 'Map2' }]}"; TransactionalContext tc = CreateTransactionContext(graph, tx, query); result = executionEngine.ExecuteQuery(query, _noParams, tc); VerifyResult(result); result.Close(); tx.Success(); } }
public override void Initialize(DependencyResolver dependencyResolver) { foreach (ExecutionMonitor monitor in _monitors) { monitor.Initialize(dependencyResolver); } }
public override void Start() { DependencyResolver resolver = _database.Graph.DependencyResolver; this._executionEngine = ( ExecutionEngine )resolver.ResolveDependency(typeof(QueryExecutionEngine)); this._service = resolver.ResolveDependency(typeof(GraphDatabaseQueryService)); this._contextFactory = Neo4jTransactionalContextFactory.create(this._service, _locker); }
public virtual long FindLastAppliedIndex() { DependencyResolver dependencies = _localDatabase.dataSource().DependencyResolver; TransactionIdStore transactionIdStore = dependencies.ResolveDependency(typeof(TransactionIdStore), ONLY); LogicalTransactionStore transactionStore = dependencies.ResolveDependency(typeof(LogicalTransactionStore), ONLY); return((new LastCommittedIndexFinder(transactionIdStore, transactionStore, _logProvider)).LastCommittedIndex); }
public CommitProcessSwitcher(TransactionPropagator txPropagator, Master master, DelegateInvocationHandler <TransactionCommitProcess> @delegate, RequestContextFactory requestContextFactory, Monitors monitors, DependencyResolver dependencyResolver, Config config) : base(@delegate) { this._txPropagator = txPropagator; this._master = master; this._requestContextFactory = requestContextFactory; this._dependencyResolver = dependencyResolver; this._monitor = monitors.NewMonitor(typeof(MasterTransactionCommitProcess.Monitor)); this._activeDatabaseName = config.Get(GraphDatabaseSettings.active_database); }
public override TransactionCommitProcess CommitProcess() { // We simply can't resolve the commit process here, since the commit process of a slave // is one that sends transactions to the master. We here, however would like to actually // commit transactions in this db. DependencyResolver databaseResolver = DatabaseResolver; return(new TransactionRepresentationCommitProcess(databaseResolver.ResolveDependency(typeof(TransactionAppender)), databaseResolver.ResolveDependency(typeof(StorageEngine)))); }
public virtual UpdatePullingTransactionObligationFulfiller CreateObligationFulfiller(UpdatePuller updatePuller) { return(new UpdatePullingTransactionObligationFulfiller(updatePuller, _memberStateMachine, _serverId, () => { GraphDatabaseFacade databaseFacade = this._dependencyResolver.resolveDependency(typeof(DatabaseManager)).getDatabaseFacade(_activeDatabaseName).get(); DependencyResolver databaseResolver = databaseFacade.DependencyResolver; return databaseResolver.resolveDependency(typeof(TransactionIdStore)); })); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void setUp() public virtual void SetUp() { DependencyResolver dependencyResolver = mock(typeof(DependencyResolver)); when(_datasource.DependencyResolver).thenReturn(dependencyResolver); when(dependencyResolver.ResolveDependency(typeof(LogicalTransactionStore))).thenReturn(_logicalTransactionStore); when(dependencyResolver.ResolveDependency(typeof(TransactionIdStore))).thenReturn(_transactionIdStore); when(_transactionIdStore.LastCommittedTransactionId).thenReturn(15L); _txPullRequestHandler = new TxPullRequestHandler(new CatchupServerProtocol(), () => _storeId, () => true, () => _datasource, new Monitors(), _logProvider); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void setUp() public virtual void SetUp() { GraphDatabaseAPI api = DbRule.GraphDatabaseAPI; _graph = api; DependencyResolver dependencyResolver = api.DependencyResolver; this._bridge = dependencyResolver.ResolveDependency(typeof(ThreadToStatementContextBridge)); this._tx = _graph.beginTx(); }
private static BasicContext CreateContext(SecurityContext securityContext, DependencyResolver dependencyResolver, ProcedureCallContext procedureCallContext) { BasicContext ctx = new BasicContext(); ctx.Put(SECURITY_CONTEXT, securityContext); ctx.Put(PROCEDURE_CALL_CONTEXT, procedureCallContext); ctx.Put(DEPENDENCY_RESOLVER, dependencyResolver); ctx.Put(DATABASE_API, dependencyResolver.ResolveDependency(typeof(GraphDatabaseAPI))); return(ctx); }
/// <summary> /// Creates an execution engine around the give graph database </summary> /// <param name="queryService"> The database to wrap </param> /// <param name="logProvider"> A <seealso cref="LogProvider"/> for cypher-statements </param> public ExecutionEngine(GraphDatabaseQueryService queryService, LogProvider logProvider, CompilerFactory compilerFactory) { DependencyResolver resolver = queryService.DependencyResolver; Monitors monitors = resolver.ResolveDependency(typeof(Monitors)); CacheTracer cacheTracer = new MonitoringCacheTracer(monitors.NewMonitor(typeof(StringCacheMonitor))); Config config = resolver.ResolveDependency(typeof(Config)); CypherConfiguration cypherConfiguration = CypherConfiguration.fromConfig(config); CompilationTracer tracer = new TimingCompilationTracer(monitors.NewMonitor(typeof(TimingCompilationTracer.EventListener))); _inner = new [email protected](queryService, monitors, tracer, cacheTracer, cypherConfiguration, compilerFactory, logProvider, Clock.systemUTC()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void createBufferedIdComponentsByDefault() public virtual void CreateBufferedIdComponentsByDefault() { ClusterManager.ManagedCluster managedCluster = ClusterRule.startCluster(); DependencyResolver dependencyResolver = managedCluster.Master.DependencyResolver; IdController idController = dependencyResolver.ResolveDependency(typeof(IdController)); IdGeneratorFactory idGeneratorFactory = dependencyResolver.ResolveDependency(typeof(IdGeneratorFactory)); assertThat(idController, instanceOf(typeof(BufferedIdController))); assertThat(idGeneratorFactory, instanceOf(typeof(BufferingIdGeneratorFactory))); }
public TxPullRequestHandler(CatchupServerProtocol protocol, System.Func <StoreId> storeIdSupplier, System.Func <bool> databaseAvailable, System.Func <NeoStoreDataSource> dataSourceSupplier, Monitors monitors, LogProvider logProvider) { this._protocol = protocol; this._storeIdSupplier = storeIdSupplier; this._databaseAvailable = databaseAvailable; DependencyResolver dependencies = dataSourceSupplier().DependencyResolver; this._transactionIdStore = dependencies.ResolveDependency(typeof(TransactionIdStore)); this._logicalTransactionStore = dependencies.ResolveDependency(typeof(LogicalTransactionStore)); this._monitor = monitors.NewMonitor(typeof(TxPullRequestsMonitor)); this._log = logProvider.getLog(this.GetType()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void createBufferedIdComponentsByDefault() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void CreateBufferedIdComponentsByDefault() { Cluster cluster = ClusterRule.startCluster(); CoreClusterMember leader = cluster.awaitLeader(); DependencyResolver dependencyResolver = leader.Database().DependencyResolver; IdController idController = dependencyResolver.ResolveDependency(typeof(IdController)); IdGeneratorFactory idGeneratorFactory = dependencyResolver.ResolveDependency(typeof(IdGeneratorFactory)); assertThat(idController, instanceOf(typeof(BufferedIdController))); assertThat(idGeneratorFactory, instanceOf(typeof(FreeIdFilteredIdGeneratorFactory))); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void createBufferedIdComponentsByDefault() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void CreateBufferedIdComponentsByDefault() { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: org.neo4j.causalclustering.discovery.Cluster<?> cluster = clusterRule.startCluster(); Cluster <object> cluster = ClusterRule.startCluster(); CoreClusterMember leader = cluster.AwaitLeader(); DependencyResolver dependencyResolver = leader.Database().DependencyResolver; IdController idController = dependencyResolver.ResolveDependency(typeof(IdController)); IdGeneratorFactory idGeneratorFactory = dependencyResolver.ResolveDependency(typeof(IdGeneratorFactory)); assertThat(idController, instanceOf(typeof(BufferedIdController))); assertThat(idGeneratorFactory, instanceOf(typeof(FreeIdFilteredIdGeneratorFactory))); }
private static DatabaseManager NewDbMock() { GraphDatabaseFacade db = mock(typeof(GraphDatabaseFacade)); DependencyResolver dependencyResolver = mock(typeof(DependencyResolver)); when(Db.DependencyResolver).thenReturn(dependencyResolver); GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService)); when(queryService.DependencyResolver).thenReturn(dependencyResolver); when(dependencyResolver.ResolveDependency(typeof(GraphDatabaseQueryService))).thenReturn(queryService); DatabaseManager databaseManager = mock(typeof(DatabaseManager)); when(databaseManager.GetDatabaseFacade(CUSTOM_DB_NAME)).thenReturn(db); return(databaseManager); }
public PullerFactory(RequestContextFactory requestContextFactory, Master master, LastUpdateTime lastUpdateTime, LogProvider logging, InstanceId serverId, InvalidEpochExceptionHandler invalidEpochHandler, long pullInterval, JobScheduler jobScheduler, DependencyResolver dependencyResolver, AvailabilityGuard availabilityGuard, HighAvailabilityMemberStateMachine memberStateMachine, Monitors monitors, Config config) { this._requestContextFactory = requestContextFactory; this._master = master; this._lastUpdateTime = lastUpdateTime; this._logging = logging; this._serverId = serverId; this._invalidEpochHandler = invalidEpochHandler; this._pullInterval = pullInterval; this._jobScheduler = jobScheduler; this._dependencyResolver = dependencyResolver; this._availabilityGuard = availabilityGuard; this._memberStateMachine = memberStateMachine; this._monitors = monitors; this._activeDatabaseName = config.Get(GraphDatabaseSettings.active_database); }
protected internal override QueryExecutionEngine CreateEngine(Dependencies deps, GraphDatabaseAPI graphAPI) { GraphDatabaseCypherService queryService = new GraphDatabaseCypherService(graphAPI); deps.SatisfyDependency(queryService); DependencyResolver resolver = graphAPI.DependencyResolver; LogService logService = resolver.ResolveDependency(typeof(LogService)); Monitors monitors = resolver.ResolveDependency(typeof(Monitors)); Config config = resolver.ResolveDependency(typeof(Config)); CypherConfiguration cypherConfig = CypherConfiguration.fromConfig(config); CypherPlannerConfiguration plannerConfig = cypherConfig.toCypherPlannerConfiguration(config); CypherRuntimeConfiguration runtimeConfig = cypherConfig.toCypherRuntimeConfiguration(); LogProvider logProvider = logService.InternalLogProvider; CommunityCompilerFactory compilerFactory = new CommunityCompilerFactory(queryService, monitors, logProvider, plannerConfig, runtimeConfig); deps.SatisfyDependencies(compilerFactory); return(CreateEngine(queryService, config, logProvider, compilerFactory)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shutdownWhileFinishingTransactionWithIndexUpdates() public virtual void ShutdownWhileFinishingTransactionWithIndexUpdates() { CreateConstraint(Database); WaitIndexesOnline(Database); using (Transaction transaction = Database.beginTx()) { Node node = Database.createNode(_constraintIndexLabel); node.SetProperty(UNIQUE_PROPERTY_NAME, _indexProvider.AndIncrement); DependencyResolver dependencyResolver = Database.DependencyResolver; NeoStoreDataSource dataSource = dependencyResolver.ResolveDependency(typeof(NeoStoreDataSource)); LifeSupport dataSourceLife = dataSource.Life; TransactionCloseListener closeListener = new TransactionCloseListener(transaction); dataSourceLife.AddLifecycleListener(closeListener); dataSource.Stop(); assertTrue("Transaction should be closed and no exception should be thrown.", closeListener.TransactionClosed); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void setup() public virtual void Setup() { _dataSource = mock(typeof(NeoStoreDataSource)); StorageEngine storageEngine = mock(typeof(StorageEngine)); StorageReader storageReader = mock(typeof(StorageReader)); when(storageEngine.NewReader()).thenReturn(storageReader); _indexingService = mock(typeof(IndexingService)); TokenHolders tokenHolders = MockedTokenHolders(); when(tokenHolders.LabelTokens().getIdByName(EXISTING_LABEL)).thenReturn(LABEL_ID); when(tokenHolders.PropertyKeyTokens().getIdByName(EXISTING_PROPERTY)).thenReturn(PROPERTY_ID); when(tokenHolders.PropertyKeyTokens().getIdByName(NON_EXISTING_PROPERTY)).thenReturn(-1); when(tokenHolders.LabelTokens().getIdByName(NON_EXISTING_LABEL)).thenReturn(NO_TOKEN); DependencyResolver resolver = mock(typeof(DependencyResolver)); when(resolver.ResolveDependency(typeof(IndexingService))).thenReturn(_indexingService); when(resolver.ResolveDependency(typeof(StorageEngine))).thenReturn(storageEngine); when(resolver.ResolveDependency(typeof(TokenHolders))).thenReturn(tokenHolders); when(_dataSource.DependencyResolver).thenReturn(resolver); }
private void SetUpMocks() { _database = mock(typeof(Database)); _databaseFacade = mock(typeof(GraphDatabaseFacade)); _resolver = mock(typeof(DependencyResolver)); _executionEngine = mock(typeof(ExecutionEngine)); _statementBridge = mock(typeof(ThreadToStatementContextBridge)); _databaseQueryService = mock(typeof(GraphDatabaseQueryService)); _kernelTransaction = mock(typeof(KernelTransaction)); _statement = mock(typeof(Statement)); _request = mock(typeof(HttpServletRequest)); InternalTransaction transaction = new TopLevelTransaction(_kernelTransaction); LoginContext loginContext = AUTH_DISABLED; KernelTransaction.Type type = KernelTransaction.Type.@implicit; QueryRegistryOperations registryOperations = mock(typeof(QueryRegistryOperations)); when(_statement.queryRegistration()).thenReturn(registryOperations); when(_statementBridge.get()).thenReturn(_statement); when(_kernelTransaction.securityContext()).thenReturn(loginContext.Authorize(s => - 1, GraphDatabaseSettings.DEFAULT_DATABASE_NAME)); when(_kernelTransaction.transactionType()).thenReturn(type); when(_database.Graph).thenReturn(_databaseFacade); when(_databaseFacade.DependencyResolver).thenReturn(_resolver); when(_resolver.resolveDependency(typeof(QueryExecutionEngine))).thenReturn(_executionEngine); when(_resolver.resolveDependency(typeof(ThreadToStatementContextBridge))).thenReturn(_statementBridge); when(_resolver.resolveDependency(typeof(GraphDatabaseQueryService))).thenReturn(_databaseQueryService); when(_databaseQueryService.beginTransaction(type, loginContext)).thenReturn(transaction); when(_databaseQueryService.beginTransaction(type, loginContext, CUSTOM_TRANSACTION_TIMEOUT, TimeUnit.MILLISECONDS)).thenReturn(transaction); when(_databaseQueryService.DependencyResolver).thenReturn(_resolver); when(_request.Scheme).thenReturn("http"); when(_request.RemoteAddr).thenReturn("127.0.0.1"); when(_request.RemotePort).thenReturn(5678); when(_request.ServerName).thenReturn("127.0.0.1"); when(_request.ServerPort).thenReturn(7474); when(_request.RequestURI).thenReturn("/"); }
public override void Registered(NeoStoreDataSource dataSource) { DependencyResolver dependencyResolver = dataSource.DependencyResolver; State = new State(dependencyResolver.ResolveDependency(typeof(StorageEngine)), dependencyResolver.ResolveDependency(typeof(IndexingService)), dependencyResolver.ResolveDependency(typeof(TokenHolders))); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private org.neo4j.internal.kernel.api.Transaction transaction() throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException private Transaction Transaction() { DependencyResolver resolver = this.Db.DependencyResolver; return(resolver.ResolveDependency(typeof(Kernel)).beginTransaction(@implicit, LoginContext.AUTH_DISABLED)); }
public GraphDatabaseCypherService(GraphDatabaseService graph) { this._graph = ( GraphDatabaseFacade )graph; this._dbmsOperations = DependencyResolver.resolveDependency(typeof(DbmsOperations)); }
internal ResolvableDependencies(DependencyResolver globalResolver) { this.GlobalResolver = globalResolver; }
public TransactionCommittingResponseUnpacker(DependencyResolver dependencies, int maxBatchSize, long idReuseSafeZoneTime) : this(new ResolvableDependencies(dependencies), maxBatchSize, idReuseSafeZoneTime) { }
public override Kernel KernelToTest() { DependencyResolver resolver = (( GraphDatabaseAPI )this._db).DependencyResolver; return(resolver.ResolveDependency(typeof(Kernel))); }
public TransactionApplier(DependencyResolver resolver) { _commitProcess = new TransactionRepresentationCommitProcess(resolver.ResolveDependency(typeof(TransactionAppender)), resolver.ResolveDependency(typeof(StorageEngine))); _versionContextSupplier = resolver.ResolveDependency(typeof(VersionContextSupplier)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public org.neo4j.collection.RawIterator<Object[],org.neo4j.internal.kernel.api.exceptions.ProcedureException> procedureCallDbms(int id, Object[] input, org.neo4j.graphdb.DependencyResolver dependencyResolver, org.neo4j.internal.kernel.api.security.SecurityContext securityContext, org.neo4j.kernel.api.ResourceTracker resourceTracker, org.neo4j.internal.kernel.api.procs.ProcedureCallContext procedureCallContext) throws org.neo4j.internal.kernel.api.exceptions.ProcedureException public override RawIterator <object[], ProcedureException> ProcedureCallDbms(int id, object[] input, DependencyResolver dependencyResolver, SecurityContext securityContext, ResourceTracker resourceTracker, ProcedureCallContext procedureCallContext) { BasicContext ctx = CreateContext(securityContext, dependencyResolver, procedureCallContext); return(_procedures.callProcedure(ctx, id, input, resourceTracker)); }