9i d dl Z d dlZd dlmZ ddlmZ ddlmZ ddlm Z m
Z
m Z m Z m
Z
ddlmZmZ ddlmZ d d
lmZ d d lmZmZ G d d
e Z G d de Zg dZg dZd Z d Z edd Z y) N)
namedtuple ) APIClient)DEFAULT_DATA_CHUNK_SIZE)ContainerErrorDockerException
ImageNotFoundNotFound create_unexpected_kwargs_error)
HostConfigNetworkingConfig) version_gte )Image)
CollectionModelc
e Zd ZdZed Zed Zed Zed Zed Z ed Z
d Z d Z d d Z
d Z d!dZefdZed
fdZd"dZd Zd Zd Zd Zd Zd Zd Zd Zd Z d Z d Z d Z d Z d Z!y
)# ContaineraI Local representation of a container object. Detailed configuration may
be accessed through the :py:attr:`attrs` attribute. Note that local
attributes are cached; users may call :py:meth:`reload` to
query the Docker daemon for the current properties, causing
:py:attr:`attrs` to be refreshed.
c v | j j d | j d j d S y)z,
The name of the container.
NameN/)attrsgetlstripselfs Y/home/factor_ks/STREAMA2026/venv/lib/python3.12/site-packages/docker/models/containers.pynamezContainer.name s6
::>>& ! -::f%,,S1 1 . c | j j d| j d }|y| j j j |j d d S )z-
The image of the container.
ImageIDr N:r )r r clientimagessplit)r image_ids r imagezContainer.image$ sS
::>>)TZZ-@A {{!!%%hnnS&9!&<==r c | j d j d }|xs i S # t $ r}t d |d}~ww xY w)z:
The labels of a container as dictionary.
ConfigLabelszYLabel data is not available for sparse objects. Call reload() to retrieve all informationN)r r KeyErrorr )r resultkes r labelszContainer.labels. sQ
ZZ)--h7F`_
for full details.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)
repositorytagId)r# r? commitrA r$ r )r rG rH rC resps r rJ zContainer.commit sT , &t{{%%dgg 0*# 0(.0{{!!%%d4j11r c ` | j j j | j S )a'
Inspect changes on a container's filesystem.
Returns:
(list) A list of dictionaries containing the attributes `Path`
and `Kind`.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? diffrA r s r rM zContainer.diff s! {{##DGG,,r Fc Z | j j j | j |||||||| |
}| j j j |d ||| |
|
}|
s| r t d| S t | j j j
|d d | S )a1
Run a command inside this container. Similar to
``docker exec``.
Args:
cmd (str or list): Command to be executed
stdout (bool): Attach to stdout. Default: ``True``
stderr (bool): Attach to stderr. Default: ``True``
stdin (bool): Attach to stdin. Default: ``False``
tty (bool): Allocate a pseudo-TTY. Default: False
privileged (bool): Run as privileged.
user (str): User to execute command as. Default: root
detach (bool): If true, detach from the exec command.
Default: False
stream (bool): Stream response data. Default: False
socket (bool): Return the connection socket to allow custom
read/write operations. Default: False
environment (dict or list): A dictionary or a list of strings in
the following format ``["PASSWORD=xxx"]`` or
``{"PASSWORD": "xxx"}``.
workdir (str): Path to working directory for this exec session
demux (bool): Return stdout and stderr separately
Returns:
(ExecResult): A tuple of (exit_code, output)
exit_code: (int):
Exit code for the executed command or ``None`` if
either ``stream`` or ``socket`` is ``True``.
output: (generator, bytes, or tuple):
If ``stream=True``, a generator yielding response chunks.
If ``socket=True``, a socket object for the connection.
If ``demux=True``, a tuple of two bytes: stdout and stderr.
A bytestring containing response data otherwise.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)stdoutstderrstdintty
privilegeduser environmentworkdirrI )detachrR streamsocketdemuxNExitCode)r# r? exec_createrA
exec_start
ExecResult exec_inspect)r cmdrO rP rQ rR rS rT rW rX rY rU rV rZ rK exec_outputs r exec_runzContainer.exec_run s R {{** GGSe!+ +
kkoo00 Jv3vf 1
V dK0 0 KKOO ( (d 4Z @
r c b | j j j | j | S )a
Export the contents of the container's filesystem as a tar archive.
Args:
chunk_size (int): The number of bytes returned by each iteration
of the generator. If ``None``, data will be streamed as it is
received. Default: 2 MB
Returns:
(str): The filesystem tar archive
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? exportrA )r
chunk_sizes r rd zContainer.export s# {{%%dggz::r c f | j j j | j ||| S )a
Retrieve a file or folder from the container in the form of a tar
archive.
Args:
path (str): Path to the file or folder to retrieve
chunk_size (int): The number of bytes returned by each iteration
of the generator. If ``None``, data will be streamed as it is
received. Default: 2 MB
encode_stream (bool): Determines if data should be encoded
(gzip-compressed) during transmission. Default: False
Returns:
(tuple): First element is a raw tar data stream. Second element is
a dict containing ``stat`` information on the specified ``path``.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
Example:
>>> f = open('./sh_bin.tar', 'wb')
>>> bits, stat = container.get_archive('/bin/sh')
>>> print(stat)
{'name': 'sh', 'size': 1075464, 'mode': 493,
'mtime': '2018-10-01T15:37:48-07:00', 'linkTarget': ''}
>>> for chunk in bits:
... f.write(chunk)
>>> f.close()
)r# r? get_archiverA )r pathre
encode_streams r rg zContainer.get_archive s/ B {{**477D+5}F Fr c d | j j j | j | S )a
Kill or send a signal to the container.
Args:
signal (str or int): The signal to send. Defaults to ``SIGKILL``
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)signal)r# r? killrA )r rk s r rl zContainer.kill s& {{##DGGF#;;r c d | j j j | j fi |S )a
Get logs from this container. Similar to the ``docker logs`` command.
The ``stream`` parameter makes the ``logs`` function return a blocking
generator you can iterate over to retrieve log output as it happens.
Args:
stdout (bool): Get ``STDOUT``. Default ``True``
stderr (bool): Get ``STDERR``. Default ``True``
stream (bool): Stream the response. Default ``False``
timestamps (bool): Show timestamps. Default ``False``
tail (str or int): Output specified number of lines at the end of
logs. Either an integer of number of lines or the string
``all``. Default ``all``
since (datetime, int, or float): Show logs since a given datetime,
integer epoch (in seconds) or float (in nanoseconds)
follow (bool): Follow log output. Default ``False``
until (datetime, int, or float): Show logs that occurred before
the given datetime, integer epoch (in seconds), or
float (in nanoseconds)
Returns:
(generator of bytes or bytes): Logs from the container.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? logsrA rB s r rn zContainer.logs% s( : $t{{##DGG6v66r c ` | j j j | j S )z
Pauses all processes within this container.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? pauserA r s r rp zContainer.pauseD s! {{$$TWW--r c d | j j j | j || S )a
Insert a file or folder in this container using a tar archive as
source.
Args:
path (str): Path inside the container where the file(s) will be
extracted. Must exist.
data (bytes or stream): tar data to be extracted
Returns:
(bool): True if the call succeeds.
Raises:
:py:class:`~docker.errors.APIError` If an error occurs.
)r# r? put_archiverA )r rh datas r rr zContainer.put_archiveN s% {{**477D$??r c d | j j j | j fi |S )a
Remove this container. Similar to the ``docker rm`` command.
Args:
v (bool): Remove the volumes associated with the container
link (bool): Remove the specified link and not the underlying
container
force (bool): Force the removal of a running container (uses
``SIGKILL``)
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? remove_containerrA rB s r removezContainer.remove` s( 0t{{//B6BBr c b | j j j | j | S )a
Rename this container. Similar to the ``docker rename`` command.
Args:
name (str): New name for the container
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? renamerA )r r s r rx zContainer.renameq s# {{%%dggt44r c d | j j j | j || S )a
Resize the tty session.
Args:
height (int): Height of tty session
width (int): Width of tty session
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? resizerA )r heightwidths r rz zContainer.resize~ s% {{%%dggvu==r c d | j j j | j fi |S )a
Restart this container. Similar to the ``docker restart`` command.
Args:
timeout (int): Number of seconds to try to stop for before killing
the container. Once killed it will then be restarted. Default
is 10 seconds.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? restartrA rB s r r~ zContainer.restart s( 't{{&&tww9&99r c d | j j j | j fi |S )z
Start this container. Similar to the ``docker start`` command, but
doesn't support attach options.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? startrA rB s r r zContainer.start s( %t{{$$TWW777r c d | j j j | j fi |S )a#
Stream statistics for this container. Similar to the
``docker stats`` command.
Args:
decode (bool): If set to true, stream will be decoded into dicts
on the fly. Only applicable if ``stream`` is True.
False by default.
stream (bool): If set to false, only the current stats will be
returned instead of a stream. True by default.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? statsrA rB s r r zContainer.stats s( %t{{$$TWW777r c d | j j j | j fi |S )aU
Stops a container. Similar to the ``docker stop`` command.
Args:
timeout (int): Timeout in seconds to wait for the container to
stop before sending a ``SIGKILL``. Default: 10
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? stoprA rB s r r zContainer.stop s( $t{{##DGG6v66r c d | j j j | j fi |S )aH
Display the running processes of the container.
Args:
ps_args (str): An optional arguments passed to ps (e.g. ``aux``)
Returns:
(str): The output of the top
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? toprA rB s r r z
Container.top s( #t{{""4775f55r c ` | j j j | j S )z
Unpause all processes within the container.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? unpauserA r s r r zContainer.unpause s! {{&&tww//r c d | j j j | j fi |S )a
Update resource configuration of the containers.
Args:
blkio_weight (int): Block IO (relative weight), between 10 and 1000
cpu_period (int): Limit CPU CFS (Completely Fair Scheduler) period
cpu_quota (int): Limit CPU CFS (Completely Fair Scheduler) quota
cpu_shares (int): CPU shares (relative weight)
cpuset_cpus (str): CPUs in which to allow execution
cpuset_mems (str): MEMs in which to allow execution
mem_limit (int or str): Memory limit
mem_reservation (int or str): Memory soft limit
memswap_limit (int or str): Total memory (memory + swap), -1 to
disable swap
kernel_memory (int or str): Kernel memory limit
restart_policy (dict): Restart policy dictionary
Returns:
(dict): Dictionary containing a ``Warnings`` key.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? update_containerrA rB s r updatezContainer.update s( 2 0t{{//B6BBr c d | j j j | j fi |S )a
Block until the container stops, then return its exit code. Similar to
the ``docker wait`` command.
Args:
timeout (int): Request timeout
condition (str): Wait until a container state reaches the given
condition, either ``not-running`` (default), ``next-exit``,
or ``removed``
Returns:
(dict): The API's response as a Python dictionary, including
the container's exit code under the ``StatusCode`` attribute.
Raises:
:py:class:`requests.exceptions.ReadTimeout`
If the timeout is exceeded.
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? waitrA rB s r r zContainer.wait s( * $t{{##DGG6v66r )NN) TTFFF FFFNNFN)"__name__
__module__ __qualname____doc__propertyr r' r. r4 r9 r= r@ rE rJ rM rb r rd rg rl rn rp rr rv rx rz r~ r r r r r r r r r r r s 2 2 > > # # V V F F 94@ 24 - HMAFEJ8
t !8 ;$ ,C"'"FH < 7>.@$C" 5 >
: 88$ 7 6 0C67r r c t e Zd ZeZ ddZddZd Z d dZddZ e
j j e _ y)
ContainerCollectionNc * t |t r |j }|j dd }|j dd }|j dd } |r=|r;t | j j j d rd|d< n t d |j d
r |j d r t d |j d
r |j d
s t d | j d|||d|}
|
j |r|
S |
j d d d } d} | dk( s| dk( r|
j! ||dd } |
j# d }
|
dk7 r&d} |j d s|
j! dd } |r|
j% |
dk7 rt' |
|
||| |s| | S dj) | S # t $ rA | j j j || | j d|||d|}
Y w xY w) aA
Run a container. By default, it will wait for the container to finish
and return its logs, similar to ``docker run``.
If the ``detach`` argument is ``True``, it will start the container
and immediately return a :py:class:`Container` object, similar to
``docker run -d``.
Example:
Run a container and get its output:
>>> import docker
>>> client = docker.from_env()
>>> client.containers.run('alpine', 'echo hello world')
b'hello world\n'
Run a container and detach:
>>> container = client.containers.run('bfirsh/reticulate-splines',
detach=True)
>>> container.logs()
'Reticulating spline 1...\nReticulating spline 2...\n'
Args:
image (str): The image to run.
command (str or list): The command to run in the container.
auto_remove (bool): enable auto-removal of the container on daemon
side when the container's process exits.
blkio_weight_device: Block IO weight (relative device weight) in
the form of: ``[{"Path": "device_path", "Weight": weight}]``.
blkio_weight: Block IO weight (relative weight), accepts a weight
value between 10 and 1000.
cap_add (list of str): Add kernel capabilities. For example,
``["SYS_ADMIN", "MKNOD"]``.
cap_drop (list of str): Drop kernel capabilities.
cgroup_parent (str): Override the default parent cgroup.
cgroupns (str): Override the default cgroup namespace mode for the
container. One of:
- ``private`` the container runs in its own private cgroup
namespace.
- ``host`` use the host system's cgroup namespace.
cpu_count (int): Number of usable CPUs (Windows only).
cpu_percent (int): Usable percentage of the available CPUs
(Windows only).
cpu_period (int): The length of a CPU period in microseconds.
cpu_quota (int): Microseconds of CPU time that the container can
get in a CPU period.
cpu_rt_period (int): Limit CPU real-time period in microseconds.
cpu_rt_runtime (int): Limit CPU real-time runtime in microseconds.
cpu_shares (int): CPU shares (relative weight).
cpuset_cpus (str): CPUs in which to allow execution (``0-3``,
``0,1``).
cpuset_mems (str): Memory nodes (MEMs) in which to allow execution
(``0-3``, ``0,1``). Only effective on NUMA systems.
detach (bool): Run container in the background and return a
:py:class:`Container` object.
device_cgroup_rules (:py:class:`list`): A list of cgroup rules to
apply to the container.
device_read_bps: Limit read rate (bytes per second) from a device
in the form of: `[{"Path": "device_path", "Rate": rate}]`
device_read_iops: Limit read rate (IO per second) from a device.
device_write_bps: Limit write rate (bytes per second) from a
device.
device_write_iops: Limit write rate (IO per second) from a device.
devices (:py:class:`list`): Expose host devices to the container,
as a list of strings in the form
``::``.
For example, ``/dev/sda:/dev/xvda:rwm`` allows the container
to have read-write access to the host's ``/dev/sda`` via a
node named ``/dev/xvda`` inside the container.
device_requests (:py:class:`list`): Expose host resources such as
GPUs to the container, as a list of
:py:class:`docker.types.DeviceRequest` instances.
dns (:py:class:`list`): Set custom DNS servers.
dns_opt (:py:class:`list`): Additional options to be added to the
container's ``resolv.conf`` file.
dns_search (:py:class:`list`): DNS search domains.
domainname (str or list): Set custom DNS search domains.
entrypoint (str or list): The entrypoint for the container.
environment (dict or list): Environment variables to set inside
the container, as a dictionary or a list of strings in the
format ``["SOMEVARIABLE=xxx"]``.
extra_hosts (dict): Additional hostnames to resolve inside the
container, as a mapping of hostname to IP address.
group_add (:py:class:`list`): List of additional group names and/or
IDs that the container process will run as.
healthcheck (dict): Specify a test to perform to check that the
container is healthy. The dict takes the following keys:
- test (:py:class:`list` or str): Test to perform to determine
container health. Possible values:
- Empty list: Inherit healthcheck from parent image
- ``["NONE"]``: Disable healthcheck
- ``["CMD", args...]``: exec arguments directly.
- ``["CMD-SHELL", command]``: Run command in the system's
default shell.
If a string is provided, it will be used as a ``CMD-SHELL``
command.
- interval (int): The time to wait between checks in
nanoseconds. It should be 0 or at least 1000000 (1 ms).
- timeout (int): The time to wait before considering the check
to have hung. It should be 0 or at least 1000000 (1 ms).
- retries (int): The number of consecutive failures needed to
consider a container as unhealthy.
- start_period (int): Start period for the container to
initialize before starting health-retries countdown in
nanoseconds. It should be 0 or at least 1000000 (1 ms).
hostname (str): Optional hostname for the container.
init (bool): Run an init inside the container that forwards
signals and reaps processes
init_path (str): Path to the docker-init binary
ipc_mode (str): Set the IPC mode for the container.
isolation (str): Isolation technology to use. Default: `None`.
kernel_memory (int or str): Kernel memory limit
labels (dict or list): A dictionary of name-value labels (e.g.
``{"label1": "value1", "label2": "value2"}``) or a list of
names of labels to set with empty values (e.g.
``["label1", "label2"]``)
links (dict): Mapping of links using the
``{'container': 'alias'}`` format. The alias is optional.
Containers declared in this dict will be linked to the new
container using the provided alias. Default: ``None``.
log_config (LogConfig): Logging configuration.
lxc_conf (dict): LXC config.
mac_address (str): MAC address to assign to the container.
mem_limit (int or str): Memory limit. Accepts float values
(which represent the memory limit of the created container in
bytes) or a string with a units identification char
(``100000b``, ``1000k``, ``128m``, ``1g``). If a string is
specified without a units character, bytes are assumed as an
intended unit.
mem_reservation (int or str): Memory soft limit.
mem_swappiness (int): Tune a container's memory swappiness
behavior. Accepts number between 0 and 100.
memswap_limit (str or int): Maximum amount of memory + swap a
container is allowed to consume.
mounts (:py:class:`list`): Specification for mounts to be added to
the container. More powerful alternative to ``volumes``. Each
item in the list is expected to be a
:py:class:`docker.types.Mount` object.
name (str): The name for this container.
nano_cpus (int): CPU quota in units of 1e-9 CPUs.
network (str): Name of the network this container will be connected
to at creation time. You can connect to additional networks
using :py:meth:`Network.connect`. Incompatible with
``network_mode``.
network_disabled (bool): Disable networking.
network_mode (str): One of:
- ``bridge`` Create a new network stack for the container on
the bridge network.
- ``none`` No networking for this container.
- ``container:`` Reuse another container's network
stack.
- ``host`` Use the host network stack.
This mode is incompatible with ``ports``.
Incompatible with ``network``.
networking_config (Dict[str, EndpointConfig]):
Dictionary of EndpointConfig objects for each container network.
The key is the name of the network.
Defaults to ``None``.
Used in conjuction with ``network``.
Incompatible with ``network_mode``.
oom_kill_disable (bool): Whether to disable OOM killer.
oom_score_adj (int): An integer value containing the score given
to the container in order to tune OOM killer preferences.
pid_mode (str): If set to ``host``, use the host PID namespace
inside the container.
pids_limit (int): Tune a container's pids limit. Set ``-1`` for
unlimited.
platform (str): Platform in the format ``os[/arch[/variant]]``.
Only used if the method needs to pull the requested image.
ports (dict): Ports to bind inside the container.
The keys of the dictionary are the ports to bind inside the
container, either as an integer or a string in the form
``port/protocol``, where the protocol is either ``tcp``,
``udp``, or ``sctp``.
The values of the dictionary are the corresponding ports to
open on the host, which can be either:
- The port number, as an integer. For example,
``{'2222/tcp': 3333}`` will expose port 2222 inside the
container as port 3333 on the host.
- ``None``, to assign a random host port. For example,
``{'2222/tcp': None}``.
- A tuple of ``(address, port)`` if you want to specify the
host interface. For example,
``{'1111/tcp': ('127.0.0.1', 1111)}``.
- A list of integers, if you want to bind multiple host ports
to a single container port. For example,
``{'1111/tcp': [1234, 4567]}``.
Incompatible with ``host`` network mode.
privileged (bool): Give extended privileges to this container.
publish_all_ports (bool): Publish all ports to the host.
read_only (bool): Mount the container's root filesystem as read
only.
remove (bool): Remove the container when it has finished running.
Default: ``False``.
restart_policy (dict): Restart the container when it exits.
Configured as a dictionary with keys:
- ``Name`` One of ``on-failure``, or ``always``.
- ``MaximumRetryCount`` Number of times to restart the
container on failure.
For example:
``{"Name": "on-failure", "MaximumRetryCount": 5}``
runtime (str): Runtime to use with this container.
security_opt (:py:class:`list`): A list of string values to
customize labels for MLS systems, such as SELinux.
shm_size (str or int): Size of /dev/shm (e.g. ``1G``).
stdin_open (bool): Keep ``STDIN`` open even if not attached.
stdout (bool): Return logs from ``STDOUT`` when ``detach=False``.
Default: ``True``.
stderr (bool): Return logs from ``STDERR`` when ``detach=False``.
Default: ``False``.
stop_signal (str): The stop signal to use to stop the container
(e.g. ``SIGINT``).
storage_opt (dict): Storage driver options per container as a
key-value mapping.
stream (bool): If true and ``detach`` is false, return a log
generator instead of a string. Ignored if ``detach`` is true.
Default: ``False``.
sysctls (dict): Kernel parameters to set in the container.
tmpfs (dict): Temporary filesystems to mount, as a dictionary
mapping a path inside the container to options for that path.
For example:
.. code-block:: python
{
'/mnt/vol2': '',
'/mnt/vol1': 'size=3G,uid=1000'
}
tty (bool): Allocate a pseudo-TTY.
ulimits (:py:class:`list`): Ulimits to set inside the container,
as a list of :py:class:`docker.types.Ulimit` instances.
use_config_proxy (bool): If ``True``, and if the docker client
configuration file (``~/.docker/config.json`` by default)
contains a proxy configuration, the corresponding environment
variables will be set in the container being built.
user (str or int): Username or UID to run commands as inside the
container.
userns_mode (str): Sets the user namespace mode for the container
when user namespace remapping option is enabled. Supported
values are: ``host``
uts_mode (str): Sets the UTS namespace mode for the container.
Supported values are: ``host``
version (str): The version of the API to use. Set to ``auto`` to
automatically detect the server's version. Default: ``1.35``
volume_driver (str): The name of a volume driver/plugin.
volumes (dict or list): A dictionary to configure volumes mounted
inside the container. The key is either the host path or a
volume name, and the value is a dictionary with the keys:
- ``bind`` The path to mount the volume inside the container
- ``mode`` Either ``rw`` to mount the volume read/write, or
``ro`` to mount it read-only.
For example:
.. code-block:: python
{'/home/user1/': {'bind': '/mnt/vol2', 'mode': 'rw'},
'/var/www': {'bind': '/mnt/vol1', 'mode': 'ro'}}
Or a list of strings which each one of its elements specifies a
mount volume.
For example:
.. code-block:: python
['/home/user1/:/mnt/vol2','/var/www:/mnt/vol1']
volumes_from (:py:class:`list`): List of container names or IDs to
get volumes from.
working_dir (str): Path to the working directory.
Returns:
The container logs, either ``STDOUT``, ``STDERR``, or both,
depending on the value of the ``stdout`` and ``stderr`` arguments.
``STDOUT`` and ``STDERR`` may be read only if either ``json-file``
or ``journald`` logging driver used. Thus, if you are using none of
these drivers, a ``None`` object is returned instead. See the
`Engine API documentation
`_
for full details.
If ``detach`` is ``True``, a :py:class:`Container` object is
returned instead.
Raises:
:py:class:`docker.errors.ContainerError`
If the container exits with a non-zero exit code and
``detach`` is ``False``.
:py:class:`docker.errors.ImageNotFound`
If the specified image does not exist.
:py:class:`docker.errors.APIError`
If the server returns an error.
rX FrW platformNz1.25T auto_removezQThe options 'detach' and 'remove' cannot be used together in api versions < 1.25.network network_modezBThe options "network" and "network_mode" can not be used together.networking_configzAThe option "networking_config" can not be used without "network".)r' commandrW )r r LogConfigTypez json-filejournald)rO rP rX follow
StatusCoder )rO rP r r )r2 r rA popr r r# r? _version RuntimeErrorcreater r$ pullr r rn r rv r join)r r' r rO rP rv rC rX rW r containerlogging_driverout exit_statuss r runzContainerCollection.run s= x eU #HHEHe,He,::j$/ f4;;??33V<(,}%" $N O O ::i VZZ%?
::) *6::i3H %
=# =%+1=5;=I " 6{CFK [ (Nj,H.. fT$ ! C nn&|4 ! C::m, nnE$n? ! ;
S[Jxx} C = KK # #EH # =# =%+1=5;=I =s -G AHHc t |t r |j }||d< ||d< | j j j
|d< t
| } | j j j di |}| j |d S )a
Create a container without starting it. Similar to ``docker create``.
Takes the same arguments as :py:meth:`run`, except for ``stdout``,
``stderr``, and ``remove``.
Returns:
A :py:class:`Container` object.
Raises:
:py:class:`docker.errors.ImageNotFound`
If the specified image does not exist.
:py:class:`docker.errors.APIError`
If the server returns an error.
r' r versionrI r ) r2 r rA r# r? r _create_container_argscreate_containerr )r r' r rC
create_kwargsrK s r r zContainerCollection.create s| eU #HHE w #y KKOO 4 4y.v6
/t{{//@-@xxT
##r c n | j j j | }| j | S )a
Get a container by name or ID.
Args:
container_id (str): Container name or ID.
Returns:
A :py:class:`Container` object.
Raises:
:py:class:`docker.errors.NotFound`
If the container does not exist.
:py:class:`docker.errors.APIError`
If the server returns an error.
)r# r? inspect_container
prepare_model)r container_idrK s r r zContainerCollection.get s- {{00 >!!$''r c $ | j j j ||||| }|r |D cg c] } | j | c} S g }
|D ]& } |
j | j | d ( |
S c c} w # t $ r |s Y >w xY w)af
List containers. Similar to the ``docker ps`` command.
Args:
all (bool): Show all containers. Only running containers are shown
by default
since (str): Show only containers created since Id or Name, include
non-running ones
before (str): Show only container created before Id or Name,
include non-running ones
limit (int): Show `limit` last created containers, include
non-running ones
filters (dict): Filters to be processed on the image list.
Available filters:
- `exited` (int): Only containers with specified exit code
- `status` (str): One of ``restarting``, ``running``,
``paused``, ``exited``
- `label` (str|list): format either ``"key"``, ``"key=value"``
or a list of such.
- `id` (str): The id of the container.
- `name` (str): The name of the container.
- `ancestor` (str): Filter by container ancestor. Format of
``[:tag]``, ````, or
````.
- `before` (str): Only containers created before a particular
container. Give the container name or id.
- `since` (str): Only containers created after a particular
container. Give container name or id.
A comprehensive list can be found in the documentation for
`docker ps
`_.
sparse (bool): Do not inspect containers. Returns partial
information, but guaranteed not to block. Use
:py:meth:`Container.reload` on resulting objects to retrieve
all attributes. Default: ``False``
ignore_removed (bool): Ignore failures due to missing containers
when attempting to inspect containers from the original list.
Set to ``True`` if race conditions are likely. Has no effect
if ``sparse=True``. Default: ``False``
Returns:
(list of :py:class:`Container`)
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)allbeforefilterslimitsincerI )r# r?
containersr appendr r
) r r r r r r sparseignore_removedrK rr s r listzContainerCollection.list s h {{))c&2905 * 7 378aD&&q)8 8J
%%dhhqw&78
9 ) * s A;#B BBc N | j j j | S )N)r )r# r? prune_containers)r r s r prunezContainerCollection.prune s {{///@@r )NTFFr )FNNNFF)
r r r r modelr r r r r r r r r r r r r sJ E;@y v $2(& JN*/B HA ..66EMr r )r rW
domainname
entrypointrU healthcheckhostnamer' r. mac_addressr network_disabledr
stdin_open stop_signalrR use_config_proxyrT working_dir)?r blkio_weight_device blkio_weightcap_addcap_drop
cgroup_parentcgroupns cpu_count cpu_percent
cpu_period cpu_quota
cpu_shares cpuset_cpus cpuset_mems
cpu_rt_periodcpu_rt_runtimedevice_cgroup_rulesdevice_read_bpsdevice_read_iopsdevice_write_bpsdevice_write_iopsdevicesdevice_requestsdns_opt
dns_searchdns extra_hosts group_addinit init_pathipc_mode isolation
kernel_memorylinks
log_configlxc_conf mem_limitmem_reservationmem_swappiness
memswap_limitmounts nano_cpusr oom_kill_disable
oom_score_adjpid_mode
pids_limitrS publish_all_ports read_onlyrestart_policy security_optshm_size storage_optsysctlstmpfsulimits userns_modeuts_moder
volume_driver volumes_fromruntimec i }t j | D ] }|t v s | j | ||< ! i }t j | D ] }|t v s | j | ||< ! | j di }|r||d< | j di }|r||d< | j dd }| j dd }|r!|r||vrd}|r t | n|di|d< ||d< | r t d | t
di ||d
< |d
j d }|rCt |j D cg c] } t | j d d
c} |d< |r^t |t r2|j D
cg c] }
|
j d c}
|d< |S |D
cg c]
}
t |
c}
|d< |S c c} w c c}
w c c}
w )zK
Convert arguments to create() to arguments to create_container().
r=
port_bindingsvolumesbindsr Nr r r host_config PortBindingsr r bindr )copyRUN_CREATE_KWARGSr RUN_HOST_CONFIG_KWARGSr
r r r sortedkeystupler% r2 r3 values_host_volume_from_bind) rC r keyhost_config_kwargsr= r r r r pvs r r r b s
Myy 1 # #!'C M# 1 yy 6 ( (&,jjo s #6
JJw #E .3?+jjB'G&-7#jjD)G
#6= //$(! .> .
%,dO )* .5>* ,UF;;#-#C0B#CM- "-044^DM ,2-2D2D2F+G"I&' #(Q"8 "I
g gt $'.~~'7("#f
(M) $ 4;(./&q)(M) $ "I((s 9"GG)G
c t j | \ }}|j dd }t | dk( s|d dv r||d z S |d j d s|d j d r|d d d S |d S )Nr" r )rorwr z:roz:rw)ntpath
splitdriver% lenendswith)r driverestbitss r r r s ##D)KE4 ::c1 D
4yA~aL0tAw
a % DG$4$4U$;Aws|Awr r^ zexit_code,output) r r% collectionsr r? r constantsr errorsr r r r
r typesr r
utilsr r$ r resourcer r r r r r r r r^ r r r r2 s{
" / 1 '|7 |7~q7* q7j .@ F;| &8
9
r