Merge branch 'temp'

Author: lh5053

config

@@ -2,7 +2,7 @@ port=8000
 log_path=./log
 queue_size=10
 config_test=Config Loaded, hello from server.cpp!
-start_full_server=false
+start_full_server=true
 ;
 
 Config manual:

hackttp.archive

@@ -6,4 +6,4 @@ echo "OK"
 echo -n "Creating archive..."
 zip -r HackTTP.zip hackttp/ -x '*/.git/*'
 rm -Rf hackttp
-echo "HackTTP.zip ready"
+echo "etap_$1.zip ready"

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/Logger.h

@@ -6,7 +6,8 @@ enum LogLevel { QUIET, WARNINGS, INFO, DEBUG };
 
 class LoggerBase {
 protected:
-	int current_log_level = INFO;
+    // TODO: should be loaded from Config
+	int current_log_level = DEBUG;
 public:
 	LoggerBase() {}
 	LoggerBase(std::string path);

src/Manager.cpp

@@ -1,15 +1,50 @@
-#include "Manager.h"
+#include <stdio.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <cstring>
+#include <pthread.h>
 
+#include "Manager.h"
+#include "Worker.h"
 /*
  * manager - keeps track of workers, their current status, should handle zombies (number of workers comes from config)
  */
 
 Manager::Manager() {
-	// TODO Auto-generated constructor stub
-
+    this->logger = Logger("Manager");
+    // TODO Move to config file and fetch directly from there
+    int worker_count = 10;
+    this->pool = (pthread_t*) calloc(worker_count, sizeof(pthread_t));
 }
 
 Manager::~Manager() {
-	// TODO Auto-generated destructor stub
+    free(this->pool);
 }
 
+void *worker_runner(void *socket_fd);
+
+void Manager::handle_request(int socket_fd) {
+    this->logger.debug("Handling request via socket: " + std::to_string(socket_fd));
+
+    // get worker, if available
+    pthread_t worker_t = this->get_free_worker();
+
+    // handle the requst in a new thread
+    pthread_create(&worker_t, NULL, worker_runner, (void *) &socket_fd);
+
+    return;
+}
+
+int Manager::get_free_worker() {
+    // TODO look for a free worker
+    return this->pool[0];
+}
+
+void *worker_runner(void *socket_fd) {
+    int *socket = (int *) socket_fd;
+    Worker worker(*socket);
+    worker.handle_request();
+
+    return NULL;
+}

src/Manager.h

@@ -1,10 +1,19 @@
 #ifndef SRC_MANAGER_H_
 #define SRC_MANAGER_H_
 
+#include "Logger.h"
+#include "Worker.h"
+
 class Manager {
+private:
+    pthread_t * pool; // keeps a pool of available workers
+    Logger logger;
+    int get_free_worker();
+
 public:
 	Manager();
 	virtual ~Manager();
+	void handle_request(int socket_fd);
 };
 
 #endif /* SRC_MANAGER_H_ */

src/Router.cpp

@@ -1,93 +1,104 @@
-#include <cstring>
-#include <string.h>
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <errno.h>
 #include <netdb.h>
 #include <unistd.h>
-#include <stdio.h>
-#include <pthread.h>
+#include <thread>
+#include <chrono>
+#include <cstring>
+#include <netinet/in.h>
+#include <arpa/inet.h>
 
 #include "Router.h"
+#include "Manager.h"
 
 /*
  * router - watches the designated port and for launches a new worker for every connection
  * (when all workers are busy, waits some time before returning an error - "how long" should be kept in the config)
  * Handles *some* of the HTTP errors
  */
 
-Router::Router(int qsize) {
+Router::Router(int qsize, std::string port) {
 	this->queue_size = qsize;
 	this->logger = Logger("Router");
+	this->port = port;
+    // initialize the socket
+	this->listening_socket_fd = this->init_socket();
 }
 
 Router::~Router() {
-	// TODO Auto-generated destructor stub
+    // close our socket
+    close(this->listening_socket_fd);
+    // free the address
+    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 *newSocketFunction(void *socket_fd);
-void Router::watch(std::string port) {
-	this->logger.debug("starting with port" + port);
+void Router::watch() {
+	socklen_t addr_size;
+    struct sockaddr_storage client;
+    int handling_socket;
+
+    this->logger.debug("watching port: " + this->port);
+
+    // create a manager object to handle different threads
+    Manager manager;
+
+    // we work until we're told to stop working
+    while (true) {
+        // listen for new connections
+        listen(this->listening_socket_fd, this->queue_size);
+
+        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: add try/catch and handle too many workers exception
+        manager.handle_request(handling_socket);
+    }
+}
 
-    struct sockaddr_storage incoming_connection_info;
-    socklen_t addr_size;
-    struct addrinfo listening_socket_description, *results;
-    int listening_socket_fd, new_socket_fd;
+int Router::init_socket() {
+    struct addrinfo listening_socket_description;
 
     // first, load up address structs with getaddrinfo():
+    // TODO error handling (what if there's no memory available)
     memset(&listening_socket_description, 0, sizeof listening_socket_description);
 
     listening_socket_description.ai_family = AF_UNSPEC;  // use IPv4 or IPv6, whichever
     listening_socket_description.ai_socktype = SOCK_STREAM;
     listening_socket_description.ai_flags = AI_PASSIVE;     // fill in my IP for me
-    getaddrinfo(NULL, port.c_str(), &listening_socket_description, &results);
+    getaddrinfo(NULL, this->port.c_str(), &listening_socket_description, &this->addr);
 
-    // make a socket, bind it, and listen on it:
-    listening_socket_fd = socket(results->ai_family, results->ai_socktype, results->ai_protocol);
-    bind(listening_socket_fd, results->ai_addr, results->ai_addrlen);
-
-    listen(listening_socket_fd, this->queue_size);
-
-    addr_size = sizeof incoming_connection_info;
-    new_socket_fd = accept(listening_socket_fd, (struct sockaddr *) &incoming_connection_info, &addr_size);
-    this->logger.info("handling connection");
-
-    pthread_t t1;
-    this->logger.debug("creating new thread");
-    pthread_create(&t1, NULL, newSocketFunction, (void *) &new_socket_fd);
-    pthread_join(t1, NULL);
-
-    this->logger.debug("closing connection");
-    freeaddrinfo(results);
-    close(listening_socket_fd);
-    close(new_socket_fd);
-
-    this->logger.debug("done");
-}
+    // 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"));
+    }
 
-// Possibly this code will be moved and divided to manager/worker
-// that's why I'm leaving this out of the Router:: class
-void *newSocketFunction(void *socket_fd_ptr){
-	int *socket_fd = (int *)socket_fd_ptr;
-    char reply[100], *msg;
-
-    std::string string = "Welcome to HACKttp: " + std::to_string(*socket_fd) + "\nYour message: ";
-    //msg = "Welcome to HACKttp " + (char) socket_fd;
-    msg = (char *) string.c_str();
-    send(*socket_fd, msg, strlen(msg), 0);
-
-    std::string response;
-    while(1){
-        memset(&reply, 0, sizeof reply);
-        if(recv(*socket_fd, reply, 100, 0) <= 0) break;
-        response.append("HackTTP echo: ");
-        response.append(reply);
-		response.append("\nYour message: ");
-        msg = (char *)response.c_str();
-        send(*socket_fd, msg, strlen(msg), 0);
-        //reply[99] = '\0';
-        printf("Sent back: %s", response.c_str());
-        response.clear();
+    // TODO error handling (what if we can't bind)
+    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"));
     }
 
-    return NULL;
+    this->logger.debug("Got socket: " + std::to_string(listening_socket));
+    return listening_socket;
 }

src/Router.h

@@ -1,17 +1,38 @@
 #ifndef SRC_ROUTER_H_
 #define SRC_ROUTER_H_
-
+#include <cstring>
 #include <iostream>
+
 #include "Logger.h"
 
 class Router {
 private:
 	int queue_size;
+	int listening_socket_fd;
+	std::string port;
+	struct addrinfo *addr;
 	Logger logger;
+	int init_socket();
+
 public:
-	Router(int qsize);
+	Router(int qsize, std::string port);
 	virtual ~Router();
-	void watch(std::string port);
+	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_ */

src/Worker.cpp

@@ -1,16 +1,48 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <cstring>
+#include <string.h>
+
 #include "Worker.h"
 #include "BasicHTTP.h"
 
 /*
  * worker - uses an appropriate handler to serve the request
  */
 
-Worker::Worker() {
-	// TODO Auto-generated constructor stub
-
+Worker::Worker(int socket_fd) {
+    this->logger = Logger("Worker");
+    this->socket_fd = socket_fd;
 }
 
 Worker::~Worker() {
-	// TODO Auto-generated destructor stub
+    // make sure to close the socket when we finish
+	close(this->socket_fd);
 }
 
+void Worker::handle_request() {
+    char reply[100], *msg;
+
+    this->logger.info("Handling request via socket: " + std::to_string(this->socket_fd));
+    // Send welcome message
+    std::string string = "Welcome to HACKttp: " + std::to_string(this->socket_fd) + "\nYour message: ";
+    msg = (char *) string.c_str();
+    send(this->socket_fd, msg, strlen(msg), 0);
+
+    std::string response;
+    while(1){
+        memset(&reply, 0, sizeof reply);
+        if(recv(this->socket_fd, reply, 100, 0) <= 0) break;
+        response.append("HackTTP echo: ");
+        response.append(reply);
+        response.append("\nYour message: ");
+        msg = (char *)response.c_str();
+        send(this->socket_fd, msg, strlen(msg), 0);
+        //reply[99] = '\0';
+        printf("Sent back: %s", response.c_str());
+        response.clear();
+    }
+}