softwarecontainer::DBusGatewayInstance Class Reference

DBus Gateway takes care of spawning and killing the DBus proxies. More...

#include <dbusgatewayinstance.h>

Inheritance diagram for softwarecontainer::DBusGatewayInstance:

Collaboration diagram for softwarecontainer::DBusGatewayInstance:

Public Types
enum	ProxyType { SessionProxy, SystemProxy }
enum	GatewayState : unsigned int { CREATED, CONFIGURED, ACTIVATED }

Public Member Functions
	DBusGatewayInstance (ProxyType type, const std::string &gatewayDir, std::shared_ptr< ContainerAbstractInterface > container)
	Spawn the proxy and use the supplied path for the socket. More...
virtual bool	readConfigElement (const json_t *element) override
	Gateway specific parsing of config elements. More...
virtual bool	activateGateway ()
	Implements Gateway::activateGateway. More...
virtual bool	teardownGateway () override
	Implements Gateway::teardownGateway. More...
virtual std::string	id () const
	Returns the ID of the gateway. More...
virtual bool	setConfig (const json_t *config)
	Configure this gateway according to the supplied JSON configuration string. More...
virtual bool	activate ()
	Applies any configuration set by setConfig() More...
virtual bool	teardown ()
	Restore system to the state prior to launching of gateway. More...
virtual bool	isConfigured ()
	Is the gateway configured or not? More...
virtual bool	isActivated ()
	Is the gateway activated or not? More...

Static Public Attributes
static constexpr const char *	ID
static constexpr const char *	SESSION_CONFIG
static constexpr const char *	SYSTEM_CONFIG

Protected Member Functions
std::shared_ptr< ContainerAbstractInterface >	getContainer ()
	Get a handle to the associated container. More...
bool	setEnvironmentVariable (const std::string &variable, const std::string &value)
	Set an environment variable in the associated container. More...

Protected Attributes
bool	m_activatedOnce

Detailed Description

DBus Gateway takes care of spawning and killing the DBus proxies.

This module requires the 'dbus-proxy' binary to be available in the $PATH of the user executing softwarecontainer.

Definition at line 32 of file dbusgatewayinstance.h.

Constructor & Destructor Documentation

softwarecontainer::DBusGatewayInstance::DBusGatewayInstance	(	ProxyType	type,
		const std::string &	gatewayDir,
		std::shared_ptr< ContainerAbstractInterface >	container
	)

Spawn the proxy and use the supplied path for the socket.

Parameters

type	SessionProxy or SystemProxy

Definition at line 36 of file dbusgatewayinstance.cpp.

References softwarecontainer::Gateway::id(), softwarecontainer::Gateway::isActivated(), and softwarecontainer::Gateway::teardown().

                                                                                              :
    Gateway(ID, container, true /*this GW is dynamic*/),
    m_socket(""),
    m_type(type),
    m_pid(INVALID_PID),
    m_proxyStdin(INVALID_FD)
{
    std::string name = container->id();
    std::string socketName = (m_type == SessionProxy ? "sess_" : "sys_") + name + ".sock";
    m_socket = buildPath(gatewayDir, socketName);

    // Write configuration
    m_entireConfig = json_object();
    m_busConfig = json_array();

    const char* unusedTypeStr;
    if (m_type == SessionProxy) {
        typeStr = SESSION_CONFIG;
        unusedTypeStr = SYSTEM_CONFIG;

    } else {
        typeStr = SYSTEM_CONFIG;
        unusedTypeStr = SESSION_CONFIG;
    }
    json_object_set(m_entireConfig, typeStr, m_busConfig);

    // Send an empty array as config for the irrelevant proxy type
    json_t* emptyArray = json_array();
    json_object_set(m_entireConfig, unusedTypeStr, emptyArray);
}

Here is the call graph for this function:

Member Function Documentation

bool softwarecontainer::DBusGatewayInstance::readConfigElement ( const json_t *  element )

overridevirtual

Gateway specific parsing of config elements.

All gateways implement this method in order to provide gateway specific parsing of the configuration content.

Parameters

element

A JSON configuration item.

Returns

false if an error was encountered while parsing, true otherwise.

Implements softwarecontainer::Gateway.

Definition at line 81 of file dbusgatewayinstance.cpp.

{
    DBusGatewayParser parser;

    // TODO: This should really be done with exceptions instead and json_t* as return type.
    if (!parser.parseDBusConfig(element, typeStr, m_busConfig)) {
        // This might also mean that only one of session or system bus config parsing failed
        // so this is not a fatal error
        log_warning() << "Failed to parse DBus configuration element";
        return false;
    }

    return true;
}

bool softwarecontainer::DBusGatewayInstance::activateGateway ( )

virtual

Implements Gateway::activateGateway.

Starts the dbus-proxy binary and feeds it the configuration set in setConfig(). This function will also set up the correct environment variables (DBUS_SESSION_BUS_ADDRESS when proxying the session bus, or DBUS_SYSTEM_BUS_ADDRESS when proxying the system bus).

This function requires a config to have been set using setConfig().

This function requires the 'dbus-proxy' binary to be available in $PATH

Returns

true when dbus-proxy was correctly execute and environment variable was correctly set false if dbus-proxy failed to execute or accept input on STDIN, or when environment variable could not be set.

Implements softwarecontainer::Gateway.

Definition at line 96 of file dbusgatewayinstance.cpp.

References softwarecontainer::Gateway::getContainer().

{
    // Setting up the environment and starting dbus-proxy should only be done the first time
    // around. Any subsequent calls after the first should only result in the config being
    // updated.
    if (!m_activatedOnce) {
        // set DBUS_{SESSION,SYSTEM}_BUS_ADDRESS env variable
        std::string variable = std::string("DBUS_")
                             + (m_type == SessionProxy ? "SESSION" : "SYSTEM")
                             + std::string("_BUS_ADDRESS");
        std::string value = "unix:path=" + buildPath("/gateways", socketName());
        getContainer()->setEnvironmentVariable(variable, value);

        std::vector<std::string> commandVec = {"dbus-proxy",
                                               m_socket,
                                               m_type == SessionProxy ? "session" : "system"};

        // Give the dbus-proxy access to the real dbus bus address.
        std::vector<std::string> envVec;

        bool hasEnvVar = false;
        std::string envValue = Glib::getenv(variable, hasEnvVar);

        if (!hasEnvVar) {
            if (SessionProxy == m_type) {
                log_error() << "Using DBus gateway in session mode"
                            << " and no " + variable + " set in host environment, dbus-proxy won't work";
                return false;
            } else {
                log_warn() << "Using DBus gateway in system mode"
                           << " and no " + variable + " set in host environment, this could be a problem";
            }
        } else {
            envVec.push_back(variable + "=" + envValue);
        }

        if (!startDBusProxy(commandVec, envVec)) {
            return false;
        }
    }

    // Dump to string. Compact format is currently needed as dbus-proxy relies on
    // the config string to be without newlines anywhere in the middle of it all
    char *config_c = json_dumps(m_entireConfig, JSON_COMPACT);
    std::string config = std::string(config_c);

    free(config_c);

    return testDBusConnection(config);
}

Here is the call graph for this function:

bool softwarecontainer::DBusGatewayInstance::teardownGateway ( )

overridevirtual

Implements Gateway::teardownGateway.

This function will clean up processes launched and file descriptors opened during the lifetime of the gatway. Specifically it will close the connection to the dbus-proxy, and close the stdin and stdout pipes opened to dbus-proxy.

Returns

false if dbus-proxy could not be terminated, if stdin or stdout could not be closed, or if the socket created by the dbus-proxy could not be removed.

Implements softwarecontainer::Gateway.

Definition at line 221 of file dbusgatewayinstance.cpp.

{
    bool success = true;

    if (nullptr != m_entireConfig) {
        json_decref(m_entireConfig);
        m_entireConfig = nullptr;
    }

    if (m_pid != INVALID_PID) {
        log_debug() << "Killing dbus-proxy with pid " << m_pid;

        // TODO: Figure out how to shut down nicely?
        kill(m_pid, SIGKILL); // In some configurations, hangs if using SIGTERM instead
        waitpid(m_pid, nullptr, 0); // Wait until it exits
        Glib::spawn_close_pid(m_pid);
    } else {
        log_debug() << "dbus-proxy pid not set or already dead: " << m_pid;
    }

    if (access(m_socket.c_str(), F_OK) != -1) {
        if (unlink(m_socket.c_str()) == -1) {
            log_error() << "Could not remove " << m_socket << ": " << strerror(errno);
            success = false;
        }
    } else {
        // TODO: Seems weird that this would ever happen. Seems like a severe error.
        log_debug() << "Socket not accessible, has it been removed already?";
    }

    // Close stdin to proxy as we will no longer send configs to it
    if (close(m_proxyStdin) == -1) {
        log_warning() << "Could not close stdin of dbus-proxy";
    }

    return success;
}

std::string softwarecontainer::Gateway::id ( ) const

virtualinherited

Returns the ID of the gateway.

Returns

Returns the ID of the gateway as a string

Definition at line 36 of file gateway.cpp.

Referenced by softwarecontainer::Gateway::activate(), DBusGatewayInstance(), softwarecontainer::Gateway::setConfig(), and softwarecontainer::Gateway::teardown().

{
    return m_id;
}

Here is the caller graph for this function:

bool softwarecontainer::Gateway::setConfig ( const json_t *  config )

virtualinherited

Configure this gateway according to the supplied JSON configuration string.

Parameters

config

JSON string containing gateway-specific JSON configuration

Returns

true if config was successfully parsed, false otherwise

Exceptions

GatewayError

If called on an already activated gateway.

Reimplemented in softwarecontainer::DBusGateway.

Definition at line 41 of file gateway.cpp.

References softwarecontainer::Gateway::id(), and softwarecontainer::Gateway::readConfigElement().

{
    if (GatewayState::ACTIVATED == m_state && !m_isDynamic) {
        std::string message = "Can not configure a gateway that is already activated "
                              "if the gateway does not support dynamic behavior. "
                              "Gateway ID: " + id();
        log_error() << message;
        throw GatewayError(message);
    }

    if (!json_is_array(config)) {
        log_error() << "Root JSON element is not an array";
        return false;
    }

    if (json_array_size(config) == 0) {
        log_error() << "Root JSON array is empty";
        return false;
    }

    for(size_t i = 0; i < json_array_size(config); i++) {
        json_t *element = json_array_get(config, i);
        if (!json_is_object(element)) {
            log_error() << "json configuration is not an object";
            return false;
        }

        if (!readConfigElement(element)) {
            log_warning() << "Could not read config element";
            return false;
        }
    }

    m_state = GatewayState::CONFIGURED;
    return true;
}

Here is the call graph for this function:

bool softwarecontainer::Gateway::activate ( )

virtualinherited

Applies any configuration set by setConfig()

Returns

true upon successful application of configuration, false otherwise

Exceptions

GatewayError

If called on an already activated gateway, or if the gateway has not been previously configured, or if there is not container instance set.

Reimplemented in softwarecontainer::DBusGateway.

Definition at line 78 of file gateway.cpp.

References softwarecontainer::Gateway::id().

                       {
    if (GatewayState::ACTIVATED == m_state && !m_isDynamic) {
        std::string message =  "Can not activate a gateway that is already activated "
                               "if the gateway does not support dynamic behavior. "
                               "Gateway ID: " + id();
        log_error() << message;
        throw GatewayError(message);
    }

    if (GatewayState::CONFIGURED != m_state) {
        std::string message = "Activate was called on a gateway which is not in configured state. "
                              "Gateway ID: " + id();
        log_error() << message;
        throw GatewayError(message);
    }

    if (!activateGateway()) {
        log_error() << "Couldn't activate gateway: " << id();
        return false;
    }

    m_state = GatewayState::ACTIVATED;
    return true;
}

Here is the call graph for this function:

bool softwarecontainer::Gateway::teardown ( )

virtualinherited

Restore system to the state prior to launching of gateway.

Any cleanup code (removal of files, virtual interfaces, etc) should be placed here.

Returns

true upon successful clean-up, false otherwise

Exceptions

GatewayError

If called on a non activated gateway.

Reimplemented in softwarecontainer::DBusGateway.

Definition at line 103 of file gateway.cpp.

References softwarecontainer::Gateway::id().

Referenced by DBusGatewayInstance().

                       {
    /* At this point, a gateway should either be in state ACTIVATED if it is non-dynamic, or
       if it is dynamic it should have been activated at least once before.
     */
    if (GatewayState::ACTIVATED != m_state && !m_activatedOnce) {
        std::string message = "Teardown called on non-activated gateway. Gateway ID:  " + id();
        log_error() << message;
        throw GatewayError(message);
    }

    if (!teardownGateway()) {
        log_error() << "Could not tear down gateway: " << id();
        return false;
    }

    // Return to a state of nothingness
    m_state = GatewayState::CREATED;

    /* Since we have been torn down, we should not be considered to have been
       activated any more. */
    m_activatedOnce = false;

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool softwarecontainer::Gateway::isConfigured ( )

virtualinherited

Is the gateway configured or not?

Reimplemented in softwarecontainer::DBusGateway.

Definition at line 134 of file gateway.cpp.

{
    return m_state >= GatewayState::CONFIGURED;
}

bool softwarecontainer::Gateway::isActivated ( )

virtualinherited

Is the gateway activated or not?

Dynamic gateways will return true if they have been activated at least once. Non-dynamic gateways will return true if they are in state ACTIVATED

Reimplemented in softwarecontainer::DBusGateway.

Definition at line 139 of file gateway.cpp.

Referenced by DBusGatewayInstance().

{
    // For dynamic gateways it's only relevant to know if it has been activated
    // at least once, the current state is not important
    if (m_isDynamic) {
        return m_activatedOnce;
    }

    // For non-dynamic gateways, the current state is the only relevant info
    return m_state >= GatewayState::ACTIVATED;
}

Here is the caller graph for this function:

std::shared_ptr< ContainerAbstractInterface > softwarecontainer::Gateway::getContainer ( )

protectedinherited

Get a handle to the associated container.

Exceptions

GatewayError

If called before setContainer() has been called.

Definition at line 128 of file gateway.cpp.

Referenced by softwarecontainer::NetworkGateway::activateGateway(), activateGateway(), softwarecontainer::WaylandGateway::readConfigElement(), and softwarecontainer::NetworkGateway::teardownGateway().

{
    std::shared_ptr<ContainerAbstractInterface> ptrCopy = m_container;
    return ptrCopy;
}

Here is the caller graph for this function:

bool softwarecontainer::Gateway::setEnvironmentVariable ( const std::string &  variable, const std::string &  value  )

protectedinherited

Set an environment variable in the associated container.

---

The documentation for this class was generated from the following files:

• libsoftwarecontainer/src/gateway/dbus/dbusgatewayinstance.h
• libsoftwarecontainer/src/gateway/dbus/dbusgatewayinstance.cpp