import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.timeout;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.typesafe.config.ConfigFactory;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.GlobalEventExecutor;
-import io.netty.util.concurrent.SucceededFuture;
import java.io.File;
import java.util.AbstractMap.SimpleEntry;
-import java.util.Collections;
+import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.aaa.encrypt.AAAEncryptionService;
-import org.opendaylight.binding.runtime.spi.BindingRuntimeHelpers;
import org.opendaylight.controller.cluster.ActorSystemProvider;
import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
import org.opendaylight.controller.config.threadpool.ThreadPool;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.api.DataTreeModification;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.binding.api.Transaction;
import org.opendaylight.mdsal.binding.api.TransactionChain;
import org.opendaylight.mdsal.binding.api.TransactionChainListener;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.binding.dom.adapter.test.AbstractConcurrentDataBrokerTest;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
+import org.opendaylight.mdsal.binding.runtime.spi.BindingRuntimeHelpers;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
import org.opendaylight.mdsal.dom.broker.DOMMountPointServiceImpl;
import org.opendaylight.mdsal.dom.broker.DOMRpcRouter;
import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
-import org.opendaylight.mdsal.eos.dom.simple.SimpleDOMEntityOwnershipService;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
import org.opendaylight.mdsal.singleton.dom.impl.DOMClusterSingletonServiceProviderImpl;
import org.opendaylight.netconf.client.NetconfClientDispatcher;
+import org.opendaylight.netconf.nettyutil.ReconnectFuture;
import org.opendaylight.netconf.sal.connect.api.DeviceActionFactory;
import org.opendaylight.netconf.sal.connect.api.SchemaResourceManager;
import org.opendaylight.netconf.sal.connect.impl.DefaultSchemaResourceManager;
import org.opendaylight.netconf.sal.connect.netconf.NetconfDevice.SchemaResourcesDTO;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfSessionPreferences;
+import org.opendaylight.netconf.sal.connect.netconf.util.NetconfMessageTransformUtil;
import org.opendaylight.netconf.topology.singleton.impl.utils.ClusteringRpcException;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologySetup;
import org.opendaylight.netconf.topology.singleton.impl.utils.NetconfTopologyUtils;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
-import org.opendaylight.yangtools.rcf8528.data.util.EmptyMountPointContext;
+import org.opendaylight.yangtools.rfc8528.data.util.EmptyMountPointContext;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+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.parser.impl.YangParserFactoryImpl;
+import org.opendaylight.yangtools.yang.parser.impl.DefaultYangParserFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*
* @author Thomas Pantelis
*/
-@RunWith(MockitoJUnitRunner.class)
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class MountPointEndToEndTest extends AbstractBaseSchemasTest {
private static final Logger LOG = LoggerFactory.getLogger(MountPointEndToEndTest.class);
private static final String TOP_MODULE_NAME = "opendaylight-mdsal-list-test";
private static final String ACTOR_SYSTEM_NAME = "test";
private static final String TOPOLOGY_ID = TopologyNetconf.QNAME.getLocalName();
- private static final NodeId NODE_ID = new NodeId("node-id");
- private static final InstanceIdentifier<Node> NODE_INSTANCE_ID = NetconfTopologyUtils.createTopologyNodeListPath(
- new NodeKey(NODE_ID), TOPOLOGY_ID);
+ private static final KeyedInstanceIdentifier<Node, NodeKey> NODE_INSTANCE_ID =
+ NetconfTopologyUtils.createTopologyNodeListPath(new NodeKey(new NodeId("node-id")), TOPOLOGY_ID);
private static final String TEST_ROOT_DIRECTORY = "test-cache-root";
private static final String TEST_DEFAULT_SUBDIR = "test-schema";
@Mock private DOMRpcProviderService mockRpcProviderRegistry;
+ @Mock private RpcProviderService mockRpcProviderService;
@Mock private DOMActionProviderService mockActionProviderRegistry;
@Mock private NetconfClientDispatcher mockClientDispatcher;
@Mock private AAAEncryptionService mockEncryptionService;
private final Config config = new ConfigBuilder().setWriteTransactionIdleTimeout(Uint16.ZERO).build();
private EffectiveModelContext deviceSchemaContext;
private YangModuleInfo topModuleInfo;
- private SchemaPath putTopRpcSchemaPath;
- private SchemaPath getTopRpcSchemaPath;
+ private QName putTopRpcSchemaPath;
+ private QName getTopRpcSchemaPath;
private BindingNormalizedNodeSerializer bindingToNormalized;
private YangInstanceIdentifier yangNodeInstanceId;
private final TopDOMRpcImplementation topRpcImplementation = new TopDOMRpcImplementation();
private SchemaResourceManager resourceManager;
- @SuppressWarnings({ "unchecked", "rawtypes" })
@Before
public void setUp() throws Exception {
deleteCacheDir();
- resourceManager = new DefaultSchemaResourceManager(new YangParserFactoryImpl(), TEST_ROOT_DIRECTORY,
+ resourceManager = new DefaultSchemaResourceManager(new DefaultYangParserFactory(), TEST_ROOT_DIRECTORY,
TEST_DEFAULT_SUBDIR);
topModuleInfo = BindingReflections.getModuleInfo(Top.class);
deviceRpcService.onModelContextUpdated(deviceSchemaContext);
- putTopRpcSchemaPath = findRpcDefinition("put-top").getPath();
- getTopRpcSchemaPath = findRpcDefinition("get-top").getPath();
+ putTopRpcSchemaPath = findRpcDefinition("put-top").getQName();
+ getTopRpcSchemaPath = findRpcDefinition("get-top").getQName();
deviceRpcService.getRpcProviderService().registerRpcImplementation(topRpcImplementation,
DOMRpcIdentifier.create(putTopRpcSchemaPath), DOMRpcIdentifier.create(getTopRpcSchemaPath));
yangNodeInstanceId = bindingToNormalized.toYangInstanceIdentifier(NODE_INSTANCE_ID);
- doReturn(new SucceededFuture(GlobalEventExecutor.INSTANCE, null)).when(mockClientDispatcher)
- .createReconnectingClient(any());
+ doReturn(mock(ReconnectFuture.class)).when(mockClientDispatcher).createReconnectingClient(any());
LOG.info("****** Setup complete");
}
masterSystem = ActorSystem.create(ACTOR_SYSTEM_NAME, ConfigFactory.load().getConfig("Master"));
- masterClusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(
- new SimpleDOMEntityOwnershipService());
+ masterClusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl();
masterClusterSingletonServiceProvider.initializeProvider();
doReturn(masterSystem).when(mockMasterActorSystemProvider).getActorSystem();
resources.getSchemaRegistry().registerSchemaSource(
id -> Futures.immediateFuture(YangTextSchemaSource.delegateForByteSource(id,
topModuleInfo.getYangTextByteSource())),
- PotentialSchemaSource.create(RevisionSourceIdentifier.create(TOP_MODULE_NAME,
- topModuleInfo.getName().getRevision()), YangTextSchemaSource.class, 1));
+ PotentialSchemaSource.create(new SourceIdentifier(TOP_MODULE_NAME,
+ topModuleInfo.getName().getRevision().map(Revision::toString).orElse(null)),
+ YangTextSchemaSource.class, 1));
masterNetconfTopologyManager = new NetconfTopologyManager(BASE_SCHEMAS, masterDataBroker,
mockRpcProviderRegistry, mockActionProviderRegistry, masterClusterSingletonServiceProvider,
mockKeepaliveExecutor, mockThreadPool, mockMasterActorSystemProvider, eventExecutor,
mockClientDispatcher, TOPOLOGY_ID, config, masterMountPointService, mockEncryptionService,
- deviceActionFactory, resourceManager) {
+ mockRpcProviderService, deviceActionFactory, resourceManager) {
@Override
protected NetconfTopologyContext newNetconfTopologyContext(final NetconfTopologySetup setup,
final ServiceGroupIdentifier serviceGroupIdent, final Timeout actorResponseWaitTime,
slaveNetconfTopologyManager = new NetconfTopologyManager(BASE_SCHEMAS, slaveDataBroker, mockRpcProviderRegistry,
mockActionProviderRegistry, mockSlaveClusterSingletonServiceProvider, mockKeepaliveExecutor, mockThreadPool,
mockSlaveActorSystemProvider, eventExecutor, mockClientDispatcher, TOPOLOGY_ID, config,
- slaveMountPointService, mockEncryptionService, deviceActionFactory, resourceManager) {
+ slaveMountPointService, mockEncryptionService, mockRpcProviderService, deviceActionFactory,
+ resourceManager) {
@Override
protected NetconfTopologyContext newNetconfTopologyContext(final NetconfTopologySetup setup,
final ServiceGroupIdentifier serviceGroupIdent, final Timeout actorResponseWaitTime,
writeNetconfNode(TEST_DEFAULT_SUBDIR, masterDataBroker);
final MasterSalFacade masterSalFacade = masterSalFacadeFuture.get(5, TimeUnit.SECONDS);
+ final ArrayList<String> capabilities = Lists.newArrayList(
+ NetconfMessageTransformUtil.NETCONF_CANDIDATE_URI.toString());
masterSalFacade.onDeviceConnected(new EmptyMountPointContext(deviceSchemaContext),
- NetconfSessionPreferences.fromStrings(Collections.emptyList()), deviceRpcService.getRpcService());
+ NetconfSessionPreferences.fromStrings(capabilities), deviceRpcService.getRpcService());
DOMMountPoint masterMountPoint = awaitMountPoint(masterMountPointService);
verify(masterMountPointListener, timeout(5000)).onMountPointRemoved(yangNodeInstanceId);
MasterSalFacade masterSalFacade = masterSalFacadeFuture.get(5, TimeUnit.SECONDS);
+ final ArrayList<String> capabilities = Lists.newArrayList(
+ NetconfMessageTransformUtil.NETCONF_CANDIDATE_URI.toString());
masterSalFacade.onDeviceConnected(new EmptyMountPointContext(deviceSchemaContext),
- NetconfSessionPreferences.fromStrings(Collections.emptyList()), deviceRpcService.getRpcService());
+ NetconfSessionPreferences.fromStrings(capabilities), deviceRpcService.getRpcService());
verify(masterMountPointListener, timeout(5000)).onMountPointCreated(yangNodeInstanceId);
private void testDOMRpcService(final DOMRpcService domRpcService)
throws InterruptedException, ExecutionException, TimeoutException {
- testPutTopRpc(domRpcService, new DefaultDOMRpcResult((NormalizedNode<?, ?>)null));
+ testPutTopRpc(domRpcService, new DefaultDOMRpcResult((NormalizedNode)null));
testPutTopRpc(domRpcService, null);
testPutTopRpc(domRpcService, new DefaultDOMRpcResult(ImmutableList.of(
- RpcResultBuilder.newError(ErrorType.APPLICATION, "tag1", "error1"),
- RpcResultBuilder.newError(ErrorType.APPLICATION, "tag2", "error2"))));
+ RpcResultBuilder.newError(ErrorType.APPLICATION, new ErrorTag("tag1"), "error1"),
+ RpcResultBuilder.newError(ErrorType.APPLICATION, new ErrorTag("tag2"), "error2"))));
testGetTopRpc(domRpcService, new DefaultDOMRpcResult(bindingToNormalized.toNormalizedNodeRpcData(
new GetTopOutputBuilder().setTopLevelList(oneTopLevelList()).build())));
testRpc(domRpcService, getTopRpcSchemaPath, getTopInput, result);
}
- private void testRpc(final DOMRpcService domRpcService, final SchemaPath schemaPath,
- final NormalizedNode<?, ?> input, final DOMRpcResult result) throws InterruptedException,
- ExecutionException, TimeoutException {
+ private void testRpc(final DOMRpcService domRpcService, final QName qname, final NormalizedNode input,
+ final DOMRpcResult result) throws InterruptedException, ExecutionException, TimeoutException {
final FluentFuture<DOMRpcResult> future = result == null ? FluentFutures.immediateNullFluentFuture()
: FluentFutures.immediateFluentFuture(result);
- final DOMRpcResult actual = invokeRpc(domRpcService, schemaPath, input, future);
+ final DOMRpcResult actual = invokeRpc(domRpcService, qname, input, future);
if (result == null) {
assertNull(actual);
return;
}
}
- private void testFailedRpc(final DOMRpcService domRpcService, final SchemaPath schemaPath,
- final NormalizedNode<?, ?> input) throws InterruptedException, TimeoutException {
+ private void testFailedRpc(final DOMRpcService domRpcService, final QName qname, final NormalizedNode input)
+ throws InterruptedException, TimeoutException {
try {
- invokeRpc(domRpcService, schemaPath, input, FluentFutures.immediateFailedFluentFuture(
+ invokeRpc(domRpcService, qname, input, FluentFutures.immediateFailedFluentFuture(
new ClusteringRpcException("mock")));
fail("Expected exception");
} catch (ExecutionException e) {
}
}
- private DOMRpcResult invokeRpc(final DOMRpcService domRpcService, final SchemaPath schemaPath,
- final NormalizedNode<?, ?> input, final FluentFuture<DOMRpcResult> returnFuture)
- throws InterruptedException, ExecutionException, TimeoutException {
+ private DOMRpcResult invokeRpc(final DOMRpcService domRpcService, final QName qname, final NormalizedNode input,
+ final FluentFuture<DOMRpcResult> returnFuture)
+ throws InterruptedException, ExecutionException, TimeoutException {
topRpcImplementation.init(returnFuture);
- final ListenableFuture<? extends DOMRpcResult> resultFuture = domRpcService.invokeRpc(schemaPath, input);
+ final ListenableFuture<? extends DOMRpcResult> resultFuture = domRpcService.invokeRpc(qname, input);
- topRpcImplementation.verify(DOMRpcIdentifier.create(schemaPath), input);
+ topRpcImplementation.verify(DOMRpcIdentifier.create(qname), input);
return resultFuture.get(5, TimeUnit.SECONDS);
}
private static void writeNetconfNode(final String cacheDir, final DataBroker databroker)
throws InterruptedException, ExecutionException, TimeoutException {
final Node node = new NodeBuilder()
- .setNodeId(NODE_ID)
+ .withKey(NODE_INSTANCE_ID.getKey())
.addAugmentation(new NetconfNodeBuilder()
.setHost(new Host(new IpAddress(new Ipv4Address("127.0.0.1"))))
.setPort(new PortNumber(Uint16.valueOf(1234)))
}
private static void verifyDataInStore(final DOMDataTreeReadOperations readTx, final YangInstanceIdentifier path,
- final NormalizedNode<?, ?> expNode) throws InterruptedException, ExecutionException, TimeoutException {
- final Optional<NormalizedNode<?, ?>> read = readTx.read(LogicalDatastoreType.CONFIGURATION, path)
+ final NormalizedNode expNode) throws InterruptedException, ExecutionException, TimeoutException {
+ final Optional<NormalizedNode> read = readTx.read(LogicalDatastoreType.CONFIGURATION, path)
.get(5, TimeUnit.SECONDS);
assertTrue(read.isPresent());
assertEquals(expNode, read.get());
private void awaitMountPointNotPresent(final DOMMountPointService mountPointService) {
await().atMost(5, TimeUnit.SECONDS).until(
- () -> !mountPointService.getMountPoint(yangNodeInstanceId).isPresent());
+ () -> mountPointService.getMountPoint(yangNodeInstanceId).isEmpty());
}
private static DOMDataBroker getDOMDataBroker(final DOMMountPoint mountPoint) {
}
private static class TopDOMRpcImplementation implements DOMRpcImplementation {
- private volatile SettableFuture<Entry<DOMRpcIdentifier, NormalizedNode<?, ?>>> rpcInvokedFuture;
+ private volatile SettableFuture<Entry<DOMRpcIdentifier, NormalizedNode>> rpcInvokedFuture;
private volatile FluentFuture<DOMRpcResult> returnFuture;
@Override
- public FluentFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc,
- final NormalizedNode<?, ?> input) {
+ public FluentFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final NormalizedNode input) {
rpcInvokedFuture.set(new SimpleEntry<>(rpc, input));
return returnFuture;
}
void init(final FluentFuture<DOMRpcResult> retFuture) {
- this.returnFuture = retFuture;
+ returnFuture = retFuture;
rpcInvokedFuture = SettableFuture.create();
}
- void verify(final DOMRpcIdentifier expRpc, final NormalizedNode<?, ?> expInput)
+ void verify(final DOMRpcIdentifier expRpc, final NormalizedNode expInput)
throws InterruptedException, ExecutionException, TimeoutException {
- final Entry<DOMRpcIdentifier, NormalizedNode<?, ?>> actual = rpcInvokedFuture.get(5, TimeUnit.SECONDS);
+ final Entry<DOMRpcIdentifier, NormalizedNode> actual = rpcInvokedFuture.get(5, TimeUnit.SECONDS);
assertEquals(expRpc, actual.getKey());
assertEquals(expInput, actual.getValue());
}
Code Review / netconf.git / blobdiff