salmanoff/smocore/marionette/marionette.cpp

#include <config.h>
#include <cstdlib>
#include <iostream>
#include <exception>
#include <opts.h>
#include <typeinfo>
#include <boost/asio/signal_set.hpp>
#include <asynchronousBridge.h>
#include <mind.h>
#include <componentThread.h>
#include <marionette/marionette.h>
#include <salmanoff.h>

namespace smo {

// Global Mind instance
std::shared_ptr<Mind> globalMind = std::make_shared<Mind>();

// Global marionette thread instance
std::shared_ptr<ComponentThread> mrntt::mrntt =
	std::make_shared<ComponentThread>(ComponentThread::MRNTT, *globalMind);

CrtCommandLineArgs crtCommandLineArgs(0, nullptr, nullptr);

void CrtCommandLineArgs::set(int argc, char *argv[], char *envp[])
{
    crtCommandLineArgs = CrtCommandLineArgs(argc, argv, envp);
}

namespace mrntt {
std::atomic<int> exitCode;

void exitMarionetteLoop()
{
	mrntt::mrntt->keepLooping = false;
	mrntt::mrntt->getIoService().stop();
	std::cout << "Mrntt: Signaled main loop to exit." << "\n";
}

} // namespace mrntt

void ComponentThread::marionetteMain(ComponentThread& self)
{
    // Wait for CRT's main() to post us the command line args.
    std::cout << __func__ << ": Waiting for command line JOLT" << std::endl;
    self.getIoService().run();
    self.initializeTls();
    mrntt::exitCode = EXIT_SUCCESS;
	static boost::asio::signal_set signals(self.getIoService(), SIGINT);
	bool callFinalizeReq = false, callShutdownSalmanoffReq = false;

	try {
		// Register SIGINT (Ctrl+C) and SIGSEGV handlers
		signals.async_wait(
			[&self](const boost::system::error_code& ec, int signal)
			{
				if (ec) { return; }

				switch (signal) {
					case SIGINT:
						std::cerr << "SIGINT (Ctrl+C) received. Initiating "
							"shutdown..." << '\n';
						break;
					case SIGSEGV:
						std::cerr << "FATAL: Segmentation fault detected. "
							"Initiating shutdown..." << '\n';
						break;
					default:
						break;
				}
				self.userShutdownInd();
			}
		);

		OptionParser &options = OptionParser::getOptions();

		std::cout << __func__ << ": " << PACKAGE_NAME << " " << PACKAGE_VERSION
			<< std::endl;

		options.parseArguments(
			crtCommandLineArgs.argc, crtCommandLineArgs.argv,
			crtCommandLineArgs.envp);

		std::cout << __func__ << ": " << options.stringifyOptions()
			<< std::endl;

		if (options.printUsage) {
			throw JustPrintUsageNoError(options);
		}

		self.getIoService().post([]()
		{
			// Initialize Salmanoff first
			initializeSalmanoff([](bool success)
			{
				if (success) {
					// Then initialize the global Mind object
					globalMind->initialize();
				} else {
					std::cerr << "Failed to initialize Salmanoff" << std::endl;
				}
			});
		});

        std::cout << __func__ << ": Entering event loop" << "\n";

		/* We loop here because when an exception occurs in mrntt, we need to
		 * both direct the mind threads to exit gracefully, and then we also
		 * need to post messages to our own event loop to initiate our own
		 * orderly exit. So we loop here to re-enter the event loop, both
		 * to receive the ACK messages from the mind threads, and to post
		 * messages to our own event loop to initiate our own orderly exit.
		 */
        for (self.keepLooping = true; self.keepLooping;)
        {
			bool sendExceptionInd = false;
            try {
				/**		EXPLANATION:
				 * This reset() call is crucial for async bridging patterns
				 * to work.
				 * When the outermost thread's io_service is stop()ped (e.g.,
				 * from JOLT sequence), it won't process any new work until
				 * reset() is called, even if nested async operations try to
				 * post work to it. This means async bridges invoked from
				 * the outermost thread main sequence won't work until this
				 * reset() call.
				 */
				self.getIoService().reset();
				self.getIoService().run();
            }
            catch (const std::exception& e)
            {
				sendExceptionInd = true;
                std::cerr << self.name << ":" << __func__
                    << ": Exception occurred: " << e.what() << "\n";
            }
            catch (...)
            {
				sendExceptionInd = true;
                std::cerr << self.name << ":" << __func__
                    << ": Unknown exception occurred" << "\n";
            }

			if (sendExceptionInd)
			{
				mrntt::exitCode = EXIT_FAILURE;
				self.exceptionInd(self.shared_from_this());
			}
        }

        std::cout << __func__ << ": Exited event loop" << "\n";
	}
	catch (const OptionParser::Exception& e)
	{
		std::ostream *out = &std::cout;
		std::string outUsageMsg;

		if (typeid(e) == typeid(OptionsParserError))
		{
			mrntt::exitCode = EXIT_FAILURE;
			out = &std::cerr;
			outUsageMsg = std::string(__func__) + ": ";
		}

		*out << outUsageMsg << e.what() << std::endl;
		callShutdownSalmanoffReq = callFinalizeReq = true;
	}
	catch (const std::exception& e)
	{
		std::cerr << __func__ << ": Exception occurred: " << e.what()
			<< std::endl;
		mrntt::exitCode = EXIT_FAILURE;
		callShutdownSalmanoffReq = callFinalizeReq = true;
	}
	catch (...)
	{
		std::cerr << __func__ << ": Unknown exception occurred" << std::endl;
		mrntt::exitCode = EXIT_FAILURE;
		callShutdownSalmanoffReq = callFinalizeReq = true;
	}

	if (callShutdownSalmanoffReq)
	{
		shutdownSalmanoff(
			[](bool success)
			{
				if (success) {
					std::cout << "Salmanoff shutdown completed successfully"
						<< std::endl;
				} else {
					std::cerr << "Salmanoff shutdown failed" << std::endl;
				}
				mrntt::mrntt->getIoService().stop();
			}
		);
		self.getIoService().reset();
		self.getIoService().run();
	}

	if (callFinalizeReq)
	{
		globalMind->finalizeReq([]{
			mrntt::mrntt->getIoService().stop();
		});
		self.getIoService().reset();
		self.getIoService().run();
	}
}

} // namespace smo