<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-core-spi</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal</groupId>
+ <artifactId>mdsal-binding-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-binding-dom-codec</artifactId>
import java.util.Set;
import java.util.function.Predicate;
import org.apache.aries.blueprint.services.ExtendedBlueprintContainer;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcAvailabilityListener;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.broker.spi.rpc.RpcRoutingStrategy;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
+import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
+import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.spi.RpcRoutingStrategy;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
private final String interfaceName;
private ListenerRegistration<DOMRpcAvailabilityListener> rpcListenerReg;
- private RpcProviderRegistry rpcRegistry;
+ private RpcConsumerRegistry rpcRegistry;
private Class<RpcService> rpcInterface;
private Set<SchemaPath> rpcSchemaPaths;
@Override
protected final void startTracking() {
// Request RpcProviderRegistry first ...
- retrieveService("RpcProviderRegistry", RpcProviderRegistry.class, this::onRpcRegistry);
+ retrieveService("RpcConsumerRegistry", RpcConsumerRegistry.class, this::onRpcRegistry);
}
private void onRpcRegistry(final Object service) {
log.debug("{}: Retrieved RpcProviderRegistry {}", logName(), service);
- rpcRegistry = (RpcProviderRegistry)service;
+ rpcRegistry = (RpcConsumerRegistry)service;
// Now acquire SchemaService...
retrieveService("SchemaService", DOMSchemaService.class, this::onSchemaService);
import com.google.common.util.concurrent.Futures;
import java.util.Collection;
import java.util.Set;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcIdentifier;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcProviderService;
-import org.opendaylight.controller.md.sal.dom.broker.spi.rpc.RpcRoutingStrategy;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
+import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.spi.RpcRoutingStrategy;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
*
* <p>
* This bean has two distinct facets:
- * - if a reference bean is provided, it registers it with {@link RpcProviderRegistry}
+ * - if a reference bean is provided, it registers it with {@link RpcProviderService}
* - if a reference bean is not provided, it registers the corresponding no-op implementation with
* {@link DOMRpcProviderService} for all action (Routed RPC) elements in the provided interface
*
private static final Logger LOG = LoggerFactory.getLogger(ActionProviderBean.class);
- private DOMRpcProviderService rpcProviderService;
- private RpcProviderRegistry rpcRegistry;
+ private DOMRpcProviderService domRpcProvider;
+ private RpcProviderService bindingRpcProvider;
private DOMSchemaService schemaService;
private RpcService implementation;
private String interfaceName;
this.implementation = implementation;
}
- public void setRpcProviderService(final DOMRpcProviderService rpcProviderService) {
- this.rpcProviderService = rpcProviderService;
+ public void setDomRpcProvider(final DOMRpcProviderService rpcProviderService) {
+ this.domRpcProvider = rpcProviderService;
}
- public void setRpcRegistry(final RpcProviderRegistry rpcRegistry) {
- this.rpcRegistry = rpcRegistry;
+ public void setBindingRpcProvider(final RpcProviderService rpcProvider) {
+ this.bindingRpcProvider = rpcProvider;
}
public void setSchemaService(final DOMSchemaService schemaService) {
}
final Set<DOMRpcIdentifier> rpcs = ImmutableSet.copyOf(Collections2.transform(paths, DOMRpcIdentifier::create));
- reg = rpcProviderService.registerRpcImplementation((rpc, input) -> {
+ reg = domRpcProvider.registerRpcImplementation((rpc, input) -> {
return Futures.immediateFailedCheckedFuture(new DOMRpcImplementationNotAvailableException(
"Action %s has no instance matching %s", rpc, input));
}, rpcs);
interfaceName, ACTION_PROVIDER, implementation.getClass()));
}
- reg = rpcRegistry.addRpcImplementation(interfaceClass, implementation);
+ reg = bindingRpcProvider.registerRpcImplementation(interfaceClass, implementation);
LOG.debug("Registered implementation {} for {}", implementation, interfaceName);
}
}
package org.opendaylight.controller.blueprint.ext;
import java.util.function.Predicate;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
-import org.opendaylight.controller.md.sal.dom.broker.spi.rpc.RpcRoutingStrategy;
+import org.opendaylight.mdsal.dom.spi.RpcRoutingStrategy;
/**
* Factory metadata corresponding to the "action-service" element. It waits for a DOM promise of registration
*/
package org.opendaylight.controller.blueprint.ext;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.NotificationService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
import org.osgi.framework.Bundle;
import org.apache.aries.blueprint.mutable.MutableServiceReferenceMetadata;
import org.apache.aries.blueprint.mutable.MutableValueMetadata;
import org.opendaylight.controller.blueprint.BlueprintContainerRestartService;
-import org.opendaylight.controller.md.sal.binding.api.NotificationService;
-import org.opendaylight.controller.md.sal.dom.api.DOMRpcProviderService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.osgi.service.blueprint.container.ComponentDefinitionException;
public final class OpendaylightNamespaceHandler implements NamespaceHandler {
public static final String NAMESPACE_1_0_0 = "http://opendaylight.org/xmlns/blueprint/v1.0.0";
static final String ROUTED_RPC_REG_CONVERTER_NAME = "org.opendaylight.blueprint.RoutedRpcRegConverter";
- static final String RPC_PROVIDER_SERVICE_NAME = "org.opendaylight.blueprint.DOMRpcProviderService";
+ static final String DOM_RPC_PROVIDER_SERVICE_NAME = "org.opendaylight.blueprint.DOMRpcProviderService";
static final String RPC_REGISTRY_NAME = "org.opendaylight.blueprint.RpcRegistry";
+ static final String BINDING_RPC_PROVIDER_SERVICE_NAME = "org.opendaylight.blueprint.RpcProviderService";
static final String SCHEMA_SERVICE_NAME = "org.opendaylight.blueprint.SchemaService";
static final String NOTIFICATION_SERVICE_NAME = "org.opendaylight.blueprint.NotificationService";
static final String TYPE_ATTR = "type";
}
private static Metadata parseActionProvider(final Element element, final ParserContext context) {
- registerRpcProviderServiceRefBean(context);
- registerRpcRegistryServiceRefBean(context);
+ registerDomRpcProviderServiceRefBean(context);
+ registerBindingRpcProviderServiceRefBean(context);
registerSchemaServiceRefBean(context);
MutableBeanMetadata metadata = createBeanMetadata(context, context.generateId(), ActionProviderBean.class,
true, true);
addBlueprintBundleRefProperty(context, metadata);
- metadata.addProperty("rpcProviderService", createRef(context, RPC_PROVIDER_SERVICE_NAME));
- metadata.addProperty("rpcRegistry", createRef(context, RPC_REGISTRY_NAME));
+ metadata.addProperty("domRpcProvider", createRef(context, DOM_RPC_PROVIDER_SERVICE_NAME));
+ metadata.addProperty("bindingRpcProvider", createRef(context, BINDING_RPC_PROVIDER_SERVICE_NAME));
metadata.addProperty("schemaService", createRef(context, SCHEMA_SERVICE_NAME));
metadata.addProperty("interfaceName", createValue(context, element.getAttribute(INTERFACE)));
private static Metadata parseRpcImplementation(final Element element, final ParserContext context) {
- registerRpcRegistryServiceRefBean(context);
+ registerBindingRpcProviderServiceRefBean(context);
MutableBeanMetadata metadata = createBeanMetadata(context, context.generateId(), RpcImplementationBean.class,
true, true);
addBlueprintBundleRefProperty(context, metadata);
- metadata.addProperty("rpcRegistry", createRef(context, RPC_REGISTRY_NAME));
+ metadata.addProperty("rpcProvider", createRef(context, BINDING_RPC_PROVIDER_SERVICE_NAME));
metadata.addProperty("implementation", createRef(context, element.getAttribute(REF_ATTR)));
if (element.hasAttribute(INTERFACE)) {
}
private static Metadata parseRoutedRpcImplementation(final Element element, final ParserContext context) {
- registerRpcRegistryServiceRefBean(context);
+ registerRefBean(context, RPC_REGISTRY_NAME, RpcProviderRegistry.class);
registerRoutedRpcRegistrationConverter(context);
ComponentFactoryMetadata metadata = new RoutedRpcMetadata(getId(context, element),
}
}
- private static void registerRpcProviderServiceRefBean(final ParserContext context) {
- registerRefBean(context, RPC_PROVIDER_SERVICE_NAME, DOMRpcProviderService.class);
+ private static void registerDomRpcProviderServiceRefBean(final ParserContext context) {
+ registerRefBean(context, DOM_RPC_PROVIDER_SERVICE_NAME, DOMRpcProviderService.class);
}
- private static void registerRpcRegistryServiceRefBean(final ParserContext context) {
- registerRefBean(context, RPC_REGISTRY_NAME, RpcProviderRegistry.class);
+ private static void registerBindingRpcProviderServiceRefBean(final ParserContext context) {
+ registerRefBean(context, BINDING_RPC_PROVIDER_SERVICE_NAME, RpcProviderService.class);
}
private static void registerSchemaServiceRefBean(final ParserContext context) {
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.osgi.framework.Bundle;
import org.osgi.service.blueprint.container.ComponentDefinitionException;
private static final Logger LOG = LoggerFactory.getLogger(RpcImplementationBean.class);
static final String RPC_IMPLEMENTATION = "rpc-implementation";
- private RpcProviderRegistry rpcRegistry;
+ private RpcProviderService rpcProvider;
private Bundle bundle;
private String interfaceName;
private RpcService implementation;
- private final List<RpcRegistration<RpcService>> rpcRegistrations = new ArrayList<>();
+ private final List<ObjectRegistration<RpcService>> rpcRegistrations = new ArrayList<>();
- public void setRpcRegistry(final RpcProviderRegistry rpcRegistry) {
- this.rpcRegistry = rpcRegistry;
+ public void setRpcProvider(final RpcProviderService rpcProvider) {
+ this.rpcProvider = rpcProvider;
}
public void setBundle(final Bundle bundle) {
implementation, rpcInterfaces);
for (Class<RpcService> rpcInterface : rpcInterfaces) {
- rpcRegistrations.add(rpcRegistry.addRpcImplementation(rpcInterface, implementation));
+ rpcRegistrations.add(rpcProvider.registerRpcImplementation(rpcInterface, implementation));
}
} catch (final ComponentDefinitionException e) {
throw e;
}
public void destroy() {
- for (RpcRegistration<RpcService> reg: rpcRegistrations) {
+ for (ObjectRegistration<RpcService> reg: rpcRegistrations) {
reg.close();
}
}
package org.opendaylight.controller.blueprint.ext;
import java.util.function.Predicate;
-import org.opendaylight.controller.md.sal.dom.broker.spi.rpc.RpcRoutingStrategy;
+import org.opendaylight.mdsal.dom.spi.RpcRoutingStrategy;
/**
* Factory metadata corresponding to the "rpc-service" element that gets an RPC service implementation from
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Predicate;
-import org.opendaylight.controller.md.sal.dom.broker.spi.rpc.RpcRoutingStrategy;
+import org.opendaylight.mdsal.dom.spi.RpcRoutingStrategy;
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
import org.opendaylight.yangtools.yang.common.QNameModule;