2 * Copyright (c) 2016 Brocade Communications 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.blueprint.ext;
10 import java.util.Collection;
11 import java.util.HashSet;
13 import org.apache.aries.blueprint.services.ExtendedBlueprintContainer;
14 import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
15 import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
16 import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
17 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
18 import org.opendaylight.controller.sal.core.api.model.SchemaService;
19 import org.opendaylight.yangtools.concepts.ListenerRegistration;
20 import org.opendaylight.yangtools.yang.binding.RpcService;
21 import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
22 import org.opendaylight.yangtools.yang.common.QNameModule;
23 import org.opendaylight.yangtools.yang.model.api.Module;
24 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
25 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
26 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
27 import org.osgi.service.blueprint.container.ComponentDefinitionException;
28 import org.slf4j.Logger;
29 import org.slf4j.LoggerFactory;
32 * Factory metadata corresponding to the "rpc-service" element that gets an RPC service implementation from
33 * the RpcProviderRegistry and provides it to the Blueprint container.
35 * @author Thomas Pantelis
37 class RpcServiceMetadata extends AbstractDependentComponentFactoryMetadata {
38 private static final Logger LOG = LoggerFactory.getLogger(RpcServiceMetadata.class);
40 private final String interfaceName;
41 private volatile Set<SchemaPath> rpcSchemaPaths;
42 private volatile RpcProviderRegistry rpcRegistry;
43 private volatile ListenerRegistration<DOMRpcAvailabilityListener> rpcListenerReg;
44 private volatile Class<RpcService> rpcInterface;
46 RpcServiceMetadata(String id, String interfaceName) {
48 this.interfaceName = interfaceName;
52 @SuppressWarnings("unchecked")
53 public void init(ExtendedBlueprintContainer container) {
54 super.init(container);
57 Class<?> interfaceClass = container().getBundleContext().getBundle().loadClass(interfaceName);
58 if(!RpcService.class.isAssignableFrom(interfaceClass)) {
59 throw new ComponentDefinitionException(String.format(
60 "%s: The specified interface %s is not an RpcService", logName(), interfaceName));
63 rpcInterface = (Class<RpcService>)interfaceClass;
64 } catch(Exception e) {
65 throw new ComponentDefinitionException(String.format("%s: Error obtaining interface class %s",
66 logName(), interfaceName), e);
71 protected void startTracking() {
72 // First get the SchemaContext. This will be used to get the RPC SchemaPaths.
74 retrieveService("SchemaService", SchemaService.class,
75 service -> retrievedSchemaContext(((SchemaService)service).getGlobalContext()));
78 private void retrievedSchemaContext(SchemaContext schemaContext) {
79 LOG.debug("{}: retrievedSchemaContext", logName());
81 QNameModule moduleName = BindingReflections.getQNameModule(rpcInterface);
82 Module module = schemaContext.findModuleByNamespaceAndRevision(moduleName.getNamespace(), moduleName.getRevision());
84 LOG.debug("{}: Got Module: {}", logName(), module);
86 rpcSchemaPaths = new HashSet<>();
87 for(RpcDefinition rpcDef : module.getRpcs()) {
88 rpcSchemaPaths.add(rpcDef.getPath());
91 LOG.debug("{}: Got SchemaPaths: {}", logName(), rpcSchemaPaths);
93 // First get the DOMRpcService OSGi service. This will be used to register a listener to be notified
94 // when the underlying DOM RPC service is available.
96 retrieveService("DOMRpcService", DOMRpcService.class, service -> retrievedDOMRpcService((DOMRpcService)service));
99 private void retrievedDOMRpcService(DOMRpcService domRpcService) {
100 LOG.debug("{}: retrievedDOMRpcService", logName());
102 rpcListenerReg = domRpcService.registerRpcListener(new DOMRpcAvailabilityListener() {
104 public void onRpcAvailable(Collection<DOMRpcIdentifier> rpcs) {
105 onRpcsAvailable(rpcs);
109 public void onRpcUnavailable(Collection<DOMRpcIdentifier> rpcs) {
114 protected void onRpcsAvailable(Collection<DOMRpcIdentifier> rpcs) {
115 for(DOMRpcIdentifier identifier: rpcs) {
116 if(rpcSchemaPaths.contains(identifier.getType())) {
117 LOG.debug("{}: onRpcsAvailable - found SchemaPath {}", logName(), identifier.getType());
119 retrieveService("RpcProviderRegistry", RpcProviderRegistry.class, service -> {
120 rpcRegistry = (RpcProviderRegistry)service;
130 public Object create() throws ComponentDefinitionException {
131 LOG.debug("{}: In create: interfaceName: {}", logName(), interfaceName);
136 RpcService rpcService = rpcRegistry.getRpcService(rpcInterface);
138 LOG.debug("{}: create returning service {}", logName(), rpcService);
141 } catch(Exception e) {
142 throw new ComponentDefinitionException("Error getting RPC service for " + interfaceName, e);
147 public void stopTracking() {
148 super.stopTracking();
149 closeRpcListenerReg();
152 private void closeRpcListenerReg() {
153 if(rpcListenerReg != null) {
154 rpcListenerReg.close();
155 rpcListenerReg = null;
160 public void destroy(Object instance) {
161 super.destroy(instance);
162 closeRpcListenerReg();
166 public String toString() {
167 return "RpcServiceMetadata [id=" + getId() + ", interfaceName=" + interfaceName + "]";