public void satisfyDependencies( Object... dependencies ) { for ( Object dependency : dependencies ) { satisfyDependency( dependency ); } }
/** * Puts state of a certain type. * * @param state state instance to set. * @see #getState(Class) * @throws IllegalStateException if state of this type has already been defined. */ public <T> void putState( T state ) { accessibleState.put( state.getClass(), state ); dependencies.satisfyDependency( state ); }
public static QueryExecutionEngine initialize( Dependencies deps, GraphDatabaseAPI graphAPI, Iterable<QueryEngineProvider> providers ) { List<QueryEngineProvider> engineProviders = asList( providers ); engineProviders.sort( Comparator.comparingInt( QueryEngineProvider::enginePriority ) ); QueryEngineProvider provider = Iterables.firstOrNull( engineProviders ); if ( provider == null ) { return noEngine(); } QueryExecutionEngine engine = provider.createEngine( deps, graphAPI ); return deps.satisfyDependency( engine ); }
private static <T> T dependency( Dependencies dependencies, Class<T> type, Function<DependencyResolver,T> defaultSupplier ) { try { return dependencies.resolveDependency( type ); } catch ( IllegalArgumentException | UnsatisfiedDependencyException e ) { return dependencies.satisfyDependency( defaultSupplier.apply( dependencies ) ); } }
private void buildTransactionMonitor( KernelTransactions kernelTransactions, Clock clock, Config config ) { KernelTransactionMonitor kernelTransactionTimeoutMonitor = new KernelTransactionMonitor( kernelTransactions, clock, logService ); dataSourceDependencies.satisfyDependency( kernelTransactionTimeoutMonitor ); KernelTransactionMonitorScheduler transactionMonitorScheduler = new KernelTransactionMonitorScheduler( kernelTransactionTimeoutMonitor, scheduler, config.get( GraphDatabaseSettings.transaction_monitor_check_interval ).toMillis() ); life.add( transactionMonitorScheduler ); }
@Test public void givenSatisfiedTypeInParentAndDependenciesWhenResolveWithTypeInDependenciesThenInstanceReturned() { // Given Dependencies parent = new Dependencies( ); Dependencies dependencies = new Dependencies( parent ); Collection foo = new ArrayList( ); dependencies.satisfyDependency( foo ); parent.satisfyDependency( new ArrayList()); // When Collection instance = dependencies.resolveDependency( Collection.class ); // Then assertThat(instance, equalTo(foo)); }
@Test void shouldNotSupportMultipleProvidersWithSameDescriptor() { // given IndexProviderDescriptor descriptor = new IndexProviderDescriptor( "provider", "1.2" ); IndexProvider provider1 = mock( IndexProvider.class ); when( provider1.getProviderDescriptor() ).thenReturn( descriptor ); IndexProvider provider2 = mock( IndexProvider.class ); when( provider2.getProviderDescriptor() ).thenReturn( descriptor ); Dependencies dependencies = new Dependencies(); dependencies.satisfyDependency( provider1 ); dependencies.satisfyDependency( provider2 ); // when assertThrows( IllegalArgumentException.class, () -> createDefaultProviderMap( dependencies, descriptor ).init() ); }
@Test public void givenSatisfiedTypeWhenResolveWithSuperTypeThenInstanceReturned() { // Given Dependencies dependencies = new Dependencies( ); AbstractList foo = new ArrayList( ); dependencies.satisfyDependency( foo ); // When AbstractList instance = dependencies.resolveDependency( AbstractList.class ); // Then assertThat(instance, equalTo(foo)); }
@Test public void givenSatisfiedTypeWhenResolveWithInterfaceThenInstanceReturned() { // Given Dependencies dependencies = new Dependencies( ); List foo = new ArrayList( ); dependencies.satisfyDependency( foo ); // When List instance = dependencies.resolveDependency( List.class ); // Then assertThat(instance, equalTo(foo)); }
@Test public void givenSatisfiedTypeWhenResolveWithSubInterfaceThenInstanceReturned() { // Given Dependencies dependencies = new Dependencies( ); Collection foo = new ArrayList( ); dependencies.satisfyDependency( foo ); // When Collection instance = dependencies.resolveDependency( Collection.class ); // Then assertThat(instance, equalTo(foo)); }
@Override public void init() { for ( KernelExtensionFactory<?> kernelExtensionFactory : kernelExtensionFactories ) { try { Object kernelExtensionDependencies = getKernelExtensionDependencies( kernelExtensionFactory ); Lifecycle dependency = newInstance( kernelContext, kernelExtensionFactory, kernelExtensionDependencies ); Objects.requireNonNull( dependency, kernelExtensionFactory.toString() + " returned a null KernelExtension" ); life.add( dependencies.satisfyDependency( dependency ) ); } catch ( UnsatisfiedDependencyException exception ) { kernelExtensionFailureStrategy.handle( kernelExtensionFactory, exception ); } catch ( Throwable throwable ) { kernelExtensionFailureStrategy.handle( kernelExtensionFactory, throwable ); } } life.init(); }
@Test public void givenSatisfiedTypeWhenResolveWithTypeThenInstanceReturned() { // Given Dependencies dependencies = new Dependencies( ); String foo = "foo"; dependencies.satisfyDependency( foo ); // When String instance = dependencies.resolveDependency( String.class ); // Then assertThat(instance, equalTo(foo)); }
@Test public void givenSatisfiedTypeInParentWhenResolveWithTypeInEmptyDependenciesThenInstanceReturned() { // Given Dependencies parent = new Dependencies( ); Dependencies dependencies = new Dependencies( parent ); Collection foo = new ArrayList( ); dependencies.satisfyDependency( foo ); // When Collection instance = dependencies.resolveDependency( Collection.class ); // Then assertThat(instance, equalTo(foo)); }
@Test public void flushOfThePageCacheOnShutdownDoesNotHappenIfTheDbIsUnhealthy() throws Throwable { DatabaseHealth health = mock( DatabaseHealth.class ); when( health.isHealthy() ).thenReturn( false ); PageCache pageCache = spy( pageCacheRule.getPageCache( fs.get() ) ); Dependencies dependencies = new Dependencies(); dependencies.satisfyDependency( health ); NeoStoreDataSource ds = dsRule.getDataSource( dir.databaseLayout(), fs.get(), pageCache, dependencies ); ds.start(); verify( pageCache, never() ).flushAndForce(); ds.stop(); ds.shutdown(); verify( pageCache, never() ).flushAndForce( IOLimiter.UNLIMITED ); }
private LifeSupport initializeExtensions( Dependencies dependencies ) { LifeSupport extensionsLife = new LifeSupport(); extensionsLife.add( new DatabaseKernelExtensions( new SimpleKernelContext( databaseLayout.databaseDirectory(), databaseInfo, dependencies ), kernelExtensionFactories, dependencies, fail() ) ); indexProviderMap = extensionsLife.add( new DefaultIndexProviderMap( dependencies, config ) ); dependencies.satisfyDependency( indexProviderMap ); extensionsLife.init(); return extensionsLife; }
@Test void shouldThrowOnLookupOnUnknownProvider() { // given IndexProvider provider = mock( IndexProvider.class ); IndexProviderDescriptor descriptor = new IndexProviderDescriptor( "provider", "1.2" ); when( provider.getProviderDescriptor() ).thenReturn( descriptor ); Dependencies dependencies = new Dependencies(); dependencies.satisfyDependency( provider ); // when DefaultIndexProviderMap defaultIndexProviderMap = createDefaultProviderMap( dependencies, descriptor ); defaultIndexProviderMap.init(); assertThrows( IndexProviderNotFoundException.class, () -> defaultIndexProviderMap.lookup( new IndexProviderDescriptor( "provider2", "1.2" ) ) ); }
@Override protected QueryExecutionEngine createEngine( Dependencies deps, GraphDatabaseAPI graphAPI ) { GraphDatabaseCypherService queryService = new GraphDatabaseCypherService( graphAPI ); deps.satisfyDependency( queryService ); DependencyResolver resolver = graphAPI.getDependencyResolver(); LogService logService = resolver.resolveDependency( LogService.class ); Monitors monitors = resolver.resolveDependency( Monitors.class ); Config config = resolver.resolveDependency( Config.class ); CypherConfiguration cypherConfig = CypherConfiguration.fromConfig( config ); CypherPlannerConfiguration plannerConfig = cypherConfig.toCypherPlannerConfiguration( config ); CypherRuntimeConfiguration runtimeConfig = cypherConfig.toCypherRuntimeConfiguration(); LogProvider logProvider = logService.getInternalLogProvider(); CommunityCompilerFactory compilerFactory = new CommunityCompilerFactory( queryService, monitors, logProvider, plannerConfig, runtimeConfig ); deps.satisfyDependencies( compilerFactory ); return createEngine( queryService, config, logProvider, compilerFactory ); }
@Test public void buildDefaultContextWithDependencies() throws IOException { SimpleLogVersionRepository logVersionRepository = new SimpleLogVersionRepository( 2 ); SimpleTransactionIdStore transactionIdStore = new SimpleTransactionIdStore(); Dependencies dependencies = new Dependencies(); dependencies.satisfyDependency( logVersionRepository ); dependencies.satisfyDependency( transactionIdStore ); TransactionLogFilesContext context = builder( testDirectory.databaseLayout(), fileSystem ).withDependencies( dependencies ).buildContext(); assertEquals( fileSystem, context.getFileSystem() ); assertNotNull( context.getLogEntryReader() ); assertSame( LogFileCreationMonitor.NO_MONITOR, context.getLogFileCreationMonitor() ); assertEquals( ByteUnit.mebiBytes( 250 ), context.getRotationThreshold().get() ); assertEquals( 1, context.getLastCommittedTransactionId() ); assertEquals( 2, context.getLogVersionRepository().getCurrentLogVersion() ); }
@Test public void databaseHealthShouldBeHealedOnStart() throws Throwable { NeoStoreDataSource theDataSource = null; try { DatabaseHealth databaseHealth = new DatabaseHealth( mock( DatabasePanicEventGenerator.class ), NullLogProvider.getInstance().getLog( DatabaseHealth.class ) ); Dependencies dependencies = new Dependencies(); dependencies.satisfyDependency( databaseHealth ); theDataSource = dsRule.getDataSource( dir.databaseLayout(), fs.get(), pageCacheRule.getPageCache( fs.get() ), dependencies ); databaseHealth.panic( new Throwable() ); theDataSource.start(); databaseHealth.assertHealthy( Throwable.class ); } finally { if ( theDataSource != null ) { theDataSource.stop(); theDataSource.shutdown(); } } }
private void initializeStores( DatabaseLayout databaseLayout, Map<String,String> additionalConfig ) throws IOException { Dependencies dependencies = new Dependencies(); dependencies.satisfyDependency( Config.defaults( additionalConfig ) ); ds = dsRule.getDataSource( databaseLayout, fs.get(), pageCache, dependencies ); ds.start(); NeoStores neoStores = ds.getDependencyResolver() .resolveDependency( RecordStorageEngine.class ).testAccessNeoStores(); pStore = neoStores.getPropertyStore(); rtStore = neoStores.getRelationshipTypeTokenStore(); relStore = neoStores.getRelationshipStore(); nodeStore = neoStores.getNodeStore(); storageReader = ds.getDependencyResolver().resolveDependency( StorageEngine.class ).newReader(); }