d07e20bebba013c82e32ab0ba1b3c988550f0ecb
[controller.git] / opendaylight / config / yang-jmx-generator / src / main / java / org / opendaylight / controller / config / yangjmxgenerator / RuntimeBeanEntry.java
1 /*
2  * Copyright (c) 2013 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.controller.config.yangjmxgenerator;
9
10 import com.google.common.annotations.VisibleForTesting;
11 import com.google.common.base.Optional;
12 import com.google.common.collect.Lists;
13 import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
14 import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
15 import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
16 import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
17 import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.FullyQualifiedNameHelper;
18 import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.NameConflictException;
19 import org.opendaylight.yangtools.yang.common.QName;
20 import org.opendaylight.yangtools.yang.model.api.*;
21
22 import java.util.*;
23
24 import static com.google.common.base.Preconditions.checkArgument;
25 import static com.google.common.base.Preconditions.checkState;
26
27 /**
28  * Holds information about runtime bean to be generated. There are two kinds of
29  * RuntimeBeanEntry instances: if isRoot flag is set to true, this bean
30  * represents state that must be present at time of configuration module
31  * instantiation. Root RB must have depthLevel set to 0 and cannot have
32  * children. There might be other RBs defined in yang, but no other RB can have
33  * isRoot set to true. At least one RB must be root and all other RBs must be
34  * lined via children so that a tree with all beans can be created.
35  */
36 public class RuntimeBeanEntry {
37     private final String packageName;
38     private final String yangName, javaNamePrefix;
39     private final boolean isRoot;
40     private final Optional<String> keyYangName, keyJavaName;
41     private final Map<String, AttributeIfc> attributeMap;
42     private final List<RuntimeBeanEntry> children;
43     private final Set<Rpc> rpcs;
44
45     @VisibleForTesting
46     public RuntimeBeanEntry(String packageName,
47             DataSchemaNode nodeForReporting, String yangName,
48             String javaNamePrefix, boolean isRoot,
49             Optional<String> keyYangName, List<AttributeIfc> attributes,
50             List<RuntimeBeanEntry> children, Set<Rpc> rpcs) {
51
52         checkArgument(isRoot == false || keyYangName.isPresent() == false,
53                 "Root RuntimeBeanEntry must not have key " + "set");
54         this.packageName = packageName;
55         this.isRoot = isRoot;
56         this.yangName = yangName;
57         this.javaNamePrefix = javaNamePrefix;
58         this.children = Collections.unmodifiableList(children);
59         this.rpcs = Collections.unmodifiableSet(rpcs);
60
61         this.keyYangName = keyYangName;
62         Map<String, AttributeIfc> map = new HashMap<>();
63
64         for (AttributeIfc a : attributes) {
65             checkState(map.containsKey(a.getAttributeYangName()) == false,
66                     "Attribute already defined: " + a.getAttributeYangName()
67                             + " in " + nodeForReporting);
68             map.put(a.getAttributeYangName(), a);
69         }
70
71         if (keyYangName.isPresent()) {
72             AttributeIfc keyJavaName = map.get(keyYangName.get());
73             checkArgument(keyJavaName != null, "Key " + keyYangName.get()
74                     + " not found in attribute " + "list " + attributes
75                     + " in " + nodeForReporting);
76             this.keyJavaName = Optional
77                     .of(keyJavaName.getUpperCaseCammelCase());
78         } else {
79             keyJavaName = Optional.absent();
80         }
81         attributeMap = Collections.unmodifiableMap(map);
82     }
83
84     /**
85      * @return map containing all class names as key, extracted RuntimeBeans as
86      *         values. If more than zero values is returned, exactly one
87      *         RuntimeBeanEntry will have isRoot set to true, even if yang does
88      *         not contain special configuration for it.
89      */
90     public static Map<String, RuntimeBeanEntry> extractClassNameToRuntimeBeanMap(
91             String packageName, ChoiceCaseNode container,
92             String moduleYangName, TypeProviderWrapper typeProviderWrapper,
93             String javaNamePrefix, Module currentModule) {
94
95         Map<QName, Set<RpcDefinition>> identitiesToRpcs = getIdentitiesToRpcs(currentModule);
96
97         AttributesRpcsAndRuntimeBeans attributesRpcsAndRuntimeBeans = extractSubtree(
98                 packageName, container, typeProviderWrapper, currentModule,
99                 identitiesToRpcs);
100         Map<String, RuntimeBeanEntry> result = new HashMap<>();
101
102         List<AttributeIfc> attributes;
103         Set<Rpc> rpcs;
104         if (attributesRpcsAndRuntimeBeans.isEmpty() == false) {
105             attributes = attributesRpcsAndRuntimeBeans.getAttributes();
106             rpcs = attributesRpcsAndRuntimeBeans.getRpcs();
107         } else {
108             // create artificial root if not defined in yang
109             attributes = Collections.emptyList();
110             rpcs = Collections.emptySet();
111         }
112         RuntimeBeanEntry rootRuntimeBeanEntry = createRoot(packageName,
113                 container, moduleYangName, attributes, javaNamePrefix,
114                 attributesRpcsAndRuntimeBeans.getRuntimeBeanEntries(), rpcs);
115
116         Deque<RuntimeBeanEntry> stack = new LinkedList<>();
117         stack.add(rootRuntimeBeanEntry);
118
119         while (stack.isEmpty() == false) {
120             RuntimeBeanEntry first = stack.pollFirst();
121             if (result.containsKey(first.getJavaNameOfRuntimeMXBean())) {
122                 throw new NameConflictException(
123                         first.getJavaNameOfRuntimeMXBean(), null, null);
124             }
125             result.put(first.getJavaNameOfRuntimeMXBean(), first);
126             stack.addAll(first.getChildren());
127         }
128         return result;
129     }
130
131     private static Map<QName/* of identity */, Set<RpcDefinition>> getIdentitiesToRpcs(
132             Module currentModule) {
133         // currently only looks for local identities (found in currentModule)
134         Map<QName, Set<RpcDefinition>> result = new HashMap<>();
135         for (IdentitySchemaNode identity : currentModule.getIdentities()) {
136             // add all
137             result.put(identity.getQName(), new HashSet<RpcDefinition>());
138         }
139
140         for (RpcDefinition rpc : currentModule.getRpcs()) {
141             ContainerSchemaNode input = rpc.getInput();
142             for (UsesNode uses : input.getUses()) {
143
144                 if (uses.getGroupingPath().getPath().size() != 1)
145                     continue;
146
147                 // check grouping path
148                 QName qname = uses.getGroupingPath().getPath().get(0);
149                 if (false == qname
150                         .equals(ConfigConstants.RPC_CONTEXT_REF_GROUPING_QNAME))
151                     continue;
152
153                 for (SchemaNode refinedNode : uses.getRefines().values()) {
154
155                     for (UnknownSchemaNode unknownSchemaNode : refinedNode
156                             .getUnknownSchemaNodes()) {
157                         if (ConfigConstants.RPC_CONTEXT_INSTANCE_EXTENSION_QNAME
158                                 .equals(unknownSchemaNode.getNodeType())) {
159                             String localIdentityName = unknownSchemaNode
160                                     .getNodeParameter();
161                             QName identityQName = new QName(
162                                     currentModule.getNamespace(),
163                                     currentModule.getRevision(),
164                                     localIdentityName);
165                             Set<RpcDefinition> rpcDefinitions = result
166                                     .get(identityQName);
167                             if (rpcDefinitions == null) {
168                                 throw new IllegalArgumentException(
169                                         "Identity referenced by rpc not found. Identity:"
170                                                 + localIdentityName + " , rpc "
171                                                 + rpc);
172                             }
173                             rpcDefinitions.add(rpc);
174                         }
175                     }
176
177                 }
178             }
179         }
180         return result;
181     }
182
183     /**
184      * Get direct descendants of this subtree, together with attributes defined
185      * in subtree.
186      */
187     private static AttributesRpcsAndRuntimeBeans extractSubtree(
188             String packageName, DataNodeContainer subtree,
189             TypeProviderWrapper typeProviderWrapper, Module currentModule,
190             Map<QName, Set<RpcDefinition>> identitiesToRpcs) {
191
192         List<AttributeIfc> attributes = Lists.newArrayList();
193         // List<JavaAttribute> javaAttributes = new ArrayList<>();
194         // List<TOAttribute> toAttributes = new ArrayList<>();
195         List<RuntimeBeanEntry> runtimeBeanEntries = new ArrayList<>();
196         for (DataSchemaNode child : subtree.getChildNodes()) {
197             // child leaves can be java attributes, TO attributes, or child
198             // runtime beans
199             if (child instanceof LeafSchemaNode) {
200                 // just save the attribute
201                 LeafSchemaNode leaf = (LeafSchemaNode) child;
202                 attributes.add(new JavaAttribute(leaf, typeProviderWrapper));
203             } else if (child instanceof ContainerSchemaNode) {
204                 ContainerSchemaNode container = (ContainerSchemaNode) child;
205                 // this can be either TO or hierarchical RB
206                 TOAttribute toAttribute = TOAttribute.create(container,
207                         typeProviderWrapper);
208                 attributes.add(toAttribute);
209             } else if (child instanceof ListSchemaNode) {
210                 if (isInnerStateBean(child)) {
211                     ListSchemaNode listSchemaNode = (ListSchemaNode) child;
212                     RuntimeBeanEntry hierarchicalChild = createHierarchical(
213                             packageName, listSchemaNode, typeProviderWrapper,
214                             currentModule, identitiesToRpcs);
215                     runtimeBeanEntries.add(hierarchicalChild);
216                 } else /* ordinary list attribute */{
217                     ListAttribute listAttribute = ListAttribute.create(
218                             (ListSchemaNode) child, typeProviderWrapper);
219                     attributes.add(listAttribute);
220                 }
221
222             } else {
223                 throw new IllegalStateException("Unknown running-data node "
224                         + child + " , " + "" + "expected leaf or container");
225             }
226         }
227         Set<Rpc> rpcs = new HashSet<>();
228         SchemaNode subtreeSchemaNode = (SchemaNode) subtree;
229         for (UnknownSchemaNode unknownSchemaNode : subtreeSchemaNode
230                 .getUnknownSchemaNodes()) {
231             if (ConfigConstants.RPC_CONTEXT_INSTANCE_EXTENSION_QNAME
232                     .equals(unknownSchemaNode.getNodeType())) {
233                 String localIdentityName = unknownSchemaNode.getNodeParameter();
234                 QName identityQName = new QName(currentModule.getNamespace(),
235                         currentModule.getRevision(), localIdentityName);
236                 Set<RpcDefinition> rpcDefinitions = identitiesToRpcs
237                         .get(identityQName);
238                 if (rpcDefinitions == null) {
239                     throw new IllegalArgumentException("Cannot find identity "
240                             + localIdentityName + " to be used as "
241                             + "context reference when resolving "
242                             + unknownSchemaNode);
243                 }
244                 // convert RpcDefinition to Rpc
245                 for (RpcDefinition rpcDefinition : rpcDefinitions) {
246                     String name = ModuleMXBeanEntry
247                             .findJavaParameter(rpcDefinition);
248                     String returnType;
249                     if (rpcDefinition.getOutput() == null
250                             || rpcDefinition.getOutput().getChildNodes().size() == 0) {
251                         returnType = "void";
252                     } else if (rpcDefinition.getOutput().getChildNodes().size() == 1) {
253                         DataSchemaNode returnDSN = rpcDefinition.getOutput()
254                                 .getChildNodes().iterator().next();
255                         checkArgument(
256                                 returnDSN instanceof LeafSchemaNode,
257                                 "Unexpected type of rpc return type. "
258                                         + "Currently only leafs and empty output nodes are supported, got "
259                                         + returnDSN);
260                         LeafSchemaNode returnLeaf = (LeafSchemaNode) returnDSN;
261                         // We currently expect leaf defined in output element in yang to be named result
262                         // FIXME: value of result is fully qualified name - should be extended to accept TOs
263                         String localName = returnLeaf.getQName().getLocalName();
264                         checkArgument(
265                                 localName.equals("result"),
266                                 "Unexpected name of leaf in output element, expected leaf named result, was %s at %s",
267                                 localName, currentModule.getName());
268
269                         returnType = typeProviderWrapper.getType(returnLeaf)
270                                 .getFullyQualifiedName();
271                     } else {
272                         throw new IllegalArgumentException(
273                                 "More than one child node in rpc output is not supported. "
274                                         + "Error occured in " + rpcDefinition);
275                     }
276                     List<JavaAttribute> parameters = new ArrayList<>();
277                     for (DataSchemaNode childNode : sortAttributes(rpcDefinition.getInput()
278                             .getChildNodes())) {
279                         if (childNode.isAddedByUses() == false) { // skip
280                                                                   // refined
281                                                                   // context-instance
282                             checkArgument(childNode instanceof LeafSchemaNode, "Unexpected type of rpc input type. "
283                                     + "Currently only leafs and empty output nodes are supported, got " + childNode);
284                             JavaAttribute javaAttribute = new JavaAttribute(
285                                     (LeafSchemaNode) childNode,
286                                     typeProviderWrapper);
287                             parameters.add(javaAttribute);
288                         }
289                     }
290                     Rpc newRpc = new Rpc(returnType, name, rpcDefinition
291                             .getQName().getLocalName(), parameters);
292                     rpcs.add(newRpc);
293                 }
294             }
295         }
296         return new AttributesRpcsAndRuntimeBeans(runtimeBeanEntries,
297                 attributes, rpcs);
298     }
299
300     private static Collection<DataSchemaNode> sortAttributes(Set<DataSchemaNode> childNodes) {
301         final TreeSet<DataSchemaNode> dataSchemaNodes = new TreeSet<>(new Comparator<DataSchemaNode>() {
302             @Override
303             public int compare(DataSchemaNode o1, DataSchemaNode o2) {
304                 return o1.getQName().getLocalName().compareTo(o2.getQName().getLocalName());
305             }
306         });
307         dataSchemaNodes.addAll(childNodes);
308         return dataSchemaNodes;
309     }
310
311     private static boolean isInnerStateBean(DataSchemaNode child) {
312         for (UnknownSchemaNode unknownSchemaNode : child
313                 .getUnknownSchemaNodes()) {
314             if (unknownSchemaNode.getNodeType().equals(
315                     ConfigConstants.INNER_STATE_BEAN_EXTENSION_QNAME))
316                 return true;
317         }
318         return false;
319     }
320
321     private static RuntimeBeanEntry createHierarchical(String packageName,
322             ListSchemaNode listSchemaNode,
323             TypeProviderWrapper typeProviderWrapper, Module currentModule,
324             Map<QName, Set<RpcDefinition>> identitiesToRpcs) {
325
326         // supported are numeric types, strings, enums
327         // get all attributes
328         AttributesRpcsAndRuntimeBeans attributesRpcsAndRuntimeBeans = extractSubtree(
329                 packageName, listSchemaNode, typeProviderWrapper,
330                 currentModule, identitiesToRpcs);
331
332         Optional<String> keyYangName;
333         if (listSchemaNode.getKeyDefinition().size() == 0) {
334             keyYangName = Optional.absent();
335         } else if (listSchemaNode.getKeyDefinition().size() == 1) {
336             // key must be either null or one of supported key types
337             QName keyQName = listSchemaNode.getKeyDefinition().iterator()
338                     .next();
339             keyYangName = Optional.of(keyQName.getLocalName());
340
341         } else {
342             throw new IllegalArgumentException(
343                     "More than one key is not supported in " + listSchemaNode);
344         }
345
346         String javaNamePrefix = ModuleMXBeanEntry
347                 .findJavaNamePrefix(listSchemaNode);
348
349         RuntimeBeanEntry rbFromAttributes = new RuntimeBeanEntry(packageName,
350                 listSchemaNode, listSchemaNode.getQName().getLocalName(),
351                 javaNamePrefix, false, keyYangName,
352                 attributesRpcsAndRuntimeBeans.getAttributes(),
353                 attributesRpcsAndRuntimeBeans.getRuntimeBeanEntries(),
354                 attributesRpcsAndRuntimeBeans.getRpcs());
355
356         return rbFromAttributes;
357     }
358
359     private static RuntimeBeanEntry createRoot(String packageName,
360             DataSchemaNode nodeForReporting, String attributeYangName,
361             List<AttributeIfc> attributes, String javaNamePrefix,
362             List<RuntimeBeanEntry> children, Set<Rpc> rpcs) {
363         return new RuntimeBeanEntry(packageName, nodeForReporting,
364                 attributeYangName, javaNamePrefix, true,
365                 Optional.<String> absent(), attributes, children, rpcs);
366     }
367
368     public boolean isRoot() {
369         return isRoot;
370     }
371
372     public Optional<String> getKeyYangName() {
373         return keyYangName;
374     }
375
376     public Optional<String> getKeyJavaName() {
377         return keyJavaName;
378     }
379
380     public Collection<AttributeIfc> getAttributes() {
381         return attributeMap.values();
382     }
383
384     public Map<String, AttributeIfc> getYangPropertiesToTypesMap() {
385         return attributeMap;
386     }
387
388     public String getYangName() {
389         return yangName;
390     }
391
392     public String getPackageName() {
393         return packageName;
394     }
395
396     public String getJavaNamePrefix() {
397         return javaNamePrefix;
398     }
399
400     public List<RuntimeBeanEntry> getChildren() {
401         return children;
402     }
403
404     public Set<Rpc> getRpcs() {
405         return rpcs;
406     }
407
408     private static class AttributesRpcsAndRuntimeBeans {
409         private final List<RuntimeBeanEntry> runtimeBeanEntries;
410         private final List<AttributeIfc> attributes;
411         private final Set<Rpc> rpcs;
412
413         public AttributesRpcsAndRuntimeBeans(
414                 List<RuntimeBeanEntry> runtimeBeanEntries,
415                 List<AttributeIfc> attributes, Set<Rpc> rpcs) {
416             this.runtimeBeanEntries = runtimeBeanEntries;
417             this.attributes = attributes;
418             this.rpcs = rpcs;
419         }
420
421         private List<AttributeIfc> getAttributes() {
422             return attributes;
423         }
424
425         public List<RuntimeBeanEntry> getRuntimeBeanEntries() {
426             return runtimeBeanEntries;
427         }
428
429         public boolean isEmpty() {
430             return attributes.isEmpty() && rpcs.isEmpty();
431         }
432
433         private Set<Rpc> getRpcs() {
434             return rpcs;
435         }
436     }
437
438     public static class Rpc {
439         private final String name;
440         private final List<JavaAttribute> parameters;
441         private final String returnType;
442         private final String yangName;
443
444         Rpc(String returnType, String name, String yangName,
445                 List<JavaAttribute> parameters) {
446             this.returnType = returnType;
447             this.name = name;
448             this.parameters = parameters;
449             this.yangName = yangName;
450         }
451
452         public String getYangName() {
453             return yangName;
454         }
455
456         public String getName() {
457             return name;
458         }
459
460         public List<JavaAttribute> getParameters() {
461             return parameters;
462         }
463
464         public String getReturnType() {
465             return returnType;
466         }
467     }
468
469     private static final String MXBEAN_SUFFIX = "RuntimeMXBean";
470
471     public String getJavaNameOfRuntimeMXBean() {
472         return getJavaNameOfRuntimeMXBean(javaNamePrefix);
473     }
474
475     public String getFullyQualifiedName(String typeName) {
476         return FullyQualifiedNameHelper.getFullyQualifiedName(packageName,
477                 typeName);
478     }
479
480     private static String getJavaNameOfRuntimeMXBean(String javaNamePrefix) {
481         return javaNamePrefix + MXBEAN_SUFFIX;
482     }
483
484     @Override
485     public String toString() {
486         return "RuntimeBeanEntry{" + "isRoot=" + isRoot + ", yangName='"
487                 + yangName + '\'' + ", packageName='" + packageName + '\''
488                 + ", keyYangName=" + keyYangName + '}';
489     }
490 }

©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.