First working version with Router/Manager/Worker split.

Author: lh5053

src/Logger.cpp

@@ -40,7 +40,7 @@ Logger::Logger(std::string path, std::string name) : LoggerBase(path) {
     logFileDescriptor = open(log_path.c_str(), O_WRONLY | O_APPEND);
 
     if(logFileDescriptor < 0){
-        loggerStatus = "[" + this->class_name + "]" + "Error opening logfile, disabling logging to file\nError: " + strerror(errno);
+        loggerStatus = "[" + this->class_name + "]" + " Error opening logfile, disabling logging to file\nError: " + strerror(errno) + "\n";
         cLoggerStatus = loggerStatus.c_str();
         write(2, cLoggerStatus, strlen(cLoggerStatus));
         isLoggingToFileEnabled = false;
@@ -72,8 +72,8 @@ void Logger::_log(std::string msg, int level) {
 
         write(1, cFullMessage, strlen(cFullMessage));
         if (isLoggingToFileEnabled) {
-                write(logFileDescriptor, cFullMessage, strlen(cFullMessage));
-            }
+            write(logFileDescriptor, cFullMessage, strlen(cFullMessage));
+        }
         mutex.unlock();
     }
 }

src/Router.cpp

@@ -1,9 +1,13 @@
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <errno.h>
 #include <netdb.h>
 #include <unistd.h>
 #include <thread>
 #include <chrono>
+#include <cstring>
+#include <netinet/in.h>
+#include <arpa/inet.h>
 
 #include "Router.h"
 #include "Manager.h"
@@ -19,7 +23,7 @@ Router::Router(int qsize, std::string port) {
 	this->logger = Logger("Router");
 	this->port = port;
     // initialize the socket
-    this->init_socket();
+	this->listening_socket_fd = this->init_socket();
 }
 
 Router::~Router() {
@@ -29,9 +33,17 @@ Router::~Router() {
     freeaddrinfo(addr);
 }
 
+void *get_in_addr(struct sockaddr *sa) {
+    if (sa->sa_family == AF_INET) {
+        return &(((struct sockaddr_in*)sa)->sin_addr);
+    }
+
+    return &(((struct sockaddr_in6*)sa)->sin6_addr);
+}
+
 void Router::watch() {
 	socklen_t addr_size;
-    struct sockaddr_storage incoming_connection_info;
+    struct sockaddr_storage client;
     int handling_socket;
 
     this->logger.debug("watching port: " + this->port);
@@ -44,15 +56,20 @@ void Router::watch() {
         // listen for new connections
         listen(this->listening_socket_fd, this->queue_size);
 
-        addr_size = sizeof incoming_connection_info;
-        handling_socket = accept(listening_socket_fd, (struct sockaddr *) &incoming_connection_info, &addr_size);
-        this->logger.info("Handling incoming connection from: ");
+        addr_size = sizeof client;
+        handling_socket = accept(this->listening_socket_fd, (struct sockaddr *) &client, &addr_size);
+        if (handling_socket < 0) {
+            char * err = std::strerror(errno);
+            throw RouterException("Error when accepting connection: " + std::string(err ? err : "unknown error"));
+        }
+
+        struct sockaddr_in *sin = (struct sockaddr_in *)&client;
+        char client_addr[INET6_ADDRSTRLEN];
+        inet_ntop(AF_INET, &sin->sin_addr, client_addr, sizeof client_addr);
+        this->logger.info("Handling incoming connection from: " + std::string(client_addr));
         // this will create a new worker to work with
-        // TODO: handle too many workers exception
+        // TODO: add try/catch and handle too many workers exception
         manager.handle_request(handling_socket);
-
-        // sleep a little
-        std::this_thread::sleep_for (std::chrono::seconds(1));
     }
 }
 
@@ -70,9 +87,18 @@ int Router::init_socket() {
 
     // TODO error handling (what if we cannot open the socket)
     int listening_socket = socket(this->addr->ai_family, this->addr->ai_socktype, this->addr->ai_protocol);
+    if (listening_socket < 0) {
+        char * err = std::strerror(errno);
+        throw RouterException("Error opening socket: " + std::string(err ? err : "unknown error"));
+    }
 
     // TODO error handling (what if we can't bind)
-    bind(listening_socket, this->addr->ai_addr, this->addr->ai_addrlen);
+    int check = bind(listening_socket, this->addr->ai_addr, this->addr->ai_addrlen);
+    if (check < 0) {
+        char * err = std::strerror(errno);
+        throw RouterException("Error binding socket: " + std::string(err ? err : "unknown error"));
+    }
 
+    this->logger.debug("Got socket: " + std::to_string(listening_socket));
     return listening_socket;
 }

src/Router.h

@@ -20,4 +20,19 @@ class Router {
 	void watch();
 };
 
+using namespace std;
+// Possibly we could also add a stack trace here:
+// http://stackoverflow.com/questions/353180/how-do-i-find-the-name-of-the-calling-function
+class RouterException: public exception {
+    std::string reason;
+
+    public:
+        RouterException(std::string msg = "Unknown exception") {
+            reason = msg;
+        }
+        virtual const char* what() const throw() {
+            return reason.c_str();
+        }
+};
+
 #endif /* SRC_ROUTER_H_ */