feat(API): remove API endpoints that redirect clients to newer API versioned endpoints

schema/update.bash

@@ -24,4 +24,4 @@ while true; do
     fi
 done
 wget http://localhost:8181/api -O - | yq -P 'sort_keys(..)' > "${DIR}/openapi.yaml"
-wget http://localhost:8181/api/v3/graphql/schema.graphql -O "${DIR}/schema.graphql"
+wget http://localhost:8181/api/v4/graphql/schema.graphql -O "${DIR}/schema.graphql"

src/main/java/io/cryostat/JsonRequestFilter.java

@@ -39,11 +39,11 @@ public class JsonRequestFilter implements ContainerRequestFilter {
     static final Set<String> disallowedFields = Set.of("id");
     static final Set<String> allowedPathPatterns =
             Set.of(
-                    "/api/v2.2/discovery",
-                    "/api/v2/rules/[\\w]+",
+                    "/api/v4/discovery",
+                    "/api/v4/rules/[\\w]+",
                     "/api/beta/matchExpressions",
-                    "/api/v2.2/graphql",
-                    "/api/v3/graphql");
+                    "/api/v2/graphql",
+                    "/api/v4/graphql");
 
     private final Map<String, Pattern> compiledPatterns = new HashMap<>();
     @Inject ObjectMapper objectMapper;

src/main/java/io/cryostat/credentials/CredentialCheck.java

@@ -19,7 +19,6 @@
 import java.net.URISyntaxException;
 import java.util.Optional;
 
-import io.cryostat.V2Response;
 import io.cryostat.targets.Target;
 import io.cryostat.targets.TargetConnectionManager;
 
@@ -29,7 +28,6 @@
 import jakarta.inject.Inject;
 import jakarta.ws.rs.POST;
 import jakarta.ws.rs.Path;
-import jakarta.ws.rs.core.Response.Status;
 import org.jboss.resteasy.reactive.RestForm;
 import org.jboss.resteasy.reactive.RestPath;
 
@@ -42,7 +40,7 @@ public class CredentialCheck {
     @Blocking
     @RolesAllowed("read")
     @Path("/api/beta/credentials/{connectUrl}")
-    public Uni<V2Response> checkCredentialForTarget(
+    public Uni<CredentialTestResult> checkCredentialForTarget(
             @RestPath String connectUrl, @RestForm String username, @RestForm String password)
             throws URISyntaxException {
         Target target = Target.getTargetByConnectUrl(new URI(connectUrl));
@@ -74,8 +72,7 @@ public Uni<V2Response> checkCredentialForTarget(
                                                             || connectionManager.isAgentAuthFailure(
                                                                     t))
                                     .recoverWithItem(t -> CredentialTestResult.FAILURE);
-                        })
-                .map(r -> V2Response.json(Status.OK, r));
+                        });
     }
 
     static enum CredentialTestResult {

src/main/java/io/cryostat/credentials/Credentials.java

@@ -15,70 +15,92 @@
  */
 package io.cryostat.credentials;
 
-import java.net.URI;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 
-import io.cryostat.V2Response;
 import io.cryostat.expressions.MatchExpression;
 import io.cryostat.expressions.MatchExpression.TargetMatcher;
 
 import io.smallrye.common.annotation.Blocking;
 import jakarta.annotation.security.RolesAllowed;
 import jakarta.inject.Inject;
+import jakarta.persistence.NoResultException;
 import jakarta.transaction.Transactional;
 import jakarta.ws.rs.DELETE;
 import jakarta.ws.rs.GET;
 import jakarta.ws.rs.POST;
 import jakarta.ws.rs.Path;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.core.MediaType;
 import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.UriInfo;
 import org.jboss.logging.Logger;
 import org.jboss.resteasy.reactive.RestForm;
 import org.jboss.resteasy.reactive.RestPath;
 import org.jboss.resteasy.reactive.RestResponse;
 import org.jboss.resteasy.reactive.RestResponse.ResponseBuilder;
 import org.projectnessie.cel.tools.ScriptException;
 
-@Path("/api/v2.2/credentials")
+@Path("/api/v4/credentials")
 public class Credentials {
 
     @Inject TargetMatcher targetMatcher;
     @Inject Logger logger;
 
+    @Blocking
     @GET
     @RolesAllowed("read")
-    public V2Response list() {
-        List<Credential> credentials = Credential.listAll();
-        return V2Response.json(
-                Response.Status.OK,
-                credentials.stream()
-                        .map(
-                                c -> {
-                                    try {
-                                        return Credentials.safeResult(c, targetMatcher);
-                                    } catch (ScriptException e) {
-                                        logger.warn(e);
-                                        return null;
-                                    }
-                                })
-                        .filter(Objects::nonNull)
-                        .toList());
+    public Response list() {
+        try {
+            List<Credential> credentials = Credential.listAll();
+            List<Map<String, Object>> results =
+                    credentials.stream()
+                            .map(
+                                    c -> {
+                                        try {
+                                            return safeResult(c, targetMatcher);
+                                        } catch (ScriptException e) {
+                                            logger.warn(e);
+                                            return null;
+                                        }
+                                    })
+                            .filter(Objects::nonNull)
+                            .toList();
+
+            return Response.ok(results).type(MediaType.APPLICATION_JSON).build();
+        } catch (Exception e) {
+            logger.error("Error listing credentials", e);
+            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
+        }
     }
 
+    @Blocking
     @GET
     @RolesAllowed("read")
     @Path("/{id}")
-    public V2Response get(@RestPath long id) throws ScriptException {
-        Credential credential = Credential.find("id", id).singleResult();
-        return V2Response.json(Response.Status.OK, safeMatchedResult(credential, targetMatcher));
+    public Response get(@RestPath long id) throws ScriptException {
+        try {
+            Credential credential = Credential.find("id", id).singleResult();
+            Map<String, Object> result = safeResult(credential, targetMatcher);
+            return Response.ok(result).type(MediaType.APPLICATION_JSON).build();
+        } catch (ScriptException e) {
+            logger.error("Error retrieving credential", e);
+            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
+        } catch (NoResultException e) {
+            throw e;
+        } catch (Exception e) {
+            logger.error("Unexpected error occurred", e);
+            return Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
+        }
     }
 
     @Transactional
     @POST
     @RolesAllowed("write")
-    public RestResponse<Void> create(
+    public RestResponse<Credential> create(
+            @Context UriInfo uriInfo,
             @RestForm String matchExpression,
             @RestForm String username,
             @RestForm String password) {
@@ -89,7 +111,9 @@ public RestResponse<Void> create(
         credential.username = username;
         credential.password = password;
         credential.persist();
-        return ResponseBuilder.<Void>created(URI.create("/api/v2.2/credentials/" + credential.id))
+        return ResponseBuilder.<Credential>created(
+                        uriInfo.getAbsolutePathBuilder().path(Long.toString(credential.id)).build())
+                .entity(credential)
                 .build();
     }
 
@@ -113,23 +137,15 @@ static Map<String, Object> notificationResult(Credential credential) throws Scri
         return result;
     }
 
-    @Blocking
     static Map<String, Object> safeResult(Credential credential, TargetMatcher matcher)
             throws ScriptException {
         Map<String, Object> result = new HashMap<>();
         result.put("id", credential.id);
         result.put("matchExpression", credential.matchExpression);
-        result.put(
-                "numMatchingTargets", matcher.match(credential.matchExpression).targets().size());
-        return result;
-    }
-
-    @Blocking
-    static Map<String, Object> safeMatchedResult(Credential credential, TargetMatcher matcher)
-            throws ScriptException {
-        Map<String, Object> result = new HashMap<>();
-        result.put("matchExpression", credential.matchExpression);
-        result.put("targets", matcher.match(credential.matchExpression).targets());
+        // TODO remove numMatchingTargets, clients can just use targets.length
+        var matchedTargets = matcher.match(credential.matchExpression).targets();
+        result.put("numMatchingTargets", matchedTargets.size());
+        result.put("targets", matchedTargets);
         return result;
     }
 }