Integrate netconf-mapping-api into netconf-server
[netconf.git] / 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 com.google.common.util.concurrent.MoreExecutors;
11 import java.util.EnumMap;
12 import java.util.HashMap;
13 import java.util.Map;
14 import java.util.Set;
15 import java.util.concurrent.ExecutionException;
16 import java.util.concurrent.ExecutorService;
17 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
18 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
19 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
20 import org.opendaylight.mdsal.dom.api.DOMSchemaService;
21 import org.opendaylight.mdsal.dom.broker.SerializedDOMDataBroker;
22 import org.opendaylight.mdsal.dom.spi.store.DOMStore;
23 import org.opendaylight.mdsal.dom.store.inmemory.InMemoryDOMDataStoreFactory;
24 import org.opendaylight.netconf.api.capability.Capability;
25 import org.opendaylight.netconf.api.monitoring.CapabilityListener;
26 import org.opendaylight.netconf.mdsal.connector.CurrentSchemaContext;
27 import org.opendaylight.netconf.mdsal.connector.TransactionProvider;
28 import org.opendaylight.netconf.mdsal.connector.ops.Commit;
29 import org.opendaylight.netconf.mdsal.connector.ops.DiscardChanges;
30 import org.opendaylight.netconf.mdsal.connector.ops.EditConfig;
31 import org.opendaylight.netconf.mdsal.connector.ops.Lock;
32 import org.opendaylight.netconf.mdsal.connector.ops.Unlock;
33 import org.opendaylight.netconf.mdsal.connector.ops.get.Get;
34 import org.opendaylight.netconf.mdsal.connector.ops.get.GetConfig;
35 import org.opendaylight.netconf.server.api.SessionIdProvider;
36 import org.opendaylight.netconf.server.api.operations.NetconfOperation;
37 import org.opendaylight.netconf.server.api.operations.NetconfOperationService;
38 import org.opendaylight.netconf.server.api.operations.NetconfOperationServiceFactory;
39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.Yang;
41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
43 import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
44 import org.opendaylight.yangtools.concepts.ListenerRegistration;
45 import org.opendaylight.yangtools.concepts.Registration;
46 import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
47 import org.opendaylight.yangtools.yang.common.QName;
48 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
49 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
50 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
51 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
52 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
53 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
54 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
55 import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
56 import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
57 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
58 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
59 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
60 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
61 import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
62 import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
63 import org.slf4j.Logger;
64 import org.slf4j.LoggerFactory;
65
66 class MdsalOperationProvider implements NetconfOperationServiceFactory {
67     private static final Logger LOG = LoggerFactory.getLogger(MdsalOperationProvider.class);
68
69     private final Set<Capability> caps;
70     private final EffectiveModelContext schemaContext;
71     private final SchemaSourceProvider<YangTextSchemaSource> sourceProvider;
72
73     MdsalOperationProvider(final SessionIdProvider idProvider,
74                            final Set<Capability> caps,
75                            final EffectiveModelContext schemaContext,
76                            final SchemaSourceProvider<YangTextSchemaSource> sourceProvider) {
77         this.caps = caps;
78         this.schemaContext = schemaContext;
79         this.sourceProvider = sourceProvider;
80     }
81
82     @Override
83     public Set<Capability> getCapabilities() {
84         return caps;
85     }
86
87     @Override
88     public Registration registerCapabilityListener(final CapabilityListener listener) {
89         listener.onCapabilitiesChanged(caps, Set.of());
90         return () -> { };
91     }
92
93     @Override
94     public NetconfOperationService createService(final String netconfSessionIdForReporting) {
95         return new MdsalOperationService(Long.parseLong(netconfSessionIdForReporting), schemaContext, caps,
96             sourceProvider);
97     }
98
99     static class MdsalOperationService implements NetconfOperationService {
100         private final String currentSessionId;
101         private final EffectiveModelContext schemaContext;
102         private final Set<Capability> caps;
103         private final DOMSchemaService schemaService;
104         private final DOMDataBroker dataBroker;
105         private final SchemaSourceProvider<YangTextSchemaSource> sourceProvider;
106
107         MdsalOperationService(final long currentSessionId, final EffectiveModelContext schemaContext,
108                               final Set<Capability> caps,
109                               final SchemaSourceProvider<YangTextSchemaSource> sourceProvider) {
110             this.currentSessionId = String.valueOf(currentSessionId);
111             this.schemaContext = schemaContext;
112             this.caps = caps;
113             this.sourceProvider = sourceProvider;
114             schemaService = createSchemaService();
115
116             dataBroker = createDataStore(schemaService, currentSessionId);
117
118         }
119
120         @Override
121         public Set<NetconfOperation> getNetconfOperations() {
122             ContainerNode netconf = createNetconfState();
123
124             final DOMDataTreeWriteTransaction tx = dataBroker.newWriteOnlyTransaction();
125             tx.put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.of(NetconfState.QNAME), netconf);
126
127             try {
128                 tx.commit().get();
129                 LOG.debug("Netconf state updated successfully");
130             } catch (InterruptedException | ExecutionException e) {
131                 LOG.warn("Unable to update netconf state", e);
132             }
133
134             TransactionProvider transactionProvider = new TransactionProvider(dataBroker, currentSessionId);
135             CurrentSchemaContext currentSchemaContext = CurrentSchemaContext.create(schemaService, sourceProvider);
136
137             final Get get = new Get(currentSessionId, currentSchemaContext, transactionProvider);
138             final EditConfig editConfig = new EditConfig(currentSessionId, currentSchemaContext, transactionProvider);
139             final GetConfig getConfig = new GetConfig(currentSessionId, currentSchemaContext, transactionProvider);
140             final Commit commit = new Commit(currentSessionId, transactionProvider);
141             final Lock lock = new Lock(currentSessionId);
142             final Unlock unLock = new Unlock(currentSessionId);
143             final DiscardChanges discardChanges = new DiscardChanges(currentSessionId, transactionProvider);
144
145             return Set.of(get, getConfig, editConfig, commit, lock, unLock, discardChanges);
146         }
147
148         @Override
149         public void close() {
150             // No-op
151         }
152
153         private ContainerNode createNetconfState() {
154             final DummyMonitoringService monitor = new DummyMonitoringService(caps);
155             final QName identifier = QName.create(Schema.QNAME, "identifier");
156             final QName version = QName.create(Schema.QNAME, "version");
157             final QName format = QName.create(Schema.QNAME, "format");
158             final QName location = QName.create(Schema.QNAME, "location");
159             final QName namespace = QName.create(Schema.QNAME, "namespace");
160
161             CollectionNodeBuilder<MapEntryNode, SystemMapNode> schemaMapEntryNodeMapNodeCollectionNodeBuilder =
162                 Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(Schema.QNAME));
163             LeafSetNode<String> locationLeafSet = Builders.<String>leafSetBuilder()
164                 .withNodeIdentifier(new NodeIdentifier(location))
165                 .withChild(Builders.<String>leafSetEntryBuilder()
166                     .withNodeIdentifier(new NodeWithValue<>(location, "NETCONF"))
167                     .withValue("NETCONF")
168                     .build())
169                 .build();
170
171             Map<QName, Object> keyValues = new HashMap<>();
172             for (final Schema schema : monitor.getSchemas().nonnullSchema().values()) {
173                 keyValues.put(identifier, schema.getIdentifier());
174                 keyValues.put(version, schema.getVersion());
175                 keyValues.put(format, Yang.QNAME);
176
177                 schemaMapEntryNodeMapNodeCollectionNodeBuilder.withChild(Builders.mapEntryBuilder()
178                     .withNodeIdentifier(NodeIdentifierWithPredicates.of(Schema.QNAME, keyValues))
179                     .withChild(ImmutableNodes.leafNode(identifier, schema.getIdentifier()))
180                     .withChild(ImmutableNodes.leafNode(version, schema.getVersion()))
181                     .withChild(ImmutableNodes.leafNode(format, Yang.QNAME))
182                     .withChild(ImmutableNodes.leafNode(namespace, schema.getNamespace().getValue()))
183                     .withChild(locationLeafSet)
184                     .build());
185             }
186
187             return Builders.containerBuilder()
188                 .withNodeIdentifier(new NodeIdentifier(NetconfState.QNAME))
189                 .withChild(Builders.containerBuilder()
190                     .withNodeIdentifier(new NodeIdentifier(Schemas.QNAME))
191                     .withChild(schemaMapEntryNodeMapNodeCollectionNodeBuilder.build())
192                     .build())
193                 .build();
194         }
195
196         private static DOMDataBroker createDataStore(final DOMSchemaService schemaService, final long sessionId) {
197             LOG.debug("Session {}: Creating data stores for simulated device", sessionId);
198             final DOMStore operStore = InMemoryDOMDataStoreFactory.create("DOM-OPER", schemaService);
199             final DOMStore configStore = InMemoryDOMDataStoreFactory.create("DOM-CFG", schemaService);
200
201             ExecutorService listenableFutureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(16, 16,
202                 "CommitFutures", MdsalOperationProvider.class);
203
204             final EnumMap<LogicalDatastoreType, DOMStore> datastores = new EnumMap<>(LogicalDatastoreType.class);
205             datastores.put(LogicalDatastoreType.CONFIGURATION, configStore);
206             datastores.put(LogicalDatastoreType.OPERATIONAL, operStore);
207
208             return new SerializedDOMDataBroker(datastores, MoreExecutors.listeningDecorator(listenableFutureExecutor));
209         }
210
211         private DOMSchemaService createSchemaService() {
212             return new DOMSchemaService() {
213                 @Override
214                 public EffectiveModelContext getGlobalContext() {
215                     return schemaContext;
216                 }
217
218                 @Override
219                 public ListenerRegistration<EffectiveModelContextListener> registerSchemaContextListener(
220                         final EffectiveModelContextListener listener) {
221                     listener.onModelContextUpdated(getGlobalContext());
222                     return new AbstractListenerRegistration<>(listener) {
223                         @Override
224                         protected void removeRegistration() {
225                             // No-op
226                         }
227                     };
228                 }
229             };
230         }
231     }
232 }