import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcInput;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
@NonNullByDefault
final class ActionAdapter extends AbstractBindingAdapter<DOMActionService> implements InvocationHandler {
private final Class<? extends Action<?, ?, ?>> type;
private final NodeIdentifier inputName;
- private final SchemaPath schemaPath;
+ private final Absolute actionPath;
ActionAdapter(final AdapterContext codec, final DOMActionService delegate,
final Class<? extends Action<?, ?, ?>> type) {
super(codec, delegate);
this.type = requireNonNull(type);
- this.schemaPath = currentSerializer().getActionPath(type);
- this.inputName = NodeIdentifier.create(operationInputQName(schemaPath.getLastComponent().getModule()));
+ this.actionPath = currentSerializer().getActionPath(type);
+ this.inputName = NodeIdentifier.create(operationInputQName(actionPath.lastNodeIdentifier().getModule()));
}
@Override
final InstanceIdentifier<?> path = (InstanceIdentifier<?>) requireNonNull(args[0]);
final RpcInput input = (RpcInput) requireNonNull(args[1]);
final CurrentAdapterSerializer serializer = currentSerializer();
- final ListenableFuture<? extends DOMActionResult> future = getDelegate().invokeAction(schemaPath,
+ final ListenableFuture<? extends DOMActionResult> future = getDelegate().invokeAction(actionPath,
new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL,
serializer.toYangInstanceIdentifier(path)),
serializer.toLazyNormalizedNodeActionInput(type, inputName, input));
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
@NonNullByDefault
public final class ActionProviderServiceAdapter extends AbstractBindingAdapter<DOMActionProviderService>
public <O extends DataObject, P extends InstanceIdentifier<O>, T extends Action<P, ?, ?>, S extends T>
ObjectRegistration<S> registerImplementation(final Class<T> actionInterface, final S implementation,
final LogicalDatastoreType datastore, final Set<DataTreeIdentifier<O>> validNodes) {
- final SchemaPath path = currentSerializer().getActionPath(actionInterface);
+ final Absolute path = currentSerializer().getActionPath(actionInterface);
final ObjectRegistration<DOMActionImplementation> reg = getDelegate().registerActionImplementation(
new Impl(adapterContext(),
- NodeIdentifier.create(YangConstants.operationOutputQName(path.getLastComponent().getModule())),
+ NodeIdentifier.create(YangConstants.operationOutputQName(path.lastNodeIdentifier().getModule())),
actionInterface, implementation), ImmutableSet.of());
return new AbstractObjectRegistration<>(implementation) {
@Override
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
- public ListenableFuture<? extends DOMActionResult> invokeAction(final SchemaPath type,
+ public ListenableFuture<? extends DOMActionResult> invokeAction(final Absolute type,
final DOMDataTreeIdentifier path, final ContainerNode input) {
final CurrentAdapterSerializer codec = adapterContext.currentSerializer();
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
class BindingDOMNotificationListenerAdapter implements DOMNotificationListener {
private final AdapterContext adapterContext;
private final NotificationListener delegate;
- private final ImmutableMap<SchemaPath, NotificationListenerInvoker> invokers;
+ private final ImmutableMap<Absolute, NotificationListenerInvoker> invokers;
BindingDOMNotificationListenerAdapter(final AdapterContext adapterContext, final NotificationListener delegate) {
this.adapterContext = requireNonNull(adapterContext);
@Override
public void onNotification(final DOMNotification notification) {
final Notification baNotification = deserialize(notification);
- final QName notificationQName = notification.getType().getLastComponent();
+ final QName notificationQName = notification.getType().lastNodeIdentifier();
getInvoker(notification.getType()).invokeNotification(delegate, notificationQName, baNotification);
}
: serializer.fromNormalizedNodeNotification(notification.getType(), notification.getBody());
}
- private NotificationListenerInvoker getInvoker(final SchemaPath type) {
+ private NotificationListenerInvoker getInvoker(final Absolute type) {
return invokers.get(type);
}
- protected Set<SchemaPath> getSupportedNotifications() {
+ protected Set<Absolute> getSupportedNotifications() {
return invokers.keySet();
}
- private static ImmutableMap<SchemaPath, NotificationListenerInvoker> createInvokerMapFor(
+ private static ImmutableMap<Absolute, NotificationListenerInvoker> createInvokerMapFor(
final Class<? extends NotificationListener> implClz) {
- final Map<SchemaPath, NotificationListenerInvoker> builder = new HashMap<>();
+ final Map<Absolute, NotificationListenerInvoker> builder = new HashMap<>();
for (final TypeToken<?> ifaceToken : TypeToken.of(implClz).getTypes().interfaces()) {
Class<?> iface = ifaceToken.getRawType();
if (NotificationListener.class.isAssignableFrom(iface) && BindingReflections.isBindingClass(iface)) {
final Class<? extends NotificationListener> listenerType
= (Class<? extends NotificationListener>) iface;
final NotificationListenerInvoker invoker = NotificationListenerInvoker.from(listenerType);
- for (final SchemaPath path : getNotificationTypes(listenerType)) {
+ for (final Absolute path : getNotificationTypes(listenerType)) {
builder.put(path, invoker);
}
}
return ImmutableMap.copyOf(builder);
}
- private static Set<SchemaPath> getNotificationTypes(final Class<? extends NotificationListener> type) {
+ private static Set<Absolute> getNotificationTypes(final Class<? extends NotificationListener> type) {
// TODO: Investigate possibility and performance impact if we cache this or expose
// it from NotificationListenerInvoker
- final Set<SchemaPath> ret = new HashSet<>();
+ final Set<Absolute> ret = new HashSet<>();
for (final Method method : type.getMethods()) {
if (BindingReflections.isNotificationCallback(method)) {
final Class<?> notification = method.getParameterTypes()[0];
- final QName name = BindingReflections.findQName(notification);
- ret.add(SchemaPath.create(true, name));
+ ret.add(Absolute.of(BindingReflections.findQName(notification)));
}
}
return ret;
*/
package org.opendaylight.mdsal.binding.dom.adapter;
+import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.dom.adapter.StaticConfiguration.ENABLE_CODEC_SHORTCUT;
import com.google.common.cache.CacheBuilder;
import com.google.common.util.concurrent.ListenableFuture;
import java.lang.reflect.Method;
-import java.util.HashMap;
import java.util.Map;
-import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;
import org.opendaylight.mdsal.binding.dom.adapter.invoke.RpcServiceInvoker;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingLazyContainerNode;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
final class BindingDOMRpcImplementationAdapter implements DOMRpcImplementation {
private static final Cache<Class<?>, RpcServiceInvoker> SERVICE_INVOKERS = CacheBuilder.newBuilder().weakKeys()
private final QName inputQname;
<T extends RpcService> BindingDOMRpcImplementationAdapter(final AdapterContext adapterContext,
- final Class<T> type, final Map<SchemaPath, Method> localNameToMethod, final T delegate) {
+ final Class<T> type, final Map<QName, Method> localNameToMethod, final T delegate) {
try {
- this.invoker = SERVICE_INVOKERS.get(type, () -> {
- final Map<QName, Method> map = new HashMap<>();
- for (Entry<SchemaPath, Method> e : localNameToMethod.entrySet()) {
- map.put(e.getKey().getLastComponent(), e.getValue());
- }
-
- return RpcServiceInvoker.from(map);
- });
+ this.invoker = SERVICE_INVOKERS.get(type, () -> RpcServiceInvoker.from(localNameToMethod));
} catch (ExecutionException e) {
throw new IllegalArgumentException("Failed to create invokers for type " + type, e);
}
@Override
public ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode<?, ?> input) {
- final SchemaPath schemaPath = rpc.getType();
+ final QName rpcType = rpc.getType();
final CurrentAdapterSerializer serializer = adapterContext.currentSerializer();
- final DataObject bindingInput = input != null ? deserialize(serializer, schemaPath, input) : null;
- final ListenableFuture<RpcResult<?>> bindingResult = invoke(schemaPath, bindingInput);
+ final DataObject bindingInput = input != null ? deserialize(serializer, rpcType, input) : null;
+ final ListenableFuture<RpcResult<?>> bindingResult = invoke(rpcType, bindingInput);
return LazyDOMRpcResultFuture.create(serializer, bindingResult);
}
return COST;
}
- private DataObject deserialize(final CurrentAdapterSerializer serializer, final SchemaPath rpcPath,
+ private DataObject deserialize(final CurrentAdapterSerializer serializer, final QName rpcType,
final NormalizedNode<?, ?> input) {
if (ENABLE_CODEC_SHORTCUT && input instanceof BindingLazyContainerNode) {
return ((BindingLazyContainerNode<?>) input).getDataObject();
}
- final SchemaPath inputSchemaPath = rpcPath.createChild(inputQname);
- return serializer.fromNormalizedNodeRpcData(inputSchemaPath, (ContainerNode) input);
+
+ final ContainerNode container = (ContainerNode) input;
+ checkArgument(inputQname.equals(container.getIdentifier().getNodeType()), "Unexpected RPC %s input %s", rpcType,
+ input);
+ return serializer.fromNormalizedNodeRpcData(Absolute.of(rpcType, inputQname), container);
}
- private ListenableFuture<RpcResult<?>> invoke(final SchemaPath schemaPath, final DataObject input) {
- return invoker.invokeRpc(delegate, schemaPath.getLastComponent(), input);
+ private ListenableFuture<RpcResult<?>> invoke(final QName rpcType, final DataObject input) {
+ return invoker.invokeRpc(delegate, rpcType, input);
}
}
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
@VisibleForTesting
public class BindingDOMRpcProviderServiceAdapter extends AbstractBindingAdapter<DOMRpcProviderService>
private <S extends RpcService, T extends S> ObjectRegistration<T> register(final Class<S> type,
final T implementation, final Collection<YangInstanceIdentifier> rpcContextPaths) {
- final Map<SchemaPath, Method> rpcs = currentSerializer().getRpcMethodToSchemaPath(type).inverse();
+ final Map<QName, Method> rpcs = currentSerializer().getRpcMethodToSchemaPath(type).inverse();
final BindingDOMRpcImplementationAdapter adapter = new BindingDOMRpcImplementationAdapter(adapterContext(),
type, rpcs, implementation);
return new BindingRpcAdapterRegistration<>(implementation, domReg);
}
- private static Set<DOMRpcIdentifier> createDomRpcIdentifiers(final Set<SchemaPath> rpcs,
+ private static Set<DOMRpcIdentifier> createDomRpcIdentifiers(final Set<QName> rpcs,
final Collection<YangInstanceIdentifier> paths) {
final Set<DOMRpcIdentifier> ret = new HashSet<>();
for (final YangInstanceIdentifier path : paths) {
- for (final SchemaPath rpc : rpcs) {
+ for (final QName rpc : rpcs) {
ret.add(DOMRpcIdentifier.create(rpc, path));
}
}
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableList;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.stream.Collectors;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return subtrees.stream().map(this::toDOMDataTreeIdentifier).collect(Collectors.toSet());
}
- @NonNull SchemaPath getActionPath(final @NonNull Class<? extends Action<?, ?, ?>> type) {
+ @NonNull Absolute getActionPath(final @NonNull Class<? extends Action<?, ?, ?>> type) {
+ // FIXME: we really just want a SchemaNodeIdentifier.Absolute here
final ActionDefinition schema = getRuntimeContext().getActionDefinition(type);
checkArgument(schema != null, "Failed to find schema for %s", type);
- return schema.getPath();
+ return Absolute.of(ImmutableList.copyOf(schema.getPath().getPathFromRoot()));
}
// FIXME: This should be probably part of Binding Runtime context
}
// FIXME: This should be probably part of Binding Runtime context
- ImmutableBiMap<Method, SchemaPath> getRpcMethodToSchemaPath(final Class<? extends RpcService> key) {
+ ImmutableBiMap<Method, QName> getRpcMethodToSchemaPath(final Class<? extends RpcService> key) {
final Module module = getModule(key);
- final ImmutableBiMap.Builder<Method, SchemaPath> ret = ImmutableBiMap.builder();
+ final ImmutableBiMap.Builder<Method, QName> ret = ImmutableBiMap.builder();
try {
for (final RpcDefinition rpcDef : module.getRpcs()) {
final Method method = findRpcMethod(key, rpcDef);
- ret.put(method, rpcDef.getPath());
+ ret.put(method,rpcDef.getQName());
}
} catch (final NoSuchMethodException e) {
throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
/*
* FIXME: This is a bit of functionality which should really live in binding-dom-codec, but for to happen we need
super(NodeIdentifier.create(identifier), binding, requireNonNull(codec));
}
- static ContainerNode create(final SchemaPath rpcName, final DataObject data,
+ static ContainerNode create(final QName rpcName, final DataObject data,
final BindingNormalizedNodeSerializer codec) {
- return data == null ? null : new LazySerializedContainerNode(rpcName.getLastComponent(), data, codec);
+ return data == null ? null : new LazySerializedContainerNode(rpcName, data, codec);
}
- static ContainerNode withContextRef(final SchemaPath rpcName, final DataObject data,
+ static ContainerNode withContextRef(final QName rpcName, final DataObject data,
final LeafNode<?> contextRef, final BindingNormalizedNodeSerializer serializer) {
- return new WithContextRef(rpcName.getLastComponent(), data, contextRef, serializer);
+ return new WithContextRef(rpcName, data, contextRef, serializer);
}
@Override
import static java.util.Objects.requireNonNull;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
import java.time.Instant;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
* Lazy serialized implementation of DOM Notification.
* notification.
*/
public final class LazySerializedDOMNotification implements DOMNotification, DOMEvent {
+ private static final LoadingCache<Class<?>, Absolute> PATHS = CacheBuilder.newBuilder().weakKeys()
+ .build(new CacheLoader<Class<?>, Absolute>() {
+ @Override
+ public Absolute load(final Class<?> key) {
+ // TODO: for nested (YANG 1.1) notifications we will need the SchemaPath where the notification is
+ // being invoked and use that instead of ROOT. How Binding users will refer to it is TBD (but
+ // probably InstanceIdentifier, which means we will need to do some lifting to find the
+ // SchemaPath)
+ return Absolute.of(BindingReflections.findQName(key)).intern();
+ }
+ });
+
private final @NonNull BindingNormalizedNodeSerializer codec;
private final @NonNull Notification data;
- private final @NonNull SchemaPath type;
+ private final @NonNull Absolute type;
private final @NonNull Instant eventInstant;
private volatile ContainerNode domBody;
LazySerializedDOMNotification(final BindingNormalizedNodeSerializer codec, final Notification data,
- final SchemaPath type, final Instant eventInstant) {
+ final Absolute type, final Instant eventInstant) {
this.codec = requireNonNull(codec);
this.data = requireNonNull(data);
this.type = requireNonNull(type);
static @NonNull DOMNotification create(final BindingNormalizedNodeSerializer codec, final Notification data,
final Instant eventInstant) {
- // TODO: for nested (YANG 1.1) notifications we will need the SchemaPath where the notification is being invoked
- // and use that instead of ROOT. How Binding users will refer to it is TBD (but probably
- // InstanceIdentifier, which means we will need to do some lifting to find the SchemaPath)
- final SchemaPath type = SchemaPath.ROOT.createChild(BindingReflections.findQName(data.implementedInterface()));
+ final Absolute type = PATHS.getUnchecked(data.implementedInterface());
return new LazySerializedDOMNotification(codec, data, type, eventInstant);
}
@Override
- public SchemaPath getType() {
+ public Absolute getType() {
return type;
}
import java.lang.reflect.Proxy;
import java.util.Map.Entry;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
class RpcServiceAdapter implements InvocationHandler {
private final ImmutableMap<Method, RpcInvocationStrategy> rpcNames;
}
private RpcInvocationStrategy createStrategy(final Method method, final RpcDefinition schema) {
+ final QName rpcType = schema.getQName();
final RpcRoutingStrategy strategy = RpcRoutingStrategy.from(schema);
- if (strategy.isContextBasedRouted()) {
- return new RoutedStrategy(schema.getPath(), method, strategy.getLeaf());
- }
- return new NonRoutedStrategy(schema.getPath());
+ return strategy.isContextBasedRouted() ? new RoutedStrategy(rpcType, method, strategy.getLeaf())
+ : new NonRoutedStrategy(rpcType);
}
RpcService getProxy() {
}
private abstract class RpcInvocationStrategy {
- private final SchemaPath rpcName;
+ private final @NonNull Absolute outputPath;
- RpcInvocationStrategy(final SchemaPath path) {
- rpcName = path;
+ RpcInvocationStrategy(final QName rpcName) {
+ this.outputPath = Absolute.of(rpcName, YangConstants.operationOutputQName(rpcName.getModule()).intern())
+ .intern();
}
final ListenableFuture<RpcResult<?>> invoke(final DataObject input) {
- return invoke0(rpcName, serialize(input));
+ return invoke0(serialize(input));
}
abstract ContainerNode serialize(DataObject input);
- final SchemaPath getRpcName() {
- return rpcName;
+ final QName getRpcName() {
+ return outputPath.firstNodeIdentifier();
}
- ListenableFuture<RpcResult<?>> invoke0(final SchemaPath schemaPath, final ContainerNode input) {
- final ListenableFuture<? extends DOMRpcResult> result = delegate.invokeRpc(schemaPath, input);
+ ListenableFuture<RpcResult<?>> invoke0(final ContainerNode input) {
+ final ListenableFuture<? extends DOMRpcResult> result =
+ delegate.invokeRpc(outputPath.firstNodeIdentifier(), input);
if (ENABLE_CODEC_SHORTCUT && result instanceof BindingRpcFutureAware) {
return ((BindingRpcFutureAware) result).getBindingFuture();
}
- return transformFuture(schemaPath, result, adapterContext.currentSerializer());
+ return transformFuture(result, adapterContext.currentSerializer());
}
- private ListenableFuture<RpcResult<?>> transformFuture(final SchemaPath rpc,
- final ListenableFuture<? extends DOMRpcResult> domFuture,
+ private ListenableFuture<RpcResult<?>> transformFuture(final ListenableFuture<? extends DOMRpcResult> domFuture,
final BindingNormalizedNodeSerializer resultCodec) {
return Futures.transform(domFuture, input -> {
final NormalizedNode<?, ?> domData = input.getResult();
final DataObject bindingResult;
if (domData != null) {
- final SchemaPath rpcOutput = rpc.createChild(YangConstants.operationOutputQName(
- rpc.getLastComponent().getModule()));
- bindingResult = resultCodec.fromNormalizedNodeRpcData(rpcOutput, (ContainerNode) domData);
+ bindingResult = resultCodec.fromNormalizedNodeRpcData(outputPath, (ContainerNode) domData);
} else {
bindingResult = null;
}
}
private final class NonRoutedStrategy extends RpcInvocationStrategy {
- NonRoutedStrategy(final SchemaPath path) {
- super(path);
+ NonRoutedStrategy(final QName rpcName) {
+ super(rpcName);
}
@Override
private final ContextReferenceExtractor refExtractor;
private final NodeIdentifier contextName;
- RoutedStrategy(final SchemaPath path, final Method rpcMethod, final QName leafName) {
- super(path);
+ RoutedStrategy(final QName rpcName, final Method rpcMethod, final QName leafName) {
+ super(rpcName);
final Optional<Class<? extends DataContainer>> maybeInputType =
BindingReflections.resolveRpcInputClass(rpcMethod);
checkState(maybeInputType.isPresent(), "RPC method %s has no input", rpcMethod.getName());
import org.opendaylight.yang.gen.v1.urn.odl.actions.norev.Othercont;
import org.opendaylight.yang.gen.v1.urn.odl.actions.norev.cont.Foo;
import org.opendaylight.yang.gen.v1.urn.odl.actions.norev.grpcont.Bar;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
public class ActionLookupTest {
@Test
CurrentAdapterSerializer codec = new CurrentAdapterSerializer(new BindingCodecContext(
BindingRuntimeHelpers.createRuntimeContext()));
- assertEquals(SchemaPath.create(true, Cont.QNAME, Foo.QNAME), codec.getActionPath(Foo.class));
- assertEquals(SchemaPath.create(true, Grpcont.QNAME, Bar.QNAME), codec.getActionPath(Bar.class));
- assertEquals(SchemaPath.create(true, Othercont.QNAME, Bar.QNAME),
+ assertEquals(Absolute.of(Cont.QNAME, Foo.QNAME), codec.getActionPath(Foo.class));
+ assertEquals(Absolute.of(Grpcont.QNAME, Bar.QNAME), codec.getActionPath(Bar.class));
+ assertEquals(Absolute.of(Othercont.QNAME, Bar.QNAME),
codec.getActionPath(org.opendaylight.yang.gen.v1.urn.odl.actions.norev.othercont.Bar.class));
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.rpcservice.rev140701.OpendaylightTestRpcServiceService;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class BindingDOMRpcImplementationAdapterTest {
public void basicTest() throws Exception {
final BindingDOMCodecServices registry = mock(BindingDOMCodecServices.class);
final Method testMethod = this.getClass().getDeclaredMethod("testMethod");
- final SchemaPath schemaPath = SchemaPath.create(true,
- QName.create(QNameModule.create(new URI("tst")), "test"));
+ final QName rpcType = QName.create(QNameModule.create(new URI("tst")), "test");
final BindingDOMRpcImplementationAdapter adapter = new BindingDOMRpcImplementationAdapter(
new ConstantAdapterContext(registry), OpendaylightTestRpcServiceService.class,
- ImmutableMap.of(schemaPath, testMethod), mock(OpendaylightTestRpcServiceService.class));
+ ImmutableMap.of(rpcType, testMethod), mock(OpendaylightTestRpcServiceService.class));
assertNotNull(adapter);
}
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class BindingDOMRpcIntegrationTest {
private static final InstanceIdentifier<TopLevelList> BA_NODE_ID = InstanceIdentifier.create(Top.class)
.child(TopLevelList.class, new TopLevelListKey("a"));
private static final QName KNOCK_KNOCK_QNAME = QName.create(KnockKnockOutput.QNAME, "knock-knock");
- private static final SchemaPath KNOCK_KNOCK_PATH = SchemaPath.create(true, KNOCK_KNOCK_QNAME);
private RpcProviderService baRpcProviderService;
private RpcConsumerRegistry baRpcConsumerService;
KnockKnockInput baKnockKnockInput = knockKnock(BA_NODE_ID).setQuestion("who's there?").build();
ContainerNode biKnockKnockInput = toDOMKnockKnockInput(baKnockKnockInput);
- DOMRpcResult domResult = biRpcService.invokeRpc(KNOCK_KNOCK_PATH, biKnockKnockInput).get(5, TimeUnit.SECONDS);
+ DOMRpcResult domResult = biRpcService.invokeRpc(KNOCK_KNOCK_QNAME, biKnockKnockInput).get(5, TimeUnit.SECONDS);
assertNotNull(domResult);
assertNotNull(domResult.getResult());
assertTrue("Binding KnockKnock service was not invoked",
biRpcProviderService.registerRpcImplementation((rpc, input) ->
FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult(testContext.getCodec()
.currentSerializer().toNormalizedNodeRpcData(baKnockKnockOutput))),
- DOMRpcIdentifier.create(KNOCK_KNOCK_PATH, testContext.getCodec().currentSerializer()
+ DOMRpcIdentifier.create(KNOCK_KNOCK_QNAME, testContext.getCodec().currentSerializer()
.toYangInstanceIdentifier(BA_NODE_ID)));
final OpendaylightKnockKnockRpcService baKnockService =
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class LazySerializedContainerNodeTest {
@Test
public void basicTest() throws Exception {
- final SchemaPath rpcName;
final DataObject dataObject = mock(DataObject.class);
final BindingNormalizedNodeSerializer codec = mock(BindingNormalizedNodeSerializer.class);
final ContainerNode containerNode = mock(ContainerNode.class);
final ImmutableBiMap<?, ?> biMap = bindingTestContext.getCodec().currentSerializer()
.getRpcMethodToSchema(OpendaylightTestRpcServiceService.class);
- rpcName = ((RpcDefinition) biMap.values().iterator().next()).getPath();
+ final QName rpcName = ((RpcDefinition) biMap.values().iterator().next()).getQName();
final LeafNode<?> leafNode = ImmutableLeafNodeBuilder.create().withNodeIdentifier(NodeIdentifier
.create(QName.create("", "test"))).withValue("").build();
final ContainerNode normalizedNode = LazySerializedContainerNode.create(rpcName, dataObject, codec);
assertTrue(lazySerializedContainerNode.getValue().isEmpty());
assertEquals(lazySerializedContainerNode.getIdentifier().getNodeType(),
lazySerializedContainerNode.getNodeType());
- assertEquals(rpcName.getLastComponent(), lazySerializedContainerNode.getIdentifier().getNodeType());
+ assertEquals(rpcName, lazySerializedContainerNode.getIdentifier().getNodeType());
assertEquals(dataObject, lazySerializedContainerNode.getDataObject());
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class Mdsal500Test {
private static final String FOO = "foo";
private static final QName SWITCH_QNAME = QName.create(SwitchOutput.QNAME, "switch");
- private static final SchemaPath SWITCH_PATH = SchemaPath.create(true, SWITCH_QNAME);
private RpcProviderService baRpcProviderService;
private RpcConsumerRegistry baRpcConsumerService;
SwitchInput baSwitchInput = switchBuilder(FOO).build();
ContainerNode biSwitchInput = toDOMSwitchInput(baSwitchInput);
- DOMRpcResult domResult = biRpcService.invokeRpc(SWITCH_PATH, biSwitchInput).get(5, TimeUnit.SECONDS);
+ DOMRpcResult domResult = biRpcService.invokeRpc(SWITCH_QNAME, biSwitchInput).get(5, TimeUnit.SECONDS);
assertNotNull(domResult);
assertNotNull(domResult.getResult());
assertTrue("Binding KnockKnock service was not invoked",
biRpcProviderService.registerRpcImplementation((rpc, input) ->
FluentFutures.immediateFluentFuture(new DefaultDOMRpcResult(testContext.getCodec().currentSerializer()
.toNormalizedNodeRpcData(baSwitchOutput))),
- DOMRpcIdentifier.create(SWITCH_PATH));
+ DOMRpcIdentifier.create(SWITCH_QNAME));
final Mdsal500Service baSwitchService =
baRpcConsumerService.getRpcService(Mdsal500Service.class);
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
* Serialization service, which provides two-way serialization between Java
* @param data NormalizedNode representing data
* @return Binding representation of Notification
*/
- @Nullable Notification fromNormalizedNodeNotification(@NonNull SchemaPath path, @NonNull ContainerNode data);
+ @Nullable Notification fromNormalizedNodeNotification(@NonNull Absolute path, @NonNull ContainerNode data);
/**
* Translates supplied NormalizedNode Notification into Binding data, optionally taking an instant
* @return Binding representation of Notification
*/
@Beta
- @Nullable Notification fromNormalizedNodeNotification(@NonNull SchemaPath path, @NonNull ContainerNode data,
+ @Nullable Notification fromNormalizedNodeNotification(@NonNull Absolute path, @NonNull ContainerNode data,
@Nullable Instant eventInstant);
/**
* Translates supplied NormalizedNode RPC input or output into Binding data.
*
- * @param path Schema path of RPC data, Schema path consists of rpc QName and input / output QName.
+ * @param containerPath Container path (RPC type + input/output)
* @param data NormalizedNode representing data
* @return Binding representation of RPC data
*/
- @Nullable DataObject fromNormalizedNodeRpcData(@NonNull SchemaPath path, @NonNull ContainerNode data);
+ @Nullable DataObject fromNormalizedNodeRpcData(@NonNull Absolute containerPath, @NonNull ContainerNode data);
/**
* Translates supplied ContainerNode action input.
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
@Beta
}
@Override
- public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) {
+ public Notification fromNormalizedNodeNotification(final Absolute path, final ContainerNode data) {
return delegate().fromNormalizedNodeNotification(path, data);
}
@Override
- public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data,
+ public Notification fromNormalizedNodeNotification(final Absolute path, final ContainerNode data,
final Instant eventInstant) {
return delegate().fromNormalizedNodeNotification(path, data, eventInstant);
}
@Override
- public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) {
- return delegate().fromNormalizedNodeRpcData(path, data);
+ public DataObject fromNormalizedNodeRpcData(final Absolute containerPath, final ContainerNode data) {
+ return delegate().fromNormalizedNodeRpcData(containerPath, data);
}
@Override
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
return null;
}
- NotificationCodecContext<?> getNotificationContext(final SchemaPath notification) {
+ NotificationCodecContext<?> getNotificationContext(final Absolute notification) {
return root.getNotification(notification);
}
- RpcInputCodec<?> getRpcInputCodec(final SchemaPath path) {
- return root.getRpc(path);
+ RpcInputCodec<?> getRpcInputCodec(final Absolute containerPath) {
+ return root.getRpc(containerPath);
}
ActionCodecContext getActionCodec(final Class<? extends Action<?, ?, ?>> action) {
}
@Override
- public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data) {
+ public Notification fromNormalizedNodeNotification(final Absolute path, final ContainerNode data) {
return getNotificationContext(path).deserialize(data);
}
@Override
- public Notification fromNormalizedNodeNotification(final SchemaPath path, final ContainerNode data,
+ public Notification fromNormalizedNodeNotification(final Absolute path, final ContainerNode data,
final Instant eventInstant) {
return eventInstant == null ? fromNormalizedNodeNotification(path, data)
: getNotificationContext(path).deserialize(data, eventInstant);
}
@Override
- public DataObject fromNormalizedNodeRpcData(final SchemaPath path, final ContainerNode data) {
- return getRpcInputCodec(path).deserialize(data);
+ public DataObject fromNormalizedNodeRpcData(final Absolute containerPath, final ContainerNode data) {
+ return getRpcInputCodec(containerPath).deserialize(data);
}
@Override
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
}
});
- private final LoadingCache<SchemaPath, RpcInputCodec<?>> rpcDataByPath = CacheBuilder.newBuilder().build(
- new CacheLoader<SchemaPath, RpcInputCodec<?>>() {
+ private final LoadingCache<Absolute, RpcInputCodec<?>> rpcDataByPath = CacheBuilder.newBuilder().build(
+ new CacheLoader<Absolute, RpcInputCodec<?>>() {
@Override
- public RpcInputCodec<?> load(final SchemaPath key) {
- final ContainerSchemaNode schema = SchemaContextUtil.getRpcDataSchema(getSchema(), key);
+ public RpcInputCodec<?> load(final Absolute key) {
+ final ContainerSchemaNode schema = SchemaContextUtil.getRpcDataSchema(getSchema(), key.asSchemaPath());
@SuppressWarnings("unchecked")
final Class<? extends DataContainer> cls = (Class<? extends DataContainer>)
factory().getRuntimeContext().getClassForSchema(schema);
}
});
- private final LoadingCache<SchemaPath, NotificationCodecContext<?>> notificationsByPath = CacheBuilder.newBuilder()
- .build(new CacheLoader<SchemaPath, NotificationCodecContext<?>>() {
+ private final LoadingCache<Absolute, NotificationCodecContext<?>> notificationsByPath = CacheBuilder.newBuilder()
+ .build(new CacheLoader<Absolute, NotificationCodecContext<?>>() {
@Override
- public NotificationCodecContext<?> load(final SchemaPath key) {
- final NotificationDefinition schema = SchemaContextUtil.getNotificationSchema(getSchema(), key);
+ public NotificationCodecContext<?> load(final Absolute key) {
+ final NotificationDefinition schema = SchemaContextUtil.getNotificationSchema(getSchema(),
+ // FIXME: do not convert here!
+ key.asSchemaPath());
@SuppressWarnings("unchecked")
final Class<? extends Notification> clz = (Class<? extends Notification>)
factory().getRuntimeContext().getClassForSchema(schema);
return getOrRethrow(notificationsByClass, notification);
}
- NotificationCodecContext<?> getNotification(final SchemaPath notification) {
+ NotificationCodecContext<?> getNotification(final Absolute notification) {
return getOrRethrow(notificationsByPath, notification);
}
return getOrRethrow(rpcDataByClass, rpcInputOrOutput);
}
- RpcInputCodec<?> getRpc(final SchemaPath notification) {
- return getOrRethrow(rpcDataByPath, notification);
+ RpcInputCodec<?> getRpc(final Absolute containerPath) {
+ return getOrRethrow(rpcDataByPath, containerPath);
}
DataContainerCodecContext<?,?> createDataTreeChildContext(final Class<?> key) {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
public class Mdsal552Test extends AbstractBindingCodecTest {
- private static final SchemaPath OUTPUT_PATH = SchemaPath.create(true, QName.create(RefTestOutput.QNAME, "ref_test"),
+ private static final Absolute OUTPUT_PATH = Absolute.of(QName.create(RefTestOutput.QNAME, "ref_test"),
RefTestOutput.QNAME);
private static final QName OUTPUTREF = QName.create(RefTestOutput.QNAME, "outputref");
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
public class NotificationProcessingTest extends AbstractBindingCodecTest {
private static final QName NAME = QName.create(TopLevelList.QNAME, "name");
@Test
public void testNormalizedToNotification() {
- final Notification bindingDeserialized = codecContext.fromNormalizedNodeNotification(SchemaPath.create(true,
+ final Notification bindingDeserialized = codecContext.fromNormalizedNodeNotification(Absolute.of(
TwoLevelListChanged.QNAME), createTestDomData());
assertTrue(bindingDeserialized instanceof TwoLevelListChanged);
assertEquals(createTestBindingData(), bindingDeserialized);
@Test
public void testNormalizedToNotificationWithInstant() {
final Instant instant = Instant.now();
- final Notification bindingDeserialized = codecContext.fromNormalizedNodeNotification(SchemaPath.create(true,
+ final Notification bindingDeserialized = codecContext.fromNormalizedNodeNotification(Absolute.of(
TwoLevelListChanged.QNAME), createTestDomData(), instant);
assertTrue(bindingDeserialized instanceof TwoLevelListChanged);
assertEquals(createTestBindingData(), bindingDeserialized);
@Test
public void testNormalizedToNotificationWithNull() {
- final Notification bindingDeserialized = codecContext.fromNormalizedNodeNotification(SchemaPath.create(true,
+ final Notification bindingDeserialized = codecContext.fromNormalizedNodeNotification(Absolute.of(
TwoLevelListChanged.QNAME), createTestDomData(), null);
assertTrue(bindingDeserialized instanceof TwoLevelListChanged);
assertEquals(createTestBindingData(), bindingDeserialized);
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
public class RpcDataSerializationTest extends AbstractBindingCodecTest {
-
private static final QName PUT_TOP = QName.create(PutTopInput.QNAME, "put-top");
private static final QName GET_TOP = QName.create(GetTopOutput.QNAME, "get-top");
-
- private static final SchemaPath PUT_TOP_INPUT = SchemaPath.create(true, PUT_TOP, PutTopInput.QNAME);
- private static final SchemaPath GET_TOP_OUTPUT = SchemaPath.create(true, GET_TOP, GetTopOutput.QNAME);
+ private static final Absolute PUT_TOP_INPUT = Absolute.of(PUT_TOP, PutTopInput.QNAME);
+ private static final Absolute GET_TOP_OUTPUT = Absolute.of(GET_TOP, GetTopOutput.QNAME);
private static final TopLevelListKey LIST_KEY = new TopLevelListKey("test");
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
* An {@link DOMActionServiceExtension} exposed by {@link DOMActionService}s which allow their users to listen
*
* <p>
* Users should note that using a listener does not necessarily mean that
- * {@link DOMActionService#invokeAction(SchemaPath, DOMDataTreeIdentifier, ContainerNode)} will not report
+ * {@link DOMActionService#invokeAction(Absolute, DOMDataTreeIdentifier, ContainerNode)} will not report
* a failure due to {@link DOMActionNotAvailableException} and need to be ready to handle it.
*
* <p>
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
* Interface implemented by an individual operation implementation. This API allows for dispatch implementations, e.g.
/**
* Initiate invocation of the action. Implementations of this method are expected to not block.
*
- * @param type SchemaPath of the action to be invoked. This path refers to an effective action instantiated on top
- * of the conceptual {@link StoreTreeNode}.
+ * @param type absolute schema node identifier of the action to be invoked. This path refers to an effective action
+ * instantiated on top of the conceptual {@link StoreTreeNode}.
* @param path {@link DOMDataTreeIdentifier} of parent data node which action attached to.
* @param input Input arguments
* @return A FluentFuture which completes with the result of invocation
* @throws NullPointerException if any of the arguments is null
*/
- ListenableFuture<? extends DOMActionResult> invokeAction(SchemaPath type, DOMDataTreeIdentifier path,
+ ListenableFuture<? extends DOMActionResult> invokeAction(Absolute type, DOMDataTreeIdentifier path,
ContainerNode input);
/**
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
* An action which is subject to availability.
*/
public final class DOMActionInstance implements Immutable {
private final Set<DOMDataTreeIdentifier> dataTrees;
- private final SchemaPath type;
+ private final Absolute type;
- DOMActionInstance(final SchemaPath type, final Set<DOMDataTreeIdentifier> dataTrees) {
+ DOMActionInstance(final Absolute type, final Set<DOMDataTreeIdentifier> dataTrees) {
this.type = requireNonNull(type);
this.dataTrees = ImmutableSet.copyOf(dataTrees);
checkArgument(!dataTrees.isEmpty());
}
- public static DOMActionInstance of(final SchemaPath type, final Set<DOMDataTreeIdentifier> dataTrees) {
+ public static DOMActionInstance of(final Absolute type, final Set<DOMDataTreeIdentifier> dataTrees) {
return new DOMActionInstance(type, dataTrees);
}
- public static DOMActionInstance of(final SchemaPath type, final DOMDataTreeIdentifier... dataTrees) {
+ public static DOMActionInstance of(final Absolute type, final DOMDataTreeIdentifier... dataTrees) {
return of(type, ImmutableSet.copyOf(dataTrees));
}
- public static DOMActionInstance of(final SchemaPath type, final LogicalDatastoreType datastore,
+ public static DOMActionInstance of(final Absolute type, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path) {
return of(type, ImmutableSet.of(new DOMDataTreeIdentifier(datastore, path)));
}
*
* @return operation type.
*/
- public SchemaPath getType() {
+ public Absolute getType() {
return type;
}
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
* A {@link DOMService} which allows clients to invoke Actions. The conceptual model of this service is that
/**
* Initiate invocation of an Action. This method is guaranteed to not block on any external resources.
*
- * @param type SchemaPath of the action to be invoked. This path refers to an effective action instantiated on top
- * of the conceptual {@link StoreTreeNode}.
+ * @param type Absolute schema node identifier of the action to be invoked. This path refers to an effective action
+ * instantiated on top of the conceptual {@link StoreTreeNode}.
* @param path {@link DOMDataTreeIdentifier} of parent data node which action attached to.
* @param input Input argument
* @return A FluentFuture which completes with the result of invocation
* @throws NullPointerException if any of the arguments is null
*/
- ListenableFuture<? extends DOMActionResult> invokeAction(SchemaPath type, DOMDataTreeIdentifier path,
+ ListenableFuture<? extends DOMActionResult> invokeAction(Absolute type, DOMDataTreeIdentifier path,
ContainerNode input);
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
* A single YANG notification. This interface captures the data portion of a notification. Implementations may choose
*
* @return Notification type.
*/
- @NonNull SchemaPath getType();
+ @NonNull Absolute getType();
/**
* Return the body of this notification.
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
* A {@link DOMService} which allows its users to subscribe to receive
* @return Registration handle. Invoking {@link ListenerRegistration#close()} will stop the
* delivery of notifications to the listener
* @throws IllegalArgumentException if types is empty or contains an invalid element, such as
- * null or a SchemaPath which does not represent a valid {@link DOMNotification} type.
+ * null or a schema node identifier which does not represent a valid {@link DOMNotification} type.
* @throws NullPointerException if either of the arguments is null
*/
<T extends DOMNotificationListener> ListenerRegistration<T>
- registerNotificationListener(@NonNull T listener, @NonNull Collection<SchemaPath> types);
+ registerNotificationListener(@NonNull T listener, @NonNull Collection<Absolute> types);
/**
* Register a {@link DOMNotificationListener} to receive a set of notifications. As with other
* @return Registration handle. Invoking {@link ListenerRegistration#close()} will stop the
* delivery of notifications to the listener
* @throws IllegalArgumentException if types is empty or contains an invalid element, such as
- * null or a SchemaPath which does not represent a valid {@link DOMNotification} type.
+ * null or a schema node identifier which does not represent a valid {@link DOMNotification} type.
* @throws NullPointerException if listener is null
*/
default <T extends DOMNotificationListener> ListenerRegistration<T>
- registerNotificationListener(@NonNull final T listener, final SchemaPath... types) {
+ registerNotificationListener(@NonNull final T listener, final Absolute... types) {
return registerNotificationListener(listener, Arrays.asList(types));
}
}
import java.util.Objects;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
/**
* Identifier of a RPC context. This is an extension of the YANG RPC, which always has global context. It allows an RPC
@NonNullByDefault
public abstract class DOMRpcIdentifier {
private static final class Global extends DOMRpcIdentifier {
- private Global(final SchemaPath type) {
+ private Global(final QName type) {
super(type);
}
private static final class Local extends DOMRpcIdentifier {
private final YangInstanceIdentifier contextReference;
- private Local(final SchemaPath type, final YangInstanceIdentifier contextReference) {
+ private Local(final QName type, final YangInstanceIdentifier contextReference) {
super(type);
this.contextReference = requireNonNull(contextReference);
}
}
}
- private final SchemaPath type;
+ private final QName type;
- private DOMRpcIdentifier(final SchemaPath type) {
+ private DOMRpcIdentifier(final QName type) {
this.type = requireNonNull(type);
}
/**
* Create a global RPC identifier.
*
- * @param type RPC type, SchemaPath of its definition, may not be null
+ * @param type RPC type, schema node identifier of its definition, may not be null
* @return A global RPC identifier, guaranteed to be non-null.
*/
- public static DOMRpcIdentifier create(final SchemaPath type) {
+ public static DOMRpcIdentifier create(final QName type) {
return new Global(type);
}
/**
* Create an RPC identifier with a particular context reference.
*
- * @param type RPC type, SchemaPath of its definition, may not be null
+ * @param type RPC type, schema node identifier of its definition, may not be null
* @param contextReference Context reference, null means a global RPC identifier.
* @return A global RPC identifier, guaranteed to be non-null.
*/
- public static DOMRpcIdentifier create(final SchemaPath type,
- final @Nullable YangInstanceIdentifier contextReference) {
+ public static DOMRpcIdentifier create(final QName type, final @Nullable YangInstanceIdentifier contextReference) {
if (contextReference == null || contextReference.isEmpty()) {
return new Global(type);
}
*
* @return RPC type.
*/
- public final SchemaPath getType() {
+ public final QName getType() {
return type;
}
import com.google.common.util.concurrent.ListenableFuture;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
/**
* A {@link DOMService} which allows clients to invoke RPCs. The conceptual model of this service is that of a dynamic
* Initiate invocation of an RPC. This method is guaranteed to not block on any external
* resources.
*
- * @param type SchemaPath of the RPC to be invoked
+ * @param type QName of the RPC to be invoked
* @param input Input arguments, null if the RPC does not take any.
* @return A {@link ListenableFuture} which will return either a result structure, or report a subclass
* of {@link DOMRpcException} reporting a transport error.
*/
- @NonNull ListenableFuture<? extends DOMRpcResult> invokeRpc(@NonNull SchemaPath type,
+ @NonNull ListenableFuture<? extends DOMRpcResult> invokeRpc(@NonNull QName type,
@NonNull NormalizedNode<?, ?> input);
/**
* about RPC implementations becoming (un)available. The listener will be invoked with the
* current implementations reported and will be kept uptodate as implementations come and go.
* Users should note that using a listener does not necessarily mean that
- * {@link #invokeRpc(SchemaPath, NormalizedNode)} will not report a failure due to
+ * {@link #invokeRpc(QName, NormalizedNode)} will not report a failure due to
* {@link DOMRpcImplementationNotAvailableException} and need to be ready to handle it.
* Implementations are encouraged to take reasonable precautions to prevent this scenario from
* occurring.
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class DOMRpcIdentifierTest {
private static final String LOCAL_IDENT = "local";
private static final QNameModule TEST_MODULE = QNameModule.create(URI.create(
"urn:opendaylight:params:xml:ns:yang:controller:md:sal:test:store"));
- private static final DOMRpcIdentifier GLOBAL = DOMRpcIdentifier.create(SchemaPath.SAME, null);
- private static final DOMRpcIdentifier LOCAL = DOMRpcIdentifier.create(SchemaPath.ROOT,YangInstanceIdentifier.create(
- new NodeIdentifier(QName.create(TEST_MODULE, LOCAL_IDENT))));
+ private static final QName LOCAL_QNAME = QName.create(TEST_MODULE, LOCAL_IDENT);
+
+ private static final DOMRpcIdentifier GLOBAL = DOMRpcIdentifier.create(LOCAL_QNAME, null);
+ private static final DOMRpcIdentifier LOCAL = DOMRpcIdentifier.create(LOCAL_QNAME,
+ YangInstanceIdentifier.create(new NodeIdentifier(LOCAL_QNAME)));
@Test
public void createTest() {
@Test
public void hashCodeTest() {
- assertEquals("hashCode", GLOBAL.hashCode(), DOMRpcIdentifier.create(SchemaPath.ROOT).hashCode());
+ assertEquals("hashCode", GLOBAL.hashCode(), DOMRpcIdentifier.create(LOCAL_QNAME).hashCode());
assertNotEquals("hashCode", GLOBAL.hashCode(), LOCAL.hashCode());
}
@Test
public void equalsTest() {
- assertTrue("Equals same", GLOBAL.equals(DOMRpcIdentifier.create(SchemaPath.SAME)));
+ assertTrue("Equals same", GLOBAL.equals(DOMRpcIdentifier.create(LOCAL_QNAME)));
assertTrue("Equals same instance", GLOBAL.equals(GLOBAL));
assertFalse("Different object", GLOBAL.equals(new Object()));
assertFalse("Different instance", GLOBAL.equals(LOCAL));
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
/**
* Abstract routing table definition for Action and RPC.
* @param <M> implementation type of RPC or Acton
* @param <L> listener type of RPC or Acton
* @param <E> routing entry type of RPC or Acton
+ * @param <K> routing key type
*/
@Beta
-abstract class AbstractDOMRoutingTable<I, D, M, L extends EventListener,
- E extends AbstractDOMRoutingTableEntry<D, M, L>> {
- private final Map<SchemaPath, E> operations;
+abstract class AbstractDOMRoutingTable<I, D, M, L extends EventListener, K,
+ E extends AbstractDOMRoutingTableEntry<D, M, L, K>> {
+ private final Map<K, E> operations;
private final EffectiveModelContext schemaContext;
- AbstractDOMRoutingTable(final Map<SchemaPath, E> operations, final EffectiveModelContext schemaContext) {
+ AbstractDOMRoutingTable(final Map<K, E> operations, final EffectiveModelContext schemaContext) {
this.operations = requireNonNull(operations);
this.schemaContext = schemaContext;
}
- AbstractDOMRoutingTable<I, D, M, L, E> setSchemaContext(final EffectiveModelContext context) {
- final Builder<SchemaPath, E> b = ImmutableMap.builder();
+ AbstractDOMRoutingTable<I, D, M, L, K, E> setSchemaContext(final EffectiveModelContext context) {
+ final Builder<K, E> b = ImmutableMap.builder();
- for (Entry<SchemaPath, E> e : operations.entrySet()) {
- final E entry = createOperationEntry(context, e.getKey(),
- e.getValue().getImplementations());
+ for (Entry<K, E> e : operations.entrySet()) {
+ final E entry = createOperationEntry(context, e.getKey(), e.getValue().getImplementations());
if (entry != null) {
b.put(e.getKey(), entry);
}
return newInstance(b.build(), context);
}
- AbstractDOMRoutingTable<I, D, M, L, E> add(final M implementation, final Set<I> oprsToAdd) {
+ AbstractDOMRoutingTable<I, D, M, L, K, E> add(final M implementation, final Set<I> oprsToAdd) {
if (oprsToAdd.isEmpty()) {
return this;
}
// First decompose the identifiers to a multimap
- final ListMultimap<SchemaPath, D> toAdd = decomposeIdentifiers(oprsToAdd);
+ final ListMultimap<K, D> toAdd = decomposeIdentifiers(oprsToAdd);
// Now iterate over existing entries, modifying them as appropriate...
- final Builder<SchemaPath, E> mb = ImmutableMap.builder();
- for (Entry<SchemaPath, E> re : this.operations.entrySet()) {
+ final Builder<K, E> mb = ImmutableMap.builder();
+ for (Entry<K, E> re : this.operations.entrySet()) {
List<D> newOperations = new ArrayList<>(toAdd.removeAll(re.getKey()));
if (!newOperations.isEmpty()) {
final E ne = (E) re.getValue().add(implementation, newOperations);
}
// Finally add whatever is left in the decomposed multimap
- for (Entry<SchemaPath, Collection<D>> e : toAdd.asMap().entrySet()) {
+ for (Entry<K, Collection<D>> e : toAdd.asMap().entrySet()) {
final Builder<D, List<M>> vb = ImmutableMap.builder();
final List<M> v = ImmutableList.of(implementation);
for (D i : e.getValue()) {
return newInstance(mb.build(), schemaContext);
}
- AbstractDOMRoutingTable<I, D, M, L, E> remove(final M implementation, final Set<I> instances) {
+ AbstractDOMRoutingTable<I, D, M, L, K, E> remove(final M implementation, final Set<I> instances) {
if (instances.isEmpty()) {
return this;
}
// First decompose the identifiers to a multimap
- final ListMultimap<SchemaPath, D> toRemove = decomposeIdentifiers(instances);
+ final ListMultimap<K, D> toRemove = decomposeIdentifiers(instances);
// Now iterate over existing entries, modifying them as appropriate...
- final Builder<SchemaPath, E> b = ImmutableMap.builder();
- for (Entry<SchemaPath, E> e : this.operations.entrySet()) {
+ final Builder<K, E> b = ImmutableMap.builder();
+ for (Entry<K, E> e : this.operations.entrySet()) {
final List<D> removed = new ArrayList<>(toRemove.removeAll(e.getKey()));
if (!removed.isEmpty()) {
final E ne = (E) e.getValue().remove(implementation, removed);
}
@VisibleForTesting
- Map<SchemaPath, Set<D>> getOperations() {
+ Map<K, Set<D>> getOperations() {
return Maps.transformValues(operations, AbstractDOMRoutingTableEntry::registeredIdentifiers);
}
- Map<SchemaPath, Set<D>> getOperations(final L listener) {
- final Map<SchemaPath, Set<D>> ret = new HashMap<>(operations.size());
- for (Entry<SchemaPath, E> e : operations.entrySet()) {
+ Map<K, Set<D>> getOperations(final L listener) {
+ final Map<K, Set<D>> ret = new HashMap<>(operations.size());
+ for (Entry<K, E> e : operations.entrySet()) {
final Set<D> ids = e.getValue().registeredIdentifiers(listener);
if (!ids.isEmpty()) {
ret.put(e.getKey(), ids);
return ret;
}
- @Nullable AbstractDOMRoutingTableEntry<D, M, L> getEntry(final @NonNull SchemaPath type) {
+ @Nullable AbstractDOMRoutingTableEntry<D, M, L, K> getEntry(final @NonNull K type) {
return operations.get(type);
}
- protected abstract AbstractDOMRoutingTable<I, D, M, L, E> newInstance(Map<SchemaPath, E> operations,
+ protected abstract AbstractDOMRoutingTable<I, D, M, L, K, E> newInstance(Map<K, E> operations,
EffectiveModelContext schemaContext);
- abstract ListMultimap<SchemaPath, D> decomposeIdentifiers(Set<I> instances);
+ abstract ListMultimap<K, D> decomposeIdentifiers(Set<I> instances);
- abstract E createOperationEntry(EffectiveModelContext context, SchemaPath key, Map<D, List<M>> implementations);
+ abstract E createOperationEntry(EffectiveModelContext context, K key, Map<D, List<M>> implementations);
}
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
/**
* Abstract routing table entry definition for Action and RPC.
* @param <D> identifier type of RPC or Acton
* @param <M> implementation type of RPC or Acton
* @param <L> listener type of RPC or Acton
+ * @param <K> routing key type
*/
@Beta
-abstract class AbstractDOMRoutingTableEntry<D, M, L extends EventListener> {
+abstract class AbstractDOMRoutingTableEntry<D, M, L extends EventListener, K> {
private final Map<D, List<M>> implementations;
- private final SchemaPath type;
+ private final K type;
- AbstractDOMRoutingTableEntry(final SchemaPath type, final Map<D, List<M>> implementations) {
+ AbstractDOMRoutingTableEntry(final K type, final Map<D, List<M>> implementations) {
this.type = requireNonNull(type);
this.implementations = requireNonNull(implementations);
}
- SchemaPath getType() {
+ K getType() {
return type;
}
* @param newOprs the List of new RPCs/Actions that the DOMOperationImplementation provides, must be mutable
* @return a new instance of DOMActionRoutingTableEntry with the additions
*/
- AbstractDOMRoutingTableEntry<D, M, L> add(final M implementation, final List<D> newOprs) {
+ AbstractDOMRoutingTableEntry<D, M, L, K> add(final M implementation, final List<D> newOprs) {
final Builder<D, List<M>> vb = ImmutableMap.builder();
for (final Entry<D, List<M>> ve : implementations.entrySet()) {
if (newOprs.remove(ve.getKey())) {
return newInstance(vb.build());
}
- AbstractDOMRoutingTableEntry<D, M, L> remove(final M implementation, final List<D> removed) {
+ AbstractDOMRoutingTableEntry<D, M, L, K> remove(final M implementation, final List<D> removed) {
final Builder<D, List<M>> vb = ImmutableMap.builder();
for (final Entry<D, List<M>> ve : implementations.entrySet()) {
if (removed.remove(ve.getKey())) {
protected abstract Comparator<M> implComparator();
- protected abstract AbstractDOMRoutingTableEntry<D, M, L> newInstance(Map<D, List<M>> impls);
+ protected abstract AbstractDOMRoutingTableEntry<D, M, L, K> newInstance(Map<D, List<M>> impls);
}
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
abstract class AbstractDOMRpcRoutingTableEntry extends AbstractDOMRoutingTableEntry<YangInstanceIdentifier,
- DOMRpcImplementation, DOMRpcAvailabilityListener> {
+ DOMRpcImplementation, DOMRpcAvailabilityListener, QName> {
private final DOMRpcIdentifier rpcId;
- AbstractDOMRpcRoutingTableEntry(final DOMRpcIdentifier rpcId, final Map<YangInstanceIdentifier,
- List<DOMRpcImplementation>> implementations) {
+ AbstractDOMRpcRoutingTableEntry(final DOMRpcIdentifier rpcId,
+ final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> implementations) {
super(rpcId.getType(), implementations);
this.rpcId = requireNonNull(rpcId);
}
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
-
/**
* Definition of Action routing table.
*/
@Beta
final class DOMActionRoutingTable extends AbstractDOMRoutingTable<DOMActionInstance, DOMDataTreeIdentifier,
- DOMActionImplementation, AvailabilityListener, DOMActionRoutingTableEntry> {
+ DOMActionImplementation, AvailabilityListener, Absolute, DOMActionRoutingTableEntry> {
static final DOMActionRoutingTable EMPTY = new DOMActionRoutingTable(ImmutableMap.of(), null);
- private DOMActionRoutingTable(final Map<SchemaPath, DOMActionRoutingTableEntry> actions,
+ private DOMActionRoutingTable(final Map<Absolute, DOMActionRoutingTableEntry> actions,
final EffectiveModelContext schemaContext) {
super(actions, schemaContext);
}
@Override
- protected DOMActionRoutingTable newInstance(final Map<SchemaPath, DOMActionRoutingTableEntry> operations,
+ protected DOMActionRoutingTable newInstance(final Map<Absolute, DOMActionRoutingTableEntry> operations,
final EffectiveModelContext schemaContext) {
return new DOMActionRoutingTable(operations, schemaContext);
}
@Override
- protected ListMultimap<SchemaPath, DOMDataTreeIdentifier> decomposeIdentifiers(
+ protected ListMultimap<Absolute, DOMDataTreeIdentifier> decomposeIdentifiers(
final Set<DOMActionInstance> instances) {
- final ListMultimap<SchemaPath, DOMDataTreeIdentifier> ret = LinkedListMultimap.create();
+ final ListMultimap<Absolute, DOMDataTreeIdentifier> ret = LinkedListMultimap.create();
for (DOMActionInstance instance : instances) {
instance.getDataTrees().forEach(id -> ret.put(instance.getType(), id));
}
@Override
protected DOMActionRoutingTableEntry createOperationEntry(final EffectiveModelContext context,
- final SchemaPath type, final Map<DOMDataTreeIdentifier, List<DOMActionImplementation>> implementations) {
+ final Absolute type, final Map<DOMDataTreeIdentifier, List<DOMActionImplementation>> implementations) {
final ActionDefinition actionDef = findActionDefinition(context, type);
if (actionDef == null) {
//FIXME: return null directly instead of providing kind of unknown entry.
return new DOMActionRoutingTableEntry(type, implementations);
}
- private static ActionDefinition findActionDefinition(final SchemaContext context, final SchemaPath path) {
- final SchemaNode node = SchemaContextUtil.findDataSchemaNode(context, path.getParent());
+ private static ActionDefinition findActionDefinition(final SchemaContext context, final Absolute path) {
+ // FIXME: use direct search
+ final SchemaPath legacy = path.asSchemaPath();
+ final SchemaNode node = SchemaContextUtil.findDataSchemaNode(context, legacy.getParent());
if (node instanceof ActionNodeContainer) {
- return ((ActionNodeContainer) node).findAction(path.getLastComponent()).orElse(null);
+ return ((ActionNodeContainer) node).findAction(legacy.getLastComponent()).orElse(null);
}
return null;
}
import org.opendaylight.mdsal.dom.api.DOMActionAvailabilityExtension.AvailabilityListener;
import org.opendaylight.mdsal.dom.api.DOMActionImplementation;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
* Definition of Action routing table entry.
*/
@Beta
final class DOMActionRoutingTableEntry extends AbstractDOMRoutingTableEntry<DOMDataTreeIdentifier,
- DOMActionImplementation, AvailabilityListener> {
- DOMActionRoutingTableEntry(final SchemaPath type,
+ DOMActionImplementation, AvailabilityListener, Absolute> {
+ DOMActionRoutingTableEntry(final Absolute type,
final Map<DOMDataTreeIdentifier, List<DOMActionImplementation>> implementations) {
super(type, implementations);
}
@Override
protected DOMActionRoutingTableEntry newInstance(
- Map<DOMDataTreeIdentifier, List<DOMActionImplementation>> impls) {
+ final Map<DOMDataTreeIdentifier, List<DOMActionImplementation>> impls) {
return new DOMActionRoutingTableEntry(getType(), impls);
}
}
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.util.ListenerRegistry;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final ScheduledThreadPoolExecutor observer;
private final ExecutorService executor;
- private volatile Multimap<SchemaPath, AbstractListenerRegistration<? extends DOMNotificationListener>> listeners =
+ private volatile Multimap<Absolute, AbstractListenerRegistration<? extends DOMNotificationListener>> listeners =
ImmutableMultimap.of();
@VisibleForTesting
@Override
public synchronized <T extends DOMNotificationListener> ListenerRegistration<T> registerNotificationListener(
- final T listener, final Collection<SchemaPath> types) {
+ final T listener, final Collection<Absolute> types) {
final AbstractListenerRegistration<T> reg = new AbstractListenerRegistration<>(listener) {
@Override
protected void removeRegistration() {
};
if (!types.isEmpty()) {
- final Builder<SchemaPath, AbstractListenerRegistration<? extends DOMNotificationListener>> b =
+ final Builder<Absolute, AbstractListenerRegistration<? extends DOMNotificationListener>> b =
ImmutableMultimap.builder();
b.putAll(listeners);
- for (final SchemaPath t : types) {
+ for (final Absolute t : types) {
b.put(t, reg);
}
* @param newListeners is used to notify listenerTypes changed
*/
private void replaceListeners(
- final Multimap<SchemaPath, AbstractListenerRegistration<? extends DOMNotificationListener>> newListeners) {
+ final Multimap<Absolute, AbstractListenerRegistration<? extends DOMNotificationListener>> newListeners) {
listeners = newListeners;
notifyListenerTypesChanged(newListeners.keySet());
}
@SuppressWarnings("checkstyle:IllegalCatch")
- private void notifyListenerTypesChanged(final Set<SchemaPath> typesAfter) {
+ private void notifyListenerTypesChanged(final Set<Absolute> typesAfter) {
final List<? extends DOMNotificationSubscriptionListener> listenersAfter =
subscriptionListeners.streamListeners().collect(ImmutableList.toImmutableList());
executor.execute(() -> {
@Override
public <L extends DOMNotificationSubscriptionListener> ListenerRegistration<L> registerSubscriptionListener(
final L listener) {
- final Set<SchemaPath> initialTypes = listeners.keySet();
+ final Set<Absolute> initialTypes = listeners.keySet();
executor.execute(() -> listener.onSubscriptionChanged(initialTypes));
return subscriptionListeners.register(listener);
}
}
@VisibleForTesting
- Multimap<SchemaPath, ?> listeners() {
+ Multimap<Absolute, ?> listeners() {
return listeners;
}
import org.opendaylight.yangtools.concepts.AbstractRegistration;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final class Registration<T extends DOMRpcAvailabilityListener>
extends AbstractListenerRegistration<T> {
- private Map<SchemaPath, Set<YangInstanceIdentifier>> prevRpcs;
+ private Map<QName, Set<YangInstanceIdentifier>> prevRpcs;
private DOMRpcRouter router;
- Registration(final DOMRpcRouter router, final T listener,
- final Map<SchemaPath, Set<YangInstanceIdentifier>> rpcs) {
+ Registration(final DOMRpcRouter router, final T listener, final Map<QName, Set<YangInstanceIdentifier>> rpcs) {
super(listener);
this.router = requireNonNull(router);
this.prevRpcs = requireNonNull(rpcs);
void initialTable() {
final Collection<DOMRpcIdentifier> added = new ArrayList<>();
- for (Entry<SchemaPath, Set<YangInstanceIdentifier>> e : prevRpcs.entrySet()) {
+ for (Entry<QName, Set<YangInstanceIdentifier>> e : prevRpcs.entrySet()) {
added.addAll(Collections2.transform(e.getValue(), i -> DOMRpcIdentifier.create(e.getKey(), i)));
}
if (!added.isEmpty()) {
return;
}
- final Map<SchemaPath, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(l));
- final MapDifference<SchemaPath, Set<YangInstanceIdentifier>> diff = Maps.difference(prevRpcs, rpcs);
+ final Map<QName, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(l));
+ final MapDifference<QName, Set<YangInstanceIdentifier>> diff = Maps.difference(prevRpcs, rpcs);
final Collection<DOMRpcIdentifier> added = new ArrayList<>();
- for (Entry<SchemaPath, Set<YangInstanceIdentifier>> e : diff.entriesOnlyOnRight().entrySet()) {
+ for (Entry<QName, Set<YangInstanceIdentifier>> e : diff.entriesOnlyOnRight().entrySet()) {
added.addAll(Collections2.transform(e.getValue(), i -> DOMRpcIdentifier.create(e.getKey(), i)));
}
- for (Entry<SchemaPath, ValueDifference<Set<YangInstanceIdentifier>>> e :
- diff.entriesDiffering().entrySet()) {
+ for (Entry<QName, ValueDifference<Set<YangInstanceIdentifier>>> e : diff.entriesDiffering().entrySet()) {
for (YangInstanceIdentifier i : Sets.difference(e.getValue().rightValue(), e.getValue().leftValue())) {
added.add(DOMRpcIdentifier.create(e.getKey(), i));
}
return;
}
- final Map<SchemaPath, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(l));
- final MapDifference<SchemaPath, Set<YangInstanceIdentifier>> diff = Maps.difference(prevRpcs, rpcs);
+ final Map<QName, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(l));
+ final MapDifference<QName, Set<YangInstanceIdentifier>> diff = Maps.difference(prevRpcs, rpcs);
final Collection<DOMRpcIdentifier> removed = new ArrayList<>();
- for (Entry<SchemaPath, Set<YangInstanceIdentifier>> e : diff.entriesOnlyOnLeft().entrySet()) {
+ for (Entry<QName, Set<YangInstanceIdentifier>> e : diff.entriesOnlyOnLeft().entrySet()) {
removed.addAll(Collections2.transform(e.getValue(), i -> DOMRpcIdentifier.create(e.getKey(), i)));
}
- for (Entry<SchemaPath, ValueDifference<Set<YangInstanceIdentifier>>> e :
- diff.entriesDiffering().entrySet()) {
+ for (Entry<QName, ValueDifference<Set<YangInstanceIdentifier>>> e : diff.entriesDiffering().entrySet()) {
for (YangInstanceIdentifier i : Sets.difference(e.getValue().leftValue(), e.getValue().rightValue())) {
removed.add(DOMRpcIdentifier.create(e.getKey(), i));
}
private static final class ActionRegistration<T extends AvailabilityListener>
extends AbstractListenerRegistration<T> {
- private Map<SchemaPath, Set<DOMDataTreeIdentifier>> prevActions;
+ private Map<Absolute, Set<DOMDataTreeIdentifier>> prevActions;
private DOMRpcRouter router;
ActionRegistration(final DOMRpcRouter router, final T listener,
- final Map<SchemaPath, Set<DOMDataTreeIdentifier>> actions) {
+ final Map<Absolute, Set<DOMDataTreeIdentifier>> actions) {
super(listener);
this.router = requireNonNull(router);
this.prevActions = requireNonNull(actions);
void initialTable() {
final Collection<DOMActionInstance> added = new ArrayList<>();
- for (Entry<SchemaPath, Set<DOMDataTreeIdentifier>> e : prevActions.entrySet()) {
+ for (Entry<Absolute, Set<DOMDataTreeIdentifier>> e : prevActions.entrySet()) {
added.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
}
if (!added.isEmpty()) {
return;
}
- final Map<SchemaPath, Set<DOMDataTreeIdentifier>> actions = verifyNotNull(newTable.getOperations(l));
- final MapDifference<SchemaPath, Set<DOMDataTreeIdentifier>> diff = Maps.difference(prevActions, actions);
+ final Map<Absolute, Set<DOMDataTreeIdentifier>> actions = verifyNotNull(newTable.getOperations(l));
+ final MapDifference<Absolute, Set<DOMDataTreeIdentifier>> diff = Maps.difference(prevActions, actions);
final Set<DOMActionInstance> removed = new HashSet<>();
final Set<DOMActionInstance> added = new HashSet<>();
- for (Entry<SchemaPath, Set<DOMDataTreeIdentifier>> e : diff.entriesOnlyOnLeft().entrySet()) {
+ for (Entry<Absolute, Set<DOMDataTreeIdentifier>> e : diff.entriesOnlyOnLeft().entrySet()) {
removed.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
}
- for (Entry<SchemaPath, Set<DOMDataTreeIdentifier>> e : diff.entriesOnlyOnRight().entrySet()) {
+ for (Entry<Absolute, Set<DOMDataTreeIdentifier>> e : diff.entriesOnlyOnRight().entrySet()) {
added.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
}
- for (Entry<SchemaPath, ValueDifference<Set<DOMDataTreeIdentifier>>> e :
- diff.entriesDiffering().entrySet()) {
+ for (Entry<Absolute, ValueDifference<Set<DOMDataTreeIdentifier>>> e : diff.entriesDiffering().entrySet()) {
for (DOMDataTreeIdentifier i : Sets.difference(e.getValue().leftValue(), e.getValue().rightValue())) {
removed.add(DOMActionInstance.of(e.getKey(), i));
}
}
@Override
- public ListenableFuture<? extends DOMActionResult> invokeAction(final SchemaPath type,
+ public ListenableFuture<? extends DOMActionResult> invokeAction(final Absolute type,
final DOMDataTreeIdentifier path, final ContainerNode input) {
final DOMActionRoutingTableEntry entry = (DOMActionRoutingTableEntry) actionRoutingTable.getEntry(type);
if (entry == null) {
private final class RpcServiceFacade implements DOMRpcService {
@Override
- public ListenableFuture<? extends DOMRpcResult> invokeRpc(final SchemaPath type,
- final NormalizedNode<?, ?> input) {
+ public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final NormalizedNode<?, ?> input) {
final AbstractDOMRpcRoutingTableEntry entry = (AbstractDOMRpcRoutingTableEntry) routingTable.getEntry(type);
if (entry == null) {
return Futures.immediateFailedFuture(
private static final Logger LOG = LoggerFactory.getLogger(OperationInvocation.class);
static ListenableFuture<? extends DOMActionResult> invoke(final DOMActionRoutingTableEntry entry,
- final SchemaPath type, final DOMDataTreeIdentifier path, final ContainerNode input) {
+ final Absolute type, final DOMDataTreeIdentifier path, final ContainerNode input) {
return entry.getImplementations(path).get(0).invokeAction(type, path, input);
}
final NormalizedNode<?, ?> input) {
if (entry instanceof UnknownDOMRpcRoutingTableEntry) {
return Futures.immediateFailedFuture(
- new DOMRpcImplementationNotAvailableException("SchemaPath %s is not resolved to an RPC",
- entry.getType()));
+ new DOMRpcImplementationNotAvailableException("%s is not resolved to an RPC", entry.getType()));
} else if (entry instanceof RoutedDOMRpcRoutingTableEntry) {
return invokeRoutedRpc((RoutedDOMRpcRoutingTableEntry) entry, input);
} else if (entry instanceof GlobalDOMRpcRoutingTableEntry) {
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
final class DOMRpcRoutingTable extends AbstractDOMRoutingTable<DOMRpcIdentifier, YangInstanceIdentifier,
- DOMRpcImplementation, DOMRpcAvailabilityListener, AbstractDOMRpcRoutingTableEntry> {
+ DOMRpcImplementation, DOMRpcAvailabilityListener, QName, AbstractDOMRpcRoutingTableEntry> {
static final DOMRpcRoutingTable EMPTY = new DOMRpcRoutingTable(ImmutableMap.of(), null);
- private DOMRpcRoutingTable(final Map<SchemaPath, AbstractDOMRpcRoutingTableEntry> rpcs,
+ private DOMRpcRoutingTable(final Map<QName, AbstractDOMRpcRoutingTableEntry> rpcs,
final EffectiveModelContext schemaContext) {
super(rpcs, schemaContext);
}
}
@Override
- protected DOMRpcRoutingTable newInstance(final Map<SchemaPath, AbstractDOMRpcRoutingTableEntry> operations,
+ protected DOMRpcRoutingTable newInstance(final Map<QName, AbstractDOMRpcRoutingTableEntry> operations,
final EffectiveModelContext schemaContext) {
return new DOMRpcRoutingTable(operations, schemaContext);
}
@Override
- protected ListMultimap<SchemaPath, YangInstanceIdentifier> decomposeIdentifiers(
- final Set<DOMRpcIdentifier> rpcs) {
- final ListMultimap<SchemaPath, YangInstanceIdentifier> ret = LinkedListMultimap.create();
+ protected ListMultimap<QName, YangInstanceIdentifier> decomposeIdentifiers(final Set<DOMRpcIdentifier> rpcs) {
+ final ListMultimap<QName, YangInstanceIdentifier> ret = LinkedListMultimap.create();
for (DOMRpcIdentifier i : rpcs) {
ret.put(i.getType(), i.getContextReference());
}
}
@Override
- AbstractDOMRpcRoutingTableEntry createOperationEntry(final EffectiveModelContext context, final SchemaPath key,
+ AbstractDOMRpcRoutingTableEntry createOperationEntry(final EffectiveModelContext context, final QName key,
final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> implementations) {
final RpcDefinition rpcDef = findRpcDefinition(context, key);
if (rpcDef == null) {
return new GlobalDOMRpcRoutingTableEntry(rpcDef, implementations);
}
- private static RpcDefinition findRpcDefinition(final SchemaContext context, final SchemaPath schemaPath) {
+ private static RpcDefinition findRpcDefinition(final SchemaContext context, final QName qname) {
if (context != null) {
- final QName qname = schemaPath.getPathFromRoot().iterator().next();
final Module module = context.findModule(qname.getModule()).orElse(null);
if (module != null && module.getRpcs() != null) {
for (RpcDefinition rpc : module.getRpcs()) {
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
final class GlobalDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry {
-
- private GlobalDOMRpcRoutingTableEntry(final DOMRpcIdentifier rpcId, final Map<YangInstanceIdentifier,
- List<DOMRpcImplementation>> impls) {
+ private GlobalDOMRpcRoutingTableEntry(final DOMRpcIdentifier rpcId,
+ final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> impls) {
super(rpcId, impls);
}
// forward something we don't know to be an RPC.
GlobalDOMRpcRoutingTableEntry(final RpcDefinition def, final Map<YangInstanceIdentifier,
List<DOMRpcImplementation>> impls) {
- super(DOMRpcIdentifier.create(def.getPath()), impls);
+ super(DOMRpcIdentifier.create(def.getQName()), impls);
}
@Override
import org.opendaylight.mdsal.dom.spi.DOMNotificationSubscriptionListener;
import org.opendaylight.mdsal.dom.spi.DOMNotificationSubscriptionListenerRegistry;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
@Override
public <T extends DOMNotificationListener> ListenerRegistration<T> registerNotificationListener(final T listener,
- final Collection<SchemaPath> types) {
+ final Collection<Absolute> types) {
return router.registerNotificationListener(listener, types);
}
}
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
final class RoutedDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry {
-
private RoutedDOMRpcRoutingTableEntry(final DOMRpcIdentifier routedRpcId,
final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> impls) {
super(routedRpcId, impls);
RoutedDOMRpcRoutingTableEntry(final RpcDefinition def, final YangInstanceIdentifier keyId,
final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> impls) {
- super(DOMRpcIdentifier.create(def.getPath(), keyId), impls);
+ super(DOMRpcIdentifier.create(def.getQName(), keyId), impls);
}
@Override
import java.util.Map;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
final class UnknownDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry {
- UnknownDOMRpcRoutingTableEntry(final SchemaPath schemaPath, final Map<YangInstanceIdentifier,
- List<DOMRpcImplementation>> impls) {
- super(DOMRpcIdentifier.create(schemaPath), impls);
+ UnknownDOMRpcRoutingTableEntry(final QName type,
+ final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> impls) {
+ super(DOMRpcIdentifier.create(type), impls);
}
@Override
- protected UnknownDOMRpcRoutingTableEntry newInstance(final Map<YangInstanceIdentifier,
- List<DOMRpcImplementation>> impls) {
+ protected UnknownDOMRpcRoutingTableEntry newInstance(
+ final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> impls) {
return new UnknownDOMRpcRoutingTableEntry(getType(), impls);
}
}
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.mdsal.dom.api.DOMNotificationPublishService;
+import org.opendaylight.mdsal.dom.broker.util.TestModel;
import org.opendaylight.mdsal.dom.spi.DOMNotificationSubscriptionListener;
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.util.ListenerRegistry;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
public class DOMNotificationRouterTest extends TestUtils {
final DOMNotificationListener domNotificationListener = new TestListener(latch);
final DOMNotificationRouter domNotificationRouter = DOMNotificationRouter.create(1);
- Multimap<SchemaPath, ?> listeners = domNotificationRouter.listeners();
+ Multimap<Absolute, ?> listeners = domNotificationRouter.listeners();
assertTrue(listeners.isEmpty());
- assertNotNull(domNotificationRouter.registerNotificationListener(domNotificationListener, SchemaPath.ROOT));
- assertNotNull(domNotificationRouter.registerNotificationListener(domNotificationListener, SchemaPath.SAME));
+ assertNotNull(domNotificationRouter.registerNotificationListener(domNotificationListener,
+ Absolute.of(TestModel.TEST_QNAME)));
+ assertNotNull(domNotificationRouter.registerNotificationListener(domNotificationListener,
+ Absolute.of(TestModel.TEST2_QNAME)));
listeners = domNotificationRouter.listeners();
final DOMNotification domNotification = mock(DOMNotification.class);
doReturn("test").when(domNotification).toString();
- doReturn(SchemaPath.ROOT).when(domNotification).getType();
+ doReturn(Absolute.of(TestModel.TEST_QNAME)).when(domNotification).getType();
doReturn(TEST_CHILD).when(domNotification).getBody();
assertNotNull(domNotificationRouter.offerNotification(domNotification));
assertNotNull(domNotificationRouter.offerNotification(domNotification, 1, TimeUnit.SECONDS));
assertNotNull(domNotificationRouter.offerNotification(domNotification, 1, TimeUnit.SECONDS));
} catch (Exception e) {
+ // FIXME: what is the point here?!
assertTrue(e instanceof UnsupportedOperationException);
}
public void offerNotification() throws Exception {
final DOMNotificationRouter domNotificationRouter = DOMNotificationRouter.create(1);
final DOMNotification domNotification = mock(DOMNotification.class);
- doReturn(SchemaPath.ROOT).when(domNotification).getType();
+ doReturn(Absolute.of(TestModel.TEST_QNAME)).when(domNotification).getType();
doReturn(TEST_CHILD).when(domNotification).getBody();
assertNotNull(domNotificationRouter.putNotification(domNotification));
assertNotNull(domNotificationRouter.offerNotification(domNotification));
final TestListener testListener = new TestListener(latch);
final DOMNotification domNotification = mock(DOMNotification.class);
doReturn("test").when(domNotification).toString();
- doReturn(SchemaPath.ROOT).when(domNotification).getType();
+ doReturn(Absolute.of(TestModel.TEST_QNAME)).when(domNotification).getType();
doReturn(TEST_CHILD).when(domNotification).getBody();
try (TestRouter testRouter = new TestRouter(1)) {
- assertNotNull(testRouter.registerNotificationListener(testListener, SchemaPath.ROOT));
- assertNotNull(testRouter.registerNotificationListener(testListener, SchemaPath.SAME));
+ assertNotNull(testRouter.registerNotificationListener(testListener, Absolute.of(TestModel.TEST_QNAME)));
+ assertNotNull(testRouter.registerNotificationListener(testListener, Absolute.of(TestModel.TEST2_QNAME)));
assertNotEquals(DOMNotificationPublishService.REJECTED,
testRouter.offerNotification(domNotification, 3, TimeUnit.SECONDS));
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import org.junit.Test;
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
+import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
import org.opendaylight.mdsal.dom.broker.util.TestModel;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class DOMRpcRouterTest extends TestUtils {
public void registerRpcImplementation() {
try (DOMRpcRouter rpcRouter = new DOMRpcRouter()) {
DOMRpcRoutingTable routingTable = rpcRouter.routingTable();
- assertFalse(routingTable.getOperations().containsKey(SchemaPath.ROOT));
+ assertFalse(routingTable.getOperations().containsKey(TestModel.TEST_QNAME));
rpcRouter.getRpcProviderService().registerRpcImplementation(getTestRpcImplementation(),
- DOMRpcIdentifier.create(SchemaPath.ROOT, null));
+ DOMRpcIdentifier.create(TestModel.TEST_QNAME, null));
routingTable = rpcRouter.routingTable();
- assertTrue(routingTable.getOperations().containsKey(SchemaPath.ROOT));
+ assertTrue(routingTable.getOperations().containsKey(TestModel.TEST_QNAME));
rpcRouter.getRpcProviderService().registerRpcImplementation(getTestRpcImplementation(),
- DOMRpcIdentifier.create(SchemaPath.SAME, null));
+ DOMRpcIdentifier.create(TestModel.TEST2_QNAME, null));
routingTable = rpcRouter.routingTable();
- assertTrue(routingTable.getOperations().containsKey(SchemaPath.SAME));
+ assertTrue(routingTable.getOperations().containsKey(TestModel.TEST2_QNAME));
}
}
@Test
public void invokeRpc() {
try (DOMRpcRouter rpcRouter = new DOMRpcRouter()) {
- assertNotNull(rpcRouter.getRpcService().invokeRpc(SchemaPath.create(false, TestModel.TEST_QNAME), null));
+ assertNotNull(rpcRouter.getRpcService().invokeRpc(TestModel.TEST_QNAME, null));
}
}
}
}
- @Test(expected = RejectedExecutionException.class)
+ @Test
public void close() {
final DOMRpcRouter rpcRouter = new DOMRpcRouter();
rpcRouter.close();
- rpcRouter.getRpcProviderService().registerRpcImplementation(getTestRpcImplementation(),
- DOMRpcIdentifier.create(SchemaPath.ROOT, null));
+
+ final DOMRpcProviderService svc = rpcRouter.getRpcProviderService();
+ assertThrows(RejectedExecutionException.class, () -> svc.registerRpcImplementation(getTestRpcImplementation(),
+ DOMRpcIdentifier.create(TestModel.TEST_QNAME, null)));
}
}
*/
package org.opendaylight.mdsal.dom.broker;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
import org.junit.Test;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
import org.opendaylight.mdsal.dom.broker.DOMRpcRouter.OperationInvocation;
+import org.opendaylight.mdsal.dom.broker.util.TestModel;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class GlobalDOMRpcRoutingTableEntryTest extends TestUtils {
-
@Test
- public void basicTest() throws InterruptedException, TimeoutException {
+ public void basicTest() {
final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> rpcImplementations = new HashMap<>();
final List<DOMRpcImplementation> rpcImplementation = new ArrayList<>();
final RpcDefinition rpcDefinition = mock(RpcDefinition.class);
final YangInstanceIdentifier yangInstanceIdentifier = YangInstanceIdentifier.builder().build();
- doReturn(SchemaPath.ROOT).when(rpcDefinition).getPath();
+ doReturn(TestModel.TEST2_QNAME).when(rpcDefinition).getQName();
final GlobalDOMRpcRoutingTableEntry globalDOMRpcRoutingTableEntry = new GlobalDOMRpcRoutingTableEntry(
rpcDefinition, new HashMap<>());
rpcImplementation.add(getTestRpcImplementation());
rpcImplementations.put(yangInstanceIdentifier, rpcImplementation);
- assertTrue(globalDOMRpcRoutingTableEntry.getType().equals(SchemaPath.ROOT));
+ assertEquals(TestModel.TEST2_QNAME, globalDOMRpcRoutingTableEntry.getType());
assertTrue(globalDOMRpcRoutingTableEntry.getImplementations().isEmpty());
assertFalse(globalDOMRpcRoutingTableEntry.newInstance(rpcImplementations).getImplementations().isEmpty());
assertTrue(globalDOMRpcRoutingTableEntry.newInstance(rpcImplementations).getImplementations().containsValue(
rpcImplementation));
- try {
- OperationInvocation.invoke(globalDOMRpcRoutingTableEntry.newInstance(rpcImplementations),
- TEST_CONTAINER).get(5, TimeUnit.SECONDS);
- fail("Expected DOMRpcImplementationNotAvailableException");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof DOMRpcImplementationNotAvailableException);
- assertTrue(e.getCause().getMessage().contains(EXCEPTION_TEXT));
- }
+ final ListenableFuture<?> future = OperationInvocation.invoke(
+ globalDOMRpcRoutingTableEntry.newInstance(rpcImplementations), TEST_CONTAINER);
+
+ final ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get(5, TimeUnit.SECONDS));
+ final Throwable cause = ex.getCause();
+ assertThat(cause, instanceOf(DOMRpcImplementationNotAvailableException.class));
+ assertThat(cause.getMessage(), containsString(EXCEPTION_TEXT));
}
}
*/
package org.opendaylight.mdsal.dom.broker;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.assertThrows;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.HashMap;
import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeoutException;
+import java.util.concurrent.TimeUnit;
import org.junit.Test;
import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
import org.opendaylight.mdsal.dom.broker.DOMRpcRouter.OperationInvocation;
import org.opendaylight.mdsal.dom.broker.util.TestModel;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class RoutedDOMRpcRoutingTableEntryTest extends TestUtils {
-
- @SuppressWarnings("checkstyle:IllegalCatch")
@Test
- public void basicTest() throws InterruptedException, TimeoutException {
+ public void basicTest() {
final RpcDefinition rpcDefinition = mock(RpcDefinition.class);
- doReturn(SchemaPath.ROOT).when(rpcDefinition).getPath();
+ doReturn(TestModel.TEST2_QNAME).when(rpcDefinition).getQName();
final RoutedDOMRpcRoutingTableEntry routedDOMRpcRoutingTableEntry =
new RoutedDOMRpcRoutingTableEntry(rpcDefinition, TestModel.TEST_PATH, new HashMap<>());
assertNotNull(routedDOMRpcRoutingTableEntry.newInstance(new HashMap<>()));
- try {
- OperationInvocation.invoke(routedDOMRpcRoutingTableEntry, TEST_CHILD).get();
- fail("Expected DOMRpcImplementationNotAvailableException");
- } catch (ExecutionException e) {
- assertTrue(e.getCause() instanceof DOMRpcImplementationNotAvailableException);
- }
+ final ListenableFuture<?> future = OperationInvocation.invoke(routedDOMRpcRoutingTableEntry, TEST_CHILD);
+ final ExecutionException ex = assertThrows(ExecutionException.class, () -> future.get(5, TimeUnit.SECONDS));
+ assertThat(ex.getCause(), instanceOf(DOMRpcImplementationNotAvailableException.class));
}
}
import org.opendaylight.mdsal.dom.broker.DOMRpcRouter.OperationInvocation;
import org.opendaylight.mdsal.dom.broker.util.TestModel;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class UnknownDOMRpcRoutingTableEntryTest extends TestUtils {
private static final List<DOMRpcImplementation> TEST_LIST = new ArrayList<>();
final List<YangInstanceIdentifier> addList1 = new ArrayList<>();
final List<YangInstanceIdentifier> addList2 = new ArrayList<>();
final DOMRpcImplementation testClass = getTestRpcImplementation();
- final UnknownDOMRpcRoutingTableEntry test = new UnknownDOMRpcRoutingTableEntry(SchemaPath.ROOT, emptyImpls);
+ final UnknownDOMRpcRoutingTableEntry test =
+ new UnknownDOMRpcRoutingTableEntry(TestModel.TEST_QNAME, emptyImpls);
TEST_LIST.add(testClass);
emptyImpls.put(YangInstanceIdentifier.empty(), TEST_LIST);
import com.google.common.annotations.Beta;
import java.util.EventListener;
import java.util.Set;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
- * Listener which is notified when subscriptions changes and
- * provides set of notification types for which currently
+ * Listener which is notified when subscriptions changes and provides set of notification types for which currently
* subscriptions are in place.
*/
@Beta
public interface DOMNotificationSubscriptionListener extends EventListener {
-
/**
* Invoked when notification subscription changed.
*
* @param currentTypes Set of notification types for which listeners are registered.
*/
- void onSubscriptionChanged(Set<SchemaPath> currentTypes);
+ void onSubscriptionChanged(Set<Absolute> currentTypes);
}
import org.opendaylight.mdsal.dom.api.DOMActionServiceExtension;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
@Beta
public abstract class ForwardingDOMActionService extends ForwardingObject implements DOMActionService {
}
@Override
- public ListenableFuture<? extends DOMActionResult> invokeAction(final SchemaPath type,
+ public ListenableFuture<? extends DOMActionResult> invokeAction(final Absolute type,
final DOMDataTreeIdentifier path, final ContainerNode input) {
return delegate().invokeAction(type, path, input);
}
import org.opendaylight.mdsal.dom.api.DOMNotificationListener;
import org.opendaylight.mdsal.dom.api.DOMNotificationService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
/**
* Utility implementation of a {@link DOMNotificationService} which forwards all requests
@Override
public <T extends DOMNotificationListener> ListenerRegistration<T> registerNotificationListener(final T listener,
- final Collection<SchemaPath> types) {
+ final Collection<Absolute> types) {
return delegate().registerNotificationListener(listener, types);
}
@Override
public <T extends DOMNotificationListener> ListenerRegistration<T> registerNotificationListener(final T listener,
- final SchemaPath... types) {
+ final Absolute... types) {
return delegate().registerNotificationListener(listener, types);
}
}
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
/**
* Utility {@link DOMRpcService} which forwards all requests to a backing delegate instance.
protected abstract @NonNull DOMRpcService delegate();
@Override
- public ListenableFuture<? extends DOMRpcResult> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
+ public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final NormalizedNode<?, ?> input) {
return delegate().invokeRpc(type, input);
}
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import static org.mockito.MockitoAnnotations.initMocks;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class ForwardingDOMRpcServiceTest extends ForwardingDOMRpcService {
-
@Mock(name = "domRpcService")
private DOMRpcService domRpcService;
@Test
public void basicTest() throws Exception {
- initMocks(this);
-
final DOMRpcAvailabilityListener domRpcAvailabilityListener = mock(DOMRpcAvailabilityListener.class);
+ final QName id = QName.create("urn:foo", "foo");
- doReturn(null).when(domRpcService).invokeRpc(SchemaPath.SAME, null);
- this.invokeRpc(SchemaPath.SAME, null);
- verify(domRpcService).invokeRpc(SchemaPath.SAME, null);
+ doReturn(null).when(domRpcService).invokeRpc(id, null);
+ this.invokeRpc(id, null);
+ verify(domRpcService).invokeRpc(id, null);
doReturn(null).when(domRpcService).registerRpcListener(domRpcAvailabilityListener);
this.registerRpcListener(domRpcAvailabilityListener);
Code Review / mdsal.git / commitdiff