feat: Implement running multiple servers

Makefile

@@ -4,7 +4,7 @@ INCLUDE_FLAGS = -I srcs
 TARGET = webserv
 
 SRCS_FILES = main.cpp utils.cpp \
-			Master.cpp Worker.cpp Request.cpp Response.cpp Cgi.cpp Uri.cpp \
+			Nginxs.cpp Master.cpp Worker.cpp Request.cpp Response.cpp Cgi.cpp Uri.cpp \
 			autoindex/AutoindexData.cpp autoindex/Autoindex.cpp \
 			config/Config.cpp config/Block.cpp
 SRCS = $(addprefix ./srcs/, $(SRCS_FILES))

conf/webserv.conf

@@ -0,0 +1,67 @@
+server {
+	listen 0.0.0.0:4242;
+
+	server_name xxx.xxx.com localhost;
+	root html;
+	client_max_body_size 4242;
+
+	error_page 400 error_pages/400.html;
+	error_page 403 error_pages/403.html;
+	error_page 404 error_pages/404.html;
+	error_page 405 error_pages/405.html;
+	error_page 500 error_pages/500.html;
+	error_page 505 error_pages/505.html;
+
+	location / {
+		location /*.py {
+			cgi ./cgi-bin/python-cgi.py;
+		}
+		index abc.html;
+	}
+
+	location /data {
+		autoindex on;
+		allowed_methods GET;
+	}
+
+	location /errors {
+	}
+
+	location /admin {
+		index index.html;
+	}
+}
+
+server {
+	listen 0.0.0.0:2424;
+
+	server_name xxx.xxx.com localhost;
+	root html;
+	client_max_body_size 4242;
+
+	error_page 400 error_pages/400.html;
+	error_page 403 error_pages/403.html;
+	error_page 404 error_pages/404.html;
+	error_page 405 error_pages/405.html;
+	error_page 500 error_pages/500.html;
+	error_page 505 error_pages/505.html;
+
+	location / {
+		location /*.py {
+			cgi ./cgi-bin/python-cgi.py;
+		}
+		index abc.html;
+	}
+
+	location /data {
+		autoindex on;
+		allowed_methods GET;
+	}
+
+	location /errors {
+	}
+
+	location /admin {
+		index index.html;
+	}
+}

srcs/Master.cpp

@@ -10,58 +10,45 @@ const char *Master::MasterException::what() const throw() {
 	return message_.c_str();
 }
 
-Master::Master(char **env) {
-	struct sockaddr_in	serverAddress;
+Master::Master() {}
 
-	init(serverAddress);
-	bind(serverAddress);
+Master::Master(const Block &serverBlock)
+	: serverBlock_(serverBlock) {
+	init();
+	bind();
 	listen();
-	setEnv(env);
 }
 
 Master::~Master() {
-	std::vector<Worker *>::iterator itBegin = workers_.begin();
-	std::vector<Worker *>::iterator itEnd = workers_.end();
+	std::vector<Worker *>::iterator it;
 
-	while (itBegin != itEnd) {
-		delete *itBegin;
-		++itBegin;
-	}
-}
-
-void Master::setEnv(char **originalEnv) {
-	while (originalEnv && *originalEnv) {
-		env_.push_back(std::string(*originalEnv));
-		originalEnv++;
-	}
+	for (it = workers_.begin(); it != workers_.end(); it++)
+		delete *it;
 }
 
-void Master::addEnv(std::string new_env) {
-	env_.push_back(new_env);
-}
-
-void	Master::init(struct sockaddr_in &serverAddress) {
+void	Master::init() {
 	int yes = 1;
 
 	listenSocket_ = socket(PF_INET, SOCK_STREAM, 0);
 	std::cout << "listenSocket: " << listenSocket_ << std::endl;
+	std::cout << "Port: " << serverBlock_.getPort() << std::endl;
 	if (listenSocket_ == FT_ERROR)
-		throw MasterException("fail: socket()\n");
-	memset(&serverAddress, 0, sizeof(serverAddress));
-	serverAddress.sin_len = sizeof(struct sockaddr_in);
-	serverAddress.sin_family = PF_INET;
-	serverAddress.sin_port = htons(4242);
-	serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+		throw MasterException("init: socket() failed");
+	memset(&serverAddress_, 0, sizeof(serverAddress_));
+	serverAddress_.sin_len = sizeof(struct sockaddr_in);
+	serverAddress_.sin_family = PF_INET;
+	serverAddress_.sin_port = htons(serverBlock_.getPort());
+	serverAddress_.sin_addr.s_addr = htonl(inet_addr(serverBlock_.getHost().c_str()));
 	setsockopt(listenSocket_, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
 }
 
-void	Master::bind(struct sockaddr_in &serverAddress) {
+void	Master::bind() {
 	int	ret;
 
-	ret = ::bind(listenSocket_, (const struct sockaddr *)&serverAddress, sizeof(serverAddress));
+	ret = ::bind(listenSocket_, (const struct sockaddr *)&serverAddress_, sizeof(serverAddress_));
 	if (ret == FT_ERROR) {
 		close(listenSocket_);
-		throw MasterException("fail: bind()\n");
+		throw MasterException("bind: bind() failed");
 	}
 }
 
@@ -71,54 +58,45 @@ void	Master::listen() {
 	ret = ::listen(listenSocket_, 2);
 	if (ret == -1) {
 		close(listenSocket_);
-		throw MasterException("fail: listen()\n");
+		throw MasterException("listen: listen() failed");
 	}
 }
 
 void	Master::run() {
-	int	i;
-	int	ret;
+	int								ret;
+	std::vector<Worker *>::iterator	itBegin = workers_.begin();
+	std::vector<Worker *>::iterator	itEnd = workers_.end();
+
+	while (itBegin != itEnd) {
+		ret = (*itBegin)->work();
+		if (ret == FT_FALSE) {
+			delete *itBegin;
+			itBegin = workers_.erase(itBegin);
+			continue ;
+		}
+		++itBegin;
+	}
+}
 
-	pollfds_[0].fd = listenSocket_;
-	pollfds_[0].events = POLLIN | POLLOUT;
-	pollfds_[0].revents = 0;
+void	Master::appendWorker(struct pollfd *pollFd) {
+	Worker	*worker = new Worker(listenSocket_);
 
-	for (i = 1; i < POLLFDSLEN; i++)
-		pollfds_[i].fd = -1;
+	worker->setPollfd(pollFd);
+	workers_.push_back(worker);
+}
 
-	while (1) {
-		ret = poll(pollfds_, POLLFDSLEN, -1);
-		if (ret == -1) {
-			close(listenSocket_);
-			throw MasterException("fail: poll()\n");
-		}
-		if (pollfds_[0].revents & POLLIN) {
-			Worker	*worker = new Worker(listenSocket_);
-			worker->setPollfd(findEmptyPollfd());
-			workers_.push_back(worker);
-		}
+const struct sockaddr_in Master::getServerAddress() const {
+	return serverAddress_;
+}
 
-		std::vector<Worker *>::iterator itBegin = workers_.begin();
-		std::vector<Worker *>::iterator itEnd = workers_.end();
-
-		while (itBegin != itEnd) {
-			ret = (*itBegin)->work();
-			if (ret == FT_FALSE) {
-				delete *itBegin;
-				itBegin = workers_.erase(itBegin);
-				continue ;
-			}
-			++itBegin;
-		}
-	}
-	close(listenSocket_);
+int Master::getListenSocket() const {
+	return listenSocket_;
 }
 
-struct pollfd	*Master::findEmptyPollfd()
-{
-	for (int i = 1; i < POLLFDSLEN; i++) {
-		if (pollfds_[i].fd == -1)
-			return &pollfds_[i];
-	}
-	return nullptr;
+std::size_t Master::getPollIndex() const {
+	return pollIndex_;
+}
+
+void Master::setPollIndex(std::size_t pollIndex) {
+	pollIndex_ = pollIndex;
 }

srcs/Master.hpp

@@ -13,33 +13,38 @@
 #include <vector>
 #include <iostream>
 #include <exception>
+#include "config/Block.hpp"
 #include "Worker.hpp"
 #include "macro.hpp"
 
-#define POLLFDSLEN 100
-
 class Master {
 private:
 	std::vector<std::string>	env_;
+	struct sockaddr_in 			serverAddress_;
 	int							listenSocket_;
 	std::vector<Worker *>		workers_;
-	struct pollfd				pollfds_[POLLFDSLEN];
-	// Config					config_;
+	Block						serverBlock_;
+	std::size_t					pollIndex_;
 
-	void	init(struct sockaddr_in &serverAddress);
-	void	bind(struct sockaddr_in &serverAddress);
+	void	init();
+	void	bind();
 	void	listen();
-	struct pollfd *findEmptyPollfd();
+
+	Master();
 
 public:
-	Master(char **env);
+	Master(const Block &serverBlock);
 	~Master();
 
 	void	run();
+	void	appendWorker(struct pollfd *pollFd);
 
-	void	setEnv(char **originalEnv);
-	void	addEnv(std::string new_env);
+	const struct sockaddr_in	getServerAddress() const;
+	int							getListenSocket() const;
+	std::size_t					getPollIndex() const;
 
+	void						setPollIndex(std::size_t pollIndex);
+
 	class MasterException : public std::exception {
 	private:
 		std::string message_;

srcs/Nginxs.cpp

@@ -0,0 +1,76 @@
+#include "Nginxs.hpp"
+
+Nginxs::Nginxs() {}
+
+Nginxs::Nginxs(const char *confFilePath) {
+	config_.parseConfigFile(confFilePath);
+}
+
+Nginxs::~Nginxs() {
+	std::vector<Master *>::iterator	masterIt;
+
+	for (masterIt = masters_.begin(); masterIt != masters_.end(); masterIt++)
+		delete *masterIt;
+}
+
+void	Nginxs::run() {
+	std::size_t	i = 0; 
+	int			ret;
+
+	std::vector<Block>				serverBlocks = config_.getServerBlocks();
+	std::vector<Block>::iterator	it;
+	std::vector<Master *>::iterator	masterIt;
+
+	for (it = serverBlocks.begin();	it != serverBlocks.end(); it++)
+	{
+		Master *m = new Master(*it);
+		m->setPollIndex(i);
+		std::cout << "setPollIndex: " << i << std::endl;
+		masters_.push_back(m);
+
+		pollfds_[i].fd = m->getListenSocket();
+		pollfds_[i].events = POLLIN | POLLOUT;
+		pollfds_[i].revents = 0;	
+		i++;
+	}
+
+	// Initialize pollfds for workers
+	for (int fds = i; fds < POLLFDSLEN; fds++)
+		pollfds_[fds].fd = -1;
+
+	while (1) {
+		ret = poll(pollfds_, POLLFDSLEN, -1);
+		if (ret == -1) {
+			for (int fds = 0; fds < POLLFDSLEN; fds++) {
+				if (pollfds_[fds].fd != -1)
+					close(pollfds_[fds].fd);
+			}
+			throw std::runtime_error("run: poll() failed");
+		}
+		for(masterIt = masters_.begin(); masterIt != masters_.end(); masterIt++) {
+			if (pollfds_[(*masterIt)->getPollIndex()].revents & POLLIN) {
+				struct pollfd	*emptyPollFd = findEmptyPollfd();
+			// 	// if (emptyPollFd == nullptr)
+			// 	// 	throw 503
+				// std::cout << "master: " << masterIt->getPollIndex() << std::endl;
+				(*masterIt)->appendWorker(emptyPollFd);
+			}
+			(*masterIt)->run();
+		}
+	}
+	for (int fds = 0; fds < POLLFDSLEN; fds++) {
+		if (pollfds_[fds].fd != -1)
+			close(pollfds_[fds].fd);
+	}
+}
+
+struct pollfd *Nginxs::findEmptyPollfd()
+{
+	for (int i = 0; i < POLLFDSLEN; i++) {
+		if (pollfds_[i].fd == -1) {
+			std::cout << "pollfd index: " << i << std::endl;
+			return &pollfds_[i];
+		}
+	}
+	return nullptr;
+}