@Before public void before() { FileSystemAbstraction fs = fileSystemRule.get(); DefaultIdGeneratorFactory idGeneratorFactory = new DefaultIdGeneratorFactory( fs ); PageCache pageCache = pageCacheRule.getPageCache( fs ); StoreFactory factory = new StoreFactory( testDirectory.databaseLayout(), Config.defaults(), idGeneratorFactory, pageCache, fs, NullLogProvider.getInstance(), EmptyVersionContextSupplier.EMPTY ); neoStores = factory.openAllNeoStores( true ); arrayStore = neoStores.getPropertyStore().getArrayStore(); }
private void truncateBytesFromLastLogFile( long bytesToTrim ) throws IOException { File highestLogFile = logFiles.getHighestLogFile(); long fileSize = fileSystemRule.getFileSize( highestLogFile ); if ( bytesToTrim > fileSize ) { fileSystemRule.deleteFile( highestLogFile ); } else { fileSystemRule.truncate( highestLogFile, fileSize - bytesToTrim ); } }
@Before public void setUp() throws Exception { databaseLayout = testDirectory.databaseLayout(); storeDir = databaseLayout.databaseDirectory(); nativeLabelIndex = databaseLayout.labelScanStore(); migrationLayout = testDirectory.databaseLayout( "migrationDir" ); luceneLabelScanStore = testDirectory.databaseDir().toPath().resolve( Paths.get( "schema", "label", "lucene" ) ).toFile(); fileSystem = fileSystemRule.get(); pageCache = pageCacheRule.getPageCache( fileSystemRule ); indexMigrator = new NativeLabelScanStoreMigrator( fileSystem, pageCache, Config.defaults() ); fileSystem.mkdirs( luceneLabelScanStore ); }
@Before public void setup() throws IOException { fileSystem = fileSystemRule.get(); PageCache pageCache = pageCacheRule.getPageCache( fileSystem ); workingStoreDir = testDir.storeDir( "working_" + version ); workingDatabaseLayout = testDir.databaseLayout( workingStoreDir ); check = new StoreVersionCheck( pageCache ); File prepareDirectory = testDir.directory( "prepare_" + version ); prepareSampleLegacyDatabase( version, fileSystem, workingDatabaseLayout.databaseDirectory(), prepareDirectory ); }
@Before public void setUp() { indexStore = new IndexConfigStore( directory.databaseLayout(), fileSystemRule.get() ); addIndex( "foo" ); }
@Before public void start() throws IOException { jobScheduler = new ThreadPoolJobScheduler(); stores = BatchingNeoStores.batchingNeoStores( fileSystemRule.get(), directory.absolutePath(), format, CONFIG, NullLogService.getInstance(), AdditionalInitialIds.EMPTY, Config.defaults(), jobScheduler ); stores.createNew(); }
@Before public void setUp() { File folder = testDir.directory( "folder" ); indexStorage = new PartitionedIndexStorage( directoryFactory, fileSystemRule.get(), folder ); index = LuceneSchemaIndexBuilder.create( descriptor, Config.defaults() ) .withIndexStorage( indexStorage ) .build(); schemaDescriptor = descriptor.schema(); }
@Before public void setUp() throws Exception { storeDir = directory.storeDir(); logFiles = LogFilesBuilder.builder( directory.databaseLayout(), fileSystemRule.get() ) .withLogVersionRepository( logVersionRepository ) .withTransactionIdStore( transactionIdStore ) .build(); }
@Before public void setup() throws IOException { valueCreatorUtil = createValueCreatorUtil(); indexDescriptor = valueCreatorUtil.indexDescriptor(); layout = createLayout(); indexDirectoryStructure = directoriesByProvider( directory.directory( "root" ) ).forProvider( indexDescriptor.providerDescriptor() ); indexFile = indexDirectoryStructure.directoryForIndex( indexDescriptor.getId() ); fs.mkdirs( indexFile.getParentFile() ); pageCache = pageCacheRule.getPageCache( fs ); }
@Before public void setup() { DefaultFileSystemAbstraction fs = this.fs.get(); PageCache pc = pageCacheRule.getPageCache( fs ); File file = directory.file( "index" ); GenericLayout layout = new GenericLayout( 1, indexSettings ); RecoveryCleanupWorkCollector collector = RecoveryCleanupWorkCollector.ignore(); descriptor = TestIndexDescriptorFactory.forLabel( 1, 1 ).withId( 1 ); IndexDirectoryStructure.Factory factory = IndexDirectoryStructure.directoriesByProvider( directory.storeDir() ); IndexDirectoryStructure structure = factory.forProvider( GenericNativeIndexProvider.DESCRIPTOR ); accessor = new GenericNativeIndexAccessor( pc, fs, file, layout, collector, EMPTY, descriptor, indexSettings, structure, new StandardConfiguration() ); }
private StoreFactory newStoreFactory( PageCache pageCache ) { FileSystemAbstraction fileSystem = fileSystemRule.get(); return new StoreFactory( directory.databaseLayout(), getTuningConfiguration(), new DefaultIdGeneratorFactory( fileSystem ), pageCache, fileSystem, NullLogProvider.getInstance(), EmptyVersionContextSupplier.EMPTY ); }
private void setupIndexInfrastructure() throws Exception { DatabaseLayout databaseLayout = testDirectory.databaseLayout(); indexStore = new IndexConfigStore( databaseLayout, fileSystemRule.get() ); indexStore.set( Node.class, INDEX_NAME, MapUtil.stringMap( IndexManager.PROVIDER, "lucene", "type", "fulltext" ) ); LuceneDataSource luceneDataSource = new LuceneDataSource( databaseLayout, Config.defaults(), indexStore, fileSystemRule.get(), OperationalMode.single ); try { luceneDataSource.init(); luceneDataSource.getIndexSearcher( indexIdentifier ); } finally { luceneDataSource.shutdown(); } }
private BatchInserter newBatchInserter() throws Exception { return BatchInserters.inserter( localTestDirectory.databaseDir(), fileSystemRule.get(), configuration() ); }
private void extractTransactionalInformationFromLogs( String path, File customLogLocation, DatabaseLayout databaseLayout, File storeDir ) throws IOException { LogService logService = new SimpleLogService( NullLogProvider.getInstance(), NullLogProvider.getInstance() ); File neoStore = databaseLayout.metadataStore(); GraphDatabaseService database = new TestGraphDatabaseFactory().newEmbeddedDatabaseBuilder( storeDir ) .setConfig( logical_logs_location, path ).newGraphDatabase(); for ( int i = 0; i < 10; i++ ) { try ( Transaction transaction = database.beginTx() ) { Node node = database.createNode(); transaction.success(); } } database.shutdown(); MetaDataStore.setRecord( pageCache, neoStore, MetaDataStore.Position.LAST_CLOSED_TRANSACTION_LOG_VERSION, MetaDataRecordFormat.FIELD_NOT_PRESENT ); Config config = Config.defaults( logical_logs_location, path ); StoreMigrator migrator = new StoreMigrator( fileSystemRule.get(), pageCache, config, logService, jobScheduler ); LogPosition logPosition = migrator.extractTransactionLogPosition( neoStore, databaseLayout, 100 ); File[] logFiles = customLogLocation.listFiles(); assertNotNull( logFiles ); assertEquals( 0, logPosition.getLogVersion() ); assertEquals( logFiles[0].length(), logPosition.getByteOffset() ); }
Kernel( String desiredId ) { super( fileSystemRule.get(), pageCacheRule.getPageCache( fileSystemRule.get() ), new File( GraphDatabaseSettings.DEFAULT_DATABASE_NAME ), Config.defaults( forced_kernel_id, desiredId), mock( DataSourceManager.class ) ); kernels.add( this ); }
private void setupIndexInfrastructure() { indexStore = new IndexConfigStore( testDirectory.databaseLayout(), fileSystemRule.get() ); indexStore.set( Node.class, INDEX_NAME, MapUtil.stringMap( IndexManager.PROVIDER, "lucene", "type", "fulltext" ) ); } }
@Test public void shouldThrowClosedChannelExceptionWhenChannelUnexpectedlyClosed() throws Exception { // GIVEN final File file = new File( directory.directory(), "file" ); StoreChannel storeChannel = fileSystemRule.get().open( file, OpenMode.READ_WRITE ); PhysicalLogVersionedStoreChannel versionedStoreChannel = new PhysicalLogVersionedStoreChannel( storeChannel, 1, (byte) -1 /* ignored */ ); PhysicalFlushableChannel channel = new PhysicalFlushableChannel( versionedStoreChannel ); // just close the underlying channel storeChannel.close(); // WHEN just appending something to the buffer channel.put( (byte) 0 ); // and wanting to empty that into the channel try { channel.prepareForFlush(); fail( "Should have thrown exception" ); } catch ( ClosedChannelException e ) { // THEN we should get a ClosedChannelException } }
private void prepareNeoStoreFile( String storeVersion ) throws IOException { File neoStoreFile = createNeoStoreFile(); long value = MetaDataStore.versionStringToLong( storeVersion ); try ( PageCache pageCache = pageCacheRule.getPageCache( fsRule.get() ) ) { MetaDataStore.setRecord( pageCache, neoStoreFile, STORE_VERSION, value ); } }