Added process manager

Added a process manager to more gracefully handle launching and stopping each
individual process. It's still a little rough around the edges, but it works
well enough for now... I hope :S More testing is needed, and will be done.

Author: TheTechmage

.gitignore

@@ -18,6 +18,7 @@ install-sh
 minimalraw.log
 missing
 src/librenzoku.a
+*/tags
 test-driver
 tests/test-suite.log
 tests/test_runner*

src/Makefile.am

@@ -1,6 +1,6 @@
 #CFLAGS = --pedantic -Wall -std=c99 -O2
 #CXXFLAGS = -Wall -g -Isrc/ -static -lyaml-cpp -std=c++11
-AM_CXXFLAGS = --pedantic -Wall -O2 -std=c++11
+AM_CXXFLAGS = --pedantic -Wall -O2 -g -std=c++11
 AM_LDFLAGS = -Bstatic -lyaml-cpp -Bdynamic
 
 # this lists the binaries to produce, the (non-PHONY, binary) targets in
@@ -25,6 +25,8 @@ librenzoku_a_SOURCES = \
 											 log.hpp \
 											 process.cpp \
 											 process.hpp \
+											 procman.cpp \
+											 procman.hpp \
 											 signals.cpp \
 											 signals.hpp \
 											 util.cpp \

src/config.cpp

@@ -43,23 +43,25 @@
 #include "util.hpp"
 #include "log.hpp"
 
-Config::Config(iLogger *logger) :
+Config::Config(iLogger *logger, ProcessManager* pm) :
 	mWatch(),
 	mCompile(),
 	mTest(),
 	mProgram(),
+	procman(pm),
 	logger(logger)
 {
 	std::ifstream file;
 	this->findConfig(file);
 	this->parseConfig(file);
 }
 
-Config::Config(iLogger *logger, std::istream& file) :
+Config::Config(iLogger *logger, ProcessManager* pm, std::istream& file) :
 	mWatch(),
 	mCompile(),
 	mTest(),
 	mProgram(),
+	procman(pm),
 	logger(logger)
 {
 	this->parseConfig(file);
@@ -83,11 +85,6 @@ Config::~Config()
 			delete [] mProgram.command[i];
 		delete [] mProgram.command;
 	}
-	for(Process* proc : processes)
-	{
-		if(proc)
-			delete proc;
-	}
 }
 
 void Config::findConfig(std::ifstream& is)
@@ -120,20 +117,26 @@ void Config::parseConfig(std::istream& file)
 		else if(key == "program")
 		{
 			this->parseCommand(it->second, mProgram);
+			if(procman->getProgram()) {
+				throw std::runtime_error("Program already set!");
+			}
 			if(mProgram.command && mProgram.enabled)
-				processes.push_back(new Process(logger, mProgram.command, true));
+				procman->setProgram(new Process(logger, mProgram.command, true));
 		}
 		else if(key == "test")
 		{
 			this->parseCommand(it->second, mTest);
 			if(mTest.command && mTest.enabled)
-				processes.push_back(new Process(logger, mTest.command, true));
+				procman->addProcess(new Process(logger, mTest.command, true));
 		}
 		else if(key == "compile")
 		{
 			this->parseCommand(it->second, mCompile);
+			if(procman->getBuildStep()) {
+				throw std::runtime_error("BuildStage already set!");
+			}
 			if(mCompile.command && mCompile.enabled)
-				processes.push_back(new Process(logger, mCompile.command, true));
+				procman->setBuilder(new Process(logger, mCompile.command, true));
 		}
 		else
 		{
@@ -200,27 +203,7 @@ void Config::parseCommand(const YAML::Node& node, iCommandConfig& config)
 
 void Config::restartProcesses()
 {
-	for(Process* proc : processes)
-	{
-		if(proc->kill())
-		{
-			if(proc != processes.back())
-			{
-				if(proc->runAndWait())
-				{
-					LOG(logger, SUCCESS, "Successfully ran command");
-				}
-				else
-				{
-					LOG(logger, ERROR, "A command failed to run :(");
-				}
-			}
-			else
-			{
-				proc->run();
-			}
-		}
-	}
+	procman->restartAll();
 }
 
 void Config::parseWatcher(const YAML::Node& node)

src/config.hpp

@@ -40,6 +40,7 @@
 #include <yaml-cpp/yaml.h>
 #include "process.hpp"
 #include "log.hpp"
+#include "procman.hpp"
 
 #define CONFIG_NAME "renzoku.conf"
 
@@ -77,7 +78,7 @@ class Config {
 #define CONFIG_SECTION(X) X##Config m##X;
 #include "config_sections.hpp"
 #undef CONFIG_SECTION
-		std::vector<Process*> processes;
+		ProcessManager* procman;
 		iLogger* logger;
 		void parseWatcher(const YAML::Node&);
 		void parseCommand(const YAML::Node&, iCommandConfig&);
@@ -89,13 +90,12 @@ class Config {
 #include "config_sections.hpp"
 #undef CONFIG_SECTION
 		};
-		Config(iLogger*);
-		Config(iLogger*, std::istream&);
+		Config(iLogger*, ProcessManager*);
+		Config(iLogger*, ProcessManager*, std::istream&);
 		~Config();
 		inline WatchConfig getWatchConfig() { return mWatch; };
 		inline CompileConfig getCompileConfig() { return mCompile; };
 		inline TestConfig getTestConfig() { return mTest; };
 		inline ProgramConfig getProgramConfig() { return mProgram; };
-		inline std::vector<Process*> getProcesses() const { return processes; };
 		void restartProcesses();
 };

src/log.cpp

@@ -134,9 +134,9 @@ std::string iLogger::createMessage(LogLevel level, const char* format, va_list
 			var_copy) + 1;
 	char* buffer = new char[ string_size + 10 ];
 	buffer[0] = 0;
-	char* f = new char[final_format.str().length()+1];
-	strcpy(f, final_format.str().c_str());
-	vsprintf( buffer, f, arguments );
+	//char* f = new char[final_format.str().length()+1];
+	//strcpy(f, final_format.str().c_str());
+	vsprintf( buffer, final_format.str().c_str(), arguments );
 //#pragma GCC diagnostic pop
 	std::string ret = std::string( buffer, string_size - 1 );
 	delete [] buffer;

src/main.cpp

@@ -40,6 +40,7 @@
 #include "config.hpp"
 #include "log.hpp"
 #include "watcher.hpp"
+#include "procman.hpp"
 
 volatile sig_atomic_t gRunning = 1;
 
@@ -50,8 +51,9 @@ int main(int argc, char** argv) {
 	sigaction(SIGINT,&int_catcher,0);
 	//watcher();
 	StdoutLogger logger;
-	Config config(&logger);
-	Watcher w(&logger, "./", config, true);
+	ProcessManager procman(&logger);
+	Config config(&logger, &procman);
+	Watcher w(&logger, "./", config, &procman, true);
 
 	while(gRunning)
 		w.listen();

src/process.cpp

@@ -93,7 +93,7 @@ bool Process::run()
 			size += strlen(mCommand[i]) + 1;
 			i++;
 		}
-		char* args_string = new char[size];
+		char* args_string = new char[size + 1];
 		//strcpy(args_string, mCommand[0]);
 		args_string[0] = '\0';
 		for(size_t i2 = 1; mCommand[i2] != NULL; i2++) {

src/procman.cpp

@@ -0,0 +1,119 @@
+/*
+ * Renzoku - Re-build, re-test, and re-run a program whenever the code changes
+ * Copyright (C) 2015  Colton Wolkins
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#include <stdexcept>
+#include "procman.hpp"
+
+ProcessManager::ProcessManager(iLogger *logger) :
+	mBuildStep(NULL),
+	mProgram(NULL),
+	logger(logger)
+{
+}
+
+ProcessManager::~ProcessManager() {
+	for(Process* proc : mProcesses)
+		delete proc;
+	delete mBuildStep;
+	delete mProgram;
+}
+
+Process* ProcessManager::getBuildStep() {
+	return mBuildStep;
+}
+
+Process* ProcessManager::getProgram() {
+	return mProgram;
+}
+
+bool ProcessManager::runBuild() {
+	if(mBuildStep->runAndWait())
+	{
+		LOG(logger, SUCCESS, "Successfully ran command");
+		return true;
+	}
+	else
+	{
+		LOG(logger, ERROR, "A command failed to run :(");
+		return false;
+	}
+}
+
+bool ProcessManager::runProcesses() {
+	for(Process* proc : mProcesses)
+	{
+		if(proc->runAndWait())
+		{
+			LOG(logger, SUCCESS, "Successfully ran command");
+		}
+		else
+		{
+			LOG(logger, ERROR, "A command failed to run :(");
+		}
+	}
+	return true;
+}
+
+void ProcessManager::haltConstructionProcs() {
+	for(Process* proc : mProcesses)
+	{
+		proc->kill();
+	}
+}
+
+void ProcessManager::killAll() {
+	mBuildStep->kill();
+	haltConstructionProcs();
+	mProgram->kill();
+}
+
+void ProcessManager::startProgram() {
+	mProgram->run();
+}
+
+void ProcessManager::haltProgram() {
+	mProgram->kill();
+}
+
+void ProcessManager::restartAll()
+{
+	haltConstructionProcs();
+	if(runBuild()) {
+		runProcesses();
+		haltProgram();
+		startProgram();
+	}
+}
+
+void ProcessManager::setBuilder(Process* proc) {
+	if(mBuildStep)
+		throw std::runtime_error("Build Step already set");
+	mBuildStep = proc;
+}
+
+void ProcessManager::addProcess(Process* proc) {
+	mProcesses.push_back(proc);
+}
+
+void ProcessManager::setProgram(Process* proc) {
+	if(mProgram)
+		throw std::runtime_error("Pogram already set");
+	mProgram = proc;
+}
+

src/procman.hpp

@@ -0,0 +1,47 @@
+/*
+ * Renzoku - Re-build, re-test, and re-run a program whenever the code changes
+ * Copyright (C) 2015  Colton Wolkins
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#pragma once
+#include "process.hpp"
+#include "log.hpp"
+#include <vector>
+
+class ProcessManager
+{
+	private:
+		Process* mBuildStep; // The actual build step
+		std::vector<Process*> mProcesses; // Procs that run between build and launch
+		Process* mProgram; // The actual program
+		iLogger* logger;
+	public:
+		ProcessManager(iLogger*);
+		~ProcessManager();
+		Process* getBuildStep();
+		Process* getProgram();
+		bool runBuild();
+		bool runProcesses();
+		void haltConstructionProcs();
+		void startProgram();
+		void haltProgram();
+		void restartAll();
+		void killAll();
+		void setBuilder(Process*);
+		void addProcess(Process*);
+		void setProgram(Process*);
+};