*/
package org.opendaylight.mdsal.singleton.dom.impl;
-import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Verify.verify;
import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Strings;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
-import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.osgi.service.component.annotations.Activate;
@VisibleForTesting
static final @NonNull String CLOSE_SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.AsyncServiceCloseEntityType";
- private final ConcurrentMap<String, ClusterSingletonServiceGroup> serviceGroupMap = new ConcurrentHashMap<>();
+ private final ConcurrentMap<String, ServiceGroup> serviceGroupMap = new ConcurrentHashMap<>();
private final DOMEntityOwnershipService entityOwnershipService;
/* EOS Entity Listeners Registration */
serviceEntityListenerReg = null;
final var future = Futures.allAsList(serviceGroupMap.values().stream()
- .map(ClusterSingletonServiceGroup::closeClusterSingletonGroup)
+ .map(ServiceGroup::closeClusterSingletonGroup)
.toList());
try {
LOG.debug("Waiting for service groups to stop");
}
@Override
- public synchronized ClusterSingletonServiceRegistration registerClusterSingletonService(
- final ClusterSingletonService service) {
+ public synchronized Registration registerClusterSingletonService(final ClusterSingletonService service) {
+ final var serviceIdentifier = requireNonNull(service.getIdentifier());
LOG.debug("Call registrationService {} method for ClusterSingletonService Provider {}", service, this);
- final String serviceIdentifier = service.getIdentifier().getName();
- checkArgument(!Strings.isNullOrEmpty(serviceIdentifier),
- "ClusterSingletonService identifier may not be null nor empty");
-
- final ClusterSingletonServiceGroup serviceGroup;
- final var existing = serviceGroupMap.get(serviceIdentifier);
+ final var identifierValue = serviceIdentifier.value();
+ final ServiceGroup serviceGroup;
+ final var existing = serviceGroupMap.get(identifierValue);
if (existing == null) {
serviceGroup = createGroup(serviceIdentifier, new ArrayList<>(1));
- serviceGroupMap.put(serviceIdentifier, serviceGroup);
+ serviceGroupMap.put(identifierValue, serviceGroup);
try {
initializeOrRemoveGroup(serviceGroup);
serviceGroup = existing;
}
- final var reg = new AbstractClusterSingletonServiceRegistration(service) {
+ final var reg = new ServiceRegistration(service) {
@Override
protected void removeRegistration() {
// We need to bounce the unregistration through a ordered lock in order not to deal with asynchronous
return reg;
}
- private ClusterSingletonServiceGroup createGroup(final String serviceIdentifier,
- final List<ClusterSingletonServiceRegistration> services) {
- return new ClusterSingletonServiceGroupImpl(serviceIdentifier, entityOwnershipService,
- createEntity(SERVICE_ENTITY_TYPE, serviceIdentifier),
- createEntity(CLOSE_SERVICE_ENTITY_TYPE, serviceIdentifier), services);
+ private ServiceGroup createGroup(final ServiceGroupIdentifier identifier,
+ final List<ServiceRegistration> services) {
+ return new ActiveServiceGroup(identifier, entityOwnershipService,
+ createEntity(SERVICE_ENTITY_TYPE, identifier), createEntity(CLOSE_SERVICE_ENTITY_TYPE, identifier),
+ services);
}
- private void initializeOrRemoveGroup(final ClusterSingletonServiceGroup group)
- throws CandidateAlreadyRegisteredException {
+ private void initializeOrRemoveGroup(final ServiceGroup group) throws CandidateAlreadyRegisteredException {
try {
group.initialize();
} catch (CandidateAlreadyRegisteredException e) {
}
}
- private void removeRegistration(final String serviceIdentifier, final ClusterSingletonServiceRegistration reg) {
- final PlaceholderGroup placeHolder;
+ private void removeRegistration(final ServiceGroupIdentifier serviceIdentifier, final ServiceRegistration reg) {
+ final PlaceholderServiceGroup placeHolder;
final ListenableFuture<?> future;
synchronized (this) {
- final var lookup = verifyNotNull(serviceGroupMap.get(serviceIdentifier));
+ final var lookup = verifyNotNull(serviceGroupMap.get(serviceIdentifier.value()));
future = lookup.unregisterService(reg);
if (future == null) {
return;
// Close the group and replace it with a placeholder
LOG.debug("Closing service group {}", serviceIdentifier);
- placeHolder = new PlaceholderGroup(lookup, future);
+ placeHolder = new PlaceholderServiceGroup(lookup, future);
- final String identifier = reg.getInstance().getIdentifier().getName();
+ final var identifier = reg.getInstance().getIdentifier().value();
verify(serviceGroupMap.replace(identifier, lookup, placeHolder));
LOG.debug("Replaced group {} with {}", serviceIdentifier, placeHolder);
future.addListener(() -> finishShutdown(placeHolder), MoreExecutors.directExecutor());
}
- private synchronized void finishShutdown(final PlaceholderGroup placeHolder) {
+ private synchronized void finishShutdown(final PlaceholderServiceGroup placeHolder) {
final var identifier = placeHolder.getIdentifier();
LOG.debug("Service group {} closed", identifier);
final var services = placeHolder.getServices();
if (services.isEmpty()) {
// No services, we are all done
- if (serviceGroupMap.remove(identifier, placeHolder)) {
+ if (serviceGroupMap.remove(identifier.value(), placeHolder)) {
LOG.debug("Service group {} removed", placeHolder);
} else {
- LOG.debug("Service group {} superseded by {}", placeHolder, serviceGroupMap.get(identifier));
+ LOG.debug("Service group {} superseded by {}", placeHolder, serviceGroupMap.get(identifier.value()));
}
return;
}
// Placeholder is being retired, we are reusing its services as the seed for the group.
final var group = createGroup(identifier, services);
- verify(serviceGroupMap.replace(identifier, placeHolder, group));
+ verify(serviceGroupMap.replace(identifier.value(), placeHolder, group));
placeHolder.setSuccessor(group);
LOG.debug("Service group upgraded from {} to {}", placeHolder, group);
}
@VisibleForTesting
- static String getServiceIdentifierFromEntity(final DOMEntity entity) {
+ static @NonNull String getServiceIdentifierFromEntity(final DOMEntity entity) {
final var yii = entity.getIdentifier();
final var niiwp = (NodeIdentifierWithPredicates) yii.getLastPathArgument();
return niiwp.values().iterator().next().toString();
* Creates an extended {@link DOMEntity} instance.
*
* @param entityType the type of the entity
- * @param entityIdentifier the identifier of the entity
+ * @param sgi the identifier of the entity
* @return instance of Entity extended GenericEntity type
*/
@VisibleForTesting
- static DOMEntity createEntity(final String entityType, final String entityIdentifier) {
- return new DOMEntity(entityType, entityIdentifier);
+ static DOMEntity createEntity(final String entityType, final ServiceGroupIdentifier sgi) {
+ return new DOMEntity(entityType, sgi.value());
}
}
Code Review / mdsal.git / blobdiff