Cppcheck report - GATE C/C++ Framework: apps/contools/gatesvc/gatesvc.cpp

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at>                 |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/

#include "gate/applications.h"

#include "gate/gatemain.h"

#include "gate/applications.hpp"
#include "gate/results.hpp"
#include "gate/exceptions.hpp"
#include "gate/files.hpp"
#include "gate/streams.hpp"
#include "gate/console.hpp"
#include "gate/utilities.hpp"
#include "gate/environments.hpp"
#include "gate/runnables.hpp"
#include "gate/synchronization.hpp"
#include "gate/wrappers.hpp"

#include "gate/system/services.hpp"
#include "gate/system/configurations.hpp"
#include "gate/encode/yaml.hpp"
#include "gate/encode/json.hpp"
#include "gate/encode/texts.hpp"
#include "gate/io/logging.hpp"
#include "gate/threading.hpp"

#include "gate/tech/gateservices.hpp"


#if defined(GATE_COMPILER_MSVC) && defined(GATE_LEAK_DETECTION) && defined(GATE_SYS_WIN) && !defined(GATE_SYS_WINCE) && (GATE_ARCH != GATE_ARCH_ARM32) && (GATE_ARCH != GATE_ARCH_ARM64)
#	include <vld.h>
#endif

namespace gate
{
    namespace apps
    {
        typedef gate::sys::AppConfig AppConfig;
        typedef gate::sys::ServiceMgr ServiceMgr;
        typedef gate::sys::ServiceInfo ServiceInfo;
        typedef gate::tech::ServiceHost ServiceHost;
        typedef gate::tech::MicroFactory MicroFactory;
        typedef gate::io::Logger Logger;
        typedef gate::io::LoggerStream LoggerStream;
        typedef gate::io::LogProvider LogProvider;
        typedef gate::io::GlobalLogProvider GlobalLogProvider;
        typedef gate::enc::Json Json;
        typedef gate::enc::Yaml Yaml;

        static StaticString const GateSvcName = "gatesvc";
        static StaticString const GateSvcConfig = "config";
        static StaticString const GateSvcDescription = "GATE Service Host";

        class GATE_API_LOCAL GateSvc : public AppService
        {
        private:
            Optional<ServiceHost>	host;
            SyncEvent				shutdownEvent;

        private:
            String getServiceConfigFile()
            {
                AppConfig appcfg(this->getServiceName(), GateSvcConfig, AppConfig::Scope_Global);

                static StaticString const keyServiceConfigFile = "ServiceConfigYamlFile";

                String defaultFileName = this->getServiceName() + ".config.yml";

                String cfgFilePath;
                try
                {
                    cfgFilePath = appcfg.read(keyServiceConfigFile);
                }
                catch (...) {}

                if (!cfgFilePath.empty() && File::exists(cfgFilePath))
                {
                    return cfgFilePath;
                }

                try
                {
                    cfgFilePath = File::buildPath(Environment::getAppConfigPath(this->getServiceName(), true), defaultFileName);
                }
                catch (...) {}

                if (!cfgFilePath.empty() && File::exists(cfgFilePath))
                {
                    return cfgFilePath;
                }

                try
                {
                    cfgFilePath = File::buildPath(Environment::getAppExecutableDirPath(), defaultFileName);
                }
                catch (...) {}

                if (!cfgFilePath.empty() && File::exists(cfgFilePath))
                {
                    return cfgFilePath;
                }

                GATEXX_RAISE_EXCEPTION(results::NotAvailable, "Missing service configuration file", 0);
                return String();
            }

            void initMicroservices()
            {
                Logger logger(GlobalLogProvider::get(), "GateSvc::initMicroservices");

                String serviceConfigYamlFile;
                try
                {
                    serviceConfigYamlFile = this->getServiceConfigFile();
                }
                catch (Throwable const& throwable)
                {
                    logger.warn(throwable.getResult(), throwable.getErrorCode())
                        << "Failed to find service configuration file: " << throwable.getMessage();
                    throw;
                }

                logger.info() << "Loading service configuration: " << serviceConfigYamlFile;

                String yamlData = File::getContent(serviceConfigYamlFile);

                ServiceHost::Config config;
                try
                {
                    Property configTree;
                    Yaml::ResultInfo info = Yaml::parse(yamlData, configTree);

                    String tmp = Json::build(configTree);
                    configTree.exportToStruct(config);
                }
                catch (Throwable const& thr)
                {
                    logger.warn(thr.getResult(), thr.getErrorCode()) << "Failed to load service configuration";
                    throw;
                }

                this->host.create(ServiceHost::create());
                MicroFactory internalServices = ServiceHost::getEssentialsFactory();
                MicroFactory extensionServices = ServiceHost::getEssentialsExtensionsFactory();

                try
                {
                    this->host->addFactory(internalServices, this->getServiceName());
                    StringBuilder exname;
                    exname << this->getServiceName() << "Ex";
                    this->host->addFactory(extensionServices, exname);
                    host->importConfig(config);
                }
                catch (Throwable const& thr)
                {
                    logger.warn(thr.getResult(), thr.getErrorCode()) << "Failed to import service configuration";
                    throw;
                }
            }

            void uninitMicroservices()
            {
                if (this->host)
                {
                    this->host->releaseServices();
                    this->host.reset();
                }
            }

            void startMicroservices()
            {
                this->host->startup();
            }
            void stopMicroservices()
            {
                try
                {
                    this->host->shutdown(true);
                }
                catch (...) {}
            }

            void printMessage(String const& text)
            {
                Console.println(text);
            }

            void registerService()
            {
                try
                {
                    String serviceName = this->getServiceName();
                    String appPath = Environment::getAppExecutablePath();
                    String descr = GateSvcDescription;
                    uint32_t flags = ServiceInfo::Flag_Autostart;<--- Variable 'flags' is assigned a value that is never used.
                    Array<String> deps;
                    ServiceMgr::registerHost(serviceName, appPath, descr, 0, deps,
                        ServiceMgr::MessageCallback(this, &GateSvc::printMessage));
                    Console << "Service registration succeeded" << strings::NewLine;
                }
                catch (...)
                {
                    Console.writeErr("Failed to register service" GATE_STR_NEWLINE);
                    throw;
                }
            }

            void unregisterService()
            {
                try
                {
                    String serviceName = this->getServiceName();
                    ServiceMgr::unregisterHost(serviceName,
                        ServiceMgr::MessageCallback(this, &GateSvc::printMessage));
                    Console << "Service registration removed" << strings::NewLine;
                }
                catch (...)
                {
                    Console.writeErr("Failed to unregister service" GATE_STR_NEWLINE);
                    throw;
                }
            }

            void startService()
            {
                try
                {
                    String serviceName = this->getServiceName();
                    ServiceMgr::start(serviceName,
                        ServiceMgr::MessageCallback(this, &GateSvc::printMessage));
                    Console << "Service startup initiated" << strings::NewLine;
                }
                catch (...)
                {
                    Console.writeErr("Service startup failed" GATE_STR_NEWLINE);
                    throw;
                }
            }

            void stopService()
            {
                try
                {
                    String serviceName = this->getServiceName();
                    ServiceMgr::stop(serviceName, 8000, true,
                        ServiceMgr::MessageCallback(this, &GateSvc::printMessage));
                    Console << "Service shutdown initiated" << strings::NewLine;
                }
                catch (...)
                {
                    Console.writeErr("Service shutdown failed" GATE_STR_NEWLINE);
                    throw;
                }
            }

        public:
            GateSvc()
                : AppService(GateSvcName),
                shutdownEvent(true)
            {
            }

            virtual ~GateSvc() noexcept
            {
            }

            virtual void run()
            {
                Logger logger(GlobalLogProvider::get(), "GateSvc::run");

                logger.info() << "Starting microservices";
                try
                {
                    this->startMicroservices();
                    logger.status() << "Microservices started";
                }
                catch (...)
                {
                    logger.error() << "Failed to start microservices: " << util::printCurrentException();
                }

                this->shutdownEvent.wait();

                logger.info() << "Stopping microservices";
                try
                {
                    this->stopMicroservices();
                    logger.status() << "Microservices stopped";
                }
                catch (...)
                {
                    logger.error() << "Failed to stop microservices: " << util::printCurrentException();
                }

                logger.info() << "Releasing microservice instances";
                try
                {
                    this->uninitMicroservices();
                    logger.status() << "Microservices released";
                }
                catch (...)
                {
                    logger.error() << "Failed to release microservices: " << util::printCurrentException();
                }
            }

        protected:
            virtual void onSignal(int appsignal)
            {
            }

            virtual void onStart()
            {
#if defined(GATE_DEBUG_MODE)
                uint32_t logType = LogProvider::Type_Debug;
#else
                uint32_t logType = LogProvider::Type_Info;
#endif
                GlobalLogProvider::start(String(), logType);
                Logger logger(GlobalLogProvider::get(), "GateSvc::onStart");

                try
                {
                    logger.info() << "Service start initiated";
                    this->initMicroservices();
                    logger.status() << "Microservice initialization completed";
                }
                catch (...)
                {
                    logger.warn() << "Failed to initialize microservice host: " << util::printCurrentException();
                    throw;
                }

                this->shutdownEvent.reset();
            }

            virtual void onStop()
            {
                Logger logger(GlobalLogProvider::get(), "GateSvc::onStop");
                logger.status() << "Service stop initiated";
                this->shutdownEvent.set();
            }

            virtual void onPause()
            {
                Logger logger(GlobalLogProvider::get(), "GateSvc::onPause");
                logger.status() << "Service pause initiated";
            }

            virtual void onContinue()
            {
                Logger logger(GlobalLogProvider::get(), "GateSvc::onContinue");
                logger.status() << "Service continuation initiated";
            }

            void runConsoleMode()
            {
                static StaticString const startErrorMsg = "[GateSvc::runConsoleMode::onStart] ";
                static StaticString const runErrorMsg = "[GateSvc::runConsoleMode::run] ";
                static StaticString const unknownErrorMsg = "Unknown internal error";

                try
                {
                    this->initMicroservices();
                }
                catch (Throwable const& xcpt)
                {
                    Console.writeErr(startErrorMsg + util::printException(xcpt, true, true));
                    return;
                }
                catch (...)
                {
                    Console.writeErr(startErrorMsg + unknownErrorMsg);
                    return;
                }

                try
                {
                    this->startMicroservices();
                }
                catch (Throwable const& xcpt)
                {
                    Console.writeErr(runErrorMsg + util::printException(xcpt, true, true));
                }
                catch (...)
                {
                    Console.writeErr(runErrorMsg + unknownErrorMsg);
                }

                Console << "Press [ENTER] to exit console mode";
                String line = Console.readLine();

                try
                {
                    this->stopMicroservices();
                }
                catch (...)
                {
                }

                this->uninitMicroservices();
            }

            virtual void onInit()
            {
                static bool const debug_mode_enabled =
#ifdef GATE_DEBUG_MODE
                    true
#else
                    false
#endif
                    ;

                if (this->appArgs.empty() && !debug_mode_enabled)
                {
                    // service mode
                }
                else
                {
                    static AppOptionDef optRegister = AppOptionDef::createSwitch("register", "I", "register_service", "Registers the service");
                    static AppOptionDef optUnregister = AppOptionDef::createSwitch("unregister", "U", "unregister_service", "Unregisters the service");
                    static AppOptionDef optStart = AppOptionDef::createSwitch("start", "S", "start_service", "Starts the service process");
                    static AppOptionDef optStop = AppOptionDef::createSwitch("stop", "T", "terminate_service", "Stops and terminates the service process");
                    static AppOptionDef optRun = AppOptionDef::createSwitch("run", "R", "run_service", "Runs service in interative mode instead of service mode");

                    static AppOptionDef* options[] = {
                        &optRegister,
                        &optUnregister,
                        &optStart,
                        &optStop,
                        &optRun
                    };

                    App::parseAppOptions(this->appArgs, options, sizeof(options) / sizeof(options[0]));

                    do
                    {
                        if (optRun.getBool() || debug_mode_enabled)
                        {
                            GlobalLogProvider::start(String(), LogProvider::Type_Debug);
                            this->runConsoleMode();
                            GlobalLogProvider::stop();
                            break;
                        }

                        if (optRegister.getBool())
                        {
                            this->registerService();
                        }

                        if (optStart.getBool())
                        {
                            this->startService();
                        }

                        if (optStop.getBool())
                        {
                            this->stopService();
                        }

                        if (optUnregister.getBool())
                        {
                            this->unregisterService();
                        }

                    } while (0);

                    // cancel further service initialization
                    GATEXX_RAISE_EXCEPTION(results::Canceled, NULL, 0);
                }
            }

            virtual void onError(result_t resultCode, int32_t nativeCode, String const& message)
            {
                Logger logger(GlobalLogProvider::get(), "GateSvc::onError");
                LoggerStream stream = logger.warn();
                stream << "Service error [" << util::printResult(resultCode) << "]";
                if (nativeCode != 0)
                {
                    stream << " #" << static_cast<gate_uint32_t>(nativeCode);
                }
                if (!message.empty())
                {
                    stream << ": " << message;
                }
            }

        };

    }	//	end of namespace apps
}	//	end of namespace gate



static gate::apps::GateSvc gatesvc;

int gate_main(char const* program, char const* const* arguments, gate_size_t argcount, gate_uintptr_t apphandle)
{
    return gate::AppService::runService(gatesvc, program, arguments, argcount, apphandle);
}