@GET
@Path("/streams/stream/{identifier:.+}")
- public Response subscribeToStream(@Encoded @PathParam("identifier") String identifier, @Context UriInfo uriInfo);
+ public NormalizedNodeContext subscribeToStream(@Encoded @PathParam("identifier") String identifier,
+ @Context UriInfo uriInfo);
/**
* @deprecated do not use this method. It will be replaced by
import java.lang.reflect.Type;
import java.net.URI;
import java.nio.charset.StandardCharsets;
+import java.util.Map.Entry;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
private static final int DEFAULT_INDENT_SPACES_NUM = 2;
@Override
- public boolean isWriteable(final Class<?> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType) {
+ public boolean isWriteable(final Class<?> type, final Type genericType, final Annotation[] annotations,
+ final MediaType mediaType) {
return type.equals(NormalizedNodeContext.class);
}
@Override
- public long getSize(final NormalizedNodeContext t, final Class<?> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType) {
+ public long getSize(final NormalizedNodeContext t, final Class<?> type, final Type genericType,
+ final Annotation[] annotations, final MediaType mediaType) {
return -1;
}
@Override
- public void writeTo(final NormalizedNodeContext t, final Class<?> type, final Type genericType, final Annotation[] annotations,
- final MediaType mediaType, final MultivaluedMap<String, Object> httpHeaders, final OutputStream entityStream)
- throws IOException, WebApplicationException {
+ public void writeTo(final NormalizedNodeContext t, final Class<?> type, final Type genericType,
+ final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, Object> httpHeaders,
+ final OutputStream entityStream) throws IOException, WebApplicationException {
+ for (final Entry<String, Object> entry : t.getNewHeaders().entrySet()) {
+ httpHeaders.add(entry.getKey(), entry.getValue());
+ }
final NormalizedNode<?, ?> data = t.getData();
if (data == null) {
return;
}
@SuppressWarnings("unchecked")
- final InstanceIdentifierContext<SchemaNode> context = (InstanceIdentifierContext<SchemaNode>) t.getInstanceIdentifierContext();
+ final InstanceIdentifierContext<SchemaNode> context =
+ (InstanceIdentifierContext<SchemaNode>) t.getInstanceIdentifierContext();
final SchemaPath path = context.getSchemaNode().getPath();
final JsonWriter jsonWriter = createJsonWriter(entityStream, t.getWriterParameters().isPrettyPrint());
}
private void writeNormalizedNode(final JsonWriter jsonWriter, SchemaPath path,
- final InstanceIdentifierContext<SchemaNode> context, NormalizedNode<?, ?> data, final Optional<Integer> depth) throws
- IOException {
+ final InstanceIdentifierContext<SchemaNode> context, NormalizedNode<?, ?> data,
+ final Optional<Integer> depth) throws IOException {
final RestconfNormalizedNodeWriter nnWriter;
if (SchemaPath.ROOT.equals(path)) {
/*
} else {
initialNs = null;
}
- final NormalizedNodeStreamWriter streamWriter = JSONNormalizedNodeStreamWriter.createNestedWriter(codecs,path,initialNs,jsonWriter);
+ final NormalizedNodeStreamWriter streamWriter =
+ JSONNormalizedNodeStreamWriter.createNestedWriter(codecs, path, initialNs, jsonWriter);
if (depth.isPresent()) {
return DepthAwareNormalizedNodeWriter.forStreamWriter(streamWriter, depth.get());
} else {
import java.io.OutputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
+import java.util.Map.Entry;
import javanet.staxutils.IndentingXMLStreamWriter;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
final Annotation[] annotations, final MediaType mediaType,
final MultivaluedMap<String, Object> httpHeaders, final OutputStream entityStream) throws IOException,
WebApplicationException {
+ for (final Entry<String, Object> entry : t.getNewHeaders().entrySet()) {
+ httpHeaders.add(entry.getKey(), entry.getValue());
+ }
final InstanceIdentifierContext<?> pathContext = t.getInstanceIdentifierContext();
if (t.getData() == null) {
return;
writeNormalizedNode(xmlWriter, schemaPath, pathContext, data, Optional.fromNullable(t.getWriterParameters().getDepth()));
}
- private void writeNormalizedNode(final XMLStreamWriter xmlWriter, final SchemaPath schemaPath, final InstanceIdentifierContext<?>
- pathContext, NormalizedNode<?, ?> data, final Optional<Integer> depth) throws IOException {
+ private void writeNormalizedNode(final XMLStreamWriter xmlWriter, final SchemaPath schemaPath,
+ final InstanceIdentifierContext<?> pathContext, NormalizedNode<?, ?> data, final Optional<Integer> depth)
+ throws IOException {
final RestconfNormalizedNodeWriter nnWriter;
final SchemaContext schemaCtx = pathContext.getSchemaContext();
if (SchemaPath.ROOT.equals(schemaPath)) {
}
private RestconfNormalizedNodeWriter createNormalizedNodeWriter(final XMLStreamWriter xmlWriter,
- final SchemaContext schemaContext, final SchemaPath schemaPath, final Optional<Integer> depth) {
- final NormalizedNodeStreamWriter xmlStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(xmlWriter, schemaContext, schemaPath);
+ final SchemaContext schemaContext, final SchemaPath schemaPath, final Optional<Integer> depth) {
+ final NormalizedNodeStreamWriter xmlStreamWriter =
+ XMLStreamNormalizedNodeStreamWriter.create(xmlWriter, schemaContext, schemaPath);
if (depth.isPresent()) {
return DepthAwareNormalizedNodeWriter.forStreamWriter(xmlStreamWriter, depth.get());
} else {
throws IOException {
try {
final QName name = data.getNodeType();
- xmlWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, name.getLocalName(), name.getNamespace().toString());
+ xmlWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, name.getLocalName(),
+ name.getNamespace().toString());
xmlWriter.writeDefaultNamespace(name.getNamespace().toString());
for(final NormalizedNode<?,?> child : data.getValue()) {
nnWriter.write(child);
}
@Override
- public Response subscribeToStream(final String identifier, final UriInfo uriInfo) {
+ public NormalizedNodeContext subscribeToStream(final String identifier, final UriInfo uriInfo) {
return this.restconf.subscribeToStream(identifier, uriInfo);
}
*/
package org.opendaylight.netconf.sal.restconf.impl;
+import java.util.HashMap;
+import java.util.Map;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
private final InstanceIdentifierContext<? extends SchemaNode> context;
private final NormalizedNode<?,?> data;
private final WriterParameters writerParameters;
+ private Map<String, Object> headers = new HashMap<>();
public NormalizedNodeContext(final InstanceIdentifierContext<? extends SchemaNode> context,
- final NormalizedNode<?, ?> data, WriterParameters writerParameters) {
+ final NormalizedNode<?, ?> data, final WriterParameters writerParameters) {
this.context = context;
this.data = data;
this.writerParameters = writerParameters;
}
+ public NormalizedNodeContext(final InstanceIdentifierContext<? extends SchemaNode> context,
+ final NormalizedNode<?, ?> data, final WriterParameters writerParameters,
+ final Map<String, Object> headers) {
+ this.context = context;
+ this.data = data;
+ this.writerParameters = writerParameters;
+ this.headers = headers;
+ }
+
public NormalizedNodeContext(final InstanceIdentifierContext<? extends SchemaNode> context,
final NormalizedNode<?, ?> data) {
this.context = context;
this.writerParameters = new WriterParameters.WriterParametersBuilder().build();
}
+ public NormalizedNodeContext(final InstanceIdentifierContext<? extends SchemaNode> context,
+ final NormalizedNode<?, ?> data, final Map<String, Object> headers) {
+ this.context = context;
+ this.data = data;
+ // default writer parameters
+ this.writerParameters = new WriterParameters.WriterParametersBuilder().build();
+ this.headers = headers;
+ }
+
+
public InstanceIdentifierContext<? extends SchemaNode> getInstanceIdentifierContext() {
- return context;
+ return this.context;
}
public NormalizedNode<?, ?> getData() {
- return data;
+ return this.data;
}
public WriterParameters getWriterParameters() {
- return writerParameters;
+ return this.writerParameters;
+ }
+
+ /**
+ * @return
+ */
+ public Map<String, Object> getNewHeaders() {
+ return this.headers;
}
}
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
* </ul>
*/
@Override
- public Response subscribeToStream(final String identifier, final UriInfo uriInfo) {
+ public NormalizedNodeContext subscribeToStream(final String identifier, final UriInfo uriInfo) {
+ URI response = null;
if (identifier.contains(DATA_SUBSCR)) {
- return dataSubs(identifier, uriInfo);
+ response = dataSubs(identifier, uriInfo);
} else if (identifier.contains(NOTIFICATION_STREAM)) {
- return notifStream(identifier, uriInfo);
+ response = notifStream(identifier, uriInfo);
}
+
+ if(response != null){
+ // prepare node with value of location
+ final InstanceIdentifierContext<?> iid = prepareIIDSubsStreamOutput();
+ final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> builder = ImmutableLeafNodeBuilder
+ .create().withValue(response.toString());
+ builder.withNodeIdentifier(
+ NodeIdentifier.create(QName.create("subscribe:to:notification", "2016-10-28", "location")));
+
+ // prepare new header with location
+ final Map<String, Object> headers = new HashMap<>();
+ headers.put("Location", response);
+
+ return new NormalizedNodeContext(iid, builder.build(), headers);
+ }
+
final String msg = "Bad type of notification of sal-remote";
LOG.warn(msg);
throw new RestconfDocumentedException(msg);
}
+ /**
+ * @return {@link InstanceIdentifierContext} of location leaf for
+ * notification
+ */
+ private 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
+ .findModuleByNamespaceAndRevision(qnameBase.getNamespace(), qnameBase.getRevision())
+ .getDataChildByName(qnameBase)).getDataChildByName(QName.create(qnameBase, "location"));
+ final List<PathArgument> path = new ArrayList<>();
+ path.add(NodeIdentifier.create(qnameBase));
+ path.add(NodeIdentifier.create(QName.create(qnameBase, "location")));
+
+ return new InstanceIdentifierContext<SchemaNode>(YangInstanceIdentifier.create(path), location, null,
+ schemaCtx);
+ }
+
/**
* Register notification listener by stream name
*
* - uriInfo
* @return {@link Response}
*/
- private Response notifStream(final String identifier, final UriInfo uriInfo) {
+ private URI notifStream(final String identifier, final UriInfo uriInfo) {
final String streamName = Notificator.createStreamNameFromUri(identifier);
if (Strings.isNullOrEmpty(streamName)) {
throw new RestconfDocumentedException("Stream name is empty.", ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
final UriBuilder uriToWebsocketServerBuilder = uriBuilder.port(notificationPort).scheme("ws");
final URI uriToWebsocketServer = uriToWebsocketServerBuilder.replacePath(streamName).build();
- return Response.status(Status.OK).location(uriToWebsocketServer).build();
+ return uriToWebsocketServer;
}
/**
* - uri info
* @return {@link Response}
*/
- private Response dataSubs(final String identifier, final UriInfo uriInfo) {
+ private URI dataSubs(final String identifier, final UriInfo uriInfo) {
final String streamName = Notificator.createStreamNameFromUri(identifier);
if (Strings.isNullOrEmpty(streamName)) {
throw new RestconfDocumentedException("Stream name is empty.", ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
final UriBuilder uriToWebsocketServerBuilder = uriBuilder.port(notificationPort).scheme("ws");
final URI uriToWebsocketServer = uriToWebsocketServerBuilder.replacePath(streamName).build();
- return Response.status(Status.OK).location(uriToWebsocketServer).build();
+ return uriToWebsocketServer;
}
@Override
import java.math.BigInteger;
import java.util.concurrent.atomic.AtomicLong;
-import javax.ws.rs.core.Context;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.UriInfo;
AtomicLong failurePut = new AtomicLong();
AtomicLong failureDelete = new AtomicLong();
- private static final StatisticsRestconfServiceWrapper INSTANCE = new StatisticsRestconfServiceWrapper(RestconfImpl.getInstance());
+ private static final StatisticsRestconfServiceWrapper INSTANCE =
+ new StatisticsRestconfServiceWrapper(RestconfImpl.getInstance());
final RestconfService delegate;
@Override
public Object getRoot() {
- return delegate.getRoot();
+ return this.delegate.getRoot();
}
@Override
public NormalizedNodeContext getModules(final UriInfo uriInfo) {
- return delegate.getModules(uriInfo);
+ return this.delegate.getModules(uriInfo);
}
@Override
public NormalizedNodeContext getModules(final String identifier, final UriInfo uriInfo) {
- return delegate.getModules(identifier, uriInfo);
+ return this.delegate.getModules(identifier, uriInfo);
}
@Override
public NormalizedNodeContext getModule(final String identifier, final UriInfo uriInfo) {
- return delegate.getModule(identifier, uriInfo);
+ return this.delegate.getModule(identifier, uriInfo);
}
@Override
public NormalizedNodeContext getOperations(final UriInfo uriInfo) {
- return delegate.getOperations(uriInfo);
+ return this.delegate.getOperations(uriInfo);
}
@Override
public NormalizedNodeContext getOperations(final String identifier, final UriInfo uriInfo) {
- return delegate.getOperations(identifier, uriInfo);
+ return this.delegate.getOperations(identifier, uriInfo);
}
@Override
- public NormalizedNodeContext invokeRpc(final String identifier, final NormalizedNodeContext payload, final UriInfo uriInfo) {
- rpc.incrementAndGet();
- return delegate.invokeRpc(identifier, payload, uriInfo);
+ public NormalizedNodeContext invokeRpc(final String identifier, final NormalizedNodeContext payload,
+ final UriInfo uriInfo) {
+ this.rpc.incrementAndGet();
+ return this.delegate.invokeRpc(identifier, payload, uriInfo);
}
@Override
public NormalizedNodeContext invokeRpc(final String identifier, final String noPayload, final UriInfo uriInfo) {
- rpc.incrementAndGet();
- return delegate.invokeRpc(identifier, noPayload, uriInfo);
+ this.rpc.incrementAndGet();
+ return this.delegate.invokeRpc(identifier, noPayload, uriInfo);
}
@Override
public NormalizedNodeContext readConfigurationData(final String identifier, final UriInfo uriInfo) {
- configGet.incrementAndGet();
+ this.configGet.incrementAndGet();
NormalizedNodeContext normalizedNodeContext = null;
try {
- normalizedNodeContext = delegate.readConfigurationData(identifier, uriInfo);
+ normalizedNodeContext = this.delegate.readConfigurationData(identifier, uriInfo);
if (normalizedNodeContext.getData() != null) {
- successGetConfig.incrementAndGet();
+ this.successGetConfig.incrementAndGet();
}
else {
- failureGetConfig.incrementAndGet();
+ this.failureGetConfig.incrementAndGet();
}
- } catch (Exception e) {
- failureGetConfig.incrementAndGet();
+ } catch (final Exception e) {
+ this.failureGetConfig.incrementAndGet();
throw e;
}
return normalizedNodeContext;
@Override
public NormalizedNodeContext readOperationalData(final String identifier, final UriInfo uriInfo) {
- operationalGet.incrementAndGet();
+ this.operationalGet.incrementAndGet();
NormalizedNodeContext normalizedNodeContext = null;
try {
- normalizedNodeContext = delegate.readOperationalData(identifier, uriInfo);
+ normalizedNodeContext = this.delegate.readOperationalData(identifier, uriInfo);
if (normalizedNodeContext.getData() != null) {
- successGetOperational.incrementAndGet();
+ this.successGetOperational.incrementAndGet();
}
else {
- failureGetOperational.incrementAndGet();
+ this.failureGetOperational.incrementAndGet();
}
- } catch (Exception e) {
- failureGetOperational.incrementAndGet();
+ } catch (final Exception e) {
+ this.failureGetOperational.incrementAndGet();
throw e;
}
return normalizedNodeContext;
@Override
public Response updateConfigurationData(final String identifier, final NormalizedNodeContext payload) {
- configPut.incrementAndGet();
+ this.configPut.incrementAndGet();
Response response = null;
try {
- response = delegate.updateConfigurationData(identifier, payload);
+ response = this.delegate.updateConfigurationData(identifier, payload);
if (response.getStatus() == Status.OK.getStatusCode()) {
- successPut.incrementAndGet();
+ this.successPut.incrementAndGet();
}
else {
- failurePut.incrementAndGet();
+ this.failurePut.incrementAndGet();
}
- } catch (Exception e) {
- failurePut.incrementAndGet();
+ } catch (final Exception e) {
+ this.failurePut.incrementAndGet();
throw e;
}
return response;
}
@Override
- public Response createConfigurationData(final String identifier, final NormalizedNodeContext payload, final UriInfo uriInfo) {
- configPost.incrementAndGet();
+ public Response createConfigurationData(final String identifier, final NormalizedNodeContext payload,
+ final UriInfo uriInfo) {
+ this.configPost.incrementAndGet();
Response response = null;
try {
- response = delegate.createConfigurationData(identifier, payload, uriInfo);
+ response = this.delegate.createConfigurationData(identifier, payload, uriInfo);
if (response.getStatus() == Status.OK.getStatusCode()) {
- successPost.incrementAndGet();
+ this.successPost.incrementAndGet();
}
else {
- failurePost.incrementAndGet();
+ this.failurePost.incrementAndGet();
}
- } catch (Exception e) {
- failurePost.incrementAndGet();
+ } catch (final Exception e) {
+ this.failurePost.incrementAndGet();
throw e;
}
return response;
@Override
public Response createConfigurationData(final NormalizedNodeContext payload, final UriInfo uriInfo) {
- configPost.incrementAndGet();
+ this.configPost.incrementAndGet();
Response response = null;
try {
- response = delegate.createConfigurationData(payload, uriInfo);
+ response = this.delegate.createConfigurationData(payload, uriInfo);
if (response.getStatus() == Status.OK.getStatusCode()) {
- successPost.incrementAndGet();
+ this.successPost.incrementAndGet();
}
else {
- failurePost.incrementAndGet();
+ this.failurePost.incrementAndGet();
}
- }catch (Exception e) {
- failurePost.incrementAndGet();
+ }catch (final Exception e) {
+ this.failurePost.incrementAndGet();
throw e;
}
return response;
@Override
public Response deleteConfigurationData(final String identifier) {
- configDelete.incrementAndGet();
+ this.configDelete.incrementAndGet();
Response response = null;
try {
- response = delegate.deleteConfigurationData(identifier);
+ response = this.delegate.deleteConfigurationData(identifier);
if (response.getStatus() == Status.OK.getStatusCode()) {
- successDelete.incrementAndGet();
+ this.successDelete.incrementAndGet();
}
else {
- failureDelete.incrementAndGet();
+ this.failureDelete.incrementAndGet();
}
- } catch (Exception e) {
- failureDelete.incrementAndGet();
+ } catch (final Exception e) {
+ this.failureDelete.incrementAndGet();
throw e;
}
return response;
}
@Override
- public Response subscribeToStream(final String identifier, final UriInfo uriInfo) {
- return delegate.subscribeToStream(identifier, uriInfo);
+ public NormalizedNodeContext subscribeToStream(final String identifier, final UriInfo uriInfo) {
+ return this.delegate.subscribeToStream(identifier, uriInfo);
}
@Override
public NormalizedNodeContext getAvailableStreams(final UriInfo uriInfo) {
- return delegate.getAvailableStreams(uriInfo);
+ return this.delegate.getAvailableStreams(uriInfo);
}
@Override
- public PATCHStatusContext patchConfigurationData(final String identifier, final PATCHContext payload, final UriInfo
- uriInfo) {
- return delegate.patchConfigurationData(identifier, payload, uriInfo);
+ public PATCHStatusContext patchConfigurationData(final String identifier, final PATCHContext payload,
+ final UriInfo uriInfo) {
+ return this.delegate.patchConfigurationData(identifier, payload, uriInfo);
}
@Override
public PATCHStatusContext patchConfigurationData(final PATCHContext payload, final UriInfo uriInfo) {
- return delegate.patchConfigurationData(payload, uriInfo);
+ return this.delegate.patchConfigurationData(payload, uriInfo);
}
public BigInteger getConfigDelete() {
- return BigInteger.valueOf(configDelete.get());
+ return BigInteger.valueOf(this.configDelete.get());
}
public BigInteger getConfigGet() {
- return BigInteger.valueOf(configGet.get());
+ return BigInteger.valueOf(this.configGet.get());
}
public BigInteger getConfigPost() {
- return BigInteger.valueOf(configPost.get());
+ return BigInteger.valueOf(this.configPost.get());
}
public BigInteger getConfigPut() {
- return BigInteger.valueOf(configPut.get());
+ return BigInteger.valueOf(this.configPut.get());
}
public BigInteger getOperationalGet() {
- return BigInteger.valueOf(operationalGet.get());
+ return BigInteger.valueOf(this.operationalGet.get());
}
public BigInteger getRpc() {
- return BigInteger.valueOf(rpc.get());
+ return BigInteger.valueOf(this.rpc.get());
}
public BigInteger getSuccessGetConfig() {
- return BigInteger.valueOf(successGetConfig.get());
+ return BigInteger.valueOf(this.successGetConfig.get());
}
public BigInteger getSuccessGetOperational() {
- return BigInteger.valueOf(successGetOperational.get());
+ return BigInteger.valueOf(this.successGetOperational.get());
}
public BigInteger getSuccessPost() {
- return BigInteger.valueOf(successPost.get());
+ return BigInteger.valueOf(this.successPost.get());
}
public BigInteger getSuccessPut() {
- return BigInteger.valueOf(successPut.get());
+ return BigInteger.valueOf(this.successPut.get());
}
public BigInteger getSuccessDelete() {
- return BigInteger.valueOf(successDelete.get());
+ return BigInteger.valueOf(this.successDelete.get());
}
public BigInteger getFailureGetConfig() {
- return BigInteger.valueOf(failureGetConfig.get());
+ return BigInteger.valueOf(this.failureGetConfig.get());
}
public BigInteger getFailureGetOperational() {
- return BigInteger.valueOf(failureGetOperational.get());
+ return BigInteger.valueOf(this.failureGetOperational.get());
}
public BigInteger getFailurePost() {
- return BigInteger.valueOf(failurePost.get());
+ return BigInteger.valueOf(this.failurePost.get());
}
public BigInteger getFailurePut() {
- return BigInteger.valueOf(failurePut.get());
+ return BigInteger.valueOf(this.failurePut.get());
}
public BigInteger getFailureDelete() {
- return BigInteger.valueOf(failureDelete.get());
+ return BigInteger.valueOf(this.failureDelete.get());
}
}
\ No newline at end of file
--- /dev/null
+module subscribe-to-notification {
+
+ yang-version 1;
+ namespace "subscribe:to:notification";
+ prefix "subs-to-notifi";
+
+ description
+ "Added input parameters to rpc create-data-change-event-subscription and to create-notification-stream";
+
+ revision "2016-10-28" {
+ }
+
+ container "notifi"{
+ leaf "location"{
+ type string;
+ }
+ }
+}
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import java.text.ParseException;
import java.util.Set;
import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
import org.junit.Before;
doReturn(mount).when(iiCtx).getMountPoint();
final DOMRpcService rpcService = mock(DOMRpcService.class);
doReturn(Optional.of(rpcService)).when(mount).getService(DOMRpcService.class);
- doReturn(Futures.immediateCheckedFuture(mock(DOMRpcResult.class))).when(rpcService).invokeRpc(any(SchemaPath.class), any(NormalizedNode.class));
+ doReturn(Futures.immediateCheckedFuture(mock(DOMRpcResult.class))).when(rpcService)
+ .invokeRpc(any(SchemaPath.class), any(NormalizedNode.class));
this.restconfImpl.invokeRpc("randomId", ctx, uriInfo);
this.restconfImpl.invokeRpc("ietf-netconf", ctx, uriInfo);
verify(rpcService, times(2)).invokeRpc(any(SchemaPath.class), any(NormalizedNode.class));
this.restconfImpl.setBroker(brokerFacade);
// subscribe to stream and verify response
- final Response response = this.restconfImpl.subscribeToStream(identifier, uriInfo);
- assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
+ final NormalizedNodeContext response = this.restconfImpl.subscribeToStream(identifier, uriInfo);
// remove test notification stream
Notificator.removeAllListeners();
--- /dev/null
+module subscribe-to-notification {
+
+ yang-version 1;
+ namespace "subscribe:to:notification";
+ prefix "subs-to-notifi";
+
+ description
+ "Added input parameters to rpc create-data-change-event-subscription and to create-notification-stream";
+
+ revision "2016-10-28" {
+ }
+
+ container "notifi"{
+ leaf "location"{
+ type string;
+ }
+ }
+}
Code Review / netconf.git / commitdiff