Handle send failures as non fatal and return detailed results in json output

[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 c33cd9a5057e6fa796da55c20002d2aa37834607..8d13ad2875ad1b819fb23ed9b51643cf686c10ad 100644 (file)
--- a/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java
+++ b/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java
@@ -6,24 +6,28 @@ import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ContainerNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ContainerNode;

+import com.fasterxml.jackson.databind.node.ObjectNode;

 
 

-import org.asamk.signal.JsonReceiveMessageHandler;
-import org.asamk.signal.JsonWriter;
-import org.asamk.signal.OutputWriter;

 import org.asamk.signal.commands.Command;
 import org.asamk.signal.commands.Commands;
 import org.asamk.signal.commands.Command;
 import org.asamk.signal.commands.Commands;

-import org.asamk.signal.commands.JsonRpcCommand;
-import org.asamk.signal.commands.SignalCreator;
+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.exceptions.IOErrorException;
 import org.asamk.signal.commands.exceptions.UntrustedKeyErrorException;
 import org.asamk.signal.commands.exceptions.UserErrorException;
 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.Manager;

+import org.asamk.signal.manager.MultiAccountManager;
+import org.asamk.signal.manager.RegistrationManager;
+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 org.asamk.signal.util.Util;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;

+import java.nio.channels.OverlappingFileLockException;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;


@@ -42,25 +46,27 @@ public class SignalJsonRpcDispatcherHandler {
     private final JsonRpcReader jsonRpcReader;
     private final boolean noReceiveOnStart;
 
     private final JsonRpcReader jsonRpcReader;
     private final boolean noReceiveOnStart;
 

-    private SignalCreator c;
+    private MultiAccountManager c;

     private final Map<Manager, Manager.ReceiveMessageHandler> receiveHandlers = new HashMap<>();
 
     private Manager m;
 
     public SignalJsonRpcDispatcherHandler(
     private final Map<Manager, Manager.ReceiveMessageHandler> receiveHandlers = new HashMap<>();
 
     private Manager m;
 
     public SignalJsonRpcDispatcherHandler(

-            final JsonWriter outputWriter, 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();

-        this.jsonRpcSender = new JsonRpcSender(outputWriter);
+        this.jsonRpcSender = new JsonRpcSender(jsonWriter);

         this.jsonRpcReader = new JsonRpcReader(jsonRpcSender, lineSupplier);
     }
 
         this.jsonRpcReader = new JsonRpcReader(jsonRpcSender, lineSupplier);
     }
 

-    public void handleConnection(final SignalCreator c) {
+    public void handleConnection(final MultiAccountManager c) {

         this.c = c;
 
         if (!noReceiveOnStart) {
             c.getAccountNumbers().stream().map(c::getManager).filter(Objects::nonNull).forEach(this::subscribeReceive);
         this.c = c;
 
         if (!noReceiveOnStart) {
             c.getAccountNumbers().stream().map(c::getManager).filter(Objects::nonNull).forEach(this::subscribeReceive);

+            c.addOnManagerAddedHandler(this::subscribeReceive);
+            c.addOnManagerRemovedHandler(this::unsubscribeReceive);

         }
 
         handleConnection();
         }
 
         handleConnection();


@@ -73,6 +79,9 @@ public class SignalJsonRpcDispatcherHandler {
             subscribeReceive(m);
         }
 
             subscribeReceive(m);
         }
 

+        final var currentThread = Thread.currentThread();
+        m.addClosedListener(currentThread::interrupt);
+

         handleConnection();
     }
 
         handleConnection();
     }
 


@@ -119,17 +128,34 @@ public class SignalJsonRpcDispatcherHandler {
             final ObjectMapper objectMapper, final String method, ContainerNode<?> params
     ) throws JsonRpcException {
         var command = getCommand(method);
             final ObjectMapper objectMapper, final String method, ContainerNode<?> params
     ) throws JsonRpcException {
         var command = getCommand(method);

-        // TODO implement listAccounts, register, verify, link
-        if (command instanceof JsonRpcCommand<?> jsonRpcCommand) {
+        if (c != null) {
+            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));
             }
 
             if (m != null) {
                 return runCommand(objectMapper, params, new CommandRunnerImpl<>(m, jsonRpcCommand));
             }
 

-            if (params.has("account")) {
-                Manager manager = c.getManager(params.get("account").asText());
-                if (manager != null) {
-                    return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, 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",
             } else {
                 throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
                         "Method requires valid account parameter",


@@ -142,6 +168,32 @@ public class SignalJsonRpcDispatcherHandler {
                 null));
     }
 
                 null));
     }
 

+    private Manager getManagerFromParams(final ContainerNode<?> params) {
+        if (params != null && params.has("account")) {
+            final var manager = c.getManager(params.get("account").asText());
+            ((ObjectNode) params).remove("account");
+            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();


@@ -152,11 +204,41 @@ public class SignalJsonRpcDispatcherHandler {
         return Commands.getCommand(method);
     }
 
         return Commands.getCommand(method);
     }
 

-    private record CommandRunnerImpl<T>(Manager m, JsonRpcCommand<T> command) implements CommandRunner<T> {
+    private record CommandRunnerImpl<T>(Manager m, JsonRpcSingleCommand<T> command) implements CommandRunner<T> {

 
         @Override
 
         @Override

-        public void handleCommand(final T request, final OutputWriter outputWriter) throws CommandException {
-            command.handleCommand(request, m, outputWriter);
+        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
         }
 
         @Override


@@ -167,7 +249,7 @@ public class SignalJsonRpcDispatcherHandler {
 
     interface CommandRunner<T> {
 
 
     interface CommandRunner<T> {
 

-        void handleCommand(T request, OutputWriter outputWriter) throws CommandException;
+        void handleCommand(T request, JsonWriter jsonWriter) throws CommandException;

 
         TypeReference<T> getRequestType();
     }
 
         TypeReference<T> getRequestType();
     }


@@ -176,7 +258,7 @@ public class SignalJsonRpcDispatcherHandler {
             final ObjectMapper objectMapper, final ContainerNode<?> params, final CommandRunner<?> command
     ) throws JsonRpcException {
         final Object[] result = {null};
             final ObjectMapper objectMapper, final ContainerNode<?> params, final CommandRunner<?> command
     ) throws JsonRpcException {
         final Object[] result = {null};

-        final JsonWriter commandOutputWriter = s -> {
+        final JsonWriter commandJsonWriter = s -> {

             if (result[0] != null) {
                 throw new AssertionError("Command may only write one json result");
             }
             if (result[0] != null) {
                 throw new AssertionError("Command may only write one json result");
             }


@@ -185,32 +267,45 @@ public class SignalJsonRpcDispatcherHandler {
         };
 
         try {
         };
 
         try {

-            parseParamsAndRunCommand(objectMapper, params, commandOutputWriter, command);
+            parseParamsAndRunCommand(objectMapper, params, commandJsonWriter, command);

         } catch (JsonMappingException e) {
             throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
                     e.getMessage(),
                     null));
         } catch (UserErrorException e) {
         } 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(), null));
+            throw new JsonRpcException(new JsonRpcResponse.Error(USER_ERROR,
+                    e.getMessage(),
+                    getErrorDataNode(objectMapper, result)));

         } catch (IOErrorException e) {
         } catch (IOErrorException e) {

-            throw new JsonRpcException(new JsonRpcResponse.Error(IO_ERROR, e.getMessage(), null));
+            throw new JsonRpcException(new JsonRpcResponse.Error(IO_ERROR,
+                    e.getMessage(),
+                    getErrorDataNode(objectMapper, result)));

         } catch (UntrustedKeyErrorException e) {
         } catch (UntrustedKeyErrorException e) {

-            throw new JsonRpcException(new JsonRpcResponse.Error(UNTRUSTED_KEY_ERROR, e.getMessage(), null));
+            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(),
         } catch (Throwable e) {
             logger.error("Command execution failed", e);
             throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INTERNAL_ERROR,
                     e.getMessage(),

-                    null));
+                    getErrorDataNode(objectMapper, result)));

         }
 
         Object output = result[0] == null ? Map.of() : result[0];
         return objectMapper.valueToTree(output);
     }
 
         }
 
         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,
     private <T> void parseParamsAndRunCommand(
             final ObjectMapper objectMapper,
             final TreeNode params,

-            final OutputWriter outputWriter,
+            final JsonWriter jsonWriter,

             final CommandRunner<T> command
     ) throws CommandException, JsonMappingException {
         T requestParams = null;
             final CommandRunner<T> command
     ) throws CommandException, JsonMappingException {
         T requestParams = null;


@@ -224,10 +319,10 @@ public class SignalJsonRpcDispatcherHandler {
                 throw new AssertionError(e);
             }
         }
                 throw new AssertionError(e);
             }
         }

-        command.handleCommand(requestParams, outputWriter);
+        command.handleCommand(requestParams, jsonWriter);

     }
 
     }
 

-    private class SubscribeReceiveCommand implements JsonRpcCommand<Void> {
+    private class SubscribeReceiveCommand implements JsonRpcSingleCommand<Void> {

 
         @Override
         public String getName() {
 
         @Override
         public String getName() {


@@ -236,13 +331,13 @@ public class SignalJsonRpcDispatcherHandler {
 
         @Override
         public void handleCommand(
 
         @Override
         public void handleCommand(

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

         ) throws CommandException {
             subscribeReceive(m);
         }
     }
 
         ) throws CommandException {
             subscribeReceive(m);
         }
     }
 

-    private class UnsubscribeReceiveCommand implements JsonRpcCommand<Void> {
+    private class UnsubscribeReceiveCommand implements JsonRpcSingleCommand<Void> {

 
         @Override
         public String getName() {
 
         @Override
         public String getName() {


@@ -251,7 +346,7 @@ public class SignalJsonRpcDispatcherHandler {
 
         @Override
         public void handleCommand(
 
         @Override
         public void handleCommand(

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

         ) throws CommandException {
             unsubscribeReceive(m);
         }
         ) throws CommandException {
             unsubscribeReceive(m);
         }