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

@@ -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);
         }

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;

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
 {

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();
+}

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)
 }