package org.opendaylight.restconf.nb.rfc8040.rests.services.impl;
import static java.util.Objects.requireNonNull;
-import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.NOTIFICATION_STREAM;
-import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAMS_PATH;
-import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAM_ACCESS_PATH_PART;
-import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAM_LOCATION_PATH_PART;
-import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAM_PATH;
-import static org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants.STREAM_PATH_PART;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.MoreExecutors;
import java.io.IOException;
import java.io.InputStream;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.VarHandle;
import java.net.URI;
import java.time.Clock;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.Encoded;
import org.opendaylight.mdsal.dom.api.DOMActionException;
import org.opendaylight.mdsal.dom.api.DOMActionResult;
import org.opendaylight.mdsal.dom.api.DOMActionService;
-import org.opendaylight.mdsal.dom.api.DOMDataBroker;
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteOperations;
import org.opendaylight.mdsal.dom.api.DOMMountPoint;
-import org.opendaylight.mdsal.dom.api.DOMMountPointService;
import org.opendaylight.mdsal.dom.spi.SimpleDOMActionResult;
import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
+import org.opendaylight.restconf.common.errors.RestconfFuture;
+import org.opendaylight.restconf.common.errors.SettableRestconfFuture;
import org.opendaylight.restconf.common.patch.PatchContext;
import org.opendaylight.restconf.common.patch.PatchStatusContext;
+import org.opendaylight.restconf.common.patch.PatchStatusEntity;
import org.opendaylight.restconf.nb.rfc8040.MediaTypes;
+import org.opendaylight.restconf.nb.rfc8040.ReadDataParams;
import org.opendaylight.restconf.nb.rfc8040.databind.ChildBody;
import org.opendaylight.restconf.nb.rfc8040.databind.DatabindProvider;
import org.opendaylight.restconf.nb.rfc8040.databind.JsonChildBody;
import org.opendaylight.restconf.nb.rfc8040.databind.XmlPatchBody;
import org.opendaylight.restconf.nb.rfc8040.databind.XmlResourceBody;
import org.opendaylight.restconf.nb.rfc8040.databind.jaxrs.QueryParams;
+import org.opendaylight.restconf.nb.rfc8040.legacy.ErrorTags;
import org.opendaylight.restconf.nb.rfc8040.legacy.InstanceIdentifierContext;
import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
-import org.opendaylight.restconf.nb.rfc8040.monitoring.RestconfStateStreams;
-import org.opendaylight.restconf.nb.rfc8040.rests.services.api.RestconfStreamsSubscriptionService;
-import org.opendaylight.restconf.nb.rfc8040.rests.transactions.MdsalRestconfStrategy;
-import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy;
-import org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfStreamsConstants;
-import org.opendaylight.restconf.nb.rfc8040.streams.StreamsConfiguration;
-import org.opendaylight.restconf.nb.rfc8040.streams.listeners.ListenersBroker;
-import org.opendaylight.restconf.nb.rfc8040.streams.listeners.NotificationListenerAdapter;
+import org.opendaylight.restconf.nb.rfc8040.rests.transactions.RestconfStrategy.CreateOrReplaceResult;
import org.opendaylight.restconf.nb.rfc8040.utils.parser.IdentifierCodec;
-import org.opendaylight.restconf.nb.rfc8040.utils.parser.ParserIdentifier;
-import org.opendaylight.yang.gen.v1.urn.sal.restconf.event.subscription.rev140708.NotificationOutputTypeGrouping.NotificationOutputType;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.ErrorTag;
import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.slf4j.Logger;
public final class RestconfDataServiceImpl {
private static final Logger LOG = LoggerFactory.getLogger(RestconfDataServiceImpl.class);
private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MMM-dd HH:mm:ss");
- private static final VarHandle LOCAL_STRATEGY;
- static {
- try {
- LOCAL_STRATEGY = MethodHandles.lookup()
- .findVarHandle(RestconfDataServiceImpl.class, "localStrategy", RestconfStrategy.class);
- } catch (NoSuchFieldException | IllegalAccessException e) {
- throw new ExceptionInInitializerError(e);
- }
- }
-
- private final RestconfStreamsSubscriptionService delegRestconfSubscrService;
private final DatabindProvider databindProvider;
- private final DOMMountPointService mountPointService;
- private final SubscribeToStreamUtil streamUtils;
private final DOMActionService actionService;
- private final DOMDataBroker dataBroker;
- private final ListenersBroker listenersBroker = ListenersBroker.getInstance();
+ private final MdsalRestconfServer server;
- @SuppressWarnings("unused")
- private volatile RestconfStrategy localStrategy;
-
- public RestconfDataServiceImpl(final DatabindProvider databindProvider,
- final DOMDataBroker dataBroker, final DOMMountPointService mountPointService,
- final RestconfStreamsSubscriptionService delegRestconfSubscrService,
- final DOMActionService actionService, final StreamsConfiguration configuration) {
+ public RestconfDataServiceImpl(final DatabindProvider databindProvider, final MdsalRestconfServer server,
+ final DOMActionService actionService) {
this.databindProvider = requireNonNull(databindProvider);
- this.dataBroker = requireNonNull(dataBroker);
- this.mountPointService = requireNonNull(mountPointService);
- this.delegRestconfSubscrService = requireNonNull(delegRestconfSubscrService);
+ this.server = requireNonNull(server);
this.actionService = requireNonNull(actionService);
- streamUtils = configuration.useSSE() ? SubscribeToStreamUtil.serverSentEvents()
- : SubscribeToStreamUtil.webSockets();
}
/**
MediaType.TEXT_XML
})
public Response readData(@Context final UriInfo uriInfo) {
- return readData(null, uriInfo);
+ final var readParams = QueryParams.newReadDataParams(uriInfo);
+ return readData(server.bindRequestRoot(), readParams);
}
/**
public Response readData(@Encoded @PathParam("identifier") final String identifier,
@Context final UriInfo uriInfo) {
final var readParams = QueryParams.newReadDataParams(uriInfo);
- final var schemaContextRef = databindProvider.currentContext().modelContext();
- // FIXME: go through
- final var instanceIdentifier = ParserIdentifier.toInstanceIdentifier(identifier, schemaContextRef,
- mountPointService);
- final var mountPoint = instanceIdentifier.getMountPoint();
-
- // FIXME: this looks quite crazy, why do we even have it?
- if (mountPoint == null && identifier != null && identifier.contains(STREAMS_PATH)
- && !identifier.contains(STREAM_PATH_PART)) {
- createAllYangNotificationStreams(schemaContextRef, uriInfo);
- }
+ return readData(server.bindRequestPath(identifier), readParams);
+ }
- final var queryParams = QueryParams.newQueryParameters(readParams, instanceIdentifier);
+ private Response readData(final InstanceIdentifierContext reqPath, final ReadDataParams readParams) {
+ final var queryParams = QueryParams.newQueryParameters(readParams, reqPath);
final var fieldPaths = queryParams.fieldPaths();
- // FIXME:the model context should be coming from instanceIdentifier!
- final var strategy = getRestconfStrategy(schemaContextRef, mountPoint);
+ final var strategy = server.getRestconfStrategy(reqPath.getSchemaContext(), reqPath.getMountPoint());
final NormalizedNode node;
if (fieldPaths != null && !fieldPaths.isEmpty()) {
- node = strategy.readData(readParams.content(), instanceIdentifier.getInstanceIdentifier(),
+ node = strategy.readData(readParams.content(), reqPath.getInstanceIdentifier(),
readParams.withDefaults(), fieldPaths);
} else {
- node = strategy.readData(readParams.content(), instanceIdentifier.getInstanceIdentifier(),
+ node = strategy.readData(readParams.content(), reqPath.getInstanceIdentifier(),
readParams.withDefaults());
}
-
- // FIXME: this is utter craziness, refactor it properly!
- if (identifier != null && identifier.contains(STREAM_PATH) && identifier.contains(STREAM_ACCESS_PATH_PART)
- && identifier.contains(STREAM_LOCATION_PATH_PART)) {
- final String value = (String) node.body();
- final String streamName = value.substring(value.indexOf(NOTIFICATION_STREAM + '/'));
- delegRestconfSubscrService.subscribeToStream(streamName, uriInfo);
- }
if (node == null) {
throw new RestconfDocumentedException(
- "Request could not be completed because the relevant data model content does not exist",
- ErrorType.PROTOCOL, ErrorTag.DATA_MISSING);
+ "Request could not be completed because the relevant data model content does not exist",
+ ErrorType.PROTOCOL, ErrorTag.DATA_MISSING);
}
return switch (readParams.content()) {
case ALL, CONFIG -> {
final QName type = node.name().getNodeType();
yield Response.status(Status.OK)
- .entity(new NormalizedNodePayload(instanceIdentifier.inference(), node, queryParams))
+ .entity(new NormalizedNodePayload(reqPath.inference(), node, queryParams))
.header("ETag", '"' + type.getModule().getRevision().map(Revision::toString).orElse(null) + "-"
+ type.getLocalName() + '"')
.header("Last-Modified", FORMATTER.format(LocalDateTime.now(Clock.systemUTC())))
.build();
}
case NONCONFIG -> Response.status(Status.OK)
- .entity(new NormalizedNodePayload(instanceIdentifier.inference(), node, queryParams))
+ .entity(new NormalizedNodePayload(reqPath.inference(), node, queryParams))
.build();
};
}
- private void createAllYangNotificationStreams(final EffectiveModelContext schemaContext, final UriInfo uriInfo) {
- final var transaction = dataBroker.newWriteOnlyTransaction();
-
- for (var module : schemaContext.getModuleStatements().values()) {
- final var moduleName = module.argument().getLocalName();
- // Note: this handles only RFC6020 notifications
- module.streamEffectiveSubstatements(NotificationEffectiveStatement.class).forEach(notification -> {
- final var notifName = notification.argument();
-
- writeNotificationStreamToDatastore(schemaContext, uriInfo, transaction,
- createYangNotifiStream(listenersBroker, moduleName, notifName, NotificationOutputType.XML));
- writeNotificationStreamToDatastore(schemaContext, uriInfo, transaction,
- createYangNotifiStream(listenersBroker, moduleName, notifName, NotificationOutputType.JSON));
- });
- }
-
- try {
- transaction.commit().get();
- } catch (final InterruptedException | ExecutionException e) {
- throw new RestconfDocumentedException("Problem while putting data to DS.", e);
- }
- }
-
- private static NotificationListenerAdapter createYangNotifiStream(final ListenersBroker listenersBroker,
- final String moduleName, final QName notifName, final NotificationOutputType outputType) {
- final var streamName = createNotificationStreamName(moduleName, notifName.getLocalName(), outputType);
-
- final var existing = listenersBroker.notificationListenerFor(streamName);
- return existing != null ? existing
- : listenersBroker.registerNotificationListener(Absolute.of(notifName), streamName, outputType);
- }
-
- private static String createNotificationStreamName(final String moduleName, final String notifName,
- final NotificationOutputType outputType) {
- final var sb = new StringBuilder()
- .append(RestconfStreamsConstants.NOTIFICATION_STREAM)
- .append('/').append(moduleName).append(':').append(notifName);
- if (outputType != NotificationOutputType.XML) {
- sb.append('/').append(outputType.getName());
- }
- return sb.toString();
- }
-
- private void writeNotificationStreamToDatastore(final EffectiveModelContext schemaContext,
- final UriInfo uriInfo, final DOMDataTreeWriteOperations tx, final NotificationListenerAdapter listener) {
- final URI uri = streamUtils.prepareUriByStreamName(uriInfo, listener.getStreamName());
- final MapEntryNode mapToStreams = RestconfStateStreams.notificationStreamEntry(schemaContext,
- listener.getSchemaPath().lastNodeIdentifier(), null, listener.getOutputType(), uri);
-
- tx.merge(LogicalDatastoreType.OPERATIONAL,
- RestconfStateStreams.restconfStateStreamPath(mapToStreams.name()), mapToStreams);
- }
-
/**
* Replace the data store.
*
* @param uriInfo request URI information
* @param body data node for put to config DS
- * @return {@link Response}
+ * @param ar {@link AsyncResponse} which needs to be completed
*/
@PUT
@Path("/data")
MediaTypes.APPLICATION_YANG_DATA_JSON,
MediaType.APPLICATION_JSON,
})
- public Response putDataJSON(@Context final UriInfo uriInfo, final InputStream body) {
+ public void putDataJSON(@Context final UriInfo uriInfo, final InputStream body, @Suspended final AsyncResponse ar) {
try (var jsonBody = new JsonResourceBody(body)) {
- return putData(null, uriInfo, jsonBody);
+ putData(null, uriInfo, jsonBody, ar);
}
}
* @param identifier path to target
* @param uriInfo request URI information
* @param body data node for put to config DS
- * @return {@link Response}
+ * @param ar {@link AsyncResponse} which needs to be completed
*/
@PUT
@Path("/data/{identifier:.+}")
MediaTypes.APPLICATION_YANG_DATA_JSON,
MediaType.APPLICATION_JSON,
})
- public Response putDataJSON(@Encoded @PathParam("identifier") final String identifier,
- @Context final UriInfo uriInfo, final InputStream body) {
+ public void putDataJSON(@Encoded @PathParam("identifier") final String identifier,
+ @Context final UriInfo uriInfo, final InputStream body, @Suspended final AsyncResponse ar) {
try (var jsonBody = new JsonResourceBody(body)) {
- return putData(identifier, uriInfo, jsonBody);
+ putData(identifier, uriInfo, jsonBody, ar);
}
}
*
* @param uriInfo request URI information
* @param body data node for put to config DS
- * @return {@link Response}
+ * @param ar {@link AsyncResponse} which needs to be completed
*/
@PUT
@Path("/data")
MediaType.APPLICATION_XML,
MediaType.TEXT_XML
})
- public Response putDataXML(@Context final UriInfo uriInfo, final InputStream body) {
+ public void putDataXML(@Context final UriInfo uriInfo, final InputStream body, @Suspended final AsyncResponse ar) {
try (var xmlBody = new XmlResourceBody(body)) {
- return putData(null, uriInfo, xmlBody);
+ putData(null, uriInfo, xmlBody, ar);
}
}
* @param identifier path to target
* @param uriInfo request URI information
* @param body data node for put to config DS
- * @return {@link Response}
+ * @param ar {@link AsyncResponse} which needs to be completed
*/
@PUT
@Path("/data/{identifier:.+}")
MediaType.APPLICATION_XML,
MediaType.TEXT_XML
})
- public Response putDataXML(@Encoded @PathParam("identifier") final String identifier,
- @Context final UriInfo uriInfo, final InputStream body) {
+ public void putDataXML(@Encoded @PathParam("identifier") final String identifier,
+ @Context final UriInfo uriInfo, final InputStream body, @Suspended final AsyncResponse ar) {
try (var xmlBody = new XmlResourceBody(body)) {
- return putData(identifier, uriInfo, xmlBody);
+ putData(identifier, uriInfo, xmlBody, ar);
}
}
- private Response putData(final @Nullable String identifier, final UriInfo uriInfo, final ResourceBody body) {
- final var localModel = databindProvider.currentContext().modelContext();
- final var context = ParserIdentifier.toInstanceIdentifier(identifier, localModel, mountPointService);
- final var insert = QueryParams.parseInsert(context.getSchemaContext(), uriInfo);
- final var req = bindResourceRequest(context, body);
+ private void putData(final @Nullable String identifier, final UriInfo uriInfo, final ResourceBody body,
+ final AsyncResponse ar) {
+ final var reqPath = server.bindRequestPath(identifier);
+ final var insert = QueryParams.parseInsert(reqPath.getSchemaContext(), uriInfo);
+ final var req = bindResourceRequest(reqPath, body);
- return switch (
- req.strategy().putData(req.path(), req.data(), insert)) {
- // Note: no Location header, as it matches the request path
- case CREATED -> Response.status(Status.CREATED).build();
- case REPLACED -> Response.noContent().build();
- };
+ req.strategy().putData(req.path(), req.data(), insert).addCallback(new JaxRsRestconfCallback<>(ar) {
+ @Override
+ Response transform(final CreateOrReplaceResult result) {
+ return switch (result) {
+ // Note: no Location header, as it matches the request path
+ case CREATED -> Response.status(Status.CREATED).build();
+ case REPLACED -> Response.noContent().build();
+ };
+ }
+ });
}
/**
*
* @param body data node for put to config DS
* @param uriInfo URI info
- * @return {@link Response}
+ * @param ar {@link AsyncResponse} which needs to be completed
*/
@POST
@Path("/data")
MediaTypes.APPLICATION_YANG_DATA_JSON,
MediaType.APPLICATION_JSON,
})
- public Response postDataJSON(final InputStream body, @Context final UriInfo uriInfo) {
+ public void postDataJSON(final InputStream body, @Context final UriInfo uriInfo,
+ @Suspended final AsyncResponse ar) {
try (var jsonBody = new JsonChildBody(body)) {
- return postData(jsonBody, uriInfo);
+ postData(jsonBody, uriInfo, ar);
}
}
* @param identifier path to target
* @param body data node for put to config DS
* @param uriInfo URI info
- * @return {@link Response}
+ * @param ar {@link AsyncResponse} which needs to be completed
*/
@POST
@Path("/data/{identifier:.+}")
MediaTypes.APPLICATION_YANG_DATA_JSON,
MediaType.APPLICATION_JSON,
})
- public Response postDataJSON(@Encoded @PathParam("identifier") final String identifier, final InputStream body,
- @Context final UriInfo uriInfo) {
- final var instanceIdentifier = ParserIdentifier.toInstanceIdentifier(identifier,
- databindProvider.currentContext().modelContext(), mountPointService);
- if (instanceIdentifier.getSchemaNode() instanceof ActionDefinition) {
+ public void postDataJSON(@Encoded @PathParam("identifier") final String identifier, final InputStream body,
+ @Context final UriInfo uriInfo, @Suspended final AsyncResponse ar) {
+ final var reqPath = server.bindRequestPath(identifier);
+ if (reqPath.getSchemaNode() instanceof ActionDefinition) {
try (var jsonBody = new JsonOperationInputBody(body)) {
- return invokeAction(instanceIdentifier, jsonBody);
+ invokeAction(reqPath, jsonBody, ar);
+ }
+ } else {
+ try (var jsonBody = new JsonChildBody(body)) {
+ postData(reqPath.inference(), reqPath.getInstanceIdentifier(), jsonBody, uriInfo,
+ reqPath.getMountPoint(), ar);
}
- }
-
- try (var jsonBody = new JsonChildBody(body)) {
- return postData(instanceIdentifier.inference(), instanceIdentifier.getInstanceIdentifier(), jsonBody,
- uriInfo, instanceIdentifier.getMountPoint());
}
}
*
* @param body data node for put to config DS
* @param uriInfo URI info
- * @return {@link Response}
+ * @param ar {@link AsyncResponse} which needs to be completed
*/
@POST
@Path("/data")
MediaType.APPLICATION_XML,
MediaType.TEXT_XML
})
- public Response postDataXML(final InputStream body, @Context final UriInfo uriInfo) {
+ public void postDataXML(final InputStream body, @Context final UriInfo uriInfo, @Suspended final AsyncResponse ar) {
try (var xmlBody = new XmlChildBody(body)) {
- return postData(xmlBody, uriInfo);
+ postData(xmlBody, uriInfo, ar);
}
}
* @param identifier path to target
* @param body data node for put to config DS
* @param uriInfo URI info
- * @return {@link Response}
+ * @param ar {@link AsyncResponse} which needs to be completed
*/
@POST
@Path("/data/{identifier:.+}")
MediaType.APPLICATION_XML,
MediaType.TEXT_XML
})
- public Response postDataXML(@Encoded @PathParam("identifier") final String identifier, final InputStream body,
- @Context final UriInfo uriInfo) {
- final var iid = ParserIdentifier.toInstanceIdentifier(identifier,
- databindProvider.currentContext().modelContext(), mountPointService);
- if (iid.getSchemaNode() instanceof ActionDefinition) {
+ public void postDataXML(@Encoded @PathParam("identifier") final String identifier, final InputStream body,
+ @Context final UriInfo uriInfo, @Suspended final AsyncResponse ar) {
+ final var reqPath = server.bindRequestPath(identifier);
+ if (reqPath.getSchemaNode() instanceof ActionDefinition) {
try (var xmlBody = new XmlOperationInputBody(body)) {
- return invokeAction(iid, xmlBody);
+ invokeAction(reqPath, xmlBody, ar);
+ }
+ } else {
+ try (var xmlBody = new XmlChildBody(body)) {
+ postData(reqPath.inference(), reqPath.getInstanceIdentifier(), xmlBody, uriInfo,
+ reqPath.getMountPoint(), ar);
}
- }
-
- try (var xmlBody = new XmlChildBody(body)) {
- return postData(iid.inference(), iid.getInstanceIdentifier(), xmlBody, uriInfo, iid.getMountPoint());
}
}
- private Response postData(final ChildBody body, final UriInfo uriInfo) {
- return postData(Inference.ofDataTreePath(databindProvider.currentContext().modelContext()),
- YangInstanceIdentifier.of(), body, uriInfo, null);
+ private void postData(final ChildBody body, final UriInfo uriInfo, final AsyncResponse ar) {
+ postData(Inference.ofDataTreePath(databindProvider.currentContext().modelContext()),
+ YangInstanceIdentifier.of(), body, uriInfo, null, ar);
}
- private Response postData(final Inference inference, final YangInstanceIdentifier parentPath, final ChildBody body,
- final UriInfo uriInfo, final @Nullable DOMMountPoint mountPoint) {
+ private void postData(final Inference inference, final YangInstanceIdentifier parentPath, final ChildBody body,
+ final UriInfo uriInfo, final @Nullable DOMMountPoint mountPoint, final AsyncResponse ar) {
final var modelContext = inference.getEffectiveModelContext();
final var insert = QueryParams.parseInsert(modelContext, uriInfo);
- final var strategy = getRestconfStrategy(modelContext, mountPoint);
- var path = parentPath;
- final var payload = body.toPayload(path, inference);
+ final var strategy = server.getRestconfStrategy(modelContext, mountPoint);
+ final var payload = body.toPayload(parentPath, inference);
final var data = payload.body();
+ final var path = concat(parentPath, payload.prefix());
- for (var arg : payload.prefix()) {
- path = path.node(arg);
- }
+ strategy.postData(path, data, insert).addCallback(new JaxRsRestconfCallback<>(ar) {
+ @Override
+ Response transform(final Empty result) {
+ return Response.created(resolveLocation(uriInfo, path, modelContext, data)).build();
+ }
+ });
+ }
- strategy.postData(path, data, insert);
- return Response.created(resolveLocation(uriInfo, path, modelContext, data)).build();
+ private static YangInstanceIdentifier concat(final YangInstanceIdentifier parent, final List<PathArgument> args) {
+ var ret = parent;
+ for (var arg : args) {
+ ret = ret.node(arg);
+ }
+ return ret;
}
/**
@Path("/data/{identifier:.+}")
public void deleteData(@Encoded @PathParam("identifier") final String identifier,
@Suspended final AsyncResponse ar) {
- final var instanceIdentifier = ParserIdentifier.toInstanceIdentifier(identifier,
- databindProvider.currentContext().modelContext(), mountPointService);
- final var strategy = getRestconfStrategy(instanceIdentifier.getSchemaContext(),
- instanceIdentifier.getMountPoint());
+ final var reqPath = server.bindRequestPath(identifier);
+ final var strategy = server.getRestconfStrategy(reqPath.getSchemaContext(), reqPath.getMountPoint());
- Futures.addCallback(strategy.delete(instanceIdentifier.getInstanceIdentifier()), new FutureCallback<>() {
+ strategy.delete(reqPath.getInstanceIdentifier()).addCallback(new JaxRsRestconfCallback<>(ar) {
@Override
- public void onSuccess(final Empty result) {
- ar.resume(Response.noContent().build());
+ Response transform(final Empty result) {
+ return Response.noContent().build();
}
-
- @Override
- public void onFailure(final Throwable failure) {
- ar.resume(failure);
- }
- }, MoreExecutors.directExecutor());
+ });
}
/**
})
public void plainPatchDataXML(final InputStream body, @Suspended final AsyncResponse ar) {
try (var xmlBody = new XmlResourceBody(body)) {
- plainPatchData(null, xmlBody, ar);
+ plainPatchData(xmlBody, ar);
}
}
})
public void plainPatchDataJSON(final InputStream body, @Suspended final AsyncResponse ar) {
try (var jsonBody = new JsonResourceBody(body)) {
- plainPatchData(null, jsonBody, ar);
+ plainPatchData(jsonBody, ar);
}
}
}
}
+ /**
+ * Partially modify the target data resource, as defined in
+ * <a href="https://www.rfc-editor.org/rfc/rfc8040#section-4.6.1">RFC8040, section 4.6.1</a>.
+ *
+ * @param body data node for put to config DS
+ * @param ar {@link AsyncResponse} which needs to be completed
+ */
+ private void plainPatchData(final ResourceBody body, final AsyncResponse ar) {
+ plainPatchData(server.bindRequestRoot(), body, ar);
+ }
+
/**
* Partially modify the target data resource, as defined in
* <a href="https://www.rfc-editor.org/rfc/rfc8040#section-4.6.1">RFC8040, section 4.6.1</a>.
* @param body data node for put to config DS
* @param ar {@link AsyncResponse} which needs to be completed
*/
- private void plainPatchData(final @Nullable String identifier, final ResourceBody body, final AsyncResponse ar) {
- final var req = bindResourceRequest(
- ParserIdentifier.toInstanceIdentifier(identifier, databindProvider.currentContext().modelContext(),
- mountPointService),
- body);
- final var future = req.strategy().merge(req.path(), req.data());
-
- Futures.addCallback(future, new FutureCallback<>() {
- @Override
- public void onSuccess(final Empty result) {
- ar.resume(Response.ok().build());
- }
+ private void plainPatchData(final String identifier, final ResourceBody body, final AsyncResponse ar) {
+ plainPatchData(server.bindRequestPath(identifier), body, ar);
+ }
+ /**
+ * Partially modify the target data resource, as defined in
+ * <a href="https://www.rfc-editor.org/rfc/rfc8040#section-4.6.1">RFC8040, section 4.6.1</a>.
+ *
+ * @param reqPath path to target
+ * @param body data node for put to config DS
+ * @param ar {@link AsyncResponse} which needs to be completed
+ */
+ private void plainPatchData(final InstanceIdentifierContext reqPath, final ResourceBody body,
+ final AsyncResponse ar) {
+ final var req = bindResourceRequest(reqPath, body);
+ req.strategy().merge(req.path(), req.data()).addCallback(new JaxRsRestconfCallback<>(ar) {
@Override
- public void onFailure(final Throwable failure) {
- ar.resume(failure);
+ Response transform(final Empty result) {
+ return Response.ok().build();
}
- }, MoreExecutors.directExecutor());
+ });
}
- private @NonNull ResourceRequest bindResourceRequest(final InstanceIdentifierContext context,
+ private @NonNull ResourceRequest bindResourceRequest(final InstanceIdentifierContext reqPath,
final ResourceBody body) {
- final var inference = context.inference();
- final var path = context.getInstanceIdentifier();
- final var data = body.toNormalizedNode(path, inference, context.getSchemaNode());
+ final var inference = reqPath.inference();
+ final var path = reqPath.getInstanceIdentifier();
+ final var data = body.toNormalizedNode(path, inference, reqPath.getSchemaNode());
- return new ResourceRequest(getRestconfStrategy(inference.getEffectiveModelContext(), context.getMountPoint()),
+ return new ResourceRequest(
+ server.getRestconfStrategy(inference.getEffectiveModelContext(), reqPath.getMountPoint()),
path, data);
}
*
* @param identifier path to target
* @param body YANG Patch body
- * @return {@link PatchStatusContext}
+ * @param ar {@link AsyncResponse} which needs to be completed with a {@link PatchStatusContext}
*/
@PATCH
@Path("/data/{identifier:.+}")
MediaTypes.APPLICATION_YANG_DATA_JSON,
MediaTypes.APPLICATION_YANG_DATA_XML
})
- public PatchStatusContext yangPatchDataXML(@Encoded @PathParam("identifier") final String identifier,
- final InputStream body) {
+ public void yangPatchDataXML(@Encoded @PathParam("identifier") final String identifier, final InputStream body,
+ @Suspended final AsyncResponse ar) {
try (var xmlBody = new XmlPatchBody(body)) {
- return yangPatchData(identifier, xmlBody);
+ yangPatchData(identifier, xmlBody, ar);
}
}
* <a href="https://www.rfc-editor.org/rfc/rfc8072#section-2">RFC8072, section 2</a>.
*
* @param body YANG Patch body
- * @return {@link PatchStatusContext}
+ * @param ar {@link AsyncResponse} which needs to be completed with a {@link PatchStatusContext}
*/
@PATCH
@Path("/data")
MediaTypes.APPLICATION_YANG_DATA_JSON,
MediaTypes.APPLICATION_YANG_DATA_XML
})
- public PatchStatusContext yangPatchDataXML(final InputStream body) {
+ public void yangPatchDataXML(final InputStream body, @Suspended final AsyncResponse ar) {
try (var xmlBody = new XmlPatchBody(body)) {
- return yangPatchData(xmlBody);
+ yangPatchData(xmlBody, ar);
}
}
*
* @param identifier path to target
* @param body YANG Patch body
- * @return {@link PatchStatusContext}
+ * @param ar {@link AsyncResponse} which needs to be completed with a {@link PatchStatusContext}
*/
@PATCH
@Path("/data/{identifier:.+}")
MediaTypes.APPLICATION_YANG_DATA_JSON,
MediaTypes.APPLICATION_YANG_DATA_XML
})
- public PatchStatusContext yangPatchDataJSON(@Encoded @PathParam("identifier") final String identifier,
- final InputStream body) {
+ public void yangPatchDataJSON(@Encoded @PathParam("identifier") final String identifier,
+ final InputStream body, @Suspended final AsyncResponse ar) {
try (var jsonBody = new JsonPatchBody(body)) {
- return yangPatchData(identifier, jsonBody);
+ yangPatchData(identifier, jsonBody, ar);
}
}
* <a href="https://www.rfc-editor.org/rfc/rfc8072#section-2">RFC8072, section 2</a>.
*
* @param body YANG Patch body
- * @return {@link PatchStatusContext}
+ * @param ar {@link AsyncResponse} which needs to be completed with a {@link PatchStatusContext}
*/
@PATCH
@Path("/data")
MediaTypes.APPLICATION_YANG_DATA_JSON,
MediaTypes.APPLICATION_YANG_DATA_XML
})
- public PatchStatusContext yangPatchDataJSON(final InputStream body) {
+ public void yangPatchDataJSON(final InputStream body, @Suspended final AsyncResponse ar) {
try (var jsonBody = new JsonPatchBody(body)) {
- return yangPatchData(jsonBody);
+ yangPatchData(jsonBody, ar);
}
}
- private PatchStatusContext yangPatchData(final @NonNull PatchBody body) {
- final var context = databindProvider.currentContext().modelContext();
- return yangPatchData(context, parsePatchBody(context, YangInstanceIdentifier.of(), body), null);
+ private void yangPatchData(final @NonNull PatchBody body, final AsyncResponse ar) {
+ final var context = server.bindRequestRoot().getSchemaContext();
+ yangPatchData(context, parsePatchBody(context, YangInstanceIdentifier.of(), body), null, ar);
}
- private PatchStatusContext yangPatchData(final String identifier, final @NonNull PatchBody body) {
- final var iid = ParserIdentifier.toInstanceIdentifier(requireNonNull(identifier),
- databindProvider.currentContext().modelContext(), mountPointService);
- final var context = iid.getSchemaContext();
- return yangPatchData(context, parsePatchBody(context, iid.getInstanceIdentifier(), body), iid.getMountPoint());
+ private void yangPatchData(final String identifier, final @NonNull PatchBody body,
+ final AsyncResponse ar) {
+ final var reqPath = server.bindRequestPath(identifier);
+ final var modelContext = reqPath.getSchemaContext();
+ yangPatchData(modelContext, parsePatchBody(modelContext, reqPath.getInstanceIdentifier(), body),
+ reqPath.getMountPoint(), ar);
}
-
@VisibleForTesting
- @NonNull PatchStatusContext yangPatchData(final @NonNull EffectiveModelContext modelContext,
- final @NonNull PatchContext patch, final @Nullable DOMMountPoint mountPoint) {
- return getRestconfStrategy(modelContext, mountPoint).patchData(patch);
+ void yangPatchData(final @NonNull EffectiveModelContext modelContext,
+ final @NonNull PatchContext patch, final @Nullable DOMMountPoint mountPoint, final AsyncResponse ar) {
+ server.getRestconfStrategy(modelContext, mountPoint).patchData(patch)
+ .addCallback(new JaxRsRestconfCallback<>(ar) {
+ @Override
+ Response transform(final PatchStatusContext result) {
+ return Response.status(getStatusCode(result)).entity(result).build();
+ }
+ });
+ }
+
+ private static Status getStatusCode(final PatchStatusContext result) {
+ if (result.ok()) {
+ return Status.OK;
+ } else if (result.globalErrors() == null || result.globalErrors().isEmpty()) {
+ return result.editCollection().stream()
+ .filter(patchStatus -> !patchStatus.isOk() && !patchStatus.getEditErrors().isEmpty())
+ .findFirst()
+ .map(PatchStatusEntity::getEditErrors)
+ .flatMap(errors -> errors.stream().findFirst())
+ .map(error -> ErrorTags.statusOf(error.getErrorTag()))
+ .orElse(Status.INTERNAL_SERVER_ERROR);
+ } else {
+ final var error = result.globalErrors().iterator().next();
+ return ErrorTags.statusOf(error.getErrorTag());
+ }
}
private static @NonNull PatchContext parsePatchBody(final @NonNull EffectiveModelContext context,
}
}
- @VisibleForTesting
- @NonNull RestconfStrategy getRestconfStrategy(final EffectiveModelContext modelContext,
- final @Nullable DOMMountPoint mountPoint) {
- if (mountPoint == null) {
- return localStrategy(modelContext);
- }
-
- final var ret = RestconfStrategy.forMountPoint(modelContext, mountPoint);
- if (ret == null) {
- final var mountId = mountPoint.getIdentifier();
- LOG.warn("Mount point {} does not expose a suitable access interface", mountId);
- throw new RestconfDocumentedException("Could not find a supported access interface in mount point "
- + mountId);
- }
- return ret;
- }
-
- private @NonNull RestconfStrategy localStrategy(final EffectiveModelContext modelContext) {
- final var local = (RestconfStrategy) LOCAL_STRATEGY.getAcquire(this);
- if (local != null && modelContext.equals(local.modelContext())) {
- return local;
- }
-
- final var created = new MdsalRestconfStrategy(modelContext, dataBroker);
- LOCAL_STRATEGY.setRelease(this, created);
- return created;
- }
-
/**
* Invoke Action operation.
*
* @param payload {@link NormalizedNodePayload} - the body of the operation
- * @return {@link NormalizedNodePayload} wrapped in {@link Response}
+ * @param ar {@link AsyncResponse} which needs to be completed with a NormalizedNodePayload
*/
- private Response invokeAction(final InstanceIdentifierContext context, final OperationInputBody body) {
- final var yangIIdContext = context.getInstanceIdentifier();
+ private void invokeAction(final InstanceIdentifierContext reqPath, final OperationInputBody body,
+ final AsyncResponse ar) {
+ final var yangIIdContext = reqPath.getInstanceIdentifier();
final ContainerNode input;
try {
- input = body.toContainerNode(context.inference());
+ input = body.toContainerNode(reqPath.inference());
} catch (IOException e) {
LOG.debug("Error reading input", e);
throw new RestconfDocumentedException("Error parsing input: " + e.getMessage(), ErrorType.PROTOCOL,
ErrorTag.MALFORMED_MESSAGE, e);
}
- final var mountPoint = context.getMountPoint();
- final var inference = context.inference();
+ final var mountPoint = reqPath.getMountPoint();
+ final var inference = reqPath.inference();
final var schemaPath = inference.toSchemaInferenceStack().toSchemaNodeIdentifier();
final var response = mountPoint != null ? invokeAction(input, schemaPath, yangIIdContext, mountPoint)
: invokeAction(input, schemaPath, yangIIdContext, actionService);
- final var result = checkActionResponse(response);
- final var resultData = result != null ? result.getOutput().orElse(null) : null;
- if (resultData == null || resultData.isEmpty()) {
- return Response.status(Status.NO_CONTENT).build();
- }
- return Response.status(Status.OK).entity(new NormalizedNodePayload(inference, resultData)).build();
+ response.addCallback(new JaxRsRestconfCallback<>(ar) {
+ @Override
+ Response transform(final DOMActionResult result) {
+ final var output = result.getOutput().orElse(null);
+ return output == null || output.isEmpty() ? Response.status(Status.NO_CONTENT).build()
+ : Response.status(Status.OK).entity(new NormalizedNodePayload(inference, output)).build();
+ }
+ });
}
/**
* @param schemaPath schema path of data
* @return {@link DOMActionResult}
*/
- private static DOMActionResult invokeAction(final ContainerNode data,
+ private static RestconfFuture<DOMActionResult> invokeAction(final ContainerNode data,
final Absolute schemaPath, final YangInstanceIdentifier yangIId, final DOMMountPoint mountPoint) {
- return invokeAction(data, schemaPath, yangIId, mountPoint.getService(DOMActionService.class)
- .orElseThrow(() -> new RestconfDocumentedException("DomAction service is missing.")));
+ final var actionService = mountPoint.getService(DOMActionService.class);
+ return actionService.isPresent() ? invokeAction(data, schemaPath, yangIId, actionService.orElseThrow())
+ : RestconfFuture.failed(new RestconfDocumentedException("DOMActionService is missing."));
}
/**
* @param actionService action service to invoke action
* @return {@link DOMActionResult}
*/
- // FIXME: NETCONF-718: we should be returning a future here
- private static DOMActionResult invokeAction(final ContainerNode data, final Absolute schemaPath,
+ private static RestconfFuture<DOMActionResult> invokeAction(final ContainerNode data, final Absolute schemaPath,
final YangInstanceIdentifier yangIId, final DOMActionService actionService) {
- return RestconfInvokeOperationsServiceImpl.checkedGet(Futures.catching(actionService.invokeAction(
- schemaPath, new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, yangIId.getParent()), data),
- DOMActionException.class,
- cause -> new SimpleDOMActionResult(List.of(RpcResultBuilder.newError(
- ErrorType.RPC, ErrorTag.OPERATION_FAILED, cause.getMessage()))),
- MoreExecutors.directExecutor()));
- }
+ final var ret = new SettableRestconfFuture<DOMActionResult>();
+
+ Futures.addCallback(actionService.invokeAction(schemaPath,
+ new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, yangIId.getParent()), data),
+ new FutureCallback<DOMActionResult>() {
+ @Override
+ public void onSuccess(final DOMActionResult result) {
+ final var errors = result.getErrors();
+ LOG.debug("InvokeAction Error Message {}", errors);
+ if (errors.isEmpty()) {
+ ret.set(result);
+ } else {
+ ret.setFailure(new RestconfDocumentedException("InvokeAction Error Message ", null, errors));
+ }
+ }
+
+ @Override
+ public void onFailure(final Throwable cause) {
+ if (cause instanceof DOMActionException) {
+ ret.set(new SimpleDOMActionResult(List.of(RpcResultBuilder.newError(
+ ErrorType.RPC, ErrorTag.OPERATION_FAILED, cause.getMessage()))));
+ } else if (cause instanceof RestconfDocumentedException e) {
+ ret.setFailure(e);
+ } else if (cause instanceof CancellationException) {
+ ret.setFailure(new RestconfDocumentedException("Action cancelled while executing",
+ ErrorType.RPC, ErrorTag.PARTIAL_OPERATION, cause));
+ } else {
+ ret.setFailure(new RestconfDocumentedException("Invocation failed", cause));
+ }
+ }
+ }, MoreExecutors.directExecutor());
- /**
- * Check the validity of the result.
- *
- * @param response response of Action
- * @return {@link DOMActionResult} result
- */
- private static DOMActionResult checkActionResponse(final DOMActionResult response) {
- if (response == null) {
- return null;
- }
-
- try {
- if (response.getErrors().isEmpty()) {
- return response;
- }
- LOG.debug("InvokeAction Error Message {}", response.getErrors());
- throw new RestconfDocumentedException("InvokeAction Error Message ", null, response.getErrors());
- } catch (final CancellationException e) {
- final String errMsg = "The Action Operation was cancelled while executing.";
- LOG.debug("Cancel Execution: {}", errMsg, e);
- throw new RestconfDocumentedException(errMsg, ErrorType.RPC, ErrorTag.PARTIAL_OPERATION, e);
- }
+ return ret;
}
}