ApplicationInstance.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    ArmarXCore::core
 * @author     Dennis Weigelt
 * @date       2016
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
 
#include "ApplicationInstance.h"
 
#include <filesystem>
 
#include <ArmarXCore/core/application/properties/PropertyDefinitionConfigFormatter.h>
#include <ArmarXCore/core/application/properties/PropertyDefinitionContainerFormatter.h>
#include <ArmarXCore/core/application/properties/PropertyDefinitionFormatter.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include "../parser/iceparser.h"
 
 
using namespace ScenarioManager;
using namespace armarx;
 
const std::string Data_Structure::ApplicationStatus::Stopped = "Stopped";
const std::string Data_Structure::ApplicationStatus::Running = "Running";
const std::string Data_Structure::ApplicationStatus::Waiting = "Waiting";
const std::string Data_Structure::ApplicationStatus::Mixed = "Mixed";
const std::string Data_Structure::ApplicationStatus::Unknown = "Unknown";
const std::string Data_Structure::ApplicationStatus::Inactive = "Inactive";
const std::string Data_Structure::ApplicationStatus::Missing = "Missing";
 
const char*
Data_Structure::ToString(Intent intent)
{
    switch (intent)
    {
        case Intent::Start:
            return "Start";
        case Intent::Stop:
            return "Stop";
        case Intent::Restart:
            return "Restart";
        case Intent::None:
            break;
    }
    return "None";
}
 
std::string
Data_Structure::ApplicationStatus::Aggregate(const std::vector<std::string>& stati)
{
    bool sawMissing = false;
    bool sawUnknown = false;
    // The single definite status seen so far (Running, Stopped or Inactive), if any.
    const std::string* definite = nullptr;
 
    for (const std::string& status : stati)
    {
        if (status == Waiting)
        {
            return Waiting;
        }
        if (status == Missing)
        {
            sawMissing = true;
            continue;
        }
        if (status == Unknown || status == Mixed)
        {
            sawUnknown = true;
            continue;
        }
 
        if (definite == nullptr)
        {
            definite = &status;
        }
        else if (*definite != status)
        {
            return Mixed;
        }
    }
 
    if (definite != nullptr)
    {
        return *definite;
    }
    if (sawUnknown)
    {
        return Unknown;
    }
    if (sawMissing)
    {
        return Missing;
    }
    return Unknown;
}
 
std::string
Data_Structure::ApplicationInstance::getConfigDomain() const
{
    return configDomain;
}
 
void
Data_Structure::ApplicationInstance::setConfigDomain(const std::string& value)
{
    ARMARX_CHECK_EXPRESSION(!value.empty());
    configDomain = value;
}
 
bool
Data_Structure::ApplicationInstance::isReadOnly() const
{
    return this->readOnly;
}
 
Data_Structure::ApplicationInstance::ApplicationInstance(std::string executableName,
                                                         std::string executablePath,
                                                         std::string instanceName,
                                                         std::string configPath,
                                                         std::string packageName,
                                                         ScenarioPtr scenario,
                                                         std::string node,
                                                         bool enabled) :
    Application(executableName, executablePath, packageName),
    instanceName(instanceName),
    configPath(configPath),
    status(ApplicationStatus::Unknown),
    nodeName(node),
    scenario(scenario),
    pid(-1),
    pendingIntent(Intent::None),
    enabled(enabled)
{
}
 
Data_Structure::ApplicationInstance::ApplicationInstance(Application application,
                                                         std::string instanceName,
                                                         std::string configPath,
                                                         ScenarioPtr scenario,
                                                         std::string node,
                                                         bool enabled) :
    Application(application),
    instanceName(instanceName),
    configPath(configPath),
    status(ApplicationStatus::Unknown),
    nodeName(node),
    scenario(scenario),
    pid(-1),
    pendingIntent(Intent::None),
    enabled(enabled)
{
}
 
Data_Structure::ScenarioPtr
Data_Structure::ApplicationInstance::getScenario()
{
    return scenario;
}
 
std::string
Data_Structure::ApplicationInstance::getInstanceName()
{
    return this->instanceName;
}
 
void
Data_Structure::ApplicationInstance::setInstanceName(std::string newName)
{
    this->instanceName = newName;
}
 
std::string
Data_Structure::ApplicationInstance::getConfigPath()
{
    return this->configPath;
}
 
void
Data_Structure::ApplicationInstance::setConfigPath(std::string configPath)
{
    this->configPath = configPath;
}
 
void
Data_Structure::ApplicationInstance::resetConfigPath()
{
    std::filesystem::path scenariosFolder(scenario->getPackage()->getScenarioPath());
    std::filesystem::path scenarioFolder = scenariosFolder / scenario->getName();
    std::filesystem::path scenarioCfgFolder = scenarioFolder / "config";
 
    std::filesystem::path configPath = scenarioCfgFolder;
 
    if (!this->instanceName.empty() && this->instanceName != R"("")" &&
        this->instanceName != R"(" ")")
    {
        configPath = configPath / (this->getName() + "." + this->getInstanceName() + ".cfg");
    }
    else
    {
        configPath = configPath / (this->getName() + ".cfg");
        ;
    }
 
    if (configPath != this->configPath)
    {
        std::filesystem::remove(std::filesystem::path(this->configPath));
    }
    this->configPath = configPath.string();
}
 
std::string
Data_Structure::ApplicationInstance::getStatus()
{
    return this->status;
}
 
bool
Data_Structure::ApplicationInstance::setStatus(const std::string& status)
{
    bool result = status != this->status;
    if (result)
    {
        this->status = status;
    }
    return result;
}
 
int
Data_Structure::ApplicationInstance::getPid()
{
    return this->pid;
}
 
void
Data_Structure::ApplicationInstance::setPid(int pid) // if PID < -1 Error?
{
    this->pid = pid;
}
 
bool
Data_Structure::ApplicationInstance::compareAndResetPid(int expectedPid)
{
    int expected = expectedPid;
    return pid.compare_exchange_strong(expected, -1);
}
 
bool
Data_Structure::ApplicationInstance::adoptPidIfUnset(int newPid)
{
    int expected = -1;
    return pid.compare_exchange_strong(expected, newPid);
}
 
void
Data_Structure::ApplicationInstance::modifyProperty(std::string name, std::string value)
{
    // Take a snapshot of the container instead of using the member directly: a lifecycle worker
    // may swap in a freshly loaded one at any moment.
    const armarx::PropertyDefinitionsPtr props = getProperties();
    if (!props->isPropertySet(name))
    {
        props->defineOptionalProperty(name, std::string("::NOT_DEFINED::"), "Custom Property");
    }
    props->getProperties()->setProperty(name, value);
}
 
void
Data_Structure::ApplicationInstance::addProperty(std::string name, std::string value)
{
    const armarx::PropertyDefinitionsPtr props = getProperties();
    if (!props->isPropertySet(name))
    {
        props->defineOptionalProperty(name, std::string("::NOT_DEFINED::"), "Custom Property");
    }
    props->getProperties()->setProperty(name, value);
}
 
void
Data_Structure::ApplicationInstance::save()
{
    Parser::IceParser parser;
    parser.saveCfg(shared_from_this());
}
 
void
Data_Structure::ApplicationInstance::makeLocal()
{
    if (!isReadOnly())
    {
        return;
    }
 
    if (!std::filesystem::is_symlink(configPath))
    {
        ARMARX_WARNING << "Make local called on non-linked application";
        return;
    }
 
    std::filesystem::remove(configPath);
    this->save();
    // Reload to register status changes
    this->load();
}
 
void
Data_Structure::ApplicationInstance::linkFrom(ApplicationInstance& other)
{
    deleteConfig();
    load(true);
    auto target_path = other.configPath.lexically_relative(configPath.parent_path());
    std::filesystem::create_symlink(target_path, configPath);
    load();
}
 
void
Data_Structure::ApplicationInstance::copyFrom(ApplicationInstance& other)
{
    deleteConfig();
    load(true);
    std::filesystem::copy_file(
        other.configPath, configPath, std::filesystem::copy_options::overwrite_existing);
    load();
}
 
void
Data_Structure::ApplicationInstance::deleteConfig()
{
    if (std::filesystem::exists(this->configPath))
    {
        std::filesystem::remove(this->configPath);
    }
}
 
void
Data_Structure::ApplicationInstance::load(bool firstLoad)
{
    if (!std::filesystem::exists(configPath))
    {
        ARMARX_WARNING_S << "Cannot find ApplicationInstance Config at:" << configPath;
    }
    else
    {
        Parser::IceParser parser;
        setProperties(parser.mergeXmlAndCfg(shared_from_this(), firstLoad));
    }
 
    // If the config file is a symlink, put app into read-only mode
    this->readOnly = std::filesystem::is_symlink(configPath);
}
 
bool
Data_Structure::ApplicationInstance::isConfigWritable()
{
    std::ofstream ofs;
 
    ofs.open(configPath.c_str(), std::ofstream::out | std::ofstream::app);
    ARMARX_DEBUG << configPath << " is writeable: " << ofs.is_open();
 
    return ofs.is_open();
}
 
Data_Structure::Intent
Data_Structure::ApplicationInstance::getPendingIntent() const
{
    return pendingIntent;
}
 
void
Data_Structure::ApplicationInstance::setPendingIntent(Intent intent)
{
    pendingIntent = intent;
}
 
std::string
Data_Structure::ApplicationInstance::getNodeName() const
{
    return nodeName;
}
 
std::string
Data_Structure::ApplicationInstance::getEffectiveNodeName() const
{
    return nodeName.empty() && scenario ? scenario->getNodeName() : nodeName;
}
 
void
Data_Structure::ApplicationInstance::setNodeName(std::string nodeName)
{
    this->nodeName = nodeName;
}
 
bool
Data_Structure::ApplicationInstance::getEnabled()
{
    return enabled;
}
 
void
Data_Structure::ApplicationInstance::setEnabled(bool enabled)
{
    this->enabled = enabled;
}