Inject logger instead of using a singleton

src/logger.cpp

@@ -1,32 +1,35 @@
 #include <cstdio>
 #include "logger.hpp"
 
+void Log(std::string const & label, std::string const & message)
+{
+	std::printf("[%s] %s\n", label.c_str(), message.c_str());
+}
+
+void Logger::Success(const std::string & s)
+{
+	Log("SUCCESS", s);
+}
+
+void Logger::Error(const std::string & s)
+{
+	Log("ERROR", s);
+}
+
+void Logger::Info(const std::string & s)
+{
+	Log("INFO", s);
+}
+
+void Logger::Debug(const std::string & s)
+{
+	Log("DEBUG", s);
+}
+
 Logger::~Logger()
 {
 }
 
 Logger::Logger()
 {
-}
-
-void Logger::Success(const std::string & s)
-{
-	std::printf("[SUCCESS] %s\n", s.c_str());
-}
-
-void Logger::Error(const std::string & s)
-{
-	std::printf("[ERROR] %s\n", s.c_str());
-}
-
-void Logger::Info(const std::string & s)
-{
-	std::printf("[INFO] %s\n", s.c_str());
-}
-
-Logger & Logger::GetInstance()
-{
-	static Logger logger;
-
-	return logger;
 }

src/logger.hpp

@@ -3,17 +3,14 @@
 
 class Logger
 {
-private:
-	Logger();
-	~Logger();
-
 public:
 	void Success(const std::string & s);
 	void Error(const std::string & s);
 	void Info(const std::string & s);
+	void Debug(const std::string & s);
 
-	static Logger & GetInstance();
+	Logger();
-
+	~Logger();
 	Logger(Logger & other) = delete;
 	Logger(Logger && other) = delete;
 	Logger & operator=(Logger & other) = delete;

src/main.cpp

@@ -5,16 +5,8 @@
 
 int main(int argc, char ** argv)
 {
-	/*
+	Logger logger;
-	ServerConfiguration & serverConfiguration;
+	HttpServer httpServer(logger);
-	if (serverConfiguration.LoadFromFile("./server.cfg") && !serverConfiguration.IsValid())
-	{
-		Logger::GetInstance().Error("Error loading configuration file, aborting.");
-		return 1;
-	}
-	*/
-
-	HttpServer httpServer;
 	httpServer.Execute();
 
 	return 0;

src/middleware/base.cpp

@@ -0,0 +1,9 @@
+#include "base.hpp"
+
+namespace Middleware
+{
+	BaseMiddleware::BaseMiddleware(Logger & _logger)
+		: logger(_logger)
+	{
+	}
+}

src/middleware/base.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include "../http/request.hpp"
 #include "../http/response.hpp"
+#include "../logger.hpp"
 #include <cstdint>
 #include <string>
 
@@ -8,10 +9,13 @@ namespace Middleware
 {
 	class BaseMiddleware
 	{
+	protected:
+		Logger & logger;
+
 	public:
 		virtual void HandleRequest(Http::Request const & request, Http::Response & response) = 0;
 
-		BaseMiddleware() = default;
+		BaseMiddleware(Logger & logger);
 		virtual ~BaseMiddleware() = default;
 	};
 }

src/middleware/notfound.cpp

@@ -25,4 +25,9 @@ namespace Middleware
 			responseContent.begin(),
 			responseContent.end());
 	}
+
+	NotFound::NotFound(Logger & _logger)
+		: BaseMiddleware(_logger)
+	{
+	}
 }

src/middleware/notfound.hpp

@@ -7,5 +7,7 @@ namespace Middleware
 	{
 	public:
 		void HandleRequest(Http::Request const & request, Http::Response & Response) override;
+
+		NotFound(Logger & logger);
 	};
 }

src/middleware/staticcontent.cpp

@@ -90,11 +90,12 @@ namespace Middleware
 		return;
 	}
 
-	StaticContent::StaticContent(std::string const & staticFileRoot)
+	StaticContent::StaticContent(Logger & _logger, std::string const & staticFileRoot)
-		: root(staticFileRoot)
+		: BaseMiddleware(_logger),
+		root(staticFileRoot)
 	{
 		std::stringstream ss;
 		ss << "Using static file root " << root;
-		Logger::GetInstance().Info(ss.str());
+		_logger.Info(ss.str());
 	}
 }

src/middleware/staticcontent.hpp

@@ -14,6 +14,6 @@ namespace Middleware
 	public:
 		virtual	void HandleRequest(Http::Request const & request, Http::Response & response) override;
 
-		StaticContent(std::string const & staticFileRoot);
+		StaticContent(Logger & logger, std::string const & staticFileRoot);
 	};
 }

src/server/connectionoperator.cpp

@@ -15,7 +15,7 @@ void ConnectionOperator::SendResponse(Connection const & connection, Http::Respo
 	}
 	catch(std::runtime_error & e)
 	{
-		Logger::GetInstance().Error("Error writing data to connection");
+		logger.Error("Error writing data to connection");
 	}
 }
 
@@ -34,7 +34,7 @@ void ConnectionOperator::HandleNewConnection(Connection const & newConnection)
 		ss << "Error during parsing of request <";
 		ss << e.what();
 		ss << '>';
-		Logger::GetInstance().Error(ss.str());
+		logger.Error(ss.str());
 
 		response.code = HttpResponse::Code::BAD_REQUEST;
 		SendResponse(newConnection, response);
@@ -54,7 +54,7 @@ void ConnectionOperator::HandleNewConnection(Connection const & newConnection)
 		ss << " request for file <";
 		ss << request.url.GetPath();
 		ss << '>';
-		Logger::GetInstance().Error(ss.str());
+		logger.Error(ss.str());
 
 		response.code = HttpResponse::Code::NOT_IMPLEMENTED;
 		SendResponse(newConnection, response);
@@ -65,15 +65,16 @@ void ConnectionOperator::HandleNewConnection(Connection const & newConnection)
 	newConnection.WriteBytes(bytesToSend);
 }
 
-ConnectionOperator::ConnectionOperator()
+ConnectionOperator::ConnectionOperator(Logger & _logger)
+	: logger(_logger)
 {
 	// Base static file server
 	auto const & staticFileRoot = ServerConfiguration::GetInstance().GetWwwRoot();
 	if (staticFileRoot.size() > 0)
 	{
-		middlewares.emplace_back(std::make_unique<Middleware::StaticContent>(staticFileRoot));
+		middlewares.emplace_back(std::make_unique<Middleware::StaticContent>(_logger, staticFileRoot));
 	}
 
 	// ALWAYS LAST!
-	middlewares.emplace_back(std::make_unique<Middleware::NotFound>());
+	middlewares.emplace_back(std::make_unique<Middleware::NotFound>(_logger));
 }

src/server/connectionoperator.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include "../logger.hpp"
 #include "../middleware/base.hpp"
 #include "connection.hpp"
 #include <memory>
@@ -8,6 +9,7 @@
 class ConnectionOperator
 {
 private:
+	Logger & logger;
 	std::vector<std::unique_ptr<Middleware::BaseMiddleware>> middlewares;
 
 	void SendResponse(Connection const & connection, Http::Response const & response) const;
@@ -15,5 +17,5 @@ private:
 public:
 	void HandleNewConnection(Connection const & newConnection);
 
-	ConnectionOperator();
+	ConnectionOperator(Logger & logger);
 };

src/server/listeningsocket.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include "../logger.hpp"
 #include "connection.hpp"
 #include <sys/socket.h>
 #include <netinet/in.h>

src/server/server.cpp

@@ -15,17 +15,18 @@ void HttpServer::Execute()
 		}
 		catch (std::runtime_error & e)
 		{
-			Logger::GetInstance().Info("Connection dropped on accept");
+			logger.Info("Connection dropped on accept");
 		}
 	}
 }
 	
-HttpServer::HttpServer()
+HttpServer::HttpServer(Logger & _logger)
-	: listeningSocket(ServerConfiguration::GetInstance().GetPort()),
+	: logger(_logger),
-	connectionOperator(),
+	listeningSocket(ServerConfiguration::GetInstance().GetPort()),
+	connectionOperator(_logger),
 	isOpen(true)
 {
 	std::stringstream ss;
 	ss << "Listening on port " << ServerConfiguration::GetInstance().GetPort();
-	Logger::GetInstance().Info(ss.str());
+	logger.Info(ss.str());
 }

src/server/server.hpp

@@ -1,10 +1,12 @@
 #pragma once
+#include "../logger.hpp"
 #include "connectionoperator.hpp"
 #include "listeningsocket.hpp"
 
 class HttpServer
 {
 private:
+	Logger & logger;
 	ListeningSocket listeningSocket;
 	ConnectionOperator connectionOperator;
 	bool isOpen;
@@ -12,7 +14,7 @@ private:
 public:
 	void Execute();
 	
-	HttpServer();
+	HttpServer(Logger & logger);
 	HttpServer(HttpServer & other) = delete;
 	HttpServer & operator=(HttpServer & other) = delete;
 };