Examples with DataWriteCommand org.infinispan.commands.write.DataWriteCommand used on opensource projects

Example 1 with DataWriteCommand

use of org.infinispan.commands.write.DataWriteCommand in project infinispan by infinispan.

the class SingleKeyBackupWriteCommand method createWriteCommand.

@Override
WriteCommand createWriteCommand() {
    DataWriteCommand command;
    switch(operation) {
        case REMOVE:
            command = new RemoveCommand(key, null, segmentId, getFlags(), getCommandInvocationId());
            break;
        case WRITE:
            command = EnumUtil.containsAny(getFlags(), FlagBitSets.IRAC_UPDATE) ? new IracPutKeyValueCommand(key, segmentId, getCommandInvocationId(), valueOrFunction, metadata, internalMetadata) : new PutKeyValueCommand(key, valueOrFunction, false, metadata, segmentId, getFlags(), getCommandInvocationId());
            break;
        case COMPUTE:
            command = new ComputeCommand(key, (BiFunction) valueOrFunction, false, segmentId, getFlags(), getCommandInvocationId(), metadata);
            break;
        case REPLACE:
            command = new ReplaceCommand(key, null, valueOrFunction, metadata, segmentId, getFlags(), getCommandInvocationId());
            break;
        case REMOVE_EXPIRED:
            // Doesn't matter if it is max idle or not - important thing is that it raises expired event
            command = new RemoveExpiredCommand(key, valueOrFunction, null, false, segmentId, getFlags(), getCommandInvocationId());
            break;
        case COMPUTE_IF_PRESENT:
            command = new ComputeCommand(key, (BiFunction) valueOrFunction, true, segmentId, getFlags(), getCommandInvocationId(), metadata);
            break;
        case COMPUTE_IF_ABSENT:
            command = new ComputeIfAbsentCommand(key, (Function) valueOrFunction, segmentId, getFlags(), getCommandInvocationId(), metadata);
            break;
        default:
            throw new IllegalStateException("Unknown operation " + operation);
    }
    command.setInternalMetadata(internalMetadata);
    return command;
}

Example 2 with DataWriteCommand

use of org.infinispan.commands.write.DataWriteCommand in project infinispan by infinispan.

the class ScatteredDistributionInterceptor method handleWriteOnOriginPrimary.

private Object handleWriteOnOriginPrimary(InvocationContext ctx, DataWriteCommand command, Object rv, RepeatableReadEntry cacheEntry, Object seenValue, EntryVersion seenVersion, CacheTopology cacheTopology, DistributionInfo info) {
    if (!command.isSuccessful()) {
        if (log.isTraceEnabled())
            log.tracef("Skipping the replication of the command as it did not succeed on primary owner (%s).", command);
        return rv;
    }
    // increment the version
    EntryVersion nextVersion = svm.incrementVersion(info.segmentId());
    Metadata metadata = addVersion(cacheEntry.getMetadata(), nextVersion);
    cacheEntry.setMetadata(metadata);
    CompletionStage<Void> stage;
    if (command.loadType() != DONT_LOAD) {
        stage = commitSingleEntryIfNoChange(cacheEntry, ctx, command);
    } else {
        stage = commitSingleEntryIfNewer(cacheEntry, ctx, command);
    }
    // When replicating to backup, we'll add skip ownership check since we're now on primary owner
    // and we have already committed the entry, reading the return value. If we got OTE from remote
    // site and the command would be retried, we could fail to do the retry/return wrong value.
    WriteCommand backupCommand;
    long flags = command.getFlagsBitSet() | FlagBitSets.SKIP_OWNERSHIP_CHECK;
    if (cacheEntry.isRemoved()) {
        backupCommand = cf.buildRemoveCommand(command.getKey(), null, info.segmentId(), flags);
        ((RemoveCommand) backupCommand).setMetadata(cacheEntry.getMetadata());
    } else {
        backupCommand = cf.buildPutKeyValueCommand(command.getKey(), cacheEntry.getValue(), info.segmentId(), cacheEntry.getMetadata(), flags);
    }
    backupCommand.setTopologyId(command.getTopologyId());
    Address backup = getNextMember(cacheTopology);
    if (backup != null) {
        // error responses throw exceptions from JGroupsTransport
        CompletionStage<?> rpcFuture = rpcManager.invokeCommand(backup, backupCommand, SingleResponseCollector.validOnly(), rpcManager.getSyncRpcOptions());
        rpcFuture.thenRun(() -> {
            if (cacheEntry.isCommitted() && !command.hasAnyFlag(FlagBitSets.PUT_FOR_STATE_TRANSFER)) {
                scheduleKeyInvalidation(command.getKey(), cacheEntry.getMetadata().version(), cacheEntry.isRemoved());
            }
        });
        rpcFuture = completeSingleWriteOnPrimaryOriginator(command, backup, rpcFuture);
        // Exception responses are thrown anyway and we don't expect any return values
        return delayedValue(CompletionStages.allOf(stage.toCompletableFuture(), rpcFuture.toCompletableFuture()), rv);
    } else {
        return delayedValue(stage, rv);
    }
}

Example 3 with DataWriteCommand

use of org.infinispan.commands.write.DataWriteCommand in project infinispan by infinispan.

the class BaseBackupInterceptor method handleSingleKeyWriteReturn.

private Object handleSingleKeyWriteReturn(InvocationContext ctx, DataWriteCommand dataWriteCommand, Object rv) {
    if (!dataWriteCommand.isSuccessful()) {
        if (log.isTraceEnabled()) {
            log.tracef("Command %s is not successful, not replicating", dataWriteCommand);
        }
        return rv;
    }
    int segment = dataWriteCommand.getSegment();
    if (clusteringDependentLogic.getCacheTopology().getSegmentDistribution(segment).isPrimary()) {
        // primary owner always tracks updates to the remote sites (and sends the update in the background)
        iracManager.trackUpdatedKey(segment, dataWriteCommand.getKey(), dataWriteCommand.getCommandInvocationId());
        CacheEntry<?, ?> entry = ctx.lookupEntry(dataWriteCommand.getKey());
        WriteCommand crossSiteCommand = createCommandForXSite(entry, segment, dataWriteCommand.getFlagsBitSet());
        return backupSender.backupWrite(crossSiteCommand, dataWriteCommand).thenReturn(ctx, dataWriteCommand, rv);
    } else if (!ctx.isOriginLocal()) {
        // backup owners need to keep track of the update in the remote context for ASYNC cross-site
        // if backup owner == originator, we don't want to track the key again when ctx.isOriginLocal==true
        iracManager.trackUpdatedKey(segment, dataWriteCommand.getKey(), dataWriteCommand.getCommandInvocationId());
    }
    return rv;
}

Example 4 with DataWriteCommand

use of org.infinispan.commands.write.DataWriteCommand in project infinispan by infinispan.

the class ScatteredDistributionInterceptor method commitSingleEntryOnReturn.

private Object commitSingleEntryOnReturn(InvocationContext ctx, DataWriteCommand command, RepeatableReadEntry cacheEntry, EntryVersion nextVersion) {
    return invokeNextThenApply(ctx, command, (rCtx, rCommand, rv) -> {
        DataWriteCommand dataWriteCommand = (DataWriteCommand) rCommand;
        if (nextVersion != null) {
            cacheEntry.setMetadata(addVersion(cacheEntry.getMetadata(), nextVersion));
        }
        CompletionStage<Void> stage;
        if (command.loadType() != DONT_LOAD) {
            stage = commitSingleEntryIfNoChange(cacheEntry, rCtx, rCommand);
        } else {
            stage = commitSingleEntryIfNewer(cacheEntry, rCtx, dataWriteCommand);
        }
        if (cacheEntry.isCommitted() && rCtx.isOriginLocal() && nextVersion != null) {
            scheduleKeyInvalidation(dataWriteCommand.getKey(), nextVersion, cacheEntry.isRemoved());
        }
        return delayedValue(stage, rv);
    });
}

Example 5 with DataWriteCommand

use of org.infinispan.commands.write.DataWriteCommand in project infinispan by infinispan.

the class L1NonTxInterceptor method handleDataWriteCommand.

private Object handleDataWriteCommand(InvocationContext ctx, DataWriteCommand command, boolean assumeOriginKeptEntryInL1) {
    if (command.hasAnyFlag(FlagBitSets.CACHE_MODE_LOCAL)) {
        if (log.isTraceEnabled()) {
            log.tracef("local mode forced, suppressing L1 calls.");
        }
        return invokeNext(ctx, command);
    }
    CompletableFuture<?> l1InvalidationFuture = invalidateL1InCluster(ctx, command, assumeOriginKeptEntryInL1);
    return invokeNextAndHandle(ctx, command, (InvocationContext rCtx, DataWriteCommand dataWriteCommand, Object rv, Throwable ex) -> {
        if (ex != null) {
            if (mustSyncInvalidation(l1InvalidationFuture, dataWriteCommand)) {
                return asyncValue(l1InvalidationFuture).thenApply(rCtx, dataWriteCommand, (rCtx1, rCommand1, rv1) -> {
                    throw ex;
                });
            }
            throw ex;
        } else {
            if (mustSyncInvalidation(l1InvalidationFuture, dataWriteCommand)) {
                if (shouldRemoveFromLocalL1(rCtx, dataWriteCommand)) {
                    CompletionStage<VisitableCommand> removeFromL1CommandStage = removeFromL1Command(rCtx, dataWriteCommand.getKey(), dataWriteCommand.getSegment());
                    // TODO: To be fixed in https://issues.redhat.com/browse/ISPN-11125
                    VisitableCommand removeFromL1Command = CompletionStages.join(removeFromL1CommandStage);
                    return makeStage(asyncInvokeNext(rCtx, removeFromL1Command, l1InvalidationFuture)).thenApply(null, null, (rCtx2, rCommand2, rv2) -> rv);
                } else {
                    return asyncValue(l1InvalidationFuture).thenApply(rCtx, dataWriteCommand, (rCtx1, rCommand1, rv1) -> rv);
                }
            } else if (shouldRemoveFromLocalL1(rCtx, dataWriteCommand)) {
                CompletionStage<VisitableCommand> removeFromL1CommandStage = removeFromL1Command(rCtx, dataWriteCommand.getKey(), dataWriteCommand.getSegment());
                // TODO: To be fixed in https://issues.redhat.com/browse/ISPN-11125
                VisitableCommand removeFromL1Command = CompletionStages.join(removeFromL1CommandStage);
                return invokeNextThenApply(rCtx, removeFromL1Command, (rCtx2, rCommand2, rv2) -> rv);
            } else if (log.isTraceEnabled()) {
                log.trace("Allowing entry to commit as local node is owner");
            }
        }
        return rv;
    });
}