/** * Open {@link NeoStores} with all possible stores. If some store does not exist it will <b>not</b> be created. * @return container with all opened stores */ public NeoStores openAllNeoStores() { return openNeoStores( false, StoreType.values() ); }
/** * Open {@link NeoStores} with all possible stores with a possibility to create store if it not exist. * @param createStoreIfNotExists - should store be created if it's not exist * @return container with all opened stores */ public NeoStores openAllNeoStores( boolean createStoreIfNotExists ) { return openNeoStores( createStoreIfNotExists, StoreType.values() ); }
MappedFileCounter( DatabaseLayout layout ) { this.layout = layout; mappedCandidates = Arrays.stream( StoreType.values() ) .filter( StoreType::isRecordStore ) .map( StoreType::getDatabaseFile ) .flatMap( layout::file ) .collect( toList() ); mappedIndexFilter = new NativeIndexFileFilter( layout.databaseDirectory() ); }
/** * Determine type of a store base on provided database file. * * @param databaseFile - database file to map * @return an {@link Optional} that wraps the matching store type of the specified file, * or {@link Optional#empty()} if the given file name does not match any store files. */ public static Optional<StoreType> typeOf( DatabaseFile databaseFile ) { Objects.requireNonNull( databaseFile ); StoreType[] values = StoreType.values(); for ( StoreType value : values ) { if ( value.getDatabaseFile().equals( databaseFile ) ) { return Optional.of( value ); } } return Optional.empty(); } }
@Override public void close() { for ( StoreType type : StoreType.values() ) { IdSequence generator = idGenerator( type ); if ( generator instanceof RenewableBatchIdSequence ) { ((RenewableBatchIdSequence)generator).close(); } } } }
private void deleteStoreFiles( DatabaseLayout databaseLayout, Predicate<StoreType> storesToKeep ) { for ( StoreType type : StoreType.values() ) { if ( type.isRecordStore() && !storesToKeep.test( type ) ) { DatabaseFile databaseFile = type.getDatabaseFile(); databaseLayout.file( databaseFile ).forEach( fileSystem::deleteFile ); databaseLayout.idFile( databaseFile ).ifPresent( fileSystem::deleteFile ); } } }
private long sumStoreFiles( DatabaseLayout databaseLayout ) { long total = 0; for ( StoreType type : StoreType.values() ) { if ( type.isRecordStore() ) { FileSystemAbstraction fileSystem = outsideWorld.fileSystem(); total += databaseLayout.file( type.getDatabaseFile() ).filter( fileSystem::fileExists ).mapToLong( fileSystem::getFileSize ).sum(); } } return total; }
private StoreType[] relevantRecordStores() { return Stream.of( StoreType.values() ) .filter( type -> type.isRecordStore() && type != StoreType.META_DATA ).toArray( StoreType[]::new ); }
@Override public Collection<StoreFileMetadata> listStorageFiles() { List<StoreFileMetadata> files = new ArrayList<>(); for ( StoreType type : StoreType.values() ) { if ( type.equals( StoreType.COUNTS ) ) { addCountStoreFiles( files ); } else { final RecordStore<AbstractBaseRecord> recordStore = neoStores.getRecordStore( type ); StoreFileMetadata metadata = new StoreFileMetadata( recordStore.getStorageFile(), recordStore.getRecordSize() ); files.add( metadata ); } } return files; }
private void manuallyCountTotalMappedFileSize( File dir, MutableLong result, NativeIndexFileFilter nativeIndexFilter ) { Set<String> storeFiles = Stream.of( StoreType.values() ).filter( StoreType::isRecordStore ).map( type -> type.getDatabaseFile().getName() ).collect( Collectors.toSet() ); for ( File file : dir.listFiles() ) { if ( file.isDirectory() ) { manuallyCountTotalMappedFileSize( file, result, nativeIndexFilter ); } else if ( storeFiles.contains( file.getName() ) || file.getName().equals( DatabaseFile.LABEL_SCAN_STORE.getName() ) || nativeIndexFilter.accept( file ) ) { result.add( file.length() ); } } }
public RenewableBatchIdSequences( NeoStores stores, int batchSize ) { for ( StoreType type : StoreType.values() ) { if ( type.isRecordStore() ) { RecordStore<AbstractBaseRecord> store = stores.getRecordStore( type ); if ( type.isLimitedIdStore() || batchSize == 1 ) { // This is a token store or otherwise meta-data store, so let's not add batching for it types[type.ordinal()] = store; } else { // This is a normal record store where id batching is beneficial types[type.ordinal()] = new RenewableBatchIdSequence( store, batchSize, store::freeId ); } } } }
stores = new Object[StoreType.values().length]; try
public void flushAndForce() { if ( propertyKeyRepository != null ) { propertyKeyRepository.flush(); } if ( labelRepository != null ) { labelRepository.flush(); } if ( relationshipTypeRepository != null ) { relationshipTypeRepository.flush(); } if ( neoStores != null ) { neoStores.flush( UNLIMITED ); flushIdFiles( neoStores, StoreType.values() ); } if ( temporaryNeoStores != null ) { temporaryNeoStores.flush( UNLIMITED ); flushIdFiles( temporaryNeoStores, TEMP_STORE_TYPES ); } if ( labelScanStore != null ) { labelScanStore.force( UNLIMITED ); } }
private static long[] calculatePageCacheFileSize( DatabaseLayout databaseLayout ) throws IOException { MutableLong pageCacheTotal = new MutableLong(); MutableLong luceneTotal = new MutableLong(); for ( StoreType storeType : StoreType.values() ) { if ( storeType.isRecordStore() ) { long length = databaseLayout.file( storeType.getDatabaseFile() ).mapToLong( File::length ).sum(); pageCacheTotal.add( length ); } } Files.walkFileTree( IndexDirectoryStructure.baseSchemaIndexFolder( databaseLayout.databaseDirectory() ).toPath(), new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile( Path path, BasicFileAttributes attrs ) { File file = path.toFile(); Path name = path.getName( path.getNameCount() - 3 ); boolean isLuceneFile = (path.getNameCount() >= 3 && name.toString().startsWith( "lucene-" )) || (path.getNameCount() >= 4 && path.getName( path.getNameCount() - 4 ).toString().equals( "lucene" )); if ( !FailureStorage.DEFAULT_FAILURE_FILE_NAME.equals( file.getName() ) ) { (isLuceneFile ? luceneTotal : pageCacheTotal).add( file.length() ); } return FileVisitResult.CONTINUE; } } ); return new long[]{pageCacheTotal.longValue(), luceneTotal.longValue()}; }
for ( StoreType storeType : StoreType.values() )
private void shouldPrintReferenceLinkAsPartOfErrorMessage( List<String> nodeIds, Iterator<RelationshipDataLine> relationshipDataLines, String message ) { Configuration config = Configuration.COMMAS; try { // WHEN importTool( "--into", dbRule.getDatabaseDirAbsolutePath(), "--nodes", nodeData( true, config, nodeIds, TRUE ).getAbsolutePath(), "--skip-bad-relationships", "false", "--relationships", relationshipData( true, config, relationshipDataLines, TRUE, true ).getAbsolutePath() ); fail( " Should fail during import." ); } catch ( Exception e ) { // EXPECT assertTrue( suppressOutput.getErrorVoice().containsMessage( message ) ); } for ( StoreType storeType : StoreType.values() ) { if ( storeType.isRecordStore() ) { dbRule.databaseLayout().file( storeType.getDatabaseFile() ).forEach( File::delete ); } } }
@Test public void isPresentFalseAfterCreatingAllButLastStoreType() throws Exception { // given FileSystemAbstraction fileSystem = fs.get(); fileSystem.deleteRecursively( databaseLayout.databaseDirectory() ); DefaultIdGeneratorFactory idFactory = new DefaultIdGeneratorFactory( fileSystem ); StoreFactory factory = new StoreFactory( databaseLayout, Config.defaults(), idFactory, pageCache, fileSystem, LOG_PROVIDER, EmptyVersionContextSupplier.EMPTY ); StoreType[] allStoreTypes = StoreType.values(); StoreType[] allButLastStoreTypes = Arrays.copyOf( allStoreTypes, allStoreTypes.length - 1 ); // when try ( NeoStores ignore = factory.openNeoStores( true, allButLastStoreTypes ) ) { // then assertFalse( NeoStores.isStorePresent( pageCache, databaseLayout ) ); } }
@Test public void shouldDelegateDeletionOptionToStores() { // GIVEN StoreFactory storeFactory = storeFactory( Config.defaults(), DELETE_ON_CLOSE ); // WHEN neoStores = storeFactory.openAllNeoStores( true ); assertTrue( fsRule.get().listFiles( testDirectory.databaseDir() ).length >= StoreType.values().length ); // THEN neoStores.close(); assertEquals( 0, fsRule.get().listFiles( testDirectory.databaseDir() ).length ); }
new RecordFormatPropertyConfigurator( formats, config ).configure(); boolean create = true; StoreType[] storeTypes = StoreType.values(); OpenOption[] openOptions = new OpenOption[0]; NeoStores neoStores = new NeoStores(
private static void assertSameStoreContents( EphemeralFileSystemAbstraction fs1, EphemeralFileSystemAbstraction fs2, DatabaseLayout databaseLayout ) { NullLogProvider logProvider = NullLogProvider.getInstance(); VersionContextSupplier contextSupplier = EmptyVersionContextSupplier.EMPTY; try ( ThreadPoolJobScheduler jobScheduler = new ThreadPoolJobScheduler(); PageCache pageCache1 = new ConfiguringPageCacheFactory( fs1, defaults(), PageCacheTracer.NULL, PageCursorTracerSupplier.NULL, NullLog.getInstance(), contextSupplier, jobScheduler ) .getOrCreatePageCache(); PageCache pageCache2 = new ConfiguringPageCacheFactory( fs2, defaults(), PageCacheTracer.NULL, PageCursorTracerSupplier.NULL, NullLog.getInstance(), contextSupplier, jobScheduler ) .getOrCreatePageCache(); NeoStores store1 = new StoreFactory( databaseLayout, defaults(), new DefaultIdGeneratorFactory( fs1 ), pageCache1, fs1, logProvider, contextSupplier ).openAllNeoStores(); NeoStores store2 = new StoreFactory( databaseLayout, defaults(), new DefaultIdGeneratorFactory( fs2 ), pageCache2, fs2, logProvider, contextSupplier ).openAllNeoStores() ) { for ( StoreType storeType : StoreType.values() ) { if ( storeType.isRecordStore() ) { assertSameStoreContents( store1.getRecordStore( storeType ), store2.getRecordStore( storeType ) ); } } } }