netconf/tools/netconf-testtool/src/main/java/org/opendaylight/netconf/test/tool/MdsalOperationProvider.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.netconf.test.tool;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import java.util.EnumMap;
  13 import java.util.HashMap;
  14 import java.util.Set;
  15 import java.util.concurrent.ExecutionException;
  16 import java.util.concurrent.ExecutorService;
  17 import java.util.function.Consumer;
  18 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  19 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  20 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  21 import org.opendaylight.mdsal.dom.api.DOMSchemaService;
  22 import org.opendaylight.mdsal.dom.api.DOMSchemaService.YangTextSourceExtension;
  23 import org.opendaylight.mdsal.dom.broker.SerializedDOMDataBroker;
  24 import org.opendaylight.mdsal.dom.spi.store.DOMStore;
  25 import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStoreFactory;
  26 import org.opendaylight.netconf.server.api.SessionIdProvider;
  27 import org.opendaylight.netconf.server.api.monitoring.Capability;
  28 import org.opendaylight.netconf.server.api.monitoring.CapabilityListener;
  29 import org.opendaylight.netconf.server.api.operations.NetconfOperation;
  30 import org.opendaylight.netconf.server.api.operations.NetconfOperationService;
  31 import org.opendaylight.netconf.server.api.operations.NetconfOperationServiceFactory;
  32 import org.opendaylight.netconf.server.mdsal.CurrentSchemaContext;
  33 import org.opendaylight.netconf.server.mdsal.TransactionProvider;
  34 import org.opendaylight.netconf.server.mdsal.operations.Commit;
  35 import org.opendaylight.netconf.server.mdsal.operations.DiscardChanges;
  36 import org.opendaylight.netconf.server.mdsal.operations.EditConfig;
  37 import org.opendaylight.netconf.server.mdsal.operations.Get;
  38 import org.opendaylight.netconf.server.mdsal.operations.GetConfig;
  39 import org.opendaylight.netconf.server.mdsal.operations.Lock;
  40 import org.opendaylight.netconf.server.mdsal.operations.Unlock;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.SessionIdType;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.Yang;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
  46 import org.opendaylight.yangtools.concepts.Registration;
  47 import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
  48 import org.opendaylight.yangtools.yang.common.QName;
  49 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  50 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  51 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  52 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  53 import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
  54 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  55 import org.slf4j.Logger;
  56 import org.slf4j.LoggerFactory;
  57
  58 class MdsalOperationProvider implements NetconfOperationServiceFactory {
  59     private static final Logger LOG = LoggerFactory.getLogger(MdsalOperationProvider.class);
  60
  61     private final Set<Capability> caps;
  62     private final EffectiveModelContext schemaContext;
  63     private final YangTextSourceExtension sourceProvider;
  64
  65     MdsalOperationProvider(final SessionIdProvider idProvider,
  66                            final Set<Capability> caps,
  67                            final EffectiveModelContext schemaContext,
  68                            final YangTextSourceExtension sourceProvider) {
  69         this.caps = caps;
  70         this.schemaContext = schemaContext;
  71         this.sourceProvider = sourceProvider;
  72     }
  73
  74     @Override
  75     public Set<Capability> getCapabilities() {
  76         return caps;
  77     }
  78
  79     @Override
  80     public Registration registerCapabilityListener(final CapabilityListener listener) {
  81         listener.onCapabilitiesChanged(caps, Set.of());
  82         return () -> { };
  83     }
  84
  85     @Override
  86     public NetconfOperationService createService(final SessionIdType sessionId) {
  87         return new MdsalOperationService(sessionId, schemaContext, caps, sourceProvider);
  88     }
  89
  90     static class MdsalOperationService implements NetconfOperationService {
  91         private final SessionIdType currentSessionId;
  92         private final EffectiveModelContext schemaContext;
  93         private final Set<Capability> caps;
  94         private final DOMSchemaService schemaService;
  95         private final DOMDataBroker dataBroker;
  96         private final YangTextSourceExtension sourceProvider;
  97
  98         MdsalOperationService(final SessionIdType currentSessionId, final EffectiveModelContext schemaContext,
  99                               final Set<Capability> caps, final YangTextSourceExtension sourceProvider) {
 100             this.currentSessionId = requireNonNull(currentSessionId);
 101             this.schemaContext = schemaContext;
 102             this.caps = caps;
 103             this.sourceProvider = sourceProvider;
 104             schemaService = createSchemaService();
 105
 106             dataBroker = createDataStore(schemaService, currentSessionId);
 107         }
 108
 109         @Override
 110         public Set<NetconfOperation> getNetconfOperations() {
 111             ContainerNode netconf = createNetconfState();
 112
 113             final DOMDataTreeWriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 114             tx.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.of(NetconfState.QNAME), netconf);
 115
 116             try {
 117                 tx.commit().get();
 118                 LOG.debug("Netconf state updated successfully");
 119             } catch (InterruptedException | ExecutionException e) {
 120                 LOG.warn("Unable to update netconf state", e);
 121             }
 122
 123             TransactionProvider transactionProvider = new TransactionProvider(dataBroker, currentSessionId);
 124             CurrentSchemaContext currentSchemaContext = CurrentSchemaContext.create(schemaService, sourceProvider);
 125
 126             final Get get = new Get(currentSessionId, currentSchemaContext, transactionProvider);
 127             final EditConfig editConfig = new EditConfig(currentSessionId, currentSchemaContext, transactionProvider);
 128             final GetConfig getConfig = new GetConfig(currentSessionId, currentSchemaContext, transactionProvider);
 129             final Commit commit = new Commit(currentSessionId, transactionProvider);
 130             final Lock lock = new Lock(currentSessionId);
 131             final Unlock unLock = new Unlock(currentSessionId);
 132             final DiscardChanges discardChanges = new DiscardChanges(currentSessionId, transactionProvider);
 133
 134             return Set.of(get, getConfig, editConfig, commit, lock, unLock, discardChanges);
 135         }
 136
 137         @Override
 138         public void close() {
 139             // No-op
 140         }
 141
 142         private ContainerNode createNetconfState() {
 143             final DummyMonitoringService monitor = new DummyMonitoringService(caps);
 144             final QName identifier = QName.create(Schema.QNAME, "identifier");
 145             final QName version = QName.create(Schema.QNAME, "version");
 146             final QName format = QName.create(Schema.QNAME, "format");
 147             final QName location = QName.create(Schema.QNAME, "location");
 148             final QName namespace = QName.create(Schema.QNAME, "namespace");
 149
 150             final var schemaMapEntryNodeMapNodeCollectionNodeBuilder = ImmutableNodes.newSystemMapBuilder()
 151                 .withNodeIdentifier(new NodeIdentifier(Schema.QNAME));
 152             final var locationLeafSet = ImmutableNodes.<String>newSystemLeafSetBuilder()
 153                 .withNodeIdentifier(new NodeIdentifier(location))
 154                 .withChildValue("NETCONF")
 155                 .build();
 156
 157             final var keyValues = new HashMap<QName, Object>();
 158             for (final Schema schema : monitor.getSchemas().nonnullSchema().values()) {
 159                 keyValues.put(identifier, schema.getIdentifier());
 160                 keyValues.put(version, schema.getVersion());
 161                 keyValues.put(format, Yang.QNAME);
 162
 163                 schemaMapEntryNodeMapNodeCollectionNodeBuilder.withChild(ImmutableNodes.newMapEntryBuilder()
 164                     .withNodeIdentifier(NodeIdentifierWithPredicates.of(Schema.QNAME, keyValues))
 165                     .withChild(ImmutableNodes.leafNode(identifier, schema.getIdentifier()))
 166                     .withChild(ImmutableNodes.leafNode(version, schema.getVersion()))
 167                     .withChild(ImmutableNodes.leafNode(format, Yang.QNAME))
 168                     .withChild(ImmutableNodes.leafNode(namespace, schema.getNamespace().getValue()))
 169                     .withChild(locationLeafSet)
 170                     .build());
 171             }
 172
 173             return ImmutableNodes.newContainerBuilder()
 174                 .withNodeIdentifier(new NodeIdentifier(NetconfState.QNAME))
 175                 .withChild(ImmutableNodes.newContainerBuilder()
 176                     .withNodeIdentifier(new NodeIdentifier(Schemas.QNAME))
 177                     .withChild(schemaMapEntryNodeMapNodeCollectionNodeBuilder.build())
 178                     .build())
 179                 .build();
 180         }
 181
 182         private static DOMDataBroker createDataStore(final DOMSchemaService schemaService,
 183                 final SessionIdType sessionId) {
 184             LOG.debug("Session {}: Creating data stores for simulated device", sessionId.getValue());
 185             final DOMStore operStore = InMemoryDOMDataStoreFactory.create("DOM-OPER", schemaService);
 186             final DOMStore configStore = InMemoryDOMDataStoreFactory.create("DOM-CFG", schemaService);
 187
 188             ExecutorService listenableFutureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(16, 16,
 189                 "CommitFutures", MdsalOperationProvider.class);
 190
 191             final var datastores = new EnumMap<LogicalDatastoreType, DOMStore>(LogicalDatastoreType.class);
 192             datastores.put(LogicalDatastoreType.CONFIGURATION, configStore);
 193             datastores.put(LogicalDatastoreType.OPERATIONAL, operStore);
 194
 195             return new SerializedDOMDataBroker(datastores, listenableFutureExecutor);
 196         }
 197
 198         private DOMSchemaService createSchemaService() {
 199             return new DOMSchemaService() {
 200                 @Override
 201                 public EffectiveModelContext getGlobalContext() {
 202                     return schemaContext;
 203                 }
 204
 205                 @Override
 206                 public Registration registerSchemaContextListener(final Consumer<EffectiveModelContext> listener) {
 207                     listener.accept(getGlobalContext());
 208                     return () -> {
 209                         // No-op
 210                     };
 211                 }
 212             };
 213         }
 214     }
 215 }