Reorganized some includes.

Fixed Logger to actually *use* LoggingSingleton.
Fixed a couple of places to log using Logger instead of cout.
Fixed typo in globals.h
Fixed init order in server (Config, Logger and then SignalHandler)
Made compiler happy by handling a couple of unhandled errors, thus currently no compiler warnings.

Author: LeHack

.gitignore

@@ -46,3 +46,4 @@ CMakeLists.txt
 
 # Archive
 etap*.zip
+/Release/

src/BasicHTTP.h

@@ -2,7 +2,6 @@
 #define SRC_BASICHTTP_H_
 
 #include "DataHandler.h"
-#include "Exceptions.h"
 #include "Logger.h"
 
 // Currently returned HTTP CODES

src/Common.h

@@ -0,0 +1,13 @@
+#ifndef SRC_COMMON_H_
+#define SRC_COMMON_H_
+
+using namespace std;
+
+// our exception model
+#include "Exceptions.h"
+
+// commonly used libs
+#include <cerrno>
+#include <cstdlib>
+
+#endif /* SRC_COMMON_H_ */

src/Config.cpp

@@ -1,23 +1,17 @@
-#include <fstream>
-#include <sstream>
-#include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-#include <vector>
-#include <map>
-#include <signal.h>
 #include "Config.h"
-#include "globals.h"
-#define CONFIG_SIZE 500
+#include "Logger.h"
 /*
  * config - loads config file on demand, keeps the config in shared RO memory for fast access
  */
 
 std::map<string, string> configMap;
 
+Logger *logger;
 Config::Config() {
+    queue_size = 10;
     loadConfigFileToMap();
-//    printMapContents();
+    logger = new Logger("Config");
+    logger->debug("Ready");
 }
 
 
@@ -30,9 +24,16 @@ void Config::loadConfigFileToMap(){
     std::string key;
     size_t position;
 
-    int configFileDescriptor = open("./config", O_RDONLY);
+    int configFileDescriptor;
+    // TODO: Should take name of config file from constructor param (passed from CmdLine or some default)
+    if ((configFileDescriptor = open("./config", O_RDONLY, S_IRUSR)) == -1) {
+        throw ConfigException("Cannot open config file!");
+    }
+
     char configFileContents[CONFIG_SIZE];
-    read(configFileDescriptor, &configFileContents, CONFIG_SIZE);
+    if (read(configFileDescriptor, &configFileContents, CONFIG_SIZE) == -1) {
+        throw ConfigException("Cannot read config file!");
+    }
     close(configFileDescriptor);
 
     //Removes everything after ; in config file
@@ -62,21 +63,22 @@ void Config::loadConfigFileToMap(){
 }
 
 void Config::printMapContents(){
-    cout << "Currently loaded Config:" << endl;
+    logger->debug("Currently loaded Config:");
     for (const auto &p : configMap) {
-        std::cout << "[" << p.first << "] = " << p.second << '\n';
+        logger->debug("[" + p.first + "] = " + p.second);
     }
 }
 
 Config::~Config() {
+    delete(logger);
 }
 
 
 int Config::get_int_setting(std::string setting_name) {
-    if(isSigusr1Recieved){
+    if(isSigusr1Received){
         Config::loadConfigFileToMap();
-//        Config::printMapContents();
-        isSigusr1Recieved = false;
+        Config::printMapContents();
+        isSigusr1Received = false;
     }
 	int returnInt = -1;
     try {
@@ -91,10 +93,10 @@ int Config::get_int_setting(std::string setting_name) {
 
 
 std::string Config::get_str_setting(std::string setting_name) {
-    if(isSigusr1Recieved){
+    if(isSigusr1Received){
         Config::loadConfigFileToMap();
         Config::printMapContents();
-        isSigusr1Recieved = false;
+        isSigusr1Received = false;
     }
     std::string returnString;
 

src/Config.h

@@ -1,15 +1,22 @@
 #ifndef SRC_CONFIG_H_
 #define SRC_CONFIG_H_
-#include <iostream>
-#include <exception>
-#include <vector>
+
+#include "Common.h"
+#include "globals.h"
+
+#include <fcntl.h>
+#include <fstream>
+#include <map>
 #include <signal.h>
+#include <sstream>
+#include <unistd.h>
+#include <vector>
 
+#define CONFIG_SIZE 500
 
 class Config {
 	private:
-		// to be replaced with some dynamic map struct
-		int queue_size = 10;
+		int queue_size;
         static std::string configString;
         static std::string delimiter;
         static std::string configRelevantString;
@@ -26,19 +33,11 @@ class Config {
 		static std::string get_str_setting(std::string);
 };
 
-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 ConfigException: public exception {
-	std::string reason;
-
-	public:
-		ConfigException(std::string msg = "Unknown exception") {
-			reason = msg;
-		}
-		virtual const char* what() const throw() {
-			return reason.c_str();
-		}
+class ConfigException: public BaseException {
+    public:
+        ConfigException(std::string msg = "Unknown config exception") {
+            this->reason = msg;
+        }
 };
 
 #endif /* SRC_CONFIG_H_ */

src/DataHandler/Exec.cpp

@@ -1,10 +1,5 @@
 #include "../DataHandler.h"
 
-#include <cstring>
-#include <fcntl.h>
-#include <unistd.h>
-#include <linux/limits.h>
-
 /*
  * handlers - currently two are planned: static file handler, cgi script handler
  * 1. cgi handler - fires given script and returns it's output
@@ -113,7 +108,14 @@ DataHandler::resource DataHandler::Exec::run_command(std::string args[], DataHan
 
         // Now first write what we have
         if (data && data->type == "POST") {
-            write(comms_in[PIPE_WRITE], data->data, data->size + 1);
+            if (write(comms_in[PIPE_WRITE], data->data, data->size + 1) == -1 ) {
+                char * err = std::strerror(errno);
+                throw DataHandler::Exception(
+                    "Error while writing to child process: " + std::string(args[0]) +", "
+                    + "error message: " + std::string(err ? err : "unknown error")
+                );
+
+            }
         }
         close(comms_in[PIPE_WRITE]);
 

src/DataHandler/Static.cpp

@@ -1,11 +1,5 @@
 #include "../DataHandler.h"
 
-#include <cstring>
-#include <fcntl.h>
-#include <unistd.h>
-#include <linux/limits.h>
-
-
 /*
  * handlers - currently two are planned: static file handler, cgi script handler
  * 1. cgi handler - fires given script and returns it's output
@@ -26,7 +20,6 @@ DataHandler::resource DataHandler::Static::get_file(std::string path) {
     this->logger->debug("Read file: " + path);
     int fd = open(path.c_str(), O_RDONLY);
     if (fd < 0) {
-        // TODO: replace with a proper HTTP CODE
         char * err = std::strerror(errno);
         throw DataHandler::FileNotFound("Error while reading file contents at " + path + ": " + std::string(err ? err : "unknown error"));
     }
@@ -36,7 +29,10 @@ DataHandler::resource DataHandler::Static::get_file(std::string path) {
 
     DataHandler::resource data;
     data.data = (char *) malloc(fsize+1);
-    read(fd, data.data, fsize);
+    if (read(fd, data.data, fsize) == -1) {
+        char * err = std::strerror(errno);
+        throw DataHandler::Exception("Error while reading file contents at " + path + ": " + std::string(err ? err : "unknown error"));
+    }
     close(fd);
 
     data.data[fsize] = '\0';

src/Exceptions.h

@@ -22,6 +22,7 @@ class BaseException: public std::exception {
         virtual const char* what() const throw() {
             return (name() + ": " + reason).c_str();
         }
+        virtual ~BaseException() throw() {};
 };
 
 #endif /* SRC_EXCEPTIONS_H_ */

src/Logger.cpp

@@ -1,11 +1,10 @@
 #include "Logger.h"
-#include "Config.h"
+#include "LoggingSingleton.h"
 #include <ctime>
 #include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
 #include <map>
-#include <mutex>
+#include <string.h>
+#include <unistd.h>
 
 /*
   * Simple logging utility with:
@@ -15,12 +14,10 @@
  */
 
 // global
-std::string log_path;
 std::time_t epochTimestamp;
-int logFileDescriptor;
-std::mutex mut;
 
 Logger::Logger(std::string path, std::string name) {
+    isLoggingToFileEnabled = true;
     std::map<string, int > map;
     map.insert(pair<string, int>("QUIET", 0));
     map.insert(pair<string, int>("WARNINGS", 1));
@@ -31,12 +28,14 @@ Logger::Logger(std::string path, std::string name) {
     this->current_log_level = map.at(Config::get_str_setting("current_log_level"));
     this->class_name = name;
     log_path = path;
-    logFileDescriptor = open(log_path.c_str(), O_WRONLY | O_APPEND | O_CREAT );
+    logFileDescriptor = open(log_path.c_str(), O_WRONLY | O_APPEND | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP );
 
     if(logFileDescriptor < 0){
         loggerStatus = "[" + this->class_name + "]" + " Error opening logfile at "+log_path+", disabling logging to file\nError: " + strerror(errno) + "\n";
         cLoggerStatus = loggerStatus.c_str();
-        write(2, cLoggerStatus, strlen(cLoggerStatus));
+        if (write(STDERR_FILENO, cLoggerStatus, strlen(cLoggerStatus)) == -1) {
+            throw Logger::Exception("Cannot write to STDERR.");
+        }
         isLoggingToFileEnabled = false;
     }
 }
@@ -47,23 +46,28 @@ Logger::~Logger() {
 
 void Logger::_log(std::string msg, int level) {
     if(this->current_log_level >= level) {
-        mut.lock();
         epochTimestamp = std::time(nullptr);
         fullDateTimestamp = std::asctime(std::localtime(&epochTimestamp));
-        fullMessage = "[" +
-                      this->class_name + " " +
-                      fullDateTimestamp.substr(0, fullDateTimestamp.size() - 1) + "] " +
+        fullMessage = "[" + fullDateTimestamp.substr(0, fullDateTimestamp.size() - 1) + "] " +
+                      "[:" + this->class_name + "] " +
                       msg + "\n";
         if(!isLoggingToFileEnabled){
             fullMessage = "WARNING: Logging to file disabled " + fullMessage;
         }
 
         const char* cFullMessage = fullMessage.c_str();
 
-        write(1, cFullMessage, strlen(cFullMessage));
+        // fetch a LoggingSingleton instance when it's actually needed
+        LoggingSingleton *logWriter = LoggingSingleton::GetInstance();
+        logWriter->log(STDOUT_FILENO, cFullMessage);
         if (isLoggingToFileEnabled) {
-            write(logFileDescriptor, cFullMessage, strlen(cFullMessage));
+            try {
+                logWriter->log(logFileDescriptor, cFullMessage);
+            }
+            catch (LoggingSingleton::Exception &e) {
+                const char* errMessage = std::string("Error while writing to logfile: " + std::string(e.what()) + "\n").c_str();
+                logWriter->log(STDOUT_FILENO, errMessage);
+            }
         }
-        mut.unlock();
     }
 }

src/Logger.h

@@ -1,7 +1,8 @@
 #ifndef SRC_LOGGER_H_
 #define SRC_LOGGER_H_
-#include <string>
 #include "Config.h"
+
+#include <cstring>
 #define QUIET 0
 #define WARNINGS 1
 #define INFO 2
@@ -15,7 +16,9 @@ class Logger {
 	std::string class_name;
 	std::string fullMessage;
 	std::string fullDateTimestamp;
-    bool isLoggingToFileEnabled = true;
+	std::string log_path;
+	int logFileDescriptor;
+    bool isLoggingToFileEnabled;
 
 public:
 	Logger() {}
@@ -28,6 +31,13 @@ class Logger {
 	void warn(std::string msg)  { this->_log(msg, WARNINGS); }
 	void info(std::string msg)  { this->_log(msg, INFO); 	 }
 	void debug(std::string msg) { this->_log(msg, DEBUG);	 }
+
+	class Exception: public BaseException {
+	    public:
+	        Exception(std::string msg = "Unknown logger exception") {
+	            this->reason = msg;
+	        }
+	};
 };
 
 #endif /* SRC_LOGGER_H_ */