Warning

This document is for an old release 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

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)

Bases: object

valid_modes = frozenset(['ro', 'rw'])

__init__(path, host_path=None, mode=None)

from_str(as_str)

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

Parameters:as_str (str) – string representation of volume

to_native()

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

mode_is_valid

class galaxy.containers.Container(interface, id, name=None, **kwargs)

Bases: object

__init__(interface, id, name=None, **kwargs)

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)

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

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

Returns:True if ready, else False Rtpe:bool

map_port(port)

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)

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)

key

containers_config_file

get_container(container_id)

set_kwopts_name(kwopts)

validate_config()

run_in_container(command, image=None, **kwopts)

class galaxy.containers.ContainerInterfaceConfig

Bases: dict

get(name, default=None)

galaxy.containers.build_container_interfaces(containers_config_file, containers_conf=None)

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)

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)

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

run_in_container(command, image=None, **kwopts)

image_repodigest(image)

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)

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

ps(*args, **kwargs)

run(command, image=None, **kwopts)

inspect(*args, **kwargs)

image_inspect(*args, **kwargs)

class galaxy.containers.docker.DockerAPIClient(*args, **kwargs)

Bases: object

Wraps a docker.APIClient to catch exceptions.

__init__(*args, **kwargs)

class galaxy.containers.docker.DockerAPIInterface(conf, key, containers_config_file)

Bases: galaxy.containers.docker.DockerInterface

container_type = 'docker'

host_config_option_map = {'auto_remove': {}, 'binds': {}, 'cpus': {'map': <function <lambda> at 0x7fbb29abaed8>, 'param': 'nano_cpus'}, 'memory': {'param': 'mem_limit'}, 'port_bindings': {}, 'publish_all_ports': {}}

validate_config()

ps(id=None, name=None, running=True)

run(command, image=None, **kwopts)

inspect(container_id)

image_inspect(image)

galaxy.containers.docker_decorators module

Decorators for docker

galaxy.containers.docker_decorators.docker_columns(f)

galaxy.containers.docker_decorators.docker_json(f)

galaxy.containers.docker_model module

Model objects for docker objects

class galaxy.containers.docker_model.DockerAttributeContainer(members=None)

Bases: object

__init__(members=None)

members

hash()

get(name, default)

class galaxy.containers.docker_model.DockerVolume(path, host_path=None, mode=None)

Bases: galaxy.containers.ContainerVolume

classmethod from_str(as_str)

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

class galaxy.containers.docker_model.DockerContainer(interface, id, name=None, inspect=None)

Bases: galaxy.containers.Container

__init__(interface, id, name=None, inspect=None)

classmethod from_id(interface, id)

ports

address

is_ready()

inspect

class galaxy.containers.docker_model.DockerService(interface, id, name=None, image=None, inspect=None)

Bases: galaxy.containers.Container

__init__(interface, id, name=None, image=None, inspect=None)

classmethod from_cli(interface, s, task_list)

classmethod from_id(interface, id)

ports

address

is_ready()

task_add(task)

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

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

constraint_add(name, op, value)

set_cpus()

set_image()

class galaxy.containers.docker_model.DockerServiceConstraint(name=None, op=None, value=None)

Bases: object

__init__(name=None, op=None, value=None)

static split_constraint_string(constraint_str)

classmethod from_str(constraint_str)

name

op

value

label

class galaxy.containers.docker_model.DockerServiceConstraints(members=None)

Bases: galaxy.containers.docker_model.DockerAttributeContainer

member_class

alias of DockerServiceConstraint

classmethod from_constraint_string_list(inspect)

labels

class galaxy.containers.docker_model.DockerNode(interface, id=None, name=None, status=None, availability=None, manager=False, inspect=None)

Bases: object

__init__(interface, id=None, name=None, status=None, availability=None, manager=False, inspect=None)

classmethod from_cli(interface, n, task_list)

classmethod from_id(interface, id)

task_add(task)

id

name

version

inspect

state

cpus

labels

label_add(label, value)

labels_as_constraints

set_labels_for_constraints(constraints)

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)

is_ok()

is_managed()

destroyable()

drain()

class galaxy.containers.docker_model.DockerNodeLabel(name=None, value=None)

Bases: object

__init__(name=None, value=None)

name

value

constraint_string

constraint

class galaxy.containers.docker_model.DockerNodeLabels(members=None)

Bases: galaxy.containers.docker_model.DockerAttributeContainer

member_class

alias of DockerNodeLabel

classmethod from_label_dictionary(inspect)

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)

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)

classmethod from_cli(interface, t, service=None, node=None)

classmethod from_api(interface, t, service=None, node=None)

id

name

inspect

slot

node

service

cpus

state

current_state

current_state_time

desired_state

terminal

in_state(desired, current)

galaxy.containers.docker_swarm module

Docker Swarm mode interface

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

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

run_in_container(command, image=None, **kwopts)

Run a service like a detached container

services(id=None, name=None)

service(id=None, name=None)

services_in_state(desired, current, tasks='any')

service_tasks(service)

nodes(id=None, name=None)

node(id=None, name=None)

nodes_in_state(status, availability)

node_tasks(node)

services_waiting()

services_waiting_by_constraints()

services_completed()

services_terminal()

nodes_active()

nodes_active_by_constraints()

services_clean()

class galaxy.containers.docker_swarm.DockerSwarmCLIInterface(conf, key, containers_config_file)

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)

service_tasks(service)

nodes(id=None, name=None)

service_create(command, image=None, **kwopts)

service_inspect(*args, **kwargs)

service_ls(*args, **kwargs)

service_ps(*args, **kwargs)

service_rm(service_ids)

node_inspect(*args, **kwargs)

node_ls(*args, **kwargs)

node_ps(*args, **kwargs)

node_update(node_id, **kwopts)

task_inspect(*args, **kwargs)

class galaxy.containers.docker_swarm.DockerSwarmAPIInterface(conf, key, containers_config_file)

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 0x7fbb26e797d0>, '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)

service_create(command, image=None, **kwopts)

service_inspect(service_id)

service_ls(id=None, name=None)

service_ps(service_id)

service_rm(service_ids)

node_inspect(node_id)

node_ls(id=None, name=None)

node_ps(node_id)

node_update(node_id, **kwopts)

task_inspect(task_id)

task_ls(filters=None)