147 lines
3.7 KiB
C++
147 lines
3.7 KiB
C++
#include <config.h>
|
|
#include <cstdlib>
|
|
#include <iostream>
|
|
#include <exception>
|
|
#include <opts.h>
|
|
#include <mind.h>
|
|
#include <componentThread.h>
|
|
#include <marionette/marionette.h>
|
|
#include <salmanoff.h>
|
|
|
|
namespace smo {
|
|
|
|
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 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;
|
|
|
|
try {
|
|
OptionParser &options = OptionParser::getOptions();
|
|
|
|
std::cout << __func__ << ": " << PACKAGE_NAME << " " << PACKAGE_VERSION
|
|
<< std::endl;
|
|
|
|
try {
|
|
options.parseArguments(
|
|
crtCommandLineArgs.argc, crtCommandLineArgs.argv,
|
|
crtCommandLineArgs.envp);
|
|
|
|
std::cout << __func__ << ": " << options.stringifyOptions()
|
|
<< std::endl;
|
|
}
|
|
catch (const std::invalid_argument& e)
|
|
{
|
|
std::cerr << __func__ << ": Exception occurred: " << e.what()
|
|
<< '\n';
|
|
|
|
options.printUsage = true;
|
|
mrntt::exitCode = EXIT_FAILURE;
|
|
}
|
|
|
|
if (options.printUsage)
|
|
{
|
|
/* We could make RAII guard classes to always shutdown the mind
|
|
* threads properly in these pre-event loop situations.
|
|
*/
|
|
self.getIoService().post([&options]()
|
|
{
|
|
ComponentThread::joltAllMindThreadsReq(
|
|
[&options]()
|
|
{
|
|
ComponentThread::exitAllMindThreadsReq(
|
|
[&options]()
|
|
{
|
|
std::cout << __func__ << ": " << options.getUsage()
|
|
<< '\n';
|
|
mrntt::mrntt->getIoService().stop();
|
|
}
|
|
);
|
|
});
|
|
});
|
|
self.getIoService().reset();
|
|
self.getIoService().run();
|
|
return;
|
|
}
|
|
|
|
smo::Mind mind;
|
|
|
|
self.getIoService().post([&mind]()
|
|
{
|
|
try {
|
|
initializeSalmanoff();
|
|
mind.initialize();
|
|
}
|
|
catch (const std::exception& e) {
|
|
mrntt::exitCode = EXIT_FAILURE;
|
|
throw;
|
|
}
|
|
|
|
body::body->getIoService().post([]{
|
|
throw std::runtime_error("test exception");
|
|
});
|
|
});
|
|
|
|
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;)
|
|
{
|
|
try {
|
|
self.getIoService().reset();
|
|
self.getIoService().run();
|
|
}
|
|
catch (const std::exception& e)
|
|
{
|
|
std::cerr << self.name << ":" << __func__
|
|
<< ": Exception occurred: " << e.what() << "\n";
|
|
}
|
|
catch (...)
|
|
{
|
|
std::cerr << self.name << ":" << __func__
|
|
<< ": Unknown exception occurred" << "\n";
|
|
}
|
|
}
|
|
|
|
std::cout << __func__ << ": Exited event loop" << "\n";
|
|
mind.finalize();
|
|
shutdownSalmanoff();
|
|
}
|
|
catch (const std::exception& e)
|
|
{
|
|
std::cerr << __func__ << ": Exception occurred: " << e.what()
|
|
<< std::endl;
|
|
mrntt::exitCode = EXIT_FAILURE;
|
|
return;
|
|
}
|
|
catch (...)
|
|
{
|
|
std::cerr << __func__ << ": Unknown exception occurred" << std::endl;
|
|
mrntt::exitCode = EXIT_FAILURE;
|
|
return;
|
|
}
|
|
|
|
std::cout << __func__ << ": Exiting normally" << std::endl;
|
|
}
|
|
|
|
} // namespace smo
|