X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2FDataTreeCohortActorRegistry.java;h=3ff6a9f0e61ba90e7e17a9f2a6b0bf34a7a3a818;hb=HEAD;hp=f79c0475bb73afc025545704ac590ab058961723;hpb=013a6679470bf692753f2e04ab4398c97fd9f5d0;p=controller.git diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/DataTreeCohortActorRegistry.java b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/DataTreeCohortActorRegistry.java index f79c0475bb..fa10f947db 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/DataTreeCohortActorRegistry.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/main/java/org/opendaylight/controller/cluster/datastore/DataTreeCohortActorRegistry.java @@ -5,52 +5,48 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.controller.cluster.datastore; +import static java.util.Objects.requireNonNull; + import akka.actor.ActorRef; import akka.actor.PoisonPill; import akka.actor.Status; import akka.util.Timeout; -import com.google.common.base.Preconditions; +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.Multimap; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; -import javax.annotation.concurrent.NotThreadSafe; +import java.util.concurrent.Executor; import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier; -import org.opendaylight.controller.cluster.datastore.DataTreeCohortActor.CanCommit; -import org.opendaylight.controller.md.sal.dom.spi.AbstractRegistrationTree; -import org.opendaylight.controller.md.sal.dom.spi.RegistrationTreeNode; -import org.opendaylight.controller.md.sal.dom.spi.RegistrationTreeSnapshot; import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.mdsal.dom.api.DOMDataTreeCandidate; import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier; +import org.opendaylight.mdsal.dom.spi.AbstractRegistrationTree; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; -import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidate; +import org.opendaylight.yangtools.yang.data.tree.api.DataTreeCandidateNode; +import org.opendaylight.yangtools.yang.data.tree.api.ModificationType; +import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Registry of user commit cohorts, which is responsible for handling registration and calculation - * of affected cohorts based on {@link DataTreeCandidate}. - * + * of affected cohorts based on {@link DataTreeCandidate}. This class is NOT thread-safe. */ -@NotThreadSafe class DataTreeCohortActorRegistry extends AbstractRegistrationTree { private static final Logger LOG = LoggerFactory.getLogger(DataTreeCohortActorRegistry.class); - private final Map> cohortToNode = new HashMap<>(); + private final Map> cohortToNode = new HashMap<>(); Collection getCohortActors() { - return Collections.unmodifiableCollection(cohortToNode.keySet()); + return new ArrayList<>(cohortToNode.keySet()); } @SuppressWarnings("checkstyle:IllegalCatch") @@ -58,8 +54,7 @@ class DataTreeCohortActorRegistry extends AbstractRegistrationTree { takeLock(); try { final ActorRef cohortRef = cohort.getCohort(); - final RegistrationTreeNode node = - findNodeFor(cohort.getPath().getRootIdentifier().getPathArguments()); + final Node node = findNodeFor(cohort.getPath().path().getPathArguments()); addRegistration(node, cohort.getCohort()); cohortToNode.put(cohortRef, node); } catch (final Exception e) { @@ -73,7 +68,7 @@ class DataTreeCohortActorRegistry extends AbstractRegistrationTree { void removeCommitCohort(final ActorRef sender, final RemoveCohort message) { final ActorRef cohort = message.getCohort(); - final RegistrationTreeNode node = cohortToNode.get(cohort); + final Node node = cohortToNode.get(cohort); if (node != null) { removeRegistration(node, cohort); cohortToNode.remove(cohort); @@ -82,9 +77,9 @@ class DataTreeCohortActorRegistry extends AbstractRegistrationTree { cohort.tell(PoisonPill.getInstance(), cohort); } - Collection createCanCommitMessages(final TransactionIdentifier txId, - final DataTreeCandidate candidate, final SchemaContext schema) { - try (RegistrationTreeSnapshot cohorts = takeSnapshot()) { + List createCanCommitMessages(final TransactionIdentifier txId, + final DataTreeCandidate candidate, final EffectiveModelContext schema) { + try (var cohorts = takeSnapshot()) { return new CanCommitMessageBuilder(txId, candidate, schema).perform(cohorts.getRootNode()); } } @@ -98,11 +93,10 @@ class DataTreeCohortActorRegistry extends AbstractRegistrationTree { } abstract static class CohortRegistryCommand { - private final ActorRef cohort; CohortRegistryCommand(final ActorRef cohort) { - this.cohort = Preconditions.checkNotNull(cohort); + this.cohort = requireNonNull(cohort); } ActorRef getCohort() { @@ -111,83 +105,74 @@ class DataTreeCohortActorRegistry extends AbstractRegistrationTree { } static class RegisterCohort extends CohortRegistryCommand { - private final DOMDataTreeIdentifier path; RegisterCohort(final DOMDataTreeIdentifier path, final ActorRef cohort) { super(cohort); this.path = path; - } public DOMDataTreeIdentifier getPath() { return path; } - } static class RemoveCohort extends CohortRegistryCommand { - RemoveCohort(final ActorRef cohort) { super(cohort); } - } private static class CanCommitMessageBuilder { - + private final Multimap actorToCandidates = ArrayListMultimap.create(); private final TransactionIdentifier txId; private final DataTreeCandidate candidate; - private final SchemaContext schema; - private final Collection messages = - new ArrayList<>(); + private final EffectiveModelContext schema; CanCommitMessageBuilder(final TransactionIdentifier txId, final DataTreeCandidate candidate, - final SchemaContext schema) { - this.txId = Preconditions.checkNotNull(txId); - this.candidate = Preconditions.checkNotNull(candidate); + final EffectiveModelContext schema) { + this.txId = requireNonNull(txId); + this.candidate = requireNonNull(candidate); this.schema = schema; } private void lookupAndCreateCanCommits(final List args, final int offset, - final RegistrationTreeNode node) { + final Node node) { if (args.size() != offset) { final PathArgument arg = args.get(offset); - final RegistrationTreeNode exactChild = node.getExactChild(arg); + final var exactChild = node.getExactChild(arg); if (exactChild != null) { lookupAndCreateCanCommits(args, offset + 1, exactChild); } - for (final RegistrationTreeNode c : node.getInexactChildren(arg)) { - lookupAndCreateCanCommits(args, offset + 1, c); + for (var inexact : node.getInexactChildren(arg)) { + lookupAndCreateCanCommits(args, offset + 1, inexact); } } else { lookupAndCreateCanCommits(candidate.getRootPath(), node, candidate.getRootNode()); } } - private void lookupAndCreateCanCommits(final YangInstanceIdentifier path, - final RegistrationTreeNode regNode, final DataTreeCandidateNode candNode) { - if (candNode.getModificationType() == ModificationType.UNMODIFIED) { + private void lookupAndCreateCanCommits(final YangInstanceIdentifier path, final Node regNode, + final DataTreeCandidateNode candNode) { + if (candNode.modificationType() == ModificationType.UNMODIFIED) { LOG.debug("Skipping unmodified candidate {}", path); return; } - final Collection regs = regNode.getRegistrations(); + final var regs = regNode.getRegistrations(); if (!regs.isEmpty()) { createCanCommits(regs, path, candNode); } - for (final DataTreeCandidateNode candChild : candNode.getChildNodes()) { - if (candChild.getModificationType() != ModificationType.UNMODIFIED) { - final RegistrationTreeNode regChild = - regNode.getExactChild(candChild.getIdentifier()); + for (var candChild : candNode.childNodes()) { + if (candChild.modificationType() != ModificationType.UNMODIFIED) { + final var regChild = regNode.getExactChild(candChild.name()); if (regChild != null) { - lookupAndCreateCanCommits(path.node(candChild.getIdentifier()), regChild, candChild); + lookupAndCreateCanCommits(path.node(candChild.name()), regChild, candChild); } - for (final RegistrationTreeNode rc : regNode - .getInexactChildren(candChild.getIdentifier())) { - lookupAndCreateCanCommits(path.node(candChild.getIdentifier()), rc, candChild); + for (var rc : regNode.getInexactChildren(candChild.name())) { + lookupAndCreateCanCommits(path.node(candChild.name()), rc, candChild); } } } @@ -197,24 +182,30 @@ class DataTreeCohortActorRegistry extends AbstractRegistrationTree { final DataTreeCandidateNode node) { final DOMDataTreeCandidate domCandidate = DOMDataTreeCandidateTO.create(treeIdentifier(path), node); for (final ActorRef reg : regs) { - final CanCommit message = new DataTreeCohortActor.CanCommit(txId, domCandidate, schema, reg); - messages.add(message); + actorToCandidates.put(reg, domCandidate); } } private static DOMDataTreeIdentifier treeIdentifier(final YangInstanceIdentifier path) { - return new DOMDataTreeIdentifier(LogicalDatastoreType.CONFIGURATION, path); + return DOMDataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION, path); } - private Collection perform(final RegistrationTreeNode rootNode) { - final List toLookup = candidate.getRootPath().getPathArguments(); + List perform(final Node rootNode) { + final var toLookup = candidate.getRootPath().getPathArguments(); lookupAndCreateCanCommits(toLookup, 0, rootNode); + + final Map> mapView = actorToCandidates.asMap(); + final List messages = new ArrayList<>(mapView.size()); + for (Map.Entry> entry: mapView.entrySet()) { + messages.add(new DataTreeCohortActor.CanCommit(txId, entry.getValue(), schema, entry.getKey())); + } + return messages; } } - CompositeDataTreeCohort createCohort(final SchemaContext schemaContext, final TransactionIdentifier txId, - final Timeout commitStepTimeout) { - return new CompositeDataTreeCohort(this, txId, schemaContext, commitStepTimeout); + CompositeDataTreeCohort createCohort(final EffectiveModelContext schemaContext, final TransactionIdentifier txId, + final Executor callbackExecutor, final Timeout commitStepTimeout) { + return new CompositeDataTreeCohort(this, txId, schemaContext, callbackExecutor, commitStepTimeout); } }