2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.controller.config.yangjmxgenerator.plugin.gofactory;
10 import static java.lang.String.format;
12 import com.google.common.base.Joiner;
13 import com.google.common.base.Optional;
14 import java.util.ArrayList;
15 import java.util.HashMap;
16 import java.util.LinkedHashMap;
17 import java.util.List;
19 import org.opendaylight.controller.config.api.DependencyResolver;
20 import org.opendaylight.controller.config.api.ModuleIdentifier;
21 import org.opendaylight.controller.config.api.annotations.Description;
22 import org.opendaylight.controller.config.api.runtime.RootRuntimeBeanRegistrator;
23 import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
24 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.AbstractModuleTemplate;
25 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.TemplateFactory;
26 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Annotation;
27 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.IdentityRefModuleField;
28 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.Method;
29 import org.opendaylight.controller.config.yangjmxgenerator.plugin.ftl.model.ModuleField;
30 import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.FullyQualifiedName;
31 import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.GeneratedObject;
32 import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.GeneratedObjectBuilder;
33 import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.JavaFileInputBuilder;
34 import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.TypeName;
35 import org.opendaylight.yangtools.yang.common.QName;
36 import org.slf4j.Logger;
37 import org.slf4j.LoggerFactory;
39 public class AbsModuleGeneratedObjectFactory {
41 public GeneratedObject toGeneratedObject(ModuleMXBeanEntry mbe, Optional<String> copyright) {
42 FullyQualifiedName abstractFQN = new FullyQualifiedName(mbe.getPackageName(), mbe.getAbstractModuleName());
43 Optional<String> classJavaDoc = Optional.fromNullable(mbe.getNullableDescription());
44 AbstractModuleTemplate abstractModuleTemplate = TemplateFactory.abstractModuleTemplateFromMbe(mbe);
45 Optional<String> header = abstractModuleTemplate.getHeaderString();
47 List<FullyQualifiedName> implementedInterfaces = new ArrayList<>();
48 for(String implemented: abstractModuleTemplate.getTypeDeclaration().getImplemented()) {
49 implementedInterfaces.add(FullyQualifiedName.fromString(implemented));
51 Optional<FullyQualifiedName> maybeRegistratorType;
52 if (abstractModuleTemplate.isRuntime()) {
53 maybeRegistratorType = Optional.of(FullyQualifiedName.fromString(abstractModuleTemplate.getRegistratorType()));
55 maybeRegistratorType = Optional.absent();
58 return toGeneratedObject(abstractFQN, copyright, header, classJavaDoc, implementedInterfaces,
59 abstractModuleTemplate.getModuleFields(), maybeRegistratorType, abstractModuleTemplate.getMethods(),
60 mbe.getYangModuleQName());
63 public GeneratedObject toGeneratedObject(FullyQualifiedName abstractFQN,
64 Optional<String> copyright,
65 Optional<String> header,
66 Optional<String> classJavaDoc,
67 List<FullyQualifiedName> implementedInterfaces,
68 List<ModuleField> moduleFields,
69 Optional<FullyQualifiedName> maybeRegistratorType,
70 List<? extends Method> methods,
71 QName yangModuleQName) {
72 JavaFileInputBuilder b = new JavaFileInputBuilder();
74 Annotation moduleQNameAnnotation = Annotation.createModuleQNameANnotation(yangModuleQName);
75 b.addClassAnnotation(moduleQNameAnnotation);
77 b.setFqn(abstractFQN);
78 b.setTypeName(TypeName.absClassType);
80 b.setCopyright(copyright);
82 b.setClassJavaDoc(classJavaDoc);
83 for(FullyQualifiedName implemented: implementedInterfaces) {
84 b.addImplementsFQN(implemented);
86 if (classJavaDoc.isPresent()) {
87 b.addClassAnnotation(format("@%s(value=\"%s\")", Description.class.getCanonicalName(), classJavaDoc.get()));
91 b.addToBody(getLogger(abstractFQN));
93 b.addToBody("//attributes start");
94 for(ModuleField moduleField: moduleFields) {
95 b.addToBody(moduleField.toString() +"\n");
98 b.addToBody("//attributes end");
101 b.addToBody(getCommonFields(abstractFQN));
104 b.addToBody(getNewConstructor(abstractFQN));
105 b.addToBody(getCopyFromOldConstructor(abstractFQN));
107 b.addToBody(getRuntimeRegistratorCode(maybeRegistratorType));
108 b.addToBody(getValidationMethods(moduleFields));
110 b.addToBody(getCachesOfResolvedDependencies(moduleFields));
111 b.addToBody(getCachesOfResolvedIdentityRefs(moduleFields));
112 b.addToBody(getGetInstance(moduleFields));
113 b.addToBody(getReuseLogic(moduleFields, abstractFQN));
114 b.addToBody(getEqualsAndHashCode(abstractFQN));
116 b.addToBody(getMethods(methods));
118 return new GeneratedObjectBuilder(b.build()).toGeneratedObject();
121 private static String getMethods(List<? extends Method> methods) {
122 String result = "\n// getters and setters\n";
123 for(Method method: methods) {
124 result += method.toString()+"\n";
129 private static String getEqualsAndHashCode(FullyQualifiedName abstractFQN) {
132 "public boolean equals(Object o) {\n"+
133 "if (this == o) return true;\n"+
134 "if (o == null || getClass() != o.getClass()) return false;\n"+
135 format("%s that = (%1$s) o;\n", abstractFQN.getTypeName())+
136 "return identifier.equals(that.identifier);\n"+
140 "public int hashCode() {\n"+
141 "return identifier.hashCode();\n"+
145 private static String getReuseLogic(List<ModuleField> moduleFields, FullyQualifiedName abstractFQN) {
146 String result = "\n"+
147 format("public boolean canReuseInstance(%s oldModule){\n", abstractFQN.getTypeName())+
148 "// allow reusing of old instance if no parameters was changed\n"+
149 "return isSame(oldModule);\n"+
152 format("public %s reuseInstance(%1$s oldInstance){\n", AutoCloseable.class.getCanonicalName())+
153 "// implement if instance reuse should be supported. Override canReuseInstance to change the criteria.\n"+
154 "return oldInstance;\n"+
156 // isSame method that detects changed fields
158 format("public boolean isSame(%s other) {\n", abstractFQN.getTypeName())+
159 "if (other == null) {\n"+
160 "throw new IllegalArgumentException(\"Parameter 'other' is null\");\n"+
162 // loop through fields, do deep equals on each field
164 for (ModuleField moduleField : moduleFields) {
165 if (moduleField.isListOfDependencies()) {
167 "if (%1$sDependency.equals(other.%1$sDependency) == false) {\n"+
170 "for (int idx = 0; idx < %1$sDependency.size(); idx++) {\n"+
171 "if (%1$sDependency.get(idx) != other.%1$sDependency.get(idx)) {\n"+
174 "}\n" ,moduleField.getName());
175 } else if (moduleField.isDependent()) {
177 "if (%sDependency != other.%1$sDependency) { // reference to dependency must be same\n"+
179 "}\n",moduleField.getName());
182 "if (java.util.Objects.deepEquals(%s, other.%1$s) == false) {\n"+
184 "}\n", moduleField.getName());
194 private static String getGetInstance(List<ModuleField> moduleFields) {
195 String result = "\n"+
197 format("public final %s getInstance() {\n", AutoCloseable.class.getCanonicalName())+
198 "if(instance==null) {\n";
199 // create instance start
201 // loop through dependent fields, use dependency resolver to instantiate dependencies. Do it in loop in case field represents list of dependencies.
202 Map<ModuleField, String> resolveDependenciesMap = new HashMap<>();
203 for(ModuleField moduleField: moduleFields) {
204 if (moduleField.isDependent()) {
206 String osgi = moduleField.getDependency().getSie().getExportedOsgiClassName();
207 if (moduleField.isList()) {
209 "%sDependency = new java.util.ArrayList<%s>();\n"+
210 "for(javax.management.ObjectName dep : %1$s) {\n"+
211 "%1$sDependency.add(dependencyResolver.resolveInstance(%2$s.class, dep, %1$sJmxAttribute));\n"+
212 "}\n", moduleField.getName(), osgi);
215 "%1$sDependency = dependencyResolver.resolveInstance(%2$s.class, %1$s, %1$sJmxAttribute);",
216 moduleField.getName(), osgi);
218 resolveDependenciesMap.put(moduleField, str);
222 // wrap each field resolvation statement with if !=null when dependency is not mandatory
223 for (Map.Entry<ModuleField, String> entry : resolveDependenciesMap.entrySet()) {
224 if (entry.getKey().getDependency().isMandatory() == false) {
225 result += format("if (%s!=null) {\n%s;\n}", entry.getKey().getName(), entry.getValue());
227 result += entry.getValue();
231 // add code to inject dependency resolver to fields that support it
232 for(ModuleField moduleField: moduleFields) {
233 if (moduleField.isNeedsDepResolver()) {
234 result += format("if (%s!=null){\n", moduleField.getName());
235 if (moduleField.isList()) {
237 "for(%s candidate : %s) {\n"+
238 "candidate.injectDependencyResolver(dependencyResolver);\n"+
239 "}\n", moduleField.getGenericInnerType(), moduleField.getName());
241 result += format("%s.injectDependencyResolver(dependencyResolver);\n", moduleField.getName());
247 // identity refs need to be injected with dependencyResolver and base class
248 for (ModuleField moduleField : moduleFields) {
249 if (moduleField.isIdentityRef()) {
250 result += format("if (%s!=null) {", moduleField.getName());
251 result += format("set%s(%s.resolveIdentity(dependencyResolver, %s.class));",
252 moduleField.getAttributeName(), moduleField.getName(),
253 ((IdentityRefModuleField)moduleField).getIdentityBaseClass());
258 // create instance end: reuse and recreate logic
259 result += "if(oldInstance!=null && canReuseInstance(oldModule)) {\n"+
260 "instance = reuseInstance(oldInstance);\n"+
262 "if(oldInstance!=null) {\n"+
264 "oldInstance.close();\n"+
265 "} catch(Exception e) {\n"+
266 "logger.error(\"An error occurred while closing old instance \" + oldInstance, e);\n"+
269 "instance = createInstance();\n"+
270 "if (instance == null) {\n"+
271 "throw new IllegalStateException(\"Error in createInstance - null is not allowed as return value\");\n"+
275 "return instance;\n"+
277 format("public abstract %s createInstance();\n", AutoCloseable.class.getCanonicalName());
282 private static String getCommonFields(FullyQualifiedName abstractFQN) {
284 format("private final %s oldModule;\n", abstractFQN.getTypeName())+
285 format("private final %s oldInstance;\n", AutoCloseable.class.getCanonicalName())+
286 format("private %s instance;\n", AutoCloseable.class.getCanonicalName())+
287 format("private final %s dependencyResolver;\n", DependencyResolver.class.getCanonicalName())+
288 format("private final %s identifier;\n", ModuleIdentifier.class.getCanonicalName())+
290 format("public %s getIdentifier() {\n", ModuleIdentifier.class.getCanonicalName())+
291 "return identifier;\n"+
295 private static String getCachesOfResolvedIdentityRefs(List<ModuleField> moduleFields) {
296 StringBuilder result = new StringBuilder();
297 for (ModuleField moduleField : moduleFields) {
298 if (moduleField.isIdentityRef()) {
299 IdentityRefModuleField field = (IdentityRefModuleField) moduleField;
300 result.append(format("private %s %s;\n", field.getIdentityClassType(), field.getIdentityClassName()));
303 return result.toString();
306 private static String getCachesOfResolvedDependencies(List<ModuleField> moduleFields) {
307 StringBuilder result = new StringBuilder();
308 for (ModuleField moduleField: moduleFields) {
309 if (moduleField.isDependent()) {
310 String osgi = moduleField.getDependency().getSie().getExportedOsgiClassName();
311 if (moduleField.isList()) {
313 .append(format("private java.util.List<%s> %sDependency = new java.util.ArrayList<%s>();", osgi, moduleField.getName(), osgi))
314 .append(format("protected final java.util.List<%s> get%sDependency(){\n", osgi, moduleField.getAttributeName()))
315 .append(format("return %sDependency;\n", moduleField.getName()))
318 result.append(format(
319 "private %s %sDependency;\n"+
320 "protected final %s get%sDependency(){\n"+
321 "return %sDependency;\n"+
323 osgi, moduleField.getName(), osgi, moduleField.getAttributeName(), moduleField.getName()));
327 return result.toString();
330 private static String getRuntimeRegistratorCode(Optional<FullyQualifiedName> maybeRegistratorType) {
331 if (maybeRegistratorType.isPresent()) {
332 String registratorType = maybeRegistratorType.get().toString();
335 format("private %s rootRuntimeBeanRegistratorWrapper;\n", registratorType)+
337 format("public %s getRootRuntimeBeanRegistratorWrapper(){\n", registratorType)+
338 "return rootRuntimeBeanRegistratorWrapper;\n"+
342 format("public void setRuntimeBeanRegistrator(%s rootRuntimeRegistrator){\n", RootRuntimeBeanRegistrator.class.getCanonicalName())+
343 format("this.rootRuntimeBeanRegistratorWrapper = new %s(rootRuntimeRegistrator);\n", registratorType)+
350 private static String getValidationMethods(List<ModuleField> moduleFields) {
351 String result = "\n"+
353 "public void validate() {\n";
354 // validate each mandatory dependency
355 for(ModuleField moduleField: moduleFields) {
356 if (moduleField.isDependent() && moduleField.getDependency().isMandatory()) {
357 if (moduleField.isList()) {
359 format("for(javax.management.ObjectName dep : %s) {\n", moduleField.getName()) +
360 format(" dependencyResolver.validateDependency(%s.class, dep, %sJmxAttribute);\n",
361 moduleField.getDependency().getSie().getFullyQualifiedName(), moduleField.getName()) +
364 result += format("dependencyResolver.validateDependency(%s.class, %s, %sJmxAttribute);",
365 moduleField.getDependency().getSie().getFullyQualifiedName(), moduleField.getName(), moduleField.getName());
370 "customValidation();\n"+
373 "protected void customValidation() {\n"+
378 private static String getLogger(FullyQualifiedName fqn) {
379 return format("private static final %s logger = %s.getLogger(%s.class);",
380 Logger.class.getCanonicalName(), LoggerFactory.class.getCanonicalName(), fqn);
383 // assumes that each parameter name corresponds to an field in this class, constructs lines setting this.field = field;
384 private static String getConstructorStart(FullyQualifiedName fqn,
385 LinkedHashMap<String, String> parameters, String after) {
386 String paramString = Joiner.on(",").withKeyValueSeparator(" ").join(parameters);
388 for (String paramName : parameters.values()) {
389 setters += format("this.%s = %1$s;\n", paramName);
391 return format("public %s(", fqn.getTypeName()) +
399 private static String getNewConstructor(FullyQualifiedName abstractFQN) {
400 LinkedHashMap<String, String> parameters = new LinkedHashMap<>();
401 parameters.put(ModuleIdentifier.class.getCanonicalName(), "identifier");
402 parameters.put(DependencyResolver.class.getCanonicalName(), "dependencyResolver");
404 String setToNulls = "this.oldInstance=null;\n;" +
405 "this.oldModule=null;\n";
406 return getConstructorStart(abstractFQN, parameters, setToNulls);
409 private static String getCopyFromOldConstructor(FullyQualifiedName abstractFQN) {
410 LinkedHashMap<String, String> parameters = new LinkedHashMap<>();
411 parameters.put(ModuleIdentifier.class.getCanonicalName(), "identifier");
412 parameters.put(DependencyResolver.class.getCanonicalName(), "dependencyResolver");
413 parameters.put(abstractFQN.getTypeName(), "oldModule");
414 parameters.put(AutoCloseable.class.getCanonicalName(), "oldInstance");
415 return getConstructorStart(abstractFQN, parameters, "");