Scenario.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 "Scenario.h"
 
#include <filesystem>
#include <fstream>
 
#include <Ice/Properties.h>
 
#include <ArmarXCore/core/application/properties/IceProperties.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include "../parser/XMLScenarioParser.h"
 
using namespace ScenarioManager;
 
Data_Structure::Scenario::Scenario(const std::string& name,
                                   const std::string& creationTime,
                                   const std::string& lastChangedTime,
                                   const PackagePtr& package,
                                   const std::string& globalConfigName,
                                   const std::string& subfolder) :
    name(name),
    creationTime(creationTime),
    lastChangedTime(lastChangedTime),
    globalConfigName(globalConfigName),
    subfolder(subfolder),
    nodeName("NodeMain"),
    package(package),
    applications(new std::vector<ApplicationInstancePtr>()),
    globalConfig(new armarx::PropertyDefinitionContainer(name))
{
    Ice::PropertiesPtr cfgProperties = armarx::IceProperties::create();
    auto* cfgInternal = dynamic_cast<armarx::IceProperties*>(cfgProperties.get());
    cfgInternal->setInheritanceSolver(nullptr);
 
    globalConfig->setProperties(cfgProperties);
    globalConfig->setPrefix("");
    globalConfig->setDescription("Global Config from Scenario " + name);
}
 
std::string
Data_Structure::Scenario::getName()
{
    return this->name;
}
 
void
Data_Structure::Scenario::setName(std::string scenarioName)
{
    name = std::move(scenarioName);
}
 
std::string
Data_Structure::Scenario::getCreationTime()
{
    return this->creationTime;
}
 
std::string
Data_Structure::Scenario::getLastChangedTime()
{
    return this->lastChangedTime;
}
 
std::string
Data_Structure::Scenario::getGlobalConfigName()
{
    return globalConfigName;
}
 
std::string
Data_Structure::Scenario::getSubfolder()
{
    return subfolder;
}
 
std::string
Data_Structure::Scenario::getPath()
{
    std::string scenarioPath = package.lock()->getScenarioPath();
 
    if (subfolder.empty())
    {
        scenarioPath.append("/").append(name).append("/").append(name).append(".scx");
    }
    else
    {
        scenarioPath.append("/")
            .append(subfolder)
            .append("/")
            .append(name)
            .append("/")
            .append(name)
            .append(".scx");
    }
 
    return scenarioPath;
}
 
std::string
Data_Structure::Scenario::getFolder()
{
    std::string scenarioPath = package.lock()->getScenarioPath();
 
    scenarioPath.append("/").append(name);
 
    return scenarioPath;
}
 
bool
Data_Structure::Scenario::isScenarioFileWriteable()
{
    std::ofstream ofs;
    ofs.open(getPath().c_str(), std::ofstream::out | std::ofstream::app);
    ARMARX_DEBUG << getPath() << " is writeable: " << ofs.is_open();
 
    return ofs.is_open();
 
    std::filesystem::file_status s = std::filesystem::status(std::filesystem::path(getPath()));
    if ((s.permissions() & std::filesystem::perms::owner_write) != std::filesystem::perms::none)
    {
        return true;
    }
    return false;
}
 
Data_Structure::PackagePtr
Data_Structure::Scenario::getPackage()
{
    return package.lock();
}
 
std::string
Data_Structure::Scenario::getStatus()
{
    std::string status = ApplicationStatus::Unknown;
    for (const auto& app : *applications)
    {
        if (!app->getEnabled())
        {
            continue;
        }
        if (status == ApplicationStatus::Unknown && app->getStatus() == ApplicationStatus::Running)
        {
            status = ApplicationStatus::Running;
        }
        else if (status == ApplicationStatus::Unknown &&
                 app->getStatus() == ApplicationStatus::Stopped)
        {
            status = ApplicationStatus::Stopped;
        }
        else if (status == ApplicationStatus::Unknown &&
                 app->getStatus() == ApplicationStatus::Inactive)
        {
            status = ApplicationStatus::Inactive;
        }
        else if (status == ApplicationStatus::Running &&
                 app->getStatus() == ApplicationStatus::Running)
        {
            status = ApplicationStatus::Running;
        }
        else if (status == ApplicationStatus::Stopped &&
                 app->getStatus() == ApplicationStatus::Stopped)
        {
            status = ApplicationStatus::Stopped;
        }
        else if (status == ApplicationStatus::Inactive &&
                 app->getStatus() == ApplicationStatus::Inactive)
        {
            status = ApplicationStatus::Inactive;
        }
        else if ((status == ApplicationStatus::Running &&
                  app->getStatus() == ApplicationStatus::Stopped) ||
                 (status == ApplicationStatus::Stopped &&
                  app->getStatus() == ApplicationStatus::Running) ||
                 (status == ApplicationStatus::Stopped &&
                  app->getStatus() == ApplicationStatus::Inactive) ||
                 (status == ApplicationStatus::Running &&
                  app->getStatus() == ApplicationStatus::Inactive) ||
                 (status == ApplicationStatus::Inactive &&
                  app->getStatus() == ApplicationStatus::Running) ||
                 (status == ApplicationStatus::Inactive &&
                  app->getStatus() == ApplicationStatus::Stopped))
        {
            status = ApplicationStatus::Mixed;
            break;
        }
        else if (app->getStatus() == ApplicationStatus::Waiting)
        {
            status = ApplicationStatus::Waiting;
            break;
        }
        else if (app->getStatus() == ApplicationStatus::Unknown)
        {
            status = ApplicationStatus::Unknown;
            break;
        }
        else
        {
            status = ApplicationStatus::Unknown;
            break;
        }
    }
 
    return status;
}
 
void
Data_Structure::Scenario::setLastChangedTime(std::string time)
{
    this->lastChangedTime = std::move(time);
}
 
void
Data_Structure::Scenario::setGlobalConfigName(std::string configName)
{
    globalConfigName = std::move(configName);
}
 
Data_Structure::ApplicationInstanceVectorPtr
Data_Structure::Scenario::getApplications()
{
    return applications;
}
 
Data_Structure::ApplicationInstancePtr
Data_Structure::Scenario::getApplicationByName(const std::string& appName)
{
    for (auto app : *applications)
    {
        if (app->getName() == appName)
        {
            return app;
        }
    }
 
    return {nullptr};
}
 
void
Data_Structure::Scenario::addApplication(const Data_Structure::ApplicationInstancePtr& application)
{
    applications->push_back(application);
}
 
void
Data_Structure::Scenario::removeApplication(
    const Data_Structure::ApplicationInstancePtr& application) //?
{
    for (auto iter = applications->begin(); iter != applications->end(); ++iter)
    {
        if (*iter == application)
        {
            (*iter)->deleteConfig();
            applications->erase(iter);
            return;
        }
    }
}
 
void
Data_Structure::Scenario::save(bool saveApplications)
{
    Parser::XMLScenarioParser parser;
    parser.saveScenario(shared_from_this(), saveApplications);
}
 
void
Data_Structure::Scenario::makeLocalGlobalConfig()
{
    if (!isReadOnly())
    {
        return;
    }
 
    if (!std::filesystem::is_symlink(getGlobalConfigPath()))
    {
        ARMARX_WARNING << "Make local called on non-linked global scenario config";
        return;
    }
 
    std::filesystem::remove(getGlobalConfigPath());
    this->save();
    // Reload to register status changes
    this->reloadGlobalConf();
}
 
bool
Data_Structure::Scenario::isReadOnly()
{
    return std::filesystem::is_symlink(getGlobalConfigPath());
}
 
void
Data_Structure::Scenario::reloadAppInstances()
{
    for (const auto& it : *applications)
    {
        it->load();
    }
}
 
void
Data_Structure::Scenario::reloadGlobalConf()
{
    if (isGlobalConfigFileexistent())
    {
        globalConfig->getProperties()->load(getGlobalConfigPath());
    }
}
 
armarx::PropertyDefinitionsPtr
Data_Structure::Scenario::getGlobalConfig()
{
    return globalConfig;
}
 
std::string
Data_Structure::Scenario::getGlobalConfigPath()
{
    std::filesystem::path scenarioPath;
    if (subfolder.empty())
    {
        scenarioPath = std::filesystem::path(
            package.lock()->getScenarioPath().append("/").append(name).append("/"));
    }
    else
    {
        scenarioPath = std::filesystem::path(package.lock()
                                                 ->getScenarioPath()
                                                 .append("/")
                                                 .append(subfolder + "/")
                                                 .append(name)
                                                 .append("/"));
    }
 
    scenarioPath =
        scenarioPath /
        std::filesystem::path(globalConfigName.empty() ? "./config/global.cfg" : globalConfigName);
    return scenarioPath.string();
}
 
bool
Data_Structure::Scenario::isGlobalConfigWritable()
{
    std::ofstream ofs;
    ofs.open(getGlobalConfigPath().c_str(), std::ofstream::out | std::ofstream::app);
    ARMARX_DEBUG << getGlobalConfigPath() << " is writeable: " << ofs.is_open();
 
    return ofs.is_open();
}
 
bool
Data_Structure::Scenario::isGlobalConfigFileexistent()
{
    return std::filesystem::exists(std::filesystem::path(getGlobalConfigPath()));
}
 
bool
Data_Structure::Scenario::getStatusWriteBlock()
{
    for (const auto& app : *applications)
    {
        if (app->getStatusWriteBlock())
        {
            return true;
        }
    }
    return false;
}
 
void
Data_Structure::Scenario::setStatusWriteBlock(bool state)
{
    for (const auto& app : *applications)
    {
        app->setStatusWriteBlock(state);
    }
}
 
std::vector<std::string>
Data_Structure::Scenario::getAllDeploymendNodeNames()
{
    std::vector<std::string> result;
    for (const auto& app : *applications)
    {
        result.push_back(app->getEffectiveNodeName());
    }
    return result;
}
 
bool
Data_Structure::Scenario::allApplicationsFound()
{
    for (const auto& app : *applications)
    {
        app->updateFound();
        if (!app->getFound())
        {
            return false;
        }
    }
    return true;
}
 
std::string
Data_Structure::Scenario::getNodeName() const
{
    return nodeName;
}
 
void
Data_Structure::Scenario::setNodeName(const std::string& value)
{
    nodeName = value;
}