These are private methods and they do not touch state, hence they
can be made static.
Change-Id: I1d9adf70d9121e01b2ac8e03a1198c1ba73716fb
Signed-off-by: Robert Varga <rovarga@cisco.com>
- private void onSerializeSnapshot(SerializeSnapshot request) {
+ private static void onSerializeSnapshot(final SerializeSnapshot request) {
Optional<OutputStream> installSnapshotStream = request.getInstallSnapshotStream();
if (installSnapshotStream.isPresent()) {
try {
Optional<OutputStream> installSnapshotStream = request.getInstallSnapshotStream();
if (installSnapshotStream.isPresent()) {
try {
private final EntityOwnershipStatistics entityOwnershipStatistics;
private boolean removeAllInitialCandidates = true;
private final EntityOwnershipStatistics entityOwnershipStatistics;
private boolean removeAllInitialCandidates = true;
- protected EntityOwnershipShard(Builder builder) {
+ protected EntityOwnershipShard(final Builder builder) {
super(builder);
this.localMemberName = builder.localMemberName;
this.commitCoordinator = new EntityOwnershipShardCommitCoordinator(builder.localMemberName, LOG);
super(builder);
this.localMemberName = builder.localMemberName;
this.commitCoordinator = new EntityOwnershipShardCommitCoordinator(builder.localMemberName, LOG);
this.entityOwnershipStatistics.init(getDataStore());
}
this.entityOwnershipStatistics.init(getDataStore());
}
- private static DatastoreContext noPersistenceDatastoreContext(DatastoreContext datastoreContext) {
+ private static DatastoreContext noPersistenceDatastoreContext(final DatastoreContext datastoreContext) {
return DatastoreContext.newBuilderFrom(datastoreContext).persistent(false).build();
}
@Override
return DatastoreContext.newBuilderFrom(datastoreContext).persistent(false).build();
}
@Override
- protected void onDatastoreContext(DatastoreContext context) {
+ protected void onDatastoreContext(final DatastoreContext context) {
super.onDatastoreContext(noPersistenceDatastoreContext(context));
}
super.onDatastoreContext(noPersistenceDatastoreContext(context));
}
- private void onRemoveAllCandidates(RemoveAllCandidates message) {
+ private void onRemoveAllCandidates(final RemoveAllCandidates message) {
LOG.debug("{}: onRemoveAllCandidates: {}", persistenceId(), message);
removeCandidateFromEntities(message.getMemberName());
}
LOG.debug("{}: onRemoveAllCandidates: {}", persistenceId(), message);
removeCandidateFromEntities(message.getMemberName());
}
- private void onSelectOwner(SelectOwner selectOwner) {
+ private void onSelectOwner(final SelectOwner selectOwner) {
LOG.debug("{}: onSelectOwner: {}", persistenceId(), selectOwner);
String currentOwner = getCurrentOwner(selectOwner.getEntityPath());
LOG.debug("{}: onSelectOwner: {}", persistenceId(), selectOwner);
String currentOwner = getCurrentOwner(selectOwner.getEntityPath());
- private void onRegisterCandidateLocal(RegisterCandidateLocal registerCandidate) {
+ private void onRegisterCandidateLocal(final RegisterCandidateLocal registerCandidate) {
LOG.debug("{}: onRegisterCandidateLocal: {}", persistenceId(), registerCandidate);
listenerSupport.setHasCandidateForEntity(registerCandidate.getEntity());
LOG.debug("{}: onRegisterCandidateLocal: {}", persistenceId(), registerCandidate);
listenerSupport.setHasCandidateForEntity(registerCandidate.getEntity());
getSender().tell(SuccessReply.INSTANCE, getSelf());
}
getSender().tell(SuccessReply.INSTANCE, getSelf());
}
- private void onUnregisterCandidateLocal(UnregisterCandidateLocal unregisterCandidate) {
+ private void onUnregisterCandidateLocal(final UnregisterCandidateLocal unregisterCandidate) {
LOG.debug("{}: onUnregisterCandidateLocal: {}", persistenceId(), unregisterCandidate);
DOMEntity entity = unregisterCandidate.getEntity();
LOG.debug("{}: onUnregisterCandidateLocal: {}", persistenceId(), unregisterCandidate);
DOMEntity entity = unregisterCandidate.getEntity();
- private void onUnregisterListenerLocal(UnregisterListenerLocal unregisterListener) {
+ private void onUnregisterListenerLocal(final UnregisterListenerLocal unregisterListener) {
LOG.debug("{}: onUnregisterListenerLocal: {}", persistenceId(), unregisterListener);
listenerSupport.removeEntityOwnershipListener(unregisterListener.getEntityType(),
LOG.debug("{}: onUnregisterListenerLocal: {}", persistenceId(), unregisterListener);
listenerSupport.removeEntityOwnershipListener(unregisterListener.getEntityType(),
- void possiblyRemoveAllInitialCandidates(ActorSelection leader) {
+ void possiblyRemoveAllInitialCandidates(final ActorSelection leader) {
// The following handles removing all candidates on startup when re-joining with a remote leader. When a
// follower is detected as down, the leader will re-assign new owners to entities that were owned by the
// down member but doesn't remove the down member as a candidate, as the down node may actually be isolated
// The following handles removing all candidates on startup when re-joining with a remote leader. When a
// follower is detected as down, the leader will re-assign new owners to entities that were owned by the
// down member but doesn't remove the down member as a candidate, as the down node may actually be isolated
- protected void onLeaderChanged(String oldLeader, String newLeader) {
+ protected void onLeaderChanged(final String oldLeader, final String newLeader) {
boolean isLeader = isLeader();
LOG.debug("{}: onLeaderChanged: oldLeader: {}, newLeader: {}, isLeader: {}", persistenceId(), oldLeader,
newLeader, isLeader);
boolean isLeader = isLeader();
LOG.debug("{}: onLeaderChanged: oldLeader: {}, newLeader: {}, isLeader: {}", persistenceId(), oldLeader,
newLeader, isLeader);
LOG.debug("{}: new downPeerMemberNames: {}", persistenceId(), downPeerMemberNames);
}
LOG.debug("{}: new downPeerMemberNames: {}", persistenceId(), downPeerMemberNames);
}
- private void onCandidateRemoved(CandidateRemoved message) {
+ private void onCandidateRemoved(final CandidateRemoved message) {
LOG.debug("{}: onCandidateRemoved: {}", persistenceId(), message);
if (isLeader()) {
LOG.debug("{}: onCandidateRemoved: {}", persistenceId(), message);
if (isLeader()) {
- private EntityOwnerSelectionStrategy getEntityOwnerElectionStrategy(YangInstanceIdentifier entityPath) {
+ private EntityOwnerSelectionStrategy getEntityOwnerElectionStrategy(final YangInstanceIdentifier entityPath) {
final String entityType = EntityOwnersModel.entityTypeFromEntityPath(entityPath);
return strategyConfig.createStrategy(entityType, entityOwnershipStatistics.byEntityType(entityType));
}
final String entityType = EntityOwnersModel.entityTypeFromEntityPath(entityPath);
return strategyConfig.createStrategy(entityType, entityOwnershipStatistics.byEntityType(entityType));
}
- private void onCandidateAdded(CandidateAdded message) {
+ private void onCandidateAdded(final CandidateAdded message) {
if (!isLeader()) {
return;
}
if (!isLeader()) {
return;
}
- private void onPeerDown(PeerDown peerDown) {
+ private void onPeerDown(final PeerDown peerDown) {
LOG.info("{}: onPeerDown: {}", persistenceId(), peerDown);
MemberName downMemberName = peerDown.getMemberName();
LOG.info("{}: onPeerDown: {}", persistenceId(), peerDown);
MemberName downMemberName = peerDown.getMemberName();
- private void selectNewOwnerForEntitiesOwnedBy(Set<String> ownedBy) {
+ private void selectNewOwnerForEntitiesOwnedBy(final Set<String> ownedBy) {
final BatchedModifications modifications = commitCoordinator.newBatchedModifications();
searchForEntitiesOwnedBy(ownedBy, (entityTypeNode, entityNode) -> {
YangInstanceIdentifier entityPath = YangInstanceIdentifier.builder(ENTITY_TYPES_PATH)
final BatchedModifications modifications = commitCoordinator.newBatchedModifications();
searchForEntitiesOwnedBy(ownedBy, (entityTypeNode, entityNode) -> {
YangInstanceIdentifier entityPath = YangInstanceIdentifier.builder(ENTITY_TYPES_PATH)
commitCoordinator.commitModifications(modifications, this);
}
commitCoordinator.commitModifications(modifications, this);
}
- private void onPeerUp(PeerUp peerUp) {
+ private void onPeerUp(final PeerUp peerUp) {
LOG.debug("{}: onPeerUp: {}", persistenceId(), peerUp);
downPeerMemberNames.remove(peerUp.getMemberName());
LOG.debug("{}: onPeerUp: {}", persistenceId(), peerUp);
downPeerMemberNames.remove(peerUp.getMemberName());
- private Collection<String> getCandidateNames(MapEntryNode entity) {
+ private static Collection<String> getCandidateNames(final MapEntryNode entity) {
Collection<MapEntryNode> candidates = ((MapNode)entity.getChild(CANDIDATE_NODE_ID).get()).getValue();
Collection<String> candidateNames = new ArrayList<>(candidates.size());
for (MapEntryNode candidate: candidates) {
Collection<MapEntryNode> candidates = ((MapNode)entity.getChild(CANDIDATE_NODE_ID).get()).getValue();
Collection<String> candidateNames = new ArrayList<>(candidates.size());
for (MapEntryNode candidate: candidates) {
- private void searchForEntitiesOwnedBy(Set<String> ownedBy, EntityWalker walker) {
+ private void searchForEntitiesOwnedBy(final Set<String> ownedBy, final EntityWalker walker) {
LOG.debug("{}: Searching for entities owned by {}", persistenceId(), ownedBy);
searchForEntities((entityTypeNode, entityNode) -> {
LOG.debug("{}: Searching for entities owned by {}", persistenceId(), ownedBy);
searchForEntities((entityTypeNode, entityNode) -> {
commitCoordinator.commitModifications(modifications, this);
}
commitCoordinator.commitModifications(modifications, this);
}
- private static boolean hasCandidate(MapEntryNode entity, MemberName candidateName) {
+ private static boolean hasCandidate(final MapEntryNode entity, final MemberName candidateName) {
return ((MapNode)entity.getChild(CANDIDATE_NODE_ID).get()).getChild(candidateNodeKey(candidateName.getName()))
.isPresent();
}
return ((MapNode)entity.getChild(CANDIDATE_NODE_ID).get()).getChild(candidateNodeKey(candidateName.getName()))
.isPresent();
}
- private void searchForEntities(EntityWalker walker) {
+ private void searchForEntities(final EntityWalker walker) {
Optional<NormalizedNode<?, ?>> possibleEntityTypes = getDataStore().readNode(ENTITY_TYPES_PATH);
if (!possibleEntityTypes.isPresent()) {
return;
Optional<NormalizedNode<?, ?>> possibleEntityTypes = getDataStore().readNode(ENTITY_TYPES_PATH);
if (!possibleEntityTypes.isPresent()) {
return;
- private void writeNewOwner(YangInstanceIdentifier entityPath, String newOwner) {
+ private void writeNewOwner(final YangInstanceIdentifier entityPath, final String newOwner) {
LOG.debug("{}: Writing new owner {} for entity {}", persistenceId(), newOwner, entityPath);
commitCoordinator.commitModification(new WriteModification(entityPath.node(ENTITY_OWNER_QNAME),
LOG.debug("{}: Writing new owner {} for entity {}", persistenceId(), newOwner, entityPath);
commitCoordinator.commitModification(new WriteModification(entityPath.node(ENTITY_OWNER_QNAME),
/**
* Schedule a new owner selection job. Cancelling any outstanding job if it has not been cancelled.
*/
/**
* Schedule a new owner selection job. Cancelling any outstanding job if it has not been cancelled.
*/
- private void scheduleOwnerSelection(YangInstanceIdentifier entityPath, Collection<String> allCandidates,
- EntityOwnerSelectionStrategy strategy) {
+ private void scheduleOwnerSelection(final YangInstanceIdentifier entityPath, final Collection<String> allCandidates,
+ final EntityOwnerSelectionStrategy strategy) {
cancelOwnerSelectionTask(entityPath);
LOG.debug("{}: Scheduling owner selection after {} ms", persistenceId(), strategy.getSelectionDelayInMillis());
cancelOwnerSelectionTask(entityPath);
LOG.debug("{}: Scheduling owner selection after {} ms", persistenceId(), strategy.getSelectionDelayInMillis());
entityToScheduledOwnershipTask.put(entityPath, lastScheduledTask);
}
entityToScheduledOwnershipTask.put(entityPath, lastScheduledTask);
}
- private void cancelOwnerSelectionTask(YangInstanceIdentifier entityPath) {
+ private void cancelOwnerSelectionTask(final YangInstanceIdentifier entityPath) {
final Cancellable lastScheduledTask = entityToScheduledOwnershipTask.get(entityPath);
if (lastScheduledTask != null && !lastScheduledTask.isCancelled()) {
lastScheduledTask.cancel();
}
}
final Cancellable lastScheduledTask = entityToScheduledOwnershipTask.get(entityPath);
if (lastScheduledTask != null && !lastScheduledTask.isCancelled()) {
lastScheduledTask.cancel();
}
}
- private String newOwner(String currentOwner, Collection<String> candidates,
- EntityOwnerSelectionStrategy ownerSelectionStrategy) {
+ private String newOwner(final String currentOwner, final Collection<String> candidates,
+ final EntityOwnerSelectionStrategy ownerSelectionStrategy) {
Collection<String> viableCandidates = getViableCandidates(candidates);
if (viableCandidates.isEmpty()) {
return "";
Collection<String> viableCandidates = getViableCandidates(candidates);
if (viableCandidates.isEmpty()) {
return "";
return ownerSelectionStrategy.newOwner(currentOwner, viableCandidates);
}
return ownerSelectionStrategy.newOwner(currentOwner, viableCandidates);
}
- private Collection<String> getViableCandidates(Collection<String> candidates) {
+ private Collection<String> getViableCandidates(final Collection<String> candidates) {
Collection<String> viableCandidates = new ArrayList<>();
for (String candidate : candidates) {
Collection<String> viableCandidates = new ArrayList<>();
for (String candidate : candidates) {
return viableCandidates;
}
return viableCandidates;
}
- private String getCurrentOwner(YangInstanceIdentifier entityId) {
+ private String getCurrentOwner(final YangInstanceIdentifier entityId) {
Optional<NormalizedNode<?, ?>> optionalEntityOwner = getDataStore().readNode(entityId.node(ENTITY_OWNER_QNAME));
if (optionalEntityOwner.isPresent()) {
return optionalEntityOwner.get().getValue().toString();
Optional<NormalizedNode<?, ?>> optionalEntityOwner = getDataStore().readNode(entityId.node(ENTITY_OWNER_QNAME));
if (optionalEntityOwner.isPresent()) {
return optionalEntityOwner.get().getValue().toString();
super(EntityOwnershipShard.class);
}
super(EntityOwnershipShard.class);
}
- Builder localMemberName(MemberName newLocalMemberName) {
+ Builder localMemberName(final MemberName newLocalMemberName) {
checkSealed();
this.localMemberName = newLocalMemberName;
return this;
}
checkSealed();
this.localMemberName = newLocalMemberName;
return this;
}
- Builder ownerSelectionStrategyConfig(EntityOwnerSelectionStrategyConfig newOwnerSelectionStrategyConfig) {
+ Builder ownerSelectionStrategyConfig(final EntityOwnerSelectionStrategyConfig newOwnerSelectionStrategyConfig) {
checkSealed();
this.ownerSelectionStrategyConfig = newOwnerSelectionStrategyConfig;
return this;
checkSealed();
this.ownerSelectionStrategyConfig = newOwnerSelectionStrategyConfig;
return this;
snapshotState.snapshot.serialize(toOutputStream(out));
}
snapshotState.snapshot.serialize(toOutputStream(out));
}
- private OutputStream toOutputStream(final ObjectOutput out) {
+ private static OutputStream toOutputStream(final ObjectOutput out) {
if (out instanceof OutputStream) {
return (OutputStream) out;
}
return new OutputStream() {
@Override
if (out instanceof OutputStream) {
return (OutputStream) out;
}
return new OutputStream() {
@Override
- public void write(int value) throws IOException {
+ public void write(final int value) throws IOException {
snapshotState = new ShardSnapshotState(ShardDataTreeSnapshot.deserialize(toInputStream(in)));
}
snapshotState = new ShardSnapshotState(ShardDataTreeSnapshot.deserialize(toInputStream(in)));
}
- private InputStream toInputStream(final ObjectInput in) {
+ private static InputStream toInputStream(final ObjectInput in) {
if (in instanceof InputStream) {
return (InputStream) in;
}
if (in instanceof InputStream) {
return (InputStream) in;
}
+ "aren't serialized. FindBugs does not recognize this.")
private final ShardDataTreeSnapshot snapshot;
+ "aren't serialized. FindBugs does not recognize this.")
private final ShardDataTreeSnapshot snapshot;
- public ShardSnapshotState(@Nonnull ShardDataTreeSnapshot snapshot) {
+ public ShardSnapshotState(@Nonnull final ShardDataTreeSnapshot snapshot) {
this.snapshot = Preconditions.checkNotNull(snapshot);
}
this.snapshot = Preconditions.checkNotNull(snapshot);
}
- @SuppressWarnings("static-method")
private Object writeReplace() {
return new Proxy(this);
}
private Object writeReplace() {
return new Proxy(this);
}
}
@SuppressWarnings("unchecked")
}
@SuppressWarnings("unchecked")
- private <T> FutureCallback<T> mockFutureCallback(final FutureCallback<T> actual) {
+ private static <T> FutureCallback<T> mockFutureCallback(final FutureCallback<T> actual) {
FutureCallback<T> mock = mock(FutureCallback.class);
doAnswer(invocation -> {
actual.onFailure(invocation.getArgumentAt(0, Throwable.class));
FutureCallback<T> mock = mock(FutureCallback.class);
doAnswer(invocation -> {
actual.onFailure(invocation.getArgumentAt(0, Throwable.class));