Examples with TransactionCommitProcess org.neo4j.kernel.impl.api.TransactionCommitProcess used on opensource projects

Example 6 with TransactionCommitProcess

use of org.neo4j.kernel.impl.api.TransactionCommitProcess in project neo4j by neo4j.

the class NeoStoreDataSource method buildKernel.

private NeoStoreKernelModule buildKernel(TransactionAppender appender, IndexingService indexingService, StoreReadLayer storeLayer, UpdateableSchemaState updateableSchemaState, LabelScanStore labelScanStore, StorageEngine storageEngine, IndexConfigStore indexConfigStore, TransactionIdStore transactionIdStore, AvailabilityGuard availabilityGuard, Clock clock, PropertyAccessor propertyAccessor) throws KernelException, IOException {
    TransactionCommitProcess transactionCommitProcess = commitProcessFactory.create(appender, storageEngine, config);
    /*
         * This is used by legacy indexes and constraint indexes whenever a transaction is to be spawned
         * from within an existing transaction. It smells, and we should look over alternatives when time permits.
         */
    Supplier<KernelAPI> kernelProvider = () -> kernelModule.kernelAPI();
    boolean releaseSchemaLockWhenBuildingConstratinIndexes = config.get(GraphDatabaseSettings.release_schema_lock_while_building_constraint);
    ConstraintIndexCreator constraintIndexCreator = new ConstraintIndexCreator(kernelProvider, indexingService, propertyAccessor, releaseSchemaLockWhenBuildingConstratinIndexes);
    LegacyIndexStore legacyIndexStore = new LegacyIndexStore(config, indexConfigStore, kernelProvider, legacyIndexProviderLookup);
    StatementOperationContainer statementOperationContainer = dependencies.satisfyDependency(buildStatementOperations(storeLayer, autoIndexing, constraintIndexCreator, updateableSchemaState, guard, legacyIndexStore));
    TransactionHooks hooks = new TransactionHooks();
    KernelTransactions kernelTransactions = life.add(new KernelTransactions(statementLocksFactory, constraintIndexCreator, statementOperationContainer, schemaWriteGuard, transactionHeaderInformationFactory, transactionCommitProcess, indexConfigStore, legacyIndexProviderLookup, hooks, transactionMonitor, availabilityGuard, tracers, storageEngine, procedures, transactionIdStore, clock, accessCapability));
    final Kernel kernel = new Kernel(kernelTransactions, hooks, databaseHealth, transactionMonitor, procedures, config);
    kernel.registerTransactionHook(transactionEventHandlers);
    final NeoStoreFileListing fileListing = new NeoStoreFileListing(storeDir, labelScanStore, indexingService, legacyIndexProviderLookup, storageEngine);
    return new NeoStoreKernelModule(transactionCommitProcess, kernel, kernelTransactions, fileListing);
}

Example 7 with TransactionCommitProcess

use of org.neo4j.kernel.impl.api.TransactionCommitProcess in project neo4j by neo4j.

the class TransactionCommittingResponseUnpackerTest method shouldUnfreezeKernelTransactionsAfterApplyIfBatchIsLarge.

/*
      * Tests that we unfreeze active transactions after commit and after apply of batch if batch length (in time)
      * is larger than safeZone time.
      */
@Test
public void shouldUnfreezeKernelTransactionsAfterApplyIfBatchIsLarge() throws Throwable {
    // GIVEN
    int maxBatchSize = 10;
    long idReuseSafeZoneTime = 100;
    Dependencies dependencies = mock(Dependencies.class);
    TransactionObligationFulfiller fulfiller = mock(TransactionObligationFulfiller.class);
    when(dependencies.obligationFulfiller()).thenReturn(fulfiller);
    when(dependencies.logService()).thenReturn(NullLogService.getInstance());
    KernelTransactions kernelTransactions = mock(KernelTransactions.class);
    when(dependencies.kernelTransactions()).thenReturn(kernelTransactions);
    TransactionCommitProcess commitProcess = mock(TransactionCommitProcess.class);
    when(dependencies.commitProcess()).thenReturn(commitProcess);
    TransactionCommittingResponseUnpacker unpacker = life.add(new TransactionCommittingResponseUnpacker(dependencies, maxBatchSize, idReuseSafeZoneTime));
    // WHEN
    int txCount = maxBatchSize;
    int doesNotMatter = 1;
    unpacker.unpackResponse(new DummyTransactionResponse(doesNotMatter, txCount, idReuseSafeZoneTime + 1), NO_OP_TX_HANDLER);
    // THEN
    InOrder inOrder = inOrder(commitProcess, kernelTransactions);
    inOrder.verify(commitProcess, times(1)).commit(any(), any(), any());
    inOrder.verify(kernelTransactions, times(1)).unblockNewTransactions();
}

Example 8 with TransactionCommitProcess

use of org.neo4j.kernel.impl.api.TransactionCommitProcess in project neo4j by neo4j.

the class ReplicatedTransactionStateMachine method installCommitProcess.

public synchronized void installCommitProcess(TransactionCommitProcess commitProcess, long lastCommittedIndex) {
    this.lastCommittedIndex = lastCommittedIndex;
    log.info(format("Updated lastCommittedIndex to %d", lastCommittedIndex));
    this.queue = new TransactionQueue(maxBatchSize, (first, last) -> commitProcess.commit(first, CommitEvent.NULL, TransactionApplicationMode.EXTERNAL));
}

Example 9 with TransactionCommitProcess

use of org.neo4j.kernel.impl.api.TransactionCommitProcess in project neo4j by neo4j.

the class HighlyAvailableCommitProcessFactoryTest method createRegularCommitProcess.

@Test
public void createRegularCommitProcess() {
    HighlyAvailableCommitProcessFactory factory = new HighlyAvailableCommitProcessFactory(new DelegateInvocationHandler<>(TransactionCommitProcess.class));
    TransactionCommitProcess commitProcess = factory.create(mock(TransactionAppender.class), mock(StorageEngine.class), Config.empty());
    assertThat(commitProcess, not(instanceOf(ReadOnlyTransactionCommitProcess.class)));
    assertThat(Proxy.getInvocationHandler(commitProcess), instanceOf(DelegateInvocationHandler.class));
}

Example 10 with TransactionCommitProcess

use of org.neo4j.kernel.impl.api.TransactionCommitProcess in project neo4j by neo4j.

the class CommitProcessStateMachineCollaborationTest method shouldFailTransactionIfLockSessionChanges.

@Test
public void shouldFailTransactionIfLockSessionChanges() throws Exception {
    // given
    int initialLockSessionId = 23;
    TransactionToApply transactionToApply = new TransactionToApply(physicalTx(initialLockSessionId));
    int finalLockSessionId = 24;
    TransactionCommitProcess localCommitProcess = mock(TransactionCommitProcess.class);
    ReplicatedTransactionStateMachine stateMachine = new ReplicatedTransactionStateMachine(lockState(finalLockSessionId), 16, NullLogProvider.getInstance());
    stateMachine.installCommitProcess(localCommitProcess, -1L);
    DirectReplicator<ReplicatedTransaction> replicator = new DirectReplicator<>(stateMachine);
    ReplicatedTransactionCommitProcess commitProcess = new ReplicatedTransactionCommitProcess(replicator);
    // when
    try {
        commitProcess.commit(transactionToApply, NULL, EXTERNAL);
        fail("Should have thrown exception.");
    } catch (TransactionFailureException e) {
    // expected
    }
}