Examples with GraphDatabaseFacadeFactory org.neo4j.kernel.impl.factory.GraphDatabaseFacadeFactory used on opensource projects

Example 1 with GraphDatabaseFacadeFactory

use of org.neo4j.kernel.impl.factory.GraphDatabaseFacadeFactory in project neo4j by neo4j.

the class LabelsAcceptanceTest method beansAPIWithNoMoreLabelIds.

@SuppressWarnings("deprecation")
private GraphDatabaseService beansAPIWithNoMoreLabelIds() {
    final EphemeralIdGenerator.Factory idFactory = new EphemeralIdGenerator.Factory() {

        private IdTypeConfigurationProvider idTypeConfigurationProvider = new CommunityIdTypeConfigurationProvider();

        @Override
        public IdGenerator open(File fileName, int grabSize, IdType idType, long highId, long maxId) {
            if (idType == IdType.LABEL_TOKEN) {
                IdGenerator generator = generators.get(idType);
                if (generator == null) {
                    IdTypeConfiguration idTypeConfiguration = idTypeConfigurationProvider.getIdTypeConfiguration(idType);
                    generator = new EphemeralIdGenerator(idType, idTypeConfiguration) {

                        @Override
                        public long nextId() {
                            // Same exception as the one thrown by IdGeneratorImpl
                            throw new UnderlyingStorageException("Id capacity exceeded");
                        }
                    };
                    generators.put(idType, generator);
                }
                return generator;
            }
            return super.open(fileName, grabSize, idType, Long.MAX_VALUE, Long.MAX_VALUE);
        }
    };
    TestGraphDatabaseFactory dbFactory = new TestGraphDatabaseFactory() {

        @Override
        protected GraphDatabaseBuilder.DatabaseCreator createImpermanentDatabaseCreator(final File storeDir, final TestGraphDatabaseFactoryState state) {
            return new GraphDatabaseBuilder.DatabaseCreator() {

                @Override
                public GraphDatabaseService newDatabase(Map<String, String> config) {
                    return newDatabase(Config.embeddedDefaults(config));
                }

                @Override
                public GraphDatabaseService newDatabase(@Nonnull Config config) {
                    return new ImpermanentGraphDatabase(storeDir, config, GraphDatabaseDependencies.newDependencies(state.databaseDependencies())) {

                        @Override
                        protected void create(File storeDir, Config config, GraphDatabaseFacadeFactory.Dependencies dependencies) {
                            Function<PlatformModule, EditionModule> factory = (platformModule) -> new CommunityEditionModule(platformModule) {

                                @Override
                                protected IdGeneratorFactory createIdGeneratorFactory(FileSystemAbstraction fs, IdTypeConfigurationProvider idTypeConfigurationProvider) {
                                    return idFactory;
                                }
                            };
                            new GraphDatabaseFacadeFactory(DatabaseInfo.COMMUNITY, factory) {

                                @Override
                                protected PlatformModule createPlatform(File storeDir, Config config, Dependencies dependencies, GraphDatabaseFacade graphDatabaseFacade) {
                                    return new ImpermanentPlatformModule(storeDir, config, databaseInfo, dependencies, graphDatabaseFacade);
                                }
                            }.initFacade(storeDir, config, dependencies, this);
                        }
                    };
                }
            };
        }
    };
    return dbFactory.newImpermanentDatabase();
}

Example 2 with GraphDatabaseFacadeFactory

use of org.neo4j.kernel.impl.factory.GraphDatabaseFacadeFactory in project neo4j by neo4j.

the class GraphDatabaseFacadeFactoryTest method newFaultyGraphDatabaseFacadeFactory.

private GraphDatabaseFacadeFactory newFaultyGraphDatabaseFacadeFactory(final RuntimeException startupError) {
    return new GraphDatabaseFacadeFactory(DatabaseInfo.UNKNOWN, (p) -> Mockito.mock(EditionModule.class, Mockito.RETURNS_DEEP_STUBS)) {

        @Override
        protected PlatformModule createPlatform(File storeDir, Config config, Dependencies dependencies, GraphDatabaseFacade graphDatabaseFacade) {
            final LifeSupport lifeMock = mock(LifeSupport.class);
            doThrow(startupError).when(lifeMock).start();
            doAnswer(invocation -> invocation.getArguments()[0]).when(lifeMock).add(any(Lifecycle.class));
            return new PlatformModule(storeDir, config, databaseInfo, dependencies, graphDatabaseFacade) {

                @Override
                public LifeSupport createLife() {
                    return lifeMock;
                }
            };
        }

        @Override
        protected DataSourceModule createDataSource(PlatformModule platformModule, EditionModule editionModule, Supplier<QueryExecutionEngine> queryExecutionEngineSupplier) {
            return mock(DataSourceModule.class);
        }
    };
}

Example 3 with GraphDatabaseFacadeFactory

use of org.neo4j.kernel.impl.factory.GraphDatabaseFacadeFactory in project neo4j by neo4j.

the class GraphDatabaseFacadeFactoryTest method shouldThrowAppropriateExceptionIfBothStartAndShutdownFail.

@Test
public void shouldThrowAppropriateExceptionIfBothStartAndShutdownFail() {
    // Given
    RuntimeException startupError = new RuntimeException();
    RuntimeException shutdownError = new RuntimeException();
    GraphDatabaseFacadeFactory db = newFaultyGraphDatabaseFacadeFactory(startupError);
    doThrow(shutdownError).when(mockFacade).shutdown();
    try {
        // When
        db.initFacade(dir.graphDbDir(), Collections.emptyMap(), deps, mockFacade);
        fail("Should have thrown " + RuntimeException.class);
    } catch (RuntimeException exception) {
        // Then
        assertEquals(shutdownError, exception);
        assertEquals(startupError, Exceptions.rootCause(exception.getSuppressed()[0]));
    }
}

Example 4 with GraphDatabaseFacadeFactory

use of org.neo4j.kernel.impl.factory.GraphDatabaseFacadeFactory in project neo4j by neo4j.

the class NonUniqueIndexTests method newEmbeddedGraphDatabaseWithSlowJobScheduler.

private GraphDatabaseService newEmbeddedGraphDatabaseWithSlowJobScheduler() {
    GraphDatabaseFactoryState graphDatabaseFactoryState = new GraphDatabaseFactoryState();
    graphDatabaseFactoryState.setUserLogProvider(NullLogService.getInstance().getUserLogProvider());
    return new GraphDatabaseFacadeFactory(DatabaseInfo.COMMUNITY, CommunityEditionModule::new) {

        @Override
        protected PlatformModule createPlatform(File storeDir, Config config, Dependencies dependencies, GraphDatabaseFacade graphDatabaseFacade) {
            return new PlatformModule(storeDir, config, databaseInfo, dependencies, graphDatabaseFacade) {

                @Override
                protected Neo4jJobScheduler createJobScheduler() {
                    return newSlowJobScheduler();
                }

                @Override
                protected LogService createLogService(LogProvider userLogProvider) {
                    return NullLogService.getInstance();
                }
            };
        }
    }.newFacade(directory.graphDbDir(), Config.embeddedDefaults(), graphDatabaseFactoryState.databaseDependencies());
}

Example 5 with GraphDatabaseFacadeFactory

use of org.neo4j.kernel.impl.factory.GraphDatabaseFacadeFactory in project neo4j by neo4j.

the class EmbeddedGraphDatabase method create.

protected void create(File storeDir, Map<String, String> params, GraphDatabaseFacadeFactory.Dependencies dependencies) {
    GraphDatabaseDependencies newDependencies = newDependencies(dependencies).settingsClasses(asList(append(GraphDatabaseSettings.class, dependencies.settingsClasses())));
    new GraphDatabaseFacadeFactory(DatabaseInfo.COMMUNITY, CommunityEditionModule::new).initFacade(storeDir, params, newDependencies, this);
}