import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
+import java.net.URI;
import java.nio.charset.StandardCharsets;
+import java.util.Collections;
import java.util.List;
import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.PathSegment;
+import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.netconf.sal.rest.impl.JsonNormalizedNodeBodyReader;
* @author Thomas Pantelis
*/
public class JSONRestconfServiceImpl implements JSONRestconfService, AutoCloseable {
- private final static Logger LOG = LoggerFactory.getLogger(JSONRestconfServiceImpl.class);
+ private static final Logger LOG = LoggerFactory.getLogger(JSONRestconfServiceImpl.class);
private static final Annotation[] EMPTY_ANNOTATIONS = new Annotation[0];
+ @SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public void put(final String uriPath, final String payload, final UriInfo uriInfo) throws OperationFailedException {
+ public void put(final String uriPath, final String payload) throws OperationFailedException {
Preconditions.checkNotNull(payload, "payload can't be null");
LOG.debug("put: uriPath: {}, payload: {}", uriPath, payload);
LOG.debug("Parsed NormalizedNode: {}", context.getData());
try {
- RestconfImpl.getInstance().updateConfigurationData(uriPath, context, uriInfo);
+ RestconfImpl.getInstance().updateConfigurationData(uriPath, context, new SimpleUriInfo(uriPath));
} catch (final Exception e) {
propagateExceptionAs(uriPath, e, "PUT");
}
}
+ @SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public void post(final String uriPath, final String payload, final UriInfo uriInfo)
+ public void post(final String uriPath, final String payload)
throws OperationFailedException {
Preconditions.checkNotNull(payload, "payload can't be null");
LOG.debug("Parsed NormalizedNode: {}", context.getData());
try {
- RestconfImpl.getInstance().createConfigurationData(uriPath, context, uriInfo);
+ RestconfImpl.getInstance().createConfigurationData(uriPath, context, new SimpleUriInfo(uriPath));
} catch (final Exception e) {
propagateExceptionAs(uriPath, e, "POST");
}
}
+ @SuppressWarnings("checkstyle:IllegalCatch")
@Override
public void delete(final String uriPath) throws OperationFailedException {
LOG.debug("delete: uriPath: {}", uriPath);
}
}
+ @SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Optional<String> get(final String uriPath, final LogicalDatastoreType datastoreType, final UriInfo uriInfo)
+ public Optional<String> get(final String uriPath, final LogicalDatastoreType datastoreType)
throws OperationFailedException {
LOG.debug("get: uriPath: {}", uriPath);
try {
NormalizedNodeContext readData;
- if(datastoreType == LogicalDatastoreType.CONFIGURATION) {
+ final SimpleUriInfo uriInfo = new SimpleUriInfo(uriPath);
+ if (datastoreType == LogicalDatastoreType.CONFIGURATION) {
readData = RestconfImpl.getInstance().readConfigurationData(uriPath, uriInfo);
} else {
readData = RestconfImpl.getInstance().readOperationalData(uriPath, uriInfo);
return result;
} catch (final Exception e) {
- if(!isDataMissing(e)) {
+ if (!isDataMissing(e)) {
propagateExceptionAs(uriPath, e, "GET");
}
}
}
+ @SuppressWarnings("checkstyle:IllegalCatch")
@Override
- public Optional<String> invokeRpc(final String uriPath, final Optional<String> input) throws OperationFailedException {
+ public Optional<String> invokeRpc(final String uriPath, final Optional<String> input)
+ throws OperationFailedException {
Preconditions.checkNotNull(uriPath, "uriPath can't be null");
final String actualInput = input.isPresent() ? input.get() : null;
String output = null;
try {
NormalizedNodeContext outputContext;
- if(actualInput != null) {
+ if (actualInput != null) {
final InputStream entityStream = new ByteArrayInputStream(actualInput.getBytes(StandardCharsets.UTF_8));
- final NormalizedNodeContext inputContext = JsonNormalizedNodeBodyReader.readFrom(uriPath, entityStream, true);
+ final NormalizedNodeContext inputContext =
+ JsonNormalizedNodeBodyReader.readFrom(uriPath, entityStream, true);
LOG.debug("Parsed YangInstanceIdentifier: {}", inputContext.getInstanceIdentifierContext()
.getInstanceIdentifier());
outputContext = RestconfImpl.getInstance().invokeRpc(uriPath, "", null);
}
- if(outputContext.getData() != null) {
+ if (outputContext.getData() != null) {
output = toJson(outputContext);
}
} catch (final Exception e) {
final NormalizedNodeJsonBodyWriter writer = new NormalizedNodeJsonBodyWriter();
final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
writer.writeTo(readData, NormalizedNodeContext.class, null, EMPTY_ANNOTATIONS,
- MediaType.APPLICATION_JSON_TYPE, null, outputStream );
+ MediaType.APPLICATION_JSON_TYPE, null, outputStream);
return outputStream.toString(StandardCharsets.UTF_8.name());
}
- private static boolean isDataMissing(final Exception e) {
+ private static boolean isDataMissing(final Exception exception) {
boolean dataMissing = false;
- if (e instanceof RestconfDocumentedException) {
- final RestconfDocumentedException rde = (RestconfDocumentedException)e;
- if(!rde.getErrors().isEmpty()) {
- if(rde.getErrors().get(0).getErrorTag() == ErrorTag.DATA_MISSING) {
+ if (exception instanceof RestconfDocumentedException) {
+ final RestconfDocumentedException rde = (RestconfDocumentedException)exception;
+ if (!rde.getErrors().isEmpty()) {
+ if (rde.getErrors().get(0).getErrorTag() == ErrorTag.DATA_MISSING) {
dataMissing = true;
}
}
return dataMissing;
}
- private static void propagateExceptionAs(final String uriPath, final Exception e, final String operation) throws OperationFailedException {
- LOG.debug("Error for uriPath: {}", uriPath, e);
+ private static void propagateExceptionAs(final String uriPath, final Exception exception, final String operation)
+ throws OperationFailedException {
+ LOG.debug("Error for uriPath: {}", uriPath, exception);
- if(e instanceof RestconfDocumentedException) {
- throw new OperationFailedException(String.format("%s failed for URI %s", operation, uriPath), e.getCause(),
- toRpcErrors(((RestconfDocumentedException)e).getErrors()));
+ if (exception instanceof RestconfDocumentedException) {
+ throw new OperationFailedException(String.format(
+ "%s failed for URI %s", operation, uriPath), exception.getCause(),
+ toRpcErrors(((RestconfDocumentedException)exception).getErrors()));
}
- throw new OperationFailedException(String.format("%s failed for URI %s", operation, uriPath), e);
+ throw new OperationFailedException(String.format("%s failed for URI %s", operation, uriPath), exception);
}
private static RpcError[] toRpcErrors(final List<RestconfError> from) {
final RpcError[] to = new RpcError[from.size()];
- int i = 0;
- for(final RestconfError e: from) {
- to[i++] = RpcResultBuilder.newError(toRpcErrorType(e.getErrorType()), e.getErrorTag().getTagValue(),
+ int index = 0;
+ for (final RestconfError e: from) {
+ to[index++] = RpcResultBuilder.newError(toRpcErrorType(e.getErrorType()), e.getErrorTag().getTagValue(),
e.getErrorMessage());
}
}
private static ErrorType toRpcErrorType(final RestconfError.ErrorType errorType) {
- switch(errorType) {
+ switch (errorType) {
case TRANSPORT: {
return ErrorType.TRANSPORT;
}
}
}
}
+
+ private static class SimpleUriInfo implements UriInfo {
+ private final String path;
+ private final MultivaluedMap<String, String> queryParams;
+
+ SimpleUriInfo(String path) {
+ this(path, new MultivaluedHashMap<>());
+ }
+
+ SimpleUriInfo(String path, MultivaluedMap<String, String> queryParams) {
+ this.path = path;
+ this.queryParams = queryParams;
+ }
+
+ @Override
+ public String getPath() {
+ return path;
+ }
+
+ @Override
+ public String getPath(boolean decode) {
+ return path;
+ }
+
+ @Override
+ public List<PathSegment> getPathSegments() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public List<PathSegment> getPathSegments(boolean decode) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public URI getRequestUri() {
+ return URI.create(path);
+ }
+
+ @Override
+ public UriBuilder getRequestUriBuilder() {
+ return UriBuilder.fromUri(getRequestUri());
+ }
+
+ @Override
+ public URI getAbsolutePath() {
+ return getRequestUri();
+ }
+
+ @Override
+ public UriBuilder getAbsolutePathBuilder() {
+ return UriBuilder.fromUri(getAbsolutePath());
+ }
+
+ @Override
+ public URI getBaseUri() {
+ return URI.create("");
+ }
+
+ @Override
+ public UriBuilder getBaseUriBuilder() {
+ return UriBuilder.fromUri(getBaseUri());
+ }
+
+ @Override
+ public MultivaluedMap<String, String> getPathParameters() {
+ return new MultivaluedHashMap<>();
+ }
+
+ @Override
+ public MultivaluedMap<String, String> getPathParameters(boolean decode) {
+ return getPathParameters();
+ }
+
+ @Override
+ public MultivaluedMap<String, String> getQueryParameters() {
+ return queryParams;
+ }
+
+ @Override
+ public MultivaluedMap<String, String> getQueryParameters(boolean decode) {
+ return getQueryParameters();
+ }
+
+ @Override
+ public List<String> getMatchedURIs() {
+ return Collections.emptyList();
+ }
+
+ @Override
+ public List<String> getMatchedURIs(boolean decode) {
+ return getMatchedURIs();
+ }
+
+ @Override
+ public List<Object> getMatchedResources() {
+ return Collections.emptyList();
+ }
+
+ @Override
+ public URI resolve(URI uri) {
+ return uri;
+ }
+
+ @Override
+ public URI relativize(URI uri) {
+ return uri;
+ }
+ }
}
Code Review / netconf.git / blobdiff