softwarecontaineragent.h

Go to the documentation of this file.

/*
 * Copyright (C) 2016-2017 Pelagicore AB
 *
 * Permission to use, copy, modify, and/or distribute this software for
 * any purpose with or without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
 * BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 *
 * For further information see LICENSE
 */

#include <glib-unix.h>
#include <glibmm.h>

#include <ivi-profiling.h>

#include "filetoolkitwithundo.h"
#include "softwarecontainer.h"
#include "softwarecontainer-common.h"
#include "softwarecontainererror.h"

#include "capability/filteredconfigstore.h"
#include "capability/defaultconfigstore.h"
#include "capability/servicemanifestloader.h"
#include "config/config.h"
#include "containeroptions/containeroptionparser.h"
#include "softwarecontainerfactory.h"
#include "containerutilityinterface.h"

#include <jsonparser.h>
#include "commandjob.h"
#include <queue>

namespace softwarecontainer {

static constexpr ContainerID INVALID_CONTAINER_ID = -1;

class SoftwareContainerAgentError : public SoftwareContainerError
{
public:
    SoftwareContainerAgentError():
        m_message("SoftwareContainer error")
    {
    }

    SoftwareContainerAgentError(const std::string &message):
        m_message(message)
    {
    }

    virtual const char *what() const throw()
    {
        return m_message.c_str();
    }

protected:
    std::string m_message;
};


class SoftwareContainerAgent
{
    LOG_DECLARE_CLASS_CONTEXT("SCA", "SoftwareContainerAgent");
    typedef std::shared_ptr<SoftwareContainerAbstractInterface> SoftwareContainerPtr;

public:
    SoftwareContainerAgent(Glib::RefPtr<Glib::MainContext> mainLoopContext,
                           std::shared_ptr<Config> config,
                           std::shared_ptr<SoftwareContainerFactory> factory,
                           std::shared_ptr<ContainerUtilityInterface> utility);

    ~SoftwareContainerAgent();

    std::vector<ContainerID> listContainers();

    std::vector<std::string> listCapabilities();

    void deleteContainer(ContainerID containerID);

    SoftwareContainerPtr getContainer(ContainerID containerID);

    ContainerID createContainer(const std::string &config);

    pid_t execute(ContainerID containerID,
                 const std::string &cmdLine,
                 const std::string &workingDirectory,
                 const std::string &outputFile,
                 const EnvironmentVariables &env,
                 std::function<void (pid_t, int)> listener);

    void shutdownContainer(ContainerID containerID);

    void suspendContainer(ContainerID containerID);

    void resumeContainer(ContainerID containerID);

    void bindMount(const ContainerID containerID,
                   const std::string &pathInHost,
                   const std::string &pathInContainer,
                   bool readOnly);

    void setCapabilities(const ContainerID &containerID,
                         const std::vector<std::string> &capabilities);
private:
    bool updateGatewayConfigs(const ContainerID &containerID,
                              const GatewayConfiguration &configs);

    // Find a job given a pid
    std::shared_ptr<CommandJob> getJob(pid_t pid);
    // Check if a given containerID is valid
    void assertContainerExists(ContainerID containerID);
    // Return a suitable container id
    ContainerID findSuitableId();

    // List of containers in use
    std::map<ContainerID, SoftwareContainerPtr> m_containers;

    Glib::RefPtr<Glib::MainContext> m_mainLoopContext;
    SignalConnectionsHandler m_connections;
    std::vector<ContainerID> m_containerIdPool;

    std::shared_ptr<FilteredConfigStore> m_filteredConfigStore;
    std::shared_ptr<DefaultConfigStore>  m_defaultConfigStore;

    std::shared_ptr<Config> m_config;

    /*
     * Holds all configs to use for each SoftwareContainer instance,
     * both the static configs from Config, as well as dynamic values
     * set by the client when creating a container.
     *
     * Each SoftwareContainer instance needs its own copy of these configs
     * so this reference should be used to create a copy from, which should
     * be passed to SoftwareContainer as a unique_ptr.
     */
    SoftwareContainerConfig m_containerConfig;

    /*
     * Responsible for parsing any dynamic values given when creating a container
     */
    ContainerOptionParser m_optionParser;

    std::shared_ptr<SoftwareContainerFactory> m_factory;
    std::shared_ptr<ContainerUtilityInterface> m_containerUtility;
};

} // namespace softwarecontainer