Examples with DependencyResolver org.neo4j.common.DependencyResolver used on opensource projects

Example 26 with DependencyResolver

use of org.neo4j.common.DependencyResolver in project neo4j by neo4j.

the class RecoveryCorruptedTransactionLogIT method generateTransactionsAndRotate.

private static void generateTransactionsAndRotate(GraphDatabaseAPI database, int logFilesToGenerate, boolean checkpoint) throws IOException {
    DependencyResolver resolver = database.getDependencyResolver();
    LogFiles logFiles = resolver.resolveDependency(LogFiles.class);
    CheckPointer checkpointer = resolver.resolveDependency(CheckPointer.class);
    while (logFiles.getLogFile().getHighestLogVersion() < logFilesToGenerate) {
        logFiles.getLogFile().rotate();
        generateTransaction(database);
        if (checkpoint) {
            checkpointer.forceCheckPoint(new SimpleTriggerInfo("testForcedCheckpoint"));
        }
    }
}

Example 27 with DependencyResolver

use of org.neo4j.common.DependencyResolver in project neo4j by neo4j.

the class CheckPointerIntegrationTest method checkPointsInTxLog.

private static List<CheckpointInfo> checkPointsInTxLog(GraphDatabaseService db) throws IOException {
    DependencyResolver dependencyResolver = ((GraphDatabaseAPI) db).getDependencyResolver();
    LogFiles logFiles = dependencyResolver.resolveDependency(LogFiles.class);
    return logFiles.getCheckpointFile().reachableCheckpoints();
}

Example 28 with DependencyResolver

use of org.neo4j.common.DependencyResolver in project neo4j by neo4j.

the class CommunityEditionModule method createSystemGraphInitializer.

@Override
public SystemGraphInitializer createSystemGraphInitializer(GlobalModule globalModule) {
    DependencyResolver globalDependencies = globalModule.getGlobalDependencies();
    Supplier<GraphDatabaseService> systemSupplier = systemSupplier(globalDependencies);
    var systemGraphComponents = globalModule.getSystemGraphComponents();
    SystemGraphInitializer initializer = CommunityEditionModule.tryResolveOrCreate(SystemGraphInitializer.class, globalModule.getExternalDependencyResolver(), () -> new DefaultSystemGraphInitializer(systemSupplier, systemGraphComponents));
    return globalModule.getGlobalDependencies().satisfyDependency(initializer);
}

Example 29 with DependencyResolver

use of org.neo4j.common.DependencyResolver in project neo4j by neo4j.

the class UserSecurityGraphComponentTest method setup.

@BeforeAll
static void setup() throws IOException, InvalidArgumentsException {
    Config cfg = Config.newBuilder().set(auth_enabled, TRUE).set(allow_single_automatic_upgrade, FALSE).build();
    dbms = new TestDatabaseManagementServiceBuilder(directory.homePath()).impermanent().setConfig(cfg).noOpSystemGraphInitializer().build();
    system = (GraphDatabaseFacade) dbms.database(SYSTEM_DATABASE_NAME);
    DependencyResolver resolver = system.getDependencyResolver();
    systemGraphComponents = resolver.resolveDependency(SystemGraphComponents.class);
    authManager = resolver.resolveDependency(AuthManager.class);
    // Insert a custom SecurityUserComponent instead of the default one,
    // in order to have a handle on it and to migrate a 3.5 user
    systemGraphComponents.deregister(SECURITY_USER_COMPONENT);
    UserRepository oldUsers = new InMemoryUserRepository();
    User oldUser = new User.Builder("alice", credentialFor("secret")).withRequiredPasswordChange(false).build();
    oldUsers.create(oldUser);
    UserRepository initialPassword = new InMemoryUserRepository();
    userSecurityGraphComponent = new UserSecurityGraphComponent(CommunitySecurityLog.NULL_LOG, oldUsers, initialPassword, Config.defaults());
    systemGraphComponents.register(userSecurityGraphComponent);
    // remove DBMS runtime component as it is not a subject of this test
    systemGraphComponents.deregister(DBMS_RUNTIME_COMPONENT);
}

Example 30 with DependencyResolver

use of org.neo4j.common.DependencyResolver in project neo4j by neo4j.

the class DatabaseManagementServiceFactory method setupProcedures.

/**
 * Creates and registers the systems procedures, including those which belong to a particular edition.
 * N.B. This method takes a {@link DatabaseManager} as an unused parameter *intentionally*, in
 * order to enforce that the databaseManager must be constructed first.
 */
@SuppressWarnings("unused")
private static void setupProcedures(GlobalModule globalModule, AbstractEditionModule editionModule, DatabaseManager<?> databaseManager) {
    Supplier<GlobalProcedures> procedureInitializer = () -> {
        Config globalConfig = globalModule.getGlobalConfig();
        Path proceduresDirectory = globalConfig.get(GraphDatabaseSettings.plugin_dir);
        LogService logService = globalModule.getLogService();
        Log internalLog = logService.getInternalLog(GlobalProcedures.class);
        Log proceduresLog = logService.getUserLog(GlobalProcedures.class);
        ProcedureConfig procedureConfig = new ProcedureConfig(globalConfig);
        Edition neo4jEdition = globalModule.getDbmsInfo().edition;
        SpecialBuiltInProcedures builtInProcedures = new SpecialBuiltInProcedures(Version.getNeo4jVersion(), neo4jEdition.toString());
        GlobalProceduresRegistry globalProcedures = new GlobalProceduresRegistry(builtInProcedures, proceduresDirectory, internalLog, procedureConfig);
        globalProcedures.registerType(Node.class, NTNode);
        globalProcedures.registerType(NodeValue.class, NTNode);
        globalProcedures.registerType(Relationship.class, NTRelationship);
        globalProcedures.registerType(RelationshipValue.class, NTRelationship);
        globalProcedures.registerType(org.neo4j.graphdb.Path.class, NTPath);
        globalProcedures.registerType(PathValue.class, NTPath);
        globalProcedures.registerType(Geometry.class, NTGeometry);
        globalProcedures.registerType(Point.class, NTPoint);
        globalProcedures.registerType(PointValue.class, NTPoint);
        // 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)
        globalProcedures.registerComponent(DependencyResolver.class, Context::dependencyResolver, false);
        globalProcedures.registerComponent(KernelTransaction.class, ctx -> ctx.internalTransaction().kernelTransaction(), false);
        globalProcedures.registerComponent(GraphDatabaseAPI.class, Context::graphDatabaseAPI, false);
        globalProcedures.registerComponent(SystemGraphComponents.class, ctx -> globalModule.getSystemGraphComponents(), false);
        globalProcedures.registerComponent(ValueMapper.class, Context::valueMapper, true);
        // Register injected public API components
        globalProcedures.registerComponent(Log.class, ctx -> proceduresLog, true);
        globalProcedures.registerComponent(Transaction.class, new ProcedureTransactionProvider(), true);
        globalProcedures.registerComponent(org.neo4j.procedure.TerminationGuard.class, new TerminationGuardProvider(), true);
        globalProcedures.registerComponent(SecurityContext.class, Context::securityContext, true);
        globalProcedures.registerComponent(ProcedureCallContext.class, Context::procedureCallContext, true);
        globalProcedures.registerComponent(FulltextAdapter.class, ctx -> ctx.dependencyResolver().resolveDependency(FulltextAdapter.class), true);
        globalProcedures.registerComponent(GraphDatabaseService.class, ctx -> new GraphDatabaseFacade((GraphDatabaseFacade) ctx.graphDatabaseAPI(), new ProcedureLoginContextTransformer(ctx)), true);
        globalProcedures.registerComponent(DataCollector.class, ctx -> ctx.dependencyResolver().resolveDependency(DataCollector.class), false);
        // Edition procedures
        try {
            editionModule.registerProcedures(globalProcedures, procedureConfig, globalModule, databaseManager);
        } catch (KernelException e) {
            internalLog.error("Failed to register built-in edition procedures at start up: " + e.getMessage());
        }
        globalModule.getGlobalLife().add(globalProcedures);
        return globalProcedures;
    };
    GlobalProcedures procedures = tryResolveOrCreate(GlobalProcedures.class, globalModule.getExternalDependencyResolver(), procedureInitializer);
    if (procedures instanceof Consumer) {
        ((Consumer) procedures).accept(procedureInitializer);
    }
    globalModule.getGlobalDependencies().satisfyDependency(procedures);
}