//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static Exception executeFailingTransaction(RecordStorageEngine engine) throws java.io.IOException private static Exception ExecuteFailingTransaction(RecordStorageEngine engine) { Exception applicationError = new UnderlyingStorageException("No space left on device"); TransactionToApply txToApply = NewTransactionThatFailsWith(applicationError); try { engine.Apply(txToApply, TransactionApplicationMode.INTERNAL); fail("Exception expected"); } catch (Exception e) { assertSame(applicationError, Exceptions.rootCause(e)); } return(applicationError); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static org.neo4j.kernel.impl.api.TransactionToApply newTransactionThatFailsWith(Exception error) throws java.io.IOException private static TransactionToApply NewTransactionThatFailsWith(Exception error) { TransactionRepresentation transaction = mock(typeof(TransactionRepresentation)); when(transaction.AdditionalHeader()).thenReturn(new sbyte[0]); // allow to build validated index updates but fail on actual tx application doThrow(error).when(transaction).accept(any()); long txId = ThreadLocalRandom.current().nextLong(0, 1000); TransactionToApply txToApply = new TransactionToApply(transaction); FakeCommitment commitment = new FakeCommitment(txId, mock(typeof(TransactionIdStore))); commitment.HasExplicitIndexChanges = false; txToApply.Commitment(commitment, txId); return(txToApply); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void queue(TransactionToApply transaction) throws Exception public virtual void Queue(TransactionToApply transaction) { if (Empty) { _first = _last = transaction; } else { _last.next(transaction); _last = transaction; } if (++_size == _maxSize) { Empty(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldRegisterIndexesToActivateIntoTheActivator() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldRegisterIndexesToActivateIntoTheActivator() { // given IndexingService indexing = mock(typeof(IndexingService)); LabelScanWriter writer = new OrderVerifyingLabelScanWriter(10, 15, 20); WorkSync <System.Func <LabelScanWriter>, LabelUpdateWork> labelScanSync = spy(new WorkSync <System.Func <LabelScanWriter>, LabelUpdateWork>(SingletonProvider(writer))); WorkSync <IndexingUpdateService, IndexUpdatesWork> indexUpdatesSync = new WorkSync <IndexingUpdateService, IndexUpdatesWork>(indexing); PropertyStore propertyStore = mock(typeof(PropertyStore)); TransactionToApply tx = mock(typeof(TransactionToApply)); IndexActivator indexActivator = new IndexActivator(indexing); long indexId1 = 1; long indexId2 = 2; long indexId3 = 3; long constraintId1 = 10; long constraintId2 = 11; long constraintId3 = 12; IndexProviderDescriptor providerDescriptor = new IndexProviderDescriptor("index-key", "v1"); StoreIndexDescriptor rule1 = uniqueForSchema(forLabel(1, 1), providerDescriptor).withIds(indexId1, constraintId1); StoreIndexDescriptor rule2 = uniqueForSchema(forLabel(2, 1), providerDescriptor).withIds(indexId2, constraintId2); StoreIndexDescriptor rule3 = uniqueForSchema(forLabel(3, 1), providerDescriptor).withIds(indexId3, constraintId3); using (IndexBatchTransactionApplier applier = new IndexBatchTransactionApplier(indexing, labelScanSync, indexUpdatesSync, mock(typeof(NodeStore)), mock(typeof(RelationshipStore)), propertyStore, indexActivator)) { using (TransactionApplier txApplier = applier.StartTx(tx)) { // WHEN // activate index 1 txApplier.VisitSchemaRuleCommand(new Command.SchemaRuleCommand(Collections.emptyList(), AsRecords(rule1, true), rule1)); // activate index 2 txApplier.VisitSchemaRuleCommand(new Command.SchemaRuleCommand(Collections.emptyList(), AsRecords(rule2, true), rule2)); // activate index 3 txApplier.VisitSchemaRuleCommand(new Command.SchemaRuleCommand(Collections.emptyList(), AsRecords(rule3, true), rule3)); // drop index 2 txApplier.VisitSchemaRuleCommand(new Command.SchemaRuleCommand(AsRecords(rule2, true), AsRecords(rule2, false), rule2)); } } verify(indexing).dropIndex(rule2); indexActivator.Close(); verify(indexing).activateIndex(indexId1); verify(indexing).activateIndex(indexId3); verifyNoMoreInteractions(indexing); }
public override void ApplyCommand(ReplicatedTransaction replicatedTx, long commandIndex, System.Action <Result> callback) { lock (this) { if (commandIndex <= _lastCommittedIndex) { _log.debug("Ignoring transaction at log index %d since already committed up to %d", commandIndex, _lastCommittedIndex); return; } TransactionRepresentation tx; sbyte[] extraHeader = encodeLogIndexAsTxHeader(commandIndex); tx = ReplicatedTransactionFactory.ExtractTransactionRepresentation(replicatedTx, extraHeader); int currentTokenId = _lockTokenStateMachine.currentToken().id(); int txLockSessionId = tx.LockSessionId; if (currentTokenId != txLockSessionId && txLockSessionId != Org.Neo4j.Kernel.impl.locking.Locks_Client_Fields.NO_LOCK_SESSION_ID) { callback(Result.of(new TransactionFailureException(LockSessionExpired, "The lock session in the cluster has changed: [current lock session id:%d, tx lock session id:%d]", currentTokenId, txLockSessionId))); } else { try { TransactionToApply transaction = new TransactionToApply(tx, _versionContextSupplier.VersionContext); transaction.OnClose(txId => { if (tx.LatestCommittedTxWhenStarted >= txId) { throw new System.InvalidOperationException(format("Out of order transaction. Expected that %d < %d", tx.LatestCommittedTxWhenStarted, txId)); } callback(Result.of(txId)); _commandIndexTracker.AppliedCommandIndex = commandIndex; }); _queue.queue(transaction); } catch (Exception e) { throw PanicException(e); } } } }
public override void Run() { long latestTxId = Org.Neo4j.Kernel.impl.transaction.log.TransactionIdStore_Fields.BASE_TX_ID; while (_condition.AsBoolean) { TransactionToApply transaction = _factory.nextTransaction(latestTxId); try { latestTxId = _transactionAppender.append(transaction, Org.Neo4j.Kernel.impl.transaction.tracing.LogAppendEvent_Fields.Null); } catch (IOException e) { throw new Exception(e); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void verifyIndex(org.neo4j.kernel.impl.api.TransactionToApply tx) throws Exception internal virtual void VerifyIndex(TransactionToApply tx) { using (IndexReader reader = Index.newReader()) { NodeVisitor visitor = new NodeVisitor(); for (int i = 0; tx != null; i++) { tx.TransactionRepresentation().accept(visitor.Clear()); Value propertyValue = propertyValue(Id, Base + i); IndexQuery.ExactPredicate query = IndexQuery.exact(outerInstance.descriptor.PropertyId, propertyValue); LongIterator hits = reader.Query(query); assertEquals("Index doesn't contain " + visitor.NodeId + " " + propertyValue, visitor.NodeId, hits.next()); assertFalse(hits.hasNext()); tx = tx.Next(); } } }
private void MarkUnsafeTransactionsForTermination(TransactionToApply first, TransactionToApply last) { long firstCommittedTimestamp = first.TransactionRepresentation().TimeCommitted; long lastCommittedTimestamp = last.TransactionRepresentation().TimeCommitted; long earliestSafeTimestamp = lastCommittedTimestamp - _idReuseSafeZoneTime; foreach (KernelTransactionHandle txHandle in _kernelTransactions.activeTransactions()) { long commitTimestamp = txHandle.LastTransactionTimestampWhenStarted(); if (commitTimestamp != Org.Neo4j.Kernel.impl.transaction.log.TransactionIdStore_Fields.BASE_TX_COMMIT_TIMESTAMP && commitTimestamp < earliestSafeTimestamp) { if (txHandle.MarkForTermination(Org.Neo4j.Kernel.Api.Exceptions.Status_Transaction.Outdated)) { _log.info("Marking transaction for termination, " + "invalidated due to an upcoming batch of changes being applied:" + "\n" + " Batch: firstCommittedTxId:" + first.TransactionId() + ", firstCommittedTimestamp:" + InformativeTimestamp(firstCommittedTimestamp) + ", lastCommittedTxId:" + last.TransactionId() + ", lastCommittedTimestamp:" + InformativeTimestamp(lastCommittedTimestamp) + ", batchTimeRange:" + InformativeDuration(lastCommittedTimestamp - firstCommittedTimestamp) + ", earliestSafeTimestamp:" + InformativeTimestamp(earliestSafeTimestamp) + ", safeZoneDuration:" + InformativeDuration(_idReuseSafeZoneTime) + "\n" + " Transaction: lastCommittedTimestamp:" + InformativeTimestamp(txHandle.LastTransactionTimestampWhenStarted()) + ", lastCommittedTxId:" + txHandle.LastTransactionIdWhenStarted() + ", localStartTimestamp:" + InformativeTimestamp(txHandle.StartTime())); } } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void assertTransactionsCommitted(long startTxId, long expectedCount) throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException private void AssertTransactionsCommitted(long startTxId, long expectedCount) { ArgumentCaptor <TransactionToApply> batchCaptor = ArgumentCaptor.forClass(typeof(TransactionToApply)); verify(_commitProcess).commit(batchCaptor.capture(), eq(NULL), eq(EXTERNAL)); TransactionToApply batch = Iterables.single(batchCaptor.AllValues); long expectedTxId = startTxId; long count = 0; while (batch != null) { assertEquals(expectedTxId, batch.TransactionId()); expectedTxId++; batch = batch.Next(); count++; } assertEquals(expectedCount, count); }
private static TransactionToApply ToApply(ICollection <TransactionRepresentation> transactions) { TransactionToApply first = null; TransactionToApply last = null; foreach (TransactionRepresentation transactionRepresentation in transactions) { TransactionToApply transaction = new TransactionToApply(transactionRepresentation); if (first == null) { first = last = transaction; } else { last.Next(transaction); last = transaction; } } return(first); }
private TransactionToApply BatchOf(params TransactionRepresentation[] transactions) { TransactionToApply first = null; TransactionToApply last = null; foreach (TransactionRepresentation transaction in transactions) { TransactionToApply tx = new TransactionToApply(transaction); if (first == null) { first = last = tx; } else { last.Next(tx); last = tx; } } return(first); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldKernelPanicIfTransactionIdsMismatch() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldKernelPanicIfTransactionIdsMismatch() { // Given BatchingTransactionAppender appender = Life.add(CreateTransactionAppender()); when(_transactionIdStore.nextCommittingTransactionId()).thenReturn(42L); TransactionToApply batch = new TransactionToApply(mock(typeof(TransactionRepresentation)), 43L); // When try { appender.Append(batch, Org.Neo4j.Kernel.impl.transaction.tracing.LogAppendEvent_Fields.Null); fail("should have thrown "); } catch (System.InvalidOperationException ex) { // Then verify(_databaseHealth, times(1)).panic(ex); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldAppendBatchOfTransactions() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldAppendBatchOfTransactions() { // GIVEN when(_logFile.Writer).thenReturn(_channel); TransactionAppender appender = Life.add(CreateTransactionAppender()); when(_transactionIdStore.nextCommittingTransactionId()).thenReturn(2L, 3L, 4L); TransactionToApply batch = BatchOf(Transaction(SingleCreateNodeCommand(0), new sbyte[0], 0, 0, 0, 1, 0), Transaction(SingleCreateNodeCommand(1), new sbyte[0], 0, 0, 0, 1, 0), Transaction(SingleCreateNodeCommand(2), new sbyte[0], 0, 0, 0, 1, 0)); // WHEN appender.Append(batch, _logAppendEvent); // THEN TransactionToApply tx = batch; assertEquals(2L, tx.TransactionId()); tx = tx.Next(); assertEquals(3L, tx.TransactionId()); tx = tx.Next(); assertEquals(4L, tx.TransactionId()); assertNull(tx.Next()); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private long commit(org.neo4j.kernel.impl.api.TransactionToApply first) throws org.neo4j.internal.kernel.api.exceptions.TransactionFailureException private long Commit(TransactionToApply first) { return(_commitProcess.commit(first, CommitEvent.NULL, EXTERNAL)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public long commit(org.neo4j.kernel.impl.api.TransactionToApply batch, org.neo4j.kernel.impl.transaction.tracing.CommitEvent commitEvent, org.neo4j.storageengine.api.TransactionApplicationMode mode) throws org.neo4j.graphdb.TransactionFailureException public override long Commit(TransactionToApply batch, CommitEvent commitEvent, TransactionApplicationMode mode) { TransactionsToApply.Add(batch.TransactionRepresentation()); return(-1); }