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.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

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)

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 DockerContainer

conf_defaults = {'memory': None, 'host': None, 'force_tlsverify': False, 'image': None, 'cpus': None}

option_map = {'environment': {'flag': '--env', 'type': 'list_of_kvpairs'}, 'publish_all_ports': {'flag': '--publish-all', 'type': 'boolean'}, 'publish_port_random': {'flag': '--publish', 'type': 'string'}, 'name': {'flag': '--name', 'type': 'string'}, 'volumes': {'flag': '--volume', 'type': 'docker_volumes'}, 'memory': {'flag': '--memory', 'type': 'string'}, 'detach': {'flag': '--detach', 'type': 'boolean'}, 'cpus': {'flag': '--cpus', 'type': 'string'}}

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

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

Bases: galaxy.containers.docker.DockerInterface

container_type = 'docker_cli'

conf_defaults = {'executable': 'docker', 'command_template': '{executable} {global_kwopts} {subcommand} {args}'}

validate_config()

ps(*args, **kwargs)

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

inspect(*args, **kwargs)

image_inspect(*args, **kwargs)

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

Bases: galaxy.containers.docker.DockerCLIInterface

container_type = 'docker'

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.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(docker_interface, s, task_list)

classmethod from_id(interface, id)

ports

address

is_ready()

task_add(task)

inspect

state

Return the state of the first task in the service.

image

cpus

constraints

in_state(desired, current)

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)

Bases: object

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

classmethod from_cli(docker_interface, n, task_list)

task_add(task)

id

name

inspect

state

cpus

labels

label_add(label, value)

labels_as_constraints

set_labels_for_constraints(constraints)

tasks

task_count

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

__init__(interface, id=None, name=None, image=None, desired_state=None, state=None, error=None, ports=None, service=None, node=None)

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

id

name

inspect

cpus

state

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 DockerService

conf_defaults = {'node_prefix': None, 'service_create_cpus_constraint': False, 'service_create_image_constraint': False, 'ignore_volumes': False, 'manager_autostart': True, 'resolve_image_digest': False, 'managed': True}

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)

service_tasks(service)

nodes(id=None, name=None)

node(name)

nodes_in_state(status, availability)

services_waiting()

services_waiting_by_constraints()

services_completed()

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 = {'cpu_reservation': {'flag': '--reserve-cpu', 'type': 'string'}, 'label_rm': {'flag': '--label-rm', 'type': 'list_of_kvpairs'}, 'replicas': {'flag': '--replicas', 'type': 'string'}, 'label_add': {'flag': '--label-add', 'type': 'list_of_kvpairs'}, 'publish_port_random': {'flag': '--publish', 'type': 'string'}, 'cpu_limit': {'flag': '--limit-cpu', 'type': 'string'}, 'availability': {'flag': '--availability', 'type': 'string'}, 'restart_condition': {'flag': '--restart-condition', 'type': 'string'}, 'name': {'flag': '--name', 'type': 'string'}, 'constraint': {'flag': '--constraint', 'type': 'list_of_kovtrips'}, 'environment': {'flag': '--env', 'type': 'list_of_kvpairs'}, 'mem_limit': {'flag': '--limit-memory', 'type': 'string'}, 'mem_reservation': {'flag': '--reserve-memory', 'type': 'string'}}

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

Bases: object

__init__(conf, docker_interface)

run()

class galaxy.containers.docker_swarm_manager.SwarmState(conf, interface_conf)

Bases: object

__init__(conf, interface_conf)

slots_needed(waiting_services, active_nodes)

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)

get_limit(constraints, limit)

spawning_nodes()

nodes_requested(constraints, nodes)

mark_services_handled(services)

mark_spawning_node_ready(node_name)

mark_spawning_node_timeout(node_name)

mark_spawning_node_state(node_name, state)

is_destruction_time(node)

mark_node_idle(node_name)

clear_node_idle(node_name)

clean_services(services)

galaxy.containers.docker_swarm_manager.main(argv=None, fork=False)