Current File : //lib/python2.7/site-packages/salt/states/docker_container.pyo
�
���^c
@@ sx d Z d d l m Z m Z m Z d d l Z d d l Z d d l Z d d l m Z d d l
Z d d l Z d d l
Z d d l m Z e j e � Z d Z d f Z d � Z d � Z d
� Z d � Z d � Z e e e e e d
e e e j j j e d �
Z e e e e e e e e e e e e j j j d � Z! e e e e e d � Z" e d � Z# d � Z$ e d � Z% d S( u
Management of Docker containers
.. versionadded:: 2017.7.0
:depends: docker_ Python module
.. note::
Older releases of the Python bindings for Docker were called docker-py_ in
PyPI. All releases of docker_, and releases of docker-py_ >= 1.6.0 are
supported. These python bindings can easily be installed using
:py:func:`pip.install <salt.modules.pip.install>`:
.. code-block:: bash
salt myminion pip.install docker
To upgrade from docker-py_ to docker_, you must first uninstall docker-py_,
and then install docker_:
.. code-block:: bash
salt myminion pip.uninstall docker-py
salt myminion pip.install docker
.. _docker: https://pypi.python.org/pypi/docker
.. _docker-py: https://pypi.python.org/pypi/docker-py
These states were moved from the :mod:`docker <salt.states.docker>` state
module (formerly called **dockerng**) in the 2017.7.0 release. When running the
:py:func:`docker_container.running <salt.states.docker_container.running>`
state for the first time after upgrading to 2017.7.0, your container(s) may be
replaced. The changes may show diffs for certain parameters which say that the
old value was an empty string, and the new value is ``None``. This is due to
the fact that in prior releases Salt was passing empty strings for these values
when creating the container if they were undefined in the SLS file, where now
Salt simply does not pass any arguments not explicitly defined in the SLS file.
Subsequent runs of the state should not replace the container if the
configuration remains unchanged.
.. note::
To pull from a Docker registry, authentication must be configured. See
:ref:`here <docker-authentication>` for more information on how to
configure access to docker registries in :ref:`Pillar <pillar>` data.
i ( t absolute_importt print_functiont unicode_literalsN( t CommandExecutionError( t sixu docker_containeru moby_containerc C@ s# d t k r t St t j d � f S( u?
Only load if the docker execution module is available
u docker.version( t __salt__t __virtualname__t Falset missing_fun_string( ( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt __virtual__F s c C@ s[ t | t j � r | | d <n8 d j | � | d <t | � d k rW | d c d 7<n | S( u�
DRY code for joining comments together and conditionally adding a period at
the end, and adding this comment string to the state return dict.
u commentu . i u .( t
isinstanceR t string_typest joint len( t rett comments( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt _format_commentsO s
c C@ s� x� | D]� } | d k r q n x� | | D]u } | | | d d k r* | | | d } | d k rj t Sy t d � | D� � r� t SWq� t k
r� q� Xq* q* Wq Wt S( u�
Check the diff for signs of incorrect argument handling in previous
releases, as discovered here:
https://github.com/saltstack/salt/pull/39996#issuecomment-288025200
u Networksu newu oldu c s@ s | ] } | d k Vq d S( u N( ( t .0t x( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pys <genexpr>n s N( t Nonet Truet allt TypeErrorR ( t changest conf_dictt itemt old( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt _check_diff] s
c
C@ so t j j j | p g � } | s* i } n�t j j j | � } | sT t d � � n x� t j | � D]� \ } } | d
k r� i | | <qd t j j j | � | | <| | s� t d j
| � � � n xN d D]F } y) t j j j | | | � | | | <Wq� t k
rq� q� Xq� Wqd Wg } xt t j | � D]c \ } } | d
k r/xH t j | � D]4 \ } } | d
k rW| j d j
| | � � qWqWWq/q/W| r�t d d | �� n | rky4 g t
d � D] } d | k r�| d ^ q�} Wn( t k
r} t d
j
| � � � qkXg t | � D] } | | k r#| ^ q#} | rkt d j
d j | � � � � qkn | S( u/
Common logic for parsing the networks
u1 Invalid network configuration (see documentation)u; Invalid configuration for network '{0}' (see documentation)u linksu aliasesu8 Config option '{0}' for network '{1}' is missing a valueu Invalid network configurationt infou docker.networksu Nameu- Failed to get list of existing networks: {0}.u+ The following networks are not present: {0}u , N( u linksu aliases( t saltt utilst argst split_inputt datat repack_dictlistR R t iteritemsR t formatt KeyErrort appendR t sortedR (
t networkst net_namet net_conft keyt errorst valR t all_networkst exct missing_networks( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt _parse_networksv sZ
+c C@ s� t d | � } | t k r� t d s� y t d | d | �} Wn+ t k
rm } t d j | | � � � q� X| | d d <t d | � } | t k r� t d j | � � � q� q� n | S( u>
Resolve the image ID and pull the image if necessary
u docker.resolve_image_idu testu docker.pullt client_timeoutu Failed to pull {0}: {1}u changesu imageu? Image '{0}' not present despite a docker pull raising no errors( R R t __opts__t ExceptionR R$ ( R t imageR2 t image_idt pull_resultR/ ( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt _resolve_image� s"
u forcec , @ s� i � d 6i d 6t d 6d d 6� | t k rI t � d <d � d <� Sn% t | t j � rn t j | � } n y; |
} t |
� }
|
r� |
| d <n t � | | � }
WnS t k
r� } t � d <| j
t k r� t � | j
� Sn | j � � d <� Sn Xg � | j
d t � } y t d � � d
} WnT t k
rHt } n> t k
r�t � d <� j d j � � � t � � � Sn X| t k } | r�t d � � n t } | p�| p�| |
k } | o�t d
rYt � d <| r�t � d d <n+ | |
k r#i | d 6|
d 6� d d <n � j d j � | r?d n d � � t � � � Sn yL t d | d | rv� n t d | d | d | d | | �} | d � Wn� t k
r�} t � d <� j d j | � � t � � � Sn� t k
rf} t � d <| j � } t | t � o9t | j
t � o9d | j
k rI| d 7} n � j | � t � � � Sn X� � � � f d � } � f d � } | } z�t d | r�� n � � } xu t j |
� D]d \ } } y t d! � | | � Wn= t k
r'} t � d <� j | j � � t � � � Sn Xq�Wt d � � } | t k r�t | j d" i � j d# i � � t |
� } | r�x | D] } t d$ � | � q�Wt d � � } n n t d% | | � } | r�t d& � � d' d( �} | r�t | � r.� j d) g � j d* j t d
r!d+ n d � � n � d j d, i � }! |! j | � t d
r�t � d <� j d j � | r�d n d � � nN t } | � � � r�t � d <t � � � Sn | d- � d j d. i � d/ <n
| r�t d
r� j d0 j | � � n y t d1 � d2 | �Wn@ t k
rb} t � d <� j d3 j | � � t � � � Sn% X| � d d4 <� j d5 j | � � nb | r�� r�t j d6 � � � j d7 j � t d
r�d8 n d � � n n � j d9 j � � � n | rH | � d j d, i � d# <t d
r3t � d <� j d: � n| rE t }" x�t | � D]�} g }# t }$ }% y4 � t d; | � k r�t d$ � | � t }$ n Wn& t k
r�} |# j | j � � n X| |
k ruy" t d! � | |
| � t }% Wn� t k
rq} |# j | j � � |$ rnxP t | | � D]> }& | | |& d t k rU| | |& =n t | | |& d <q)Wn n Xn |# r�� j |# � t }" n | | � d j d, i � j d# i � | <|$ o�|% r�� j d< j | � � n> |$ r�� j d= j | � � n |% r � j d> j | � � n qLW|" rB t � d <t � � � Sn n n Wd? | r\ | � n X| r� | r� � j d@ j � � � n* | � | � r� t � d <t � � � Sn | d- � d j d. i � d/ <n | o� | p� | o� | p� | o� | o� | dA k r�
t d
r1
t � d <� j dB � t � � � Snb y t dC � � dD d }' WnC t k
r�
} t � d <� j dE j � | � � t � � � Sn Xn t d � � }' t d
o�
|' dA k r� dF j � dG f � � � � f dH � }( t d% j dI g � }) x� t j � d j d, i � j d# i � � D]� \ } } dJ | k oO | dJ d dI k r� xr |) D]j }* |( � j | i � j |* � }+ |+ r� i t d 6|+ d 6| |* <y | j
dJ � Wn t k
r� n Xn qY Wn q& Wt! j
� t � n | |' k r4 i | d 6|' d 6� d dD <| t k r1 � j dK j | |' � � n n | oC | |
k rr � j dL � i | d 6|
d 6� d d <n |' dA k o� | r� t � d <� j dM � n t � � � S(N u�
Ensure that a container with a specific configuration is present and
running
name
Name of the container
image
Image to use for the container
.. note::
This state will pull the image if it is not present. However, if
the image needs to be built from a Dockerfile or loaded from a
saved image, or if you would like to use requisites to trigger a
replacement of the container when the image is updated, then the
:py:func:`docker_image.present
<salt.states.dockermod.image_present>` state should be used to
manage the image.
.. versionchanged:: 2018.3.0
If no tag is specified in the image name, and nothing matching the
specified image is pulled on the minion, the ``docker pull`` that
retrieves the image will pull *all tags* for the image. A tag of
``latest`` is no longer implicit for the pull. For this reason, it
is recommended to specify the image in ``repo:tag`` notation.
.. _docker-container-running-skip-translate:
skip_translate
This function translates Salt CLI or SLS input into the format which
docker-py_ expects. However, in the event that Salt's translation logic
fails (due to potential changes in the Docker Remote API, or to bugs in
the translation code), this argument can be used to exert granular
control over which arguments are translated and which are not.
Pass this argument as a comma-separated list (or Python list) of
arguments, and translation for each passed argument name will be
skipped. Alternatively, pass ``True`` and *all* translation will be
skipped.
Skipping tranlsation allows for arguments to be formatted directly in
the format which docker-py_ expects. This allows for API changes and
other issues to be more easily worked around. An example of using this
option to skip translation would be:
For example, imagine that there is an issue with processing the
``port_bindings`` argument, and the following configuration no longer
works as expected:
.. code-block:: yaml
mycontainer:
docker_container.running:
- image: 7.3.1611
- port_bindings:
- 10.2.9.10:8080:80
By using ``skip_translate``, you can forego the input translation and
configure the port binding in the format docker-py_ needs:
.. code-block:: yaml
mycontainer:
docker_container.running:
- image: 7.3.1611
- skip_translate: port_bindings
- port_bindings: {8080: [('10.2.9.10', 80)], '4193/udp': 9314}
See the following links for more information:
- `docker-py Low-level API`_
- `Docker Engine API`_
.. _docker-py: https://pypi.python.org/pypi/docker-py
.. _`docker-py Low-level API`: http://docker-py.readthedocs.io/en/stable/api.html#docker.api.container.ContainerApiMixin.create_container
.. _`Docker Engine API`: https://docs.docker.com/engine/api/v1.33/#operation/ContainerCreate
ignore_collisions : False
Since many of docker-py_'s arguments differ in name from their CLI
counterparts (with which most Docker users are more familiar), Salt
detects usage of these and aliases them to the docker-py_ version of
that argument so that both CLI and API versions of a given argument are
supported. However, if both the alias and the docker-py_ version of the
same argument (e.g. ``env`` and ``environment``) are used, an error
will be raised. Set this argument to ``True`` to suppress these errors
and keep the docker-py_ version of the argument.
validate_ip_addrs : True
For parameters which accept IP addresses as input, IP address
validation will be performed. To disable, set this to ``False``
force : False
Set this parameter to ``True`` to force Salt to re-create the container
irrespective of whether or not it is configured as desired.
watch_action : force
Control what type of action is taken when this state :ref:`watches
<requisites-watch>` another state that has changes. The default action
is ``force``, which runs the state with ``force`` set to ``True``,
triggering a rebuild of the container.
If any other value is passed, it will be assumed to be a kill signal.
If the container matches the specified configuration, and is running,
then the action will be to send that signal to the container. Kill
signals can be either strings or numbers, and are defined in the
**Standard Signals** section of the ``signal(7)`` manpage. Run ``man 7
signal`` on a Linux host to browse this manpage. For example:
.. code-block:: yaml
mycontainer:
docker_container.running:
- image: busybox
- watch_action: SIGHUP
- watch:
- file: some_file
.. note::
If the container differs from the specified configuration, or is
not running, then instead of sending a signal to the container, the
container will be re-created/started and no signal will be sent.
start : True
Set to ``False`` to suppress starting of the container if it exists,
matches the desired configuration, but is not running. This is useful
for data-only containers, or for non-daemonized container processes,
such as the Django ``migrate`` and ``collectstatic`` commands. In
instances such as this, the container only needs to be started the
first time.
shutdown_timeout
If the container needs to be replaced, the container will be stopped
using :py:func:`docker.stop <salt.modules.dockermod.stop>`. If a
``shutdown_timout`` is not set, and the container was created using
``stop_timeout``, that timeout will be used. If neither of these values
were set, then a timeout of 10 seconds will be used.
.. versionchanged:: 2017.7.0
This option was renamed from ``stop_timeout`` to
``shutdown_timeout`` to accommodate the ``stop_timeout`` container
configuration setting.
client_timeout : 60
Timeout in seconds for the Docker client. This is not a timeout for
this function, but for receiving a response from the API.
.. note::
This is only used if Salt needs to pull the requested image.
.. _salt-states-docker-container-network-management:
**NETWORK MANAGEMENT**
.. versionadded:: 2018.3.0
.. versionchanged:: 2019.2.0
If the ``networks`` option is used, any networks (including the default
``bridge`` network) which are not specified will be disconnected.
The ``networks`` argument can be used to ensure that a container is
attached to one or more networks. Optionally, arguments can be passed to
the networks. In the example below, ``net1`` is being configured with
arguments, while ``net2`` and ``bridge`` are being configured *without*
arguments:
.. code-block:: yaml
foo:
docker_container.running:
- image: myuser/myimage:foo
- networks:
- net1:
- aliases:
- bar
- baz
- ipv4_address: 10.0.20.50
- net2
- bridge
- require:
- docker_network: net1
- docker_network: net2
The supported arguments are the ones from the docker-py's
`connect_container_to_network`_ function (other than ``container`` and
``net_id``).
.. important::
Unlike with the arguments described in the **CONTAINER CONFIGURATION
PARAMETERS** section below, these network configuration parameters are
not translated at all. Consult the `connect_container_to_network`_
documentation for the correct type/format of data to pass.
.. _`connect_container_to_network`: https://docker-py.readthedocs.io/en/stable/api.html#docker.api.network.NetworkApiMixin.connect_container_to_network
To start a container with no network connectivity (only possible in
2019.2.0 and later) pass this option as an empty list. For example:
.. code-block:: yaml
foo:
docker_container.running:
- image: myuser/myimage:foo
- networks: []
**CONTAINER CONFIGURATION PARAMETERS**
auto_remove (or *rm*) : False
Enable auto-removal of the container on daemon side when the
container’s process exits (analogous to running a docker container with
``--rm`` on the CLI).
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- auto_remove: True
binds
Files/directories to bind mount. Each bind mount should be passed in
one of the following formats:
- ``<host_path>:<container_path>`` - ``host_path`` is mounted within
the container as ``container_path`` with read-write access.
- ``<host_path>:<container_path>:<selinux_context>`` - ``host_path`` is
mounted within the container as ``container_path`` with read-write
access. Additionally, the specified selinux context will be set
within the container.
- ``<host_path>:<container_path>:<read_only>`` - ``host_path`` is
mounted within the container as ``container_path``, with the
read-only or read-write setting explicitly defined.
- ``<host_path>:<container_path>:<read_only>,<selinux_context>`` -
``host_path`` is mounted within the container as ``container_path``,
with the read-only or read-write setting explicitly defined.
Additionally, the specified selinux context will be set within the
container.
``<read_only>`` can be either ``rw`` for read-write access, or ``ro``
for read-only access. When omitted, it is assumed to be read-write.
``<selinux_context>`` can be ``z`` if the volume is shared between
multiple containers, or ``Z`` if the volume should be private.
.. note::
When both ``<read_only>`` and ``<selinux_context>`` are specified,
there must be a comma before ``<selinux_context>``.
Binds can be expressed as a comma-separated list or a YAML list. The
below two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- binds: /srv/www:/var/www:ro,/etc/foo.conf:/usr/local/etc/foo.conf:rw
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- binds:
- /srv/www:/var/www:ro
- /home/myuser/conf/foo.conf:/etc/foo.conf:rw
However, in cases where both ro/rw and an selinux context are combined,
the only option is to use a YAML list, like so:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- binds:
- /srv/www:/var/www:ro,Z
- /home/myuser/conf/foo.conf:/etc/foo.conf:rw,Z
Since the second bind in the previous example is mounted read-write,
the ``rw`` and comma can be dropped. For example:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- binds:
- /srv/www:/var/www:ro,Z
- /home/myuser/conf/foo.conf:/etc/foo.conf:Z
blkio_weight
Block IO weight (relative weight), accepts a weight value between 10
and 1000.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- blkio_weight: 100
blkio_weight_device
Block IO weight (relative device weight), specified as a list of
expressions in the format ``PATH:RATE``
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- blkio_weight_device: /dev/sda:100
cap_add
List of capabilities to add within the container. Can be expressed as a
comma-separated list or a Python list. The below two examples are
equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- cap_add: SYS_ADMIN,MKNOD
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- cap_add:
- SYS_ADMIN
- MKNOD
.. note::
This option requires Docker 1.2.0 or newer.
cap_drop
List of capabilities to drop within the container. Can be expressed as
a comma-separated list or a Python list. The below two examples are
equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- cap_drop: SYS_ADMIN,MKNOD
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- cap_drop:
- SYS_ADMIN
- MKNOD
.. note::
This option requires Docker 1.2.0 or newer.
command (or *cmd*)
Command to run in the container
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- command: bash
cpuset_cpus (or *cpuset*)
CPUs on which which to allow execution, specified as a string
containing a range (e.g. ``0-3``) or a comma-separated list of CPUs
(e.g. ``0,1``).
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- cpuset_cpus: "0,1"
cpuset_mems
Memory nodes on which which to allow execution, specified as a string
containing a range (e.g. ``0-3``) or a comma-separated list of MEMs
(e.g. ``0,1``). Only effective on NUMA systems.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- cpuset_mems: "0,1"
cpu_group
The length of a CPU period in microseconds
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- cpu_group: 100000
cpu_period
Microseconds of CPU time that the container can get in a CPU period
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- cpu_period: 50000
cpu_shares
CPU shares (relative weight), specified as an integer between 2 and 1024.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- cpu_shares: 512
detach : False
If ``True``, run the container's command in the background (daemon
mode)
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- detach: True
devices
List of host devices to expose within the container. Can be expressed
as a comma-separated list or a YAML list. The below two examples are
equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- devices: /dev/net/tun,/dev/xvda1:/dev/xvda1,/dev/xvdb1:/dev/xvdb1:r
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- devices:
- /dev/net/tun
- /dev/xvda1:/dev/xvda1
- /dev/xvdb1:/dev/xvdb1:r
device_read_bps
Limit read rate (bytes per second) from a device, specified as a list
of expressions in the format ``PATH:RATE``, where ``RATE`` is either an
integer number of bytes, or a string ending in ``kb``, ``mb``, or
``gb``. Can be expressed as a comma-separated list or a YAML list. The
below two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- devices_read_bps: /dev/sda:1mb,/dev/sdb:5mb
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- devices_read_bps:
- /dev/sda:1mb
- /dev/sdb:5mb
device_read_iops
Limit read rate (I/O per second) from a device, specified as a list
of expressions in the format ``PATH:RATE``, where ``RATE`` is a number
of I/O operations. Can be expressed as a comma-separated list or a YAML
list. The below two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- devices_read_iops: /dev/sda:1000,/dev/sdb:500
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- devices_read_iops:
- /dev/sda:1000
- /dev/sdb:500
device_write_bps
Limit write rate (bytes per second) from a device, specified as a list
of expressions in the format ``PATH:RATE``, where ``RATE`` is either an
integer number of bytes, or a string ending in ``kb``, ``mb``, or
``gb``. Can be expressed as a comma-separated list or a YAML list. The
below two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- devices_write_bps: /dev/sda:1mb,/dev/sdb:5mb
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- devices_write_bps:
- /dev/sda:1mb
- /dev/sdb:5mb
device_read_iops
Limit write rate (I/O per second) from a device, specified as a list
of expressions in the format ``PATH:RATE``, where ``RATE`` is a number
of I/O operations. Can be expressed as a comma-separated list or a
YAML list. The below two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- devices_read_iops: /dev/sda:1000,/dev/sdb:500
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- devices_read_iops:
- /dev/sda:1000
- /dev/sdb:500
dns
List of DNS nameservers. Can be expressed as a comma-separated list or
a YAML list. The below two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- dns: 8.8.8.8,8.8.4.4
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- dns:
- 8.8.8.8
- 8.8.4.4
.. note::
To skip IP address validation, use ``validate_ip_addrs=False``
dns_opt
Additional options to be added to the container’s ``resolv.conf`` file.
Can be expressed as a comma-separated list or a YAML list. The below
two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- dns_opt: ndots:9
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- dns_opt:
- ndots:9
dns_search
List of DNS search domains. Can be expressed as a comma-separated list
or a YAML list. The below two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- dns_search: foo1.domain.tld,foo2.domain.tld
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- dns_search:
- foo1.domain.tld
- foo2.domain.tld
domainname
The domain name to use for the container
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- dommainname: domain.tld
entrypoint
Entrypoint for the container
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- entrypoint: "mycmd --arg1 --arg2"
This argument can also be specified as a list:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- entrypoint:
- mycmd
- --arg1
- --arg2
environment
Either a list of variable/value mappings, or a list of strings in the
format ``VARNAME=value``. The below three examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- environment:
- VAR1: value
- VAR2: value
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- environment: 'VAR1=value,VAR2=value'
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- environment:
- VAR1=value
- VAR2=value
extra_hosts
Additional hosts to add to the container's /etc/hosts file. Can be
expressed as a comma-separated list or a Python list. The below two
examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- extra_hosts: web1:10.9.8.7,web2:10.9.8.8
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- extra_hosts:
- web1:10.9.8.7
- web2:10.9.8.8
.. note::
To skip IP address validation, use ``validate_ip_addrs=False``
.. note::
This option requires Docker 1.3.0 or newer.
group_add
List of additional group names and/or IDs that the container process
will run as. Can be expressed as a comma-separated list or a YAML list.
The below two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- group_add: web,network
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- group_add:
- web
- network
hostname
Hostname of the container. If not provided, the value passed as the
container's``name`` will be used for the hostname.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- hostname: web1
.. warning::
``hostname`` cannot be set if ``network_mode`` is set to ``host``.
The below example will result in an error:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- hostname: web1
- network_mode: host
interactive (or *stdin_open*) : False
Leave stdin open, even if not attached
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- interactive: True
ipc_mode (or *ipc*)
Set the IPC mode for the container. The default behavior is to create a
private IPC namespace for the container, but this option can be
used to change that behavior:
- ``container:<container_name_or_id>`` reuses another container shared
memory, semaphores and message queues
- ``host``: use the host's shared memory, semaphores and message queues
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- ipc_mode: container:foo
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- ipc_mode: host
.. warning::
Using ``host`` gives the container full access to local shared
memory and is therefore considered insecure.
isolation
Specifies the type of isolation technology used by containers
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- isolation: hyperv
.. note::
The default value on Windows server is ``process``, while the
default value on Windows client is ``hyperv``. On Linux, only
``default`` is supported.
labels
Add metadata to the container. Labels can be set both with and without
values, and labels with values can be passed either as ``key=value`` or
``key: value`` pairs. For example, while the below would be very
confusing to read, it is technically valid, and demonstrates the
different ways in which labels can be passed:
.. code-block:: yaml
mynet:
docker_network.present:
- labels:
- foo
- bar=baz
- hello: world
The labels can also simply be passed as a YAML dictionary, though this
can be error-prone due to some :ref:`idiosyncrasies
<yaml-idiosyncrasies>` with how PyYAML loads nested data structures:
.. code-block:: yaml
foo:
docker_network.present:
- labels:
foo: ''
bar: baz
hello: world
.. versionchanged:: 2018.3.0
Methods for specifying labels can now be mixed. Earlier releases
required either labels with or without values.
links
Link this container to another. Links can be specified as a list of
mappings or a comma-separated or Python list of expressions in the
format ``<container_name_or_id>:<link_alias>``. The below three
examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- links:
- web1: link1
- web2: link2
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- links: web1:link1,web2:link2
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- links:
- web1:link1
- web2:link2
log_driver and log_opt
Set container's logging driver and options to configure that driver.
Requires Docker 1.6 or newer.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- log_driver: syslog
- log_opt:
- syslog-address: tcp://192.168.0.42
- syslog-facility: daemon
The ``log_opt`` can also be expressed as a comma-separated or YAML list
of ``key=value`` pairs. The below two examples are equivalent to the
above one:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- log_driver: syslog
- log_opt: "syslog-address=tcp://192.168.0.42,syslog-facility=daemon"
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- log_driver: syslog
- log_opt:
- syslog-address=tcp://192.168.0.42
- syslog-facility=daemon
.. note::
The logging driver feature was improved in Docker 1.13 introducing
option name changes. Please see Docker's
`Configure logging drivers`_ documentation for more information.
.. _`Configure logging drivers`: https://docs.docker.com/engine/admin/logging/overview/
lxc_conf
Additional LXC configuration parameters to set before starting the
container. Either a list of variable/value mappings, or a list of
strings in the format ``VARNAME=value``. The below three examples are
equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- lxc_conf:
- lxc.utsname: docker
- lxc.arch: x86_64
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- lxc_conf: lxc.utsname=docker,lxc.arch=x86_64
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- lxc_conf:
- lxc.utsname=docker
- lxc.arch=x86_64
.. note::
These LXC configuration parameters will only have the desired
effect if the container is using the LXC execution driver, which
has been deprecated for some time.
mac_address
MAC address to use for the container. If not specified, a random MAC
address will be used.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- mac_address: 01:23:45:67:89:0a
mem_limit (or *memory*) : 0
Memory limit. Can be specified in bytes or using single-letter units
(i.e. ``512M``, ``2G``, etc.). A value of ``0`` (the default) means no
memory limit.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- mem_limit: 512M
mem_swappiness
Tune a container's memory swappiness behavior. Accepts an integer
between 0 and 100.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- mem_swappiness: 60
memswap_limit (or *memory_swap*) : -1
Total memory limit (memory plus swap). Set to ``-1`` to disable swap. A
value of ``0`` means no swap limit.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- memswap_limit: 1G
network_disabled : False
If ``True``, networking will be disabled within the container
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- network_disabled: True
network_mode : bridge
One of the following:
- ``bridge`` - Creates a new network stack for the container on the
docker bridge
- ``none`` - No networking (equivalent of the Docker CLI argument
``--net=none``). Not to be confused with Python's ``None``.
- ``container:<name_or_id>`` - Reuses another container's network stack
- ``host`` - Use the host's network stack inside the container
- Any name that identifies an existing network that might be created
with ``docker.network_present``.
.. warning::
Using ``host`` mode gives the container full access to the
hosts system's services (such as D-bus), and is therefore
considered insecure.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- network_mode: "none"
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- network_mode: container:web1
oom_kill_disable
Whether to disable OOM killer
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- oom_kill_disable: False
oom_score_adj
An integer value containing the score given to the container in order
to tune OOM killer preferences
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- oom_score_adj: 500
pid_mode
Set to ``host`` to use the host container's PID namespace within the
container. Requires Docker 1.5.0 or newer.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- pid_mode: host
.. note::
This option requires Docker 1.5.0 or newer.
pids_limit
Set the container's PID limit. Set to ``-1`` for unlimited.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- pids_limit: 2000
port_bindings (or *publish*)
Bind exposed ports. Port bindings should be passed in the same way as
the ``--publish`` argument to the ``docker run`` CLI command:
- ``ip:hostPort:containerPort`` - Bind a specific IP and port on the
host to a specific port within the container.
- ``ip::containerPort`` - Bind a specific IP and an ephemeral port to a
specific port within the container.
- ``hostPort:containerPort`` - Bind a specific port on all of the
host's interfaces to a specific port within the container.
- ``containerPort`` - Bind an ephemeral port on all of the host's
interfaces to a specific port within the container.
Multiple bindings can be separated by commas, or expressed as a YAML
list, and port ranges can be defined using dashes. The below two
examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- port_bindings: "4505-4506:14505-14506,2123:2123/udp,8080"
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- port_bindings:
- 4505-4506:14505-14506
- 2123:2123/udp
- 8080
.. note::
When specifying a protocol, it must be passed in the
``containerPort`` value, as seen in the examples above.
ports
A list of ports to expose on the container. Can either be a
comma-separated list or a YAML list. If the protocol is omitted, the
port will be assumed to be a TCP port. The below two examples are
equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- ports: 1111,2222/udp
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- ports:
- 1111
- 2222/udp
privileged : False
If ``True``, runs the exec process with extended privileges
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- privileged: True
publish_all_ports (or *publish_all*) : False
Publish all ports to the host
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- ports: 8080
- publish_all_ports: True
read_only : False
If ``True``, mount the container’s root filesystem as read only
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- read_only: True
restart_policy (or *restart*)
Set a restart policy for the container. Must be passed as a string in
the format ``policy[:retry_count]`` where ``policy`` is one of
``always``, ``unless-stopped``, or ``on-failure``, and ``retry_count``
is an optional limit to the number of retries. The retry count is ignored
when using the ``always`` or ``unless-stopped`` restart policy.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- restart_policy: on-failure:5
bar:
docker_container.running:
- image: bar/baz:latest
- restart_policy: always
security_opt (or *security_opts*):
Security configuration for MLS systems such as SELinux and AppArmor.
Can be expressed as a comma-separated list or a YAML list. The below
two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- security_opt: apparmor:unconfined
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- security_opt:
- apparmor:unconfined
.. important::
Some security options can contain commas. In these cases, this
argument *must* be passed as a Python list, as splitting by comma
will result in an invalid configuration.
.. note::
See the documentation for security_opt at
https://docs.docker.com/engine/reference/run/#security-configuration
shm_size
Size of /dev/shm
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- shm_size: 128M
stop_signal
Specify the signal docker will send to the container when stopping.
Useful when running systemd as PID 1 inside the container.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- stop_signal: SIGRTMIN+3
.. note::
This option requires Docker 1.9.0 or newer and docker-py 1.7.0 or
newer.
.. versionadded:: 2016.11.0
stop_timeout
Timeout to stop the container, in seconds
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- stop_timeout: 5
.. note::
In releases prior to 2017.7.0, this option was not set in the
container configuration, but rather this timeout was enforced only
when shutting down an existing container to replace it. To remove
the ambiguity, and to allow for the container to have a stop
timeout set for it, the old ``stop_timeout`` argument has been
renamed to ``shutdown_timeout``, while ``stop_timeout`` now refer's
to the container's configured stop timeout.
storage_opt
Storage driver options for the container. Can be either a list of
strings in the format ``option=value``, or a list of mappings between
option and value. The below three examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- storage_opt:
- dm.basesize: 40G
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- storage_opt: dm.basesize=40G
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- storage_opt:
- dm.basesize=40G
sysctls (or *sysctl*)
Set sysctl options for the container. Can be either a list of strings
in the format ``option=value``, or a list of mappings between option
and value. The below three examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- sysctls:
- fs.nr_open: 1048576
- kernel.pid_max: 32768
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- sysctls: fs.nr_open=1048576,kernel.pid_max=32768
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- sysctls:
- fs.nr_open=1048576
- kernel.pid_max=32768
tmpfs
A map of container directories which should be replaced by tmpfs mounts
and their corresponding mount options.
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- tmpfs:
- /run: rw,noexec,nosuid,size=65536k
tty : False
Attach TTYs
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- tty: True
ulimits
List of ulimits. These limits should be passed in the format
``<ulimit_name>:<soft_limit>:<hard_limit>``, with the hard limit being
optional. Can be expressed as a comma-separated list or a YAML list.
The below two examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- ulimits: nofile=1024:1024,nproc=60
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- ulimits:
- nofile=1024:1024
- nproc=60
user
User under which to run exec process
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- user: foo
userns_mode (or *user_ns_mode*)
Sets the user namsepace mode, when the user namespace remapping option
is enabled
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- userns_mode: host
volumes (or *volume*)
List of directories to expose as volumes. Can be expressed as a
comma-separated list or a YAML list. The below two examples are
equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- volumes: /mnt/vol1,/mnt/vol2
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- volumes:
- /mnt/vol1
- /mnt/vol2
volumes_from
Container names or IDs from which the container will get volumes. Can
be expressed as a comma-separated list or a YAML list. The below two
examples are equivalent:
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- volumes_from: foo
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- volumes_from:
- foo
volume_driver
sets the container's volume driver
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- volume_driver: foobar
working_dir (or *workdir*)
Working directory inside the container
.. code-block:: yaml
foo:
docker_container.running:
- image: bar/baz:latest
- working_dir: /var/log/nginx
u nameu changesu resultu u commentu The 'image' argument is requiredu networksu send_signalu docker.inspect_containeru Imageud Unable to detect current image for container '{0}'. This might be due to a change in the Docker API.u docker.stateu testu
forced_updateu oldu newu imageu Container '{0}' would be {1}u createdu replacedu
docker.createt namet skip_translatet ignore_collisionst validate_ip_addrsR2 u Nameu� Key '{0}' missing from API response, this may be due to a change in the Docker Remote API. Please report this on the SaltStack issue tracker if it has not already been reported.u invalidu�
If you feel this information is incorrect, the skip_translate argument can be used to skip input translation for the argument(s) identified as invalid. See the documentation for details.c @ s� i t d 6} � d k r& � | d <n t d � | � � d j d i � d <y t d | | � } Wn/ t k
r� } t } � j d j | � � n X| r� � j d j | � � n
� j d
� | S( Nu stopu timeoutu docker.rmu changesu container_idu removedu
docker.renameu$ Failed to rename temp container: {0}u Replaced container '{0}'u! Failed to replace container '{0}'( R R R t
setdefaultR R R& R$ ( t origt newt rm_kwargst resultR/ ( R R9 R t shutdown_timeout( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt _replace� s
'
c @ s" t j d � � t d � � d S( Nu Removing temp container '%s'u docker.rm( t logt debugR ( ( t temp_container_name( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt _delete_temp_container s u# docker.connect_container_to_networku NetworkSettingsu Networksu( docker.disconnect_container_from_networku! docker.compare_container_networksu docker.compare_containerst ignoreu Hostnameu warningsu� The detected changes may be due to incorrect handling of arguments in earlier Salt releases. If this warning persists after running the state again{0}, and no changes were made to the SLS file, then please report this.u without test=Trueu containeru Idu container_idu addedu% Signal {0} would be sent to containeru
docker.signalt signalu Failed to signal container: {0}u signalu Sent signal {0} to containeruX docker_container.running: detected changes without a specific comment for container '%s'u Container '{0}'{1} updated.u would beu2 Container '{0}' is already configured as specifiedu& Network configuration would be updatedu docker.connectedu7 Reconnected to network '{0}' with updated configurationu Disconnected from network '{0}'u Connected to network '{0}'Nu Created container '{0}'u runningu Container would be startedu docker.startu stateu& Failed to start container '{0}': '{1}'u .u docker_container.runningc @ sI � t k rA t d � � } | j d i � j d i � t � <n t � S( Nu docker.inspect_containeru NetworkSettingsu Networks( t __context__R t get( t new_container_info( t
contextkeyR9 ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt _get_nets
s
u automaticu IPConfigurationu! State changed from '{0}' to '{1}'u Container has a new imageu Container is not running(" R R R R
R R t text_typeR1 R8 R R R t __str__t popR R% R& R$ R3 R4 t dictR# t setRK R R= t updateRD t warningR' t listt extendR RJ (, R9 R5 R: R; R< t forcet watch_actiont startRB R2 R( t kwargst configured_networksR6 R/ t send_signalt current_image_idt existst pre_statet skip_comparisont temp_containert msgRC RG t cleanup_tempt pre_net_connectR) R* t post_net_connectt
extra_netst extra_nett net_changest container_changest changes_ptrt network_failureR, t disconnectedt connectedR t
post_stateRN t autoip_keysR+ R- ( ( R RM R9 R RB RF s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt running� s � � � � � �
!
!
*
!
/
c
K@ s i | d 6i d 6t d 6d d 6} t j j j |
� }
x; d& D]3 } | |
k r> t | d <d
j | � | d <| Sq> W| d' k r� t | d <d | d <| St | t j
� s� t j | � } n t | | | � } t | t
� r� | j | � | SyG d |
k r%|
d d' k r%t |
d � |
d <n t | | | � WnP t k
r�} t | d <| j d' k rqt | | j � S| j � | d <| Sn Xt | | | � } t | t
� r�| j | � | St d
r�d' | d <d j | r�d n d � | d <| S| rt } n� d' } xq d( D]i } y |
j | � } Wn t k
r=qn X| d' k rk|
swt | d <d | d <| Sqt | � } qW| d' k r�t |
d <n t } yK t d | d | d | d |
d | d | d | d | d | |
�| d <Wn= t k
r$} t j d � t | d <d j | � | d <no X| r8d | d <n[ y | d d } Wn t k
r]n6 X| rv| d k rvt n t | d <d! j | � | d <| r| j d i � j d" � } | ry t d# | d d" � Wqt k
r } | j d$ g � j d% j | � � qXqn | S() u�
.. versionadded:: 2018.3.0
.. note::
If no tag is specified in the image name, and nothing matching the
specified image is pulled on the minion, the ``docker pull`` that
retrieves the image will pull *all tags* for the image. A tag of
``latest`` is not implicit for the pull. For this reason, it is
recommended to specify the image in ``repo:tag`` notation.
Like the :py:func:`cmd.run <salt.states.cmd.run>` state, only for Docker.
Does the equivalent of a ``docker run`` and returns information about the
container that was created, as well as its output.
This state accepts the same arguments as :py:func:`docker_container.running
<salt.states.docker_container.running>`, with the exception of
``watch_action``, ``start``, and ``shutdown_timeout`` (though the ``force``
argument has a different meaning in this state).
In addition, this state accepts the arguments from :py:func:`docker.logs
<salt.modules.dockermod.logs>`, with the exception of ``follow``, to
control how logs are returned.
Additionally, the following arguments are supported:
onlyif
A command or list of commands to run as a check. The container will
only run if any of the specified commands returns a zero exit status.
unless
A command or list of commands to run as a check. The container will
only run if any of the specified commands returns a non-zero exit
status.
creates
A path or list of paths. Only run if one or more of the specified paths
do not exist on the minion.
bg : False
If ``True``, run container in background and do not await or deliver
its results.
.. note::
This may not be useful in cases where other states depend on the
results of this state. Also, the logs will be inaccessible once the
container exits if ``auto_remove`` is set to ``True``, so keep this
in mind.
failhard : True
If ``True``, the state will return a ``False`` result if the exit code
of the container is non-zero. When this argument is set to ``False``,
the state will return a ``True`` result regardless of the container's
exit code.
.. note::
This has no effect if ``bg`` is set to ``True``.
replace : False
If ``True``, and if the named container already exists, this will
remove the existing container. The default behavior is to return a
``False`` result when the container already exists.
force : False
If ``True``, and the named container already exists, *and* ``replace``
is also set to ``True``, then the container will be forcibly removed.
Otherwise, the state will not proceed and will return a ``False``
result.
CLI Examples:
.. code-block:: bash
salt myminion docker.run_container myuser/myimage command=/usr/local/bin/myscript.sh
**USAGE EXAMPLE**
.. code-block:: jinja
{% set pkg_version = salt.pillar.get('pkg_version', '1.0-1') %}
build_package:
docker_container.run:
- image: myuser/builder:latest
- binds: /home/myuser/builds:/build_dir
- command: /scripts/build.sh {{ pkg_version }}
- creates: /home/myuser/builds/myapp-{{ pkg_version }}.noarch.rpm
- replace: True
- networks:
- mynet
- require:
- docker_network: mynet
u nameu changesu resultu u commentu watch_actionu startu shutdown_timeoutu followu# The '{0}' argument is not supportedu The 'image' argument is requiredu networksu testu Container would be run{0}u in the backgroundu auto_removeu rmu< 'rm' is an alias for 'auto_remove', they cannot both be usedu docker.run_containerR9 R: R; R< R2 t bgt replaceRX u# Encountered error running containeru( Encountered error running container: {0}u# Container was run in the backgroundu ExitCodei u2 Container ran and exited with a return code of {0}u Idu docker.rmu warningsu$ Failed to auto_remove container: {0}( u watch_actionu startu shutdown_timeoutu followN( u auto_removeu rm( R R R R t clean_kwargsR R$ R R
R R RO t
mod_run_checkRR RT R1 R8 R R R RP R3 RQ R% t boolR R4 RD t exceptionRK R= R& ( R9 R5 t onlyift unlesst createsRr t failhardRs RX R: R; R< R2 R[ R t unsupportedt cretR/ t removeR R- t retcodet id_( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt run4 s� i
"
c K@ s� i | d 6i d 6t d 6d d 6} | r> | r> d | d <| S| d k r� t | t � sg d | d <| Sg } x{ | D]7 } t | t j � s� t j | � } n | j | � qt Wn9 | r� t | t j � s� t j | � g } q� | g } n i } xh | D]` } y t d | � } Wn* t k
r>| j
d g � j | � q� X| j
| g � j | � q� Wg }
| r�d | k r�|
j d
j d j | d � � � n | r�d | k r�t | d <|
j d
j d j | d � � � n |
rt | d <d j |
� | d <| S| j
d g � | j
d g � } | s�t | d <t | � d k rbd j | d � | d <n
d | d <d | k r�| d c d 7<n | d c d 7<| St d r�d | d <d j d j | � � | d <| Sg } x� | D]� } i | d 6}
| r| |
d <n t d | |
� } | d t k r:| | d | <q�d | k rZ| j | d � q�| j d j | � � q�W| r�d j | � | d <| St | d <d j d j | � � | d <| S( u@
Ensure that a container (or containers) is stopped
name
Name or ID of the container
containers
Run this state on more than one container at a time. The following two
examples accomplish the same thing:
.. code-block:: yaml
stopped_containers:
docker_container.stopped:
- names:
- foo
- bar
- baz
.. code-block:: yaml
stopped_containers:
docker_container.stopped:
- containers:
- foo
- bar
- baz
However, the second example will be a bit quicker since Salt will stop
all specified containers in a single run, rather than executing the
state separately on each image (as it would in the first example).
shutdown_timeout
Timeout for graceful shutdown of the container. If this timeout is
exceeded, the container will be killed. If this value is not passed,
then the container's configured ``stop_timeout`` will be observed. If
``stop_timeout`` was also unset on the container, then a timeout of 10
seconds will be used.
unpause : False
Set to ``True`` to unpause any paused containers before stopping. If
unset, then an error will be raised for any container that was paused.
error_on_absent : True
By default, this state will return an error if any of the specified
containers are absent. Set this to ``False`` to suppress that error.
u nameu changesu resultu u commentu/ One of 'name' and 'containers' must be providedu containers must be a listu docker.stateu absentu* The following container(s) are absent: {0}u , u pausedu* The following container(s) are paused: {0}u . u runningi u Container '{0}' is i u All specified containers are u
absent or u not runningu testu/ The following container(s) will be stopped: {0}u unpauseu timeoutu docker.stopu Failed to stop container '{0}'u ; u, The following container(s) were stopped: {0}N( R R R
RV R R RO R& R R R= R$ R RK R R
R3 ( R9 t
containersRB t unpauset error_on_absentR[ R t targetst targett c_stateR, t to_stopt stop_errorst stop_kwargsR ( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt stopped s� 5
"
c C@ s{ i | d 6i d 6t d 6d d 6} | t d d t � k r\ t | d <d j | � | d <| St d | � } | d
k r� | r� d | d <| St d r� d | d <d
j | � | d <| Sy" t d | d | �| d d <Wn* t k
r} d j | | � | d <| SX| t d d t � k r6d j | � | d <nA | rQ| d
k rQd } n d } d j | | � | d <t | d <| S( u�
Ensure that a container is absent
name
Name of the container
force : False
Set to ``True`` to remove the container even if it is running
Usage Examples:
.. code-block:: yaml
mycontainer:
docker_container.absent
multiple_containers:
docker_container.absent:
- names:
- foo
- bar
- baz
u nameu changesu resultu u commentu docker.list_containersR u Container '{0}' does not existu docker.stateu stoppedu= Container is running, set force to True to forcibly remove itu testu Container '{0}' will be removedu docker.rmRX u removedu% Failed to remove container '{0}': {1}u Failed to remove container '{0}'u Forciblyu Successfullyu {0} removed container '{1}'N( R R R R$ R3 R R4 ( R9 RX R R` R/ t method( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt absent� s<
"
c C@ sC i t d 6t d 6} | d k r� t | t j � r> | g } n t | t � se t d � | D� � r~ i d d 6t d 6t d 6Sx^ | D]S } t d | d t d
t �} | d k r� i d j | | � d 6t d 6t d 6Sq� Wn | d k r�t | t j � r | g } n t | t � s0t d
� | D� � rIi d d 6t d 6t d 6Sx^ | D]S } t d | d t d
t �} | d k rPi d j | | � d 6t d 6t d 6SqPWn | d k r?t | t j � r�| g } n t | t � s�t d � | D� � ri d d 6t d 6t d 6St d � | D� � r?i d d 6t d 6Sn t S( u~
Execute the onlyif/unless/creates logic. Returns a result dict if any of
the checks fail, otherwise returns True
u use_vtu bgc s@ s! | ] } t | t j � Vq d S( N( R
R R ( R R ( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pys <genexpr>
s u) onlyif is not a string or list of stringsu commentu
skip_watchu resultu cmd.retcodet ignore_retcodet python_shelli u, onlyif command {0} returned exit code of {1}c s@ s! | ] } t | t j � Vq d S( N( R
R R ( R R ( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pys <genexpr>
s u) unless is not a string or list of stringsu, unless command {0} returned exit code of {1}c s@ s! | ] } t | t j � Vq d S( N( R
R R ( R R ( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pys <genexpr>-
s u* creates is not a string or list of stringsc s@ s! | ] } t j j | � Vq d S( N( t ost pathR_ ( R R ( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pys <genexpr>1
s u/ All specified paths in 'creates' argument existN(
R R R
R R RV R R R R$ ( Rx Ry Rz t
cmd_kwargst entryR ( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyRu � sf
c K@ s� | d k ra t j | � } | j d d � d k r@ t | d <n t | d <t | d <t | | � S| d k r� t | t j j j
| � � S| d k r� t | t j j j
| � � Si | d 6i d 6t d 6d
j | � d 6S( u<
The docker_container watcher, called to invoke the watch command.
.. note::
This state exists to support special handling of the ``watch``
:ref:`requisite <requisites>`. It should not be called directly.
Parameters for this function should be set by the state being triggered.
u runningu watch_actionu forceu send_signalu stoppedu runu nameu changesu resultu* watch requisite is not implemented for {0}u comment(
t copyt deepcopyRK R R Rq R� R R R Rt R� R$ ( R9 t sfunR[ t watch_kwargs( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt mod_watch:
s
(& t __doc__t
__future__R R R R� t loggingR� t salt.exceptionsR t salt.utils.argsR t salt.utils.datat salt.utils.dockert salt.extR t getLoggert __name__RD R t __virtual_aliases__R R R R1 R8 R R R R t dockert CLIENT_TIMEOUTRq R� R� R� Ru R� ( ( ( s@ /usr/lib/python2.7/site-packages/salt/states/docker_container.pyt <module>/ sl G � � � � � � � V� � @ B
Mini Shell