private void FlushNeoStoreOnly() { NeoStores neoStores = (( GraphDatabaseAPI )_db).DependencyResolver.resolveDependency(typeof(RecordStorageEngine)).testAccessNeoStores(); MetaDataStore metaDataStore = neoStores.MetaDataStore; metaDataStore.Flush(); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void prepareNeoStoreFile(String storeVersion) throws java.io.IOException private void PrepareNeoStoreFile(string storeVersion) { File neoStoreFile = CreateNeoStoreFile(); long value = MetaDataStore.versionStringToLong(storeVersion); MetaDataStore.setRecord(PageCacheRule.getPageCache(FsRule.get()), neoStoreFile, STORE_VERSION, value); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void extractTransactionalInformationFromLogs(String path, java.io.File customLogLocation, org.neo4j.io.layout.DatabaseLayout databaseLayout, java.io.File storeDir) throws java.io.IOException private void ExtractTransactionalInformationFromLogs(string path, File customLogLocation, DatabaseLayout databaseLayout, File storeDir) { LogService logService = new SimpleLogService(NullLogProvider.Instance, NullLogProvider.Instance); File neoStore = databaseLayout.MetadataStore(); GraphDatabaseService database = (new TestGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(storeDir).setConfig(logical_logs_location, path).newGraphDatabase(); for (int i = 0; i < 10; i++) { using (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.LogVersion); assertEquals(logFiles[0].length(), logPosition.ByteOffset); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static long readLogVersion(org.neo4j.io.pagecache.PageCache pageCache, java.io.File neoStore) throws java.io.IOException private static long ReadLogVersion(PageCache pageCache, File neoStore) { try { return(MetaDataStore.getRecord(pageCache, neoStore, MetaDataStore.Position.LOG_VERSION)); } catch (NoSuchFileException) { return(0); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldWriteNewFileWhenExistingFileHasZeroLength() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldWriteNewFileWhenExistingFileHasZeroLength() { // Given _file.createNewFile(); // When IndexProviderStore store = new IndexProviderStore(_file, _fileSystem, MetaDataStore.versionStringToLong("3.5"), false); // Then assertTrue(_fileSystem.getFileSize(_file) > 0); store.Close(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(expected = IllegalArgumentException.class) public void shouldThrowWhenTryingToCreateFileThatAlreadyExists() public virtual void ShouldThrowWhenTryingToCreateFileThatAlreadyExists() { // Given FileSystemAbstraction fs = mock(typeof(FileSystemAbstraction)); when(fs.FileExists(_file)).thenReturn(false).thenReturn(true); when(fs.GetFileSize(_file)).thenReturn(42L); // When new IndexProviderStore(_file, fs, MetaDataStore.versionStringToLong("3.5"), false); // Then // exception is thrown }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldPropagateIOExceptions() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldPropagateIOExceptions() { // Given TransactionFailureException exceptionThrown = null; File storeDir = TestDirectory.storeDir(); LimitedFileSystemGraphDatabase db = new LimitedFileSystemGraphDatabase(storeDir); using (Transaction tx = Db.beginTx()) { Db.createNode(); tx.Success(); } long logVersion = Db.DependencyResolver.resolveDependency(typeof(LogVersionRepository)).CurrentLogVersion; Db.runOutOfDiskSpaceNao(); // When try { using (Transaction tx = Db.beginTx()) { Db.createNode(); tx.Success(); } } catch (TransactionFailureException e) { exceptionThrown = e; } finally { assertNotNull("Expected tx finish to throw TransactionFailureException when filesystem is full.", exceptionThrown); assertTrue(Exceptions.contains(exceptionThrown, typeof(IOException))); } Db.somehowGainMoreDiskSpace(); // to help shutting down the db Db.shutdown(); PageCache pageCache = PageCacheRule.getPageCache(Db.FileSystem); File neoStore = TestDirectory.databaseLayout().metadataStore(); assertEquals(logVersion, MetaDataStore.getRecord(pageCache, neoStore, MetaDataStore.Position.LOG_VERSION)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(expected = org.neo4j.kernel.impl.store.NotCurrentStoreVersionException.class) public void shouldFailToGoBackToOlderVersionEvenIfAllowUpgrade() public virtual void ShouldFailToGoBackToOlderVersionEvenIfAllowUpgrade() { string newerVersion = "3.5"; string olderVersion = "3.1"; try { IndexProviderStore store = new IndexProviderStore(_file, _fileSystem, MetaDataStore.versionStringToLong(newerVersion), true); store.Close(); store = new IndexProviderStore(_file, _fileSystem, MetaDataStore.versionStringToLong(olderVersion), true); } catch (NotCurrentStoreVersionException e) { assertTrue(e.Message.contains(newerVersion)); assertTrue(e.Message.contains(olderVersion)); throw e; } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReportFileWithCorrectVersion() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldReportFileWithCorrectVersion() { // given File neoStore = EmptyFile(_fileSystemRule.get()); long v1 = MetaDataStore.versionStringToLong("V1"); PageCache pageCache = _pageCacheRule.getPageCache(_fileSystemRule.get()); MetaDataStore.setRecord(pageCache, neoStore, MetaDataStore.Position.STORE_VERSION, v1); StoreVersionCheck storeVersionCheck = new StoreVersionCheck(pageCache); // when StoreVersionCheck.Result result = storeVersionCheck.HasVersion(neoStore, "V1"); // then assertTrue(result.Outcome.Successful); assertEquals(StoreVersionCheck.Result.Outcome.Ok, result.Outcome); assertNull(result.ActualVersion); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldFailUpgradeIfNotAllowed() public virtual void ShouldFailUpgradeIfNotAllowed() { IndexProviderStore store = new IndexProviderStore(_file, _fileSystem, MetaDataStore.versionStringToLong("3.1"), true); store.Close(); store = new IndexProviderStore(_file, _fileSystem, MetaDataStore.versionStringToLong("3.1"), false); store.Close(); try { new IndexProviderStore(_file, _fileSystem, MetaDataStore.versionStringToLong("3.5"), false); fail("Shouldn't be able to upgrade there"); } catch (UpgradeNotAllowedByConfigurationException) { // Good } store = new IndexProviderStore(_file, _fileSystem, MetaDataStore.versionStringToLong("3.5"), true); assertEquals("3.5", MetaDataStore.versionLongToString(store.IndexVersion)); store.Close(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldForceChannelAfterWritingMetadata() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldForceChannelAfterWritingMetadata() { // Given //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.io.fs.StoreChannel[] channelUsedToCreateFile = {null}; StoreChannel[] channelUsedToCreateFile = new StoreChannel[] { null }; FileSystemAbstraction fs = spy(_fileSystem); StoreChannel tempChannel; when(tempChannel = fs.Open(_file, OpenMode.READ_WRITE)).then(ignored => { StoreChannel channel = _fileSystem.open(_file, OpenMode.READ_WRITE); if (channelUsedToCreateFile[0] == null) { StoreChannel channelSpy = spy(channel); channelUsedToCreateFile[0] = channelSpy; channel = channelSpy; } return(channel); }); // Doing the FSA spying above, calling fs.open, actually invokes that method and so a channel // is opened. We put that in tempChannel and close it before deleting the file below. tempChannel.close(); fs.DeleteFile(_file); // When IndexProviderStore store = new IndexProviderStore(_file, fs, MetaDataStore.versionStringToLong("3.5"), false); // Then StoreChannel channel = channelUsedToCreateFile[0]; verify(channel).writeAll(any(typeof(ByteBuffer)), eq(0L)); verify(channel).force(true); verify(channel).close(); verifyNoMoreInteractions(channel); store.Close(); }
public static StoreId NewStoreIdForCurrentVersion(long creationTime, long randomId, long upgradeTime, long upgradeId) { return(new StoreId(creationTime, randomId, MetaDataStore.versionStringToLong(_format.storeVersion()), upgradeTime, upgradeId)); }
private static long CurrentStoreVersionAsLong() { return(MetaDataStore.versionStringToLong(_format.storeVersion())); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldStopDatabaseWhenOutOfDiskSpace() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldStopDatabaseWhenOutOfDiskSpace() { // Given TransactionFailureException expectedCommitException = null; TransactionFailureException expectedStartException = null; File storeDir = TestDirectory.absolutePath(); LimitedFileSystemGraphDatabase db = Cleanup.add(new LimitedFileSystemGraphDatabase(storeDir)); using (Transaction tx = Db.beginTx()) { Db.createNode(); tx.Success(); } long logVersion = Db.DependencyResolver.resolveDependency(typeof(LogVersionRepository)).CurrentLogVersion; Db.runOutOfDiskSpaceNao(); try { using (Transaction tx = Db.beginTx()) { Db.createNode(); tx.Success(); } } catch (TransactionFailureException e) { expectedCommitException = e; } finally { assertNotNull("Expected tx finish to throw TransactionFailureException when filesystem is full.", expectedCommitException); } // When try { using (Transaction transaction = Db.beginTx()) { fail("Expected tx begin to throw TransactionFailureException when tx manager breaks."); } } catch (TransactionFailureException e) { expectedStartException = e; } finally { assertNotNull("Expected tx begin to throw TransactionFailureException when tx manager breaks.", expectedStartException); } // Then Db.somehowGainMoreDiskSpace(); // to help shutting down the db Db.shutdown(); PageCache pageCache = PageCacheRule.getPageCache(Db.FileSystem); File neoStore = TestDirectory.databaseLayout().metadataStore(); assertEquals(logVersion, MetaDataStore.getRecord(pageCache, neoStore, MetaDataStore.Position.LOG_VERSION)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void prepareEmpty23Database() throws java.io.IOException private void PrepareEmpty23Database() { (new TestGraphDatabaseFactory()).newEmbeddedDatabase(_storeDir).shutdown(); _fileSystem.deleteFile(_nativeLabelIndex); MetaDataStore.setRecord(_pageCache, _databaseLayout.metadataStore(), MetaDataStore.Position.STORE_VERSION, versionStringToLong(StandardV2_3.STORE_VERSION)); }