Warning

This document is for an in-development version of Galaxy. You can alternatively view this page in the latest release if it exists or view the top of the latest release's documentation.

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 0x7fe8f4a95b18>, '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 0x7fe8f44671b8>, '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]