Update gradle

[signal-cli] / src / main / java / org / asamk / signal / jsonrpc / SignalJsonRpcDispatcherHandler.java

diff --git a/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java b/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java
index 181233bc38dfe26f0b7ee80bb45dff87090e0261..5d3fa2619ef3c4c09df0c11db918ee030e5f4026 100644 (file)
--- a/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java
+++ b/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java
@@ -1,8 +1,6 @@
 package org.asamk.signal.jsonrpc;
 
 package org.asamk.signal.jsonrpc;
 

-import com.fasterxml.jackson.core.TreeNode;

 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.core.type.TypeReference;

-import com.fasterxml.jackson.databind.JsonMappingException;

 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;


@@ -13,25 +11,19 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.asamk.signal.commands.Command;
 import org.asamk.signal.commands.Commands;
 import org.asamk.signal.commands.JsonRpcMultiCommand;
 import org.asamk.signal.commands.Command;
 import org.asamk.signal.commands.Commands;
 import org.asamk.signal.commands.JsonRpcMultiCommand;

-import org.asamk.signal.commands.JsonRpcRegistrationCommand;

 import org.asamk.signal.commands.JsonRpcSingleCommand;
 import org.asamk.signal.commands.exceptions.CommandException;
 import org.asamk.signal.commands.JsonRpcSingleCommand;
 import org.asamk.signal.commands.exceptions.CommandException;

-import org.asamk.signal.commands.exceptions.IOErrorException;
-import org.asamk.signal.commands.exceptions.UntrustedKeyErrorException;

 import org.asamk.signal.commands.exceptions.UserErrorException;
 import org.asamk.signal.json.JsonReceiveMessageHandler;
 import org.asamk.signal.manager.Manager;
 import org.asamk.signal.manager.MultiAccountManager;
 import org.asamk.signal.commands.exceptions.UserErrorException;
 import org.asamk.signal.json.JsonReceiveMessageHandler;
 import org.asamk.signal.manager.Manager;
 import org.asamk.signal.manager.MultiAccountManager;

-import org.asamk.signal.manager.RegistrationManager;

 import org.asamk.signal.manager.api.Pair;
 import org.asamk.signal.output.JsonWriter;
 import org.asamk.signal.util.Util;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import org.asamk.signal.manager.api.Pair;
 import org.asamk.signal.output.JsonWriter;
 import org.asamk.signal.util.Util;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

-import java.io.IOException;

 import java.nio.channels.ClosedChannelException;
 import java.nio.channels.ClosedChannelException;

-import java.nio.channels.OverlappingFileLockException;

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;


@@ -40,24 +32,20 @@ import java.util.function.Supplier;
 
 public class SignalJsonRpcDispatcherHandler {
 
 
 public class SignalJsonRpcDispatcherHandler {
 

-    private final static Logger logger = LoggerFactory.getLogger(SignalJsonRpcDispatcherHandler.class);
-
-    private static final int USER_ERROR = -1;
-    private static final int IO_ERROR = -3;
-    private static final int UNTRUSTED_KEY_ERROR = -4;
+    private static final Logger logger = LoggerFactory.getLogger(SignalJsonRpcDispatcherHandler.class);

 
     private final ObjectMapper objectMapper;
     private final JsonRpcSender jsonRpcSender;
     private final JsonRpcReader jsonRpcReader;
     private final boolean noReceiveOnStart;
 
 
     private final ObjectMapper objectMapper;
     private final JsonRpcSender jsonRpcSender;
     private final JsonRpcReader jsonRpcReader;
     private final boolean noReceiveOnStart;
 

-    private MultiAccountManager c;

     private final Map<Integer, List<Pair<Manager, Manager.ReceiveMessageHandler>>> receiveHandlers = new HashMap<>();
     private final Map<Integer, List<Pair<Manager, Manager.ReceiveMessageHandler>>> receiveHandlers = new HashMap<>();

-
-    private Manager m;
+    private SignalJsonRpcCommandHandler commandHandler;

 
     public SignalJsonRpcDispatcherHandler(
 
     public SignalJsonRpcDispatcherHandler(

-            final JsonWriter jsonWriter, final Supplier<String> lineSupplier, final boolean noReceiveOnStart
+            final JsonWriter jsonWriter,
+            final Supplier<String> lineSupplier,
+            final boolean noReceiveOnStart

     ) {
         this.noReceiveOnStart = noReceiveOnStart;
         this.objectMapper = Util.createJsonObjectMapper();
     ) {
         this.noReceiveOnStart = noReceiveOnStart;
         this.objectMapper = Util.createJsonObjectMapper();


@@ -66,11 +54,11 @@ public class SignalJsonRpcDispatcherHandler {
     }
 
     public void handleConnection(final MultiAccountManager c) {
     }
 
     public void handleConnection(final MultiAccountManager c) {

-        this.c = c;
+        this.commandHandler = new SignalJsonRpcCommandHandler(c, this::getCommand);

 
         if (!noReceiveOnStart) {
 
         if (!noReceiveOnStart) {

-            this.subscribeReceive(c.getManagers());
-            c.addOnManagerAddedHandler(this::subscribeReceive);
+            this.subscribeReceive(c.getManagers(), true);
+            c.addOnManagerAddedHandler(m -> subscribeReceive(m, true));

             c.addOnManagerRemovedHandler(this::unsubscribeReceive);
         }
 
             c.addOnManagerRemovedHandler(this::unsubscribeReceive);
         }
 


@@ -78,10 +66,10 @@ public class SignalJsonRpcDispatcherHandler {
     }
 
     public void handleConnection(final Manager m) {
     }
 
     public void handleConnection(final Manager m) {

-        this.m = m;
+        this.commandHandler = new SignalJsonRpcCommandHandler(m, this::getCommand);

 
         if (!noReceiveOnStart) {
 
         if (!noReceiveOnStart) {

-            subscribeReceive(m);
+            subscribeReceive(m, true);

         }
 
         final var currentThread = Thread.currentThread();
         }
 
         final var currentThread = Thread.currentThread();


@@ -92,16 +80,23 @@ public class SignalJsonRpcDispatcherHandler {
 
     private static final AtomicInteger nextSubscriptionId = new AtomicInteger(0);
 
 
     private static final AtomicInteger nextSubscriptionId = new AtomicInteger(0);
 

-    private int subscribeReceive(final Manager manager) {
-        return subscribeReceive(List.of(manager));
+    private int subscribeReceive(final Manager manager, boolean internalSubscription) {
+        return subscribeReceive(List.of(manager), internalSubscription);

     }
 
     }
 

-    private int subscribeReceive(final List<Manager> managers) {
+    private int subscribeReceive(final List<Manager> managers, boolean internalSubscription) {

         final var subscriptionId = nextSubscriptionId.getAndIncrement();
         final var handlers = managers.stream().map(m -> {
             final var receiveMessageHandler = new JsonReceiveMessageHandler(m, s -> {
         final var subscriptionId = nextSubscriptionId.getAndIncrement();
         final var handlers = managers.stream().map(m -> {
             final var receiveMessageHandler = new JsonReceiveMessageHandler(m, s -> {

-                final ContainerNode<?> params = objectMapper.valueToTree(s);
-                ((ObjectNode) params).set("subscription", IntNode.valueOf(subscriptionId));
+                ContainerNode<?> params;
+                if (internalSubscription) {
+                    params = objectMapper.valueToTree(s);
+                } else {
+                    final var paramsNode = new ObjectNode(objectMapper.getNodeFactory());
+                    paramsNode.set("subscription", IntNode.valueOf(subscriptionId));
+                    paramsNode.set("result", objectMapper.valueToTree(s));
+                    params = paramsNode;
+                }

                 final var jsonRpcRequest = JsonRpcRequest.forNotification("receive", params, null);
                 try {
                     jsonRpcSender.sendRequest(jsonRpcRequest);
                 final var jsonRpcRequest = JsonRpcRequest.forNotification("receive", params, null);
                 try {
                     jsonRpcSender.sendRequest(jsonRpcRequest);


@@ -133,7 +128,7 @@ public class SignalJsonRpcDispatcherHandler {
     private void unsubscribeReceive(final Manager m) {
         final var subscriptionId = receiveHandlers.entrySet()
                 .stream()
     private void unsubscribeReceive(final Manager m) {
         final var subscriptionId = receiveHandlers.entrySet()
                 .stream()

-                .filter(e -> e.getValue().size() == 1 && e.getValue().get(0).first().equals(m))
+                .filter(e -> e.getValue().size() == 1 && e.getValue().getFirst().first().equals(m))

                 .map(Map.Entry::getKey)
                 .findFirst();
         subscriptionId.ifPresent(this::unsubscribeReceive);
                 .map(Map.Entry::getKey)
                 .findFirst();
         subscriptionId.ifPresent(this::unsubscribeReceive);


@@ -141,7 +136,7 @@ public class SignalJsonRpcDispatcherHandler {
 
     private void handleConnection() {
         try {
 
     private void handleConnection() {
         try {

-            jsonRpcReader.readMessages((method, params) -> handleRequest(objectMapper, method, params),
+            jsonRpcReader.readMessages((method, params) -> commandHandler.handleRequest(objectMapper, method, params),

                     response -> logger.debug("Received unexpected response for id {}", response.getId()));
         } finally {
             receiveHandlers.forEach((_subscriptionId, handlers) -> handlers.forEach(this::unsubscribeReceiveHandler));
                     response -> logger.debug("Received unexpected response for id {}", response.getId()));
         } finally {
             receiveHandlers.forEach((_subscriptionId, handlers) -> handlers.forEach(this::unsubscribeReceiveHandler));


@@ -155,87 +150,6 @@ public class SignalJsonRpcDispatcherHandler {
         m.removeReceiveHandler(handler);
     }
 
         m.removeReceiveHandler(handler);
     }
 

-    private JsonNode handleRequest(
-            final ObjectMapper objectMapper, final String method, ContainerNode<?> params
-    ) throws JsonRpcException {
-        var command = getCommand(method);
-        if (c != null) {
-            if (command instanceof JsonRpcSingleCommand<?> jsonRpcCommand) {
-                final var manager = getManagerFromParams(params);
-                if (manager != null) {
-                    return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
-                }
-            }
-            if (command instanceof JsonRpcMultiCommand<?> jsonRpcCommand) {
-                return runCommand(objectMapper, params, new MultiCommandRunnerImpl<>(c, jsonRpcCommand));
-            }
-            if (command instanceof JsonRpcRegistrationCommand<?> jsonRpcCommand) {
-                try (var manager = getRegistrationManagerFromParams(params)) {
-                    if (manager != null) {
-                        return runCommand(objectMapper,
-                                params,
-                                new RegistrationCommandRunnerImpl<>(manager, c, jsonRpcCommand));
-                    } else {
-                        throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
-                                "Method requires valid account parameter",
-                                null));
-                    }
-                } catch (IOException e) {
-                    logger.warn("Failed to close registration manager", e);
-                }
-            }
-        }
-        if (command instanceof JsonRpcSingleCommand<?> jsonRpcCommand) {
-            if (m != null) {
-                return runCommand(objectMapper, params, new CommandRunnerImpl<>(m, jsonRpcCommand));
-            }
-
-            final var manager = getManagerFromParams(params);
-            if (manager != null) {
-                return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
-            } else {
-                throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
-                        "Method requires valid account parameter",
-                        null));
-            }
-        }
-
-        throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.METHOD_NOT_FOUND,
-                "Method not implemented",
-                null));
-    }
-
-    private Manager getManagerFromParams(final ContainerNode<?> params) throws JsonRpcException {
-        if (params != null && params.hasNonNull("account")) {
-            final var manager = c.getManager(params.get("account").asText());
-            ((ObjectNode) params).remove("account");
-            if (manager == null) {
-                throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
-                        "Specified account does not exist",
-                        null));
-            }
-            return manager;
-        }
-        return null;
-    }
-
-    private RegistrationManager getRegistrationManagerFromParams(final ContainerNode<?> params) {
-        if (params != null && params.has("account")) {
-            try {
-                final var registrationManager = c.getNewRegistrationManager(params.get("account").asText());
-                ((ObjectNode) params).remove("account");
-                return registrationManager;
-            } catch (OverlappingFileLockException e) {
-                logger.warn("Account is already in use");
-                return null;
-            } catch (IOException | IllegalStateException e) {
-                logger.warn("Failed to load registration manager", e);
-                return null;
-            }
-        }
-        return null;
-    }
-

     private Command getCommand(final String method) {
         if ("subscribeReceive".equals(method)) {
             return new SubscribeReceiveCommand();
     private Command getCommand(final String method) {
         if ("subscribeReceive".equals(method)) {
             return new SubscribeReceiveCommand();


@@ -246,124 +160,6 @@ public class SignalJsonRpcDispatcherHandler {
         return Commands.getCommand(method);
     }
 
         return Commands.getCommand(method);
     }
 

-    private record CommandRunnerImpl<T>(Manager m, JsonRpcSingleCommand<T> command) implements CommandRunner<T> {
-
-        @Override
-        public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
-            command.handleCommand(request, m, jsonWriter);
-        }
-
-        @Override
-        public TypeReference<T> getRequestType() {
-            return command.getRequestType();
-        }
-    }
-
-    private record RegistrationCommandRunnerImpl<T>(
-            RegistrationManager m, MultiAccountManager c, JsonRpcRegistrationCommand<T> command
-    ) implements CommandRunner<T> {
-
-        @Override
-        public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
-            command.handleCommand(request, m, jsonWriter);
-        }
-
-        @Override
-        public TypeReference<T> getRequestType() {
-            return command.getRequestType();
-        }
-    }
-
-    private record MultiCommandRunnerImpl<T>(
-            MultiAccountManager c, JsonRpcMultiCommand<T> command
-    ) implements CommandRunner<T> {
-
-        @Override
-        public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
-            command.handleCommand(request, c, jsonWriter);
-        }
-
-        @Override
-        public TypeReference<T> getRequestType() {
-            return command.getRequestType();
-        }
-    }
-
-    interface CommandRunner<T> {
-
-        void handleCommand(T request, JsonWriter jsonWriter) throws CommandException;
-
-        TypeReference<T> getRequestType();
-    }
-
-    private JsonNode runCommand(
-            final ObjectMapper objectMapper, final ContainerNode<?> params, final CommandRunner<?> command
-    ) throws JsonRpcException {
-        final Object[] result = {null};
-        final JsonWriter commandJsonWriter = s -> {
-            if (result[0] != null) {
-                throw new AssertionError("Command may only write one json result");
-            }
-
-            result[0] = s;
-        };
-
-        try {
-            parseParamsAndRunCommand(objectMapper, params, commandJsonWriter, command);
-        } catch (JsonMappingException e) {
-            throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
-                    e.getMessage(),
-                    null));
-        } catch (UserErrorException e) {
-            throw new JsonRpcException(new JsonRpcResponse.Error(USER_ERROR,
-                    e.getMessage(),
-                    getErrorDataNode(objectMapper, result)));
-        } catch (IOErrorException e) {
-            throw new JsonRpcException(new JsonRpcResponse.Error(IO_ERROR,
-                    e.getMessage(),
-                    getErrorDataNode(objectMapper, result)));
-        } catch (UntrustedKeyErrorException e) {
-            throw new JsonRpcException(new JsonRpcResponse.Error(UNTRUSTED_KEY_ERROR,
-                    e.getMessage(),
-                    getErrorDataNode(objectMapper, result)));
-        } catch (Throwable e) {
-            logger.error("Command execution failed", e);
-            throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INTERNAL_ERROR,
-                    e.getMessage(),
-                    getErrorDataNode(objectMapper, result)));
-        }
-
-        Object output = result[0] == null ? Map.of() : result[0];
-        return objectMapper.valueToTree(output);
-    }
-
-    private JsonNode getErrorDataNode(final ObjectMapper objectMapper, final Object[] result) {
-        if (result[0] == null) {
-            return null;
-        }
-        return objectMapper.valueToTree(Map.of("response", result[0]));
-    }
-
-    private <T> void parseParamsAndRunCommand(
-            final ObjectMapper objectMapper,
-            final TreeNode params,
-            final JsonWriter jsonWriter,
-            final CommandRunner<T> command
-    ) throws CommandException, JsonMappingException {
-        T requestParams = null;
-        final var requestType = command.getRequestType();
-        if (params != null && requestType != null) {
-            try {
-                requestParams = objectMapper.readValue(objectMapper.treeAsTokens(params), requestType);
-            } catch (JsonMappingException e) {
-                throw e;
-            } catch (IOException e) {
-                throw new AssertionError(e);
-            }
-        }
-        command.handleCommand(requestParams, jsonWriter);
-    }
-

     private class SubscribeReceiveCommand implements JsonRpcSingleCommand<Void>, JsonRpcMultiCommand<Void> {
 
         @Override
     private class SubscribeReceiveCommand implements JsonRpcSingleCommand<Void>, JsonRpcMultiCommand<Void> {
 
         @Override


@@ -373,17 +169,21 @@ public class SignalJsonRpcDispatcherHandler {
 
         @Override
         public void handleCommand(
 
         @Override
         public void handleCommand(

-                final Void request, final Manager m, final JsonWriter jsonWriter
+                final Void request,
+                final Manager m,
+                final JsonWriter jsonWriter

         ) throws CommandException {
         ) throws CommandException {

-            final var subscriptionId = subscribeReceive(m);
+            final var subscriptionId = subscribeReceive(m, false);

             jsonWriter.write(subscriptionId);
         }
 
         @Override
         public void handleCommand(
             jsonWriter.write(subscriptionId);
         }
 
         @Override
         public void handleCommand(

-                final Void request, final MultiAccountManager c, final JsonWriter jsonWriter
+                final Void request,
+                final MultiAccountManager c,
+                final JsonWriter jsonWriter

         ) throws CommandException {
         ) throws CommandException {

-            final var subscriptionId = subscribeReceive(c.getManagers());
+            final var subscriptionId = subscribeReceive(c.getManagers(), false);

             jsonWriter.write(subscriptionId);
         }
     }
             jsonWriter.write(subscriptionId);
         }
     }


@@ -402,7 +202,9 @@ public class SignalJsonRpcDispatcherHandler {
 
         @Override
         public void handleCommand(
 
         @Override
         public void handleCommand(

-                final JsonNode request, final Manager m, final JsonWriter jsonWriter
+                final JsonNode request,
+                final Manager m,
+                final JsonWriter jsonWriter

         ) throws CommandException {
             final var subscriptionId = getSubscriptionId(request);
             if (subscriptionId == null) {
         ) throws CommandException {
             final var subscriptionId = getSubscriptionId(request);
             if (subscriptionId == null) {


@@ -416,7 +218,9 @@ public class SignalJsonRpcDispatcherHandler {
 
         @Override
         public void handleCommand(
 
         @Override
         public void handleCommand(

-                final JsonNode request, final MultiAccountManager c, final JsonWriter jsonWriter
+                final JsonNode request,
+                final MultiAccountManager c,
+                final JsonWriter jsonWriter

         ) throws CommandException {
             final var subscriptionId = getSubscriptionId(request);
             if (subscriptionId == null) {
         ) throws CommandException {
             final var subscriptionId = getSubscriptionId(request);
             if (subscriptionId == null) {


@@ -429,13 +233,11 @@ public class SignalJsonRpcDispatcherHandler {
         }
 
         private Integer getSubscriptionId(final JsonNode request) {
         }
 
         private Integer getSubscriptionId(final JsonNode request) {

-            if (request instanceof ArrayNode req) {
-                return req.get(0).asInt();
-            } else if (request instanceof ObjectNode req) {
-                return req.get("subscription").asInt();
-            } else {
-                return null;
-            }
+            return switch (request) {
+                case ArrayNode req -> req.get(0).asInt();
+                case ObjectNode req -> req.get("subscription").asInt();
+                case null, default -> null;
+            };

         }
     }
 }
         }
     }
 }