2 * Copyright (c) 2014 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.yangtools.sal.binding.generator.impl
10 import javassist.ClassPool
11 import org.opendaylight.yangtools.yang.model.api.SchemaContext
12 import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener
13 import org.opendaylight.yangtools.sal.binding.generator.impl.BindingGeneratorImpl
15 import org.opendaylight.yangtools.sal.binding.model.api.Type
16 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder
17 import org.opendaylight.yangtools.yang.model.api.SchemaNode
18 import java.util.concurrent.ConcurrentHashMap
19 import org.opendaylight.yangtools.yang.data.api.CompositeNode
20 import org.opendaylight.yangtools.yang.binding.DataObject
21 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
22 import java.util.Map.Entry
23 import java.util.AbstractMap.SimpleEntry
24 import org.opendaylight.yangtools.yang.model.api.SchemaPath
25 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil
26 import org.opendaylight.yangtools.yang.binding.DataContainer
27 import java.util.concurrent.ConcurrentMap
28 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType
29 import com.google.common.collect.HashMultimap
30 import com.google.common.util.concurrent.SettableFuture
31 import java.util.concurrent.Future
32 import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl
33 import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService
34 import org.slf4j.LoggerFactory
35 import org.opendaylight.yangtools.yang.data.impl.codec.ValueWithQName
36 import org.opendaylight.yangtools.yang.data.impl.codec.DataContainerCodec
37 import org.opendaylight.yangtools.binding.generator.util.Types
38 //import org.osgi.framework.BundleContext
39 import java.util.Hashtable
40 //import org.osgi.framework.ServiceRegistration
41 import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException
42 import java.util.concurrent.Callable
43 import org.opendaylight.yangtools.yang.binding.Augmentation
44 import org.opendaylight.yangtools.sal.binding.generator.util.YangSchemaUtils
45 import org.opendaylight.yangtools.yang.data.impl.codec.AugmentationCodec
46 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates
47 import java.util.ArrayList
48 import org.opendaylight.yangtools.yang.data.api.Node
49 import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
50 import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
51 import org.opendaylight.yangtools.yang.binding.RpcService
53 import org.opendaylight.yangtools.yang.common.QName
54 import com.google.common.collect.FluentIterable
55 import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil
57 class RuntimeGeneratedMappingServiceImpl implements BindingIndependentMappingService, SchemaServiceListener, AutoCloseable {
62 private static val LOG = LoggerFactory.getLogger(RuntimeGeneratedMappingServiceImpl);
65 extension TransformerGenerator binding;
68 extension LazyGeneratedCodecRegistry registry;
71 val ConcurrentMap<Type, Type> typeDefinitions = new ConcurrentHashMap();
74 val ConcurrentMap<Type, GeneratedTypeBuilder> typeToDefinition = new ConcurrentHashMap();
77 val ConcurrentMap<Type, SchemaNode> typeToSchemaNode = new ConcurrentHashMap();
80 val ConcurrentMap<Type,Set<QName>> serviceTypeToRpc = new ConcurrentHashMap();
82 val promisedTypeDefinitions = HashMultimap.<Type, SettableFuture<GeneratedTypeBuilder>>create;
84 val promisedSchemas = HashMultimap.<Type, SettableFuture<SchemaNode>>create;
86 //ServiceRegistration<SchemaServiceListener> listenerRegistration
88 override onGlobalContextUpdated(SchemaContext arg0) {
89 recreateBindingContext(arg0);
90 registry.onGlobalContextUpdated(arg0);
93 def recreateBindingContext(SchemaContext schemaContext) {
94 val newBinding = new BindingGeneratorImpl();
95 newBinding.generateTypes(schemaContext);
97 for (entry : newBinding.moduleContexts.entrySet) {
99 registry.onModuleContextAdded(schemaContext, entry.key, entry.value);
100 binding.pathToType.putAll(entry.value.childNodes)
101 val module = entry.key;
102 val context = entry.value;
103 updateBindingFor(context.childNodes, schemaContext);
104 updateBindingFor(context.cases, schemaContext);
105 val namespace = BindingGeneratorUtil.moduleNamespaceToPackageName(module);
107 if(!module.rpcs.empty) {
108 val rpcs = FluentIterable.from(module.rpcs).transform[QName].toSet
109 val serviceClass = new ReferencedTypeImpl(namespace,BindingGeneratorUtil.parseToClassName(module.name)+"Service");
110 serviceTypeToRpc.put(serviceClass,rpcs);
113 val typedefs = context.typedefs;
114 for (typedef : typedefs.entrySet) {
115 val typeRef = new ReferencedTypeImpl(typedef.value.packageName,typedef.value.name)
116 binding.typeDefinitions.put(typeRef, typedef.value as GeneratedType);
117 val schemaNode = YangSchemaUtils.findTypeDefinition(schemaContext,typedef.key);
118 if(schemaNode != null) {
120 binding.typeToSchemaNode.put(typeRef,schemaNode);
122 LOG.error("Type definition for {} is not available",typedef.value);
126 val augmentations = context.augmentations;
127 for (augmentation : augmentations) {
128 binding.typeToDefinition.put(augmentation, augmentation);
131 binding.typeToAugmentation.putAll(context.typeToAugmentation);
135 override CompositeNode toDataDom(DataObject data) {
136 toCompositeNodeImpl(data);
139 override Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> toDataDom(
140 Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry) {
143 val key = toDataDom(entry.key)
144 var CompositeNode data;
145 if(Augmentation.isAssignableFrom(entry.key.targetType)) {
146 data = toCompositeNodeImpl(key,entry.value);
148 data = toCompositeNodeImpl(entry.value);
150 return new SimpleEntry(key, data);
152 } catch (Exception e) {
153 LOG.error("Error during serialization for {}.", entry.key,e);
158 private def CompositeNode toCompositeNodeImpl(DataObject object) {
159 val cls = object.implementedInterface;
161 val codec = registry.getCodecForDataObject(cls) as DataContainerCodec<DataObject>;
162 val ret = codec.serialize(new ValueWithQName(null, object));
163 return ret as CompositeNode;
167 private def CompositeNode toCompositeNodeImpl(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier identifier,DataObject object) {
169 //val cls = object.implementedInterface;
170 //waitForSchema(cls);
171 val last = identifier.path.last;
172 val codec = registry.getCodecForAugmentation(object.implementedInterface as Class) as AugmentationCodec;
173 val ret = codec.serialize(new ValueWithQName(last.nodeType, object));
174 if(last instanceof NodeIdentifierWithPredicates) {
175 val predicates = last as NodeIdentifierWithPredicates;
176 val newNodes = new ArrayList<Node<?>>(predicates.keyValues.size);
177 for(predicate : predicates.keyValues.entrySet) {
178 newNodes.add(new SimpleNodeTOImpl(predicate.key,null,predicate.value));
180 newNodes.addAll(ret.children);
181 return new CompositeNodeTOImpl(last.nodeType,null,newNodes);
183 return ret as CompositeNode;
186 private def void waitForSchema(Class<? extends DataContainer> class1) {
187 if(Augmentation.isAssignableFrom(class1)) {
188 /* FIXME: We should wait also for augmentations. Currently YANGTools does not provide correct
189 * mapping between java Augmentation classes and augmentations.
193 if(registry.isCodecAvailable(class1)) {
196 val ref = Types.typeForClass(class1);
197 getSchemaWithRetry(ref);
200 override org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toDataDom(
201 InstanceIdentifier<? extends DataObject> path) {
202 for (arg : path.path) {
203 waitForSchema(arg.type);
205 return registry.instanceIdentifierCodec.serialize(path);
208 override dataObjectFromDataDom(InstanceIdentifier<? extends DataObject> path, CompositeNode node) {
209 dataObjectFromDataDom(path.targetType,node) as DataObject;
212 override fromDataDom(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier entry) {
213 return tryDeserialization[ |
214 registry.instanceIdentifierCodec.deserialize(entry);
218 override getCodecRegistry() {
219 return getRegistry();
222 private static def <T> T tryDeserialization(Callable<T> deserializationBlock) throws DeserializationException {
224 deserializationBlock.call()
225 } catch (Exception e) {
227 // FIXME: Make this block providing more information.
228 throw new DeserializationException(e);
232 private def void updateBindingFor(Map<SchemaPath, GeneratedTypeBuilder> map, SchemaContext module) {
234 for (entry : map.entrySet) {
235 val schemaNode = SchemaContextUtil.findDataSchemaNode(module, entry.key);
237 //LOG.info("{} : {}",entry.key,entry.value.fullyQualifiedName)
238 val typeRef = new ReferencedTypeImpl(entry.value.packageName,entry.value.name)
239 typeToDefinition.put(typeRef, entry.value);
240 if (schemaNode != null) {
241 typeToSchemaNode.put(typeRef, schemaNode);
242 updatePromisedSchemas(typeRef, schemaNode);
248 public def void init() {
249 binding = new TransformerGenerator(pool);
250 registry = new LazyGeneratedCodecRegistry()
251 registry.generator = binding
253 //binding.staticFieldsInitializer = registry
254 binding.listener = registry
255 binding.typeToDefinition = typeToDefinition
256 binding.typeToSchemaNode = typeToSchemaNode
257 binding.typeDefinitions = typeDefinitions
258 // if (ctx !== null) {
259 // listenerRegistration = ctx.registerService(SchemaServiceListener, this, new Hashtable<String, String>());
263 override getRpcQNamesFor(Class<? extends RpcService> service) {
264 return serviceTypeToRpc.get(new ReferencedTypeImpl(service.package.name,service.simpleName));
267 private def getSchemaWithRetry(Type type) {
268 val typeDef = typeToSchemaNode.get(type);
269 if (typeDef !== null) {
272 LOG.trace("Thread blocked waiting for schema for: {}",type.fullyQualifiedName)
273 return type.getSchemaInFuture.get();
276 private def Future<SchemaNode> getSchemaInFuture(Type type) {
277 val future = SettableFuture.<SchemaNode>create()
278 promisedSchemas.put(type, future);
282 private def void updatePromisedSchemas(Type builder, SchemaNode schema) {
283 val ref = new ReferencedTypeImpl(builder.packageName, builder.name);
284 val futures = promisedSchemas.get(ref);
285 if (futures === null || futures.empty) {
288 for (future : futures) {
291 promisedSchemas.removeAll(builder);
294 override close() throws Exception {
295 //listenerRegistration?.unregister();
298 override dataObjectFromDataDom(Class<? extends DataContainer> container, CompositeNode domData) {
299 return tryDeserialization[ |
300 if (domData == null) {
303 val transformer = registry.getCodecForDataObject(container);
304 val ret = transformer.deserialize(domData)?.value as DataObject;