import net.sourceforge.argparse4j.inf.Subparser;
import org.asamk.signal.DbusConfig;
-import org.asamk.signal.JsonReceiveMessageHandler;
-import org.asamk.signal.JsonWriter;
-import org.asamk.signal.JsonWriterImpl;
import org.asamk.signal.OutputType;
-import org.asamk.signal.OutputWriter;
-import org.asamk.signal.PlainTextWriter;
import org.asamk.signal.ReceiveMessageHandler;
import org.asamk.signal.commands.exceptions.CommandException;
import org.asamk.signal.commands.exceptions.IOErrorException;
import org.asamk.signal.commands.exceptions.UnexpectedErrorException;
+import org.asamk.signal.commands.exceptions.UserErrorException;
import org.asamk.signal.dbus.DbusSignalControlImpl;
import org.asamk.signal.dbus.DbusSignalImpl;
+import org.asamk.signal.json.JsonReceiveMessageHandler;
import org.asamk.signal.jsonrpc.SignalJsonRpcDispatcherHandler;
import org.asamk.signal.manager.Manager;
import org.asamk.signal.manager.MultiAccountManager;
+import org.asamk.signal.output.JsonWriter;
+import org.asamk.signal.output.JsonWriterImpl;
+import org.asamk.signal.output.OutputWriter;
+import org.asamk.signal.output.PlainTextWriter;
import org.asamk.signal.util.IOUtils;
import org.freedesktop.dbus.connections.impl.DBusConnection;
+import org.freedesktop.dbus.connections.impl.DBusConnectionBuilder;
import org.freedesktop.dbus.exceptions.DBusException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
import java.util.List;
-import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
-import java.util.stream.Collectors;
public class DaemonCommand implements MultiLocalCommand, LocalCommand {
final var receiveMode = ns.<ReceiveMode>get("receive-mode");
final var ignoreAttachments = Boolean.TRUE.equals(ns.getBoolean("ignore-attachments"));
- c.getAccountNumbers().stream().map(c::getManager).filter(Objects::nonNull).forEach(m -> {
+ c.getManagers().forEach(m -> {
m.setIgnoreAttachments(ignoreAttachments);
addDefaultReceiveHandler(m, noReceiveStdOut ? null : outputWriter, receiveMode != ReceiveMode.ON_START);
});
});
}
+ private static final AtomicInteger threadNumber = new AtomicInteger(0);
+
private void runSocket(final ServerSocketChannel serverChannel, Consumer<SocketChannel> socketHandler) {
- new Thread(() -> {
+ final var thread = new Thread(() -> {
while (true) {
+ final var connectionId = threadNumber.getAndIncrement();
final SocketChannel channel;
final String clientString;
try {
channel = serverChannel.accept();
clientString = channel.getRemoteAddress() + " " + IOUtils.getUnixDomainPrincipal(channel);
- logger.info("Accepted new client: " + clientString);
+ logger.info("Accepted new client connection {}: {}", connectionId, clientString);
} catch (IOException e) {
logger.error("Failed to accept new socket connection", e);
synchronized (this) {
}
break;
}
- new Thread(() -> {
+ final var connectionThread = new Thread(() -> {
try (final var c = channel) {
socketHandler.accept(c);
- logger.info("Connection closed: " + clientString);
} catch (IOException e) {
logger.warn("Failed to close channel", e);
+ } catch (Throwable e) {
+ logger.warn("Connection handler failed, closing connection", e);
}
- }).start();
+ logger.info("Connection {} closed: {}", connectionId, clientString);
+ });
+ connectionThread.setName("daemon-connection-" + connectionId);
+ connectionThread.start();
}
- }).start();
+ });
+ thread.setName("daemon-listener");
+ thread.start();
}
private SignalJsonRpcDispatcherHandler getSignalJsonRpcDispatcherHandler(
private void runDbusSingleAccount(
final Manager m, final boolean isDbusSystem, final boolean noReceiveOnStart
- ) throws UnexpectedErrorException {
+ ) throws CommandException {
runDbus(isDbusSystem, (conn, objectPath) -> {
try {
exportDbusObject(conn, objectPath, m, noReceiveOnStart).join();
private void runDbusMultiAccount(
final MultiAccountManager c, final boolean noReceiveOnStart, final boolean isDbusSystem
- ) throws UnexpectedErrorException {
+ ) throws CommandException {
runDbus(isDbusSystem, (connection, objectPath) -> {
final var signalControl = new DbusSignalControlImpl(c, objectPath);
connection.exportObject(signalControl);
c.addOnManagerAddedHandler(m -> {
final var thread = exportMultiAccountManager(connection, m, noReceiveOnStart);
- if (thread != null) {
- try {
- thread.join();
- } catch (InterruptedException ignored) {
- }
+ try {
+ thread.join();
+ } catch (InterruptedException ignored) {
}
});
c.addOnManagerRemovedHandler(m -> {
}
} catch (DBusException ignored) {
}
- connection.unExportObject(path);
});
- final var initThreads = c.getAccountNumbers()
+ final var initThreads = c.getManagers()
.stream()
- .map(c::getManager)
- .filter(Objects::nonNull)
.map(m -> exportMultiAccountManager(connection, m, noReceiveOnStart))
- .filter(Objects::nonNull)
- .collect(Collectors.toList());
+ .toList();
for (var t : initThreads) {
try {
private void runDbus(
final boolean isDbusSystem, DbusRunner dbusRunner
- ) throws UnexpectedErrorException {
+ ) throws CommandException {
DBusConnection.DBusBusType busType;
if (isDbusSystem) {
busType = DBusConnection.DBusBusType.SYSTEM;
} else {
busType = DBusConnection.DBusBusType.SESSION;
}
+ DBusConnection conn;
try {
- var conn = DBusConnection.getConnection(busType);
+ conn = DBusConnectionBuilder.forType(busType).build();
dbusRunner.run(conn, DbusConfig.getObjectPath());
+ } catch (DBusException e) {
+ throw new UnexpectedErrorException("Dbus command failed: " + e.getMessage(), e);
+ } catch (UnsupportedOperationException e) {
+ throw new UserErrorException("Failed to connect to Dbus: " + e.getMessage(), e);
+ }
+ try {
conn.requestBusName(DbusConfig.getBusname());
-
- logger.info("DBus daemon running on {} bus: {}", busType, DbusConfig.getBusname());
} catch (DBusException e) {
- logger.error("Dbus command failed", e);
- throw new UnexpectedErrorException("Dbus command failed", e);
+ throw new UnexpectedErrorException("Dbus command failed, maybe signal-cli dbus daemon is already running: "
+ + e.getMessage(), e);
}
+
+ logger.info("DBus daemon running on {} bus: {}", busType, DbusConfig.getBusname());
}
private Thread exportMultiAccountManager(
final DBusConnection conn, final Manager m, final boolean noReceiveOnStart
) {
- try {
- final var objectPath = DbusConfig.getObjectPath(m.getSelfNumber());
- return exportDbusObject(conn, objectPath, m, noReceiveOnStart);
- } catch (DBusException e) {
- logger.error("Failed to export object", e);
- return null;
- }
+ final var objectPath = DbusConfig.getObjectPath(m.getSelfNumber());
+ return exportDbusObject(conn, objectPath, m, noReceiveOnStart);
}
private Thread exportDbusObject(
final DBusConnection conn, final String objectPath, final Manager m, final boolean noReceiveOnStart
- ) throws DBusException {
+ ) {
final var signal = new DbusSignalImpl(m, conn, objectPath, noReceiveOnStart);
- conn.exportObject(signal);
final var initThread = new Thread(signal::initObjects);
+ initThread.setName("dbus-init");
initThread.start();
- logger.debug("Exported dbus object: " + objectPath);
-
return initThread;
}
git.nmode.ca / signal-cli / blobdiff
