<version>${project.version}</version>
<type>cfg</type>
<classifier>config</classifier>
- <scope>provided</scope>
</dependency>
</dependencies>
</project>
\ No newline at end of file
</dependency>
<dependency>
<groupId>org.opendaylight.odlparent</groupId>
- <artifactId>odl-karaf-feat-war</artifactId>
+ <artifactId>odl-karaf-feat-jetty</artifactId>
<type>xml</type>
<classifier>features</classifier>
</dependency>
<version>${project.version}</version>
<type>xml</type>
<classifier>config</classifier>
- <scope>provided</scope>
</dependency>
<dependency>
<!-- finalname="${config.configfile.directory}/${config.restconf.service.configfile}" -->
<version>${project.version}</version>
<type>xml</type>
<classifier>configrestconfservice</classifier>
- <scope>provided</scope>
</dependency>
</dependencies>
</project>
<dependency>
<groupId>org.opendaylight.odlparent</groupId>
- <artifactId>odl-karaf-feat-war</artifactId>
+ <artifactId>odl-karaf-feat-jetty</artifactId>
<type>xml</type>
<classifier>features</classifier>
</dependency>
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
import org.opendaylight.controller.config.util.capability.Capability;
-import org.opendaylight.netconf.api.monitoring.CapabilityListener;
import org.opendaylight.controller.sal.core.api.model.SchemaService;
+import org.opendaylight.netconf.api.monitoring.CapabilityListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
*/
package org.opendaylight.controller.config.yang.netconf.mdsal.monitoring;
+import java.util.Collections;
+import java.util.Set;
import org.opendaylight.controller.config.util.capability.Capability;
import org.opendaylight.controller.sal.common.util.NoopAutoCloseable;
import org.opendaylight.netconf.api.monitoring.CapabilityListener;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener;
import org.opendaylight.netconf.monitoring.GetSchema;
-import java.util.Collections;
-import java.util.Set;
-
public class MdsalMonitoringMapperFactory implements NetconfOperationServiceFactory, AutoCloseable {
private final NetconfOperationService operationService;
import com.google.common.util.concurrent.Futures;
import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
import org.opendaylight.controller.sal.core.api.model.SchemaService;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.library.rev160409.ModulesState;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.handler.codec.MessageToByteEncoder;
import java.util.Collection;
+import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.nettyutil.AbstractNetconfSession;
import org.opendaylight.netconf.nettyutil.handler.NetconfMessageToXMLEncoder;
import org.opendaylight.netconf.nettyutil.handler.NetconfXMLToMessageDecoder;
-import org.opendaylight.netconf.api.NetconfMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.netty.util.Timer;
import io.netty.util.concurrent.Promise;
import java.util.Set;
-import org.opendaylight.netconf.nettyutil.handler.exi.NetconfStartExiMessage;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.api.NetconfClientSessionPreferences;
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
+import org.opendaylight.netconf.nettyutil.handler.exi.NetconfStartExiMessage;
import org.opendaylight.protocol.framework.SessionListenerFactory;
import org.opendaylight.protocol.framework.SessionNegotiator;
import org.opendaylight.protocol.framework.SessionNegotiatorFactory;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.net.InetSocketAddress;
-import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
+import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.protocol.framework.ReconnectStrategy;
public class NetconfClientConfiguration {
package org.opendaylight.netconf.client.conf;
import java.net.InetSocketAddress;
-import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
+import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.protocol.framework.ReconnectStrategy;
public class NetconfClientConfigurationBuilder {
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.base.Preconditions;
import java.net.InetSocketAddress;
-import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
+import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.protocol.framework.ReconnectStrategy;
import org.opendaylight.protocol.framework.ReconnectStrategyFactory;
package org.opendaylight.netconf.client.conf;
import java.net.InetSocketAddress;
-import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.client.NetconfClientSessionListener;
+import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.protocol.framework.ReconnectStrategy;
import org.opendaylight.protocol.framework.ReconnectStrategyFactory;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
import org.opendaylight.netconf.client.conf.NetconfClientConfigurationBuilder;
+import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.protocol.framework.ReconnectStrategy;
public class NetconfClientConfigurationTest {
import java.util.concurrent.Future;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
import org.opendaylight.netconf.client.conf.NetconfReconnectingClientConfiguration;
import org.opendaylight.netconf.client.conf.NetconfReconnectingClientConfigurationBuilder;
+import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.protocol.framework.ReconnectStrategy;
import org.opendaylight.protocol.framework.ReconnectStrategyFactory;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.client.conf.NetconfClientConfiguration;
import org.opendaylight.netconf.client.conf.NetconfReconnectingClientConfiguration;
import org.opendaylight.netconf.client.conf.NetconfReconnectingClientConfigurationBuilder;
+import org.opendaylight.netconf.nettyutil.handler.ssh.authentication.AuthenticationHandler;
import org.opendaylight.protocol.framework.ReconnectStrategy;
import org.opendaylight.protocol.framework.ReconnectStrategyFactory;
import org.mockito.internal.util.collections.Sets;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
public class SimpleNetconfClientSessionListenerTest {
import static org.mockito.MockitoAnnotations.initMocks;
import com.google.common.collect.Lists;
-import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import io.netty.channel.socket.SocketChannel;
import io.netty.util.concurrent.Promise;
import java.net.InetSocketAddress;
-import org.opendaylight.netconf.nettyutil.AbstractChannelInitializer;
import org.opendaylight.netconf.api.NetconfServerDispatcher;
import org.opendaylight.netconf.impl.util.DeserializerExceptionHandler;
+import org.opendaylight.netconf.nettyutil.AbstractChannelInitializer;
import org.opendaylight.protocol.framework.AbstractDispatcher;
public class NetconfServerDispatcherImpl extends AbstractDispatcher<NetconfServerSession, NetconfServerSessionListener> implements NetconfServerDispatcher {
import java.net.SocketAddress;
import java.util.AbstractMap;
import java.util.Map;
-import org.opendaylight.netconf.nettyutil.AbstractNetconfSessionNegotiator;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.netconf.api.NetconfServerSessionPreferences;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
+import org.opendaylight.netconf.nettyutil.AbstractNetconfSessionNegotiator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.controller.config.util.xml.DocumentedException;
import org.opendaylight.controller.config.util.xml.XmlElement;
import org.opendaylight.controller.config.util.xml.XmlUtil;
-import org.opendaylight.netconf.util.mapping.AbstractSingletonNetconfOperation;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.impl.NetconfServerSession;
+import org.opendaylight.netconf.util.mapping.AbstractSingletonNetconfOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import java.util.Map;
import java.util.Set;
import org.opendaylight.controller.config.util.capability.Capability;
+import org.opendaylight.netconf.api.monitoring.CapabilityListener;
import org.opendaylight.netconf.mapping.api.NetconfOperation;
import org.opendaylight.netconf.mapping.api.NetconfOperationService;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener;
import org.opendaylight.netconf.util.CloseableUtil;
-import org.opendaylight.netconf.api.monitoring.CapabilityListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.util.osgi.NetconfConfiguration;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
*/
package org.opendaylight.netconf.impl.osgi;
+import org.opendaylight.netconf.api.util.NetconfConstants;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener;
-import org.opendaylight.netconf.api.util.NetconfConstants;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.util.tracker.ServiceTracker;
import static com.google.common.base.Preconditions.checkNotNull;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
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.api.monitoring.SessionEvent;
-import org.opendaylight.netconf.api.monitoring.SessionListener;
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.monitoring.SessionEvent;
+import org.opendaylight.netconf.api.monitoring.SessionListener;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.NetconfClientDispatcherImpl;
import static org.junit.Assert.assertNotNull;
import org.junit.Test;
-import org.opendaylight.netconf.util.test.XmlFileLoader;
import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.netconf.util.test.XmlFileLoader;
public class ExiEncodeDecodeTest {
@Test
import org.opendaylight.controller.config.util.xml.DocumentedException;
import org.opendaylight.controller.config.util.xml.XmlElement;
import org.opendaylight.controller.config.util.xml.XmlUtil;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.NetconfTerminationReason;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.impl.NetconfServerSession;
import org.opendaylight.netconf.impl.NetconfServerSessionListener;
import org.w3c.dom.Document;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.opendaylight.netconf.api.util.NetconfConstants;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory;
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener;
-import org.opendaylight.netconf.api.util.NetconfConstants;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Filter;
import org.osgi.framework.ServiceReference;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
import org.opendaylight.netconf.client.NetconfClientDispatcherImpl;
import org.opendaylight.netconf.client.TestingNetconfClient;
+import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.netconf.test.tool.Main.Params;
import org.opendaylight.netconf.test.tool.NetconfDeviceSimulator;
import org.opendaylight.netconf.util.test.XmlFileLoader;
-import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCommunicator;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.config.util.xml.XmlUtil;
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService;
-import org.opendaylight.netconf.api.monitoring.SessionListener;
import org.opendaylight.netconf.monitoring.xml.model.NetconfState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Host;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import io.netty.channel.Channel;
import io.netty.util.concurrent.Promise;
-import org.opendaylight.netconf.util.messages.FramingMechanism;
import org.opendaylight.netconf.api.NetconfSession;
import org.opendaylight.netconf.nettyutil.handler.FramingMechanismHandlerFactory;
import org.opendaylight.netconf.nettyutil.handler.NetconfEOMAggregator;
import org.opendaylight.netconf.nettyutil.handler.NetconfHelloMessageToXMLEncoder;
import org.opendaylight.netconf.nettyutil.handler.NetconfXMLToHelloMessageDecoder;
+import org.opendaylight.netconf.util.messages.FramingMechanism;
public abstract class AbstractChannelInitializer<S extends NetconfSession> {
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import javax.xml.transform.TransformerException;
+import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
-import org.opendaylight.netconf.api.NetconfMessage;
/**
* Customized NetconfMessageToXMLEncoder that serializes additional header with
import java.util.Arrays;
import java.util.List;
import org.opendaylight.controller.config.util.xml.XmlUtil;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.api.NetconfDocumentedException;
import org.opendaylight.netconf.api.NetconfMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.openexi.proc.common.EXIOptions;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
/**
* Start-exi netconf message.
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.controller.config.util.xml.XmlUtil;
+import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.messages.NetconfHelloMessage;
import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
-import org.opendaylight.netconf.api.NetconfMessage;
public class NetconfHelloMessageToXMLEncoderTest {
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
-import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.apache.sshd.common.io.IoInputStream;
import org.apache.sshd.common.io.IoOutputStream;
import org.apache.sshd.server.ExitCallback;
+import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.opendaylight.netconf.nettyutil.handler.ssh.client.AsyncSshHandlerReader;
import org.opendaylight.netconf.nettyutil.handler.ssh.client.AsyncSshHandlerWriter;
-import org.opendaylight.netconf.api.messages.NetconfHelloMessageAdditionalHeader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import java.net.InetSocketAddress;
-import org.opendaylight.netconf.util.osgi.NetconfConfigUtil;
import org.opendaylight.netconf.util.osgi.NetconfConfiguration;
public class ProxyServer implements Runnable {
import org.opendaylight.netconf.auth.AuthProvider;
import org.opendaylight.netconf.ssh.SshProxyServer;
import org.opendaylight.netconf.ssh.SshProxyServerConfigurationBuilder;
-import org.opendaylight.netconf.util.osgi.NetconfConfigUtil;
import org.opendaylight.netconf.util.osgi.NetconfConfiguration;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceListener;
<dependencies>
<dependency>
- <groupId>org.opendaylight.mdsal.model</groupId>
- <artifactId>ietf-topology</artifactId>
+ <groupId>com.typesafe.akka</groupId>
+ <artifactId>akka-actor_${scala.version}</artifactId>
</dependency>
<dependency>
<groupId>com.typesafe.akka</groupId>
- <artifactId>akka-actor_2.11</artifactId>
+ <artifactId>akka-cluster_${scala.version}</artifactId>
</dependency>
+
<dependency>
- <groupId>org.opendaylight.netconf</groupId>
- <artifactId>sal-netconf-connector</artifactId>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-codec-xml</artifactId>
</dependency>
<dependency>
- <groupId>com.typesafe.akka</groupId>
- <artifactId>akka-cluster_2.11</artifactId>
+ <groupId>org.opendaylight.netconf</groupId>
+ <artifactId>sal-netconf-connector</artifactId>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<groupId>org.opendaylight.mdsal</groupId>
<artifactId>mdsal-singleton-common-api</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal.model</groupId>
+ <artifactId>ietf-topology</artifactId>
+ </dependency>
+
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
- <scope>test</scope>
</dependency>
<dependency>
<groupId>com.typesafe.akka</groupId>
- <artifactId>akka-testkit_2.11</artifactId>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-data-codec-xml</artifactId>
+ <artifactId>akka-testkit_${scala.version}</artifactId>
</dependency>
</dependencies>
/**
* Provides API for all operations of read and write transactions
*/
+// TODO we should separate between read tx and write tx
public interface NetconfDOMTransaction {
+
+ /**
+ * Opens a new transaction. Transactions have to be opened before applying
+ * any operations on them. Previous transaction has to be either submitted
+ * ({@link #submit()} was invoked) or canceled ({@link #cancel()} was
+ * invoked.
+ *
+ * @throws IllegalStateException
+ * if the previous transaction was not SUBMITTED or CANCELLED.
+ */
+ void openTransaction();
+
/**
* Read data from particular data-store
* @param store data-store type
*/
public interface RemoteOperationTxProcessor {
+ /**
+ * Opens a new transaction.
+ */
+ void doOpenTransaction(ActorRef recipient, ActorRef sender);
+
/**
* Delete node in particular data-store in path
* @param store data-store type
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.api.NetconfDOMTransaction;
import org.opendaylight.netconf.topology.singleton.impl.tx.NetconfMasterDOMTransaction;
+import org.opendaylight.netconf.topology.singleton.impl.tx.NetconfProxyDOMTransaction;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils;
import org.opendaylight.netconf.topology.singleton.messages.CreateInitialMasterActorData;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
new NetconfMasterDOMTransaction(id, remoteSchemaContext, deviceRpc, netconfSessionPreferences);
deviceDataBroker =
new NetconfDOMDataBroker(actorSystem, id, masterDOMTransactions);
+ // We need to create NetconfProxyDOMTransaction so accessing mountpoint
+ // on leader node would be same as on follower node
+ final NetconfDOMTransaction proxyDOMTransation =
+ new NetconfProxyDOMTransaction(id, actorSystem, masterActorRef);
+ final NetconfDOMDataBroker proxyDataBroker = new NetconfDOMDataBroker(actorSystem, id, proxyDOMTransation);
salProvider.getMountInstance()
- .onTopologyDeviceConnected(remoteSchemaContext, deviceDataBroker, deviceRpc, notificationService);
+ .onTopologyDeviceConnected(remoteSchemaContext, proxyDataBroker, deviceRpc, notificationService);
}
private Future<Object> sendInitialDataToActor() {
package org.opendaylight.netconf.topology.singleton.impl;
import akka.actor.ActorRef;
+import akka.actor.Status;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
private DOMDataWriteTransaction writeTx;
private DOMDataReadOnlyTransaction readTx;
+ private ActorRef currentUser = null;
+
public RemoteOperationTxProcessorImpl(final DOMDataBroker dataBroker, final RemoteDeviceId id) {
this.dataBroker = dataBroker;
this.id = id;
this.readTx = dataBroker.newReadOnlyTransaction();
}
+ @Override
+ public void doOpenTransaction(ActorRef recipient, ActorRef sender) {
+ if (currentUser != null) {
+ LOG.error("{}: Opening a new transaction for {} failed.", id, recipient);
+ recipient.tell(new Status.Failure(
+ new IllegalStateException("Transaction is already opened for another user")), recipient);
+ return;
+ }
+
+ LOG.debug("{}: Opening a new transaction for {}", id, recipient);
+ currentUser = recipient;
+ recipient.tell(new Status.Success(null), sender);
+ }
+
@Override
public void doDelete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
if (writeTx == null) {
@Override
public void doSubmit(final ActorRef recipient, final ActorRef sender) {
+ currentUser = null;
if (writeTx != null) {
CheckedFuture<Void, TransactionCommitFailedException> submitFuture = writeTx.submit();
Futures.addCallback(submitFuture, new FutureCallback<Void>() {
@Override
public void doCancel(final ActorRef recipient, final ActorRef sender) {
+ currentUser = null;
boolean cancel = false;
if (writeTx != null) {
cancel = writeTx.cancel();
}
recipient.tell(cancel, sender);
+
}
@Override
@Override
public void close() throws Exception {
+ currentUser = null;
if (readTx != null) {
readTx.close();
}
import org.opendaylight.netconf.topology.singleton.messages.transactions.EmptyResultResponse;
import org.opendaylight.netconf.topology.singleton.messages.transactions.ExistsRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.MergeRequest;
+import org.opendaylight.netconf.topology.singleton.messages.transactions.OpenTransaction;
import org.opendaylight.netconf.topology.singleton.messages.transactions.PutRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.ReadRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.SubmitRequest;
}
private void resolveProxyCalls(final Object message, final ActorRef recipient, final ActorRef futureSender) {
- if (message instanceof ReadRequest) {
+ if (message instanceof OpenTransaction) {
+ operationsProcessor.doOpenTransaction(recipient, futureSender);
+ } else if (message instanceof ReadRequest) {
final ReadRequest readRequest = (ReadRequest) message;
operationsProcessor.doRead(readRequest.getStore(), readRequest.getPath(), recipient, futureSender);
package org.opendaylight.netconf.topology.singleton.impl.tx;
import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
readTx = delegateBroker.newReadOnlyTransaction();
}
+ @Override
+ public void openTransaction() {
+ // TODO We don't have to do anything here since
+ // NetconfProxyDOMTransactions and RemoteOperationTxProcessor do all
+ // the work regarding opening transactions. But maybe we should check
+ // for open transaction here instead in RemoteOperationTxProcessor
+ }
+
@Override
public Future<Optional<NormalizedNodeMessage>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
import akka.dispatch.OnComplete;
import akka.pattern.Patterns;
import com.google.common.base.Optional;
+import com.google.common.base.Throwables;
import org.opendaylight.controller.config.util.xml.DocumentedException;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.netconf.topology.singleton.messages.transactions.EmptyReadResponse;
import org.opendaylight.netconf.topology.singleton.messages.transactions.ExistsRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.MergeRequest;
+import org.opendaylight.netconf.topology.singleton.messages.transactions.OpenTransaction;
import org.opendaylight.netconf.topology.singleton.messages.transactions.PutRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.ReadRequest;
import org.opendaylight.netconf.topology.singleton.messages.transactions.SubmitFailedReply;
this.masterContextRef = masterContextRef;
}
+ @Override
+ public void openTransaction() {
+ // TODO we can do some checking for already opened transaction also
+ // here in this class. We can track open transaction at least for this
+ // node.
+ LOG.debug("{}: Requesting leader {} to open new transaction", id, masterContextRef);
+ final Future<Object> openTxFuture =
+ Patterns.ask(masterContextRef, new OpenTransaction(), NetconfTopologyUtils.TIMEOUT);
+ try {
+ // we have to wait here so we can see if tx can be opened
+ Await.result(openTxFuture, NetconfTopologyUtils.TIMEOUT.duration());
+ LOG.debug("{}: New transaction opened successfully", id);
+ } catch (final Exception e) {
+ LOG.error("{}: Failed to open new transaction", id, e);
+ Throwables.propagate(e);
+ }
+ }
+
@Override
public Future<Optional<NormalizedNodeMessage>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
this.id = id;
this.delegate = delegate;
this.actorSystem = actorSystem;
+
+ this.delegate.openTransaction();
}
@Override
package org.opendaylight.netconf.topology.singleton.impl.utils;
-import akka.cluster.Member;
import akka.util.Timeout;
import java.io.File;
import java.math.BigDecimal;
--- /dev/null
+/*
+ * Copyright (c) 2017 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.topology.singleton.messages.transactions;
+
+/**
+ * A message sent to MountPoint leader to open new transaction
+ */
+public class OpenTransaction implements TransactionRequest {
+ private static final long serialVersionUID = 1L;
+}
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
// Test of invoking put on master through slave proxy
doNothing().when(writeTx).put(storeType, instanceIdentifier, testNode);
- slaveDataBroker.newWriteOnlyTransaction().put(storeType, instanceIdentifier, testNode);
+
+ DOMDataWriteTransaction wTx = slaveDataBroker.newWriteOnlyTransaction();
+ wTx.put(storeType, instanceIdentifier, testNode);
verify(writeTx, times(1)).put(storeType, instanceIdentifier, testNode);
+ wTx.cancel();
// Test of invoking merge on master through slave proxy
doNothing().when(writeTx).merge(storeType, instanceIdentifier, testNode);
- slaveDataBroker.newWriteOnlyTransaction().merge(storeType, instanceIdentifier, testNode);
+ wTx = slaveDataBroker.newWriteOnlyTransaction();
+ wTx.merge(storeType, instanceIdentifier, testNode);
verify(writeTx, times(1)).merge(storeType, instanceIdentifier, testNode);
+ wTx.cancel();
// Test of invoking delete on master through slave proxy
doNothing().when(writeTx).delete(storeType, instanceIdentifier);
- slaveDataBroker.newWriteOnlyTransaction().delete(storeType, instanceIdentifier);
+ wTx = slaveDataBroker.newWriteOnlyTransaction();
+ wTx.delete(storeType, instanceIdentifier);
+ wTx.cancel();
verify(writeTx, times(1)).delete(storeType, instanceIdentifier);
// Without Tx
+ DOMDataWriteTransaction wTx = slaveDataBroker.newWriteOnlyTransaction();
final CheckedFuture<Void,TransactionCommitFailedException> resultSubmit = Futures.immediateCheckedFuture(null);
doReturn(resultSubmit).when(writeTx).submit();
- final CheckedFuture<Void, TransactionCommitFailedException> resultSubmitResponse =
- slaveDataBroker.newWriteOnlyTransaction().submit();
+ final CheckedFuture<Void, TransactionCommitFailedException> resultSubmitResponse = wTx.submit();
- final Object result= resultSubmitResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
+ final Object result = resultSubmitResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
assertNull(result);
// With Tx
-
+ wTx = slaveDataBroker.newWriteOnlyTransaction();
doNothing().when(writeTx).delete(any(), any());
- slaveDataBroker.newWriteOnlyTransaction().delete(LogicalDatastoreType.CONFIGURATION,
+ wTx.delete(LogicalDatastoreType.CONFIGURATION,
YangInstanceIdentifier.EMPTY);
final CheckedFuture<Void,TransactionCommitFailedException> resultSubmitTx = Futures.immediateCheckedFuture(null);
doReturn(resultSubmitTx).when(writeTx).submit();
- final CheckedFuture<Void, TransactionCommitFailedException> resultSubmitTxResponse =
- slaveDataBroker.newWriteOnlyTransaction().submit();
+ final CheckedFuture<Void, TransactionCommitFailedException> resultSubmitTxResponse = wTx.submit();
final Object resultTx = resultSubmitTxResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
assertNull(resultTx);
- slaveDataBroker.newWriteOnlyTransaction().delete(LogicalDatastoreType.CONFIGURATION,
+ wTx = slaveDataBroker.newWriteOnlyTransaction();
+ wTx.delete(LogicalDatastoreType.CONFIGURATION,
YangInstanceIdentifier.EMPTY);
final TransactionCommitFailedException throwable = new TransactionCommitFailedException("Fail", null);
doReturn(resultThrowable).when(writeTx).submit();
final CheckedFuture<Void, TransactionCommitFailedException> resultThrowableResponse =
- slaveDataBroker.newWriteOnlyTransaction().submit();
+ wTx.submit();
exception.expect(TransactionCommitFailedException.class);
resultThrowableResponse.checkedGet(TIMEOUT_SEC, TimeUnit.SECONDS);
// Without Tx
- final Boolean resultFalseNoTx = slaveDataBroker.newWriteOnlyTransaction().cancel();
+ DOMDataWriteTransaction wTx = slaveDataBroker.newWriteOnlyTransaction();
+ final Boolean resultFalseNoTx = wTx.cancel();
assertEquals(false, resultFalseNoTx);
// With Tx, readWriteTx test
+ wTx = slaveDataBroker.newWriteOnlyTransaction();
doNothing().when(writeTx).delete(any(), any());
- slaveDataBroker.newReadWriteTransaction().delete(LogicalDatastoreType.CONFIGURATION,
+ wTx.delete(LogicalDatastoreType.CONFIGURATION,
YangInstanceIdentifier.EMPTY);
doReturn(true).when(writeTx).cancel();
-
- final Boolean resultTrue = slaveDataBroker.newWriteOnlyTransaction().cancel();
+ final Boolean resultTrue = wTx.cancel();
assertEquals(true, resultTrue);
doReturn(false).when(writeTx).cancel();
- final Boolean resultFalse = slaveDataBroker.newWriteOnlyTransaction().cancel();
+ final Boolean resultFalse = wTx.cancel();
assertEquals(false, resultFalse);
}
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
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;
-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.NodeKey;
import org.opendaylight.yangtools.yang.binding.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
package org.opendaylight.netconf.util.messages;
import com.google.common.base.Optional;
-import java.io.IOException;
import java.util.Map;
import org.opendaylight.controller.config.util.xml.DocumentedException;
import org.opendaylight.controller.config.util.xml.XmlElement;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
-import org.xml.sax.SAXException;
/**
* See <a href="http://tools.ietf.org/html/rfc6241#section-6">rfc6241</a> for details.
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
-import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.osgi.framework.BundleContext;
import org.osgi.framework.InvalidSyntaxException;
package org.opendaylight.netconf.util.osgi;
-import io.netty.channel.local.LocalAddress;
import java.net.InetSocketAddress;
import java.util.Dictionary;
import java.util.Hashtable;
package org.opendaylight.netconf.sal.connect.api;
import java.util.Set;
-import org.opendaylight.netconf.sal.connect.netconf.NetconfStateSchemas;
-import org.opendaylight.netconf.sal.connect.util.RemoteDeviceId;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
-import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
public interface NetconfDeviceSchemas {
package org.opendaylight.netconf.sal.connect.netconf.sal;
import com.google.common.base.Preconditions;
-
import java.util.Collection;
import java.util.Collections;
-
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
/**
* Invokes RPC by sending netconf message via listener. Also transforms result from NetconfMessage to CompositeNode.
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import java.util.concurrent.ExecutionException;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
@Override
public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> data = read(store, path);
-
- try {
- return Futures.immediateCheckedFuture(data.get().isPresent());
- } catch (InterruptedException | ExecutionException e) {
- return Futures.immediateFailedCheckedFuture(new ReadFailedException("Exists failed",e));
- }
+ final ListenableFuture<Boolean> result =
+ Futures.transform(data, (Optional<NormalizedNode<?, ?>> a) -> a != null && a.isPresent());
+ return MappingCheckedFuture.create(result, ReadFailedException.MAPPER);
}
@Override
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import java.util.concurrent.ExecutionException;
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
@Override public CheckedFuture<Boolean, ReadFailedException> exists(
final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException>
- data = read(store, path);
-
- try {
- return Futures.immediateCheckedFuture(data.get().isPresent());
- } catch (InterruptedException | ExecutionException e) {
- return Futures.immediateFailedCheckedFuture(new ReadFailedException("Exists failed",e));
- }
+ return delegateReadTx.exists(store, path);
}
@Override
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 static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.stripNotification;
import static org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil.toPath;
import com.google.common.base.Function;
import static org.mockito.Mockito.verify;
import com.google.common.collect.Lists;
-import java.lang.reflect.Field;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Collection;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.same;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.verify;
import static org.opendaylight.netconf.api.xml.XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0;
+
import com.google.common.base.CharMatcher;
import com.google.common.base.Strings;
import com.google.common.collect.Sets;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
+import com.google.common.util.concurrent.Futures;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
-
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import com.google.common.util.concurrent.Futures;
-
public class KeepaliveSalFacadeTest {
private static final RemoteDeviceId REMOTE_DEVICE_ID = new RemoteDeviceId("test", new InetSocketAddress("localhost", 22));
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import org.junit.Assert;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public class ReadWriteTxTest {
@Mock
@Test
public void exists() throws Exception {
final YangInstanceIdentifier id = TxTestUtils.getContainerId();
- final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> resultFuture =
- Futures.immediateCheckedFuture(Optional.of(TxTestUtils.getContainerNode()));
- when(delegateReadTx.read(LogicalDatastoreType.CONFIGURATION, id)).thenReturn(resultFuture);
+ final CheckedFuture<Boolean, ReadFailedException> resultFuture =
+ Futures.immediateCheckedFuture(true);
+ when(delegateReadTx.exists(LogicalDatastoreType.CONFIGURATION, id)).thenReturn(resultFuture);
final CheckedFuture<Boolean, ReadFailedException> exists = tx.exists(LogicalDatastoreType.CONFIGURATION, id);
Assert.assertTrue(exists.get());
}
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
+
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import static org.opendaylight.netconf.cli.io.IOUtil.isSkipInput;
import static org.opendaylight.netconf.cli.io.IOUtil.listType;
+
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.collect.BiMap;
package org.opendaylight.netconf.test.tool;
-import com.ning.http.client.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
+import com.ning.http.client.AsyncCompletionHandler;
+import com.ning.http.client.AsyncHttpClient;
+import com.ning.http.client.AsyncHttpClientConfig;
+import com.ning.http.client.HttpResponseStatus;
+import com.ning.http.client.ListenableFuture;
+import com.ning.http.client.Realm;
+import com.ning.http.client.Request;
+import com.ning.http.client.Response;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Semaphore;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Execution implements Callable<Void> {
import com.google.common.io.Files;
import java.io.File;
import java.io.FileFilter;
-import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
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 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;
package org.opendaylight.netconf.test.tool.rpc;
import com.google.common.base.Optional;
-
import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
-
import org.opendaylight.controller.config.util.xml.DocumentedException;
import org.opendaylight.controller.config.util.xml.XmlElement;
import org.opendaylight.controller.config.util.xml.XmlUtil;
import java.util.Set;
import javax.ws.rs.core.Application;
import org.opendaylight.yanglib.api.YangLibRestAppService;
-import org.opendaylight.yanglib.api.YangLibService;
import org.osgi.framework.FrameworkUtil;
public class YangLibRestApp extends Application implements YangLibRestAppService {
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-import org.opendaylight.netconf.sal.restconf.impl.RestconfDocumentedException;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import java.util.Date;
import java.util.List;
import java.util.Set;
-import org.opendaylight.netconf.sal.restconf.impl.RestconfDocumentedException;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
final RpcServiceHandler rpcServiceHandler, final NotificationServiceHandler notificationServiceHandler) {
this.delegRestOpsService = new RestconfOperationsServiceImpl(schemaCtxHandler, domMountPointServiceHandler);
this.delegRestSchService = new RestconfSchemaServiceImpl(schemaCtxHandler, domMountPointServiceHandler);
+ this.delegRestconfSubscrService = new RestconfStreamsSubscriptionServiceImpl(domDataBrokerHandler,
+ notificationServiceHandler, schemaCtxHandler, transactionChainHandler);
this.delegRestconfDataService =
- new RestconfDataServiceImpl(schemaCtxHandler, transactionChainHandler, domMountPointServiceHandler);
+ new RestconfDataServiceImpl(schemaCtxHandler, transactionChainHandler, domMountPointServiceHandler,
+ this.delegRestconfSubscrService);
this.delegRestconfInvokeOpsService =
new RestconfInvokeOperationsServiceImpl(rpcServiceHandler, schemaCtxHandler);
- this.delegRestconfSubscrService = new RestconfStreamsSubscriptionServiceImpl(domDataBrokerHandler,
- notificationServiceHandler, schemaCtxHandler, transactionChainHandler);
this.delegRestService = new RestconfImpl(schemaCtxHandler);
}
}
*/
package org.opendaylight.restconf.restful.services.impl;
+import static org.opendaylight.restconf.restful.utils.RestconfStreamsConstants.CREATE_NOTIFICATION_STREAM;
+import static org.opendaylight.restconf.restful.utils.RestconfStreamsConstants.STREAM_ACCESS_PATH_PART;
+import static org.opendaylight.restconf.restful.utils.RestconfStreamsConstants.STREAM_LOCATION_PATH_PART;
+import static org.opendaylight.restconf.restful.utils.RestconfStreamsConstants.STREAM_PATH;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.text.SimpleDateFormat;
import org.opendaylight.restconf.handlers.SchemaContextHandler;
import org.opendaylight.restconf.handlers.TransactionChainHandler;
import org.opendaylight.restconf.restful.services.api.RestconfDataService;
+import org.opendaylight.restconf.restful.services.api.RestconfStreamsSubscriptionService;
import org.opendaylight.restconf.restful.transaction.TransactionVarsWrapper;
import org.opendaylight.restconf.restful.utils.DeleteDataTransactionUtil;
import org.opendaylight.restconf.restful.utils.PatchDataTransactionUtil;
import org.opendaylight.restconf.restful.utils.PutDataTransactionUtil;
import org.opendaylight.restconf.restful.utils.ReadDataTransactionUtil;
import org.opendaylight.restconf.restful.utils.RestconfDataServiceConstant;
+import org.opendaylight.restconf.utils.RestconfConstants;
import org.opendaylight.restconf.utils.parser.ParserIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
private final TransactionChainHandler transactionChainHandler;
private final DOMMountPointServiceHandler mountPointServiceHandler;
+ private final RestconfStreamsSubscriptionService delegRestconfSubscrService;
+
public RestconfDataServiceImpl(final SchemaContextHandler schemaContextHandler,
final TransactionChainHandler transactionChainHandler,
- final DOMMountPointServiceHandler mountPointServiceHandler) {
+ final DOMMountPointServiceHandler mountPointServiceHandler,
+ final RestconfStreamsSubscriptionService delegRestconfSubscrService) {
this.schemaContextHandler = schemaContextHandler;
this.transactionChainHandler = transactionChainHandler;
this.mountPointServiceHandler = mountPointServiceHandler;
+ this.delegRestconfSubscrService = delegRestconfSubscrService;
}
@Override
final TransactionVarsWrapper transactionNode = new TransactionVarsWrapper(
instanceIdentifier, mountPoint, transactionChain);
final NormalizedNode<?, ?> node =
- ReadDataTransactionUtil.readData(parameters.getContent(), transactionNode, withDefa);
+ ReadDataTransactionUtil.readData(identifier, parameters.getContent(), transactionNode, withDefa,
+ schemaContextRef, uriInfo);
+ if (identifier.contains(STREAM_PATH) && identifier.contains(STREAM_ACCESS_PATH_PART)
+ && identifier.contains(STREAM_LOCATION_PATH_PART)) {
+ final String value = (String) node.getValue();
+ final String streamName = value.substring(
+ value.indexOf(CREATE_NOTIFICATION_STREAM.toString() + RestconfConstants.SLASH),
+ value.length());
+ this.delegRestconfSubscrService.subscribeToStream(streamName, uriInfo);
+ }
if (node == null) {
throw new RestconfDocumentedException(
"Request could not be completed because the relevant data model content does not exist",
if (namespace.toString().equals(RestconfStreamsConstants.SAL_REMOTE_NAMESPACE)) {
if (identifier.contains(RestconfStreamsConstants.CREATE_DATA_SUBSCR)) {
response = CreateStreamUtil.createDataChangeNotifiStream(payload, refSchemaCtx);
- } else if (identifier.contains(RestconfStreamsConstants.CREATE_NOTIFICATION_STREAM)) {
- response = CreateStreamUtil.createYangNotifiStream(payload, refSchemaCtx);
} else {
throw new RestconfDocumentedException("Not supported operation", ErrorType.RPC,
ErrorTag.OPERATION_NOT_SUPPORTED);
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Iterator;
import java.util.List;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netconf.sal.restconf.impl.RestconfDocumentedException;
import org.opendaylight.netconf.sal.restconf.impl.RestconfError.ErrorTag;
import org.opendaylight.netconf.sal.restconf.impl.RestconfError.ErrorType;
+import org.opendaylight.netconf.sal.streams.listeners.NotificationListenerAdapter;
import org.opendaylight.netconf.sal.streams.listeners.Notificator;
import org.opendaylight.restconf.common.references.SchemaContextRef;
import org.opendaylight.restconf.utils.parser.ParserIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.Module;
/**
* Create stream with POST operation via RPC
*
- * @param payload
+ * @param notificatinoDefinition
* - input of RPC
* @param refSchemaCtx
* - schemaContext
+ * @param outputType
* @return {@link DOMRpcResult}
*/
- public static DOMRpcResult createYangNotifiStream(final NormalizedNodeContext payload,
- final SchemaContextRef refSchemaCtx) {
- final ContainerNode data = (ContainerNode) payload.getData();
- LeafSetNode leafSet = null;
- String outputType = "XML";
- for (final DataContainerChild<? extends PathArgument, ?> dataChild : data.getValue()) {
- if (dataChild instanceof LeafSetNode) {
- leafSet = (LeafSetNode) dataChild;
- } else if (dataChild instanceof AugmentationNode) {
- outputType = (String) (((AugmentationNode) dataChild).getValue()).iterator().next().getValue();
- }
- }
-
- final Collection<LeafSetEntryNode> entryNodes = leafSet.getValue();
+ public static List<NotificationListenerAdapter> createYangNotifiStream(
+ final NotificationDefinition notificatinoDefinition, final SchemaContextRef refSchemaCtx,
+ final String outputType) {
final List<SchemaPath> paths = new ArrayList<>();
String streamName = RestconfStreamsConstants.CREATE_NOTIFICATION_STREAM + "/";
-
- final Iterator<LeafSetEntryNode> iterator = entryNodes.iterator();
- while (iterator.hasNext()) {
- final QName valueQName = QName.create((String) iterator.next().getValue());
- final Module module = refSchemaCtx.findModuleByNamespaceAndRevision(valueQName.getModule().getNamespace(),
- valueQName.getModule().getRevision());
- Preconditions.checkNotNull(module,
- "Module for namespace " + valueQName.getModule().getNamespace() + " does not exist");
- NotificationDefinition notifiDef = null;
- for (final NotificationDefinition notification : module.getNotifications()) {
- if (notification.getQName().equals(valueQName)) {
- notifiDef = notification;
- break;
- }
- }
- final String moduleName = module.getName();
- Preconditions.checkNotNull(notifiDef,
- "Notification " + valueQName + "doesn't exist in module " + moduleName);
- paths.add(notifiDef.getPath());
- streamName = streamName + moduleName + ":" + valueQName.getLocalName();
- if (iterator.hasNext()) {
- streamName = streamName + ",";
+ final QName notificatinoDefinitionQName = notificatinoDefinition.getQName();
+ final Module module =
+ refSchemaCtx.findModuleByNamespaceAndRevision(notificatinoDefinitionQName.getModule().getNamespace(),
+ notificatinoDefinitionQName.getModule().getRevision());
+ Preconditions.checkNotNull(module,
+ "Module for namespace " + notificatinoDefinitionQName.getModule().getNamespace() + " does not exist");
+ NotificationDefinition notifiDef = null;
+ for (final NotificationDefinition notification : module.getNotifications()) {
+ if (notification.getQName().equals(notificatinoDefinitionQName)) {
+ notifiDef = notification;
+ break;
}
}
+ final String moduleName = module.getName();
+ Preconditions.checkNotNull(notifiDef,
+ "Notification " + notificatinoDefinitionQName + "doesn't exist in module " + moduleName);
+ paths.add(notifiDef.getPath());
+ streamName = streamName + moduleName + ":" + notificatinoDefinitionQName.getLocalName();
if (outputType.equals("JSON")) {
streamName = streamName + "/JSON";
}
- final QName rpcQName = payload.getInstanceIdentifierContext().getSchemaNode().getQName();
- final QName outputQname = QName.create(rpcQName, "output");
- final QName streamNameQname = QName.create(rpcQName, "notification-stream-identifier");
-
- final ContainerNode output =
- ImmutableContainerNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(outputQname))
- .withChild(ImmutableNodes.leafNode(streamNameQname, streamName)).build();
if (!Notificator.existNotificationListenerFor(streamName)) {
- Notificator.createNotificationListener(paths, streamName, outputType);
+ return Notificator.createNotificationListener(paths, streamName, outputType);
+ } else {
+ final List<NotificationListenerAdapter> notificationListenerFor =
+ Notificator.getNotificationListenerFor(streamName);
+ return SubscribeToStreamUtil.pickSpecificListenerByOutput(notificationListenerFor, outputType);
}
-
- return new DefaultDOMRpcResult(output);
}
}
*/
package org.opendaylight.restconf.restful.utils;
+import static org.opendaylight.restconf.restful.utils.RestconfStreamsConstants.STREAMS_PATH;
+import static org.opendaylight.restconf.restful.utils.RestconfStreamsConstants.STREAM_PATH_PART;
+
import com.google.common.base.Optional;
import com.google.common.primitives.Ints;
import com.google.common.util.concurrent.CheckedFuture;
+import java.net.URI;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import javax.ws.rs.core.UriInfo;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext;
import org.opendaylight.netconf.sal.restconf.impl.RestconfDocumentedException;
import org.opendaylight.netconf.sal.restconf.impl.RestconfError;
import org.opendaylight.netconf.sal.restconf.impl.WriterParameters;
import org.opendaylight.netconf.sal.restconf.impl.WriterParameters.WriterParametersBuilder;
+import org.opendaylight.netconf.sal.streams.listeners.NotificationListenerAdapter;
+import org.opendaylight.restconf.common.references.SchemaContextRef;
import org.opendaylight.restconf.restful.transaction.TransactionVarsWrapper;
+import org.opendaylight.restconf.utils.mapping.RestconfMappingNodeUtil;
import org.opendaylight.restconf.utils.parser.ParserFieldsParameter;
+import org.opendaylight.yang.gen.v1.urn.sal.restconf.event.subscription.rev140708.NotificationOutputTypeGrouping.NotificationOutputType;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
configMap.entrySet().stream().filter(x -> stateMap.containsKey(x.getKey())).forEach(
y -> builder.addChild((T) prepareData(y.getValue(), stateMap.get(y.getKey()))));
}
+
+ /**
+ * Read specific type of data from data store via transaction and if identifier read data from
+ * streams then put streams from actual schema context to datastore.
+ *
+ * @param identifier
+ * - identifier of data to read
+ * @param content
+ * - type of data to read (config, state, all)
+ * @param transactionNode
+ * - {@link TransactionVarsWrapper} - wrapper for variables
+ * @param withDefa
+ * - vaule of with-defaults parameter
+ * @param schemaContextRef
+ * - schema context
+ * @param uriInfo
+ * - uri info
+ * @return {@link NormalizedNode}
+ */
+ public static NormalizedNode<?, ?> readData(final String identifier, final String content,
+ final TransactionVarsWrapper transactionNode, final String withDefa,
+ final SchemaContextRef schemaContextRef, final UriInfo uriInfo) {
+ if (identifier.contains(STREAMS_PATH) && !identifier.contains(STREAM_PATH_PART)) {
+ final DOMDataReadWriteTransaction wTx = transactionNode.getTransactionChain().newReadWriteTransaction();
+ final SchemaContext schemaContext = schemaContextRef.get();
+ final boolean exist = SubscribeToStreamUtil.checkExist(schemaContext, wTx);
+
+ for (final NotificationDefinition notificationDefinition : schemaContextRef.get().getNotifications()) {
+ final List<NotificationListenerAdapter> notifiStreamXML =
+ CreateStreamUtil.createYangNotifiStream(notificationDefinition, schemaContextRef,
+ NotificationOutputType.XML.getName());
+ final List<NotificationListenerAdapter> notifiStreamJSON =
+ CreateStreamUtil.createYangNotifiStream(notificationDefinition, schemaContextRef,
+ NotificationOutputType.JSON.getName());
+ notifiStreamJSON.addAll(notifiStreamXML);
+
+ for (final NotificationListenerAdapter listener : notifiStreamJSON) {
+ final URI uri = SubscribeToStreamUtil.prepareUriByStreamName(uriInfo, listener.getStreamName());
+ final NormalizedNode mapToStreams =
+ RestconfMappingNodeUtil.mapYangNotificationStreamByIetfRestconfMonitoring(
+ listener.getSchemaPath().getLastComponent(), schemaContext.getNotifications(),
+ null, listener.getOutputType(), uri,
+ SubscribeToStreamUtil.getMonitoringModule(schemaContext), exist);
+ SubscribeToStreamUtil.writeDataToDS(schemaContext,
+ listener.getSchemaPath().getLastComponent().getLocalName(), wTx, exist,
+ mapToStreams);
+ }
+ }
+ SubscribeToStreamUtil.submitData(wTx);
+ }
+ return readData(content, transactionNode, withDefa);
+ }
}
public static final CharSequence NOTIFICATION_STREAM = "notification-stream";
public static final CharSequence CREATE_NOTIFICATION_STREAM = "create-" + NOTIFICATION_STREAM;
+ public static final String STREAMS_PATH = "ietf-restconf-monitoring:restconf-state/streams";
+ public static final String STREAM_PATH_PART = "/stream=";
+ public static final String STREAM_PATH = STREAMS_PATH + STREAM_PATH_PART;
+ public static final String STREAM_ACCESS_PATH_PART = "/access=";
+ public static final String STREAM_LOCATION_PATH_PART = "/location";
+
static {
Date eventSubscriptionAugRevision;
try {
import org.opendaylight.restconf.utils.RestconfConstants;
import org.opendaylight.restconf.utils.mapping.RestconfMappingNodeUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DateAndTime;
+import org.opendaylight.yang.gen.v1.urn.sal.restconf.event.subscription.rev140708.NotificationOutputTypeGrouping.NotificationOutputType;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
if (Strings.isNullOrEmpty(streamName)) {
throw new RestconfDocumentedException("Stream name is empty.", ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
- final List<NotificationListenerAdapter> listeners = Notificator.getNotificationListenerFor(streamName);
+ List<NotificationListenerAdapter> listeners = Notificator.getNotificationListenerFor(streamName);
+ if (identifier.contains(RestconfConstants.SLASH + NotificationOutputType.JSON.getName())) {
+ listeners = pickSpecificListenerByOutput(listeners, NotificationOutputType.JSON.getName());
+ } else {
+ listeners = pickSpecificListenerByOutput(listeners, NotificationOutputType.XML.getName());
+ }
if ((listeners == null) || listeners.isEmpty()) {
throw new RestconfDocumentedException("Stream was not found.", ErrorType.PROTOCOL,
ErrorTag.UNKNOWN_ELEMENT);
return uri;
}
+ static List<NotificationListenerAdapter>
+ pickSpecificListenerByOutput(final List<NotificationListenerAdapter> listeners, final String outputType) {
+ for (final NotificationListenerAdapter notificationListenerAdapter : listeners) {
+ if (notificationListenerAdapter.getOutputType().equals(outputType)) {
+ final List<NotificationListenerAdapter> list = new ArrayList<>();
+ list.add(notificationListenerAdapter);
+ return list;
+ }
+ }
+ return listeners;
+ }
+
/**
* Prepare InstanceIdentifierContext for Location leaf
*
}
@SuppressWarnings("rawtypes")
- private static void writeDataToDS(final SchemaContext schemaContext, final String name,
+ static void writeDataToDS(final SchemaContext schemaContext, final String name,
final DOMDataReadWriteTransaction wTx, final boolean exist, final NormalizedNode mapToStreams) {
String pathId = "";
if (exist) {
mapToStreams);
}
- private static void submitData(final DOMDataReadWriteTransaction wTx) {
+ static void submitData(final DOMDataReadWriteTransaction wTx) {
try {
wTx.submit().checkedGet();
} catch (final TransactionCommitFailedException e) {
return result;
}
- private static URI prepareUriByStreamName(final UriInfo uriInfo, final String streamName) {
+ static URI prepareUriByStreamName(final UriInfo uriInfo, final String streamName) {
final int port = SubscribeToStreamUtil.prepareNotificationPort();
final UriBuilder uriBuilder = uriInfo.getAbsolutePathBuilder();
return port;
}
- private static boolean checkExist(final SchemaContext schemaContext, final DOMDataReadWriteTransaction wTx) {
+ static boolean checkExist(final SchemaContext schemaContext, final DOMDataReadWriteTransaction wTx) {
boolean exist;
try {
exist = wTx.exists(LogicalDatastoreType.OPERATIONAL,
}
prepareLeafAndFillEntryBuilder(streamEntry,
listSchema.getDataChildByName(MonitoringModule.LEAF_REPLAY_SUPP_STREAM_QNAME), true);
- prepareLeafAndFillEntryBuilder(streamEntry,
+ if (start != null) {
+ prepareLeafAndFillEntryBuilder(streamEntry,
listSchema.getDataChildByName(MonitoringModule.LEAF_START_TIME_STREAM_QNAME),
new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'XXX").format(start));
+ }
prepareListAndFillEntryBuilder(streamEntry,
(ListSchemaNode) listSchema.getDataChildByName(MonitoringModule.LIST_ACCESS_STREAM_QNAME),
outputType, uri);
*/
package org.opendaylight.restconf.utils.parser;
+import com.google.common.base.Optional;
+import com.google.common.base.Splitter;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
import java.text.ParseException;
import java.util.Date;
import java.util.Iterator;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.base.Splitter;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
/**
* Util class for parsing identifier
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+
import java.lang.reflect.Field;
import java.net.URI;
import java.util.Collections;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
+
import com.google.common.collect.Maps;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+
import com.google.common.collect.Iterables;
import com.google.common.util.concurrent.CheckedFuture;
import java.io.FileNotFoundException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+
import java.io.InputStream;
import javax.ws.rs.core.MediaType;
import org.junit.BeforeClass;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+
import java.io.IOException;
import java.io.InputStream;
import javax.ws.rs.WebApplicationException;
package org.opendaylight.controller.sal.restconf.impl.nn.to.json.test;
import static org.junit.Assert.assertTrue;
+
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import javax.ws.rs.core.MediaType;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
-import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeJsonBodyWriter;
import org.opendaylight.controller.sal.rest.impl.test.providers.AbstractBodyReaderTest;
+import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeJsonBodyWriter;
import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+
import com.google.common.util.concurrent.UncheckedExecutionException;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
package org.opendaylight.controller.sal.restconf.impl.nn.to.json.test;
import static org.junit.Assert.assertTrue;
+
import com.google.common.base.Preconditions;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.controller.md.sal.rest.common.TestRestconfUtils;
-import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeJsonBodyWriter;
import org.opendaylight.controller.sal.rest.impl.test.providers.AbstractBodyReaderTest;
+import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeJsonBodyWriter;
import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+
import com.google.common.collect.Iterables;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import javax.ws.rs.core.MediaType;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
import org.opendaylight.controller.sal.rest.impl.test.providers.AbstractBodyReaderTest;
+import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext;
import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext;
package org.opendaylight.controller.sal.restconf.impl.nn.to.xml.test;
import static org.junit.Assert.assertTrue;
+
import com.google.common.collect.Iterables;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import javax.ws.rs.core.MediaType;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
import org.opendaylight.controller.sal.rest.impl.test.providers.AbstractBodyReaderTest;
+import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext;
import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext;
package org.opendaylight.controller.sal.restconf.impl.nn.to.xml.test;
import static org.junit.Assert.assertTrue;
+
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
import java.io.ByteArrayOutputStream;
import javax.ws.rs.core.MediaType;
import org.junit.BeforeClass;
import org.junit.Test;
-import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
import org.opendaylight.controller.sal.rest.impl.test.providers.AbstractBodyReaderTest;
+import org.opendaylight.netconf.sal.rest.impl.NormalizedNodeXmlBodyWriter;
import org.opendaylight.netconf.sal.restconf.impl.ControllerContext;
import org.opendaylight.netconf.sal.restconf.impl.InstanceIdentifierContext;
import org.opendaylight.netconf.sal.restconf.impl.NormalizedNodeContext;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
+
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.CheckedFuture;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+
import java.io.FileNotFoundException;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+
import java.io.ByteArrayInputStream;
import java.io.FileNotFoundException;
import java.net.URI;
package org.opendaylight.controller.sal.restconf.impl.test;
import static org.junit.Assert.assertTrue;
+
import java.io.FileNotFoundException;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.Application;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
+
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import static org.mockito.Mockito.when;
import static org.opendaylight.controller.sal.restconf.impl.test.RestOperationUtils.JSON;
import static org.opendaylight.controller.sal.restconf.impl.test.RestOperationUtils.XML;
+
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.mock;
+
import org.junit.Test;
import org.opendaylight.netconf.sal.restconf.impl.RestCodec;
import org.opendaylight.yangtools.concepts.Codec;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import java.io.FileNotFoundException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+
import java.io.FileNotFoundException;
import org.junit.BeforeClass;
import org.junit.Rule;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.opendaylight.controller.sal.restconf.impl.test.RestOperationUtils.XML;
+
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.CheckedFuture;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.when;
+
import com.google.common.collect.Maps;
import com.google.common.io.ByteStreams;
import com.google.gson.JsonArray;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil.getRevisionFormat;
+
import com.google.common.base.Preconditions;
import java.io.FileNotFoundException;
import java.text.ParseException;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+
import java.io.FileNotFoundException;
import java.util.Set;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
+
import java.io.FileNotFoundException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
* 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.restconf.restful.services.impl;
import static org.junit.Assert.assertEquals;
import org.opendaylight.restconf.handlers.DOMMountPointServiceHandler;
import org.opendaylight.restconf.handlers.SchemaContextHandler;
import org.opendaylight.restconf.handlers.TransactionChainHandler;
+import org.opendaylight.restconf.restful.services.api.RestconfStreamsSubscriptionService;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
private DOMDataBroker mountDataBroker;
@Mock
private DOMTransactionChain transactionChain;
+ @Mock
+ private RestconfStreamsSubscriptionService delegRestconfSubscrService;
@Before
public void setUp() throws Exception {
final SchemaContextHandler schemaContextHandler = new SchemaContextHandler(txHandler);
schemaContextHandler.onGlobalContextUpdated(this.contextRef.get());
- this.dataService = new RestconfDataServiceImpl(schemaContextHandler, this.transactionChainHandler, this.mountPointServiceHandler);
+ this.dataService = new RestconfDataServiceImpl(schemaContextHandler, this.transactionChainHandler,
+ this.mountPointServiceHandler, this.delegRestconfSubscrService);
doReturn(this.domTransactionChain).when(this.transactionChainHandler).get();
doReturn(this.read).when(this.domTransactionChain).newReadOnlyTransaction();
doReturn(this.readWrite).when(this.domTransactionChain).newReadWriteTransaction();
import org.junit.Test;
import org.opendaylight.netconf.sal.restconf.impl.RestconfDocumentedException;
import org.opendaylight.netconf.sal.restconf.impl.RestconfError;
-import org.opendaylight.restconf.utils.validation.RestconfValidation;
/**
* Unit test for {@link RestconfValidation}
package org.opendaylight.netconf.sal.restconf.broker;
+import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.collect.ImmutableClassToInstanceMap;
import org.opendaylight.controller.md.sal.binding.util.BindingContextUtils;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import static com.google.common.base.Preconditions.checkState;
public class SalRemoteServiceBroker implements BindingAwareBroker,AutoCloseable {
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
-
import javax.annotation.concurrent.ThreadSafe;
-
import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.remote.rev140114.DataChangedNotification;
import org.opendaylight.yangtools.yang.binding.DataObject;
*/
package org.opendaylight.netconf.sal.restconf.broker.impl;
+import com.google.common.base.Optional;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
import org.opendaylight.controller.sal.binding.api.data.DataChangeListener;
import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class DataBrokerServiceImpl implements DataBrokerService {
private static final Logger logger = LoggerFactory.getLogger(DataBrokerServiceImpl.class.toString());
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.controller.sal.binding.api.NotificationListener;
import org.opendaylight.controller.sal.binding.api.NotificationService;
import org.opendaylight.netconf.sal.restconf.broker.listeners.RemoteNotificationListener;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Future;
-
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
Code Review / netconf.git / commitdiff