27fb2bcba153f953ebd0559fc8a9ee377b5e7ca8
[controller.git] / opendaylight / config / yang-jmx-generator-plugin / src / main / java / org / opendaylight / controller / config / yangjmxgenerator / plugin / ftl / RuntimeRegistratorFtlTemplate.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.plugin.ftl;
9
10 import static com.google.common.base.Preconditions.checkArgument;
11 import static com.google.common.base.Preconditions.checkState;
12 import static java.lang.String.format;
13
14 import com.google.common.annotations.VisibleForTesting;
15 import com.google.common.collect.Lists;
16 import java.io.Closeable;
17 import java.util.ArrayList;
18 import java.util.Collection;
19 import java.util.Collections;
20 import java.util.HashMap;
21 import java.util.HashSet;
22 import java.util.LinkedHashMap;
23 import java.util.List;
24 import java.util.Map;
25 import java.util.Map.Entry;
26 import java.util.Set;
27 import java.util.concurrent.atomic.AtomicInteger;
28 import org.opendaylight.controller.config.api.runtime.HierarchicalRuntimeBeanRegistration;
29 import org.opendaylight.controller.config.api.runtime.RootRuntimeBeanRegistrator;
30 import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry;
31 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Annotation;
32 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Annotation.Parameter;
33 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Field;
34 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.MethodDefinition;
35 import org.opendaylight.controller.config.yangjmxgenerator.plugin.util.FullyQualifiedNameHelper;
36
37 public class RuntimeRegistratorFtlTemplate extends GeneralClassTemplate {
38
39     private RuntimeRegistratorFtlTemplate(RuntimeBeanEntry runtimeBeanEntry,
40             String name, List<Field> fields, List<MethodDefinition> methods) {
41         // TODO header
42         super(null, runtimeBeanEntry.getPackageName(), name, Collections
43                 .<String> emptyList(), Collections.singletonList(Closeable.class
44                 .getCanonicalName()), fields, methods);
45     }
46
47     public static RuntimeBeanEntry findRoot(
48             Collection<RuntimeBeanEntry> runtimeBeanEntries) {
49         RuntimeBeanEntry result = null;
50         for (RuntimeBeanEntry rb : runtimeBeanEntries) {
51             if (rb.isRoot()) {
52                 if (result != null) {
53                     throw new IllegalArgumentException(
54                             "More than one root runtime bean found");
55                 }
56                 result = rb;
57             }
58         }
59         if (result != null) {
60             return result;
61         }
62         throw new IllegalArgumentException("No root runtime bean found");
63     }
64
65     private static String constructConstructorBody(
66             List<Field> constructorParameters) {
67         StringBuilder constructorBody = new StringBuilder();
68         for (Field field : constructorParameters) {
69             constructorBody.append("this.");
70             constructorBody.append(field.getName());
71             constructorBody.append("=");
72             constructorBody.append(field.getName());
73             constructorBody.append(";\n");
74         }
75         return constructorBody.toString();
76     }
77
78     // TODO Move to factory
79     /**
80      * Get registrator and n registration ftls where n is equal to total number
81      * of runtime beans in hierarchy.
82      */
83     public static Map<String, FtlTemplate> create(RuntimeBeanEntry rootRB) {
84         checkArgument(rootRB.isRoot(), "RuntimeBeanEntry must be root");
85         String registratorName = getJavaNameOfRuntimeRegistrator(rootRB);
86         List<MethodDefinition> methods = new ArrayList<>();
87         Field rootRuntimeBeanRegistratorField = new Field(
88                 Lists.newArrayList("final"),
89                 RootRuntimeBeanRegistrator.class.getName(),
90                 "rootRuntimeBeanRegistrator");
91         List<Field> constructorParameters = Lists
92                 .newArrayList(rootRuntimeBeanRegistratorField);
93         String constructorBody = constructConstructorBody(constructorParameters);
94         MethodDefinition constructor = MethodDefinition.createConstructor(
95                 registratorName, constructorParameters, constructorBody);
96         methods.add(constructor);
97
98         LinkedHashMap<String, RuntimeRegistratorFtlTemplate> RuntimeRegistratorFtlTemplates = createRegistrationHierarchy(
99                 rootRB, Collections.<String> emptySet());
100         RuntimeRegistratorFtlTemplate rootFtlFile = RuntimeRegistratorFtlTemplates
101                 .values().iterator().next();
102
103         {// add register(rootruntimemxbean)
104             String fullyQualifiedNameOfMXBean = FullyQualifiedNameHelper
105                     .getFullyQualifiedName(rootRB.getPackageName(), rootRB.getJavaNameOfRuntimeMXBean());
106             String childRegistratorFQN = rootFtlFile.getFullyQualifiedName();
107             Field rbParameter = new Field(fullyQualifiedNameOfMXBean, "rb");
108             StringBuilder registerBody = new StringBuilder();
109             registerBody.append(format("%s %s = this.%s.registerRoot(%s);\n",
110                     HierarchicalRuntimeBeanRegistration.class
111                             .getCanonicalName(), hierachicalRegistration
112                             .getName(), rootRuntimeBeanRegistratorField
113                             .getName(), rbParameter.getName()));
114             registerBody.append(format("return new %s(%s);\n",
115                     rootFtlFile.getFullyQualifiedName(),
116                     hierachicalRegistration.getName()));
117
118             MethodDefinition registerMethod = new MethodDefinition(
119                     childRegistratorFQN, "register",
120                     Collections.singletonList(rbParameter), registerBody.toString());
121             methods.add(registerMethod);
122         }
123
124         MethodDefinition closeRegistrator = createCloseMethodToCloseField(rootRuntimeBeanRegistratorField);
125         methods.add(closeRegistrator);
126
127         // TODO add header
128         GeneralClassTemplate registrator = new GeneralClassTemplate(null,
129                 rootRB.getPackageName(), registratorName,
130                 Collections.<String> emptyList(), Collections.singletonList(Closeable.class
131                 .getCanonicalName()), constructorParameters, methods);
132
133         checkState(!RuntimeRegistratorFtlTemplates.containsKey(registrator
134                 .getTypeDeclaration().getName()), "Name conflict: "
135                 + registrator.getTypeDeclaration().getName());
136         Map<String, FtlTemplate> result = new HashMap<>();
137         result.putAll(RuntimeRegistratorFtlTemplates);
138         result.put(registrator.getTypeDeclaration().getName(), registrator);
139         return result;
140     }
141
142     private static Field hierachicalRegistration = new Field(
143             Lists.newArrayList("final"),
144             HierarchicalRuntimeBeanRegistration.class.getCanonicalName(),
145             "registration");
146
147     // TODO move to factory + RuntimeBeanEntry
148     /**
149      * Create ftls representing registrations. First registration is represents
150      * parent.
151      *
152      * @return map containing java class name as key, instance representing the
153      *         java file as value.
154      */
155     private static LinkedHashMap<String, RuntimeRegistratorFtlTemplate> createRegistrationHierarchy(
156             RuntimeBeanEntry parent, Set<String> occupiedKeys) {
157         LinkedHashMap<String, RuntimeRegistratorFtlTemplate> unorderedResult = new LinkedHashMap<>();
158         List<MethodDefinition> methods = new ArrayList<>();
159
160         // hierarchy of ON is created as follows:
161         // root RB: <domain>, type=RuntimeBean
162         // 1st RB in hierarchy: <domain>, type=RuntimeBean, <java name of leaf
163         // list>: key or counter
164         // n-th RB in hierarchy has same ON as n-1, with added <java name of
165         // leaf list>: key or counter
166         if (occupiedKeys.contains(parent.getJavaNamePrefix())) {
167             throw new IllegalArgumentException(
168                     "Name conflict in runtime bean hierarchy - java name found more than "
169                             + "once. Consider using java-name extension. Conflicting name: "
170                             + parent.getJavaNamePrefix());
171         }
172         Set<String> currentOccupiedKeys = new HashSet<>(occupiedKeys);
173         currentOccupiedKeys.add(parent.getJavaNamePrefix());
174
175         Field registratorsMapField = new Field(Collections.singletonList("final"),
176                 TypeHelper.getGenericType(Map.class, String.class,
177                         AtomicInteger.class), "unkeyedMap", "new "
178                         + TypeHelper.getGenericType(HashMap.class,
179                                 String.class, AtomicInteger.class) + "()");
180
181         // create register methods for children
182         for (RuntimeBeanEntry child : parent.getChildren()) {
183             checkArgument(parent.getPackageName()
184                     .equals(child.getPackageName()), "Invalid package name");
185
186             // call itself recursively to generate child
187             // registrators/registrations
188             LinkedHashMap<String, RuntimeRegistratorFtlTemplate> childRegistratorMap = createRegistrationHierarchy(
189                     child, currentOccupiedKeys);
190             for (Entry<String, RuntimeRegistratorFtlTemplate> entry : childRegistratorMap
191                     .entrySet()) {
192                 if (unorderedResult.containsKey(entry.getKey())) {
193                     throw new IllegalStateException(
194                             "Conflicting name found while generating runtime registration:"
195                                     + entry.getKey());
196                 }
197                 unorderedResult.put(entry.getKey(), entry.getValue());
198             }
199
200             if (!childRegistratorMap.isEmpty()) {
201                 // first entry is the direct descendant according to the create
202                 // contract
203                 RuntimeRegistratorFtlTemplate childRegistrator = childRegistratorMap
204                         .values().iterator().next();
205                 StringBuilder body = new StringBuilder();
206                 String key, value;
207                 key = child.getJavaNamePrefix();
208                 body.append(format(
209                         "String key = \"%s\"; //TODO: check for conflicts\n",
210                         key));
211
212                 if (child.getKeyJavaName().isPresent()) {
213                     value = "bean.get" + child.getKeyJavaName().get() + "()";
214                     value = "String.valueOf(" + value + ")";
215                 } else {
216                     body.append("java.util.concurrent.atomic.AtomicInteger counter = unkeyedMap.get(key);\n"
217                             + "if (counter==null){\n"
218                             + "counter = new java.util.concurrent.atomic.AtomicInteger();\n"
219                             + "unkeyedMap.put(key, counter);\n" + "}\n");
220                     value = "String.valueOf(counter.incrementAndGet())";
221                 }
222                 body.append(format("String value = %s;\n", value));
223                 body.append(format("%s r = %s.register(key, value, bean);\n",
224                         HierarchicalRuntimeBeanRegistration.class
225                                 .getCanonicalName(), hierachicalRegistration
226                                 .getName()));
227                 body.append(format("return new %s(r);",
228                         childRegistrator.getFullyQualifiedName()));
229
230                 Field param = new Field(Lists.newArrayList("final"),
231                         child.getJavaNameOfRuntimeMXBean(), "bean");
232                 MethodDefinition register = new MethodDefinition(
233                         Collections.singletonList("synchronized"),
234                         childRegistrator.getFullyQualifiedName(), "register",
235                         Collections.singletonList(param), Collections.<String> emptyList(),
236                         Collections.<Annotation> emptyList(), body.toString());
237                 methods.add(register);
238
239             }
240         }
241
242         // create parent registration
243         String createdName = getJavaNameOfRuntimeRegistration(parent.getJavaNamePrefix());
244
245         List<Field> constructorParameters = Collections.singletonList(hierachicalRegistration);
246         String constructorBody = constructConstructorBody(constructorParameters);
247
248         MethodDefinition constructor = MethodDefinition.createConstructor(
249                 createdName, constructorParameters, constructorBody);
250
251         MethodDefinition closeRegistrator = createCloseMethodToCloseField(hierachicalRegistration);
252         methods.add(closeRegistrator);
253         methods.add(constructor);
254         List<Field> privateFields = Lists.newArrayList(registratorsMapField);
255         privateFields.addAll(constructorParameters);
256
257         RuntimeRegistratorFtlTemplate created = new RuntimeRegistratorFtlTemplate(
258                 parent, createdName, privateFields, methods);
259
260         LinkedHashMap<String, RuntimeRegistratorFtlTemplate> result = new LinkedHashMap<>();
261         result.put(created.getTypeDeclaration().getName(), created);
262         checkState(!unorderedResult.containsKey(created.getTypeDeclaration()
263                 .getName()), "Naming conflict: "
264                 + created.getTypeDeclaration().getName());
265         result.putAll(unorderedResult);
266         return result;
267     }
268
269     private static MethodDefinition createCloseMethodToCloseField(Field field) {
270         String body = field.getName() + ".close();";
271         // TODO Thrown exception breaks build
272         // return new MethodDefinition(Collections.<String> emptyList(), "void",
273         // "close", Collections.<Field> emptyList(),
274         // Arrays.asList(IOException.class.getCanonicalName()),
275         // Collections.<Annotation> emptyList(), body);
276         List<Annotation> annotations = Lists.newArrayList(new Annotation(
277                 "Override", Collections.<Parameter> emptyList()));
278         return new MethodDefinition(Collections.<String> emptyList(), "void",
279                 "close", Collections.<Field> emptyList(),
280                 Collections.<String> emptyList(), annotations, body);
281     }
282
283     @VisibleForTesting
284     public static String getJavaNameOfRuntimeRegistration(String javaNamePrefix) {
285         return javaNamePrefix + "RuntimeRegistration";
286     }
287
288     public static String getJavaNameOfRuntimeRegistrator(RuntimeBeanEntry rootRB) {
289         checkArgument(rootRB.isRoot(), "RuntimeBeanEntry must be root");
290         return rootRB.getJavaNamePrefix() + "RuntimeRegistrator";
291     }
292 }

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