Gateway base class for SoftwareContainer. More...

#include <gateway.h>

Inheritance diagram for softwarecontainer::Gateway:

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

Public Member Functions
	Gateway (const std::string &id, std::shared_ptr< ContainerAbstractInterface > container, bool isDynamic=false)
	Constructor for inheriting classes to initilize. 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...

Protected Member Functions
virtual bool	readConfigElement (const json_t *element)=0
	Gateway specific parsing of config elements. More...

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...

virtual bool	activateGateway ()=0

virtual bool	teardownGateway ()=0

Protected Attributes
bool	m_activatedOnce

Detailed Description

Gateway base class for SoftwareContainer.

Gateways can be in one of three states:

Created - the gateway object exists
Configured - the gateway has successfully recieved and processed some configuration data, ready for activation
Activated - the gateway is active and running.

The complete gateway config is passed as a JSON array and all gateways then provide their specific parsing of the items in the array.

Gateways can specify if they are 'dynamic' or not when initializing this base class. A dynamic gateway supports multiple calls to setConfig and activate.

Definition at line 61 of file gateway.h.

Constructor & Destructor Documentation

softwarecontainer::Gateway::Gateway	(	const std::string &	id,
		std::shared_ptr< ContainerAbstractInterface >	container,
		bool	isDynamic = `false`
	)

Constructor for inheriting classes to initilize.

Gateways that supports quick-launch should flag for this when initializing this base class.

Parameters

id	Specific gateway ID used to match with configurations.
container	An interface to the Container that this gateway is part of.
isDynamic	Set to 'true' to indicate the inheriting class supports re-configuration and re-activation

Definition at line 25 of file gateway.cpp.

                                  :
     m_activatedOnce(false),
     m_id(id),
     m_container(container),
     m_isDynamic(isDynamic),
     m_state(GatewayState::CREATED)
 {
 }

Member Function Documentation

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

virtual

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 activate(), softwarecontainer::DBusGatewayInstance::DBusGatewayInstance(), setConfig(), and teardown().

 {
     return m_id;
 }

Here is the caller graph for this function:

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

virtual

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 id(), and 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 ( )

virtual

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 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 ( )

virtual

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 id().

Referenced by softwarecontainer::DBusGatewayInstance::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 ( )

virtual

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 ( )

virtual

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 softwarecontainer::DBusGatewayInstance::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:

virtual bool softwarecontainer::Gateway::readConfigElement ( const json_t * element )

protectedpure virtual

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.

Implemented in softwarecontainer::NetworkGateway, softwarecontainer::DeviceNodeGateway, softwarecontainer::DBusGatewayInstance, softwarecontainer::DBusGateway, softwarecontainer::FileGateway, softwarecontainer::CgroupsGateway, softwarecontainer::PulseGateway, softwarecontainer::WaylandGateway, and softwarecontainer::EnvironmentGateway.

Referenced by setConfig().

Here is the caller graph for this function:

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

protected

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(), softwarecontainer::DBusGatewayInstance::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
	)

protected

Set an environment variable in the associated container.

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

libsoftwarecontainer/src/gateway/gateway.h
libsoftwarecontainer/src/gateway/gateway.cpp

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation