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[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.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
class galaxy.containers.ContainerInterface(conf, key, containers_config_file)[source]

Bases: object

container_type = None
container_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)[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

conf_defaults = {'cpus': None, 'force_tlsverify': False, 'host': None, 'image': None, 'memory': None}
option_map = {'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'}}
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
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'}
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.DockerAPIInterface(conf, key, containers_config_file)[source]

Bases: galaxy.containers.docker.DockerCLIInterface

container_type = 'docker'

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.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(docker_interface, s, task_list)[source]
classmethod from_id(interface, id)[source]
ports
address
is_ready()[source]
task_add(task)[source]
inspect
state

Return the state of the first task in the service.

image
cpus
constraints
in_state(desired, current)[source]
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)[source]

Bases: object

__init__(interface, id=None, name=None, status=None, availability=None, manager=False)[source]
classmethod from_cli(docker_interface, n, task_list)[source]
task_add(task)[source]
id
name
inspect
state
cpus
labels
label_add(label, value)[source]
labels_as_constraints
set_labels_for_constraints(constraints)[source]
tasks
task_count
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

__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(docker_interface, t, service=None, node=None)[source]
id
name
inspect
cpus
state
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)[source]
service_tasks(service)[source]
nodes(id=None, name=None)[source]
node(name)[source]
nodes_in_state(status, availability)[source]
services_waiting()[source]
services_waiting_by_constraints()[source]
services_completed()[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'}}
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.DockerSwarmCLIInterface

container_type = 'docker_swarm'

galaxy.containers.docker_swarm_manager module

Docker Swarm mode management

class galaxy.containers.docker_swarm_manager.SwarmManager(conf, docker_interface)[source]

Bases: object

__init__(conf, docker_interface)[source]
run()[source]
class galaxy.containers.docker_swarm_manager.SwarmState(conf, interface_conf)[source]

Bases: object

__init__(conf, interface_conf)[source]
slots_needed(waiting_services, active_nodes)[source]

Given a list of services waiting of each constraint set, and active nodes of each constraint set, return the number of slots needed of each constraint set if the maximum wait thresholds have been reached, constrained by the configured limits.

slots_delta(constraints, services, nodes)[source]
get_limit(constraints, limit)[source]
spawning_nodes()[source]
nodes_requested(constraints, nodes)[source]
mark_services_handled(services)[source]
mark_spawning_node_ready(node_name)[source]
mark_spawning_node_timeout(node_name)[source]
mark_spawning_node_state(node_name, state)[source]
is_destruction_time(node)[source]
mark_node_idle(node_name)[source]
clear_node_idle(node_name)[source]
clean_services(services)[source]
galaxy.containers.docker_swarm_manager.main(argv=None, fork=False)[source]