d758073a8e5839e942669428239b72d444e646d2
[controller.git] / opendaylight / md-sal / sal-netconf-connector / src / main / java / org / opendaylight / controller / sal / connect / netconf / NetconfStateSchemas.java
1 package org.opendaylight.controller.sal.connect.netconf;
2
3 import com.google.common.annotations.VisibleForTesting;
4 import com.google.common.base.Function;
5 import com.google.common.base.Optional;
6 import com.google.common.base.Preconditions;
7 import com.google.common.collect.Collections2;
8 import com.google.common.collect.Lists;
9 import com.google.common.collect.Sets;
10 import java.net.URI;
11 import java.util.Collections;
12 import java.util.Set;
13 import java.util.concurrent.ExecutionException;
14 import org.opendaylight.controller.sal.connect.netconf.listener.NetconfSessionCapabilities;
15 import org.opendaylight.controller.sal.connect.netconf.sal.NetconfDeviceRpc;
16 import org.opendaylight.controller.sal.connect.netconf.util.NetconfMessageTransformUtil;
17 import org.opendaylight.controller.sal.connect.util.RemoteDeviceId;
18 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState;
19 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.Yang;
20 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
21 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
22 import org.opendaylight.yangtools.yang.common.QName;
23 import org.opendaylight.yangtools.yang.common.RpcResult;
24 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
25 import org.opendaylight.yangtools.yang.data.api.Node;
26 import org.opendaylight.yangtools.yang.data.api.SimpleNode;
27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
28 import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
29 import org.slf4j.Logger;
30 import org.slf4j.LoggerFactory;
31
32 /**
33  * Holds QNames for all yang modules reported by ietf-netconf-monitoring/state/schemas
34  */
35 public final class NetconfStateSchemas {
36
37     private static final Logger logger = LoggerFactory.getLogger(NetconfStateSchemas.class);
38
39     /**
40      * Factory for NetconfStateSchemas
41      */
42     public interface NetconfStateSchemasResolver {
43         NetconfStateSchemas resolve(final NetconfDeviceRpc deviceRpc, final NetconfSessionCapabilities remoteSessionCapabilities, final RemoteDeviceId id);
44     }
45
46     /**
47      * Default implementation resolving schemas QNames from netconf-state
48      */
49     public static final class NetconfStateSchemasResolverImpl implements NetconfStateSchemasResolver {
50
51         @Override
52         public NetconfStateSchemas resolve(final NetconfDeviceRpc deviceRpc, final NetconfSessionCapabilities remoteSessionCapabilities, final RemoteDeviceId id) {
53             return NetconfStateSchemas.create(deviceRpc, remoteSessionCapabilities, id);
54         }
55     }
56
57     public static final NetconfStateSchemas EMPTY = new NetconfStateSchemas(Collections.<RemoteYangSchema>emptySet());
58
59     private static final YangInstanceIdentifier STATE_SCHEMAS_IDENTIFIER =
60             YangInstanceIdentifier.builder().node(NetconfState.QNAME).node(Schemas.QNAME).build();
61     private static final YangInstanceIdentifier DATA_STATE_SCHEMAS_IDENTIFIER =
62             YangInstanceIdentifier.builder().node(NetconfMessageTransformUtil.NETCONF_DATA_QNAME)
63                     .node(NetconfState.QNAME).node(Schemas.QNAME).build();
64
65     private static final CompositeNode GET_SCHEMAS_RPC;
66     static {
67         final Node<?> filter = NetconfMessageTransformUtil.toFilterStructure(STATE_SCHEMAS_IDENTIFIER);
68         GET_SCHEMAS_RPC
69                 = NodeFactory.createImmutableCompositeNode(NetconfMessageTransformUtil.NETCONF_GET_QNAME, null, Lists.<Node<?>>newArrayList(filter));
70     }
71
72     private final Set<RemoteYangSchema> availableYangSchemas;
73
74     public NetconfStateSchemas(final Set<RemoteYangSchema> availableYangSchemas) {
75         this.availableYangSchemas = availableYangSchemas;
76     }
77
78     public Set<RemoteYangSchema> getAvailableYangSchemas() {
79         return availableYangSchemas;
80     }
81
82     public Set<QName> getAvailableYangSchemasQNames() {
83         return Sets.newHashSet(Collections2.transform(getAvailableYangSchemas(), new Function<RemoteYangSchema, QName>() {
84             @Override
85             public QName apply(final RemoteYangSchema input) {
86                 return input.getQName();
87             }
88         }));
89     }
90
91     /**
92      * Issue get request to remote device and parse response to find all schemas under netconf-state/schemas
93      */
94     private static NetconfStateSchemas create(final NetconfDeviceRpc deviceRpc, final NetconfSessionCapabilities remoteSessionCapabilities, final RemoteDeviceId id) {
95         if(remoteSessionCapabilities.isMonitoringSupported() == false) {
96             logger.warn("{}: Netconf monitoring not supported on device, cannot detect provided schemas");
97             return EMPTY;
98         }
99
100         final RpcResult<CompositeNode> schemasNodeResult;
101         try {
102             schemasNodeResult = deviceRpc.invokeRpc(NetconfMessageTransformUtil.NETCONF_GET_QNAME, GET_SCHEMAS_RPC).get();
103         } catch (final InterruptedException e) {
104             Thread.currentThread().interrupt();
105             throw new RuntimeException(id + ": Interrupted while waiting for response to " + STATE_SCHEMAS_IDENTIFIER, e);
106         } catch (final ExecutionException e) {
107             logger.warn("{}: Unable to detect available schemas, get to {} failed", id, STATE_SCHEMAS_IDENTIFIER, e);
108             return EMPTY;
109         }
110
111         if(schemasNodeResult.isSuccessful() == false) {
112             logger.warn("{}: Unable to detect available schemas, get to {} failed, {}", id, STATE_SCHEMAS_IDENTIFIER, schemasNodeResult.getErrors());
113             return EMPTY;
114         }
115
116         final CompositeNode schemasNode =
117                 (CompositeNode) NetconfMessageTransformUtil.findNode(schemasNodeResult.getResult(), DATA_STATE_SCHEMAS_IDENTIFIER);
118         if(schemasNode == null) {
119             logger.warn("{}: Unable to detect available schemas, get to {} was empty", id, STATE_SCHEMAS_IDENTIFIER);
120             return EMPTY;
121         }
122
123         return create(id, schemasNode);
124     }
125
126     /**
127      * Parse response of get(netconf-state/schemas) to find all schemas under netconf-state/schemas
128      */
129     @VisibleForTesting
130     protected static NetconfStateSchemas create(final RemoteDeviceId id, final CompositeNode schemasNode) {
131         final Set<RemoteYangSchema> availableYangSchemas = Sets.newHashSet();
132
133         for (final CompositeNode schemaNode : schemasNode.getCompositesByName(Schema.QNAME.withoutRevision())) {
134             final Optional<RemoteYangSchema> fromCompositeNode = RemoteYangSchema.createFromCompositeNode(id, schemaNode);
135             if(fromCompositeNode.isPresent()) {
136                 availableYangSchemas.add(fromCompositeNode.get());
137             }
138         }
139
140         return new NetconfStateSchemas(availableYangSchemas);
141     }
142
143     public final static class RemoteYangSchema {
144         private final QName qname;
145
146         private RemoteYangSchema(final QName qname) {
147             this.qname = qname;
148         }
149
150         public QName getQName() {
151             return qname;
152         }
153
154         static Optional<RemoteYangSchema> createFromCompositeNode(final RemoteDeviceId id, final CompositeNode schemaNode) {
155             Preconditions.checkArgument(schemaNode.getKey().equals(Schema.QNAME.withoutRevision()), "Wrong QName %s", schemaNode.getKey());
156
157             QName childNode = NetconfMessageTransformUtil.IETF_NETCONF_MONITORING_SCHEMA_FORMAT.withoutRevision();
158
159             String formatAsString = getSingleChildNodeValue(schemaNode, childNode).get();
160             //This is HotFix for situations where format statement in netconf-monitoring might be passed with prefix.
161             if (formatAsString.contains(":")) {
162                 String[] prefixedString = formatAsString.split(":");
163                 //FIXME: might be good idea to check prefix against model namespace
164                 formatAsString = prefixedString[1];
165             }
166             if(formatAsString.equals(Yang.QNAME.getLocalName()) == false) {
167                 logger.debug("{}: Ignoring schema due to unsupported format: {}", id, formatAsString);
168                 return Optional.absent();
169             }
170
171             childNode = NetconfMessageTransformUtil.IETF_NETCONF_MONITORING_SCHEMA_LOCATION.withoutRevision();
172             final Set<String> locationsAsString = getAllChildNodeValues(schemaNode, childNode);
173             if(locationsAsString.contains(Schema.Location.Enumeration.NETCONF.toString()) == false) {
174                 logger.debug("{}: Ignoring schema due to unsupported location: {}", id, locationsAsString);
175                 return Optional.absent();
176             }
177
178             childNode = NetconfMessageTransformUtil.IETF_NETCONF_MONITORING_SCHEMA_NAMESPACE.withoutRevision();
179             final String namespaceAsString = getSingleChildNodeValue(schemaNode, childNode).get();
180
181             childNode = NetconfMessageTransformUtil.IETF_NETCONF_MONITORING_SCHEMA_VERSION.withoutRevision();
182             // Revision does not have to be filled
183             final Optional<String> revisionAsString = getSingleChildNodeValue(schemaNode, childNode);
184
185             childNode = NetconfMessageTransformUtil.IETF_NETCONF_MONITORING_SCHEMA_IDENTIFIER.withoutRevision();
186             final String moduleNameAsString = getSingleChildNodeValue(schemaNode, childNode).get();
187
188             final QName moduleQName = revisionAsString.isPresent()
189                     ? QName.create(namespaceAsString, revisionAsString.get(), moduleNameAsString)
190                     : QName.create(URI.create(namespaceAsString), null, moduleNameAsString).withoutRevision();
191
192             return Optional.of(new RemoteYangSchema(moduleQName));
193         }
194
195         private static Set<String> getAllChildNodeValues(final CompositeNode schemaNode, final QName childNodeQName) {
196             final Set<String> extractedValues = Sets.newHashSet();
197             for (final SimpleNode<?> childNode : schemaNode.getSimpleNodesByName(childNodeQName)) {
198                 extractedValues.add(getValueOfSimpleNode(childNodeQName, childNode).get());
199             }
200             return extractedValues;
201         }
202
203         private static Optional<String> getSingleChildNodeValue(final CompositeNode schemaNode, final QName childNode) {
204             final SimpleNode<?> node = schemaNode.getFirstSimpleByName(childNode);
205             return getValueOfSimpleNode(childNode, node);
206         }
207
208         private static Optional<String> getValueOfSimpleNode(final QName childNode, final SimpleNode<?> node) {
209             Preconditions.checkNotNull(node, "Child node %s not present", childNode);
210             final Object value = node.getValue();
211             return value == null ? Optional.<String>absent() : Optional.of(value.toString().trim());
212         }
213
214         @Override
215         public boolean equals(final Object o) {
216             if (this == o) {
217                 return true;
218             }
219             if (o == null || getClass() != o.getClass()) {
220                 return false;
221             }
222
223             final RemoteYangSchema that = (RemoteYangSchema) o;
224
225             if (!qname.equals(that.qname)) {
226                 return false;
227             }
228
229             return true;
230         }
231
232         @Override
233         public int hashCode() {
234             return qname.hashCode();
235         }
236     }
237 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.