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);
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
- protected void onDatastoreContext(DatastoreContext context) {
+ protected void onDatastoreContext(final DatastoreContext context) {
super.onDatastoreContext(noPersistenceDatastoreContext(context));
}
}
}
- private void onRemoveAllCandidates(RemoveAllCandidates message) {
+ private void onRemoveAllCandidates(final RemoveAllCandidates message) {
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());
}
}
- private void onRegisterCandidateLocal(RegisterCandidateLocal registerCandidate) {
+ private void onRegisterCandidateLocal(final RegisterCandidateLocal registerCandidate) {
LOG.debug("{}: onRegisterCandidateLocal: {}", persistenceId(), registerCandidate);
- listenerSupport.setHasCandidateForEntity(registerCandidate.getEntity());
-
NormalizedNode<?, ?> entityOwners = entityOwnersWithCandidate(registerCandidate.getEntity().getType(),
registerCandidate.getEntity().getIdentifier(), localMemberName.getName());
commitCoordinator.commitModification(new MergeModification(ENTITY_OWNERS_PATH, entityOwners), this);
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();
- listenerSupport.unsetHasCandidateForEntity(entity);
-
YangInstanceIdentifier candidatePath = candidatePath(entity.getType(), entity.getIdentifier(),
localMemberName.getName());
commitCoordinator.commitModification(new DeleteModification(candidatePath), this);
});
}
- private void onUnregisterListenerLocal(UnregisterListenerLocal unregisterListener) {
+ private void onUnregisterListenerLocal(final UnregisterListenerLocal unregisterListener) {
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
}
@Override
- 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);
LOG.debug("{}: new downPeerMemberNames: {}", persistenceId(), downPeerMemberNames);
}
- private void onCandidateRemoved(CandidateRemoved message) {
+ private void onCandidateRemoved(final CandidateRemoved message) {
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));
}
- private void onCandidateAdded(CandidateAdded message) {
+ private void onCandidateAdded(final CandidateAdded message) {
if (!isLeader()) {
return;
}
}
}
- private void onPeerDown(PeerDown peerDown) {
+ private void onPeerDown(final PeerDown peerDown) {
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)
commitCoordinator.commitModifications(modifications, this);
}
- private void onPeerUp(PeerUp peerUp) {
+ private void onPeerUp(final PeerUp peerUp) {
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) {
return candidateNames;
}
- 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) -> {
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();
}
- private void searchForEntities(EntityWalker walker) {
+ private void searchForEntities(final EntityWalker walker) {
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),
/**
* 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());
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();
}
}
- 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 "";
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) {
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();
super(EntityOwnershipShard.class);
}
- Builder localMemberName(MemberName newLocalMemberName) {
+ Builder localMemberName(final MemberName newLocalMemberName) {
checkSealed();
this.localMemberName = newLocalMemberName;
return this;
}
- Builder ownerSelectionStrategyConfig(EntityOwnerSelectionStrategyConfig newOwnerSelectionStrategyConfig) {
+ Builder ownerSelectionStrategyConfig(final EntityOwnerSelectionStrategyConfig newOwnerSelectionStrategyConfig) {
checkSealed();
this.ownerSelectionStrategyConfig = newOwnerSelectionStrategyConfig;
return this;
Code Review / controller.git / blobdiff