import org.opendaylight.netconf.topology.util.messages.CustomIdentifyMessage;
import org.opendaylight.netconf.topology.util.messages.CustomIdentifyMessageReply;
import org.opendaylight.netconf.topology.util.messages.NormalizedNodeMessage;
+import org.opendaylight.netconf.util.NetconfTopologyPathCreator;
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.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
return;
}
- final String path = member.address() + PATH + topologyId;
+ final NetconfTopologyPathCreator pathCreator = new NetconfTopologyPathCreator(member.address().toString(), topologyId);
+ final String path = pathCreator.build();
LOG.debug("Actor at :{} is resolving topology actor for path {}", clusterExtension.selfAddress(), path);
// first send basic identify message in case our messages have not been loaded through osgi yet to prevent crashing akka.
if (member.address().equals(clusterExtension.selfAddress())) {
return;
}
-
- final String path = member.address() + PATH + topologyId;
+ final NetconfTopologyPathCreator pathCreator = new NetconfTopologyPathCreator(member.address().toString(), topologyId);
+ final String path = pathCreator.build();
LOG.debug("Actor at :{} is resolving topology actor for path {}", clusterExtension.selfAddress(), path);
clusterExtension.system().actorSelection(path).tell(new Identify(member.address()), TypedActor.context().self());
} else if (message instanceof ActorIdentity) {
LOG.debug("Received ActorIdentity message", message);
- final String path = ((ActorIdentity) message).correlationId() + PATH + topologyId;
+ final NetconfTopologyPathCreator pathCreator = new NetconfTopologyPathCreator(((ActorIdentity) message).correlationId().toString(), topologyId);
+ final String path = pathCreator.build();
if (((ActorIdentity) message).getRef() == null) {
LOG.debug("ActorIdentity has null actor ref, retrying..", message);
final ActorRef self = TypedActor.context().self();
return document;
}
- //TODO move all occurences of this method in mdsal netconf(and xml factories) to a utility class
private Node transformNormalizedNode(final Document document, final NormalizedNode<?, ?> data, final SchemaPath rpcOutputPath) {
final DOMResult result = new DOMResult(document.createElement(XmlMappingConstants.RPC_REPLY_KEY));
return SchemaPath.create(Iterables.transform(dataRoot.getPathArguments(), PATH_ARG_TO_QNAME), dataRoot.equals(ROOT));
}
- // TODO this code is located in Restconf already
private void writeRootElement(final XMLStreamWriter xmlWriter, final NormalizedNodeWriter nnWriter, final ContainerNode data) {
try {
if (data.getNodeType().equals(SchemaContext.NAME)) {
}
private AnyXmlNode encapsulate(final DOMNotification body) {
- // FIXME: Introduce something like AnyXmlWithNormalizedNodeData in Yangtools
+ // FIXME: Introduce something like YangModeledAnyXmlNode in Yangtools
final Document doc = XmlUtil.newDocument();
final Optional<String> namespace = Optional.of(PAYLOAD_ARG.getNodeType().getNamespace().toString());
final Element element = XmlUtil.createElement(doc, "payload", namespace);
/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
package org.opendaylight.controller.config.yang.config.netconf.northbound.impl;
import org.opendaylight.controller.config.api.JmxAttributeValidationException;
+import org.opendaylight.netconf.impl.NetconfServerSessionNegotiatorFactoryBuilder;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
import org.opendaylight.netconf.impl.NetconfServerDispatcherImpl;
import org.opendaylight.netconf.impl.SessionIdProvider;
import org.opendaylight.netconf.impl.osgi.AggregatedNetconfOperationServiceFactory;
-public class NetconfServerDispatcherModule extends org.opendaylight.controller.config.yang.config.netconf.northbound.impl.AbstractNetconfServerDispatcherModule {
+public class NetconfServerDispatcherModule extends AbstractNetconfServerDispatcherModule {
public NetconfServerDispatcherModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
super(identifier, dependencyResolver);
}
- public NetconfServerDispatcherModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.netconf.northbound.impl.NetconfServerDispatcherModule oldModule, java.lang.AutoCloseable oldInstance) {
+ public NetconfServerDispatcherModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, NetconfServerDispatcherModule oldModule, AutoCloseable oldInstance) {
super(identifier, dependencyResolver, oldModule, oldInstance);
}
}
@Override
- public java.lang.AutoCloseable createInstance() {
+ public AutoCloseable createInstance() {
final AggregatedNetconfOperationServiceFactory aggregatedOpProvider = getAggregatedOpProvider();
final NetconfMonitoringService monitoringService = getServerMonitorDependency();
- final NetconfServerSessionNegotiatorFactory serverNegotiatorFactory = new NetconfServerSessionNegotiatorFactory(
- getTimerDependency(), aggregatedOpProvider, new SessionIdProvider(), getConnectionTimeoutMillis(), monitoringService);
+
+ final NetconfServerSessionNegotiatorFactory serverNegotiatorFactory = new NetconfServerSessionNegotiatorFactoryBuilder()
+ .setAggregatedOpService(aggregatedOpProvider)
+ .setTimer(getTimerDependency())
+ .setIdProvider(new SessionIdProvider())
+ .setMonitoringService(monitoringService)
+ .setConnectionTimeoutMillis(getConnectionTimeoutMillis())
+ .build();
final NetconfServerDispatcherImpl.ServerChannelInitializer serverChannelInitializer = new NetconfServerDispatcherImpl.ServerChannelInitializer(
serverNegotiatorFactory);
try {
Preconditions.checkState(operationRouter != null, "Cannot handle message, session up was not yet received");
- // FIXME: there is no validation since the document may contain yang
- // schemas
+ // there is no validation since the document may contain yang schemas
final NetconfMessage message = processDocument(netconfMessage,
session);
LOG.debug("Responding with message {}", message);
import io.netty.util.concurrent.Promise;
import java.net.SocketAddress;
import java.util.Set;
-import org.opendaylight.netconf.mapping.api.NetconfOperationService;
-import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.netconf.api.NetconfServerSessionPreferences;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.impl.osgi.NetconfOperationRouter;
import org.opendaylight.netconf.impl.osgi.NetconfOperationRouterImpl;
+import org.opendaylight.netconf.mapping.api.NetconfOperationService;
+import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
import org.opendaylight.protocol.framework.SessionListenerFactory;
import org.opendaylight.protocol.framework.SessionNegotiator;
import org.opendaylight.protocol.framework.SessionNegotiatorFactory;
private static final Logger LOG = LoggerFactory.getLogger(NetconfServerSessionNegotiatorFactory.class);
private final Set<String> baseCapabilities;
- // TODO too many params, refactor
- public NetconfServerSessionNegotiatorFactory(final Timer timer, final NetconfOperationServiceFactory netconfOperationProvider,
- final SessionIdProvider idProvider, final long connectionTimeoutMillis,
- final NetconfMonitoringService monitoringService) {
- this(timer, netconfOperationProvider, idProvider, connectionTimeoutMillis, monitoringService, DEFAULT_BASE_CAPABILITIES);
- }
-
- // TODO too many params, refactor
- public NetconfServerSessionNegotiatorFactory(final Timer timer, final NetconfOperationServiceFactory netconfOperationProvider,
+ protected NetconfServerSessionNegotiatorFactory(final Timer timer, final NetconfOperationServiceFactory netconfOperationProvider,
final SessionIdProvider idProvider, final long connectionTimeoutMillis,
final NetconfMonitoringService monitoringService, final Set<String> baseCapabilities) {
this.timer = timer;
this.idProvider = idProvider;
this.connectionTimeoutMillis = connectionTimeoutMillis;
this.monitoringService = monitoringService;
- this.baseCapabilities = validateBaseCapabilities(baseCapabilities);
+ this.baseCapabilities = validateBaseCapabilities(baseCapabilities == null ? DEFAULT_BASE_CAPABILITIES : baseCapabilities);
}
+
private static ImmutableSet<String> validateBaseCapabilities(final Set<String> baseCapabilities) {
// Check base capabilities to be supported by the server
final Sets.SetView<String> unknownBaseCaps = Sets.difference(baseCapabilities, DEFAULT_BASE_CAPABILITIES);
}
/**
- *
* @param defunctSessionListenerFactory will not be taken into account as session listener factory can
* only be created after snapshot is opened, thus this method constructs
* proper session listener factory.
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.netconf.impl;
+
+import com.google.common.base.Preconditions;
+import io.netty.util.Timer;
+import java.util.Set;
+import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
+import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
+
+public class NetconfServerSessionNegotiatorFactoryBuilder {
+ private Timer timer;
+ private SessionIdProvider idProvider;
+ private NetconfOperationServiceFactory aggregatedOpService;
+ private long connectionTimeoutMillis;
+ private NetconfMonitoringService monitoringService;
+ private Set<String> baseCapabilities;
+
+ public NetconfServerSessionNegotiatorFactoryBuilder() {
+ }
+
+ public NetconfServerSessionNegotiatorFactoryBuilder setTimer(final Timer timer) {
+ this.timer = timer;
+ return this;
+ }
+
+ public NetconfServerSessionNegotiatorFactoryBuilder setIdProvider(final SessionIdProvider idProvider) {
+ this.idProvider = idProvider;
+ return this;
+ }
+
+ public NetconfServerSessionNegotiatorFactoryBuilder setAggregatedOpService(final NetconfOperationServiceFactory aggregatedOpService) {
+ this.aggregatedOpService = aggregatedOpService;
+ return this;
+ }
+
+ public NetconfServerSessionNegotiatorFactoryBuilder setConnectionTimeoutMillis(final long connectionTimeoutMillis) {
+ this.connectionTimeoutMillis = connectionTimeoutMillis;
+ return this;
+ }
+
+ public NetconfServerSessionNegotiatorFactoryBuilder setMonitoringService(final NetconfMonitoringService monitoringService) {
+ this.monitoringService = monitoringService;
+ return this;
+ }
+
+ public NetconfServerSessionNegotiatorFactoryBuilder setBaseCapabilities(final Set<String> baseCapabilities) {
+ this.baseCapabilities = baseCapabilities;
+ return this;
+ }
+
+
+ public NetconfServerSessionNegotiatorFactory build() {
+ validate();
+ return new NetconfServerSessionNegotiatorFactory(timer, aggregatedOpService, idProvider, connectionTimeoutMillis, monitoringService, baseCapabilities);
+ }
+
+
+ private void validate() {
+ Preconditions.checkNotNull(timer, "timer not initialized");
+ Preconditions.checkNotNull(aggregatedOpService, "NetconfOperationServiceFactory not initialized");
+ Preconditions.checkNotNull(idProvider, "SessionIdProvider not initialized");
+ Preconditions.checkArgument(connectionTimeoutMillis > 0, "connection time out <=0");
+ Preconditions.checkNotNull(monitoringService, "NetconfMonitoringService not initialized");
+
+ baseCapabilities = (baseCapabilities == null) ? NetconfServerSessionNegotiatorFactory.DEFAULT_BASE_CAPABILITIES : baseCapabilities;
+ }
+}
import java.util.Dictionary;
import java.util.Hashtable;
import java.util.concurrent.TimeUnit;
-import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener;
-import org.opendaylight.netconf.notifications.BaseNotificationPublisherRegistration;
-import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
-import org.opendaylight.netconf.util.osgi.NetconfConfigUtil;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
import org.opendaylight.netconf.impl.NetconfServerDispatcherImpl;
import org.opendaylight.netconf.impl.NetconfServerDispatcherImpl.ServerChannelInitializer;
import org.opendaylight.netconf.impl.NetconfServerSessionNegotiatorFactory;
+import org.opendaylight.netconf.impl.NetconfServerSessionNegotiatorFactoryBuilder;
import org.opendaylight.netconf.impl.SessionIdProvider;
+import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener;
+import org.opendaylight.netconf.notifications.BaseNotificationPublisherRegistration;
+import org.opendaylight.netconf.notifications.NetconfNotificationCollector;
+import org.opendaylight.netconf.util.osgi.NetconfConfigUtil;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
private BaseNotificationPublisherRegistration listenerReg;
@Override
- public void start(final BundleContext context) {
+ public void start(final BundleContext context) {
try {
AggregatedNetconfOperationServiceFactory factoriesListener = new AggregatedNetconfOperationServiceFactory();
startOperationServiceFactoryTracker(context, factoriesListener);
final NetconfMonitoringServiceImpl monitoringService = startMonitoringService(context, factoriesListener);
- NetconfServerSessionNegotiatorFactory serverNegotiatorFactory = new NetconfServerSessionNegotiatorFactory(
- timer, factoriesListener, idProvider, connectionTimeoutMillis, monitoringService);
+ NetconfServerSessionNegotiatorFactory serverNegotiatorFactory = new NetconfServerSessionNegotiatorFactoryBuilder()
+ .setAggregatedOpService(factoriesListener)
+ .setTimer(timer)
+ .setIdProvider(idProvider)
+ .setMonitoringService(monitoringService)
+ .setConnectionTimeoutMillis(connectionTimeoutMillis)
+ .build();
eventLoopGroup = new NioEventLoopGroup();
private synchronized void onCapabilitiesAdded(final Set<Capability> addedCaps) {
- // FIXME howto check for duplicates
this.capabilities.putAll(Maps.uniqueIndex(setupCapabilities(addedCaps), CAPABILITY_TO_URI));
}
import org.opendaylight.controller.config.util.capability.Capability;
import org.opendaylight.controller.config.util.xml.DocumentedException;
import org.opendaylight.controller.config.util.xml.XmlUtil;
-import org.opendaylight.netconf.mapping.api.HandlingPriority;
-import org.opendaylight.netconf.mapping.api.NetconfOperation;
-import org.opendaylight.netconf.mapping.api.NetconfOperationChainedExecution;
-import org.opendaylight.netconf.mapping.api.NetconfOperationService;
-import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
-import org.opendaylight.netconf.nettyutil.handler.exi.NetconfStartExiMessage;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
-import org.opendaylight.netconf.util.messages.NetconfMessageUtil;
-import org.opendaylight.netconf.util.test.XmlFileLoader;
import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.api.monitoring.CapabilityListener;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
import org.opendaylight.netconf.client.conf.NetconfClientConfigurationBuilder;
import org.opendaylight.netconf.impl.osgi.AggregatedNetconfOperationServiceFactory;
+import org.opendaylight.netconf.mapping.api.HandlingPriority;
+import org.opendaylight.netconf.mapping.api.NetconfOperation;
+import org.opendaylight.netconf.mapping.api.NetconfOperationChainedExecution;
+import org.opendaylight.netconf.mapping.api.NetconfOperationService;
+import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
+import org.opendaylight.netconf.nettyutil.handler.exi.NetconfStartExiMessage;
+import org.opendaylight.netconf.util.messages.NetconfMessageUtil;
+import org.opendaylight.netconf.util.test.XmlFileLoader;
import org.opendaylight.protocol.framework.NeverReconnectStrategy;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.CapabilitiesBuilder;
SessionIdProvider idProvider = new SessionIdProvider();
- NetconfServerSessionNegotiatorFactory serverNegotiatorFactory = new NetconfServerSessionNegotiatorFactory(
- hashedWheelTimer, factoriesListener, idProvider, 5000, createMockedMonitoringService(), serverCaps);
+ NetconfServerSessionNegotiatorFactory serverNegotiatorFactory = new NetconfServerSessionNegotiatorFactoryBuilder()
+ .setTimer(hashedWheelTimer)
+ .setAggregatedOpService(factoriesListener)
+ .setIdProvider(idProvider)
+ .setConnectionTimeoutMillis(5000)
+ .setMonitoringService(createMockedMonitoringService())
+ .setBaseCapabilities(serverCaps)
+ .build();
NetconfServerDispatcherImpl.ServerChannelInitializer serverChannelInitializer = new NetconfServerDispatcherImpl.ServerChannelInitializer(serverNegotiatorFactory);
final NetconfServerDispatcherImpl dispatch = new NetconfServerDispatcherImpl(serverChannelInitializer, nettyGroup, nettyGroup);
SessionIdProvider idProvider = new SessionIdProvider();
hashedWheelTimer = new HashedWheelTimer();
- NetconfServerSessionNegotiatorFactory serverNegotiatorFactory = new NetconfServerSessionNegotiatorFactory(
- hashedWheelTimer, factoriesListener, idProvider, 5000, ConcurrentClientsTest.createMockedMonitoringService());
+
+ NetconfServerSessionNegotiatorFactory serverNegotiatorFactory = new NetconfServerSessionNegotiatorFactoryBuilder()
+ .setAggregatedOpService(factoriesListener)
+ .setTimer(hashedWheelTimer)
+ .setIdProvider(idProvider)
+ .setMonitoringService(ConcurrentClientsTest.createMockedMonitoringService())
+ .setConnectionTimeoutMillis(5000)
+ .build();
NetconfServerDispatcherImpl.ServerChannelInitializer serverChannelInitializer = new NetconfServerDispatcherImpl.ServerChannelInitializer(serverNegotiatorFactory);
private final Timer timer;
private final long connectionTimeoutMillis;
- // TODO shrink constructor
protected AbstractNetconfSessionNegotiator(final P sessionPreferences, final Promise<S> promise, final Channel channel, final Timer timer,
final L sessionListener, final long connectionTimeoutMillis) {
super(promise, channel);
import org.opendaylight.netconf.topology.util.BaseTopologyManager;
import org.opendaylight.netconf.topology.util.messages.AnnounceMasterMountPoint;
import org.opendaylight.netconf.topology.util.messages.AnnounceMasterMountPointDown;
+import org.opendaylight.netconf.util.NetconfTopologyPathCreator;
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.NetconfNodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus;
this.topologyDispatcher = (ClusteredNetconfTopology) topologyDispatcher;
this.roleChangeStrategy = roleChangeStrategy;
- final Future<ActorRef> topologyRefFuture = actorSystem.actorSelection("/user/" + topologyId).resolveOne(FiniteDuration.create(10L, TimeUnit.SECONDS));
+ final NetconfTopologyPathCreator pathCreator = new NetconfTopologyPathCreator(topologyId);
+ final Future<ActorRef> topologyRefFuture = actorSystem.actorSelection(pathCreator.build()).resolveOne(FiniteDuration.create(10L, TimeUnit.SECONDS));
topologyRefFuture.onComplete(new OnComplete<ActorRef>() {
@Override
public void onComplete(Throwable throwable, ActorRef actorRef) throws Throwable {
}
}, actorSystem.dispatcher());
- final Future<ActorRef> nodeRefFuture = actorSystem.actorSelection("/user/" + topologyId + "/" + nodeId).resolveOne(FiniteDuration.create(10L, TimeUnit.SECONDS));
+ final Future<ActorRef> nodeRefFuture = actorSystem.actorSelection(pathCreator.withSuffix(nodeId).build()).resolveOne(FiniteDuration.create(10L, TimeUnit.SECONDS));
nodeRefFuture.onComplete(new OnComplete<ActorRef>() {
@Override
public void onComplete(Throwable throwable, ActorRef actorRef) throws Throwable {
import org.opendaylight.netconf.topology.pipeline.messages.AnnounceClusteredDeviceSourcesResolverUp;
import org.opendaylight.netconf.topology.pipeline.messages.AnnounceMasterOnSameNodeUp;
import org.opendaylight.netconf.topology.pipeline.messages.AnnounceMasterSourceProviderUp;
+import org.opendaylight.netconf.util.NetconfTopologyPathCreator;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
Cluster cluster = Cluster.get(actorSystem);
for(Member node : cluster.state().getMembers()) {
if(!node.address().equals(cluster.selfAddress())) {
- final String path = node.address() + "/user/" + topologyId + "/" + nodeId + "/masterSourceProvider";
+ final NetconfTopologyPathCreator pathCreator = new NetconfTopologyPathCreator(node.address().toString(), topologyId);
+ final String path = pathCreator.withSuffix(nodeId).withSuffix(NetconfTopologyPathCreator.MASTER_SOURCE_PROVIDER).build();
actorSystem.actorSelection(path).tell(new AnnounceClusteredDeviceSourcesResolverUp(), TypedActor.context().self());
}
}
import org.opendaylight.netconf.sal.connect.netconf.sal.NetconfDeviceRpc;
import org.opendaylight.netconf.sal.connect.netconf.schema.mapping.NetconfMessageTransformer;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
+import org.opendaylight.netconf.util.NetconfTopologyPathCreator;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
public MasterSourceProviderImpl create() throws Exception {
return new MasterSourceProviderImpl(schemaRepo, sourceIds, actorSystem, topologyId, nodeId);
}
- }), "masterSourceProvider");
+ }), NetconfTopologyPathCreator.MASTER_SOURCE_PROVIDER);
}
@Override
public ClusteredDeviceSourcesResolverImpl create() throws Exception {
return new ClusteredDeviceSourcesResolverImpl(topologyId, nodeId, actorSystem, schemaRegistry, sourceRegistrations);
}
- }), "clusteredDeviceSourcesResolver");
-
+ }), NetconfTopologyPathCreator.CLUSTERED_DEVICE_SOURCES_RESOLVER);
final FutureCallback<SchemaContext> schemaContextFuture = new FutureCallback<SchemaContext>() {
@Override
import org.opendaylight.netconf.topology.pipeline.messages.AnnounceClusteredDeviceSourcesResolverUp;
import org.opendaylight.netconf.topology.pipeline.messages.AnnounceMasterOnSameNodeUp;
import org.opendaylight.netconf.topology.pipeline.messages.AnnounceMasterSourceProviderUp;
+import org.opendaylight.netconf.util.NetconfTopologyPathCreator;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.slf4j.Logger;
cluster.join(cluster.selfAddress());
LOG.debug("Notifying members master schema source provider is up.");
for(Member node : cluster.state().getMembers()) {
- final String path = node.address() + "/user/" + topologyId + "/" + nodeId + "/clusteredDeviceSourcesResolver";
+ final NetconfTopologyPathCreator pathCreator = new NetconfTopologyPathCreator(node.address().toString(),topologyId);
+ final String path = pathCreator.withSuffix(nodeId).withSuffix(NetconfTopologyPathCreator.CLUSTERED_DEVICE_SOURCES_RESOLVER).build();
if(node.address().equals(cluster.selfAddress())) {
actorSystem.actorSelection(path).tell(new AnnounceMasterOnSameNodeUp(), TypedActor.context().self());
actorSystem.actorSelection(path).tell(PoisonPill.getInstance(), TypedActor.context().self());
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.util.messages.AnnounceMasterMountPoint;
import org.opendaylight.netconf.topology.util.messages.AnnounceMasterMountPointDown;
+import org.opendaylight.netconf.util.NetconfTopologyPathCreator;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final ActorRef deviceDataBrokerRef = TypedActor.get(actorSystem).getActorRefFor(deviceDataBroker);
for (final Member member : members) {
if (!member.address().equals(cluster.selfAddress())) {
- final String path = member.address() + "/user/" + topologyId + "/" + id.getName();
+ final NetconfTopologyPathCreator pathCreator = new NetconfTopologyPathCreator(member.address().toString(),topologyId);
+ final String path = pathCreator.withSuffix(id.getName()).build();
actorSystem.actorSelection(path).tell(new AnnounceMasterMountPoint(), deviceDataBrokerRef);
}
}
if (member.address().equals(Cluster.get(actorSystem).selfAddress())) {
continue;
}
- actorSystem.actorSelection(member.address() + "/user/" + topologyId + "/" + id.getName()).tell(new AnnounceMasterMountPointDown(), null);
+ final NetconfTopologyPathCreator pathCreator = new NetconfTopologyPathCreator(member.address().toString(), topologyId);
+ final String path = pathCreator.withSuffix(id.getName()).build();
+ actorSystem.actorSelection(path).tell(new AnnounceMasterMountPointDown(), null);
}
TypedActor.get(actorSystem).stop(deviceDataBroker);
deviceDataBroker = null;
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.netconf.util;
+
+public class NetconfTopologyPathCreator {
+
+ public static final String CLUSTERED_DEVICE_SOURCES_RESOLVER = "clusteredDeviceSourcesResolver";
+ public static final String MASTER_SOURCE_PROVIDER
+ = "masterSourceProvider";
+
+ private static final String USER = "/user/";
+
+ private String mainPath;
+
+ public NetconfTopologyPathCreator(final String topologyId) {
+ mainPath = createMainPath("", topologyId);
+ }
+
+ public NetconfTopologyPathCreator(final String memberAddress, final String topologyId) {
+ mainPath = createMainPath(memberAddress, topologyId);
+ }
+
+ private String createMainPath(final String memberAddress, final String topologyId) {
+ return memberAddress + USER + topologyId;
+ }
+
+ public NetconfTopologyPathCreator withSuffix(final String suffix) {
+ mainPath += "/"+suffix;
+ return this;
+ }
+
+ public String build(){
+ return mainPath;
+ }
+
+}
if (!maybeFilter.isPresent()) {
return rpcReply;
}
-
- rpcReply = reReadDocument(rpcReply);
XmlElement filter = maybeFilter.get();
if (isSupported(filter)) {
* @throws DocumentedException
*/
public static Optional<Document> applySubtreeNotificationFilter(XmlElement filter, Document notification) throws DocumentedException {
- notification = reReadDocument(notification);
removeEventTimeNode(notification);
if (isSupported(filter)) {
return Optional.fromNullable(filteredNotification(filter, notification));
return Optional.of(extractNotificationContent(notification));
}
- private static Document reReadDocument(Document notification) throws DocumentedException {
- // FIXME: rpcReply document must be reread otherwise some nodes do not inherit namespaces. (services/service)
- try {
- notification = XmlUtil.readXmlToDocument(XmlUtil.toString(notification, true));
- } catch (SAXException | IOException e) {
- LOG.error("Cannot transform document", e);
- throw new DocumentedException("Cannot transform document" + e);
- }
- return notification;
- }
-
private static void removeEventTimeNode(Document document) {
final Node eventTimeNode = document.getDocumentElement().getElementsByTagNameNS(
XmlNetconfConstants.URN_IETF_PARAMS_NETCONF_CAPABILITY_NOTIFICATION_1_0, XmlNetconfConstants.EVENT_TIME).item(0);
import org.opendaylight.protocol.framework.TimedReconnectStrategy;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Host;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceFilter;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
+import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
import org.opendaylight.yangtools.yang.model.repo.util.FilesystemSchemaSourceCache;
import org.opendaylight.yangtools.yang.parser.repo.SharedSchemaRepository;
private static final SchemaContextFactory DEFAULT_SCHEMA_CONTEXT_FACTORY =
DEFAULT_SCHEMA_REPOSITORY.createSchemaContextFactory(SchemaSourceFilter.ALWAYS_ACCEPT);
+ private static final int LOCAL_IO_FALLBACK_COST = PotentialSchemaSource.Costs.LOCAL_IO.getValue() + 1;
+
/**
* Keeps track of initialized Schema resources. A Map is maintained in which the key represents the name
* of the schema cache directory, and the value is a corresponding <code>SchemaResourcesDTO</code>. The
setSchemaRegistry(dto.getSchemaRegistry());
schemaResourcesDTO = dto;
}
+ if (userCapabilities.isPresent()) {
+ for (QName qname : userCapabilities.get().getModuleBasedCaps()) {
+ final SourceIdentifier sourceIdentifier = new SourceIdentifier(qname.getLocalName(), qname.getFormattedRevision());
+ dto.getSchemaRegistry().registerSchemaSource(DEFAULT_CACHE, PotentialSchemaSource.create(sourceIdentifier, YangTextSchemaSource.class, LOCAL_IO_FALLBACK_COST));
+ }
+ }
}
LOG.info("Netconf connector for device {} will use schema cache directory {} instead of {}",
instanceName, moduleSchemaCacheDirectory, DEFAULT_CACHE_DIRECTORY);
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.netconf.sal.connect.netconf.sal;
-
-import com.google.common.base.Function;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.FluentIterable;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-
-import java.util.Set;
-import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodesBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.inventory.rev140108.NetconfNode;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.inventory.rev140108.NetconfNodeBuilder;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Asynchronous (Binding-aware) adapter over datastore subtree for netconf device.
- *
- * All data changes are submitted to an ExecutorService to avoid Thread blocking while sal is waiting for schema.
- *
- * @deprecated Data is pushed into Topology instead if Inventory model
- */
-@Deprecated
-final class NetconfDeviceDatastoreAdapter implements AutoCloseable {
-
- private static final Logger logger = LoggerFactory.getLogger(NetconfDeviceDatastoreAdapter.class);
-
- private final RemoteDeviceId id;
- private BindingTransactionChain txChain;
-
- NetconfDeviceDatastoreAdapter(final RemoteDeviceId deviceId, final BindingTransactionChain txChain) {
- this.id = Preconditions.checkNotNull(deviceId);
- this.txChain = Preconditions.checkNotNull(txChain);
-
- initDeviceData();
- }
-
- public void updateDeviceState(final boolean up, final Set<QName> capabilities) {
- final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node data = buildDataForDeviceState(
- up, capabilities, id);
-
- final ReadWriteTransaction transaction = txChain.newReadWriteTransaction();
- logger.trace("{}: Update device state transaction {} merging operational data started.", id, transaction.getIdentifier());
- transaction.put(LogicalDatastoreType.OPERATIONAL, id.getBindingPath(), data);
- logger.trace("{}: Update device state transaction {} merging operational data ended.", id, transaction.getIdentifier());
-
- commitTransaction(transaction, "update");
- }
-
- private void removeDeviceConfigAndState() {
- final WriteTransaction transaction = txChain.newWriteOnlyTransaction();
- logger.trace("{}: Close device state transaction {} removing all data started.", id, transaction.getIdentifier());
- transaction.delete(LogicalDatastoreType.CONFIGURATION, id.getBindingPath());
- transaction.delete(LogicalDatastoreType.OPERATIONAL, id.getBindingPath());
- logger.trace("{}: Close device state transaction {} removing all data ended.", id, transaction.getIdentifier());
-
- try {
- transaction.submit().get();
- } catch (InterruptedException | ExecutionException e) {
- logger.error("{}: Transaction(close) {} FAILED!", id, transaction.getIdentifier(), e);
- throw new IllegalStateException(id + " Transaction(close) not committed correctly", e);
- }
- }
-
- private void initDeviceData() {
- final WriteTransaction transaction = txChain.newWriteOnlyTransaction();
-
- createNodesListIfNotPresent(transaction);
-
- final InstanceIdentifier<Node> path = id.getBindingPath();
- final Node nodeWithId = getNodeWithId(id);
-
- logger.trace("{}: Init device state transaction {} putting if absent operational data started.", id, transaction.getIdentifier());
- transaction.put(LogicalDatastoreType.OPERATIONAL, path, nodeWithId);
- logger.trace("{}: Init device state transaction {} putting operational data ended.", id, transaction.getIdentifier());
-
- logger.trace("{}: Init device state transaction {} putting if absent config data started.", id, transaction.getIdentifier());
- transaction.put(LogicalDatastoreType.CONFIGURATION, path, nodeWithId);
- logger.trace("{}: Init device state transaction {} putting config data ended.", id, transaction.getIdentifier());
-
- commitTransaction(transaction, "init");
- }
-
- private void createNodesListIfNotPresent(final WriteTransaction writeTx) {
- final Nodes nodes = new NodesBuilder().build();
- final InstanceIdentifier<Nodes> path = InstanceIdentifier.builder(Nodes.class).build();
- logger.trace("{}: Merging {} container to ensure its presence", id, Nodes.QNAME, writeTx.getIdentifier());
- writeTx.merge(LogicalDatastoreType.CONFIGURATION, path, nodes);
- writeTx.merge(LogicalDatastoreType.OPERATIONAL, path, nodes);
- }
-
- private void commitTransaction(final WriteTransaction transaction, final String txType) {
- logger.trace("{}: Committing Transaction {}:{}", id, txType, transaction.getIdentifier());
- final CheckedFuture<Void, TransactionCommitFailedException> result = transaction.submit();
-
- Futures.addCallback(result, new FutureCallback<Void>() {
- @Override
- public void onSuccess(final Void result) {
- logger.trace("{}: Transaction({}) {} SUCCESSFUL", id, txType, transaction.getIdentifier());
- }
-
- @Override
- public void onFailure(final Throwable t) {
- logger.error("{}: Transaction({}) {} FAILED!", id, txType, transaction.getIdentifier(), t);
- throw new IllegalStateException(id + " Transaction(" + txType + ") not committed correctly", t);
- }
- });
-
- }
-
- @Override
- public void close() throws Exception {
- removeDeviceConfigAndState();
- }
-
- public static org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node buildDataForDeviceState(
- final boolean up, final Set<QName> capabilities, final RemoteDeviceId id) {
-
- final NodeBuilder nodeBuilder = getNodeWithIdBuilder(id);
- final NetconfNodeBuilder netconfNodeBuilder = new NetconfNodeBuilder();
- netconfNodeBuilder.setConnected(up);
- netconfNodeBuilder.setInitialCapability(FluentIterable.from(capabilities)
- .transform(new Function<QName, String>() {
- @Override
- public String apply(final QName input) {
- return input.toString();
- }
- }).toList());
- nodeBuilder.addAugmentation(NetconfNode.class, netconfNodeBuilder.build());
-
- return nodeBuilder.build();
- }
-
- private static ListenableFuture<Optional<Node>> readNodeData(
- final LogicalDatastoreType store,
- final ReadWriteTransaction transaction,
- final InstanceIdentifier<Node> path) {
- return transaction.read(store, path);
- }
-
- private static Node getNodeWithId(final RemoteDeviceId id) {
- final NodeBuilder nodeBuilder = getNodeWithIdBuilder(id);
- return nodeBuilder.build();
- }
-
- private static NodeBuilder getNodeWithIdBuilder(final RemoteDeviceId id) {
- final NodeBuilder nodeBuilder = new NodeBuilder();
- nodeBuilder.setKey(id.getBindingKey());
- nodeBuilder.setId(id.getBindingKey().getId());
- return nodeBuilder;
- }
-
- public void setTxChain(BindingTransactionChain txChain) {
- this.txChain = Preconditions.checkNotNull(txChain);
- }
-}
if (input.isSuccessful()) {
return transformer.toRpcResult(input.getResult(), type);
} else {
- // TODO check whether the listener sets errors properly
return new DefaultDOMRpcResult(input.getErrors());
}
}
@Nullable
@Override
public DOMRpcException apply(@Nullable final Exception e) {
- // FIXME what other possible exceptions are there ?
return new DOMRpcImplementationNotAvailableException(e, "Unable to invoke rpc %s", type);
}
});
package org.opendaylight.netconf.sal.connect.netconf.sal;
import com.google.common.collect.Lists;
-import java.util.Collections;
import java.util.List;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final NetconfDeviceNotificationService notificationService = new NetconfDeviceNotificationService();
- salProvider.getMountInstance().onDeviceConnected(schemaContext, domBroker, deviceRpc, notificationService);
- salProvider.getDatastoreAdapter().updateDeviceState(true, netconfSessionPreferences.getModuleBasedCaps());
salProvider.getMountInstance().onTopologyDeviceConnected(schemaContext, domBroker, deviceRpc, notificationService);
salProvider.getTopologyDatastoreAdapter().updateDeviceData(true, netconfSessionPreferences.getNetconfDeviceCapabilities());
}
@Override
public synchronized void onDeviceDisconnected() {
- salProvider.getDatastoreAdapter().updateDeviceState(false, Collections.<QName>emptySet());
salProvider.getTopologyDatastoreAdapter().updateDeviceData(false, new NetconfDeviceCapabilities());
- salProvider.getMountInstance().onDeviceDisconnected();
salProvider.getMountInstance().onTopologyDeviceDisconnected();
}
@Override
public synchronized void onDeviceFailed(final Throwable throwable) {
salProvider.getTopologyDatastoreAdapter().setDeviceAsFailed(throwable);
- salProvider.getMountInstance().onDeviceDisconnected();
salProvider.getMountInstance().onTopologyDeviceDisconnected();
}
private static final Logger logger = LoggerFactory.getLogger(NetconfDeviceSalProvider.class);
private final RemoteDeviceId id;
- private volatile NetconfDeviceDatastoreAdapter datastoreAdapter;
private MountInstance mountInstance;
private volatile NetconfDeviceTopologyAdapter topologyDatastoreAdapter;
return mountInstance;
}
- public NetconfDeviceDatastoreAdapter getDatastoreAdapter() {
- Preconditions.checkState(datastoreAdapter != null,
- "%s: Sal provider %s was not initialized by sal. Cannot get datastore adapter", id);
- return datastoreAdapter;
- }
-
public NetconfDeviceTopologyAdapter getTopologyDatastoreAdapter() {
Preconditions.checkState(topologyDatastoreAdapter != null,
"%s: Sal provider %s was not initialized by sal. Cannot get topology datastore adapter", id);
this.dataBroker = session.getSALService(DataBroker.class);
txChain = Preconditions.checkNotNull(dataBroker).createTransactionChain(transactionChainListener);
- datastoreAdapter = new NetconfDeviceDatastoreAdapter(id, txChain);
topologyDatastoreAdapter = new NetconfDeviceTopologyAdapter(id, txChain);
}
private void resetTransactionChainForAdapaters() {
txChain = Preconditions.checkNotNull(dataBroker).createTransactionChain(transactionChainListener);
- datastoreAdapter.setTxChain(txChain);
topologyDatastoreAdapter.setTxChain(txChain);
logger.trace("{}: Resetting TransactionChain {}", id, txChain);
public void close() throws Exception {
mountInstance.close();
- datastoreAdapter.close();
- datastoreAdapter = null;
topologyDatastoreAdapter.close();
topologyDatastoreAdapter = null;
txChain.close();
private DOMMountPointService mountService;
private final RemoteDeviceId id;
- private ObjectRegistration<DOMMountPoint> registration;
private NetconfDeviceNotificationService notificationService;
private ObjectRegistration<DOMMountPoint> topologyRegistration;
this.id = Preconditions.checkNotNull(id);
}
- @Deprecated
- synchronized void onDeviceConnected(final SchemaContext initialCtx,
- final DOMDataBroker broker, final DOMRpcService rpc,
- final NetconfDeviceNotificationService notificationService) {
-
- Preconditions.checkNotNull(mountService, "Closed");
- Preconditions.checkState(registration == null, "Already initialized");
-
- final DOMMountPointService.DOMMountPointBuilder mountBuilder = mountService.createMountPoint(id.getPath());
- mountBuilder.addInitialSchemaContext(initialCtx);
-
- mountBuilder.addService(DOMDataBroker.class, broker);
- mountBuilder.addService(DOMRpcService.class, rpc);
- mountBuilder.addService(DOMNotificationService.class, notificationService);
- this.notificationService = notificationService;
-
- registration = mountBuilder.register();
- logger.debug("{}: Mountpoint exposed into MD-SAL {}", id, registration);
- }
-
- @Deprecated
- synchronized void onDeviceDisconnected() {
- if(registration == null) {
- logger.trace("{}: Not removing mountpoint from MD-SAL, mountpoint was not registered yet", id);
- return;
- }
-
- try {
- registration.close();
- } catch (final Exception e) {
- // Only log and ignore
- logger.warn("Unable to unregister mount instance for {}. Ignoring exception", id.getPath(), e);
- } finally {
- logger.debug("{}: Mountpoint removed from MD-SAL {}", id, registration);
- registration = null;
- }
- }
-
public synchronized void onTopologyDeviceConnected(final SchemaContext initialCtx,
final DOMDataBroker broker, final DOMRpcService rpc,
final NetconfDeviceNotificationService notificationService) {
mountBuilder.addService(DOMDataBroker.class, broker);
mountBuilder.addService(DOMRpcService.class, rpc);
mountBuilder.addService(DOMNotificationService.class, notificationService);
+ this.notificationService = notificationService;
topologyRegistration = mountBuilder.register();
logger.debug("{}: TOPOLOGY Mountpoint exposed into MD-SAL {}", id, topologyRegistration);
@Override
public synchronized void close() throws Exception {
- onDeviceDisconnected();
onTopologyDeviceDisconnected();
mountService = null;
}
final CheckedFuture<YangTextSchemaSource, SchemaSourceException> checked = Futures.makeChecked(transformed, MAPPER);
- // / FIXME remove this get, it is only present to wait until source is retrieved
- // (goal is to limit concurrent schema download, since NetconfDevice listener does not handle concurrent messages properly)
- // TODO retest this
- try {
- LOG.trace("{}: Blocking for {}", id, sourceIdentifier);
- checked.checkedGet();
- } catch (final SchemaSourceException e) {
- return Futures.immediateFailedCheckedFuture(e);
- }
-
return checked;
}
mountInstance = new NetconfDeviceSalProvider.MountInstance(service, new RemoteDeviceId("device-1", InetSocketAddress.createUnresolved("localhost", 17830)));
}
- @Test
- public void testOnDeviceConnected() throws Exception {
- mountInstance.onDeviceConnected(SCHEMA_CONTEXT, broker, rpcService, notificationService);
- verify(mountPointBuilder).addInitialSchemaContext(SCHEMA_CONTEXT);
- verify(mountPointBuilder).addService(DOMDataBroker.class, broker);
- verify(mountPointBuilder).addService(DOMRpcService.class, rpcService);
- verify(mountPointBuilder).addService(DOMNotificationService.class, notificationService);
- }
-
- @Test
- public void testOnDeviceDisconnected() throws Exception {
- mountInstance.onDeviceConnected(SCHEMA_CONTEXT, broker, rpcService, notificationService);
- mountInstance.onDeviceDisconnected();
- verify(registration).close();
- try {
- mountInstance.onDeviceConnected(SCHEMA_CONTEXT, broker, rpcService, notificationService);
- } catch (IllegalStateException e) {
- e.printStackTrace();
- Assert.fail("Registration still present after disconnect ");
- }
- }
@Test
public void testOnTopologyDeviceConnected() throws Exception {
</dependencyManagement>
<dependencies>
+ <dependency>
+ <groupId>org.codehaus.janino</groupId>
+ <artifactId>janino</artifactId>
+ <version>2.6.1</version>
+ </dependency>
<dependency>
<groupId>net.sourceforge.argparse4j</groupId>
<artifactId>argparse4j</artifactId>
<groupId>org.opendaylight.netconf</groupId>
<artifactId>mdsal-netconf-connector</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.apache.karaf.features</groupId>
+ <artifactId>org.apache.karaf.features.core</artifactId>
+ <version>3.0.3</version>
+ </dependency>
</dependencies>
<build>
import com.google.common.io.Files;
import java.io.File;
import java.io.FileFilter;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
-import org.opendaylight.controller.config.util.xml.XmlElement;
-import org.opendaylight.controller.config.util.xml.XmlUtil;
+import javax.xml.bind.JAXBException;
+import org.apache.karaf.features.internal.model.ConfigFile;
+import org.apache.karaf.features.internal.model.Feature;
+import org.apache.karaf.features.internal.model.Features;
+import org.apache.karaf.features.internal.model.JaxbUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
-import org.xml.sax.SAXException;
public final class Main {
public void updateFeatureFile(final List<File> generated) {
- // TODO karaf core contains jaxb for feature files, use that for
- // modification
- try {
- for (final File featureFile : ncFeatureFiles) {
- final Document document = XmlUtil.readXmlToDocument(Files
- .toString(featureFile, Charsets.UTF_8));
- final NodeList childNodes = document.getDocumentElement().getChildNodes();
-
- for (int i = 0; i < childNodes.getLength(); i++) {
- final Node item = childNodes.item(i);
- if (item instanceof Element == false) {
- continue;
- }
- if (item.getLocalName().equals("feature") == false) {
- continue;
- }
+ for (final File fileFeatures : ncFeatureFiles) {
+ try {
+ final Features f = JaxbUtil.unmarshal(new FileInputStream(fileFeatures), false);
- if (NETCONF_CONNECTOR_ALL_FEATURE
- .equals(((Element) item).getAttribute("name"))) {
- final Element ncAllFeatureDefinition = (Element) item;
- // Clean previous generated files
- for (final XmlElement configfile : XmlElement
- .fromDomElement(ncAllFeatureDefinition)
- .getChildElements("configfile")) {
- ncAllFeatureDefinition.removeChild(configfile.getDomElement());
- }
- for (final File file : generated) {
- final Element configfile = document.createElement("configfile");
- configfile.setTextContent("file:"
- + ETC_OPENDAYLIGHT_KARAF_PATH
- + file.getName());
- configfile.setAttribute(
- "finalname",
- ETC_OPENDAYLIGHT_KARAF_PATH
- + file.getName());
- ncAllFeatureDefinition.appendChild(configfile);
+ for (final Feature feature : f.getFeature()) {
+ if (NETCONF_CONNECTOR_ALL_FEATURE.equals(feature.getName())) {
+ //Clean all previously generated configFiles
+ feature.getConfigfile().clear();
+
+ //Create new configFiles
+ for (final File gen : generated) {
+ final ConfigFile cf = new ConfigFile();
+
+ final String generatedName = ETC_OPENDAYLIGHT_KARAF_PATH + gen.getName();
+
+ cf.setFinalname(generatedName);
+ cf.setLocation("file:" + generatedName);
+
+ feature.getConfigfile().add(cf);
+ }
}
}
- }
-
- Files.write(XmlUtil.toString(document), featureFile, Charsets.UTF_8);
- LOG.info("Feature file {} updated", featureFile);
+ JaxbUtil.marshal(f, new FileWriter(fileFeatures));
+ LOG.info("Feature file {} updated", fileFeatures);
+ } catch (JAXBException | IOException e) {
+ throw new RuntimeException(e);
}
- } catch (final IOException e) {
- throw new RuntimeException("Unable to load features file as a resource");
- } catch (final SAXException e) {
- throw new RuntimeException("Unable to parse features file");
}
}
package org.opendaylight.netconf.test.tool;
import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.LoggerContext;
+import ch.qos.logback.classic.util.ContextInitializer;
+import ch.qos.logback.core.joran.spi.JoranException;
+import ch.qos.logback.core.util.StatusPrinter;
import com.google.common.base.Stopwatch;
import com.google.common.io.CharStreams;
import com.ning.http.client.AsyncHttpClient;
import org.slf4j.LoggerFactory;
public class ScaleUtil {
-
- private static final Logger RESULTS_LOG = LoggerFactory.getLogger("results");
+ private static Logger RESULTS_LOG ;
private static final ScheduledExecutorService executor = new LoggingWrapperExecutor(4);
private static final int deviceStep = 1000;
public static void main(final String[] args) {
final TesttoolParameters params = TesttoolParameters.parseArgs(args, TesttoolParameters.getParser());
- root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
- root.setLevel(params.debug ? Level.DEBUG : Level.INFO);
+ setUpLoggers(params);
// cleanup at the start in case controller was already running
final Runtime runtime = Runtime.getRuntime();
}
}
+ private static void setUpLoggers(final TesttoolParameters params) {
+ System.setProperty("log_file_name", "scale-util.log");
+
+ root = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
+ root.setLevel(params.debug ? Level.DEBUG : Level.INFO);
+ RESULTS_LOG = LoggerFactory.getLogger("results");
+ }
+
private static void cleanup(final Runtime runtime, final TesttoolParameters params) {
try {
stopKaraf(runtime, params);
import java.util.Set;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
import org.opendaylight.netconf.impl.NetconfServerSessionNegotiatorFactory;
+import org.opendaylight.netconf.impl.NetconfServerSessionNegotiatorFactoryBuilder;
import org.opendaylight.netconf.impl.SessionIdProvider;
import org.opendaylight.netconf.mapping.api.NetconfOperationService;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
public TesttoolNegotiationFactory(final Timer timer, final NetconfOperationServiceFactory netconfOperationProvider,
final SessionIdProvider idProvider, final long connectionTimeoutMillis,
final NetconfMonitoringService monitoringService) {
- super(timer, netconfOperationProvider, idProvider, connectionTimeoutMillis, monitoringService);
+ super(timer, netconfOperationProvider, idProvider, connectionTimeoutMillis, monitoringService, NetconfServerSessionNegotiatorFactory.DEFAULT_BASE_CAPABILITIES);
}
public TesttoolNegotiationFactory(final Timer timer, final NetconfOperationServiceFactory netconfOperationProvider,
<appender-ref ref="STDOUT"/>
</root>
- <appender name="RESULTS-FILE" class="ch.qos.logback.core.FileAppender">
- <file>scale-results.log</file>
- <append>true</append>
- <encoder>
- <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
- </encoder>
- </appender>
+ <if condition='property("log_file_name").contains("scale-util.log")'>
+ <then>
+ <appender name="RESULTS-FILE" class="ch.qos.logback.core.FileAppender">
+ <file>${log_file_name}</file>
+ <append>true</append>
+ <encoder>
+ <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+ </encoder>
+ </appender>
- <logger name="results" level="DEBUG" additivity="false">
- <appender-ref ref="RESULTS-FILE"/>
- </logger>
+ <logger name="results" level="DEBUG" additivity="false">
+ <appender-ref ref="RESULTS-FILE"/>
+ </logger>
+ </then>
+ </if>
<logger name="com.ning.http.client" level="WARN"/>
</configuration>
\ No newline at end of file
targetNode = findInstanceDataChildByNameAndNamespace(parentNode, nodeName, module.getNamespace());
if (targetNode == null && parentNode instanceof Module) {
- final RpcDefinition rpc = ControllerContext.getInstance().getRpcDefinition(head, module.getRevision());
+ final RpcDefinition rpc;
+ if (mountPoint == null) {
+ rpc = ControllerContext.getInstance().getRpcDefinition(head, module.getRevision());
+ } else {
+ final String rpcName = toNodeName(head);
+ rpc = ControllerContext.getInstance().getRpcDefinition(module, rpcName);
+ }
if (rpc != null) {
return new InstanceIdentifierContext<RpcDefinition>(builder.build(), rpc, mountPoint,
mountPoint != null ? mountPoint.getSchemaContext() : globalSchema);
return validName == null ? null : qnameToRpc.get().get(validName);
}
+ private RpcDefinition getRpcDefinition(final Module module, final String rpcName) {
+ QName rpcQName = QName.create(module.getQNameModule(), rpcName);
+ for (RpcDefinition rpcDefinition : module.getRpcs()) {
+ if (rpcQName.equals(rpcDefinition.getQName())) {
+ return rpcDefinition;
+ }
+ }
+ return null;
+ }
+
@Override
public void onGlobalContextUpdated(final SchemaContext context) {
if (context != null) {