Work in progress.

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.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,78 @@
-#include <cstring>
-#include <string.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netdb.h>
 #include <unistd.h>
-#include <stdio.h>
-#include <pthread.h>
+#include <thread>
+#include <chrono>
 
 #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->init_socket();
 }
 
 Router::~Router() {
-	// TODO Auto-generated destructor stub
+    // close our socket
+    close(this->listening_socket_fd);
+    // free the address
+    freeaddrinfo(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 incoming_connection_info;
-    socklen_t addr_size;
-    struct addrinfo listening_socket_description, *results;
-    int listening_socket_fd, new_socket_fd;
+    int handling_socket;
 
-    // first, load up address structs with getaddrinfo():
-    memset(&listening_socket_description, 0, sizeof listening_socket_description);
+    this->logger.debug("watching port: " + this->port);
 
-    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);
+    // create a manager object to handle different threads
+    Manager manager;
 
-    // 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);
+    // we work until we're told to stop working
+    while (true) {
+        // listen for new connections
+        listen(this->listening_socket_fd, this->queue_size);
 
-    listen(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: ");
+        // this will create a new worker to work with
+        // TODO: handle too many workers exception
+        manager.handle_request(handling_socket);
+
+        // sleep a little
+        std::this_thread::sleep_for (std::chrono::seconds(1));
+    }
+}
 
-    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");
+int Router::init_socket() {
+    struct addrinfo listening_socket_description;
 
-    pthread_t t1;
-    this->logger.debug("creating new thread");
-    pthread_create(&t1, NULL, newSocketFunction, (void *) &new_socket_fd);
-    pthread_join(t1, NULL);
+    // 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);
 
-    this->logger.debug("closing connection");
-    freeaddrinfo(results);
-    close(listening_socket_fd);
-    close(new_socket_fd);
+    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, this->port.c_str(), &listening_socket_description, &this->addr);
 
-    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);
 
-// 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)
+    bind(listening_socket, this->addr->ai_addr, this->addr->ai_addrlen);
 
-    return NULL;
+    return listening_socket;
 }

src/Router.h

@@ -1,17 +1,23 @@
 #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();
 };
 
 #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();
+    }
+}

src/Worker.h

@@ -1,10 +1,17 @@
 #ifndef SRC_WORKER_H_
 #define SRC_WORKER_H_
 
+#include "Logger.h"
+
 class Worker {
+private:
+    int socket_fd;
+    Logger logger;
+
 public:
-	Worker();
+	Worker(int socket_fd);
 	virtual ~Worker();
+	void handle_request();
 };
 
 #endif /* SRC_WORKER_H_ */

src/server.cpp

@@ -20,16 +20,16 @@ int main() {
     //"hello from server.cpp" message, to be removed
     logger.info(config.get_str_setting("config_test"));
 
-    if(config.get_str_setting("start_full_server") == "true") {
+//    if(config.get_str_setting("start_full_server") == "true") {
         // starting the full server
         std::string port = config.get_str_setting("port");
         logger.info("Starting HackTTP at port: " + port);
 
-        Router router(config.get_int_setting("queue_size"));
-        router.watch(port);
-    } else {
-        logger.info("Running in test mode");
-    }
+        Router router(config.get_int_setting("queue_size"), port);
+        router.watch();
+//    } else {
+//        logger.info("Running in test mode");
+//    }
 	// cleanup
 	logger.info("HackTTP shutting down");