try (DOMDataTreeReadTransaction tx = domDataBroker.newReadOnlyTransaction()) {
for (int l = 0; l < outerListElem; l++) {
YangInstanceIdentifier yid = pid.node(new NodeIdentifierWithPredicates(OuterList.QNAME, olId, l));
- FluentFuture<java.util.Optional<NormalizedNode<?, ?>>> submitFuture = tx.read(dsType, yid);
+ FluentFuture<Optional<NormalizedNode<?, ?>>> submitFuture = tx.read(dsType, yid);
try {
Optional<NormalizedNode<?,?>> optionalDataObject = submitFuture.get();
if (optionalDataObject != null && optionalDataObject.isPresent()) {
// At this point the successor has completed transition and is possibly visible by the user thread, which is
// still stuck here. The successor has not seen final part of our state, nor the fact it is sealed.
// Propagate state and seal the successor.
- final java.util.Optional<ModifyTransactionRequest> optState = flushState();
+ final Optional<ModifyTransactionRequest> optState = flushState();
if (optState.isPresent()) {
forwardToSuccessor(successor, optState.get(), null);
}
if (SEALED.equals(prevState)) {
LOG.debug("Proxy {} reconnected while being sealed, propagating state to successor {}", this, successor);
final long enqueuedTicks = parent.currentTime();
- final java.util.Optional<ModifyTransactionRequest> optState = flushState();
+ final Optional<ModifyTransactionRequest> optState = flushState();
if (optState.isPresent()) {
successor.handleReplayedRemoteRequest(optState.get(), null, enqueuedTicks);
}
abstract FluentFuture<Optional<NormalizedNode<?, ?>>> doRead(YangInstanceIdentifier path);
@GuardedBy("this")
- abstract java.util.Optional<ModifyTransactionRequest> flushState();
+ abstract Optional<ModifyTransactionRequest> flushState();
abstract TransactionRequest<?> abortRequest();
}
@Override
- java.util.Optional<ModifyTransactionRequest> flushState() {
+ Optional<ModifyTransactionRequest> flushState() {
if (!builderBusy) {
- return java.util.Optional.empty();
+ return Optional.empty();
}
final ModifyTransactionRequest request = builder.build();
builderBusy = false;
- return java.util.Optional.of(request);
+ return Optional.of(request);
}
@Override
final ModifyTransactionRequest req) {
req.getModifications().forEach(this::appendModification);
- final java.util.Optional<PersistenceProtocol> maybeProto = req.getPersistenceProtocol();
+ final Optional<PersistenceProtocol> maybeProto = req.getPersistenceProtocol();
if (maybeProto.isPresent()) {
// Persistence protocol implies we are sealed, propagate the marker, but hold off doing other actions
// until we know what we are going to do.
final ModifyTransactionRequest req) {
req.getModifications().forEach(this::appendModification);
- final java.util.Optional<PersistenceProtocol> maybeProto = req.getPersistenceProtocol();
+ final Optional<PersistenceProtocol> maybeProto = req.getPersistenceProtocol();
if (maybeProto.isPresent()) {
// Persistence protocol implies we are sealed, propagate the marker, but hold off doing other actions
// until we know what we are going to do.
private void handleModifyTransaction(final ModifyTransactionRequest request, final RequestEnvelope envelope,
final long now) {
// The only valid request here is with abort protocol
- final java.util.Optional<PersistenceProtocol> optProto = request.getPersistenceProtocol();
+ final Optional<PersistenceProtocol> optProto = request.getPersistenceProtocol();
Preconditions.checkArgument(optProto.isPresent(), "Commit protocol is missing in %s", request);
Preconditions.checkArgument(optProto.get() == PersistenceProtocol.ABORT, "Unsupported commit protocol in %s",
request);
throw new UnsupportedRequestException(request);
}
- final java.util.Optional<Exception> optFailure = request.getDelayedFailure();
+ final Optional<Exception> optFailure = request.getDelayedFailure();
if (optFailure.isPresent()) {
state = new Ready(history().createFailedCohort(getIdentifier(), sealedModification, optFailure.get()));
} else {
- state = new Ready(history().createReadyCohort(getIdentifier(), sealedModification,
- java.util.Optional.empty()));
+ state = new Ready(history().createReadyCohort(getIdentifier(), sealedModification, Optional.empty()));
}
if (request.isCoordinated()) {
final RequestEnvelope envelope, final long now) throws RequestException {
// We need to examine the persistence protocol first to see if this is an idempotent request. If there is no
// protocol, there is nothing for us to do.
- final java.util.Optional<PersistenceProtocol> maybeProto = request.getPersistenceProtocol();
+ final Optional<PersistenceProtocol> maybeProto = request.getPersistenceProtocol();
if (!maybeProto.isPresent()) {
applyModifications(request.getModifications());
return replyModifySuccess(request.getSequence());
}
applyModifications(modifications);
- state = new Ready(checkOpen().ready(java.util.Optional.empty()));
+ state = new Ready(checkOpen().ready(Optional.empty()));
LOG.debug("{}: transitioned {} to ready", persistenceId(), getIdentifier());
}
return history().persistenceId();
}
- final java.util.Optional<TransactionSuccess<?>> replaySequence(final long sequence) throws RequestException {
+ final Optional<TransactionSuccess<?>> replaySequence(final long sequence) throws RequestException {
// Fast path check: if the requested sequence is the next request, bail early
if (expectedSequence == sequence) {
- return java.util.Optional.empty();
+ return Optional.empty();
}
// Check sequencing: we do not need to bother with future requests
}
// Not found
- return java.util.Optional.empty();
+ return Optional.empty();
}
final void purgeSequencesUpTo(final long sequence) {
private AbstractThreePhaseCommitCohort<ActorSelection> createMultiCommitCohort() {
final List<ThreePhaseCommitCohortProxy.CohortInfo> cohorts = new ArrayList<>(txContextWrappers.size());
- final java.util.Optional<SortedSet<String>> shardNames =
- java.util.Optional.of(new TreeSet<>(txContextWrappers.keySet()));
+ final Optional<SortedSet<String>> shardNames = Optional.of(new TreeSet<>(txContextWrappers.keySet()));
for (Entry<String, TransactionContextWrapper> e : txContextWrappers.entrySet()) {
LOG.debug("Tx {} Readying transaction for shard {}", getIdentifier(), e.getKey());
return Optional.empty();
}
- java.util.Optional<NormalizedNode<?, ?>> entityNode = dataTree.takeSnapshot().readNode(
+ Optional<NormalizedNode<?, ?>> entityNode = dataTree.takeSnapshot().readNode(
entityPath(forEntity.getType(), forEntity.getIdentifier()));
if (!entityNode.isPresent()) {
return Optional.empty();
// Check if there are any candidates, if there are none we do not really have ownership state
final MapEntryNode entity = (MapEntryNode) entityNode.get();
- final java.util.Optional<DataContainerChild<? extends PathArgument, ?>> optionalCandidates =
+ final Optional<DataContainerChild<? extends PathArgument, ?>> optionalCandidates =
entity.getChild(CANDIDATE_NODE_ID);
final boolean hasCandidates = optionalCandidates.isPresent()
&& ((MapNode) optionalCandidates.get()).getValue().size() > 0;
}
MemberName localMemberName = context.getCurrentMemberName();
- java.util.Optional<DataContainerChild<? extends PathArgument, ?>> ownerLeaf = entity.getChild(
- ENTITY_OWNER_NODE_ID);
+ Optional<DataContainerChild<? extends PathArgument, ?>> ownerLeaf = entity.getChild(ENTITY_OWNER_NODE_ID);
String owner = ownerLeaf.isPresent() ? ownerLeaf.get().getValue().toString() : null;
boolean hasOwner = !Strings.isNullOrEmpty(owner);
boolean isOwner = hasOwner && localMemberName.getName().equals(owner);
@Override
public void setUp() throws Exception {
super.setUp();
- when(getDataTreeSnapshot().readNode(PATH)).thenReturn(java.util.Optional.empty());
+ when(getDataTreeSnapshot().readNode(PATH)).thenReturn(Optional.empty());
}
@Override
public void setUp() throws Exception {
super.setUp();
when(getDataTreeSnapshot().newModification()).thenReturn(modification);
- when(modification.readNode(PATH)).thenReturn(java.util.Optional.of(DATA));
+ when(modification.readNode(PATH)).thenReturn(Optional.of(DATA));
}
@Override
new WriteModification(CarsModel.newCarPath("optima"), car1).apply(modification);
modification.ready();
- ReadyLocalTransaction readyLocal = new ReadyLocalTransaction(tx1 , modification, true,
- java.util.Optional.empty());
+ ReadyLocalTransaction readyLocal = new ReadyLocalTransaction(tx1 , modification, true, Optional.empty());
carsFollowerShard.get().tell(readyLocal, followerTestKit.getRef());
Object resp = followerTestKit.expectMsgClass(Object.class);
new WriteModification(CarsModel.newCarPath("sportage"), car2).apply(modification);
modification.ready();
- readyLocal = new ReadyLocalTransaction(tx2 , modification, false, java.util.Optional.empty());
+ readyLocal = new ReadyLocalTransaction(tx2 , modification, false, Optional.empty());
carsFollowerShard.get().tell(readyLocal, followerTestKit.getRef());
resp = followerTestKit.expectMsgClass(Object.class);
ForwardedReadyTransaction forwardedReady = new ForwardedReadyTransaction(tx1,
DataStoreVersions.CURRENT_VERSION, new ReadWriteShardDataTreeTransaction(
Mockito.mock(ShardDataTreeTransactionParent.class), tx1, modification), true,
- java.util.Optional.empty());
+ Optional.empty());
carsFollowerShard.get().tell(forwardedReady, followerTestKit.getRef());
Object resp = followerTestKit.expectMsgClass(Object.class);
forwardedReady = new ForwardedReadyTransaction(tx2,
DataStoreVersions.CURRENT_VERSION, new ReadWriteShardDataTreeTransaction(
Mockito.mock(ShardDataTreeTransactionParent.class), tx2, modification), false,
- java.util.Optional.empty());
+ Optional.empty());
carsFollowerShard.get().tell(forwardedReady, followerTestKit.getRef());
resp = followerTestKit.expectMsgClass(Object.class);
doReturn(dataTreeSnapshot).when(dataTree).takeSnapshot();
doReturn(dataTreeModification).when(dataTreeSnapshot).newModification();
- doReturn(java.util.Optional.of(readResponse)).when(dataTreeModification).readNode(
- any(YangInstanceIdentifier.class));
+ doReturn(Optional.of(readResponse)).when(dataTreeModification).readNode(any(YangInstanceIdentifier.class));
return dataTree;
}
captorForSubtrees.capture());
final List<Collection<DataTreeCandidate>> capturedValue = captorForChanges.getAllValues();
- final java.util.Optional<NormalizedNode<?, ?>> dataAfter =
+ final Optional<NormalizedNode<?, ?>> dataAfter =
capturedValue.get(0).iterator().next().getRootNode().getDataAfter();
final NormalizedNode<?,?> expected = ImmutableContainerNodeBuilder.create()