use of org.neo4j.kernel.guard.Guard in project neo4j by neo4j.
the class Neo4jTransactionalContextFactory method create.
@Deprecated
public static TransactionalContextFactory create(GraphDatabaseQueryService queryService, PropertyContainerLocker locker) {
DependencyResolver resolver = queryService.getDependencyResolver();
ThreadToStatementContextBridge txBridge = resolver.resolveDependency(ThreadToStatementContextBridge.class);
Guard guard = resolver.resolveDependency(Guard.class);
Neo4jTransactionalContext.Creator contextCreator = (Supplier<Statement> statementSupplier, InternalTransaction tx, Statement initialStatement, ExecutingQuery executingQuery) -> new Neo4jTransactionalContext(queryService, statementSupplier, guard, txBridge, locker, tx, initialStatement, executingQuery);
return new Neo4jTransactionalContextFactory(txBridge, contextCreator);
}
use of org.neo4j.kernel.guard.Guard in project neo4j by neo4j.
the class DataSourceModule method setupProcedures.
private Procedures setupProcedures(PlatformModule platform, EditionModule editionModule) {
File pluginDir = platform.config.get(GraphDatabaseSettings.plugin_dir);
Log internalLog = platform.logging.getInternalLog(Procedures.class);
Procedures procedures = new Procedures(new SpecialBuiltInProcedures(Version.getNeo4jVersion(), platform.databaseInfo.edition.toString()), pluginDir, internalLog, new ProcedureConfig(platform.config));
platform.life.add(procedures);
platform.dependencies.satisfyDependency(procedures);
procedures.registerType(Node.class, new SimpleConverter(NTNode, Node.class));
procedures.registerType(Relationship.class, new SimpleConverter(NTRelationship, Relationship.class));
procedures.registerType(Path.class, new SimpleConverter(NTPath, Path.class));
procedures.registerType(Geometry.class, new SimpleConverter(NTGeometry, Geometry.class));
procedures.registerType(Point.class, new SimpleConverter(NTPoint, Point.class));
// Register injected public API components
Log proceduresLog = platform.logging.getUserLog(Procedures.class);
procedures.registerComponent(Log.class, (ctx) -> proceduresLog, true);
Guard guard = platform.dependencies.resolveDependency(Guard.class);
procedures.registerComponent(ProcedureTransaction.class, new ProcedureTransactionProvider(), true);
procedures.registerComponent(TerminationGuard.class, new TerminationGuardProvider(guard), true);
// Below components are not public API, but are made available for internal
// procedures to call, and to provide temporary workarounds for the following
// patterns:
// - Batch-transaction imports (GDAPI, needs to be real and passed to background processing threads)
// - Group-transaction writes (same pattern as above, but rather than splitting large transactions,
// combine lots of small ones)
// - Bleeding-edge performance (KernelTransaction, to bypass overhead of working with Core API)
procedures.registerComponent(DependencyResolver.class, (ctx) -> platform.dependencies, false);
procedures.registerComponent(KernelTransaction.class, (ctx) -> ctx.get(KERNEL_TRANSACTION), false);
procedures.registerComponent(GraphDatabaseAPI.class, (ctx) -> platform.graphDatabaseFacade, false);
// Security procedures
procedures.registerComponent(SecurityContext.class, ctx -> ctx.get(SECURITY_CONTEXT), true);
// Edition procedures
try {
editionModule.registerProcedures(procedures);
} catch (KernelException e) {
internalLog.error("Failed to register built-in edition procedures at start up: " + e.getMessage());
}
return procedures;
}
use of org.neo4j.kernel.guard.Guard in project neo4j by neo4j.
the class GraphDatabaseFacade method init.
/**
* Create a new Core API facade, backed by the given SPI and using pre-resolved dependencies
*/
public void init(SPI spi, Guard guard, ThreadToStatementContextBridge txBridge, Config config) {
this.spi = spi;
this.defaultTransactionTimeout = config.get(GraphDatabaseSettings.transaction_timeout);
Supplier<Statement> statementSupplier = spi::currentStatement;
Supplier<KernelTransaction> transactionSupplier = spi::currentTransaction;
ThrowingAction<RuntimeException> assertTransactionOpen = this::assertTransactionOpen;
this.schema = new SchemaImpl(statementSupplier);
this.relActions = new StandardRelationshipActions(statementSupplier, transactionSupplier, assertTransactionOpen, (id) -> new NodeProxy(nodeActions, id), this);
this.nodeActions = new StandardNodeActions(statementSupplier, transactionSupplier, assertTransactionOpen, relActions, this);
this.indexManager = Suppliers.lazySingleton(() -> {
IndexProviderImpl idxProvider = new IndexProviderImpl(this, statementSupplier);
AutoIndexerFacade<Node> nodeAutoIndexer = new AutoIndexerFacade<>(() -> new ReadOnlyIndexFacade<>(idxProvider.getOrCreateNodeIndex(NODE_AUTO_INDEX, null)), spi.autoIndexing().nodes());
RelationshipAutoIndexerFacade relAutoIndexer = new RelationshipAutoIndexerFacade(() -> new ReadOnlyRelationshipIndexFacade(idxProvider.getOrCreateRelationshipIndex(RELATIONSHIP_AUTO_INDEX, null)), spi.autoIndexing().relationships());
return new IndexManagerImpl(statementSupplier, idxProvider, nodeAutoIndexer, relAutoIndexer);
});
this.contextFactory = Neo4jTransactionalContextFactory.create(spi, guard, txBridge, locker);
}
use of org.neo4j.kernel.guard.Guard in project neo4j by neo4j.
the class GuardIT method useTimeoutGuard.
@Test
public void useTimeoutGuard() throws Exception {
GraphDatabaseAPI database = startDataBase();
DependencyResolver dependencyResolver = database.getDependencyResolver();
Guard guard = dependencyResolver.resolveDependency(Guard.class);
assertThat(guard, instanceOf(TimeoutGuard.class));
}
use of org.neo4j.kernel.guard.Guard in project neo4j by neo4j.
the class Neo4jTransactionalContextTest method setUpMocks.
private void setUpMocks() {
queryService = mock(GraphDatabaseQueryService.class);
DependencyResolver resolver = mock(DependencyResolver.class);
ThreadToStatementContextBridge txBridge = mock(ThreadToStatementContextBridge.class);
guard = mock(Guard.class);
initialStatement = mock(KernelStatement.class);
QueryRegistryOperations queryRegistryOperations = mock(QueryRegistryOperations.class);
when(initialStatement.queryRegistration()).thenReturn(queryRegistryOperations);
when(queryService.getDependencyResolver()).thenReturn(resolver);
when(resolver.resolveDependency(ThreadToStatementContextBridge.class)).thenReturn(txBridge);
when(resolver.resolveDependency(Guard.class)).thenReturn(guard);
}
Aggregations