import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableSet;
-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.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.RpcService;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.osgi.framework.Bundle;
import org.osgi.service.blueprint.container.ComponentDefinitionException;
import org.slf4j.Logger;
*
* <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) {
}
private void registerFallback(final Class<RpcService> interfaceClass) {
- final Collection<SchemaPath> paths = RpcUtil.decomposeRpcService(interfaceClass,
+ final Collection<QName> paths = RpcUtil.decomposeRpcService(interfaceClass,
schemaService.getGlobalContext(), RpcRoutingStrategy::isContextBasedRouted);
if (paths.isEmpty()) {
LOG.warn("{}: interface {} has no actions defined", ACTION_PROVIDER, interfaceClass);
}
final Set<DOMRpcIdentifier> rpcs = ImmutableSet.copyOf(Collections2.transform(paths, DOMRpcIdentifier::create));
- reg = rpcProviderService.registerRpcImplementation((rpc, input) -> {
- return Futures.immediateFailedCheckedFuture(new DOMRpcImplementationNotAvailableException(
- "Action %s has no instance matching %s", rpc, input));
- }, rpcs);
+ reg = domRpcProvider.registerRpcImplementation(
+ (rpc, input) -> FluentFutures.immediateFailedFluentFuture(new DOMRpcImplementationNotAvailableException(
+ "Action %s has no instance matching %s", rpc, input)), rpcs);
LOG.debug("Registered provider for {}", interfaceName);
}
interfaceName, ACTION_PROVIDER, implementation.getClass()));
}
- reg = rpcRegistry.addRpcImplementation(interfaceClass, implementation);
+ reg = bindingRpcProvider.registerRpcImplementation(interfaceClass, implementation);
LOG.debug("Registered implementation {} for {}", implementation, interfaceName);
}
}