import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceSalProvider;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.messages.CreateInitialMasterActorData;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
}
@Override
- public void onDeviceConnected(final SchemaContext remoteSchemaContext,
+ public void onDeviceConnected(final MountPointContext mountContext,
final NetconfSessionPreferences sessionPreferences,
final DOMRpcService domRpcService, final DOMActionService domActionService) {
this.deviceAction = domActionService;
LOG.debug("{}: YANG 1.1 actions are supported in clustered netconf topology, "
+ "DOMActionService exposed for the device", id);
- onDeviceConnected(remoteSchemaContext, sessionPreferences, domRpcService);
+ onDeviceConnected(mountContext, sessionPreferences, domRpcService);
}
@Override
- public void onDeviceConnected(final SchemaContext remoteSchemaContext,
+ public void onDeviceConnected(final MountPointContext mountContext,
final NetconfSessionPreferences sessionPreferences,
final DOMRpcService domRpcService) {
- this.currentSchemaContext = remoteSchemaContext;
+ this.currentSchemaContext = mountContext.getSchemaContext();
this.netconfSessionPreferences = sessionPreferences;
this.deviceRpc = domRpcService;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
final MasterSalFacade masterSalFacade = masterSalFacadeFuture.get(5, TimeUnit.SECONDS);
- masterSalFacade.onDeviceConnected(deviceSchemaContext,
+ masterSalFacade.onDeviceConnected(new EmptyMountPointContext(deviceSchemaContext),
NetconfSessionPreferences.fromStrings(Collections.emptyList()), deviceRpcService.getRpcService());
DOMMountPoint masterMountPoint = awaitMountPoint(masterMountPointService);
MasterSalFacade masterSalFacade = masterSalFacadeFuture.get(5, TimeUnit.SECONDS);
- masterSalFacade.onDeviceConnected(deviceSchemaContext,
+ masterSalFacade.onDeviceConnected(new EmptyMountPointContext(deviceSchemaContext),
NetconfSessionPreferences.fromStrings(Collections.emptyList()), deviceRpcService.getRpcService());
verify(masterMountPointListener, timeout(5000)).onMountPointCreated(yangNodeInstanceId);
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
public interface RemoteDeviceHandler<PREF> extends AutoCloseable {
* @param netconfSessionPreferences - session of device
* @param deviceRpc - {@link DOMRpcService} of device
*/
- default void onDeviceConnected(final SchemaContext remoteSchemaContext, final PREF netconfSessionPreferences,
+ default void onDeviceConnected(final MountPointContext remoteSchemaContext, final PREF netconfSessionPreferences,
final DOMRpcService deviceRpc) {
// DO NOTHING
}
/**
* When device connected, init new mount point with specific schema context and DOM services.
*
- * @param remoteSchemaContext - schema context of connected device
+ * @param mountContext - MountPointContext of connected device
* @param netconfSessionPreferences - session of device
* @param deviceRpc - {@link DOMRpcService} of device
* @param deviceAction - {@link DOMActionService} of device
*/
- default void onDeviceConnected(final SchemaContext remoteSchemaContext, final PREF netconfSessionPreferences,
+ default void onDeviceConnected(final MountPointContext mountContext, final PREF netconfSessionPreferences,
final DOMRpcService deviceRpc, final DOMActionService deviceAction) {
// DO NOTHING
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapabilityBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.unavailable.capabilities.UnavailableCapability;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
final BaseSchema baseSchema = resolveBaseSchema(notificationSupport);
return new NetconfDeviceRpc(baseSchema.getSchemaContext(), listener,
- new NetconfMessageTransformer(baseSchema.getSchemaContext(), false, baseSchema));
+ new NetconfMessageTransformer(baseSchema.getMountPointContext(), false, baseSchema));
}
private static BaseSchema resolveBaseSchema(final boolean notificationSupport) {
return remoteSessionCapabilities.isNotificationsSupported() && reconnectOnSchemasChange;
}
- private synchronized void handleSalInitializationSuccess(final SchemaContext result,
+ private synchronized void handleSalInitializationSuccess(final MountPointContext result,
final NetconfSessionPreferences remoteSessionCapabilities,
final DOMRpcService deviceRpc,
final RemoteDeviceCommunicator<NetconfMessage> listener) {
// salFacade.onDeviceConnected has to be called before the notification handler is initialized
this.salFacade.onDeviceConnected(result, remoteSessionCapabilities, deviceRpc,
this.deviceActionFactory == null ? null : this.deviceActionFactory.createDeviceAction(
- this.messageTransformer, listener, result));
+ this.messageTransformer, listener, result.getSchemaContext()));
this.notificationHandler.onRemoteSchemaUp(this.messageTransformer);
LOG.info("{}: Netconf connector initialized successfully", id);
remoteSessionCapabilities.getNonModuleBasedCapsOrigin().get(entry)).build())
.collect(Collectors.toList()));
- handleSalInitializationSuccess(result, remoteSessionCapabilities, getDeviceSpecificRpc(result),
- listener);
+ final MountPointContext mountContext = new EmptyMountPointContext(result);
+ handleSalInitializationSuccess(mountContext, remoteSessionCapabilities,
+ getDeviceSpecificRpc(mountContext), listener);
return;
} catch (final ExecutionException e) {
// schemaBuilderFuture.checkedGet() throws only SchemaResolutionException
return resolutionException.getResolvedSources();
}
- protected NetconfDeviceRpc getDeviceSpecificRpc(final SchemaContext result) {
- return new NetconfDeviceRpc(result, listener, new NetconfMessageTransformer(result, true));
+ protected NetconfDeviceRpc getDeviceSpecificRpc(final MountPointContext result) {
+ return new NetconfDeviceRpc(result.getSchemaContext(), listener,
+ new NetconfMessageTransformer(result, true));
}
private Collection<SourceIdentifier> stripUnavailableSource(final Collection<SourceIdentifier> requiredSources,
public class SchemalessNetconfDevice implements
RemoteDevice<NetconfSessionPreferences, NetconfMessage, NetconfDeviceCommunicator> {
- private RemoteDeviceId id;
- private RemoteDeviceHandler<NetconfSessionPreferences> salFacade;
+ private final RemoteDeviceId id;
+ private final RemoteDeviceHandler<NetconfSessionPreferences> salFacade;
private final SchemalessMessageTransformer messageTransformer;
private final BaseRpcSchemalessTransformer rpcTransformer;
final SchemalessNetconfDeviceRpc schemalessNetconfDeviceRpc = new SchemalessNetconfDeviceRpc(id,
netconfDeviceCommunicator, rpcTransformer, messageTransformer);
- salFacade.onDeviceConnected(BaseSchema.BASE_NETCONF_CTX.getSchemaContext(),
+ salFacade.onDeviceConnected(BaseSchema.BASE_NETCONF_CTX.getMountPointContext(),
remoteSessionCapabilities, schemalessNetconfDeviceRpc);
}
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
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.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public void onDeviceConnected(final SchemaContext remoteSchemaContext,
+ public void onDeviceConnected(final MountPointContext remoteSchemaContext,
final NetconfSessionPreferences netconfSessionPreferences, final DOMRpcService deviceRpc) {
onDeviceConnected(remoteSchemaContext, netconfSessionPreferences, deviceRpc, null);
}
@Override
- public void onDeviceConnected(final SchemaContext remoteSchemaContext,
+ public void onDeviceConnected(final MountPointContext remoteSchemaContext,
final NetconfSessionPreferences netconfSessionPreferences, final DOMRpcService deviceRpc,
final DOMActionService deviceAction) {
this.currentDeviceRpc = deviceRpc;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
}
@Override
- public synchronized void onDeviceConnected(final SchemaContext schemaContext,
+ public synchronized void onDeviceConnected(final MountPointContext mountContext,
final NetconfSessionPreferences netconfSessionPreferences,
final DOMRpcService deviceRpc, final DOMActionService deviceAction) {
-
+ final SchemaContext schemaContext = mountContext.getSchemaContext();
final NetconfDeviceDataBroker netconfDeviceDataBroker =
new NetconfDeviceDataBroker(id, schemaContext, deviceRpc, netconfSessionPreferences);
registerLockListener(netconfDeviceDataBroker);
*/
package org.opendaylight.netconf.sal.connect.netconf.schema.mapping;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.CREATE_SUBSCRIPTION_RPC_QNAME;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.IETF_NETCONF_NOTIFICATIONS;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.NETCONF_URI;
import org.opendaylight.netconf.sal.connect.api.MessageTransformer;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.MessageCounter;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangConstants;
IETF_NETCONF_NOTIFICATIONS.getNamespace(),
CREATE_SUBSCRIPTION_RPC_QNAME.getNamespace());
- private final SchemaContext schemaContext;
+ private final MountPointContext mountContext;
+ private final DataSchemaContextTree contextTree;
private final BaseSchema baseSchema;
private final MessageCounter counter;
private final ImmutableMap<QName, RpcDefinition> mappedRpcs;
private final boolean strictParsing;
private final ImmutableMap<SchemaPath, ActionDefinition> actions;
- public NetconfMessageTransformer(final SchemaContext schemaContext, final boolean strictParsing) {
- this(schemaContext, strictParsing, BaseSchema.BASE_NETCONF_CTX);
+ public NetconfMessageTransformer(final MountPointContext mountContext, final boolean strictParsing) {
+ this(mountContext, strictParsing, BaseSchema.BASE_NETCONF_CTX);
}
- public NetconfMessageTransformer(final SchemaContext schemaContext, final boolean strictParsing,
+ public NetconfMessageTransformer(final MountPointContext mountContext, final boolean strictParsing,
final BaseSchema baseSchema) {
this.counter = new MessageCounter();
- this.schemaContext = schemaContext;
+ this.mountContext = requireNonNull(mountContext);
+
+ final SchemaContext schemaContext = mountContext.getSchemaContext();
+ this.contextTree = DataSchemaContextTree.from(schemaContext);
+
this.mappedRpcs = Maps.uniqueIndex(schemaContext.getOperations(), SchemaNode::getQName);
this.actions = Maps.uniqueIndex(getActions(schemaContext), ActionDefinition::getPath);
this.mappedNotifications = Multimaps.index(schemaContext.getNotifications(),
try {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
- final XmlParserStream xmlParser = XmlParserStream.create(writer, schemaContext,
+ final XmlParserStream xmlParser = XmlParserStream.create(writer, mountContext,
notificationAsContainerSchemaNode, strictParsing);
xmlParser.traverse(new DOMSource(element));
content = (ContainerNode) resultHolder.getResult();
// If the schema context for netconf device does not contain model for base netconf operations,
// use default pre build context with just the base model
// This way operations like lock/unlock are supported even if the source for base model was not provided
- final SchemaContext ctx = needToUseBaseCtx ? baseSchema.getSchemaContext() : schemaContext;
+ final SchemaContext ctx = needToUseBaseCtx ? baseSchema.getSchemaContext()
+ : mountContext.getSchemaContext();
NetconfMessageTransformUtil.writeNormalizedRpc((ContainerNode) payload, result, rpcInput, ctx);
} catch (final XMLStreamException | IOException | IllegalStateException e) {
throw new IllegalStateException("Unable to serialize " + rpcInput, e);
final ContainerSchemaNode inputDef = actionDef.getInput();
if (inputDef.getChildNodes().isEmpty()) {
- return new NetconfMessage(NetconfMessageTransformUtil.prepareDomResultForActionRequest(
- DataSchemaContextTree.from(schemaContext), domDataTreeIdentifier, action, counter,
- actionDef.getQName().getLocalName()).getNode().getOwnerDocument());
+ return new NetconfMessage(NetconfMessageTransformUtil.prepareDomResultForActionRequest(contextTree,
+ domDataTreeIdentifier, action, counter,
+ actionDef.getQName().getLocalName()).getNode().getOwnerDocument());
}
Preconditions.checkNotNull(payload, "Transforming an action with input: %s, payload cannot be null", action);
"Transforming an action with input: %s, payload has to be a container, but was: %s", action, payload);
// Set the path to the input of action for the node stream writer
- final DOMResult result = NetconfMessageTransformUtil.prepareDomResultForActionRequest(
- DataSchemaContextTree.from(schemaContext), domDataTreeIdentifier, inputDef.getPath(), counter,
- actionDef.getQName().getLocalName());
+ final DOMResult result = NetconfMessageTransformUtil.prepareDomResultForActionRequest(contextTree,
+ domDataTreeIdentifier, inputDef.getPath(), counter, actionDef.getQName().getLocalName());
try {
NetconfMessageTransformUtil.writeNormalizedRpc((ContainerNode) payload, result, inputDef.getPath(),
- schemaContext);
+ mountContext.getSchemaContext());
} catch (final XMLStreamException | IOException | IllegalStateException e) {
throw new IllegalStateException("Unable to serialize " + action, e);
}
try {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
- final XmlParserStream xmlParser = XmlParserStream.create(writer, schemaContext,
+ final XmlParserStream xmlParser = XmlParserStream.create(writer, mountContext,
operationDefinition.getOutput(), strictParsing);
xmlParser.traverse(new DOMSource(element));
return resultHolder.getResult();
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.available.capabilities.AvailableCapability;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
getSessionCaps(true, Lists.newArrayList(TEST_CAPABILITY, TEST_CAPABILITY2));
device.onRemoteSessionUp(sessionCaps, listener);
- Mockito.verify(facade, Mockito.timeout(5000)).onDeviceConnected(
- any(SchemaContext.class), any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class), isNull());
+ Mockito.verify(facade, Mockito.timeout(5000)).onDeviceConnected(any(MountPointContext.class),
+ any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class), isNull());
Mockito.verify(schemaFactory, times(2)).createSchemaContext(anyCollectionOf(SourceIdentifier.class));
}
getSessionCaps(true, Lists.newArrayList(TEST_CAPABILITY, TEST_CAPABILITY2));
device.onRemoteSessionUp(sessionCaps, listener);
- Mockito.verify(facade, Mockito.timeout(5000)).onDeviceConnected(
- any(SchemaContext.class), any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class), isNull());
+ Mockito.verify(facade, Mockito.timeout(5000)).onDeviceConnected(any(MountPointContext.class),
+ any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class), isNull());
Mockito.verify(schemaFactory, times(1)).createSchemaContext(anyCollectionOf(SourceIdentifier.class));
}
verify(schemaContextProviderFactory, timeout(5000)).createSchemaContext(any(Collection.class));
verify(facade, timeout(5000)).onDeviceConnected(
- any(SchemaContext.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class),
+ any(MountPointContext.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class),
isNull());
device.onRemoteSessionDown();
verify(schemaContextProviderFactory, timeout(5000).times(2)).createSchemaContext(any(Collection.class));
verify(facade, timeout(5000).times(2)).onDeviceConnected(
- any(SchemaContext.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class),
+ any(MountPointContext.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class),
isNull());
}
final ArgumentCaptor<NetconfSessionPreferences> argument =
ArgumentCaptor.forClass(NetconfSessionPreferences.class);
- verify(facade, timeout(5000))
- .onDeviceConnected(any(SchemaContext.class), argument.capture(), any(DOMRpcService.class), isNull());
+ verify(facade, timeout(5000)).onDeviceConnected(any(MountPointContext.class), argument.capture(),
+ any(DOMRpcService.class), isNull());
final NetconfDeviceCapabilities netconfDeviceCaps = argument.getValue().getNetconfDeviceCapabilities();
netconfDeviceCaps.getResolvedCapabilities()
final RemoteDeviceHandler<NetconfSessionPreferences> remoteDeviceHandler =
mockCloseableClass(RemoteDeviceHandler.class);
doNothing().when(remoteDeviceHandler).onDeviceConnected(
- any(SchemaContext.class), any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class),
+ any(MountPointContext.class), any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class),
any(DOMActionService.class));
doNothing().when(remoteDeviceHandler).onDeviceDisconnected();
doNothing().when(remoteDeviceHandler).onNotification(any(DOMNotification.class));
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.notifications.NetconfNotification;
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.NetconfMessageTransformer;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
@Test(expected = IllegalArgumentException.class)
public void testMostRecentWrongYangModel() throws Exception {
final SchemaContext schemaContext = getNotificationSchemaContext(getClass(), true);
- messageTransformer = new NetconfMessageTransformer(schemaContext, true);
+ messageTransformer = new NetconfMessageTransformer(new EmptyMountPointContext(schemaContext), true);
messageTransformer.toNotification(userNotification);
}
@Test
public void testToNotificationFunction() throws Exception {
final SchemaContext schemaContext = getNotificationSchemaContext(getClass(), false);
- messageTransformer = new NetconfMessageTransformer(schemaContext, true);
+ messageTransformer = new NetconfMessageTransformer(new EmptyMountPointContext(schemaContext), true);
final DOMNotification domNotification = messageTransformer.toNotification(userNotification);
final ContainerNode root = domNotification.getBody();
assertNotNull(root);
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlUtil;
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.NetconfMessageTransformer;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
cfgCtx = YangParserTestUtils.parseYangResources(NetconfToRpcRequestTest.class,
"/schemas/config-test-rpc.yang", "/schemas/rpc-notification-subscription.yang");
- messageTransformer = new NetconfMessageTransformer(cfgCtx, true);
+ messageTransformer = new NetconfMessageTransformer(new EmptyMountPointContext(cfgCtx), true);
}
private static LeafNode<Object> buildLeaf(final QName running, final Object value) {
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.SchemalessMessageTransformer;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
public class SchemalessNetconfDeviceTest {
device.onRemoteSessionUp(sessionCaps, listener);
verify(facade).onDeviceConnected(
- any(SchemaContext.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class));
+ any(MountPointContext.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class));
device.onNotification(netconfMessage);
verify(facade).onNotification(isNull());
final RemoteDeviceHandler<NetconfSessionPreferences> remoteDeviceHandler =
mockCloseableClass(RemoteDeviceHandler.class);
doNothing().when(remoteDeviceHandler).onDeviceConnected(
- any(SchemaContext.class), any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class));
+ any(MountPointContext.class), any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class));
doNothing().when(remoteDeviceHandler).onDeviceDisconnected();
doNothing().when(remoteDeviceHandler).onNotification(any(DOMNotification.class));
return remoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
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.SchemaContext;
public class KeepaliveSalFacadeResponseWaitingTest {
private DOMRpcService localDeviceRpc;
@Override
- public void onDeviceConnected(final SchemaContext remoteSchemaContext,
+ public void onDeviceConnected(final MountPointContext remoteSchemaContext,
final NetconfSessionPreferences netconfSessionPreferences, final DOMRpcService currentDeviceRpc,
final DOMActionService deviceAction) {
localDeviceRpc = currentDeviceRpc;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public class KeepaliveSalFacadeTest {
doNothing().when(listener).disconnect();
doReturn("mockedRpc").when(deviceRpc).toString();
doNothing().when(underlyingSalFacade).onDeviceConnected(
- any(SchemaContext.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class));
+ any(MountPointContext.class), any(NetconfSessionPreferences.class), any(DOMRpcService.class));
ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
executorServiceSpy = Mockito.spy(executorService);
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.NetconfMessageTransformer;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.$YangModuleInfoImpl;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
- NetconfMessageTransformer transformer = new NetconfMessageTransformer(SCHEMA_CONTEXT, true);
+ NetconfMessageTransformer transformer = new NetconfMessageTransformer(
+ new EmptyMountPointContext(SCHEMA_CONTEXT), true);
final NetconfMessage reply = new NetconfMessage(XmlUtil.readXmlToDocument(
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
+ "<rpc-reply xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\" message-id=\"101\">\n"
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public class NetconfDeviceSalFacadeTest {
NetconfSessionPreferences.fromStrings(getCapabilities());
final DOMRpcService deviceRpc = mock(DOMRpcService.class);
- deviceFacade.onDeviceConnected(schemaContext, netconfSessionPreferences, deviceRpc, null);
+ deviceFacade.onDeviceConnected(new EmptyMountPointContext(schemaContext), netconfSessionPreferences, deviceRpc,
+ null);
verify(mountInstance, times(1)).onTopologyDeviceConnected(eq(schemaContext),
any(DOMDataBroker.class), eq(deviceRpc), any(NetconfDeviceNotificationService.class),
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Capabilities;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Schemas;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.schemas.Schema;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
XMLUnit.setIgnoreComments(true);
netconfMessageTransformer = getTransformer(SCHEMA);
- actionNetconfMessageTransformer = new NetconfMessageTransformer(ACTION_SCHEMA, true);
+ actionNetconfMessageTransformer = new NetconfMessageTransformer(new EmptyMountPointContext(ACTION_SCHEMA),
+ true);
}
@Test
@Test
public void testCreateSubscriberNotificationSchemaNotPresent() throws Exception {
- final NetconfMessageTransformer transformer = new NetconfMessageTransformer(SCHEMA, true,
- BaseSchema.BASE_NETCONF_CTX_WITH_NOTIFICATIONS);
+ final NetconfMessageTransformer transformer = new NetconfMessageTransformer(new EmptyMountPointContext(SCHEMA),
+ true, BaseSchema.BASE_NETCONF_CTX_WITH_NOTIFICATIONS);
NetconfMessage netconfMessage = transformer.toRpcRequest(
toPath(CREATE_SUBSCRIPTION_RPC_QNAME),
CREATE_SUBSCRIPTION_RPC_CONTENT
}
private static NetconfMessageTransformer getTransformer(final SchemaContext schema) {
- return new NetconfMessageTransformer(schema, true);
+ return new NetconfMessageTransformer(new EmptyMountPointContext(schema), true);
}
@Test
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.NetconfMessageTransformer;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.util.NetconfUtil;
+import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
.thenReturn(FluentFuture.from(RpcResultBuilder.success(ok).buildFuture()));
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_COMMIT_QNAME)))
.thenReturn(FluentFuture.from(RpcResultBuilder.success(ok).buildFuture()));
- final MessageTransformer<NetconfMessage> transformer = new NetconfMessageTransformer(SCHEMA_CONTEXT, true);
+ final MessageTransformer<NetconfMessage> transformer = new NetconfMessageTransformer(
+ new EmptyMountPointContext(SCHEMA_CONTEXT), true);
final DOMRpcService rpc = new NetconfDeviceRpc(SCHEMA_CONTEXT, listener, transformer);
final RemoteDeviceId id =
new RemoteDeviceId("device-1", InetSocketAddress.createUnresolved("localhost", 17830));