import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.VerifyException;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Maps;
-import com.google.common.util.concurrent.ListenableFuture;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
-import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
import org.opendaylight.mdsal.binding.dom.codec.spi.BindingDOMCodecServices;
import org.opendaylight.mdsal.binding.dom.codec.spi.ForwardingBindingDOMCodecServices;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.runtime.api.ActionRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.InputRuntimeType;
-import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
-import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
+import org.opendaylight.mdsal.binding.runtime.api.NotificationRuntimeType;
+import org.opendaylight.mdsal.binding.runtime.api.RuntimeType;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
+import org.opendaylight.yangtools.yang.binding.BindingContract;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.RpcInput;
-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.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.ActionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
+import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@VisibleForTesting
public final class CurrentAdapterSerializer extends ForwardingBindingDOMCodecServices {
private static final Logger LOG = LoggerFactory.getLogger(CurrentAdapterSerializer.class);
- @Deprecated
- private static final MethodType RPC_SERVICE_METHOD_SIGNATURE = MethodType.methodType(ListenableFuture.class,
- RpcService.class, RpcInput.class);
private final LoadingCache<InstanceIdentifier<?>, YangInstanceIdentifier> cache = CacheBuilder.newBuilder()
.softValues().build(new CacheLoader<InstanceIdentifier<?>, YangInstanceIdentifier>() {
});
private final ConcurrentMap<JavaTypeName, ContextReferenceExtractor> extractors = new ConcurrentHashMap<>();
- @Deprecated
- private final ConcurrentMap<Class<? extends RpcService>, ImmutableMap<QName, MethodHandle>> rpcMethods =
- new ConcurrentHashMap<>();
private final @NonNull BindingDOMCodecServices delegate;
public CurrentAdapterSerializer(final BindingDOMCodecServices delegate) {
}
DOMDataTreeIdentifier toDOMDataTreeIdentifier(final DataTreeIdentifier<?> path) {
- return new DOMDataTreeIdentifier(path.getDatastoreType(), toYangInstanceIdentifier(path.getRootIdentifier()));
+ return DOMDataTreeIdentifier.of(path.datastore(), toYangInstanceIdentifier(path.path()));
}
Collection<DOMDataTreeIdentifier> toDOMDataTreeIdentifiers(final Collection<DataTreeIdentifier<?>> subtrees) {
}
@NonNull Absolute getActionPath(final @NonNull ActionSpec<?, ?> spec) {
- final var entry = resolvePath(spec.path());
- final var stack = entry.getKey();
- final var stmt = stack.enterSchemaTree(BindingReflections.findQName(spec.type()).bindTo(entry.getValue()));
- verify(stmt instanceof ActionEffectiveStatement, "Action %s resolved to unexpected statement %s", spec, stmt);
- return stack.toSchemaNodeIdentifier();
+ return getSchemaNodeIdentifier(spec.path(), spec.type(), ActionRuntimeType.class,
+ ActionEffectiveStatement.class);
}
@NonNull Absolute getNotificationPath(final @NonNull InstanceNotificationSpec<?, ?> spec) {
- final var entry = resolvePath(spec.path());
+ return getSchemaNodeIdentifier(spec.path(), spec.type(), NotificationRuntimeType.class,
+ NotificationEffectiveStatement.class);
+ }
+
+ private <T extends RuntimeType> @NonNull Absolute getSchemaNodeIdentifier(final @NonNull InstanceIdentifier<?> path,
+ final @NonNull Class<? extends BindingContract<?>> type, final @NonNull Class<T> expectedRuntime,
+ final @NonNull Class<? extends SchemaTreeEffectiveStatement<?>> expectedStatement) {
+ final var typeName = JavaTypeName.create(type);
+ final var runtimeType = getRuntimeContext().getTypes().findSchema(typeName)
+ .orElseThrow(() -> new IllegalArgumentException(typeName + " is not known"));
+ final T casted;
+ try {
+ casted = expectedRuntime.cast(runtimeType);
+ } catch (ClassCastException e) {
+ throw new IllegalArgumentException(typeName + " resolved to unexpected " + runtimeType, e);
+ }
+ final var qname = expectedStatement.cast(casted.statement()).argument();
+
+ final var entry = resolvePath(path);
final var stack = entry.getKey();
- final var stmt = stack.enterSchemaTree(BindingReflections.findQName(spec.type()).bindTo(entry.getValue()));
- verify(stmt instanceof NotificationEffectiveStatement, "Notification %s resolved to unexpected statement %s",
- spec, stmt);
- return stack.toSchemaNodeIdentifier();
+ final var stmt = stack.enterSchemaTree(qname.bindTo(entry.getValue()));
+ if (expectedStatement.isInstance(stmt)) {
+ return stack.toSchemaNodeIdentifier();
+ }
+ throw new VerifyException(path + " child " + typeName + " resolved to unexpected statement" + stmt);
}
@Nullable ContextReferenceExtractor findExtractor(final @NonNull InputRuntimeType inputType) {
return raced != null ? raced : created;
}
- @Deprecated
- @NonNull ImmutableMap<QName, MethodHandle> getRpcMethods(final @NonNull Class<? extends RpcService> serviceType) {
- return rpcMethods.computeIfAbsent(serviceType, ignored -> {
- final var lookup = MethodHandles.publicLookup();
- return ImmutableMap.copyOf(Maps.transformValues(createQNameToMethod(serviceType), method -> {
- final MethodHandle raw;
- try {
- raw = lookup.unreflect(method);
- } catch (IllegalAccessException e) {
- throw new IllegalStateException("Lookup on public method failed", e);
- }
- return raw.asType(RPC_SERVICE_METHOD_SIGNATURE);
- }));
- });
- }
-
- @Deprecated
- @VisibleForTesting
- // FIXME: This should be probably part of Binding Runtime context
- ImmutableMap<QName, Method> createQNameToMethod(final Class<? extends RpcService> key) {
- final var moduleName = BindingReflections.getQNameModule(key);
- final var runtimeContext = getRuntimeContext();
- final var module = runtimeContext.getEffectiveModelContext().findModule(moduleName).orElse(null);
- if (module == null) {
- LOG.trace("Schema for {} is not available; expected module name: {}; BindingRuntimeContext: {}",
- key, moduleName, runtimeContext);
- throw new IllegalStateException(String.format("Schema for %s is not available; expected module name: %s;"
- + " full BindingRuntimeContext available in trace log", key, moduleName));
- }
-
- final var ret = ImmutableBiMap.<QName, Method>builder();
- try {
- for (var rpcDef : module.getRpcs()) {
- final var rpcName = rpcDef.getQName();
- ret.put(rpcName, key.getMethod(BindingMapping.getRpcMethodName(rpcName),
- runtimeContext.getRpcInput(rpcName)));
- }
- } catch (NoSuchMethodException e) {
- throw new IllegalStateException("Rpc defined in model does not have representation in generated class.", e);
- }
- return ret.build();
- }
-
private @NonNull Entry<SchemaInferenceStack, QNameModule> resolvePath(final @NonNull InstanceIdentifier<?> path) {
final var stack = SchemaInferenceStack.of(getRuntimeContext().getEffectiveModelContext());
final var it = toYangInstanceIdentifier(path).getPathArguments().iterator();
QNameModule lastNamespace;
do {
final var arg = it.next();
- if (arg instanceof AugmentationIdentifier) {
- final var augChildren = ((AugmentationIdentifier) arg).getPossibleChildNames();
- verify(!augChildren.isEmpty(), "Invalid empty augmentation %s", arg);
- lastNamespace = augChildren.iterator().next().getModule();
- continue;
- }
-
final var qname = arg.getNodeType();
final var stmt = stack.enterDataTree(qname);
lastNamespace = qname.getModule();
Code Review / mdsal.git / blobdiff