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=05ebe55bc6b6713932100c35b0f8cce6884fae8f;hpb=806ca77eb8f5c6a7de07f5f6a0f2b3d234752050;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 05ebe55bc6..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,14 +5,14 @@ * 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; @@ -20,34 +20,30 @@ import java.util.Collection; 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.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 new ArrayList<>(cohortToNode.keySet()); @@ -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,82 +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 Multimap actorToCandidates = ArrayListMultimap.create(); + 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); } } } @@ -201,15 +187,15 @@ class DataTreeCohortActorRegistry extends AbstractRegistrationTree { } 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(); - Collection messages = new ArrayList<>(mapView.size()); + final List messages = new ArrayList<>(mapView.size()); for (Map.Entry> entry: mapView.entrySet()) { messages.add(new DataTreeCohortActor.CanCommit(txId, entry.getValue(), schema, entry.getKey())); } @@ -218,8 +204,8 @@ class DataTreeCohortActorRegistry extends AbstractRegistrationTree { } } - 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); } }