From 5062e4fcb7a93d8f9f779056dca5d87377ac54dc Mon Sep 17 00:00:00 2001 From: "Tristan B. Velloza Kildaire" Date: Wed, 3 May 2023 14:16:48 +0200 Subject: [PATCH] Logging - Moved logging global data static init to `renaissance.logging` module Daemon - Removed logging code from here Connection - Fixed logging import Stream - Fixed logging import Server - Fixed logging import --- source/renaissance/connection/connection.d | 13 ++++- source/renaissance/daemon.d | 10 +--- source/renaissance/listeners/stream.d | 2 +- source/renaissance/logging.d | 11 ++++ source/renaissance/server/server.d | 62 ++++++++++++++++++++++ 5 files changed, 87 insertions(+), 11 deletions(-) create mode 100644 source/renaissance/logging.d diff --git a/source/renaissance/connection/connection.d b/source/renaissance/connection/connection.d index 1947ed4..6661d04 100644 --- a/source/renaissance/connection/connection.d +++ b/source/renaissance/connection/connection.d @@ -5,7 +5,7 @@ import core.thread : Thread; import renaissance.server; import river.core; import tristanable; -import renaissance.daemon : logger; +import renaissance.logging; public class Connection : Thread { @@ -72,9 +72,20 @@ public class Connection : Thread // ... socket here (probably just the latter) // ... which decodes using the `davinci` library + import core.thread; + // Thread.sleep(dur!("seconds")(5)); + + // FIXME: If connection dies, something spins inside tristanable me thinks + // ... causing a high load average, it MIGHT be when an error + // ... occurs that it keeps going back to ask for recv + // ... (this would make sense as this woul dbe something) + // ... we didn't test for + // Dequeue a message from the incoming queue TaggedMessage incomingMessage = incomingQueue.dequeue(); + logger.dbg("Awoken? after dequeue()"); + // Process the message handle(incomingMessage); } diff --git a/source/renaissance/daemon.d b/source/renaissance/daemon.d index d31f20f..0c23414 100644 --- a/source/renaissance/daemon.d +++ b/source/renaissance/daemon.d @@ -1,14 +1,6 @@ module renaissance.daemon; -import gogga; - -public static __gshared GoggaLogger logger; - -__gshared static this() -{ - logger = new GoggaLogger(); - logger.enableDebug(); -} +import renaissance.logging; import std.stdio; import river.core; diff --git a/source/renaissance/listeners/stream.d b/source/renaissance/listeners/stream.d index 70d8b51..49bb511 100644 --- a/source/renaissance/listeners/stream.d +++ b/source/renaissance/listeners/stream.d @@ -8,7 +8,7 @@ import river.core; import river.impls.sock : SockStream; import core.thread; import renaissance.connection; -import renaissance.daemon : logger; +import renaissance.logging; public class StreamListener : Listener { diff --git a/source/renaissance/logging.d b/source/renaissance/logging.d new file mode 100644 index 0000000..04ea26f --- /dev/null +++ b/source/renaissance/logging.d @@ -0,0 +1,11 @@ +module renaissance.logging; + +import gogga; + +public static __gshared GoggaLogger logger; + +__gshared static this() +{ + logger = new GoggaLogger(); + logger.enableDebug(); +} \ No newline at end of file diff --git a/source/renaissance/server/server.d b/source/renaissance/server/server.d index c377a41..5dae195 100644 --- a/source/renaissance/server/server.d +++ b/source/renaissance/server/server.d @@ -6,6 +6,7 @@ import renaissance.listeners; import std.algorithm : canFind; import renaissance.exceptions; import renaissance.connection; +import renaissance.logging; /** * Represents an instance of the daemon which manages @@ -49,6 +50,8 @@ public class Server // ... kill them all. I guess we need not dtart them but it won't hurt /* Start all listeners */ startListeners(); + + // TODO: If anything else must run then start a thread for it here } public void restart() @@ -110,6 +113,7 @@ public class Server /* Start each listener */ foreach(Listener curListener; listenerQ) { + logger.dbg("Starting listener '"~curListener.toString()~"' ..."); curListener.startListener(); } } @@ -170,4 +174,62 @@ public class Server /* Unlock the connection queue */ connectionQLock.unlock(); } +} + +version(unittest) +{ + import renaissance.server; + import renaissance.listeners; + + // TODO: Building a testing client with the imports below + import std.socket; + import tristanable.manager; + import tristanable.queue; + import tristanable.encoding; + import core.thread; + + import dante; +} + +unittest +{ + /** + * Setup a `Server` instance followed by + * creating a single listener, after this + * start the server + */ + Server server = new Server(); + // Address listenAddr = parseAddress("::1", 9091); + Address listenAddr = new UnixAddress("/tmp/renaissance2.sock"); + StreamListener streamListener = StreamListener.create(server, listenAddr); + server.start(); + + scope(exit) + { + import std.stdio; + remove((cast(UnixAddress)listenAddr).path().ptr); + } + + /** + * Create a few clients here (TODO: We'd need the client code) + */ + for(ulong idx = 0; idx < 10; idx++) + { + Socket clientSocket = new Socket(listenAddr.addressFamily(), SocketType.STREAM); + clientSocket.connect(listenAddr); + Manager manager = new Manager(clientSocket); + Queue myQueue = new Queue(69); + manager.registerQueue(myQueue); + manager.start(); + + // Thread.sleep(dur!("seconds")(2)); + TaggedMessage myMessage = new TaggedMessage(69, cast(byte[])"ABBA"); + manager.sendMessage(myMessage); + manager.sendMessage(myMessage); + // Thread.sleep(dur!("seconds")(2)); + manager.sendMessage(myMessage); + manager.sendMessage(myMessage); + } + + // while(true) } \ No newline at end of file