*/
package org.opendaylight.protocol.bgp.rib.impl;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
+import static java.util.Objects.requireNonNull;
+import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.BGPRIB_NID;
+import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.LOCRIB_NID;
+import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.PEER_NID;
+import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.RIB_NID;
+import static org.opendaylight.protocol.bgp.rib.spi.RIBNodeIdentifiers.TABLES_NID;
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import javax.annotation.Nonnull;
+import javax.annotation.concurrent.GuardedBy;
import javax.annotation.concurrent.ThreadSafe;
-
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
-import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
-import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
-import org.opendaylight.protocol.bgp.rib.spi.AdjRIBsIn;
+import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataBrokerExtension;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
+import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
+import org.opendaylight.protocol.bgp.mode.api.PathSelectionMode;
+import org.opendaylight.protocol.bgp.mode.impl.base.BasePathSelectionModeFactory;
+import org.opendaylight.protocol.bgp.openconfig.spi.BGPTableTypeRegistryConsumer;
+import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
+import org.opendaylight.protocol.bgp.rib.impl.spi.CodecsRegistry;
+import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
+import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
+import org.opendaylight.protocol.bgp.rib.impl.spi.RibOutRefresh;
+import org.opendaylight.protocol.bgp.rib.impl.state.BGPRIBStateImpl;
+import org.opendaylight.protocol.bgp.rib.spi.BGPPeerTracker;
import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionConsumerContext;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130918.Update;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130918.update.PathAttributes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130918.PathAttributes1;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130918.PathAttributes2;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130918.update.path.attributes.MpReachNlri;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130918.update.path.attributes.MpUnreachNlri;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.rib.TablesKey;
-import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.protocol.bgp.rib.spi.RIBSupport;
+import org.opendaylight.protocol.bgp.rib.spi.policy.BGPRibRoutingPolicy;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev180329.BgpTableType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.BgpRib;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.PeerId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.RibId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.Route;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.Rib;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.bgp.rib.RibKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.Tables;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.TablesKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev180329.rib.tables.Routes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev180329.BgpId;
+import org.opendaylight.yangtools.yang.binding.ChildOf;
+import org.opendaylight.yangtools.yang.binding.ChoiceIn;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Objects;
-import com.google.common.base.Objects.ToStringHelper;
-import com.google.common.base.Preconditions;
-
@ThreadSafe
-public class RIBImpl {
- private static final Logger LOG = LoggerFactory.getLogger(RIBImpl.class);
- private final DataProviderService dps;
- private final RIBTables tables;
-
- public RIBImpl(final RIBExtensionConsumerContext extensions, final DataProviderService dps) {
- this.dps = Preconditions.checkNotNull(dps);
- this.tables = new RIBTables(BGPObjectComparator.INSTANCE, extensions);
- }
-
- synchronized void updateTables(final BGPPeer peer, final Update message) {
- final DataModificationTransaction trans = this.dps.beginTransaction();
-
- // FIXME: detect and handle end-of-RIB markers
-
- // remove(Ipv4AddressFamily.class, UnicastSubsequentAddressFamily.class,
- // trans, peer, message.getWithdrawnRoutes().getWithdrawnRoutes().iterator());
-
- final PathAttributes attrs = message.getPathAttributes();
- final PathAttributes2 mpu = attrs.getAugmentation(PathAttributes2.class);
- if (mpu != null) {
- final MpUnreachNlri nlri = mpu.getMpUnreachNlri();
-
- final AdjRIBsIn ari = this.tables.getOrCreate(new TablesKey(nlri.getAfi(), nlri.getSafi()));
- if (ari != null) {
- ari.removeRoutes(trans, peer, nlri);
- } else {
- LOG.debug("Not removing objects from unhandled NLRI {}", nlri);
- }
- }
-
- // add(Ipv4AddressFamily.class, UnicastSubsequentAddressFamily.class,
- // trans, peer, message.getNlri().getNlri().iterator(), attrs);
-
- final PathAttributes1 mpr = message.getPathAttributes().getAugmentation(PathAttributes1.class);
- if (mpr != null) {
- final MpReachNlri nlri = mpr.getMpReachNlri();
-
- final AdjRIBsIn ari = this.tables.getOrCreate(new TablesKey(nlri.getAfi(), nlri.getSafi()));
- if (ari != null) {
- ari.addRoutes(trans, peer, nlri, attrs);
- } else {
- LOG.debug("Not adding objects from unhandled NLRI {}", nlri);
- }
- }
-
- // FIXME: we need to attach to this future for failures
- final Future<RpcResult<TransactionStatus>> f = trans.commit();
- try {
- f.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Failed to commit RIB modification", e);
- }
- }
-
- synchronized void clearTable(final BGPPeer peer, final TablesKey key) {
- final AdjRIBsIn ari = this.tables.get(key);
- if (ari != null) {
- final DataModificationTransaction trans = this.dps.beginTransaction();
- ari.clear(trans, peer);
-
- // FIXME: we need to attach to this future for failures
- final Future<RpcResult<TransactionStatus>> f = trans.commit();
- try {
- f.get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("Failed to commit RIB modification", e);
- }
- }
- }
-
- @Override
- public String toString() {
- return addToStringAttributes(Objects.toStringHelper(this)).toString();
- }
-
- protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
- return toStringHelper;
- }
+public final class RIBImpl extends BGPRIBStateImpl implements RIB, TransactionChainListener,
+ SchemaContextListener, AutoCloseable {
+ private static final Logger LOG = LoggerFactory.getLogger(RIBImpl.class);
+ private static final QName RIB_ID_QNAME = QName.create(Rib.QNAME, "id").intern();
+
+ private final BGPDispatcher dispatcher;
+ private final AsNumber localAs;
+ private final BgpId bgpIdentifier;
+ private final Set<BgpTableType> localTables;
+ private final Set<TablesKey> localTablesKeys;
+ private final DOMDataBroker domDataBroker;
+ private final DataBroker dataBroker;
+ private final RIBExtensionConsumerContext extensions;
+ private final YangInstanceIdentifier yangRibId;
+ private final RIBSupportContextRegistryImpl ribContextRegistry;
+ private final CodecsRegistryImpl codecsRegistry;
+ private final BGPTableTypeRegistryConsumer tableTypeRegistry;
+ private final DOMDataBrokerExtension domService;
+ private final Map<TransactionChain<?, ?>, LocRibWriter> txChainToLocRibWriter = new HashMap<>();
+ private final Map<TablesKey, PathSelectionMode> bestPathSelectionStrategies;
+ private final RibId ribId;
+ private final BGPPeerTracker peerTracker = new BGPPeerTrackerImpl();
+ private final BGPRibRoutingPolicy ribPolicies;
+ @GuardedBy("this")
+ private ClusterSingletonServiceRegistration registration;
+ @GuardedBy("this")
+ private DOMTransactionChain domChain;
+ @GuardedBy("this")
+ private boolean isServiceInstantiated;
+ private final Map<TablesKey, RibOutRefresh> vpnTableRefresher = new HashMap<>();
+
+ public RIBImpl(
+ final BGPTableTypeRegistryConsumer tableTypeRegistry,
+ final RibId ribId,
+ final AsNumber localAs,
+ final BgpId localBgpId,
+ final RIBExtensionConsumerContext extensions,
+ final BGPDispatcher dispatcher,
+ final CodecsRegistryImpl codecsRegistry,
+ final DOMDataBroker domDataBroker,
+ final DataBroker dataBroker,
+ final BGPRibRoutingPolicy ribPolicies,
+ final List<BgpTableType> localTables,
+ final Map<TablesKey, PathSelectionMode> bestPathSelectionStrategies
+ ) {
+ super(InstanceIdentifier.create(BgpRib.class).child(Rib.class, new RibKey(requireNonNull(ribId))),
+ localBgpId, localAs);
+ this.tableTypeRegistry = requireNonNull(tableTypeRegistry);
+ this.localAs = requireNonNull(localAs);
+ this.bgpIdentifier = requireNonNull(localBgpId);
+ this.dispatcher = requireNonNull(dispatcher);
+ this.localTables = ImmutableSet.copyOf(localTables);
+ this.localTablesKeys = new HashSet<>();
+ this.domDataBroker = requireNonNull(domDataBroker);
+ this.dataBroker = requireNonNull(dataBroker);
+ this.domService = this.domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);
+ this.extensions = requireNonNull(extensions);
+ this.ribPolicies = requireNonNull(ribPolicies);
+ this.codecsRegistry = codecsRegistry;
+ this.ribContextRegistry = RIBSupportContextRegistryImpl.create(extensions, this.codecsRegistry);
+ final InstanceIdentifierBuilder yangRibIdBuilder = YangInstanceIdentifier.builder().node(BGPRIB_NID).node(RIB_NID);
+ this.yangRibId = yangRibIdBuilder.nodeWithKey(Rib.QNAME, RIB_ID_QNAME, ribId.getValue()).build();
+ this.bestPathSelectionStrategies = requireNonNull(bestPathSelectionStrategies);
+ this.ribId = ribId;
+
+ for (final BgpTableType t : this.localTables) {
+ final TablesKey key = new TablesKey(t.getAfi(), t.getSafi());
+ this.localTablesKeys.add(key);
+ }
+ }
+
+ private synchronized void startLocRib(final TablesKey key) {
+ LOG.debug("Creating LocRib table for {}", key);
+ // create locRibWriter for each table
+ final DOMDataWriteTransaction tx = this.domChain.newWriteOnlyTransaction();
+
+ final RIBSupport<? extends Routes, ?, ?, ?> ribSupport = this.ribContextRegistry.getRIBSupport(key);
+ if (ribSupport != null) {
+ final MapEntryNode emptyTable = ribSupport.emptyTable();
+ final InstanceIdentifierBuilder tableId = YangInstanceIdentifier
+ .builder(this.yangRibId.node(LOCRIB_NID).node(TABLES_NID)).node(emptyTable.getIdentifier());
+
+ tx.put(LogicalDatastoreType.OPERATIONAL, tableId.build(), emptyTable);
+ try {
+ tx.commit().get();
+ } catch (final InterruptedException | ExecutionException e1) {
+ LOG.error("Failed to initiate LocRIB for key {}", key, e1);
+ }
+ } else {
+ LOG.warn("There's no registered RIB Context for {}", key.getAfi());
+ }
+ }
+
+ private synchronized <C extends Routes & DataObject & ChoiceIn<Tables>, S extends ChildOf<? super C>,
+ R extends Route & ChildOf<? super S> & Identifiable<I>, I extends Identifier<R>>
+ void createLocRibWriter(final TablesKey key) {
+ final RIBSupport<C, S, R, I> ribSupport = this.ribContextRegistry.getRIBSupport(key);
+ if (ribSupport == null) {
+ return;
+ }
+ LOG.debug("Creating LocRIB writer for key {}", key);
+ final BindingTransactionChain txChain = createPeerChain(this);
+ PathSelectionMode pathSelectionStrategy = this.bestPathSelectionStrategies.get(key);
+ if (pathSelectionStrategy == null) {
+ pathSelectionStrategy = BasePathSelectionModeFactory.createBestPathSelectionStrategy();
+ }
+
+ final LocRibWriter<C, S, R, I> locRibWriter = LocRibWriter.create(
+ ribSupport,
+ this.tableTypeRegistry.getAfiSafiType(key).get(),
+ txChain,
+ getInstanceIdentifier(),
+ this.localAs,
+ getDataBroker(),
+ this.ribPolicies,
+ this.peerTracker,
+ pathSelectionStrategy);
+ this.vpnTableRefresher.put(key, locRibWriter);
+ registerTotalPathCounter(key, locRibWriter);
+ registerTotalPrefixesCounter(key, locRibWriter);
+ this.txChainToLocRibWriter.put(txChain, locRibWriter);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(this).add("bgpId", bgpIdentifier).add("localTables", localTables).toString();
+ }
+
+ @Override
+ public synchronized void close() throws Exception {
+ if (this.registration != null) {
+ this.registration.close();
+ this.registration = null;
+ }
+ }
+
+ @Override
+ public AsNumber getLocalAs() {
+ return this.localAs;
+ }
+
+ @Override
+ public BgpId getBgpIdentifier() {
+ return this.bgpIdentifier;
+ }
+
+ @Nonnull
+ @Override
+ public Set<? extends BgpTableType> getLocalTables() {
+ return this.localTables;
+ }
+
+ @Override
+ public BGPDispatcher getDispatcher() {
+ return this.dispatcher;
+ }
+
+ @Override
+ public synchronized void onTransactionChainFailed(final TransactionChain<?, ?> chain,
+ final AsyncTransaction<?, ?> transaction, final Throwable cause) {
+ LOG.error("Broken chain in RIB {} transaction {}",
+ getInstanceIdentifier(), transaction != null ? transaction.getIdentifier() : null, cause);
+ if (this.txChainToLocRibWriter.containsKey(chain)) {
+ final LocRibWriter locRibWriter = this.txChainToLocRibWriter.remove(chain);
+ final BindingTransactionChain newChain = createPeerChain(this);
+ startLocRib(locRibWriter.getTableKey());
+ locRibWriter.restart(newChain);
+ this.txChainToLocRibWriter.put(newChain, locRibWriter);
+ }
+ }
+
+ @Override
+ public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ LOG.info("RIB {} closed successfully", getInstanceIdentifier());
+ }
+
+ @Override
+ public Set<TablesKey> getLocalTablesKeys() {
+ return this.localTablesKeys;
+ }
+
+ @Override
+ public boolean supportsTable(final TablesKey tableKey) {
+ return this.localTablesKeys.contains(tableKey);
+ }
+
+ @Override
+ public BGPRibRoutingPolicy getRibPolicies() {
+ return this.ribPolicies;
+ }
+
+ @Override
+ public BGPPeerTracker getPeerTracker() {
+ return this.peerTracker;
+ }
+
+ @Override
+ public void refreshTable(final TablesKey tk, final PeerId peerId) {
+ final RibOutRefresh table = this.vpnTableRefresher.get(tk);
+ if (table != null) {
+ table.refreshTable(tk, peerId);
+ }
+ }
+
+ @Override
+ public DOMDataTreeChangeService getService() {
+ return (DOMDataTreeChangeService) this.domService;
+ }
+
+ @Override
+ public DataBroker getDataBroker() {
+ return this.dataBroker;
+ }
+
+ @Override
+ public YangInstanceIdentifier getYangRibId() {
+ return this.yangRibId;
+ }
+
+ @Override
+ public BindingTransactionChain createPeerChain(final TransactionChainListener listener) {
+ return this.dataBroker.createTransactionChain(listener);
+ }
+
+ @Override
+ public DOMTransactionChain createPeerDOMChain(final TransactionChainListener listener) {
+ return this.domDataBroker.createTransactionChain(listener);
+ }
+
+ @Override
+ public RIBExtensionConsumerContext getRibExtensions() {
+ return this.extensions;
+ }
+
+ @Override
+ public RIBSupportContextRegistry getRibSupportContext() {
+ return this.ribContextRegistry;
+ }
+
+ @Override
+ public void onGlobalContextUpdated(final SchemaContext context) {
+ this.codecsRegistry.onSchemaContextUpdated(context);
+ }
+
+ @Override
+ public CodecsRegistry getCodecsRegistry() {
+ return this.codecsRegistry;
+ }
+
+ public synchronized void instantiateServiceInstance() {
+ this.isServiceInstantiated = true;
+ setActive(true);
+ this.domChain = this.domDataBroker.createTransactionChain(this);
+ LOG.debug("Instantiating RIB table {} at {}", this.ribId, this.yangRibId);
+
+ final ContainerNode bgpRib = Builders.containerBuilder().withNodeIdentifier(BGPRIB_NID)
+ .addChild(ImmutableNodes.mapNodeBuilder(RIB_NID).build()).build();
+
+ final MapEntryNode ribInstance = Builders.mapEntryBuilder().withNodeIdentifier(
+ new NodeIdentifierWithPredicates(Rib.QNAME, RIB_ID_QNAME, this.ribId.getValue()))
+ .addChild(ImmutableNodes.leafNode(RIB_ID_QNAME, this.ribId.getValue()))
+ .addChild(ImmutableNodes.mapNodeBuilder(PEER_NID).build())
+ .addChild(Builders.containerBuilder().withNodeIdentifier(LOCRIB_NID)
+ .addChild(ImmutableNodes.mapNodeBuilder(TABLES_NID).build())
+ .build()).build();
+
+ final DOMDataWriteTransaction trans = this.domChain.newWriteOnlyTransaction();
+
+ // merge empty BgpRib + Rib, to make sure the top-level parent structure is present
+ trans.merge(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.create(BGPRIB_NID), bgpRib);
+ trans.put(LogicalDatastoreType.OPERATIONAL, this.yangRibId, ribInstance);
+
+ try {
+ trans.commit().get();
+ } catch (final InterruptedException | ExecutionException e) {
+ LOG.error("Failed to initiate RIB {}", this.yangRibId, e);
+ }
+
+ LOG.debug("Effective RIB created.");
+
+ this.localTablesKeys.forEach(this::startLocRib);
+ this.localTablesKeys.forEach(this::createLocRibWriter);
+ }
+
+ public synchronized FluentFuture<? extends CommitInfo> closeServiceInstance() {
+ if (!this.isServiceInstantiated) {
+ LOG.trace("RIB {} already closed", this.ribId.getValue());
+ return CommitInfo.emptyFluentFuture();
+ }
+ LOG.info("Close RIB {}", this.ribId.getValue());
+ this.isServiceInstantiated = false;
+ setActive(false);
+
+ this.txChainToLocRibWriter.values().forEach(LocRibWriter::close);
+ this.txChainToLocRibWriter.clear();
+
+ final DOMDataWriteTransaction t = this.domChain.newWriteOnlyTransaction();
+ t.delete(LogicalDatastoreType.OPERATIONAL, getYangRibId());
+ final FluentFuture<? extends CommitInfo> cleanFuture = t.commit();
+ cleanFuture.addCallback(new FutureCallback<CommitInfo>() {
+ @Override
+ public void onSuccess(final CommitInfo result) {
+ LOG.info("RIB cleaned {}", RIBImpl.this.ribId.getValue());
+ }
+
+ @Override
+ public void onFailure(final Throwable throwable) {
+ LOG.error("Failed to clean RIB {}",
+ RIBImpl.this.ribId.getValue(), throwable);
+ }
+ }, MoreExecutors.directExecutor());
+ this.domChain.close();
+ return cleanFuture;
+ }
}
Code Review / bgpcep.git / blobdiff