Code Review / netconf.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Refactor ServerRequest
[netconf.git] / restconf / restconf-nb / src / main / java / org / opendaylight / restconf / server / mdsal / MdsalRestconfServer.java
diff --git a/restconf/restconf-nb/src/main/java/org/opendaylight/restconf/server/mdsal/MdsalRestconfServer.java b/restconf/restconf-nb/src/main/java/org/opendaylight/restconf/server/mdsal/MdsalRestconfServer.java
index 3fc09ce4b82dd6693fd612f5bcf55dcee7f44568..ca51fa156f956f7220577dc5b6c61f0c3d3bd25c 100644 (file)
--- a/restconf/restconf-nb/src/main/java/org/opendaylight/restconf/server/mdsal/MdsalRestconfServer.java
+++ b/restconf/restconf-nb/src/main/java/org/opendaylight/restconf/server/mdsal/MdsalRestconfServer.java
@@ -31,7 +31,6 @@ import org.opendaylight.mdsal.dom.api.DOMRpcService;
 import org.opendaylight.restconf.api.ApiPath;
 import org.opendaylight.restconf.api.FormattableBody;
 import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
-import org.opendaylight.restconf.common.errors.RestconfFuture;
 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.transactions.RestconfStrategy.StrategyAndTail;
@@ -50,6 +49,7 @@ import org.opendaylight.restconf.server.api.OperationInputBody;
 import org.opendaylight.restconf.server.api.PatchBody;
 import org.opendaylight.restconf.server.api.ResourceBody;
 import org.opendaylight.restconf.server.api.RestconfServer;
+import org.opendaylight.restconf.server.api.ServerException;
 import org.opendaylight.restconf.server.api.ServerRequest;
 import org.opendaylight.restconf.server.spi.RpcImplementation;
 import org.opendaylight.yangtools.yang.common.Empty;
@@ -143,164 +143,175 @@ public final class MdsalRestconfServer implements RestconfServer, AutoCloseable
     }
 
     @Override
-    public RestconfFuture<Empty> dataDELETE(final ServerRequest request, final ApiPath identifier) {
+    public void dataDELETE(final ServerRequest<Empty> request, final ApiPath identifier) {
         final StrategyAndTail stratAndTail;
         try {
             stratAndTail = localStrategy().resolveStrategy(identifier);
-        } catch (RestconfDocumentedException e) {
-            return RestconfFuture.failed(e);
+        } catch (ServerException e) {
+            request.completeWith(e);
+            return;
         }
-        return stratAndTail.strategy().dataDELETE(request, stratAndTail.tail());
+        stratAndTail.strategy().dataDELETE(request, stratAndTail.tail());
     }
 
     @Override
-    public RestconfFuture<DataGetResult> dataGET(final ServerRequest request) {
-        return localStrategy().dataGET(request, ApiPath.empty());
+    public void dataGET(final ServerRequest<DataGetResult> request) {
+        localStrategy().dataGET(request, ApiPath.empty());
     }
 
     @Override
-    public RestconfFuture<DataGetResult> dataGET(final ServerRequest request, final ApiPath identifier) {
+    public void dataGET(final ServerRequest<DataGetResult> request, final ApiPath identifier) {
         final StrategyAndTail stratAndTail;
         try {
             stratAndTail = localStrategy().resolveStrategy(identifier);
-        } catch (RestconfDocumentedException e) {
-            return RestconfFuture.failed(e);
+        } catch (ServerException e) {
+            request.completeWith(e);
+            return;
         }
-        return stratAndTail.strategy().dataGET(request, stratAndTail.tail());
+        stratAndTail.strategy().dataGET(request, stratAndTail.tail());
     }
 
     @Override
-    public RestconfFuture<DataPatchResult> dataPATCH(final ServerRequest request, final ResourceBody body) {
-        return localStrategy().dataPATCH(ApiPath.empty(), body);
+    public void dataPATCH(final ServerRequest<DataPatchResult> request, final ResourceBody body) {
+        localStrategy().dataPATCH(request, ApiPath.empty(), body);
     }
 
     @Override
-    public RestconfFuture<DataPatchResult> dataPATCH(final ServerRequest request, final ApiPath identifier,
+    public void dataPATCH(final ServerRequest<DataPatchResult> request, final ApiPath identifier,
             final ResourceBody body) {
         final StrategyAndTail strategyAndTail;
         try {
             strategyAndTail = localStrategy().resolveStrategy(identifier);
-        } catch (RestconfDocumentedException e) {
-            return RestconfFuture.failed(e);
+        } catch (ServerException e) {
+            request.completeWith(e);
+            return;
         }
-        return strategyAndTail.strategy().dataPATCH(strategyAndTail.tail(), body);
+        strategyAndTail.strategy().dataPATCH(request, strategyAndTail.tail(), body);
     }
 
     @Override
-    public RestconfFuture<DataYangPatchResult> dataPATCH(final ServerRequest request, final PatchBody body) {
-        return localStrategy().dataPATCH(ApiPath.empty(), body);
+    public void dataPATCH(final ServerRequest<DataYangPatchResult> request, final PatchBody body) {
+        localStrategy().dataPATCH(request, ApiPath.empty(), body);
     }
 
     @Override
-    public RestconfFuture<DataYangPatchResult> dataPATCH(final ServerRequest request, final ApiPath identifier,
+    public void dataPATCH(final ServerRequest<DataYangPatchResult> request, final ApiPath identifier,
             final PatchBody body) {
         final StrategyAndTail strategyAndTail;
         try {
             strategyAndTail = localStrategy().resolveStrategy(identifier);
-        } catch (RestconfDocumentedException e) {
-            return RestconfFuture.failed(e);
+        } catch (ServerException e) {
+            request.completeWith(e);
+            return;
         }
-        return strategyAndTail.strategy().dataPATCH(strategyAndTail.tail(), body);
+        strategyAndTail.strategy().dataPATCH(request, strategyAndTail.tail(), body);
     }
 
     @Override
-    public RestconfFuture<CreateResourceResult> dataPOST(final ServerRequest request, final ChildBody body) {
-        return localStrategy().dataCreatePOST(request, body);
+    public void dataPOST(final ServerRequest<CreateResourceResult> request, final ChildBody body) {
+        localStrategy().dataCreatePOST(request, body);
     }
 
     @Override
-    public RestconfFuture<? extends DataPostResult> dataPOST(final ServerRequest request, final ApiPath identifier,
+    public void dataPOST(final ServerRequest<DataPostResult> request, final ApiPath identifier,
             final DataPostBody body) {
         final StrategyAndTail strategyAndTail;
         try {
             strategyAndTail = localStrategy().resolveStrategy(identifier);
-        } catch (RestconfDocumentedException e) {
-            return RestconfFuture.failed(e);
+        } catch (ServerException e) {
+            request.completeWith(e);
+            return;
         }
-        return strategyAndTail.strategy().dataPOST(request, strategyAndTail.tail(), body);
+        strategyAndTail.strategy().dataPOST(request, strategyAndTail.tail(), body);
     }
 
     @Override
-    public RestconfFuture<DataPutResult> dataPUT(final ServerRequest request, final ResourceBody body) {
-        return localStrategy().dataPUT(request, ApiPath.empty(), body);
+    public void dataPUT(final ServerRequest<DataPutResult> request, final ResourceBody body) {
+        localStrategy().dataPUT(request, ApiPath.empty(), body);
     }
 
     @Override
-    public RestconfFuture<DataPutResult> dataPUT(final ServerRequest request, final ApiPath identifier,
-            final ResourceBody body) {
+    public void dataPUT(final ServerRequest<DataPutResult> request, final ApiPath identifier, final ResourceBody body) {
         final StrategyAndTail strategyAndTail;
         try {
             strategyAndTail = localStrategy().resolveStrategy(identifier);
-        } catch (RestconfDocumentedException e) {
-            return RestconfFuture.failed(e);
+        } catch (ServerException e) {
+            request.completeWith(e);
+            return ;
         }
-        return strategyAndTail.strategy().dataPUT(request, strategyAndTail.tail(), body);
+        strategyAndTail.strategy().dataPUT(request, strategyAndTail.tail(), body);
     }
 
     @Override
-    public RestconfFuture<ModulesGetResult> modulesYangGET(final ServerRequest request, final String fileName,
+    public void modulesYangGET(final ServerRequest<ModulesGetResult> request, final String fileName,
             final String revision) {
-        return modulesGET(fileName, revision, YangTextSource.class);
+        modulesGET(request, fileName, revision, YangTextSource.class);
     }
 
     @Override
-    public RestconfFuture<ModulesGetResult> modulesYangGET(final ServerRequest request, final ApiPath mountPath,
+    public void modulesYangGET(final ServerRequest<ModulesGetResult> request, final ApiPath mountPath,
             final String fileName, final String revision) {
-        return modulesGET(mountPath, fileName, revision, YangTextSource.class);
+        modulesGET(request, mountPath, fileName, revision, YangTextSource.class);
     }
 
     @Override
-    public RestconfFuture<ModulesGetResult> modulesYinGET(final ServerRequest request, final String fileName,
+    public void modulesYinGET(final ServerRequest<ModulesGetResult> request, final String fileName,
             final String revision) {
-        return modulesGET(fileName, revision, YinTextSource.class);
+        modulesGET(request, fileName, revision, YinTextSource.class);
     }
 
     @Override
-    public RestconfFuture<ModulesGetResult> modulesYinGET(final ServerRequest request, final ApiPath mountPath,
+    public void modulesYinGET(final ServerRequest<ModulesGetResult> request, final ApiPath mountPath,
             final String fileName, final String revision) {
-        return modulesGET(mountPath, fileName, revision, YinTextSource.class);
+        modulesGET(request, mountPath, fileName, revision, YinTextSource.class);
     }
 
-    private @NonNull RestconfFuture<ModulesGetResult> modulesGET(final String fileName, final String revision,
+    private void modulesGET(final ServerRequest<ModulesGetResult> request, final String fileName, final String revision,
             final Class<? extends SourceRepresentation> representation) {
-        return modulesGET(localStrategy(), fileName, revision, representation);
+        modulesGET(request, localStrategy(), fileName, revision, representation);
     }
 
-    private @NonNull RestconfFuture<ModulesGetResult> modulesGET(final ApiPath mountPath, final String fileName,
-            final String revision, final Class<? extends SourceRepresentation> representation) {
+    private void modulesGET(final ServerRequest<ModulesGetResult> request, final ApiPath mountPath,
+            final String fileName, final String revision, final Class<? extends SourceRepresentation> representation) {
         final var mountOffset = mountPath.indexOf("yang-ext", "mount");
         if (mountOffset != mountPath.steps().size() - 1) {
-            return RestconfFuture.failed(new RestconfDocumentedException("Mount path has to end with yang-ext:mount"));
+            request.completeWith(new RestconfDocumentedException("Mount path has to end with yang-ext:mount"));
+            return;
         }
 
         final StrategyAndTail stratAndTail;
         try {
             stratAndTail = localStrategy().resolveStrategy(mountPath);
-        } catch (RestconfDocumentedException e) {
-            return RestconfFuture.failed(e);
+        } catch (ServerException e) {
+            request.completeWith(e);
+            return;
         }
         // FIXME: require remnant to be empty
-        return modulesGET(stratAndTail.strategy(), fileName, revision, representation);
+        modulesGET(request, stratAndTail.strategy(), fileName, revision, representation);
     }
 
-    private static @NonNull RestconfFuture<ModulesGetResult> modulesGET(final RestconfStrategy strategy,
+    private static void modulesGET(final ServerRequest<ModulesGetResult> request, final RestconfStrategy strategy,
             final String moduleName, final String revisionStr,
             final Class<? extends SourceRepresentation> representation) {
         if (moduleName == null) {
-            return RestconfFuture.failed(new RestconfDocumentedException("Module name must be supplied",
+            request.completeWith(new RestconfDocumentedException("Module name must be supplied",
                 ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE));
+            return;
         }
         if (moduleName.isEmpty() || !YangNames.IDENTIFIER_START.matches(moduleName.charAt(0))) {
-            return RestconfFuture.failed(new RestconfDocumentedException(
+            request.completeWith(new RestconfDocumentedException(
                 "Identifier must start with character from set 'a-zA-Z_", ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE));
+            return;
         }
         if (moduleName.toUpperCase(Locale.ROOT).startsWith("XML")) {
-            return RestconfFuture.failed(new RestconfDocumentedException(
+            request.completeWith(new RestconfDocumentedException(
                 "Identifier must NOT start with XML ignore case", ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE));
+            return;
         }
         if (YangNames.NOT_IDENTIFIER_PART.matchesAnyOf(moduleName.substring(1))) {
-            return RestconfFuture.failed(new RestconfDocumentedException(
+            request.completeWith(new RestconfDocumentedException(
                 "Supplied name has not expected identifier format", ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE));
+            return;
         }
 
         // YANG Revision-compliant string is required
@@ -308,49 +319,54 @@ public final class MdsalRestconfServer implements RestconfServer, AutoCloseable
         try {
             revision = Revision.ofNullable(revisionStr).orElse(null);
         } catch (final DateTimeParseException e) {
-            return RestconfFuture.failed(new RestconfDocumentedException(
+            request.completeWith(new RestconfDocumentedException(
                 "Supplied revision is not in expected date format YYYY-mm-dd",
                 ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE, e));
+            return;
         }
 
-        return strategy.resolveSource(new SourceIdentifier(moduleName, revision), representation)
-            .transform(ModulesGetResult::new);
+        strategy.resolveSource(request, new SourceIdentifier(moduleName, revision), representation);
     }
 
     @Override
-    public RestconfFuture<FormattableBody> operationsGET(final ServerRequest request) {
-        return localStrategy().operationsGET(request);
+    public void operationsGET(final ServerRequest<FormattableBody> request) {
+        localStrategy().operationsGET(request);
     }
 
     @Override
-    public RestconfFuture<FormattableBody> operationsGET(final ServerRequest request, final ApiPath operation) {
+    public void operationsGET(final ServerRequest<FormattableBody> request, final ApiPath operation) {
         final StrategyAndTail strategyAndTail;
         try {
             strategyAndTail = localStrategy().resolveStrategy(operation);
-        } catch (RestconfDocumentedException e) {
-            return RestconfFuture.failed(e);
+        } catch (ServerException e) {
+            request.completeWith(e);
+            return;
         }
 
         final var strategy = strategyAndTail.strategy();
         final var tail = strategyAndTail.tail();
-        return tail.isEmpty() ? strategy.operationsGET(request) : strategy.operationsGET(request, tail);
+        if (tail.isEmpty()) {
+            strategy.operationsGET(request);
+        } else {
+            strategy.operationsGET(request, tail);
+        }
     }
 
     @Override
-    public RestconfFuture<InvokeResult> operationsPOST(final ServerRequest request, final URI restconfURI,
-            final ApiPath apiPath, final OperationInputBody body) {
+    public void operationsPOST(final ServerRequest<InvokeResult> request, final URI restconfURI, final ApiPath apiPath,
+            final OperationInputBody body) {
         final StrategyAndTail strategyAndTail;
         try {
             strategyAndTail = localStrategy().resolveStrategy(apiPath);
-        } catch (RestconfDocumentedException e) {
-            return RestconfFuture.failed(e);
+        } catch (ServerException e) {
+            request.completeWith(e);
+            return;
         }
-        final var strategy = strategyAndTail.strategy();
-        return strategy.operationsPOST(request, restconfURI, strategyAndTail.tail(), body);
+        strategyAndTail.strategy().operationsPOST(request, restconfURI, strategyAndTail.tail(), body);
     }
 
     @Override
-    public RestconfFuture<FormattableBody> yangLibraryVersionGET(final ServerRequest request) {
-        return localStrategy().yangLibraryVersionGET(request);
+    public void yangLibraryVersionGET(final ServerRequest<FormattableBody> request) {
+        localStrategy().yangLibraryVersionGET(request);
     }
 }
Netconf