Public Member Functions
	SoftwareContainerAgent (Glib::RefPtr< Glib::MainContext > mainLoopContext, std::shared_ptr< Config > config, std::shared_ptr< SoftwareContainerFactory > factory, std::shared_ptr< ContainerUtilityInterface > utility)
	creates a new agent object and runs some initialization More...

std::vector< ContainerID >	listContainers ()
	get a list of all containers More...

std::vector< std::string >	listCapabilities ()
	List all capabilities that the user can set. More...

void	deleteContainer (ContainerID containerID)
	delete container by ID More...

SoftwareContainerPtr	getContainer (ContainerID containerID)
	Fetches a pointer to a SoftwareContainer matching an ID. More...

ContainerID	createContainer (const std::string &config)
	Create a new container. More...

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)
	Launch the given command in a the given container. More...

void	shutdownContainer (ContainerID containerID)
	shuts down a container More...

void	suspendContainer (ContainerID containerID)
	suspends execution of a container More...

void	resumeContainer (ContainerID containerID)
	resumes execution of a container More...

void	bindMount (const ContainerID containerID, const std::string &pathInHost, const std::string &pathInContainer, bool readOnly)
	Bind mount a folder into the container. More...

void	setCapabilities (const ContainerID &containerID, const std::vector< std::string > &capabilities)
	Set capabilities for the container. More...

Detailed Description

Definition at line 82 of file softwarecontaineragent.h.

Constructor & Destructor Documentation

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

creates a new agent object and runs some initialization

This will check if the workspace is sound

The config is used to set various values in the agent, or for the agent to pass along to objects it creates.

Parameters

mainLoopContext	A Glib::MainContext
config	A general SoftwareContainer config

Exceptions

SoftwareContainerAgentError	if initialization of the agent fails because of the Workspace initialization
ConfigStoreError	if initialization of ConfigStore fails

Definition at line 32 of file softwarecontaineragent.cpp.

                                                                                                 :
     m_mainLoopContext(mainLoopContext),
     m_config(config),
     m_factory(factory),
     m_containerUtility(utility)
 {
     m_containerIdPool.push_back(0);
 
     // Get all configs for the config object
     int shutdownTimeout =
         m_config->getIntValue(ConfigDefinition::SC_GROUP,
                               ConfigDefinition::SC_SHUTDOWN_TIMEOUT_KEY);
     std::string sharedMountsDir =
         m_config->getStringValue(ConfigDefinition::SC_GROUP,
                                  ConfigDefinition::SC_SHARED_MOUNTS_DIR_KEY);
     std::string lxcConfigPath =
         m_config->getStringValue(ConfigDefinition::SC_GROUP,
                                  ConfigDefinition::SC_LXC_CONFIG_PATH_KEY);
 #ifdef ENABLE_NETWORKGATEWAY
         // All of the below are network settings
     bool createBridge = m_config->getBoolValue(ConfigDefinition::SC_GROUP,
                                                ConfigDefinition::SC_CREATE_BRIDGE_KEY);
     std::string bridgeDevice = m_config->getStringValue(ConfigDefinition::SC_GROUP,
                                                         ConfigDefinition::SC_BRIDGE_DEVICE_KEY);
     std::string bridgeIp = m_config->getStringValue(ConfigDefinition::SC_GROUP,
                                                     ConfigDefinition::SC_BRIDGE_IP_KEY);
     std::string bridgeNetmask = m_config->getStringValue(ConfigDefinition::SC_GROUP,
                                                          ConfigDefinition::SC_BRIDGE_NETMASK_KEY);
     int bridgeNetmaskBits = m_config->getIntValue(ConfigDefinition::SC_GROUP,
                                                   ConfigDefinition::SC_BRIDGE_NETMASK_BITLENGTH_KEY);
     std::string bridgeNetAddr = m_config->getStringValue(ConfigDefinition::SC_GROUP,
                                                  ConfigDefinition::SC_BRIDGE_NETADDR_KEY);
 #endif // ENABLE_NETWORKGATEWAY
 
     // Get all configs for the config stores
     std::string serviceManifestDir =
         m_config->getStringValue(ConfigDefinition::SC_GROUP,
                                  ConfigDefinition::SC_SERVICE_MANIFEST_DIR_KEY);
     std::string defaultServiceManifestDir =
         m_config->getStringValue(ConfigDefinition::SC_GROUP,
                                  ConfigDefinition::SC_DEFAULT_SERVICE_MANIFEST_DIR_KEY);
 
     std::unique_ptr<ServiceManifestLoader> defaultLoader(new ServiceManifestFileLoader(defaultServiceManifestDir));
     std::unique_ptr<ServiceManifestLoader> loader(new ServiceManifestFileLoader(serviceManifestDir));
 
     m_filteredConfigStore = std::make_shared<FilteredConfigStore>(std::move(loader));
     m_defaultConfigStore  = std::make_shared<DefaultConfigStore>(std::move(defaultLoader));
 
     m_containerUtility->removeOldContainers();
     m_containerUtility->checkWorkspace();
 
     m_containerConfig = SoftwareContainerConfig(
 #ifdef ENABLE_NETWORKGATEWAY
                                                 createBridge,
                                                 bridgeDevice,
                                                 bridgeIp,
                                                 bridgeNetmask,
                                                 bridgeNetmaskBits,
                                                 bridgeNetAddr,
 #endif // ENABLE_NETWORKGATEWAY
                                                 lxcConfigPath,
                                                 sharedMountsDir,
                                                 shutdownTimeout);
 
 }

Member Function Documentation

std::vector< ContainerID > softwarecontainer::SoftwareContainerAgent::listContainers ( )

get a list of all containers

Returns: a vector of container IDs

Definition at line 131 of file softwarecontaineragent.cpp.

 {
     std::vector<ContainerID> containerIDs;
     for (auto &cont : m_containers) {
         containerIDs.push_back(cont.first);
     }
 
     return containerIDs;
 }

std::vector< std::string > softwarecontainer::SoftwareContainerAgent::listCapabilities ( )

List all capabilities that the user can set.

Capabilities are a mapping from a string to a set of gateway configurations. This method returns all capability names that can be used through setCapabilities.

Returns: a list of capabilities

Exceptions

SoftwareContainerError if not possible to create.

Definition at line 300 of file softwarecontaineragent.cpp.

 {
     return m_filteredConfigStore->IDs();
 }

void softwarecontainer::SoftwareContainerAgent::deleteContainer ( ContainerID containerID )

delete container by ID

Exceptions

SoftwareContainerError on failure.

Definition at line 141 of file softwarecontaineragent.cpp.

Referenced by shutdownContainer().

 {
     assertContainerExists(containerID);
 
     m_containers.erase(containerID);
     m_containerIdPool.push_back(containerID);
 }

Here is the caller graph for this function:

SoftwareContainerAgent::SoftwareContainerPtr softwarecontainer::SoftwareContainerAgent::getContainer ( ContainerID containerID )

Fetches a pointer to a SoftwareContainer matching an ID.

Parameters

containerID the ID for the container

Returns: Pointer to the matched container if there is such a container.

Exceptions

SoftwareContainerError on failure.

Definition at line 149 of file softwarecontaineragent.cpp.

Referenced by bindMount(), execute(), resumeContainer(), shutdownContainer(), and suspendContainer().

 {
     assertContainerExists(containerID);
     return m_containers[containerID];
 }

Here is the caller graph for this function:

ContainerID softwarecontainer::SoftwareContainerAgent::createContainer ( const std::string & config )

Create a new container.

Parameters

config	container-wide configuration string
a	reference to ContainerID

Returns: ContainerID for the newly created container

Exceptions

SoftwareContainerError if not possible to create.

Definition at line 168 of file softwarecontaineragent.cpp.

References softwarecontainer::ContainerOptionParser::parse().

 {
     profilepoint("createContainerStart");
     profilefunction("createContainerFunction");
 
     // Set options for this container
     std::unique_ptr<DynamicContainerOptions> options = m_optionParser.parse(config);
     std::unique_ptr<SoftwareContainerConfig> containerConfig = options->toConfig(m_containerConfig);
 
     // Get an ID and create the container
     ContainerID containerID = findSuitableId();
     auto container = m_factory->createContainer(containerID, std::move(containerConfig));
     log_debug() << "Created container with ID :" << containerID;
 
     m_containers[containerID] = container;
     return containerID;
 }

Here is the call graph for this function:

pid_t softwarecontainer::SoftwareContainerAgent::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
	)

Launch the given command in a the given container.

Parameters

containerID	the id for the container
cmdLine	the command to run
workingDirectory	the working directory to use when running
outputFile	where to log any output
env	any environment variables to pass to the command
listener	a function that runs when the process exits

Returns: process id of the given command

Definition at line 186 of file softwarecontaineragent.cpp.

References softwarecontainer::addProcessListener(), and getContainer().

 {
     profilefunction("executeFunction");
     SoftwareContainerPtr container = getContainer(containerID);
 
     /*
      * We want to always apply any default capabilities we have. The only way to configure
      * the gateways from the agent is through setCapabilities - which sets the default caps also.
      *
      * If it has not been set previously, then we use a call without arguments to setCapabilities
      * to set it up, since we then should get only the default ones.
      */
     if (!m_containers[containerID]->previouslyConfigured()) {
         log_info() << "Container not configured yet, configuring with default capabilities, if any";
         GatewayConfiguration gatewayConfigs = m_defaultConfigStore->configs();
         if (!updateGatewayConfigs(containerID, gatewayConfigs)) {
             std::string errorMessage("Could not set default capabilities on container " + std::to_string(containerID));
             log_error() << errorMessage;
             throw SoftwareContainerError(errorMessage);
         }
 
     }
 
     // Set up a CommandJob for this run in the container
     auto job = container->createCommandJob(cmdLine);
     if (nullptr == job) {
         std::string errorMessage("Could not create job instance for " + cmdLine);
         log_error() << errorMessage;
         throw SoftwareContainerAgentError(errorMessage);
     }
 
     job->setOutputFile(outputFile);
     job->setEnvironmentVariables(env);
     job->setWorkingDirectory(workingDirectory);
 
     // Start it
     if (!job->start()) {
         std::string errorMessage("Could not start job");
         log_error() << errorMessage;
         throw SoftwareContainerError(errorMessage);
     }
 
     // If things went well, do what we need when it exits
     addProcessListener(m_connections, job->pid(), [listener](pid_t pid, int exitCode) {
         listener(pid, exitCode);
     }, m_mainLoopContext);
 
     profilepoint("executeEnd");
 
     return job->pid();
 }

Here is the call graph for this function:

void softwarecontainer::SoftwareContainerAgent::shutdownContainer ( ContainerID containerID )

shuts down a container

Parameters

containerID the container to shut down

Exceptions

SoftwareContainerError on failure.

Definition at line 243 of file softwarecontaineragent.cpp.

References deleteContainer(), and getContainer().

 {
     profilefunction("shutdownContainerFunction");
 
     SoftwareContainerPtr container = getContainer(containerID);
 
     int timeout = m_containerConfig.containerShutdownTimeout();
     container->shutdown(timeout);
 
     try {
         deleteContainer(containerID);
     } catch (SoftwareContainerError &err) {
         std::string errorMessage("Could not delete the container" + std::string(err.what()));
         log_error() << errorMessage;
         throw SoftwareContainerError(errorMessage);
     }
 }

Here is the call graph for this function:

void softwarecontainer::SoftwareContainerAgent::suspendContainer ( ContainerID containerID )

suspends execution of a container

Parameters

containerID the container to suspend

Exceptions

SoftwareContainerError on failure.

Definition at line 261 of file softwarecontaineragent.cpp.

References getContainer().

 {
     SoftwareContainerPtr container = getContainer(containerID);
     container->suspend();
 }

Here is the call graph for this function:

void softwarecontainer::SoftwareContainerAgent::resumeContainer ( ContainerID containerID )

resumes execution of a container

Parameters

containerID the container to resume

Exceptions

SoftwareContainerError on failure.

Definition at line 267 of file softwarecontaineragent.cpp.

References getContainer().

 {
     SoftwareContainerPtr container = getContainer(containerID);
     container->resume();
 }

Here is the call graph for this function:

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

Bind mount a folder into the container.

Parameters

containerID	the container to bind into
pathInHost	path to the folder in the host system
subPathInContainer	path (relative to a fixed start point) to use in the container
readOnly	whether or not to mount read-only
reference	to the full path of the mounted folder in the container

Exceptions

SoftwareContainerError on failure.

Definition at line 273 of file softwarecontaineragent.cpp.

References getContainer().

 {
     profilefunction("bindMountFunction");
     SoftwareContainerPtr container = getContainer(containerID);
 
     bool result = container->bindMount(pathInHost,
                                        pathInContainer,
                                        readOnly);
     if (!result) {
         std::string errorMessage("Unable to bind mount " + pathInHost + " to " + pathInContainer);
         log_error() << errorMessage;
         throw SoftwareContainerError(errorMessage);
     }
 }

Here is the call graph for this function:

void softwarecontainer::SoftwareContainerAgent::setCapabilities	(	const ContainerID &	containerID,
		const std::vector< std::string > &	capabilities
	)

Set capabilities for the container.

Capabilities are a mapping from a string to a set of gateway configurations. Capabilities are translated into gateway configurations and then sent the same way as with startGateways

Parameters

containerID	the container to use
capabilities	the capabilities

Exceptions

SoftwareContainerError on failure.

Definition at line 305 of file softwarecontaineragent.cpp.

 {
     if (capabilities.empty()) {
         log_warning() << "Got empty list of capabilities";
         return;
     }
 
     // Log a list of all caps that were provided
     std::string caps = "";
     for (const std::string &capName : capabilities) {
         caps += " " + capName;
     }
     log_debug() << "Will attempt to set capabilities:" + caps;
 
     GatewayConfiguration gatewayConfigs = m_defaultConfigStore->configs();
     GatewayConfiguration filteredConfigs = m_filteredConfigStore->configsByID(capabilities);
 
     // If we get an empty config the user passed a non existent cap name
     if (filteredConfigs.empty()) {
         std::string errorMessage("One or more capabilities were not found");
         log_error() << errorMessage;
         throw SoftwareContainerError(errorMessage);
     }
 
     gatewayConfigs.append(filteredConfigs);
 
     // Update container gateway configuration
     if (!updateGatewayConfigs(containerID, gatewayConfigs)) {
         std::string errorMessage("Could not set gateway configuration for capability");
         log_error() << errorMessage;
         throw SoftwareContainerError(errorMessage);
     }
 }

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

agent/src/softwarecontaineragent.h
agent/src/softwarecontaineragent.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation