}
}
- private boolean isHostAddressPresent(final Host address) {
+ private static boolean isHostAddressPresent(final Host address) {
return address.getDomainName() != null ||
address.getIpAddress() != null && (address.getIpAddress().getIpv4Address() != null || address.getIpAddress().getIpv6Address() != null);
}
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import io.netty.util.concurrent.Future;
-import io.netty.util.concurrent.FutureListener;
-import io.netty.util.concurrent.GenericFutureListener;
import java.util.ArrayDeque;
import java.util.Iterator;
import java.util.List;
}
- initFuture.addListener(new GenericFutureListener<Future<Object>>(){
-
- @Override
- public void operationComplete(final Future<Object> future) throws Exception {
- if (!future.isSuccess() && !future.isCancelled()) {
- LOG.debug("{}: Connection failed", id, future.cause());
- NetconfDeviceCommunicator.this.remoteDevice.onRemoteSessionFailed(future.cause());
- if (firstConnectionFuture.isDone()) {
- firstConnectionFuture.setException(future.cause());
- }
+ initFuture.addListener(future -> {
+ if (!future.isSuccess() && !future.isCancelled()) {
+ LOG.debug("{}: Connection failed", id, future.cause());
+ NetconfDeviceCommunicator.this.remoteDevice.onRemoteSessionFailed(future.cause());
+ if (firstConnectionFuture.isDone()) {
+ firstConnectionFuture.setException(future.cause());
}
}
});
String.format( "The netconf session to %1$s is disconnected", id.getName() ) );
}
- private RpcResult<NetconfMessage> createErrorRpcResult(final RpcError.ErrorType errorType, final String message) {
+ private static RpcResult<NetconfMessage> createErrorRpcResult(final RpcError.ErrorType errorType,
+ final String message) {
return RpcResultBuilder.<NetconfMessage>failed()
.withError(errorType, NetconfDocumentedException.ErrorTag.OPERATION_FAILED.getTagValue(), message).build();
}
final Request req = new Request(new UncancellableFuture<>(true), message);
requests.add(req);
- session.sendMessage(req.request).addListener(new FutureListener<Void>() {
- @Override
- public void operationComplete(final Future<Void> future) throws Exception {
- if( !future.isSuccess() ) {
- // We expect that a session down will occur at this point
- LOG.debug("{}: Failed to send request {}", id,
- XmlUtil.toString(req.request.getDocument()),
- future.cause());
-
- if( future.cause() != null ) {
- req.future.set( createErrorRpcResult( RpcError.ErrorType.TRANSPORT,
- future.cause().getLocalizedMessage() ) );
- } else {
- req.future.set( createSessionDownRpcResult() ); // assume session is down
- }
- req.future.setException( future.cause() );
- }
- else {
- LOG.trace("Finished sending request {}", req.request);
+ session.sendMessage(req.request).addListener(future -> {
+ if( !future.isSuccess() ) {
+ // We expect that a session down will occur at this point
+ LOG.debug("{}: Failed to send request {}", id,
+ XmlUtil.toString(req.request.getDocument()),
+ future.cause());
+
+ if( future.cause() != null ) {
+ req.future.set( createErrorRpcResult( RpcError.ErrorType.TRANSPORT,
+ future.cause().getLocalizedMessage() ) );
+ } else {
+ req.future.set( createSessionDownRpcResult() ); // assume session is down
}
+ req.future.setException( future.cause() );
+ }
+ else {
+ LOG.trace("Finished sending request {}", req.request);
}
});
public final class NetconfDeviceTopologyAdapter implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(NetconfDeviceTopologyAdapter.class);
- public static final Function<Entry<QName, FailureReason>, UnavailableCapability> UNAVAILABLE_CAPABILITY_TRANSFORMER = new Function<Entry<QName, FailureReason>, UnavailableCapability>() {
- @Override
- public UnavailableCapability apply(final Entry<QName, FailureReason> input) {
- return new UnavailableCapabilityBuilder()
- .setCapability(input.getKey().toString())
- .setFailureReason(input.getValue()).build();
- }
- };
+ public static final Function<Entry<QName, FailureReason>, UnavailableCapability> UNAVAILABLE_CAPABILITY_TRANSFORMER = input -> new UnavailableCapabilityBuilder()
+ .setCapability(input.getKey().toString())
+ .setFailureReason(input.getValue()).build();
private final RemoteDeviceId id;
private BindingTransactionChain txChain;
commitTransaction(writeTx, "init");
}
- public void updateDeviceData(boolean up, NetconfDeviceCapabilities capabilities) {
+ public void updateDeviceData(final boolean up, final NetconfDeviceCapabilities capabilities) {
final NetconfNode data = buildDataForNetconfNode(up, capabilities);
final WriteTransaction writeTx = txChain.newWriteOnlyTransaction();
commitTransaction(writeTx, "update");
}
- public void updateClusteredDeviceData(boolean up, String masterAddress, NetconfDeviceCapabilities capabilities) {
+ public void updateClusteredDeviceData(final boolean up, final String masterAddress, final NetconfDeviceCapabilities capabilities) {
final NetconfNode data = buildDataForNetconfClusteredNode(up, masterAddress, capabilities);
final WriteTransaction writeTx = txChain.newWriteOnlyTransaction();
commitTransaction(writeTx, "update");
}
- public void setDeviceAsFailed(Throwable throwable) {
+ public void setDeviceAsFailed(final Throwable throwable) {
String reason = (throwable != null && throwable.getMessage() != null) ? throwable.getMessage() : UNKNOWN_REASON;
final NetconfNode data = new NetconfNodeBuilder().setConnectionStatus(ConnectionStatus.UnableToConnect).setConnectedMessage(reason).build();
commitTransaction(writeTx, "update-failed-device");
}
- private NetconfNode buildDataForNetconfNode(boolean up, NetconfDeviceCapabilities capabilities) {
+ private NetconfNode buildDataForNetconfNode(final boolean up, final NetconfDeviceCapabilities capabilities) {
List<AvailableCapability> capabilityList = new ArrayList<>();
capabilityList.addAll(capabilities.getNonModuleBasedCapabilities());
capabilityList.addAll(capabilities.getResolvedCapabilities());
return netconfNodeBuilder.build();
}
- private NetconfNode buildDataForNetconfClusteredNode(boolean up, String masterNodeAddress, NetconfDeviceCapabilities capabilities) {
+ private NetconfNode buildDataForNetconfClusteredNode(final boolean up, final String masterNodeAddress, final NetconfDeviceCapabilities capabilities) {
List<AvailableCapability> capabilityList = new ArrayList<>();
capabilityList.addAll(capabilities.getNonModuleBasedCapabilities());
capabilityList.addAll(capabilities.getResolvedCapabilities());
final NetworkTopology networkTopology = new NetworkTopologyBuilder().build();
LOG.trace("{}: Merging {} container to ensure its presence", id,
- networkTopology.QNAME, writeTx.getIdentifier());
+ NetworkTopology.QNAME, writeTx.getIdentifier());
writeTx.merge(LogicalDatastoreType.OPERATIONAL, networkTopologyPath, networkTopology);
final Topology topology = new TopologyBuilder().setTopologyId(new TopologyId(TopologyNetconf.QNAME.getLocalName())).build();
LOG.trace("{}: Merging {} container to ensure its presence", id,
- topology.QNAME, writeTx.getIdentifier());
+ Topology.QNAME, writeTx.getIdentifier());
writeTx.merge(LogicalDatastoreType.OPERATIONAL, topologyListPath, topology);
}
removeDeviceConfiguration();
}
- public void setTxChain(BindingTransactionChain txChain) {
+ public void setTxChain(final BindingTransactionChain txChain) {
this.txChain = Preconditions.checkNotNull(txChain);
}
}
private final SchemalessMessageTransformer schemalessTransformer;
private final RemoteDeviceId deviceId;
- public SchemalessNetconfDeviceRpc(RemoteDeviceId deviceId, final RemoteDeviceCommunicator<NetconfMessage> listener,
+ public SchemalessNetconfDeviceRpc(final RemoteDeviceId deviceId, final RemoteDeviceCommunicator<NetconfMessage> listener,
final BaseRpcSchemalessTransformer baseRpcTransformer,
final SchemalessMessageTransformer messageTransformer) {
this.deviceId = deviceId;
final NetconfMessage netconfMessage = transformer.toRpcRequest(type, input);
final ListenableFuture<RpcResult<NetconfMessage>> rpcResultListenableFuture = listener.sendRequest(netconfMessage, type.getLastComponent());
- final ListenableFuture<DOMRpcResult> transformed = Futures.transform(rpcResultListenableFuture, new Function<RpcResult<NetconfMessage>, DOMRpcResult>() {
- @Override
- public DOMRpcResult apply(final RpcResult<NetconfMessage> input) {
- if (input.isSuccessful()) {
- return transformer.toRpcResult(input.getResult(), type);
- } else {
- return new DefaultDOMRpcResult(input.getErrors());
- }
+ final ListenableFuture<DOMRpcResult> transformed = Futures.transform(rpcResultListenableFuture, (Function<RpcResult<NetconfMessage>, DOMRpcResult>) input1 -> {
+ if (input1.isSuccessful()) {
+ return transformer.toRpcResult(input1.getResult(), type);
+ } else {
+ return new DefaultDOMRpcResult(input1.getErrors());
}
});
}
- private boolean isBaseRpc(final SchemaPath type) {
+ private static boolean isBaseRpc(final SchemaPath type) {
return NetconfMessageTransformUtil.NETCONF_URI.equals(type.getLastComponent().getNamespace());
}
private static final Logger LOG = LoggerFactory.getLogger(NetconfMessageTransformer.class);
- private static final Function<SchemaNode, QName> QNAME_FUNCTION = new Function<SchemaNode, QName>() {
- @Override
- public QName apply(final SchemaNode rpcDefinition) {
- return rpcDefinition.getQName();
- }
- };
+ private static final Function<SchemaNode, QName> QNAME_FUNCTION = rpcDefinition -> rpcDefinition.getQName();
- private static final Function<SchemaNode, QName> QNAME_NOREV_FUNCTION = new Function<SchemaNode, QName>() {
- @Override
- public QName apply(final SchemaNode notification) {
- return QNAME_FUNCTION.apply(notification).withoutRevision();
- }
- };
+ private static final Function<SchemaNode, QName> QNAME_NOREV_FUNCTION = notification -> QNAME_FUNCTION.apply(notification).withoutRevision();
private final SchemaContext schemaContext;
private final BaseSchema baseSchema;
return new NetconfMessage(node);
}
- private boolean isBaseOrNotificationRpc(final QName rpc) {
+ private static boolean isBaseOrNotificationRpc(final QName rpc) {
return rpc.getNamespace().equals(NETCONF_URI) ||
rpc.getNamespace().equals(IETF_NETCONF_NOTIFICATIONS.getNamespace()) ||
rpc.getNamespace().equals(NetconfMessageTransformUtil.CREATE_SUBSCRIPTION_RPC_QNAME.getNamespace());
private ListenableFuture<Optional<NormalizedNode<?, ?>>> extractData(final Optional<YangInstanceIdentifier> path,
final ListenableFuture<DOMRpcResult> configRunning) {
- return Futures.transform(configRunning, new Function<DOMRpcResult, Optional<NormalizedNode<?, ?>>>() {
- @Override
- public Optional<NormalizedNode<?, ?>> apply(final DOMRpcResult result) {
- Preconditions.checkArgument(result.getErrors().isEmpty(), "Unable to read data: %s, errors: %s", path, result.getErrors());
- final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataNode =
- ((ContainerNode) result.getResult()).getChild(NetconfMessageTransformUtil.toId(NetconfMessageTransformUtil.NETCONF_DATA_QNAME)).get();
- return transformer.selectFromDataStructure(dataNode, path.get());
- }
+ return Futures.transform(configRunning, (Function<DOMRpcResult, Optional<NormalizedNode<?, ?>>>) result -> {
+ Preconditions.checkArgument(result.getErrors().isEmpty(), "Unable to read data: %s, errors: %s", path, result.getErrors());
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataNode =
+ ((ContainerNode) result.getResult()).getChild(NetconfMessageTransformUtil.toId(NetconfMessageTransformUtil.NETCONF_DATA_QNAME)).get();
+ return transformer.selectFromDataStructure(dataNode, path.get());
});
}
return future;
}
- private boolean isFilterPresent(final Optional<YangInstanceIdentifier> filterPath) {
+ private static boolean isFilterPresent(final Optional<YangInstanceIdentifier> filterPath) {
return filterPath.isPresent() && !filterPath.get().isEmpty();
}
return Builders.choiceBuilder().withNodeIdentifier(toId(EditContent.QNAME)).withChild(configContent).build();
}
- private ContainerNode getEditConfigContent(final QName datastore, final DataContainerChild<?, ?> editStructure, final Optional<ModifyAction> defaultOperation, final boolean rollback) {
- final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> editBuilder = Builders.containerBuilder().withNodeIdentifier(toId(NETCONF_EDIT_CONFIG_QNAME));
+ private static ContainerNode getEditConfigContent(final QName datastore,
+ final DataContainerChild<?, ?> editStructure, final Optional<ModifyAction> defaultOperation, final boolean rollback) {
+ final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> editBuilder =
+ Builders.containerBuilder().withNodeIdentifier(toId(NETCONF_EDIT_CONFIG_QNAME));
// Target
editBuilder.withChild(getTargetNode(datastore));
*/
@Override
public AnyXmlNode createEditConfigStructure(final Optional<NormalizedNode<?, ?>> data,
- final YangInstanceIdentifier dataPath, Optional<ModifyAction> operation) {
+ final YangInstanceIdentifier dataPath, final Optional<ModifyAction> operation) {
Preconditions.checkArgument(data.isPresent());
Preconditions.checkArgument(data.get() instanceof AnyXmlNode);
.build();
}
- private void checkDataValidForPath(final YangInstanceIdentifier dataPath, final Element dataNode) {
+ private static void checkDataValidForPath(final YangInstanceIdentifier dataPath, final Element dataNode) {
//if datapath is empty, consider dataNode to be a root node
if (dataPath.equals(YangInstanceIdentifier.EMPTY)) {
return;
}
- private void checkKeyValuesValidForPath(final XmlElement dataElement,
+ private static void checkKeyValuesValidForPath(final XmlElement dataElement,
final YangInstanceIdentifier.PathArgument lastPathArgument) {
final YangInstanceIdentifier.NodeIdentifierWithPredicates keyedId =
(YangInstanceIdentifier.NodeIdentifierWithPredicates) lastPathArgument;
}
}
- private void setOperationAttribute(final Optional<ModifyAction> operation, final Document document,
+ private static void setOperationAttribute(final Optional<ModifyAction> operation, final Document document,
final Element dataNode) {
final QName operationQname = NetconfMessageTransformUtil.NETCONF_OPERATION_QNAME;
final Attr operationAttribute =
return parent;
}
- private List<XmlElement> selectMatchingNodes(final Element domElement, final YangInstanceIdentifier path) {
+ private static List<XmlElement> selectMatchingNodes(final Element domElement, final YangInstanceIdentifier path) {
XmlElement element = XmlElement.fromDomElement(domElement);
for (YangInstanceIdentifier.PathArgument pathArgument : path.getPathArguments()) {
List<XmlElement> childElements = element.getChildElements(pathArgument.getNodeType().getLocalName());
verify(transaction, times(2)).submit();
}
- private void verifyNode(final NodeId nodeId, final Node node) {
+ private static void verifyNode(final NodeId nodeId, final Node node) {
Assert.assertEquals(nodeId, node.getNodeId());
final NetconfNode netconfNode = node.getAugmentation(NetconfNode.class);
Assert.assertEquals(HOST, netconfNode.getHost());
Assert.assertEquals(TCP_ONLY, netconfNode.isTcpOnly());
}
- private void setViaReflection(final Object object, final String fieldName, final Object value) {
+ private static void setViaReflection(final Object object, final String fieldName, final Object value) {
try {
final Field field = AbstractNetconfConnectorModule.class.getDeclaredField(fieldName);
field.setAccessible(true);
}
- private void verifySchemas(final LibraryModulesSchemas libraryModulesSchemas) throws MalformedURLException {
+ private static void verifySchemas(final LibraryModulesSchemas libraryModulesSchemas) throws MalformedURLException {
final Map<SourceIdentifier, URL> resolvedModulesSchema = libraryModulesSchemas.getAvailableModels();
Assert.assertThat(resolvedModulesSchema.size(), is(3));
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
import org.opendaylight.controller.config.util.xml.XmlUtil;
import org.opendaylight.controller.md.sal.dom.api.DOMNotification;
import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
import org.opendaylight.netconf.api.NetconfMessage;
import org.opendaylight.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.netconf.sal.connect.api.MessageTransformer;
-import org.opendaylight.netconf.sal.connect.api.NetconfDeviceSchemas;
import org.opendaylight.netconf.sal.connect.api.NetconfDeviceSchemasResolver;
import org.opendaylight.netconf.sal.connect.api.RemoteDeviceHandler;
import org.opendaylight.netconf.sal.connect.netconf.listener.NetconfDeviceCapabilities;
RevisionSourceIdentifier.create(TEST_MODULE + "2", Optional.of(TEST_REVISION));
public static final String TEST_CAPABILITY2 = TEST_NAMESPACE + "?module=" + TEST_MODULE + "2" + "&revision=" + TEST_REVISION;
- private static final NetconfDeviceSchemasResolver stateSchemasResolver = new NetconfDeviceSchemasResolver() {
-
- @Override
- public NetconfDeviceSchemas resolve(final NetconfDeviceRpc deviceRpc, final NetconfSessionPreferences remoteSessionCapabilities, final RemoteDeviceId id) {
- return NetconfStateSchemas.EMPTY;
- }
- };
+ private static final NetconfDeviceSchemasResolver stateSchemasResolver = (deviceRpc, remoteSessionCapabilities, id) -> NetconfStateSchemas.EMPTY;
@Test
public void testNetconfDeviceFlawedModelFailedResolution() throws Exception {
// Make fallback attempt to fail due to empty resolved sources
final MissingSchemaSourceException schemaResolutionException = new MissingSchemaSourceException("fail first", TEST_SID);
doReturn(Futures.immediateFailedCheckedFuture(schemaResolutionException)).when(schemaRepository).getSchemaSource(eq(TEST_SID), eq(ASTSchemaSource.class));
- doAnswer(new Answer<Object>() {
- @Override
- public Object answer(final InvocationOnMock invocation) throws Throwable {
- if (((Collection<?>) invocation.getArguments()[0]).size() == 2) {
- return Futures.immediateFailedCheckedFuture(schemaResolutionException);
- } else {
- return Futures.immediateCheckedFuture(schema);
- }
+ doAnswer(invocation -> {
+ if (((Collection<?>) invocation.getArguments()[0]).size() == 2) {
+ return Futures.immediateFailedCheckedFuture(schemaResolutionException);
+ } else {
+ return Futures.immediateCheckedFuture(schema);
}
}).when(schemaFactory).createSchemaContext(anyCollectionOf(SourceIdentifier.class));
- final NetconfDeviceSchemasResolver stateSchemasResolver = new NetconfDeviceSchemasResolver() {
- @Override
- public NetconfDeviceSchemas resolve(final NetconfDeviceRpc deviceRpc, final NetconfSessionPreferences remoteSessionCapabilities, final RemoteDeviceId id) {
- final Module first = Iterables.getFirst(schema.getModules(), null);
- final QName qName = QName.create(first.getQNameModule(), first.getName());
- final NetconfStateSchemas.RemoteYangSchema source1 = new NetconfStateSchemas.RemoteYangSchema(qName);
- final NetconfStateSchemas.RemoteYangSchema source2 = new NetconfStateSchemas.RemoteYangSchema(QName.create(first.getQNameModule(), "test-module2"));
- return new NetconfStateSchemas(Sets.newHashSet(source1, source2));
- }
+ final NetconfDeviceSchemasResolver stateSchemasResolver = (deviceRpc, remoteSessionCapabilities, id) -> {
+ final Module first = Iterables.getFirst(schema.getModules(), null);
+ final QName qName = QName.create(first.getQNameModule(), first.getName());
+ final NetconfStateSchemas.RemoteYangSchema source1 = new NetconfStateSchemas.RemoteYangSchema(qName);
+ final NetconfStateSchemas.RemoteYangSchema source2 = new NetconfStateSchemas.RemoteYangSchema(QName.create(first.getQNameModule(), "test-module2"));
+ return new NetconfStateSchemas(Sets.newHashSet(source1, source2));
};
final NetconfDevice.SchemaResourcesDTO schemaResourcesDTO
Mockito.verify(schemaFactory, times(1)).createSchemaContext(anyCollectionOf(SourceIdentifier.class));
}
- private SchemaSourceRegistry getSchemaRegistry() {
+ private static SchemaSourceRegistry getSchemaRegistry() {
final SchemaSourceRegistry mock = mock(SchemaSourceRegistry.class);
final SchemaSourceRegistration<?> mockReg = mock(SchemaSourceRegistration.class);
doNothing().when(mockReg).close();
return mock;
}
- private SchemaRepository getSchemaRepository() {
+ private static SchemaRepository getSchemaRepository() {
final SchemaRepository mock = mock(SchemaRepository.class);
final SchemaSourceRepresentation mockRep = mock(SchemaSourceRepresentation.class);
doReturn(Futures.immediateCheckedFuture(mockRep)).when(mock).getSchemaSource(any(SourceIdentifier.class), eq(ASTSchemaSource.class));
moduleBasedCaps.get(QName.create(entry.getCapability())).getName(), entry.getCapabilityOrigin().getName()));
}
- private SchemaContextFactory getSchemaFactory() throws Exception {
+ private static SchemaContextFactory getSchemaFactory() throws Exception {
final SchemaContextFactory schemaFactory = mockClass(SchemaContextFactory.class);
doReturn(Futures.immediateCheckedFuture(getSchema())).when(schemaFactory).createSchemaContext(any(Collection.class));
return schemaFactory;
return YangParserTestUtils.parseYangStreams(modelsToParse);
}
- private RemoteDeviceHandler<NetconfSessionPreferences> getFacade() throws Exception {
+ private static RemoteDeviceHandler<NetconfSessionPreferences> getFacade() throws Exception {
final RemoteDeviceHandler<NetconfSessionPreferences> remoteDeviceHandler = mockCloseableClass(RemoteDeviceHandler.class);
doNothing().when(remoteDeviceHandler).onDeviceConnected(any(SchemaContext.class), any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class));
doNothing().when(remoteDeviceHandler).onDeviceDisconnected();
return remoteDeviceHandler;
}
- private <T extends AutoCloseable> T mockCloseableClass(final Class<T> remoteDeviceHandlerClass) throws Exception {
+ private static <T extends AutoCloseable> T mockCloseableClass(final Class<T> remoteDeviceHandlerClass)
+ throws Exception {
final T mock = mockClass(remoteDeviceHandlerClass);
doNothing().when(mock).close();
return mock;
}
@SuppressWarnings("unchecked")
- private RemoteDeviceHandler<NetconfSessionPreferences> getFacade() throws Exception {
+ private static RemoteDeviceHandler<NetconfSessionPreferences> getFacade() throws Exception {
final RemoteDeviceHandler<NetconfSessionPreferences> remoteDeviceHandler = mockCloseableClass(RemoteDeviceHandler.class);
doNothing().when(remoteDeviceHandler).onDeviceConnected(any(SchemaContext.class), any(NetconfSessionPreferences.class), any(NetconfDeviceRpc.class));
doNothing().when(remoteDeviceHandler).onDeviceDisconnected();
return remoteDeviceHandler;
}
- private <T extends AutoCloseable> T mockCloseableClass(final Class<T> remoteDeviceHandlerClass) throws Exception {
+ private static <T extends AutoCloseable> T mockCloseableClass(final Class<T> remoteDeviceHandlerClass) throws Exception {
final T mock = mockClass(remoteDeviceHandlerClass);
doNothing().when(mock).close();
return mock;
return mock;
}
- private NetconfSessionPreferences getSessionCaps(final boolean addMonitor, final Collection<String> additionalCapabilities) {
+ private static NetconfSessionPreferences getSessionCaps(final boolean addMonitor, final Collection<String> additionalCapabilities) {
final ArrayList<String> capabilities = Lists.newArrayList(
XmlNetconfConstants.URN_IETF_PARAMS_NETCONF_BASE_1_0,
XmlNetconfConstants.URN_IETF_PARAMS_NETCONF_BASE_1_1);
assertCaps(sessionCaps1, 0, 4);
}
- private void assertCaps(final NetconfSessionPreferences sessionCaps1, final int nonModuleCaps, final int moduleCaps) {
+ private static void assertCaps(final NetconfSessionPreferences sessionCaps1, final int nonModuleCaps,
+ final int moduleCaps) {
assertEquals(nonModuleCaps, sessionCaps1.getNonModuleCaps().size());
assertEquals(moduleCaps, sessionCaps1.getModuleBasedCaps().size());
}
verify(mountInstance).publish(domNotification);
}
- private List<String> getCapabilities(){
+ private static List<String> getCapabilities() {
return Arrays.asList(NetconfMessageTransformUtil.NETCONF_CANDIDATE_URI.toString());
}
}
"</rpc>");
}
- private void assertSimilarXml(final NetconfMessage netconfMessage, final String xmlContent) throws SAXException, IOException {
+ private static void assertSimilarXml(final NetconfMessage netconfMessage, final String xmlContent)
+ throws SAXException, IOException {
final Diff diff = XMLUnit.compareXML(netconfMessage.getDocument(), XmlUtil.readXmlToDocument(xmlContent));
diff.overrideElementQualifier(new ElementNameAndAttributeQualifier());
assertTrue(diff.toString(), diff.similar());
final QName capability = QName.create(Capabilities.QNAME, "capability");
final DataContainerChild<?, ?> filter = toFilterStructure(
- YangInstanceIdentifier.create(toId(NetconfState.QNAME), toId(Capabilities.QNAME), toId(capability), new YangInstanceIdentifier.NodeWithValue(capability, "a:b:c")), schema);
+ YangInstanceIdentifier.create(toId(NetconfState.QNAME), toId(Capabilities.QNAME), toId(capability),
+ new YangInstanceIdentifier.NodeWithValue<>(capability, "a:b:c")), schema);
final NetconfMessage netconfMessage = netconfMessageTransformer.toRpcRequest(toPath(NETCONF_GET_QNAME),
NetconfMessageTransformUtil.wrap(NETCONF_GET_QNAME, filter));
"</rpc>");
}
- private NetconfMessageTransformer getTransformer(final SchemaContext schema) {
+ private static NetconfMessageTransformer getTransformer(final SchemaContext schema) {
return new NetconfMessageTransformer(schema, true);
}
assertNull(compositeNodeRpcResult.getResult());
}
- public SchemaContext getSchema(boolean addBase) {
+ public SchemaContext getSchema(final boolean addBase) {
final ModuleInfoBackedContext moduleInfoBackedContext = ModuleInfoBackedContext.create();
if(addBase) {
moduleInfoBackedContext.addModuleInfos(Collections.singleton($YangModuleInfoImpl.getInstance()));
return getExportUsingNameAndRevision(schemaContext, moduleName, revisionString);
}
- private SchemaExportContext getExportUsingNameAndRevision(final SchemaContext schemaContext, final String moduleName,
- final String revisionStr) {
+ private static SchemaExportContext getExportUsingNameAndRevision(final SchemaContext schemaContext,
+ final String moduleName, final String revisionStr) {
try {
final Date revision = SimpleDateFormatUtil.getRevisionFormat().parse(revisionStr);
final Module module = schemaContext.findModuleByName(moduleName, revision);
final InstanceIdentifierContext<?> mountContext = salContext.toMountPointIdentifier(identifier);
return mountContext.getSchemaContext();
}
-
-
-
}
* @param in reader JsonReader reader
* @return NormalizedNode representing data
*/
- private NormalizedNode readEditData(@Nonnull final JsonReader in, @Nonnull final SchemaNode targetSchemaNode,
+ private static NormalizedNode readEditData(@Nonnull final JsonReader in, @Nonnull final SchemaNode targetSchemaNode,
@Nonnull final InstanceIdentifierContext path) {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
* @param edit Instance of PatchEdit
* @return PATCHEntity
*/
- private PATCHEntity prepareEditOperation(@Nonnull final PatchEdit edit) {
+ private static PATCHEntity prepareEditOperation(@Nonnull final PatchEdit edit) {
if ((edit.getOperation() != null) && (edit.getTargetSchemaNode() != null)
&& checkDataPresence(edit.getOperation(), (edit.getData() != null))) {
if (isPatchOperationWithValue(edit.getOperation())) {
* @return true if data is present when operation requires it or if there are no data when operation does not
* allow it, false otherwise
*/
- private boolean checkDataPresence(@Nonnull final String operation, final boolean hasData) {
+ private static boolean checkDataPresence(@Nonnull final String operation, final boolean hasData) {
if (isPatchOperationWithValue(operation)) {
- if (hasData) {
- return true;
- } else {
- return false;
- }
+ return hasData;
} else {
- if (!hasData) {
- return true;
- } else {
- return false;
- }
+ return !hasData;
}
}
jsonWriter.flush();
}
- private void writeNormalizedNode(final JsonWriter jsonWriter, SchemaPath path,
+ private static void writeNormalizedNode(final JsonWriter jsonWriter, SchemaPath path,
final InstanceIdentifierContext<SchemaNode> context, NormalizedNode<?, ?> data,
final Optional<Integer> depth) throws IOException {
final RestconfNormalizedNodeWriter nnWriter;
nnWriter.flush();
}
- private void writeChildren(final RestconfNormalizedNodeWriter nnWriter, final ContainerNode data) throws IOException {
- for(final DataContainerChild<? extends PathArgument, ?> child : data.getValue()) {
+ private static void writeChildren(final RestconfNormalizedNodeWriter nnWriter, final ContainerNode data)
+ throws IOException {
+ for (final DataContainerChild<? extends PathArgument, ?> child : data.getValue()) {
nnWriter.write(child);
}
}
- private RestconfNormalizedNodeWriter createNormalizedNodeWriter(final InstanceIdentifierContext<SchemaNode> context,
- final SchemaPath path, final JsonWriter jsonWriter, final Optional<Integer> depth) {
+ private static RestconfNormalizedNodeWriter createNormalizedNodeWriter(
+ final InstanceIdentifierContext<SchemaNode> context, final SchemaPath path, final JsonWriter jsonWriter,
+ final Optional<Integer> depth) {
final SchemaNode schema = context.getSchemaNode();
final JSONCodecFactory codecs = getCodecFactory(context);
}
}
- private JsonWriter createJsonWriter(final OutputStream entityStream, final boolean prettyPrint) {
+ private static JsonWriter createJsonWriter(final OutputStream entityStream, final boolean prettyPrint) {
if (prettyPrint) {
return JsonWriterFactory.createJsonWriter(new OutputStreamWriter(entityStream, StandardCharsets.UTF_8),
DEFAULT_INDENT_SPACES_NUM);
}
}
- private JSONCodecFactory getCodecFactory(final InstanceIdentifierContext<?> context) {
+ private static JSONCodecFactory getCodecFactory(final InstanceIdentifierContext<?> context) {
// TODO: Performance: Cache JSON Codec factory and schema context
return JSONCodecFactory.create(context.getSchemaContext());
}
writeNormalizedNode(xmlWriter, schemaPath, pathContext, data, Optional.fromNullable(t.getWriterParameters().getDepth()));
}
- private void writeNormalizedNode(final XMLStreamWriter xmlWriter, final SchemaPath schemaPath,
+ private static void writeNormalizedNode(final XMLStreamWriter xmlWriter, final SchemaPath schemaPath,
final InstanceIdentifierContext<?> pathContext, NormalizedNode<?, ?> data, final Optional<Integer> depth)
throws IOException {
final RestconfNormalizedNodeWriter nnWriter;
nnWriter.flush();
}
- private RestconfNormalizedNodeWriter createNormalizedNodeWriter(final XMLStreamWriter xmlWriter,
+ private static RestconfNormalizedNodeWriter createNormalizedNodeWriter(final XMLStreamWriter xmlWriter,
final SchemaContext schemaContext, final SchemaPath schemaPath, final Optional<Integer> depth) {
final NormalizedNodeStreamWriter xmlStreamWriter =
XMLStreamNormalizedNodeStreamWriter.create(xmlWriter, schemaContext, schemaPath);
}
}
- private void writeElements(final XMLStreamWriter xmlWriter, final RestconfNormalizedNodeWriter nnWriter,
+ private static void writeElements(final XMLStreamWriter xmlWriter, final RestconfNormalizedNodeWriter nnWriter,
final ContainerNode data)
throws IOException {
try {
jsonWriter.flush();
}
- private void reportSuccess(final JsonWriter jsonWriter) throws IOException {
+ private static void reportSuccess(final JsonWriter jsonWriter) throws IOException {
jsonWriter.name("ok").beginArray().nullValue().endArray();
}
}
}
- private PATCHContext parse(final InstanceIdentifierContext<?> pathContext, final Document doc) {
+ private static PATCHContext parse(final InstanceIdentifierContext<?> pathContext, final Document doc) {
final List<PATCHEntity> resultCollection = new ArrayList<>();
final String patchId = doc.getElementsByTagName("patch-id").item(0).getFirstChild().getNodeValue();
final NodeList editNodes = doc.getElementsByTagName("edit");
* @param operation Name of current operation
* @return List of value elements
*/
- private List<Element> readValueNodes(@Nonnull final Element element, @Nonnull final String operation) {
+ private static List<Element> readValueNodes(@Nonnull final Element element, @Nonnull final String operation) {
final Node valueNode = element.getElementsByTagName("value").item(0);
if (PATCHEditOperation.isPatchOperationWithValue(operation) && (valueNode == null)) {
* @param revision Module revision
* @return Non-conditional XPath
*/
- private String prepareNonCondXpath(@Nonnull final DataSchemaNode schemaNode, @Nonnull final String target,
- @Nonnull final Element value, @Nonnull final String namespace,
- @Nonnull final String revision) {
+ private static String prepareNonCondXpath(@Nonnull final DataSchemaNode schemaNode, @Nonnull final String target,
+ @Nonnull final Element value, @Nonnull final String namespace, @Nonnull final String revision) {
final Iterator<String> args = Splitter.on("/").split(target.substring(target.indexOf(':') + 1)).iterator();
final StringBuilder nonCondXpath = new StringBuilder();
* @param keys Iterator of list keys names
* @return Iterator of list keys values
*/
- private Iterator<String> readKeyValues(@Nonnull final Element value, @Nonnull final Iterator<QName> keys) {
+ private static Iterator<String> readKeyValues(@Nonnull final Element value, @Nonnull final Iterator<QName> keys) {
final List<String> result = new ArrayList<>();
while (keys.hasNext()) {
* @param keyNames Iterator of list keys names
* @param keyValues Iterator of list keys values
*/
- private void appendKeys(@Nonnull final StringBuilder nonCondXpath, @Nonnull final Iterator<QName> keyNames,
+ private static void appendKeys(@Nonnull final StringBuilder nonCondXpath, @Nonnull final Iterator<QName> keyNames,
@Nonnull final Iterator<String> keyValues) {
while (keyNames.hasNext()) {
nonCondXpath.append("[");
}
}
- private DataSchemaNode checkListAndOrderedType(final SchemaContext ctx,
- final YangInstanceIdentifier path) {
+ private static DataSchemaNode checkListAndOrderedType(final SchemaContext ctx, final YangInstanceIdentifier path) {
final YangInstanceIdentifier parent = path.getParent();
final DataSchemaContextNode<?> node = DataSchemaContextTree.from(ctx).getChild(parent);
final DataSchemaNode dataSchemaNode = node.getDataSchemaNode();
}
}
- private void simplePostPut(final DOMDataReadWriteTransaction rWTransaction, final LogicalDatastoreType datastore,
- final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
+ private static void simplePostPut(final DOMDataReadWriteTransaction rWTransaction,
+ final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
+ final SchemaContext schemaContext) {
checkItemDoesNotExists(rWTransaction, datastore, path);
ensureParentsByMerge(datastore, path, rWTransaction, schemaContext);
rWTransaction.put(datastore, path, payload);
}
- private boolean doesItemExist(final DOMDataReadWriteTransaction rWTransaction,
+ private static boolean doesItemExist(final DOMDataReadWriteTransaction rWTransaction,
final LogicalDatastoreType store, final YangInstanceIdentifier path) {
try {
return rWTransaction.exists(store, path).checkedGet();
* @param store Used datastore
* @param path Path to item to verify its existence
*/
- private void checkItemExists(final DOMDataReadWriteTransaction rWTransaction,
- final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+ private static void checkItemExists(final DOMDataReadWriteTransaction rWTransaction,
+ final LogicalDatastoreType store, final YangInstanceIdentifier path) {
if (!doesItemExist(rWTransaction, store, path)) {
final String errMsg = "Operation via Restconf was not executed because data does not exist";
LOG.trace("{}:{}", errMsg, path);
* @param store Used datastore
* @param path Path to item to verify its existence
*/
- private void checkItemDoesNotExists(final DOMDataReadWriteTransaction rWTransaction,
- final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+ private static void checkItemDoesNotExists(final DOMDataReadWriteTransaction rWTransaction,
+ final LogicalDatastoreType store, final YangInstanceIdentifier path) {
if (doesItemExist(rWTransaction, store, path)) {
final String errMsg = "Operation via Restconf was not executed because data already exists";
LOG.trace("{}:{}", errMsg, path);
}
}
- private void makePut(final DOMDataReadWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
- final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
+ private static void makePut(final DOMDataReadWriteTransaction writeTransaction,
+ final LogicalDatastoreType datastore, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload,
+ final SchemaContext schemaContext) {
if (payload instanceof MapNode) {
final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
writeTransaction.merge(datastore, YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
}
}
- private void simplePut(final LogicalDatastoreType datastore, final YangInstanceIdentifier path,
+ private static void simplePut(final LogicalDatastoreType datastore, final YangInstanceIdentifier path,
final DOMDataReadWriteTransaction writeTransaction, final SchemaContext schemaContext,
final NormalizedNode<?, ?> payload) {
ensureParentsByMerge(datastore, path, writeTransaction, schemaContext);
writeTransaction.put(datastore, path, payload);
}
- private CheckedFuture<Void, TransactionCommitFailedException> deleteDataViaTransaction(
+ private static CheckedFuture<Void, TransactionCommitFailedException> deleteDataViaTransaction(
final DOMDataReadWriteTransaction readWriteTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path) {
LOG.trace("Delete {} via Restconf: {}", datastore.name(), path);
return readWriteTransaction.submit();
}
- private void deleteDataWithinTransaction(
- final DOMDataWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
- final YangInstanceIdentifier path) {
+ private static void deleteDataWithinTransaction(final DOMDataWriteTransaction writeTransaction,
+ final LogicalDatastoreType datastore, final YangInstanceIdentifier path) {
LOG.trace("Delete {} within Restconf PATCH: {}", datastore.name(), path);
writeTransaction.delete(datastore, path);
}
- private void mergeDataWithinTransaction(
+ private static void mergeDataWithinTransaction(
final DOMDataReadWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
LOG.trace("Merge {} within Restconf PATCH: {} with payload {}", datastore.name(), path, payload);
}
}
- private void ensureParentsByMerge(final LogicalDatastoreType store, final YangInstanceIdentifier normalizedPath,
- final DOMDataReadWriteTransaction rwTx, final SchemaContext schemaContext) {
+ private static void ensureParentsByMerge(final LogicalDatastoreType store,
+ final YangInstanceIdentifier normalizedPath, final DOMDataReadWriteTransaction rwTx,
+ final SchemaContext schemaContext) {
final List<PathArgument> normalizedPathWithoutChildArgs = new ArrayList<>();
YangInstanceIdentifier rootNormalizedPath = null;
public void close() {
}
- private String toJson(final NormalizedNodeContext readData) throws IOException {
+ private static String toJson(final NormalizedNodeContext readData) throws IOException {
final NormalizedNodeJsonBodyWriter writer = new NormalizedNodeJsonBodyWriter();
final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
writer.writeTo(readData, NormalizedNodeContext.class, null, EMPTY_ANNOTATIONS,
return outputStream.toString(StandardCharsets.UTF_8.name());
}
- private boolean isDataMissing(final Exception e) {
+ private static boolean isDataMissing(final Exception e) {
boolean dataMissing = false;
- if(e instanceof RestconfDocumentedException) {
+ if (e instanceof RestconfDocumentedException) {
final RestconfDocumentedException rde = (RestconfDocumentedException)e;
if(!rde.getErrors().isEmpty()) {
if(rde.getErrors().get(0).getErrorTag() == ErrorTag.DATA_MISSING) {
@Override
public YangInstanceIdentifier deserialize(final IdentityValuesDTO data) {
- final List<PathArgument> result = new ArrayList<PathArgument>();
+ final List<PathArgument> result = new ArrayList<>();
final IdentityValue valueWithNamespace = data.getValuesWithNamespaces().get(0);
final Module module = getModuleByNamespace(valueWithNamespace.getNamespace(), this.mountPoint);
if (module == null) {
return result.isEmpty() ? null : YangInstanceIdentifier.create(result);
}
- private List<Predicate> keyValuesToPredicateList(final Map<QName, Object> keyValues) {
+ private
static List<Predicate> keyValuesToPredicateList(final Map<QName, Object> keyValues) {
final List<Predicate> result = new ArrayList<>();
for (final QName qName : keyValues.keySet()) {
final Object value = keyValues.get(qName);
return result;
}
- private IdentityValue qNameToIdentityValue(final QName qName) {
+ private static IdentityValue qNameToIdentityValue(final QName qName) {
if (qName != null) {
return new IdentityValue(qName.getNamespace().toString(), qName.getLocalName());
}
* - mount point, if in use otherwise null
* @return {@link NormalizedNodeContext}
*/
- private NormalizedNodeContext operationsFromModulesToNormalizedContext(final Set<Module> modules,
+ private static NormalizedNodeContext operationsFromModulesToNormalizedContext(final Set<Module> modules,
final DOMMountPoint mountPoint) {
final Collection<Module> neededModules = new ArrayList<>(modules.size());
throw new RestconfDocumentedException(msg);
}
- private Date parseDateFromQueryParam(final Entry<String, List<String>> entry) {
+ private static Date parseDateFromQueryParam(final Entry<String, List<String>> entry) {
final DateAndTime event = new DateAndTime(entry.getValue().iterator().next());
String numOf_ms = "";
final String value = event.getValue();
* @return {@link InstanceIdentifierContext} of location leaf for
* notification
*/
- private InstanceIdentifierContext<?> prepareIIDSubsStreamOutput() {
+ private static InstanceIdentifierContext<?> prepareIIDSubsStreamOutput() {
final QName qnameBase = QName.create("subscribe:to:notification", "2016-10-28", "notifi");
final SchemaContext schemaCtx = ControllerContext.getInstance().getGlobalSchema();
final DataSchemaNode location = ((ContainerSchemaNode) schemaCtx
* - contains list of qnames of notifications
* @return - checked future object
*/
- private CheckedFuture<DOMRpcResult, DOMRpcException>
- invokeSalRemoteRpcNotifiStrRPC(final NormalizedNodeContext payload) {
+ private static CheckedFuture<DOMRpcResult, DOMRpcException> invokeSalRemoteRpcNotifiStrRPC(
+ final NormalizedNodeContext payload) {
final ContainerNode data = (ContainerNode) payload.getData();
LeafSetNode leafSet = null;
String outputType = "XML";
* @param in reader JsonReader reader
* @return NormalizedNode representing data
*/
- private NormalizedNode readEditData(@Nonnull final JsonReader in, @Nonnull SchemaNode targetSchemaNode,
- @Nonnull InstanceIdentifierContext path) {
+ private static NormalizedNode readEditData(@Nonnull final JsonReader in, @Nonnull final SchemaNode targetSchemaNode,
+ @Nonnull final InstanceIdentifierContext path) {
final NormalizedNodeResult resultHolder = new NormalizedNodeResult();
final NormalizedNodeStreamWriter writer = ImmutableNormalizedNodeStreamWriter.from(resultHolder);
JsonParserStream.create(writer, path.getSchemaContext(), targetSchemaNode).parse(in);
* @param edit Instance of PatchEdit
* @return PATCHEntity
*/
- private PATCHEntity prepareEditOperation(@Nonnull final PatchEdit edit) {
+ private static PATCHEntity prepareEditOperation(@Nonnull final PatchEdit edit) {
if (edit.getOperation() != null && edit.getTargetSchemaNode() != null
&& checkDataPresence(edit.getOperation(), (edit.getData() != null))) {
if (isPatchOperationWithValue(edit.getOperation())) {
* @return true if data is present when operation requires it or if there are no data when operation does not
* allow it, false otherwise
*/
- private boolean checkDataPresence(@Nonnull final String operation, final boolean hasData) {
+ private static boolean checkDataPresence(@Nonnull final String operation, final boolean hasData) {
if (isPatchOperationWithValue(operation)) {
- if (hasData) {
- return true;
- } else {
- return false;
- }
+ return hasData;
} else {
- if (!hasData) {
- return true;
- } else {
- return false;
- }
+ return !hasData;
}
}
return id;
}
- public void setId(String id) {
+ public void setId(final String id) {
this.id = id;
}
return operation;
}
- public void setOperation(String operation) {
+ public void setOperation(final String operation) {
this.operation = operation;
}
return target;
}
- public void setTarget(YangInstanceIdentifier target) {
+ public void setTarget(final YangInstanceIdentifier target) {
this.target = target;
}
return targetSchemaNode;
}
- public void setTargetSchemaNode(SchemaNode targetSchemaNode) {
+ public void setTargetSchemaNode(final SchemaNode targetSchemaNode) {
this.targetSchemaNode = targetSchemaNode;
}
return data;
}
- public void setData(NormalizedNode data) {
+ public void setData(final NormalizedNode data) {
this.data = data;
}
jsonWriter.flush();
}
- private void writeNormalizedNode(final JsonWriter jsonWriter,
- final SchemaPath path,
- final InstanceIdentifierContext<SchemaNode> context,
- final NormalizedNode<?, ?> data,
- final Integer depth,
- final List<Set<QName>> fields) throws IOException {
+ private static void writeNormalizedNode(final JsonWriter jsonWriter,
+ final SchemaPath path, final InstanceIdentifierContext<SchemaNode> context, final NormalizedNode<?, ?> data,
+ final Integer depth, final List<Set<QName>> fields) throws IOException {
final RestconfNormalizedNodeWriter nnWriter;
if (context.getSchemaNode() instanceof RpcDefinition) {
nnWriter.flush();
}
- private void writeChildren(final RestconfNormalizedNodeWriter nnWriter,
+ private static void writeChildren(final RestconfNormalizedNodeWriter nnWriter,
final ContainerNode data) throws IOException {
for (final DataContainerChild<? extends PathArgument, ?> child : data.getValue()) {
nnWriter.write(child);
}
}
- private RestconfNormalizedNodeWriter createNormalizedNodeWriter(final InstanceIdentifierContext<SchemaNode> context,
- final SchemaPath path,
- final JsonWriter jsonWriter,
- final Integer depth,
- final List<Set<QName>> fields) {
+ private static RestconfNormalizedNodeWriter createNormalizedNodeWriter(
+ final InstanceIdentifierContext<SchemaNode> context, final SchemaPath path, final JsonWriter jsonWriter,
+ final Integer depth, final List<Set<QName>> fields) {
final SchemaNode schema = context.getSchemaNode();
final JSONCodecFactory codecs = getCodecFactory(context);
return ParameterAwareNormalizedNodeWriter.forStreamWriter(streamWriter, depth, fields);
}
- private JsonWriter createJsonWriter(final OutputStream entityStream, final boolean prettyPrint) {
+ private static JsonWriter createJsonWriter(final OutputStream entityStream, final boolean prettyPrint) {
if (prettyPrint) {
return JsonWriterFactory.createJsonWriter(
new OutputStreamWriter(entityStream, StandardCharsets.UTF_8), DEFAULT_INDENT_SPACES_NUM);
}
}
- private JSONCodecFactory getCodecFactory(final InstanceIdentifierContext<?> context) {
+ private static JSONCodecFactory getCodecFactory(final InstanceIdentifierContext<?> context) {
// TODO: Performance: Cache JSON Codec factory and schema context
return JSONCodecFactory.create(context.getSchemaContext());
}
t.getWriterParameters().getFields());
}
- private void writeNormalizedNode(final XMLStreamWriter xmlWriter,
- final SchemaPath path,
- final InstanceIdentifierContext<?> pathContext,
- final NormalizedNode<?, ?> data,
- final Integer depth,
- final List<Set<QName>> fields) throws IOException {
+ private static void writeNormalizedNode(final XMLStreamWriter xmlWriter,
+ final SchemaPath path, final InstanceIdentifierContext<?> pathContext, final NormalizedNode<?, ?> data,
+ final Integer depth, final List<Set<QName>> fields) throws IOException {
final RestconfNormalizedNodeWriter nnWriter;
final SchemaContext schemaCtx = pathContext.getSchemaContext();
nnWriter.flush();
}
- private RestconfNormalizedNodeWriter createNormalizedNodeWriter(final XMLStreamWriter xmlWriter,
- final SchemaContext schemaContext,
- final SchemaPath schemaPath,
- final Integer depth,
- final List<Set<QName>> fields) {
+ private static RestconfNormalizedNodeWriter createNormalizedNodeWriter(final XMLStreamWriter xmlWriter,
+ final SchemaContext schemaContext, final SchemaPath schemaPath, final Integer depth,
+ final List<Set<QName>> fields) {
final NormalizedNodeStreamWriter xmlStreamWriter = XMLStreamNormalizedNodeStreamWriter
.create(xmlWriter, schemaContext, schemaPath);
return ParameterAwareNormalizedNodeWriter.forStreamWriter(xmlStreamWriter, depth, fields);
}
- private void writeElements(final XMLStreamWriter xmlWriter,
- final RestconfNormalizedNodeWriter nnWriter,
- final ContainerNode data) throws IOException {
+ private static void writeElements(final XMLStreamWriter xmlWriter, final RestconfNormalizedNodeWriter nnWriter,
+ final ContainerNode data) throws IOException {
try {
final QName name = data.getNodeType();
xmlWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX,
}
}
- private PATCHContext parse(final InstanceIdentifierContext<?> pathContext, final Document doc) {
+ private static PATCHContext parse(final InstanceIdentifierContext<?> pathContext, final Document doc) {
final List<PATCHEntity> resultCollection = new ArrayList<>();
final String patchId = doc.getElementsByTagName("patch-id").item(0).getFirstChild().getNodeValue();
final NodeList editNodes = doc.getElementsByTagName("edit");
* @param operation Name of current operation
* @return List of value elements
*/
- private List<Element> readValueNodes(@Nonnull final Element element, @Nonnull final String operation) {
+ private static List<Element> readValueNodes(@Nonnull final Element element, @Nonnull final String operation) {
final Node valueNode = element.getElementsByTagName("value").item(0);
if (PATCHEditOperation.isPatchOperationWithValue(operation) && valueNode == null) {
* @param revision Module revision
* @return Non-conditional XPath
*/
- private String prepareNonCondXpath(@Nonnull final DataSchemaNode schemaNode, @Nonnull final String target,
- @Nonnull final Element value, @Nonnull final String namespace,
- @Nonnull final String revision) {
+ private static String prepareNonCondXpath(@Nonnull final DataSchemaNode schemaNode, @Nonnull final String target,
+ @Nonnull final Element value, @Nonnull final String namespace, @Nonnull final String revision) {
final Iterator<String> args = Splitter.on("/").split(target.substring(target.indexOf(':') + 1)).iterator();
final StringBuilder nonCondXpath = new StringBuilder();
* @param keys Iterator of list keys names
* @return Iterator of list keys values
*/
- private Iterator<String> readKeyValues(@Nonnull final Element value, @Nonnull final Iterator<QName> keys) {
+ private static Iterator<String> readKeyValues(@Nonnull final Element value, @Nonnull final Iterator<QName> keys) {
final List<String> result = new ArrayList<>();
while (keys.hasNext()) {
* @param keyNames Iterator of list keys names
* @param keyValues Iterator of list keys values
*/
- private void appendKeys(@Nonnull final StringBuilder nonCondXpath, @Nonnull final Iterator<QName> keyNames,
+ private static void appendKeys(@Nonnull final StringBuilder nonCondXpath, @Nonnull final Iterator<QName> keyNames,
@Nonnull final Iterator<String> keyValues) {
while (keyNames.hasNext()) {
nonCondXpath.append("[");
return PutDataTransactionUtil.putData(payload, ref, transactionNode, insert, point);
}
- private void checkQueryParams(final boolean insert_used, final boolean point_used, final String insert) {
+ private static void checkQueryParams(final boolean insert_used, final boolean point_used, final String insert) {
if (point_used && !insert_used) {
throw new RestconfDocumentedException("Point parameter can't be used without Insert parameter.");
}
return this.responseBuilder.build();
}
- private Status prepareStatus(final NormalizedNode<?, ?> readData) {
+ private static Status prepareStatus(final NormalizedNode<?, ?> readData) {
return readData != null ? Status.OK : Status.CREATED;
}
}
.toString()));
}
- private void checkExpectValueNormalizeNodeContext(
- final DataSchemaNode dataSchemaNode,
+ private static void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
final NormalizedNodeContext nnContext) {
checkExpectValueNormalizeNodeContext(dataSchemaNode, nnContext, null);
}
- private void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
- final NormalizedNodeContext nnContext,
- final YangInstanceIdentifier dataNodeIdent) {
+ private static void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
+ final NormalizedNodeContext nnContext, final YangInstanceIdentifier dataNodeIdent) {
assertEquals(dataSchemaNode, nnContext.getInstanceIdentifierContext().getSchemaNode());
assertEquals(dataNodeIdent, nnContext.getInstanceIdentifierContext().getInstanceIdentifier());
assertNotNull(NormalizedNodes.findNode(nnContext.getData(), dataNodeIdent));
assertTrue("lf-test".equalsIgnoreCase(leafDataNode.get().getValue().toString()));
}
- private void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
+ private static void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
final NormalizedNodeContext nnContext) {
checkExpectValueNormalizeNodeContext(dataSchemaNode, nnContext, null);
}
- private void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
- final NormalizedNodeContext nnContext,
- final YangInstanceIdentifier dataNodeIdent) {
+ private static void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
+ final NormalizedNodeContext nnContext, final YangInstanceIdentifier dataNodeIdent) {
assertEquals(dataSchemaNode, nnContext.getInstanceIdentifierContext().getSchemaNode());
assertEquals(dataNodeIdent, nnContext.getInstanceIdentifierContext().getInstanceIdentifier());
assertNotNull(NormalizedNodes.findNode(nnContext.getData(), dataNodeIdent));
dataLoad("/cnsn-to-json/simple-data-types");
}
- private void verifyJsonOutput(final String jsonOutput) {
+ private static void verifyJsonOutput(final String jsonOutput) {
final StringReader strReader = new StringReader(jsonOutput);
final JsonReader jReader = new JsonReader(strReader);
assertNull("Error during reading Json output: " + exception, exception);
}
- private void jsonReadCont(final JsonReader jReader) throws IOException {
+ private static void jsonReadCont(final JsonReader jReader) throws IOException {
jReader.beginObject();
assertNotNull("cont1 is missing.", jReader.hasNext());
// return dataFromJson;
}
- private void jsonReadContElements(final JsonReader jReader) throws IOException {
+ private static void jsonReadContElements(final JsonReader jReader) throws IOException {
jReader.beginObject();
final Map<String, LeafVerifier> expectedMap = Maps.newHashMap();
}
}
- private void verifyException(final RestconfDocumentedException e, final ErrorType errorType, final ErrorTag errorTag) {
+ private static void verifyException(final RestconfDocumentedException e, final ErrorType errorType,
+ final ErrorTag errorTag) {
final List<RestconfError> errors = e.getErrors();
assertEquals("getErrors() size", 1, errors.size());
assertEquals("RestconfError getErrorType()", errorType, errors.get(0).getErrorType());
putListDataTest(uriKey1, uriKey2, payloadKey1, payloadKey2);
}
- private String toUri(final String uriKey1, final String uriKey2) {
+ private static String toUri(final String uriKey1, final String uriKey2) {
final StringBuilder uriBuilder = new StringBuilder("/test-module:lst-with-composite-key/");
uriBuilder.append(uriKey1);
if (uriKey2 != null) {
return normalizedNodeContext;
}
- private void verifyNormaluizedNodeContext(
- final NormalizedNodeContext normalizedNodeContext,
+ private static void verifyNormaluizedNodeContext(final NormalizedNodeContext normalizedNodeContext,
final String topLevelElementName) {
assertEquals(topLevelElementName, normalizedNodeContext.getData()
.getNodeType().getLocalName());
assertTrue(dataTree.contains("lf1"));
}
- private void verityMultipleItemsInList(
- final NormalizedNodeContext normalizedNodeContext) {
+ private static void verityMultipleItemsInList(final NormalizedNodeContext normalizedNodeContext) {
final String dataTree = NormalizedNodes.toStringTree(normalizedNodeContext
.getData());
json);
}
- private void validateJson(final String regex, final String value) {
+ private static void validateJson(final String regex, final String value) {
assertNotNull(value);
final Pattern ptrn = Pattern.compile(regex, Pattern.DOTALL);
final Matcher mtch = ptrn.matcher(value);
assertTrue(outputJson.contains("</cont>"));
}
- private NormalizedNodeContext prepareNNCLeafList()
- throws URISyntaxException {
+ private static NormalizedNodeContext prepareNNCLeafList() throws URISyntaxException {
final QName cont = QName.create("instance:identifier:module", "2014-01-17",
"cont");
final QName cont1 = QName.create("instance:identifier:module", "2014-01-17",
dataCont.withChild(dataCont1.build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<DataSchemaNode>(null, schemaCont,
+ new InstanceIdentifierContext<>(null, schemaCont,
null, schemaContext), dataCont.build());
return testNormalizedNodeContext;
assertTrue(outputJson.contains("</lst11></cont1></cont>"));
}
- private NormalizedNodeContext preparNNC() {
+ private static NormalizedNodeContext preparNNC() {
final QName cont = QName.create("instance:identifier:module", "2014-01-17",
"cont");
final QName cont1 = QName.create("instance:identifier:module", "2014-01-17",
dataCont.withChild(dataCont1.build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<DataSchemaNode>(null, schemaCont,
+ new InstanceIdentifierContext<>(null, schemaCont,
null, schemaContext), dataCont.build());
return testNormalizedNodeContext;
}
- private DataContainerChild<?, ?> buildLeaf(final DataSchemaNode lst11Schema,
- final QName qname,
+ private static DataContainerChild<?, ?> buildLeaf(final DataSchemaNode lst11Schema, final QName qname,
final CollectionNodeBuilder<MapEntryNode, MapNode> dataLst11, final Object value) {
final List<DataSchemaNode> instanceLf = ControllerContext
nnToXml(normalizedNodeContext, "<" + elName + ">true</" + elName + ">");
}
- private NormalizedNodeContext prepareNNC(final Object object, final String name) {
+ private static NormalizedNodeContext prepareNNC(final Object object, final String name) {
final QName cont = QName.create("basic:module", "2013-12-2", "cont");
final QName lf = QName.create("basic:module", "2013-12-2", name);
contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf).withValue(object).build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<DataSchemaNode>(null, contSchema, null, schemaContext), contData.build());
+ new InstanceIdentifierContext<>(null, contSchema, null, schemaContext), contData.build());
return testNormalizedNodeContext;
}
final OutputStream output = new ByteArrayOutputStream();
this.xmlBodyWriter.writeTo(normalizedNodeContext, null, null, null, this.mediaType, null, output);
- for (int i = 0; i < xmlRepresentation.length; i++) {
- assertTrue(output.toString().contains(xmlRepresentation[i]));
+ for (String element : xmlRepresentation) {
+ assertTrue(output.toString().contains(element));
}
}
- private NormalizedNodeContext prepareLeafrefData() {
+ private static NormalizedNodeContext prepareLeafrefData() {
final QName cont = QName.create("basic:module", "2013-12-2", "cont");
final QName lfBoolean = QName.create("basic:module", "2013-12-2", "lfBoolean");
final QName lfLfref = QName.create("basic:module", "2013-12-2", "lfLfref");
contData.withChild(Builders.leafBuilder((LeafSchemaNode) schemaLf).withValue("true").build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<DataSchemaNode>(null, contSchema, null, schemaContext), contData.build());
+ new InstanceIdentifierContext<>(null, contSchema, null, schemaContext), contData.build());
return testNormalizedNodeContext;
}
- private NormalizedNodeContext prepareLeafrefNegativeData() {
+ private static NormalizedNodeContext prepareLeafrefNegativeData() {
final QName cont = QName.create("basic:module", "2013-12-2", "cont");
final QName lfLfref = QName.create("basic:module", "2013-12-2", "lfLfrefNegative");
new InstanceIdentifierContext<>(null, contSchema, null, schemaContext), contData.build());
}
- private NormalizedNodeContext prepareIdrefData(final String prefix, final boolean valueAsQName) {
+ private static NormalizedNodeContext prepareIdrefData(final String prefix, final boolean valueAsQName) {
final QName cont = QName.create("basic:module", "2013-12-2", "cont");
final QName cont1 = QName.create("basic:module", "2013-12-2", "cont1");
final QName lf11 = QName.create("basic:module", "2013-12-2", "lf11");
contData.withChild(cont1Data.build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<DataSchemaNode>(null, contSchema, null, schemaContext), contData.build());
+ new InstanceIdentifierContext<>(null, contSchema, null, schemaContext), contData.build());
return testNormalizedNodeContext;
}
assertTrue(output.toString().contains("<lf2>String data2</lf2>"));
}
- private NormalizedNodeContext prepareNNC(final String name,
- final Object value) {
+ private static NormalizedNodeContext prepareNNC(final String name, final Object value) {
final QName contQname = QName.create("module:with:choice", "2013-12-18",
"cont");
dataContainerNodeAttrBuilder.withChild(dataChoice.build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<DataSchemaNode>(null,
+ new InstanceIdentifierContext<>(null,
contSchemaNode, null, schemaContext),
dataContainerNodeAttrBuilder.build());
return null;
}
- private NormalizedNodeContext prepareNormalizedNodeContext() {
+ private static NormalizedNodeContext prepareNormalizedNodeContext() {
final String rev = "2014-01-17";
final DataSchemaNode schemaContNode = schemaContext;
dataContSchemaContNode.withChild(modul2.build());
final NormalizedNodeContext testNormalizedNodeContext = new NormalizedNodeContext(
- new InstanceIdentifierContext<DataSchemaNode>(null,
+ new InstanceIdentifierContext<>(null,
schemaContNode, null, schemaContext),
dataContSchemaContNode.build());
return testNormalizedNodeContext;
}
- private DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> buildContBuilderMod1(
+ private static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> buildContBuilderMod1(
final String uri, final String rev, final String cont, final String contB, final String lf1,
final String lf1_value) {
final QName contQname = QName.create(uri, rev, cont);
ControllerContext.getInstance().setSchemas(TestUtils.loadSchemaContext("/full-versions/test-module"));
}
- private CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> wrapDummyNode(
+ private static CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> wrapDummyNode(
final NormalizedNode<?, ?> dummyNode) {
return Futures.immediateCheckedFuture(Optional.<NormalizedNode<?, ?>> of(dummyNode));
}
- private CheckedFuture<Boolean, ReadFailedException> wrapExistence(final Boolean exists) {
+ private static CheckedFuture<Boolean, ReadFailedException> wrapExistence(final Boolean exists) {
return Futures.immediateCheckedFuture(exists);
}
/**
* Value of this node shouldn't be important for testing purposes
*/
- private NormalizedNode<?, ?> createDummyNode(final String namespace, final String date, final String localName) {
+ private static NormalizedNode<?, ?> createDummyNode(final String namespace, final String date,
+ final String localName) {
return Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(QName.create(namespace, date, localName))).build();
}
}
- private void validateXmlOutput(final String xml) throws XMLStreamException {
+ private static void validateXmlOutput(final String xml) throws XMLStreamException {
final XMLInputFactory xmlInFactory = XMLInputFactory.newInstance();
XMLEventReader eventReader;
}
- private void validateXmlOutputWithLeafList(final String xml) throws XMLStreamException {
+ private static void validateXmlOutputWithLeafList(final String xml) throws XMLStreamException {
final XMLInputFactory xmlInFactory = XMLInputFactory.newInstance();
XMLEventReader eventReader;
}
- private YangInstanceIdentifier createInstanceIdentifier() throws URISyntaxException {
+ private static YangInstanceIdentifier createInstanceIdentifier() throws URISyntaxException {
final List<PathArgument> pathArguments = new ArrayList<>();
pathArguments.add(new NodeIdentifier(new QName(new URI("instance:identifier:module"), "cont")));
pathArguments.add(new NodeIdentifier(new QName(new URI("instance:identifier:module"), "cont1")));
return YangInstanceIdentifier.create(pathArguments);
}
- private YangInstanceIdentifier createInstanceIdentifierWithLeafList() throws URISyntaxException {
+ private static YangInstanceIdentifier createInstanceIdentifierWithLeafList() throws URISyntaxException {
final List<PathArgument> pathArguments = new ArrayList<>();
pathArguments.add(new NodeIdentifier(new QName(new URI("instance:identifier:module"), "cont")));
pathArguments.add(new NodeIdentifier(new QName(new URI("instance:identifier:module"), "cont1")));
return new NodeWithValue(QName.create("urn:nested:module", "2014-06-3", localName), value);
}
-
-
- private UnkeyedListEntryNode nodeDataDepth3Operational() {
+ private static UnkeyedListEntryNode nodeDataDepth3Operational() {
return unkeyedEntry("depth2-cont1",
container("depth3-cont1", container("depth4-cont1"), leaf("depth4-leaf1", "depth4-leaf1-value")),
leaf("depth3-leaf1", "depth3-leaf1-value"));
}
- private ContainerNode nodeDataDepth5() {
+ private static ContainerNode nodeDataDepth5() {
return container(
"depth1-cont",
unkeyedList(
leaf("depth2-leaf1", "depth2-leaf1-value"));
}
- private ContainerNode nodeDataDepth4() {
+ private static ContainerNode nodeDataDepth4() {
return container(
"depth1-cont",
unkeyedList("depth2-cont1", nodeDataDepth3Operational()),
leaf("depth3-leaf2", "depth3-leaf2-value")), leaf("depth2-leaf1", "depth2-leaf1-value"));
}
- private ContainerNode nodeDataDepth3() {
+ private static ContainerNode nodeDataDepth3() {
return container(
"depth1-cont",
unkeyedList("depth2-cont1",
leaf("depth2-leaf1", "depth2-leaf1-value"));
}
- private ContainerNode nodeDataDepth2() {
+ private static ContainerNode nodeDataDepth2() {
return container(
"depth1-cont",
unkeyedList("depth2-cont1", unkeyedEntry("depth2-cont1")),
leaf("depth2-leaf1", "depth2-leaf1-value"));
}
- private ContainerNode nodeDataDepth1() {
+ private static ContainerNode nodeDataDepth1() {
return container("depth1-cont");
}
}
}
- private NormalizedNodeContext prepareDomPayload() {
+ private static NormalizedNodeContext prepareDomPayload() {
final SchemaContext schema = controllerContext.getGlobalSchema();
final Module rpcModule = schema.findModuleByName("invoke-rpc-module", null);
assertNotNull(rpcModule);
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mockito;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.netconf.sal.rest.impl.JsonNormalizedNodeBodyReader;
return resourceConfig;
}
- private void setControllerContext(final SchemaContext schemaContext) {
+ private static void setControllerContext(final SchemaContext schemaContext) {
final ControllerContext controllerContext = ControllerContext.getInstance();
controllerContext.setSchemas(schemaContext);
restconfImpl.setControllerContext(controllerContext);
assertEquals(200, get(uri, MediaType.APPLICATION_XML));
}
- private YangInstanceIdentifier prepareInstanceIdentifierForList() throws Exception {
+ private static YangInstanceIdentifier prepareInstanceIdentifierForList() throws Exception {
final List<PathArgument> parameters = new ArrayList<>();
final QName qNameCont = newTestModuleQName("cont");
return YangInstanceIdentifier.create(parameters);
}
- private QName newTestModuleQName(final String localPart) throws Exception {
+ private static QName newTestModuleQName(final String localPart) throws Exception {
final Date revision = new SimpleDateFormat("yyyy-MM-dd").parse("2014-01-09");
final URI uri = new URI("test:module");
return QName.create(uri, revision, localPart);
}
- private void validateOperationsResponseXml(final Document responseDoc, final SchemaContext schemaContext) {
+ private static void validateOperationsResponseXml(final Document responseDoc, final SchemaContext schemaContext) {
final Element operationsElem = responseDoc.getDocumentElement();
assertEquals(RESTCONF_NS, operationsElem.getNamespaceURI());
}
- private Matcher validateOperationsResponseJson(final String searchIn, final String rpcName, final String moduleName) {
+ private static Matcher validateOperationsResponseJson(final String searchIn, final String rpcName,
+ final String moduleName) {
final StringBuilder regex = new StringBuilder();
regex.append(".*\"" + rpcName + "\"");
final Pattern ptrn = Pattern.compile(regex.toString(), Pattern.DOTALL);
}
- private Matcher validateOperationsResponseXml(final String searchIn, final String rpcName, final String namespace) {
+ private static Matcher validateOperationsResponseXml(final String searchIn, final String rpcName,
+ final String namespace) {
final StringBuilder regex = new StringBuilder();
regex.append("^");
}
- private void validateModulesResponseXml(final Response response, final SchemaContext schemaContext) {
+ private static void validateModulesResponseXml(final Response response, final SchemaContext schemaContext) {
assertEquals(200, response.getStatus());
final Document responseBody = response.readEntity(Document.class);
final NodeList moduleNodes = responseBody.getDocumentElement().getElementsByTagNameNS(RESTCONF_NS, "module");
assertAllModules(foundModules,schemaContext);
}
- private void assertAllModules(final Set<QName> foundModules, final SchemaContext schemaContext) {
+ private static void assertAllModules(final Set<QName> foundModules, final SchemaContext schemaContext) {
for(final Module module : schemaContext.getModules()) {
final QName current = QName.create(module.getQNameModule(),module.getName());
assertTrue("Module not found in response.",foundModules.contains(current));
}
- private QName assertedModuleXmlToModuleQName(final org.w3c.dom.Node module) {
+ private static QName assertedModuleXmlToModuleQName(final org.w3c.dom.Node module) {
assertEquals("module", module.getLocalName());
assertEquals(RESTCONF_NS, module.getNamespaceURI());
String revision = null;
return QName.create(namespace,revision,name);
}
- private void validateModulesResponseJson(final Response response) {
+ private static void validateModulesResponseJson(final Response response) {
assertEquals(200, response.getStatus());
final String responseBody = response.readEntity(String.class);
.find());
}
- private Matcher prepareJsonRegex(final String module, final String revision, final String namespace,
+ private static Matcher prepareJsonRegex(final String module, final String revision, final String namespace,
final String searchIn) {
final StringBuilder regex = new StringBuilder();
regex.append("^");
}
*/
@SuppressWarnings("rawtypes")
- private NormalizedNode prepareCnDataForMountPointTest(final boolean wrapToCont) throws URISyntaxException, ParseException {
+ private static NormalizedNode prepareCnDataForMountPointTest(final boolean wrapToCont)
+ throws URISyntaxException, ParseException {
final String testModuleDate = "2014-01-09";
final ContainerNode contChild = Builders
.containerBuilder()
}
@SuppressWarnings("unchecked")
- private void mockReadOperationalDataMethod() {
+ private static void mockReadOperationalDataMethod() {
when(brokerFacade.readOperationalData(any(YangInstanceIdentifier.class))).thenReturn(answerFromGet);
}
@SuppressWarnings("unchecked")
- private void mockReadConfigurationDataMethod() {
+ private static void mockReadConfigurationDataMethod() {
when(brokerFacade.readConfigurationData(any(YangInstanceIdentifier.class), Mockito.anyString()))
.thenReturn(answerFromGet);
}
@SuppressWarnings("rawtypes")
- private NormalizedNode prepareCnDataForSlashesBehindMountPointTest() throws ParseException {
+ private static NormalizedNode prepareCnDataForSlashesBehindMountPointTest() throws ParseException {
return ImmutableMapEntryNodeBuilder
.create()
.withNodeIdentifier(
final MultivaluedMap<String, String> paramMap = new MultivaluedHashMap<>();
paramMap.putSingle("depth", "1o");
final UriInfo mockInfo = mock(UriInfo.class);
- when(mockInfo.getQueryParameters(false)).thenAnswer(new Answer<MultivaluedMap<String, String>>() {
- @Override
- public MultivaluedMap<String, String> answer(final InvocationOnMock invocation) {
- return paramMap;
- }
- });
+ when(mockInfo.getQueryParameters(false)).thenAnswer(invocation -> paramMap);
getDataWithInvalidDepthParameterTest(mockInfo);
}
@SuppressWarnings({"rawtypes", "unchecked"})
- private void getDataWithInvalidDepthParameterTest(final UriInfo uriInfo) {
+ private static void getDataWithInvalidDepthParameterTest(final UriInfo uriInfo) {
try {
final QName qNameDepth1Cont = QName.create("urn:nested:module", "2014-06-3", "depth1-cont");
final YangInstanceIdentifier ii = YangInstanceIdentifier.builder().node(qNameDepth1Cont).build();
return resourceConfig;
}
- private void setSchemaControllerContext(final SchemaContext schema) {
+ private static void setSchemaControllerContext(final SchemaContext schema) {
final ControllerContext context = ControllerContext.getInstance();
context.setSchemas(schema);
restconfImpl.setControllerContext(context);
return target(uri).request(mediaType).put(Entity.entity(data, mediaType)).getStatus();
}
- private void mockCommitConfigurationDataPutMethod(final boolean noErrors) {
+ private static void mockCommitConfigurationDataPutMethod(final boolean noErrors) {
final PutResult putResMock = mock(PutResult.class);
if (noErrors) {
doReturn(putResMock).when(brokerFacade).commitConfigurationDataPut(
errorInfoVerifier);
}
- private JsonArray parseJsonErrorArrayElement(final InputStream stream) throws IOException {
+ private static JsonArray parseJsonErrorArrayElement(final InputStream stream) throws IOException {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
ByteStreams.copy(stream, bos);
private final String text;
- public Contains(String text) {
+ public Contains(final String text) {
this.text = text;
}
@Override
- public void describeTo(Description desc) {
+ public void describeTo(final Description desc) {
desc.appendText("contains ").appendValue(text);
}
@Override
- public boolean matches(Object arg) {
+ public boolean matches(final Object arg) {
return arg != null && arg.toString().contains(text);
}
}
@Test
public void testErrorTagStatusCodes() {
- Map<String, Integer> lookUpMap = new HashMap<String, Integer>();
+ Map<String, Integer> lookUpMap = new HashMap<>();
lookUpMap.put("in-use", 409);
lookUpMap.put("invalid-value", 400);
null, "<severity>error</severity>", new RestconfError( rpcError ) );
}
- private void validateRestConfError(String expectedMessage, ErrorType expectedErrorType, ErrorTag expectedErrorTag,
- String expectedErrorAppTag, String errorInfo, RestconfError e) {
+ private static void validateRestConfError(final String expectedMessage, final ErrorType expectedErrorType,
+ final ErrorTag expectedErrorTag, final String expectedErrorAppTag, final String errorInfo,
+ final RestconfError e) {
validateRestConfError(expectedMessage, expectedErrorType, expectedErrorTag, expectedErrorAppTag,
equalTo(errorInfo), e);
}
- private void validateRestConfError(String expectedMessage, ErrorType expectedErrorType, ErrorTag expectedErrorTag,
- String expectedErrorAppTag, Matcher<String> errorInfoMatcher, RestconfError e) {
+ private static void validateRestConfError(final String expectedMessage, final ErrorType expectedErrorType,
+ final ErrorTag expectedErrorTag, final String expectedErrorAppTag, final Matcher<String> errorInfoMatcher,
+ final RestconfError e) {
assertEquals("getErrorMessage", expectedMessage, e.getErrorMessage());
assertEquals("getErrorType", expectedErrorType, e.getErrorType());
return target(uri).request(mediaType).get();
}
- private String getRpcInput() {
+ private static String getRpcInput() {
final StringBuilder sb = new StringBuilder();
sb.append("<input xmlns=\"urn:opendaylight:params:xml:ns:yang:controller:md:sal:remote\">");
sb.append("<path xmlns:int=\"urn:ietf:params:xml:ns:yang:ietf-interfaces\">/int:interfaces/int:interface[int:name='eth0']</path>");
assertTrue(result.contains("lf-augm" + '"' + ":" + '"' + "value"));
}
- private AugmentationNode mockAugm(final LeafNode leaf) {
+ private static AugmentationNode mockAugm(final LeafNode leaf) {
final AugmentationNode augm = mock(AugmentationNode.class);
final AugmentationIdentifier augmId = new AugmentationIdentifier(SingletonSet.of(leaf.getNodeType()));
when(augm.getIdentifier()).thenReturn(augmId);
return augm;
}
- private MapEntryNode mockMapEntry(final QName entryQName, final LeafNode leaf) {
+ private static MapEntryNode mockMapEntry(final QName entryQName, final LeafNode leaf) {
final MapEntryNode entry = mock(MapEntryNode.class);
final Map<QName, Object> keyValues = new HashMap<>();
keyValues.put(leaf.getNodeType(), "value");
return entry;
}
- private MapNode mockList(final QName listQName, final MapEntryNode... entries) {
+ private static MapNode mockList(final QName listQName, final MapEntryNode... entries) {
final MapNode list = mock(MapNode.class);
when(list.getIdentifier()).thenReturn(NodeIdentifier.create(listQName));
when(list.getNodeType()).thenReturn(listQName);
return list;
}
- private ContainerNode mockCont(final QName contQName, final DataContainerChild<? extends PathArgument, ?> child) {
+ private static ContainerNode mockCont(final QName contQName, final DataContainerChild<? extends PathArgument, ?> child) {
final ContainerNode cont = mock(ContainerNode.class);
when(cont.getIdentifier()).thenReturn(NodeIdentifier.create(contQName));
when(cont.getNodeType()).thenReturn(contQName);
return cont;
}
- private LeafNode mockLeaf(final QName leafQName) {
+ private static LeafNode mockLeaf(final QName leafQName) {
final LeafNode child = mock(LeafNode.class);
when(child.getNodeType()).thenReturn(leafQName);
when(child.getIdentifier()).thenReturn(NodeIdentifier.create(leafQName));
checkExpectValueNormalizeNodeContext(dataSchemaNode, returnValue, dataII);
}
- private void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
+ private static void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
final NormalizedNodeContext nnContext, final YangInstanceIdentifier dataNodeIdent) {
assertEquals(dataSchemaNode, nnContext.getInstanceIdentifierContext().getSchemaNode());
assertEquals(dataNodeIdent, nnContext.getInstanceIdentifierContext().getInstanceIdentifier());
checkExpectValueNormalizeNodeContext(dataSchemaNode, returnValue, dataII);
}
- private void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
+ private static void checkExpectValueNormalizeNodeContext(final DataSchemaNode dataSchemaNode,
final NormalizedNodeContext nnContext, final YangInstanceIdentifier dataNodeIdent) {
assertEquals(dataSchemaNode, nnContext.getInstanceIdentifierContext().getSchemaNode());
assertEquals(dataNodeIdent, nnContext.getInstanceIdentifierContext().getInstanceIdentifier());
testData(map, mappedData);
}
- private Map<QName, Object> prepareMap(final String name, final URI uri, final Date start, final String outputType) {
+ private static Map<QName, Object> prepareMap(final String name, final URI uri, final Date start,
+ final String outputType) {
final Map<QName, Object> map = new HashMap<>();
map.put(MonitoringModule.LEAF_NAME_STREAM_QNAME, name);
map.put(MonitoringModule.LEAF_LOCATION_ACCESS_QNAME, uri.toString());
return map;
}
- private void testData(final Map<QName, Object> map, final NormalizedNode mappedData) {
+ private static void testData(final Map<QName, Object> map, final NormalizedNode mappedData) {
for (final DataContainerChild<? extends PathArgument, ?> child : ((MapEntryNode) mappedData).getValue()) {
if (child instanceof LeafNode) {
final LeafNode leaf = ((LeafNode) child);
* @param containerNode
* - modules
*/
- private void verifyLoadedModules(final ContainerNode containerNode) {
+ private static void verifyLoadedModules(final ContainerNode containerNode) {
final Map<String, String> loadedModules = new HashMap<>();
* @param expectedModules Modules from <code>SchemaContext</code>
* @param loadedModules Loaded modules into Restconf module
*/
- private final void verifyLoadedModules(final Set<Module> expectedModules,
- final Map<String, String> loadedModules) {
+ private static void verifyLoadedModules(final Set<Module> expectedModules,
+ final Map<String, String> loadedModules) {
assertEquals("Number of loaded modules is not as expected", expectedModules.size(), loadedModules.size());
for (final Module m : expectedModules) {
final String name = m.getName();
findSchemaNodeInCollection("bad_key", origSchNode);
}
- private SchemaNode findSchemaNodeInCollection(final String key, final SchemaNode... origSchNode) {
+ private static SchemaNode findSchemaNodeInCollection(final String key, final SchemaNode... origSchNode) {
final List<SchemaNode> collection = new ArrayList<>();
- for (int i = 0; i < origSchNode.length; i++) {
- collection.add(origSchNode[i]);
+ for (SchemaNode element : origSchNode) {
+ collection.add(element);
}
return RestconfSchemaUtil.findSchemaNodeInCollection(collection, key);
}
- private SchemaNode mockSchemaNode(final String origKey) {
+ private static SchemaNode mockSchemaNode(final String origKey) {
final SchemaNode mockSchNode = Mockito.mock(SchemaNode.class);
Mockito.when(mockSchNode.getQName())
.thenReturn(QName.create("ns", new SimpleDateFormat("yyyy-MM-dd").format(new Date()), origKey));
Code Review / netconf.git / commitdiff