Marionette: Introduce concept and add other 3 component threads

We introduce the 4 main component threads of execution for Harikoff:
* Marionette: This is the resident hijacking module that makes Harikoff
  instances non-persons, if configured to allow hijacking.
* Director: :)
* Canvas: :)
* Subconscious: DB, storage and recall.

main.cpp

@@ -1,16 +1,61 @@
 #include <iostream>
 #include <exception>
+#include <thread>
+#include <mutex>
+#include <unordered_map>
+#include <condition_variable>
+#include <boost/asio.hpp>
 #include <opts.h>
 #include <mind.h>
 #include <deviceManager/deviceManager.h>
 #include <senseApis/senseApiManager.h>
+#include "componentThread.h"
 
+namespace hk {
 
-int main(int argc, char **argv)
+static int initializeHarikoff(int argc, char **argv, char **envp);
+void startThreads();
+void signalThreads();
+
+} // namespace hk
+
+int main(int argc, char **argv, char **envp)
 {
-	using namespace hk;
+	try {
+		std::cout << __func__ << ": Entering main()" << std::endl;
 
-try {
+		// Print out the keys for each index in the map
+		for (const auto& [id, componentThread]
+			: hk::ComponentThread::componentThreads)
+		{
+			std::cout << __func__ << ": Thread ID: " << id << std::endl;
+		}
+
+		int ret = hk::initializeHarikoff(argc, argv, envp);
+		if (ret != 0) {
+			return ret;
+		}
+	}
+	catch (const std::exception& e) {
+		std::cerr << __func__ << ": Exception occurred: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
+	catch (...) {
+		std::cerr << __func__ << ": Unknown exception occurred" << std::endl;
+		return EXIT_FAILURE;
+	}
+
+	std::cout << __func__ << ": Exiting normally" << std::endl;
+	return 0;
+}
+
+namespace hk {
+
+static int initializeHarikoff(int argc, char **argv, char **envp)
+{
+	std::cout << __func__ << ": Entering" << std::endl;
+
+	using namespace hk;
 	OptionParser &options = OptionParser::getOptions();
 	hk::Mind mind;
 
@@ -20,7 +65,7 @@ try {
 		options.parseArguments(argc, argv);
 	}
 	catch (const std::invalid_argument& e) {
-		std::cerr << e.what() << '\n' << options.getUsage() << '\n';
+		std::cerr << __func__ << ": Exception occurred: " << e.what() << '\n' << options.getUsage() << '\n';
 		return EXIT_FAILURE;
 	}
 
@@ -34,16 +79,39 @@ try {
 	DeviceManager::getInstance().parseAllDeviceSpecs();
 	std::cout << DeviceManager::printDeviceSpecs() << std::endl;
 	sense_api::SenseApiManager::getInstance().loadAllSenseApiLibsFromOptions();
-}
-catch (const std::exception& e) {
-	std::cerr << "Exception occurred: " << e.what() << std::endl;
-	return EXIT_FAILURE;
-}
-catch (...) {
-	std::cerr << "Unknown exception occurred" << std::endl;
-	return EXIT_FAILURE;
+
+	std::cout << __func__ << ": Exiting" << std::endl;
+	return 0;
 }
 
-	std::cout << "Exiting normally" << std::endl;
-    return 0;
+void startThreads()
+{
+	for (auto& [id, componentThread] : ComponentThread::componentThreads) {
+		componentThread.thread = std::thread([&componentThread]() {
+			// We sleep on spawn until the marionette tells us to continue.
+			{
+				std::unique_lock<std::mutex> lock(
+					componentThread.startupSync.mutex);
+
+				componentThread.startupSync.cv.wait(lock, [&componentThread]() {
+					return componentThread.startupSync.ready;
+				});
+			}
+
+			componentThread.getIoService().run();
+		});
+	}
 }
+
+void signalThreads()
+{
+	for (auto& [id, componentThread] : ComponentThread::componentThreads) {
+		{
+			std::lock_guard<std::mutex> lock(componentThread.startupSync.mutex);
+			componentThread.startupSync.ready = true;
+		}
+		componentThread.startupSync.cv.notify_one();
+	}
+}
+
+} // namespace hk