package org.opendaylight.netconf.sal.connect.api;
import org.opendaylight.mdsal.dom.api.DOMActionService;
-import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public interface DeviceActionFactory {
* @param schemaContext - schema context of device
* @return {@link DOMActionService} of specific device
*/
- default DOMActionService createDeviceAction(final MessageTransformer<NetconfMessage> messageTransformer,
+ default DOMActionService createDeviceAction(final MessageTransformer messageTransformer,
final RemoteDeviceCommunicator listener, final SchemaContext schemaContext) {
return null;
}
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMNotification;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
+import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
-public interface MessageTransformer<M> {
+public interface MessageTransformer {
- DOMNotification toNotification(M message);
+ DOMNotification toNotification(NetconfMessage message);
- M toRpcRequest(QName rpc, NormalizedNode node);
+ NetconfMessage toRpcRequest(QName rpc, NormalizedNode node);
- DOMRpcResult toRpcResult(M message, QName rpc);
+ DOMRpcResult toRpcResult(NetconfMessage message, QName rpc);
/**
* Parse action into message for request.
* @param payload - input of action
* @return message
*/
- default M toActionRequest(final Absolute action, final DOMDataTreeIdentifier domDataTreeIdentifier,
+ default NetconfMessage toActionRequest(final Absolute action, final DOMDataTreeIdentifier domDataTreeIdentifier,
final NormalizedNode payload) {
throw new UnsupportedOperationException();
}
* @param message - message to parsing
* @return {@link DOMActionResult}
*/
- default DOMActionResult toActionResult(final Absolute action, final M message) {
+ default DOMActionResult toActionResult(final Absolute action, final NetconfMessage message) {
throw new UnsupportedOperationException();
}
}
private static final Logger LOG = LoggerFactory.getLogger(DeviceActionFactoryImpl.class);
@Override
- public DOMActionService createDeviceAction(final MessageTransformer<NetconfMessage> messageTransformer,
+ public DOMActionService createDeviceAction(final MessageTransformer messageTransformer,
final RemoteDeviceCommunicator listener, final SchemaContext schemaContext) {
return (schemaPath, dataTreeIdentifier, input) -> {
requireNonNull(schemaPath);
private boolean connected = false;
// Message transformer is constructed once the schemas are available
- private MessageTransformer<NetconfMessage> messageTransformer;
+ private MessageTransformer messageTransformer;
public NetconfDevice(final SchemaResourcesDTO schemaResourcesDTO, final BaseNetconfSchemas baseSchemas,
final RemoteDeviceId id, final RemoteDeviceHandler<NetconfSessionPreferences> salFacade,
updateTransformer(null);
}
- private synchronized void updateTransformer(final MessageTransformer<NetconfMessage> transformer) {
+ private synchronized void updateTransformer(final MessageTransformer transformer) {
messageTransformer = transformer;
}
* Handles incoming notifications. Either caches them(until onRemoteSchemaUp is called) or passes to sal Facade.
*/
final class NotificationHandler {
-
private static final Logger LOG = LoggerFactory.getLogger(NotificationHandler.class);
private final RemoteDeviceHandler<?> salFacade;
+ // FIXME: better implementation?
private final List<NetconfMessage> queue = new LinkedList<>();
private final RemoteDeviceId id;
- private boolean passNotifications = false;
+ private boolean passNotifications = false;
private NotificationFilter filter;
- private MessageTransformer<NetconfMessage> messageTransformer;
+ private MessageTransformer messageTransformer;
NotificationHandler(final RemoteDeviceHandler<?> salFacade, final RemoteDeviceId id) {
this.salFacade = requireNonNull(salFacade);
* Forward all cached notifications and pass all notifications from this point directly to sal facade.
* @param transformer Message transformer
*/
- synchronized void onRemoteSchemaUp(final MessageTransformer<NetconfMessage> transformer) {
- this.messageTransformer = requireNonNull(transformer);
+ synchronized void onRemoteSchemaUp(final MessageTransformer transformer) {
+ messageTransformer = requireNonNull(transformer);
passNotifications = true;
}
synchronized void addNotificationFilter(final NotificationFilter newFilter) {
- this.filter = newFilter;
+ filter = newFilter;
}
synchronized void onRemoteSchemaDown() {
*/
public final class NetconfDeviceRpc implements DOMRpcService {
private final RemoteDeviceCommunicator communicator;
- private final MessageTransformer<NetconfMessage> transformer;
+ private final MessageTransformer transformer;
private final SchemaContext schemaContext;
public NetconfDeviceRpc(final SchemaContext schemaContext, final RemoteDeviceCommunicator communicator,
- final MessageTransformer<NetconfMessage> transformer) {
+ final MessageTransformer transformer) {
this.communicator = communicator;
this.transformer = transformer;
this.schemaContext = requireNonNull(schemaContext);
@Override
public ListenableFuture<DOMRpcResult> invokeRpc(final QName type, final NormalizedNode input) {
- final MessageTransformer<NetconfMessage> transformer;
+ final MessageTransformer transformer;
if (input instanceof DOMSourceAnyxmlNode) {
transformer = schemalessTransformer;
} else if (isBaseRpc(type)) {
}
private ListenableFuture<DOMRpcResult> handleRpc(final @NonNull QName type, final @NonNull NormalizedNode input,
- final MessageTransformer<NetconfMessage> transformer) {
+ final MessageTransformer transformer) {
final ListenableFuture<RpcResult<NetconfMessage>> delegateFuture = listener.sendRequest(
transformer.toRpcRequest(type, input), type);
/**
* Transforms base netconf RPCs.
*/
-public class BaseRpcSchemalessTransformer implements MessageTransformer<NetconfMessage> {
+public class BaseRpcSchemalessTransformer implements MessageTransformer {
private final ImmutableMap<QName, ? extends RpcDefinition> mappedRpcs;
private final EffectiveModelContext modelContext;
private final MessageCounter counter;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
-public class NetconfMessageTransformer implements MessageTransformer<NetconfMessage> {
+public class NetconfMessageTransformer implements MessageTransformer {
private static final Logger LOG = LoggerFactory.getLogger(NetconfMessageTransformer.class);
private static final ImmutableSet<XMLNamespace> BASE_OR_NOTIFICATION_NS = ImmutableSet.of(
private NestedNotificationInfo traverseXmlNodeContainingNotification(final Node xmlNode,
final SchemaNode schemaNode, final List<QName> schemaBuilder,
final InstanceIdentifierBuilder instanceBuilder) {
- if (schemaNode instanceof ContainerSchemaNode) {
- final var containerSchema = (ContainerSchemaNode) schemaNode;
+ if (schemaNode instanceof ContainerSchemaNode containerSchema) {
instanceBuilder.node(QName.create(xmlNode.getNamespaceURI(), xmlNode.getLocalName()));
schemaBuilder.add(containerSchema.getQName());
Entry<Node, SchemaNode> xmlContainerChildPair = findXmlContainerChildPair(xmlNode, containerSchema);
return traverseXmlNodeContainingNotification(xmlContainerChildPair.getKey(),
xmlContainerChildPair.getValue(), schemaBuilder, instanceBuilder);
- } else if (schemaNode instanceof ListSchemaNode) {
- final var listSchema = (ListSchemaNode) schemaNode;
+ } else if (schemaNode instanceof ListSchemaNode listSchema) {
instanceBuilder.node(QName.create(xmlNode.getNamespaceURI(), xmlNode.getLocalName()));
schemaBuilder.add(listSchema.getQName());
/**
* Transforms anyxml rpcs for schemaless netconf devices.
*/
-public class SchemalessMessageTransformer implements MessageTransformer<NetconfMessage> {
+public class SchemalessMessageTransformer implements MessageTransformer {
// TODO maybe we should move this somewhere else as this
// might be used in applications using schemaless mountpoints
public static final NodeIdentifier SCHEMALESS_NOTIFICATION_PAYLOAD =
return MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
}
- public MessageTransformer<NetconfMessage> getMessageTransformer() throws Exception {
- final MessageTransformer<NetconfMessage> messageTransformer = mockClass(MessageTransformer.class);
+ public MessageTransformer getMessageTransformer() throws Exception {
+ final MessageTransformer messageTransformer = mockClass(MessageTransformer.class);
doReturn(NOTIFICATION).when(messageTransformer).toRpcRequest(any(QName.class), any(NormalizedNode.class));
doReturn(RPC_RESULT).when(messageTransformer).toRpcResult(any(NetconfMessage.class), any(QName.class));
doReturn(COMPOSITE_NODE).when(messageTransformer).toNotification(any(NetconfMessage.class));
@Test
public void testDeadlock() throws Exception {
// when rpc is successful, but transformer fails for some reason
- final MessageTransformer<NetconfMessage> failingTransformer = mock(MessageTransformer.class);
+ final MessageTransformer failingTransformer = mock(MessageTransformer.class);
final RemoteDeviceCommunicator communicatorMock = mock(RemoteDeviceCommunicator.class);
final NetconfMessage msg = null;
final RpcResult<NetconfMessage> result = RpcResultBuilder.success(msg).build();
.thenReturn(RpcResultBuilder.success(ok).buildFuture());
when(listener.sendRequest(any(), eq(NetconfMessageTransformUtil.NETCONF_COMMIT_QNAME)))
.thenReturn(RpcResultBuilder.success(ok).buildFuture());
- final MessageTransformer<NetconfMessage> transformer = new NetconfMessageTransformer(
- new EmptyMountPointContext(SCHEMA_CONTEXT), true, BASE_SCHEMAS.getBaseSchema());
+ final MessageTransformer transformer = new NetconfMessageTransformer(new EmptyMountPointContext(SCHEMA_CONTEXT),
+ true, BASE_SCHEMAS.getBaseSchema());
final DOMRpcService rpc = new NetconfDeviceRpc(SCHEMA_CONTEXT, listener, transformer);
final RemoteDeviceId id =
new RemoteDeviceId("device-1", InetSocketAddress.createUnresolved("localhost", 17830));
Code Review / netconf.git / commitdiff