galaxy.containers package

Interfaces to containerization software

class galaxy.containers.ContainerPort[source]

Bases: galaxy.containers.ContainerPort

Named tuple representing ports published by a container, with attributes:

Variables:
  • port (int) – Port number (inside the container)
  • protocol (str) – Port protocol, either tcp or udp
  • hostaddr (str) – Address or hostname where the published port can be accessed
  • hostport (int) – Published port number on which the container can be accessed
class galaxy.containers.ContainerVolume(path, host_path=None, mode=None)[source]

Bases: object

valid_modes = frozenset(['ro', 'rw'])
__init__(path, host_path=None, mode=None)[source]
from_str(as_str)[source]

Classmethod to convert from this container type’s string representation.

Parameters:as_str (str) – string representation of volume
to_native()[source]

Return this container type’s native representation of the volume.

mode_is_valid
class galaxy.containers.Container(interface, id, name=None, **kwargs)[source]

Bases: object

__init__(interface, id, name=None, **kwargs)[source]
Parameters:
  • interface (ContainerInterface subclass instance) – Container interface for the given container type
  • id (str) – Container identifier
  • name (str) – Container name
id

The container’s id

name

The container’s name

from_id(interface, id)[source]

Classmethod to create an instance of Container from the container system’s id for the given container type.

Parameters:
  • interface (ContainerInterface subclass instance) – Container insterface for the given id
  • id (str) – Container identifier
Returns:

Container object

Return type:

Container subclass instance

ports

Attribute for accessing details of ports published by the container.

Returns:Port details
Return type:list of :class:`ContainerPort`s
address

Attribute for accessing the address or hostname where published ports can be accessed.

Returns:Hostname or IP address
Return type:str
is_ready()[source]

Indicate whether or not the container is “ready” (up, available, running).

Returns:True if ready, else False
Rtpe:bool
map_port(port)[source]

Map a given container port to a host address/port.

For legacy reasons, if port is None, the first port (if any) will be returned

Parameters:port (int) – Container port to map
Returns:Mapping to host address/port for given container port
Return type:ContainerPort instance
class galaxy.containers.ContainerInterface(conf, key, containers_config_file)[source]

Bases: object

container_type = None
container_class = None
volume_class = None
conf_defaults = {'name_prefix': 'galaxy_'}
option_map = {}
publish_port_list_required = False
supports_volumes = True
__init__(conf, key, containers_config_file)[source]
key
containers_config_file
get_container(container_id)[source]
set_kwopts_name(kwopts)[source]
validate_config()[source]
run_in_container(command, image=None, **kwopts)[source]
class galaxy.containers.ContainerInterfaceConfig[source]

Bases: dict

get(name, default=None)[source]
galaxy.containers.build_container_interfaces(containers_config_file, containers_conf=None)[source]

Build ContainerInterface`s. Pass ``containers_conf` to avoid rereading the config file.

Parameters:
  • containers_config_file (str) – Filename of containers_conf.yml
  • containers_conf (dict) – Optional containers conf (as read from containers_conf.yml), will be used in place of containers_config_file
Returns:

Instantiated container interfaces with keys corresponding to containers keys

Return type:

dict of ContainerInterface subclass instances

galaxy.containers.parse_containers_config(containers_config_file)[source]

Parse a containers_conf.yml and return the contents of its containers dictionary.

Parameters:containers_config_file (str) – Filename of containers_conf.yml
Returns:Contents of the dictionary under the containers key
Return type:dict

Submodules

galaxy.containers.docker module

Interface to Docker

class galaxy.containers.docker.DockerInterface(conf, key, containers_config_file)[source]

Bases: galaxy.containers.ContainerInterface

container_class

alias of galaxy.containers.docker_model.DockerContainer

volume_class

alias of galaxy.containers.docker_model.DockerVolume

conf_defaults = {'auto_remove': True, 'cpus': None, 'force_tlsverify': False, 'host': None, 'image': None, 'memory': None, 'tls': False}
conf_run_kwopts = ('cpus', 'memory')
validate_config()[source]
run_in_container(command, image=None, **kwopts)[source]
image_repodigest(image)[source]

Get the digest image string for an image.

Parameters:image (str) – image id or image name and optionally, tag
Returns:digest string, having the format <name>@<hash_alg>:<digest>, e.g.: ‘bgruening/docker-jupyter-notebook@sha256:3ec0bc9abc9d511aa602ee4fff2534d80dd9b1564482de52cb5de36cce6debae’ or, the original image name if the digest cannot be determined (the image has not been pulled)
host
host_iter
class galaxy.containers.docker.DockerCLIInterface(conf, key, containers_config_file)[source]

Bases: galaxy.containers.docker.DockerInterface

container_type = 'docker_cli'
conf_defaults = {'command_template': '{executable} {global_kwopts} {subcommand} {args}', 'executable': 'docker'}
option_map = {'auto_remove': {'flag': '--rm', 'type': 'boolean'}, 'cpus': {'flag': '--cpus', 'type': 'string'}, 'detach': {'flag': '--detach', 'type': 'boolean'}, 'environment': {'flag': '--env', 'type': 'list_of_kvpairs'}, 'memory': {'flag': '--memory', 'type': 'string'}, 'name': {'flag': '--name', 'type': 'string'}, 'publish_all_ports': {'flag': '--publish-all', 'type': 'boolean'}, 'publish_port_random': {'flag': '--publish', 'type': 'string'}, 'volumes': {'flag': '--volume', 'type': 'docker_volumes'}}
validate_config()[source]
ps(*args, **kwargs)[source]
run(command, image=None, **kwopts)[source]
inspect(*args, **kwargs)[source]
image_inspect(*args, **kwargs)[source]
class galaxy.containers.docker.DockerAPIClient(*args, **kwargs)[source]

Bases: object

Wraps a docker.APIClient to catch exceptions.

__init__(*args, **kwargs)[source]
class galaxy.containers.docker.DockerAPIInterface(conf, key, containers_config_file)[source]

Bases: galaxy.containers.docker.DockerInterface

container_type = 'docker'
host_config_option_map = {'auto_remove': {}, 'binds': {}, 'cpus': {'map': <function <lambda> at 0x7efe490b6a28>, 'param': 'nano_cpus'}, 'memory': {'param': 'mem_limit'}, 'port_bindings': {}, 'publish_all_ports': {}}
validate_config()[source]
ps(id=None, name=None, running=True)[source]
run(command, image=None, **kwopts)[source]
inspect(container_id)[source]
image_inspect(image)[source]

galaxy.containers.docker_decorators module

Decorators for docker

galaxy.containers.docker_decorators.docker_columns(f)[source]
galaxy.containers.docker_decorators.docker_json(f)[source]

galaxy.containers.docker_model module

Model objects for docker objects

class galaxy.containers.docker_model.DockerAttributeContainer(members=None)[source]

Bases: object

__init__(members=None)[source]
members
hash()[source]
get(name, default)[source]
class galaxy.containers.docker_model.DockerVolume(path, host_path=None, mode=None)[source]

Bases: galaxy.containers.ContainerVolume

classmethod from_str(as_str)[source]

Construct an instance from a string as would be passed to docker run –volume.

A string in the format <host_path>:<mode> is supported for legacy purposes even though it is not valid Docker volume syntax.

to_native()[source]
class galaxy.containers.docker_model.DockerContainer(interface, id, name=None, inspect=None)[source]

Bases: galaxy.containers.Container

__init__(interface, id, name=None, inspect=None)[source]
classmethod from_id(interface, id)[source]
ports
address
is_ready()[source]
inspect
class galaxy.containers.docker_model.DockerService(interface, id, name=None, image=None, inspect=None)[source]

Bases: galaxy.containers.Container

__init__(interface, id, name=None, image=None, inspect=None)[source]
classmethod from_cli(interface, s, task_list)[source]
classmethod from_id(interface, id)[source]
ports
address
is_ready()[source]
task_add(task)[source]
inspect
state

If one of this service’s tasks desired state is running, return that task state, otherwise, return the state of a non-running task.

This is imperfect because it doesn’t attempt to provide useful information for replicas > 1 tasks, but it suits our purposes for now.

env
terminal

Same caveats as state().

node

Same caveats as state().

image
cpus
constraints
tasks

A list of all tasks, including terminal ones.

task_count

A count of all tasks, including terminal ones.

in_state(desired, current, tasks='any')[source]

Indicate if one of this service’s tasks matches the desired state.

constraint_add(name, op, value)[source]
set_cpus()[source]
set_image()[source]
class galaxy.containers.docker_model.DockerServiceConstraint(name=None, op=None, value=None)[source]

Bases: object

__init__(name=None, op=None, value=None)[source]
static split_constraint_string(constraint_str)[source]
classmethod from_str(constraint_str)[source]
name
op
value
label
class galaxy.containers.docker_model.DockerServiceConstraints(members=None)[source]

Bases: galaxy.containers.docker_model.DockerAttributeContainer

member_class

alias of DockerServiceConstraint

classmethod from_constraint_string_list(inspect)[source]
labels
class galaxy.containers.docker_model.DockerNode(interface, id=None, name=None, status=None, availability=None, manager=False, inspect=None)[source]

Bases: object

__init__(interface, id=None, name=None, status=None, availability=None, manager=False, inspect=None)[source]
classmethod from_cli(interface, n, task_list)[source]
classmethod from_id(interface, id)[source]
task_add(task)[source]
id
name
version
inspect
state
cpus
labels
label_add(label, value)[source]
labels_as_constraints
set_labels_for_constraints(constraints)[source]
tasks

A list of all tasks, including terminal ones.

non_terminal_tasks
task_count

A count of all tasks, including terminal ones.

in_state(status, availability)[source]
is_ok()[source]
is_managed()[source]
destroyable()[source]
drain()[source]
class galaxy.containers.docker_model.DockerNodeLabel(name=None, value=None)[source]

Bases: object

__init__(name=None, value=None)[source]
name
value
constraint_string
constraint
class galaxy.containers.docker_model.DockerNodeLabels(members=None)[source]

Bases: galaxy.containers.docker_model.DockerAttributeContainer

member_class

alias of DockerNodeLabel

classmethod from_label_dictionary(inspect)[source]
constraints
class galaxy.containers.docker_model.DockerTask(interface, id=None, name=None, image=None, desired_state=None, state=None, error=None, ports=None, service=None, node=None)[source]

Bases: object

terminal_states = ('shutdown', 'complete', 'failed', 'rejected', 'orphaned')
__init__(interface, id=None, name=None, image=None, desired_state=None, state=None, error=None, ports=None, service=None, node=None)[source]
classmethod from_cli(interface, t, service=None, node=None)[source]
classmethod from_api(interface, t, service=None, node=None)[source]
id
name
inspect
slot
node
service
cpus
state
current_state
current_state_time
desired_state
terminal
in_state(desired, current)[source]

galaxy.containers.docker_swarm module

Docker Swarm mode interface

class galaxy.containers.docker_swarm.DockerSwarmInterface(conf, key, containers_config_file)[source]

Bases: galaxy.containers.docker.DockerInterface

container_class

alias of galaxy.containers.docker_model.DockerService

conf_defaults = {'ignore_volumes': False, 'managed': True, 'manager_autostart': True, 'node_prefix': None, 'resolve_image_digest': False, 'service_create_cpus_constraint': False, 'service_create_image_constraint': False}
publish_port_list_required = True
supports_volumes = False
validate_config()[source]
run_in_container(command, image=None, **kwopts)[source]

Run a service like a detached container

services(id=None, name=None)[source]
service(id=None, name=None)[source]
services_in_state(desired, current, tasks='any')[source]
service_tasks(service)[source]
nodes(id=None, name=None)[source]
node(id=None, name=None)[source]
nodes_in_state(status, availability)[source]
node_tasks(node)[source]
services_waiting()[source]
services_waiting_by_constraints()[source]
services_completed()[source]
services_terminal()[source]
nodes_active()[source]
nodes_active_by_constraints()[source]
services_clean()[source]
class galaxy.containers.docker_swarm.DockerSwarmCLIInterface(conf, key, containers_config_file)[source]

Bases: galaxy.containers.docker_swarm.DockerSwarmInterface, galaxy.containers.docker.DockerCLIInterface

container_type = 'docker_swarm_cli'
option_map = {'availability': {'flag': '--availability', 'type': 'string'}, 'constraint': {'flag': '--constraint', 'type': 'list_of_kovtrips'}, 'cpu_limit': {'flag': '--limit-cpu', 'type': 'string'}, 'cpu_reservation': {'flag': '--reserve-cpu', 'type': 'string'}, 'environment': {'flag': '--env', 'type': 'list_of_kvpairs'}, 'label_add': {'flag': '--label-add', 'type': 'list_of_kvpairs'}, 'label_rm': {'flag': '--label-rm', 'type': 'list_of_kvpairs'}, 'mem_limit': {'flag': '--limit-memory', 'type': 'string'}, 'mem_reservation': {'flag': '--reserve-memory', 'type': 'string'}, 'name': {'flag': '--name', 'type': 'string'}, 'publish_port_random': {'flag': '--publish', 'type': 'string'}, 'replicas': {'flag': '--replicas', 'type': 'string'}, 'restart_condition': {'flag': '--restart-condition', 'type': 'string'}}
services(id=None, name=None)[source]
service_tasks(service)[source]
nodes(id=None, name=None)[source]
service_create(command, image=None, **kwopts)[source]
service_inspect(*args, **kwargs)[source]
service_ls(*args, **kwargs)[source]
service_ps(*args, **kwargs)[source]
service_rm(service_ids)[source]
node_inspect(*args, **kwargs)[source]
node_ls(*args, **kwargs)[source]
node_ps(*args, **kwargs)[source]
node_update(node_id, **kwopts)[source]
task_inspect(*args, **kwargs)[source]
class galaxy.containers.docker_swarm.DockerSwarmAPIInterface(conf, key, containers_config_file)[source]

Bases: galaxy.containers.docker_swarm.DockerSwarmInterface, galaxy.containers.docker.DockerAPIInterface

container_type = 'docker_swarm'
placement_option_map = {'constraint': {'param': 'constraints'}}
service_mode_option_map = {'replicas': {'default': 1}, 'service_mode': {'default': 'replicated', 'param': 0}}
endpoint_spec_option_map = {'ports': {}}
resources_option_map = {'cpus': {'map': <function <lambda> at 0x7efe1c887b90>, 'params': ('cpu_limit', 'cpu_reservation')}, 'memory': {'params': ('mem_limit', 'mem_reservation')}}
container_spec_option_map = {'command': {}, 'environment': {'param': 'env'}, 'image': {'param': 0}, 'labels': {}}
restart_policy_option_map = {'restart_condition': {'default': 'none', 'param': 'condition'}, 'restart_delay': {'param': 'delay'}, 'restart_max_attempts': {'param': 'max_attemps'}}
task_template_option_map = {'_container_spec': {'required': True, 'spec_class': None}, '_placement': {'spec_class': None}, '_resources': {'spec_class': None}, '_restart_policy': {'spec_class': None}}
node_spec_option_map = {'availability': {'param': 'Availability'}, 'labels': {'param': 'Labels'}, 'name': {'param': 'Name'}, 'role': {'param': 'Role'}}
static create_random_port_spec(port)[source]
service_create(command, image=None, **kwopts)[source]
service_inspect(service_id)[source]
service_ls(id=None, name=None)[source]
service_ps(service_id)[source]
service_rm(service_ids)[source]
node_inspect(node_id)[source]
node_ls(id=None, name=None)[source]
node_ps(node_id)[source]
node_update(node_id, **kwopts)[source]
task_inspect(task_id)[source]
task_ls(filters=None)[source]