softwarecontainer.h

/*
 * 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
 */

#pragma once

#include "observableproperty.h"
#include "gatewayconfig.h"
#include "signalconnectionshandler.h"
#include "config/softwarecontainerconfig.h"
#include "filetoolkitwithundo.h"
#include "softwarecontainererror.h"
#include "softwarecontainerabstractinterface.h"

#include <glibmm.h>

#include <vector>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>

#include "functionjob.h"
#include "commandjob.h"

namespace softwarecontainer {

class Gateway;
class ContainerAbstractInterface;


enum class ContainerState
{
    READY,
    SUSPENDED,
    TERMINATED,
    INVALID
};


class InvalidOperationError : public SoftwareContainerError
{
public:
    InvalidOperationError():
        SoftwareContainerError("Invalid operation on container")
    {
    }

    InvalidOperationError(const std::string &message):
        SoftwareContainerError(message)
    {
    }
};


class ContainerError : public SoftwareContainerError
{
public:
    ContainerError():
        SoftwareContainerError("Error in container implementation")
    {
    }

    ContainerError(const std::string &message):
        SoftwareContainerError(message)
    {
    }
};


class InvalidContainerError : public SoftwareContainerError
{
public:
    InvalidContainerError():
        SoftwareContainerError("Container is in an invalid state")
    {
    }

    InvalidContainerError(const std::string &message):
        SoftwareContainerError(message)
    {
    }
};


class SoftwareContainer :
    private FileToolkitWithUndo,
    public SoftwareContainerAbstractInterface
{
public:
    LOG_DECLARE_CLASS_CONTEXT("PCL", "SoftwareContainer library");

    SoftwareContainer(const ContainerID id,
                      std::unique_ptr<const SoftwareContainerConfig> config);

    ~SoftwareContainer();

    bool startGateways(const GatewayConfiguration &configs);

    std::shared_ptr<FunctionJob> createFunctionJob(const std::function<int()> fun);

    std::shared_ptr<CommandJob> createCommandJob(const std::string &command);

    void shutdown();

    void shutdown(unsigned int timeout);

    void suspend();

    void resume();

    bool bindMount(const std::string &pathOnHost,
                         const std::string &pathInContainer,
                         bool readonly = true);

    ObservableProperty<ContainerState> &getContainerState();

    bool previouslyConfigured();

private:
    /*
     * Add gateways and create and initialize the underlying container
     * implementation.
     */
    bool init();

    bool start();

    bool configureGateways(const GatewayConfiguration &gwConfig);
    bool activateGateways();
    bool shutdownGateways();

    std::string getContainerDir();
    std::string getGatewayDir();

    void assertValidState();

    // Check if the workspace is sound, and set it up if it isn't
    void checkContainerRoot(std::string rootDir);
#ifdef ENABLE_NETWORKGATEWAY
    void checkNetworkSettings();
#endif // ENABLE_NETWORKGATEWAY

    ContainerID m_containerID;
    std::shared_ptr<ContainerAbstractInterface> m_container;
    pid_t m_pcPid = INVALID_PID;
    ObservableWritableProperty<ContainerState> m_containerState;

    std::vector<std::unique_ptr<Gateway>> m_gateways;
    std::unique_ptr<const SoftwareContainerConfig> m_config;

    std::string m_containerRoot;
    unsigned int m_tmpfsSize;

    Glib::RefPtr<Glib::MainContext> m_mainLoopContext;
    SignalConnectionsHandler m_connections;

    // Keeps track of if startGateways has been called on this instance
    bool m_previouslyConfigured;
};

} // namespace softwarecontainer