Current File : //usr/lib/python2.7/site-packages/salt/modules/dockermod.pyo
�
���^c @@ s� d Z d d l m Z d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l
Z
d d l Z d d l Z d d l
Z
d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z m Z d d l m Z d d l m Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l! Z d d l Z d d l" Z d d l# m$ Z$ d d l% Z y d d l& Z& e' Z( Wn e) k
r�e* Z( n Xy1 e j+ r�d d l, j- Z- n d d l- Z- e' Z. Wn e) k
re* Z. n Xy d d l/ Z/ e' Z0 Wn e) k
r8e* Z0 n Xe1 e j2 j3 j4 d � � Z5 e
j6 e7 � Z8 i d
d 6d d
6d d 6d d 6d d 6d d 6d d 6Z9 d d d f Z: d d d f Z; d Z< e= � Z> d Z? d d f Z@ d g ZA i d d 6d d 6d d 6ZB d! � ZC d" e jD f d# � � YZE d$ � ZF e> d% � ZG d& � ZH d' � ZI d( � ZJ d) � ZK d* � ZL d+ � ZM d, � ZN d- � ZO eP d. � ZQ d/ � ZR d0 � ZS d1 � ZT d2 � ZU eI d3 � � ZV d4 � ZW d5 � ZX d6 � ZY d7 � ZZ d8 � Z[ eP d9 � Z\ eP e* e' eP d: � Z] eP d; � Z^ e j2 j j_ e^ d< � Z` d= � Za d> d? � Zb e* d@ � Zc dA � Zd dB � Ze dC � Zf dD � Zg e* dE � Zh e* dF � Zi dG � Zj dH � Zk dI � Zl dJ � Zm dK � Zn dL � Zo dM � Zp eP dN � Zq dO � Zr dP � Zs eP dQ � Zt eP dR � Zu dS � Zv e* e* dT � Zw dU � Zx dV � Zy dW � Zz eJ eP e* eP e* e' e j2 j& j{ dX � � Z| eJ eP eP e* e' e j2 j& j{ e* e* e* eP dY � � Z} e* e* dZ � Z~ e j2 j j_ e~ d[ � Z eP e* e* d\ � Z� e* e* eP d] � Z� eJ e* e* d^ � � Z� d_ � Z� eP eP eP e' e' e* eP eP eP eP d` �
Z� da eP eP eP db � Z� e* e* dc � Z� da e* eP dd � Z� eP eP eP de � Z� df � Z� e* e* e j2 j& j{ dg � Z� e* e* e j2 j& j{ dh � Z� di � Z� e* e* eP dj � Z� da e* eP dk � Z� eP eP dl � Z� eP e* e' e j2 j& j{ dm � Z� dn � Z� do � Z� dp � Z� dq � Z� dr � Z� eP ds � Z� eP eP dt � Z� du � Z� dv � Z� eJ dw � � Z� eJ dx � � Z� e j2 j j_ e� dy � Z� dz d{ � Z� eJ d| � � Z� eJ d} � � Z� eJ eP d~ � � Z� eJ d � � Z� e j2 j j_ e� d� � Z� e* e* d� � Z� e* e* e* e* e* eP d� � Z� eJ eP eP eP e' d� e* e* eP d� � � Z� eJ d� eP eP eP eP e' d� e* e* eP d� �
� Z� eP eP e' d� e* e* eP d� � Z� eP eP e' d� e* e* eP d� � Z� eP eP e' d� e* e* eP d� � Z� eP eP e' d� e* e* eP d� � Z� eP eP e' d� e* e* eP d� � Z� d� eP eP eP eP e' d� e* e* eP d� �
Z� d� eP eP eP eP e' d� e* e* eP d� �
Z� d� � Z� d� � Z� eP eP d� d� � Z� eP d� � Z� d� � Z� eP d� � Z� eP d� � Z� d� d� � Z� da d� eP e* d� � Z� d S(� sV
Management of Docker Containers
.. versionadded:: 2015.8.0
.. versionchanged:: 2017.7.0
This module has replaced the legacy docker execution module.
:depends: docker_ Python module
.. _`create_container()`: http://docker-py.readthedocs.io/en/stable/api.html#docker.api.container.ContainerApiMixin.create_container
.. _`create_host_config()`: http://docker-py.readthedocs.io/en/stable/api.html#docker.api.container.ContainerApiMixin.create_host_config
.. _`connect_container_to_network()`: http://docker-py.readthedocs.io/en/stable/api.html#docker.api.network.NetworkApiMixin.connect_container_to_network
.. _`create_network()`: http://docker-py.readthedocs.io/en/stable/api.html#docker.api.network.NetworkApiMixin.create_network
.. _`logs()`: http://docker-py.readthedocs.io/en/stable/api.html#docker.api.container.ContainerApiMixin.logs
.. _`IPAM pool`: http://docker-py.readthedocs.io/en/stable/api.html#docker.types.IPAMPool
.. _docker: https://pypi.python.org/pypi/docker
.. _docker-py: https://pypi.python.org/pypi/docker-py
.. _lxc-attach: https://linuxcontainers.org/lxc/manpages/man1/lxc-attach.1.html
.. _nsenter: http://man7.org/linux/man-pages/man1/nsenter.1.html
.. _docker-exec: http://docs.docker.com/reference/commandline/cli/#exec
.. _`docker-py Low-level API`: http://docker-py.readthedocs.io/en/stable/api.html
.. _timelib: https://pypi.python.org/pypi/timelib
.. _`trusted builds`: https://blog.docker.com/2013/11/introducing-trusted-builds/
.. _`Docker Engine API`: https://docs.docker.com/engine/api/v1.33/#operation/ContainerCreate
.. 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-authentication:
Authentication
--------------
If you have previously performed a ``docker login`` from the minion, then the
credentials saved in ``~/.docker/config.json`` will be used for any actions
which require authentication. If not, then credentials can be configured in
Pillar data. The configuration schema is as follows:
.. code-block:: yaml
docker-registries:
<registry_url>:
username: <username>
password: <password>
For example:
.. code-block:: yaml
docker-registries:
hub:
username: foo
password: s3cr3t
.. note::
As of the 2016.3.7, 2016.11.4, and 2017.7.0 releases of Salt, credentials
for the Docker Hub can be configured simply by specifying ``hub`` in place
of the registry URL. In earlier releases, it is necessary to specify the
actual registry URL for the Docker Hub (i.e.
``https://index.docker.io/v1/``).
More than one registry can be configured. Salt will look for Docker credentials
in the ``docker-registries`` Pillar key, as well as any key ending in
``-docker-registries``. For example:
.. code-block:: yaml
docker-registries:
'https://mydomain.tld/registry:5000':
username: foo
password: s3cr3t
foo-docker-registries:
https://index.foo.io/v1/:
username: foo
password: s3cr3t
bar-docker-registries:
https://index.bar.io/v1/:
username: foo
password: s3cr3t
To login to the configured registries, use the :py:func:`docker.login
<salt.modules.dockermod.login>` function. This only needs to be done once for a
given registry, and it will store/update the credentials in
``~/.docker/config.json``.
.. note::
For Salt releases before 2016.3.7 and 2016.11.4, :py:func:`docker.login
<salt.modules.dockermod.login>` is not available. Instead, Salt will try to
authenticate using each of your configured registries for each push/pull,
behavior which is not correct and has been resolved in newer releases.
Configuration Options
---------------------
The following configuration options can be set to fine-tune how Salt uses
Docker:
- ``docker.url``: URL to the docker service (default: local socket).
- ``docker.version``: API version to use (should not need to be set manually in
the vast majority of cases)
- ``docker.exec_driver``: Execution driver to use, one of ``nsenter``,
``lxc-attach``, or ``docker-exec``. See the :ref:`Executing Commands Within a
Running Container <docker-execution-driver>` section for more details on how
this config parameter is used.
These configuration options are retrieved using :py:mod:`config.get
<salt.modules.config.get>` (click the link for further information).
.. _docker-execution-driver:
Executing Commands Within a Running Container
---------------------------------------------
.. note::
With the release of Docker 1.13.1, the Execution Driver has been removed.
Starting in versions 2016.3.6, 2016.11.4, and 2017.7.0, Salt defaults to
using ``docker exec`` to run commands in containers, however for older Salt
releases it will be necessary to set the ``docker.exec_driver`` config
option to either ``docker-exec`` or ``nsenter`` for Docker versions 1.13.1
and newer.
Multiple methods exist for executing commands within Docker containers:
- lxc-attach_: Default for older versions of docker
- nsenter_: Enters container namespace to run command
- docker-exec_: Native support for executing commands in Docker containers
(added in Docker 1.3)
Adding a configuration option (see :py:func:`config.get
<salt.modules.config.get>`) called ``docker.exec_driver`` will tell Salt which
execution driver to use:
.. code-block:: yaml
docker.exec_driver: docker-exec
If this configuration option is not found, Salt will use the appropriate
interface (either nsenter_ or lxc-attach_) based on the ``Execution Driver``
value returned from ``docker info``. docker-exec_ will not be used by default,
as it is presently (as of version 1.6.2) only able to execute commands as the
effective user of the container. Thus, if a ``USER`` directive was used to run
as a non-privileged user, docker-exec_ would be unable to perform the action as
root. Salt can still use docker-exec_ as an execution driver, but must be
explicitly configured (as in the example above) to do so at this time.
If possible, try to manually specify the execution driver, as it will save Salt
a little work.
This execution module provides functions that shadow those from the :mod:`cmd
<salt.modules.cmdmod>` module. They are as follows:
- :py:func:`docker.retcode <salt.modules.dockermod.retcode>`
- :py:func:`docker.run <salt.modules.dockermod.run>`
- :py:func:`docker.run_all <salt.modules.dockermod.run_all>`
- :py:func:`docker.run_stderr <salt.modules.dockermod.run_stderr>`
- :py:func:`docker.run_stdout <salt.modules.dockermod.run_stdout>`
- :py:func:`docker.script <salt.modules.dockermod.script>`
- :py:func:`docker.script_retcode <salt.modules.dockermod.script_retcode>`
Detailed Function Documentation
-------------------------------
i ( t absolute_imports restructuredtext enN( t CommandExecutionErrort SaltInvocationError( t six( t map( t HighStatet nsentert importt import_t pst ps_t rmt rm_t signalt signal_t startt start_t tagt tag_t applyt apply_i i i s ([\d.]+)t dockert dockerngt mobyt highstatet slsc C@ s t ry
t � } Wn t k
r- t d f SX| d k rD t d f S| t k r� y t � j d � } Wn t k
r d } n X| d k s� | t k r� t St d j
d j t t
t � � d j t t
| � � � f Sn t d j
d j t t
t � � d j t t
| � � � f St d f S( s.
Only load if docker libs are present
s6 Docker module found, but no version could be extractedt VersionInfos; Insufficient Docker version (required: {0}, installed: {1})t .s> Insufficient docker-py version (required: {0}, installed: {1})s7 Could not import docker module, is docker-py installed?N( t
HAS_DOCKER_PYt _get_docker_py_versioninfot Exceptiont Falset Nonet
MIN_DOCKER_PYt versiont gett
MIN_DOCKERt __virtualname__t formatt joinR t str( t docker_py_versioninfot docker_versioninfo( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt __virtual__ s.
t DockerJSONDecoderc B@ s e Z d d � Z RS( c C@ sO g } xB | j � D]4 } | s% q n | j | � \ } } | j | � q W| S( N( t
splitlinest
raw_decodet append( t selft st _wt objst linet objt _( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt decodeC s N( t __name__t
__module__R R7 ( ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR, B s c C@ s# y t j SWn t k
r n Xd S( s7
Returns the version_info tuple from docker-py
N( R t version_infot AttributeError( ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR M s
c
K@ s� i } | t k r | | d <n xF d d f D]8 \ } } t d | t � } | t k r, | | | <q, q, Wd | k r� d t j k r� t j j d � | d <n d | k r� d | d <n t d d t � } | t k r�t d
d d | g d
t �} y� t j j j | � } | d d } | d d } d | d | d <t
j j d | d | d f d | d d t d t
� | d <Wq�t k
r�}
t d j | |
� � � q�Xn y t
j | � } Wn t k
r�t
j | � } n Xt j d t | d d � � | S(! Nt timeoutt base_urls
docker.urlR" s docker.versions
config.gett DOCKER_HOSTt autos docker.machines cmd.runs docker-machinet inspectt python_shellt HostOptionst AuthOptionst Drivert IPAddresss https://s :2376t client_certt ClientCertPatht
ClientKeyPatht ca_certt
CaCertPatht assert_hostnamet verifyt tlss Docker machine {0} failed: {1}s docker-py API version: %st api_version( R= s
docker.url( s versions docker.version( t NOTSETt __salt__t ost environR# R t saltt utilst jsont loadsR RM t TLSConfigt TrueR R R& t APIClientR; t Clientt logt debugt getattrR ( R< t kwargst
client_kwargst keyt valt paramt docker_machinet docker_machine_jsont docker_machine_tlst docker_machine_ipt exct ret( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _get_clientW sJ
c C@ sL | j d i � j d t � r" d S| j d i � j d t � rD d Sd Sd S( s^
Helper for deriving the current state of the container from the inspect
results.
t Statet Pausedt pausedt Runningt runningt stoppedN( R# R ( t inspect_results( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt
_get_state� s
c @ s" t j � � � f d � � } | S( s^
Decorator to run a function that requires the use of a docker.Client()
instance.
c @ s� t d | � } | j d t � } d t k sB t t d d � r[ t d | | � t d <n d } | t k r� t t d d � r� t d j | k r� t d j } | t d _ n � | | � } | d k r� | t d _ n | S( s3
Ensure that the client is present
s args.clean_kwargst client_timeouts
docker.clientR< N( t __utils__t popRO t __context__t hasattrRi R R< ( t argsR^ R< t orig_timeoutRh ( t wrapped( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt wrapper� s
( t functoolst wraps( Ry Rz ( ( Ry s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _docker_client� s c @ s" t j � � � f d � � } | S( s;
Decorator to trigger a refresh of salt mine data.
c @ sI � | t d | � � } t � rE t d d d t d t d t �n | S( s,
refresh salt mine on exit.
s args.clean_kwargss mine.sends docker.pst verboset allt host( Rs t _check_update_mineRP RX ( Rw R^ t returned( Ry ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRz � s #( R{ R| ( Ry Rz ( ( Ry s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _refresh_mine_cache� s c C@ sD y t d } Wn/ t k
r? t d d d t �} t d <n X| S( Ns docker.update_mines
config.gett default( Ru t KeyErrorRP RX ( Rh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s
"c O@ s� t | � } | d k rW | | k rW i t d 6i | d 6| d 6d 6d j | | � d 6St | | | | � t � y t | � } Wn t k
r� d } n Xi | | k d 6i | d 6| d 6d 6} | S( s)
Change the state of a container
t restartt resultt oldt newt states Container '{0}' already {1}t commentN( R� R R& t _client_wrappert _clear_contextR R ( t namet actiont expectedRw R^ t pret postRh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt
_change_state� s
c C@ sd d } xW t t � D]I } y/ | j d � rG | | k rG t j | � n Wq t k
r[ q Xq Wd S( s9
Clear the state/exists values stored in context
s
docker.clients docker.exec_drivers docker._pull_statuss docker.docker_versions docker.docker_py_versions docker.N( s
docker.clients docker.exec_drivers docker._pull_statuss docker.docker_versions docker.docker_py_version( t listRu t
startswithRt R; ( t keep_contextR` ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s
c C@ sR t | d j t j | � � d t �} y | j � d SWn t k
rM d SXd S( s9
Get the MD5 checksum of a file from a container
s
md5sum {0}t ignore_retcodei N( t
run_stdoutR& t pipest quoteRX t splitt
IndexErrorR ( R� t patht output( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _get_md5� s
c C@ s� d } | t k r� t d | d � } | d k r? | t | <| St � j d d � } | d k rm | t | <q� | j d � r� d t | <q� | j d � r� t r� d t | <q� | j � r� t r� t j d � d t | <q� t
d
j | � � � n t | S( s5
Get the method to be used in shell commands
s docker.exec_drivers
config.gett ExecutionDrivers docker-execs lxc-s
lxc-attachs native-R s� ExecutionDriver from 'docker info' is blank, falling back to using 'nsenter'. To squelch this warning, set docker.exec_driver. See the Salt documentation for the docker module for more information.sW Unknown docker ExecutionDriver '{0}', or didn't find command to attach to the containerN( Ru RP R t infoR# R� t HAS_NSENTERt stripR[ t warningt NotImplementedErrorR& ( t
contextkeyt from_configt driver( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _get_exec_driver s*
c C@ s� y` g | D] } | | d ^ q
} | d k r6 | n | } g | D] } | | k rC | ^ qC SWn, t t f k
r� t d j | � � � n Xd S( s�
Returns a list of the top-level images (those which are not parents). If
``subset`` (an iterable) is passed, the top-level images in the subset will
be returned, otherwise all top-level images will be returned.
t ParentIdsd Invalid image data passed to _get_top_level_images(). Please report this issue. Full image data: {0}N( R R� t TypeErrorR R& ( t imagedatat subsett xt parentst filter_( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _get_top_level_images, s !'c C@ s. g t d t � D] } | d ^ q t d <d S( s�
Populate __context__ with the current (pre-pull) image IDs (see the
docstring for _pull_status for more information).
R i s docker._pull_statusN( t imagesRX Ru ( R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt
_prep_pull= s c C@ sX t | t � rN g } x< | D]+ } | j | j d j | � d d � � q Wn | } | S( sx
Remove container name from HostConfig:Links values to enable comparing
container configurations correctly.
s /{0}/t /i ( t
isinstanceR� R/ t replaceR& ( t linksR� Rh t l( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _scrub_linksE s
,c C@ s& t | t � r" t | d d � �S| S( NR` c S@ s. | j d � | j d d � | j d d � f S( Nt Namet Hardi t Soft( R# ( R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt <lambda>W s ( R� R� t sorted( t
ulimit_val( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _ulimit_sortT s
c C@ s� yj t | � } | d k r( d j | � S| d :} x4 d
D], } | d k r[ d j | | � S| d :} q9 WWn" t k
r� t j d
| � d SXd S( s3
Format bytes as human-readable file sizes
i s {0} bytesg �@t KiBt MiBt GiBt TiBt PiBs {0:3.1f} {1}s# Unable to format file size for '%s't unknownN( R� R� R� R� R� ( t intR& R R[ t error( t numt unit( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _size_fmt] s
c O@ s� | j d t � } t t d | d � } | d k sD t | d � r\ t d j | � � � n | d
k r� y t d j � Wq� t k
r� q� Xn d } y) t
j d | | | � | | | � } Wn� t j
j k
r} | rt d j | j j | j � � � qU� nM t j
j k
r2} t | j � � � n# t k
rP} | j � } n X| Sd
j | � } | r�| d j | � 7} n t | � � d S( s>
Common functionality for running low-level API calls
t catch_api_errorss
docker.clientt __call__s Invalid client action '{0}'t pusht pullt sF Attempting to run docker-py's "%s" function with args=%s and kwargs=%ss Error {0}: {1}s Unable to perform {0}s : {0}N( s pushs pull( Rt RX R] Ru R Rv R R& t
reload_configR; R[ R\ R t errorst APIErrorR t responset status_codet explanationt DockerExceptiont __str__R ( t attrRw R^ R� t funct errRh Rg t msg( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� o s<
c C@ so | d } d | k rB | j d g � j | j � j � d � n d | k rk | j � j � d | d <n d S( sR
Process a status update from a docker build, updating the data structure
t streams
Running int Intermediate_Containersi����s Successfully builtt IdN( t
setdefaultR/ t rstripR� ( t datat itemR� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt
_build_status� s
c C@ su | d } yM d | k r d St d � | D� � rV d j | | � | d <| | d <n Wn t t f k
rp n Xd S( sQ
Process a status update from docker import, updating the data structure
t statuss Downloading fromNc s@ s | ] } | t j k Vq d S( N( t stringt hexdigits( t .0R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pys <genexpr>� s s {0}:{1}t ImageR� ( R R& R; R� ( R� R� t repo_namet repo_tagR� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _import_status� s
c @ s� � f d � } � f d � } d t k rD t j d � t t d <n | d } | d k rk | | d � n� | d k r� | | d � ns | j d � r� | d
� d <nS | d k r� t d t k r� | d } | t d k r� | | � q� | | � q� n d
S( sp
Process a status update from a docker pull, updating the data structure.
For containers created with older versions of Docker, there is no
distinction in the status updates between layers that were already present
(and thus not necessary to download), and those which were actually
downloaded. Because of this, any function that needs to invoke this
function needs to pre-fetch the image IDs by running _prep_pull() in any
function that calls _pull_status(). It is important to grab this
information before anything is pulled so we aren't looking at the state of
the images post-pull.
We can't rely on the way that __context__ is utilized by the images()
function, because by design we clear the relevant context variables once
we've made changes to allow the next call to images() to pick up any
changes that were made.
c @ s> � j d i � j d g � } | | k r: | j | � n d S( s&
Layer already exists
t Layerst Already_PulledN( R� R/ ( t id_t already_pulled( R� ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _already_exists� s c @ s> � j d i � j d g � } | | k r: | j | � n d S( s$
Pulled a new layer
R� t PulledN( R� R/ ( R� t pulled( R� ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt
_new_layer� s s docker._pull_statuss� _pull_status context variable was not populated, information on downloaded layers may be inaccurate. Please report this to the SaltStack development team, and if possible include the image (and tag) that was being pulled.R� s Already existst ids
Pull completes Status: i t Statuss Download completeN( Ru R[ R� RO R� ( R� R� R� R� R� R� ( ( R� s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _pull_status� s&
c C@ s� | d j � } d | k r� d | k s4 d | k rf | j d i � j d g � } | j | d � q� d | k s~ | d k r� | j d i � j d g � } | j | d � q� n d
S( sQ
Process a status update from a docker push, updating the data structure
R� R� s already pusheds already existsR� t Already_Pusheds successfully pushedt pushedt PushedN( t lowerR� R/ ( R� R� R� t already_pushedR� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _push_status� s c C@ s� | d } d | k rx y) d j | d d | d d f � } Wq� t k
rt d j | d d | d d � } q� Xn | d d } | j | � d S( s;
Process an API error, updating the data structure
t errorDetailt codes : t messages {0}: {1}N( R' R� R& R/ ( R� R� R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt
_error_detail s
c C@ s t d d | � S( s{
.. versionadded:: 2016.3.6,2016.11.4,2017.7.0
.. versionchanged:: 2017.7.0
Replaced the container config args with the ones from the API's
``create_container`` function.
.. versionchanged:: 2018.3.0
Added ability to limit the input to specific client functions
Many functions in Salt have been written to support the full list of
arguments for a given function in the `docker-py Low-level API`_. However,
depending on the version of docker-py installed on the minion, the
available arguments may differ. This function will get the arguments for
various functions in the installed version of docker-py, to be used as a
reference.
limit
An optional list of categories for which to limit the return. This is
useful if only a specific set of arguments is desired, and also keeps
other function's argspecs from needlessly being examined.
**AVAILABLE LIMITS**
- ``create_container`` - arguments accepted by `create_container()`_ (used
by :py:func:`docker.create <salt.modules.dockermod.create>`)
- ``host_config`` - arguments accepted by `create_host_config()`_ (used to
build the host config for :py:func:`docker.create
<salt.modules.dockermod.create>`)
- ``connect_container_to_network`` - arguments used by
`connect_container_to_network()`_ to construct an endpoint config when
connecting to a network (used by
:py:func:`docker.connect_container_to_network
<salt.modules.dockermod.connect_container_to_network>`)
- ``create_network`` - arguments accepted by `create_network()`_ (used by
:py:func:`docker.create_network <salt.modules.dockermod.create_network>`)
- ``ipam_config`` - arguments used to create an `IPAM pool`_ (used by
:py:func:`docker.create_network <salt.modules.dockermod.create_network>`
in the process of constructing an IPAM config dictionary)
CLI Example:
.. code-block:: bash
salt myminion docker.get_client_args
salt myminion docker.get_client_args logs
salt myminion docker.get_client_args create_container,connect_container_to_network
s docker.get_client_argst limit( Rs ( R ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt get_client_args s /c
K@ s� | j d i � } | j d d � | k rF i | | d | d 6} n i } t d t j j j j d | d | d | t d | � �} | r� t | � | d <n | d k r y t
d
d g � } Wq t k
r} t j
d | j � d
t �t d j | � � � q Xn i } i } i } x� t | � D]} }
|
| d k rZ| j |
� | |
<q+n |
| d
k r+|
d k r�| j | j |
� � q+| j |
� | |
<q+q+q+Wt d | � | d <| d j | � | | f S( sl
Take input kwargs and return a kwargs dict to pass to docker-py's
create_container() function.
t networkst network_modeR� s docker.translate_inputt skip_translatet ignore_collisionst validate_ip_addrss args.clean_kwargst networking_configt create_containert host_configs. docker.create: Error getting client args: '%s't exc_infos Failed to get client args: {0}t create_host_configN( Rt R# Rs RS RT R t translatet containert _create_networking_configR R R R[ R� R� RX R& R� t updateR� ( R R R t client_argsR^ R Rg t full_host_configt host_kwargst
create_kwargst arg( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _get_create_kwargsQ sF
c
C@ s� t d | p g � } t | � } t | � } i } x�d D]�} x�| | D]�} | | k rd qL n | | | } | | j | � } | d
k s� | d k s� | d k r� t | � t | � k ri | d 6| d 6| j | i � | <qqL | d k rMt | � d }
t | � d } |
| k ri |
d 6| d 6| j | i � | <qqL | d k r�t t | | � � } t t | | � � } n | d
k r�t | � } t | � } n | d k r�t | � } t | � } n | | k rL i | d 6| d 6| j | i � | <qL qL Wx�| | D]�} | | k s| | j | i � k rFqn | | j | � } | | | } | d k s�| d k s�| d k r�t | � t | � k r�i | d 6| d 6| j | i � | <q�q| d k r/t | � d }
t | � d } |
| k r�i |
d 6| d 6| j | i � | <q�q| d k rht t | | � � } t t | | � � } n | d
k r�t | � } t | � } n | d k r�t | � } t | � } n | | k ri | d 6| d 6| j | i � | <qqWq; W| S( s
.. versionadded:: 2017.7.0
.. versionchanged:: 2018.3.0
Renamed from ``docker.compare_container`` to
``docker.compare_containers`` (old function name remains as an alias)
Compare two containers' Config and and HostConfig and return any
differences between the two.
first
Name or ID of first container
second
Name or ID of second container
ignore
A comma-separated list (or Python list) of keys to ignore when
comparing. This is useful when comparing two otherwise identical
containers which have different hostnames.
CLI Examples:
.. code-block:: bash
salt myminion docker.compare_containers foo bar
salt myminion docker.compare_containers foo bar ignore=Hostname
s args.split_inputt Configt
HostConfigt OomKillDisableR� R� R� R� t Linkst Ulimitst Env( R R ( R N( R (
Rs t inspect_containerR# R t boolR� t
inspect_imageR� R� R� ( t firstt secondt ignoret result1t result2Rh t conf_dictR� t val1t val2t image1t image2( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt compare_containers� sl
$* * +$$* * /t compare_containerc @ s� d � } t d � t | t � s. t | � n | } t | t � sO t | � n | } | | � � | | � � t | � } t | � } t � � } | j � � x� | D]� } y t | � j d i � } Wn) t k
r� }
t
j d | |
� q� q� X| d k r%| � k r%| d | k r%� | =n | d k r� | � k r� | d | k r� � | =q� q� Wi } � � � f d � } x� � f d � � D� D]� } x� � j d g � D]� }
� | j |
� } |
d
k r�| | | d | �n | r�|
d k r5y | j | d
d � Wn t
t f k
r%q5X| s5q�q5n i | d 6d d 6| j | i � |
<q�q�Wq�Wx~� D]v} | � k rPxa� j d g � D]� }
� | j |
� } |
d
k r�| | | d | �q�q�| r�|
d k r"y | j | d
d � Wn t
t f k
rq"X| s"q�q"n i d d 6| d 6| j | i � |
<q�q�Wqkx�� j d g � D]z}
� | |
} � | |
} x6 | | f D]( } y | j � Wq�t k
r�q�Xq�W|
d k rQy | j | d
d � Wn t t
f k
r�n X| s d } n y | j | d
d � Wn t t
f k
r>n X| s|d } q|n+ |
d
k r|| | | d | d | �qcn t | � t | � k o�t k n r�qcqc| | k rci | d 6| d 6| j | i � |
<qcqcWqkW| S( s�
.. versionadded:: 2018.3.0
Returns the differences between two containers' networks. When a network is
only present one of the two containers, that network's diff will simply be
represented with ``True`` for the side of the diff in which the network is
present) and ``False`` for the side of the diff in which the network is
absent.
This function works by comparing the contents of both containers'
``Networks`` keys (under ``NetworkSettings``) in the return data from
:py:func:`docker.inspect_container
<salt.modules.dockermod.inspect_container>`. Because each network contains
some items that either A) only set at runtime, B) naturally varying from
container to container, or both, by default the following keys in each
network are examined:
- **Aliases**
- **Links**
- **IPAMConfig**
The exception to this is if ``IPAMConfig`` is unset (i.e. null) in one
container but not the other. This happens when no static IP configuration
is set, and automatic IP configuration is in effect. So, in order to report
on changes between automatic IP configuration in one container and static
IP configuration in another container (as we need to do for the
:py:func:`docker_container.running <salt.states.docker_container.running>`
state), automatic IP configuration will also be checked in these cases.
This function uses the :conf_minion:`docker.compare_container_networks`
minion config option to determine which keys to examine. This provides
flexibility in the event that features added in a future Docker release
necessitate changes to how Salt compares networks. In these cases, rather
than waiting for a new Salt release one can just set
:conf_minion:`docker.compare_container_networks`.
.. note::
The checks for automatic IP configuration described above only apply if
``IPAMConfig`` is among the keys set for static IP checks in
:conf_minion:`docker.compare_container_networks`.
first
Name or ID of first container (old)
second
Name or ID of second container (new)
CLI Example:
.. code-block:: bash
salt myminion docker.compare_container_networks foo bar
c S@ s | j d i � j d i � S( Nt NetworkSettingst Networks( R# ( R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _get_nets" s s! docker.compare_container_networkst
Containerss' Failed to inspect Docker network %s: %sRn R� c @ s� d | k } | r t } n t | d � } | o6 | } d | k } | rT t } n t | d � } | oo | } � j d g � } | rm| s� | rmxN | D]F }
� � j |
� } | r� i | d 6d d 6� j � i � |
<q� q� W| ri d d 6| d d 6� j � i � d <n t � � f d � | D� � s�i d d 6| rMd n d d 6� j � i � d <q�n:| rV| s| rVxN | D]F }
� � j |
� } | r�i d d 6| d 6� j � i � |
<q�q�Wt � � f d � | D� � s"i | r�d n d d 6d d 6� j � i � d <n | r�i | d d 6d d 6� j � i � d <q�nQ | j d � } | j d � }
| |
k r�i | d 6|
d 6� j � i � d <n d S(
NR� R� t automatict
IPAMConfigc 3@ s' | ] } | � j � i � k Vq d S( N( R# ( R� R� ( t net_nameRh ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pys <genexpr>j s t statics
not connectedt IPConfigurationc 3@ s' | ] } | � j � i � k Vq d S( N( R# ( R� R� ( R3 Rh ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pys <genexpr>v s ( R R R# R R� t any( Rh R3 R^ t
nets1_missingt nets1_statict nets1_autoipt
nets2_missingt nets2_statict nets2_autoipt autoip_keyst
autoip_keyt
autoip_valt old_valt new_val( t compare_keyst nets1t nets2( R3 Rh s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _check_ipconfigN sT
(( ,
( + c 3@ s! | ] } | � k r | Vq d S( N( ( R� R� ( RD ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pys <genexpr>� s R4 R2 R� t AliasesR t HostnameR� N( t __opts__R� t dictR R� t setR t inspect_networkR# R R[ R� t removet
ValueErrorR; R R� t sortR R ( R! R" R/ R$ R% t state1t state2t all_netsR3 t connected_containersRg Rh RE R` Ra R@ RA R� ( ( RB RC RD s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt compare_container_networks� s� 7
; /
.
( ,s Name,Id,Created,Containersc @ s� t d � p g � � t | t � s1 t | � n | } t | t � sR t | � n | } i } x�| D]�} | � k r} qe n
� j | � | | } | j | � } t | � t | � k o� t k n r� qe qe | d k r�x1| D]� } | | }
| j | � } t |
� t | � k o&t k n r1q� q� | d k r�d � } t | d d | �}
t | j d g � d | �} |
| k r�i |
d 6| d 6| j d i � d <q�q� |
| k r� i |
d 6| d 6| j d i � | <q� q� Wqe | | k re i | d 6| d 6| | <qe qe Wx� � f d � | D� D]t } | j | � } | | } t | � t | � k ont k n ryq,q,| | k r,i | d 6| d 6| | <q,q,W| S( s�
.. versionadded:: 2018.3.0
Compare two networks and return any differences between the two
first
Name or ID of first container
second
Name or ID of second container
ignore : Name,Id,Created,Containers
A comma-separated list (or Python list) of keys to ignore when
comparing.
CLI Example:
.. code-block:: bash
salt myminion docker.compare_network foo bar
s args.split_inputt IPAMR c S@ s( t t j | � � t t j | � � f S( N( R� R t iterkeyst
itervalues( R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� s R` R� R� c 3@ s! | ] } | � k r | Vq d S( N( ( R� R� ( R# ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pys <genexpr> s (
Rs R� RI RK R/ R# R R R� R� ( R! R" R# t net1t net2Rh R� R' R( t subkeyt subval1t subval2t kvsortt config1t config2( ( R# s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt compare_networks� sL !!
(
( ' +
( c C@ s� t | � j d i � } i } xw t j | � D]f \ } } y | j d � } Wn0 t t f k
r t j d | | | � q. q. X| | d <| | | <q. W| s� t | � S| S( s`
.. versionadded:: 2018.3.0
Return a list of running containers attached to the specified network
name
Network name
verbose : False
If ``True``, return extended info about each container (IP
configuration, etc.)
CLI Example:
.. code-block:: bash
salt myminion docker.connected net_name
R0 R� s� 'Name' key not present in container definition for container ID '%s' within inspect results for Docker network '%s'. Full container definition: %sR� (
RK R# R t iteritemsRt R� R; R[ R� R� ( R� R~ t
containersRh t cidt cinfo( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt connected! s
c
G@ s� t j d i � } i d d 6} | j d g � } t | t � sV | j d � i } n x� t j t � D]q \ } } yQ | j d � r� y | j | � Wq� t
k
r� | j d j | � � q� Xn Wqf t k
r� qf Xqf W| s� t
| � } n | j d i � } xq| D]i} | | k r7| j d j | � � q n y | | d
} | | d } WnR t
k
r�| j d j | � � q t k
r�}
| j d
j |
| � � q Xd d d | d | g } | j � d k r�| j | � n t j d | | � t d | d t d d �} | d d k | | <| | s | d rQ| j | d � qr| d rr| j | d � qrq q W| r�d | d <n | S( s�
.. versionadded:: 2016.3.7,2016.11.4,2017.7.0
Performs a ``docker login`` to authenticate to one or more configured
repositories. See the documentation at the top of this page to configure
authentication credentials.
Multiple registry URLs (matching those configured in Pillar) can be passed,
and Salt will attempt to login to *just* those registries. If no registry
URLs are provided, Salt will attempt to login to *all* configured
registries.
**RETURN DATA**
A dictionary containing the following keys:
- ``Results`` - A dictionary mapping registry URLs to the authentication
result. ``True`` means a successful login, ``False`` means a failed
login.
- ``Errors`` - A list of errors encountered during the course of this
function.
CLI Example:
.. code-block:: bash
salt myminion docker.login
salt myminion docker.login hub
salt myminion docker.login hub https://mydomain.tld/registry/
s docker-registriesi t retcodet Errorss5 'docker-registries' Pillar value must be a dictionarys -docker-registriess' '{0}' Pillar value must be a dictionaryt Resultss! No match found for registry '{0}'t usernamet passwords( Invalid configuration for registry '{0}'s Missing {0} for registry '{1}'R t logins -us -pt hubs8 Attempting to login to docker registry '%s' as user '%s's cmd.run_allRA t output_loglevelt quiett stderrt stdouti ( t
__pillar__R# R� R� RI R/ R R` t endswithR R� R& R; R� R� R� R[ R\ RP R (
t
registriest
registry_authRh R� R` R� t resultst registryRh Ri Rg t cmdt login_cmd( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRj M sh "
c C@ s� t | � d } g } xj t j t d t d t � � D]J } | d d | k r5 | j g | d D] } | j d � ^ q` � q5 q5 Wi | d 6g t j t d t � � D]& \ } } | d | k r� | d
^ q� d 6S( s�
Returns the containers and images, if any, which depend on the given image
name
Name or ID of image
**RETURN DATA**
A dictionary containing the following keys:
- ``Containers`` - A list of containers which depend on the specified image
- ``Images`` - A list of IDs of images which depend on the specified image
CLI Example:
.. code-block:: bash
salt myminion docker.depends myimage
salt myminion docker.depends 0123456789ab
R� R R~ t InfoR� t NamesR� R0 R� i t Images( R R RV R
RX t extendt lstripR` R� ( R� t image_idt container_dependsR R� t y( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt depends� s %.%c C@ s� t d | � } i d d 6d d 6d d 6} i } xA | D]9 } | j | d d � } | j | g � j | d
� q7 Wd | k r� t j d | � n | S( s�
Get information on changes made to container's filesystem since it was
created. Equivalent to running the ``docker diff`` Docker CLI command.
name
Container name or ID
**RETURN DATA**
A dictionary containing any of the following keys:
- ``Added`` - A list of paths that were added.
- ``Changed`` - A list of paths that were changed.
- ``Deleted`` - A list of paths that were deleted.
These keys will only be present if there were changes, so if the container
has no differences the return dict will be empty.
CLI Example:
.. code-block:: bash
salt myminion docker.diff mycontainer
t difft Changedi t Addedi t Deletedi t Kindt Unknownt Paths� Unknown changes detected in docker.diff of container %s. This is probably due to a change in the Docker API. Please report this to the SaltStack developers( R� R# R� R/ R[ R� ( R� t changest kind_mapRh t changeR` ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s
!
c C@ sr d j | � } | t k r# t | Sy t d | d t �} Wn! t j j k
r_ t t | <n Xt t | <t | S( s
Check if a given container exists
name
Container name or ID
**RETURN DATA**
A boolean (``True`` if the container exists, otherwise ``False``)
CLI Example:
.. code-block:: bash
salt myminion docker.exists mycontainer
s docker.exists.{0}R R� ( R& Ru R� R R R� R� RX ( R� R� t c_info( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt exists s
c
C@ sp t d | � } i d d 6d d 6} t j d � } g } x t | � D]� } i } xi t j | � D]X \ } } | j | | � }
|
d k r� | s� d } q� | j d | � } n | | |
<qa Wd | k r� t j d t j
| d � � | d
<n x: d
D]2 } | | k r� t | | � | d j | � <q� q� W| j
t j | � � qE W| rlg | D] } | j d � ^ qSS| S( sF
Return the history for an image. Equivalent to running the ``docker
history`` Docker CLI command.
name
Container name or ID
quiet : False
If ``True``, the return data will simply be a list of the commands run
to build the container.
.. code-block:: bash
$ salt myminion docker.history nginx:latest quiet=True
myminion:
- FROM scratch
- ADD file:ef063ed0ae9579362871b9f23d2bc0781ef7cd4de6ac822052cf6c9c5a12b1e2 in /
- CMD [/bin/bash]
- MAINTAINER NGINX Docker Maintainers "docker-maint@nginx.com"
- apt-key adv --keyserver pgp.mit.edu --recv-keys 573BFD6B3D8FBC641079A6ABABF5BD827BD9BF62
- echo "deb http://nginx.org/packages/mainline/debian/ wheezy nginx" >> /etc/apt/sources.list
- ENV NGINX_VERSION=1.7.10-1~wheezy
- apt-get update && apt-get install -y ca-certificates nginx=${NGINX_VERSION} && rm -rf /var/lib/apt/lists/*
- ln -sf /dev/stdout /var/log/nginx/access.log
- ln -sf /dev/stderr /var/log/nginx/error.log
- VOLUME [/var/cache/nginx]
- EXPOSE map[80/tcp:{} 443/tcp:{}]
- CMD [nginx -g daemon off;]
https://github.com/saltstack/salt/pull/22421
**RETURN DATA**
If ``quiet=False``, the return value will be a list of dictionaries
containing information about each step taken to build the image. The keys
in each step include the following:
- ``Command`` - The command executed in this build step
- ``Id`` - Layer ID
- ``Size`` - Cumulative image size, in bytes
- ``Size_Human`` - Cumulative image size, in human-readable units
- ``Tags`` - Tag(s) assigned to this layer
- ``Time_Created_Epoch`` - Time this build step was completed (Epoch
time)
- ``Time_Created_Local`` - Time this build step was completed (Minion's
local timezone)
CLI Example:
.. code-block:: bash
salt myminion docker.exists mycontainer
t historyt Commandt CreatedByt Time_Created_Epocht Createds ^/bin/sh -c (?:#\(nop\) )?s FROM scratchR� s %Y-%m-%d %H:%M:%S %Zt Time_Created_Localt Sizes {0}_Human( R� ( R� t ret compilet reversedR R` R# t subt timet strftimet localtimeR� R& R/ t copyt deepcopy(
R� Rm R� t key_mapt command_prefixRh R� t stepR` Ra t step_keyRb R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� # s4 7
$ c
K@ s" d t k r�t d d | j d t � �} i d d 6} xR| D]G} | j d d � } | d k rh q> n x� | D]{ } | d d g d f k r� d n d
} t j d i � } | j | i � } | j | | � } | | | j | i � | <qo Wd | j | i � k r4t j d t j | | d � � | | d <n xN d D]F }
|
| j | i � k r;t
| | |
� | | d j |
� <q;q;Wq> Wn t j d i � } t j
| j d
i � � } | j d t � r�| j t j
| j d i � � � n | r x% | D] } t | � | | d <q�Wn | S( st
Returns information about the Docker images on the Minion. Equivalent to
running the ``docker images`` Docker CLI command.
all : False
If ``True``, untagged images will also be returned
verbose : False
If ``True``, a ``docker inspect`` will be run on each image returned.
**RETURN DATA**
A dictionary with each key being an image ID, and each value some general
info about that image (time created, size, tags associated with the image,
etc.)
CLI Example:
.. code-block:: bash
salt myminion docker.images
salt myminion docker.images all=True
s
docker.imagesR� R R� R� R� t RepoTagss
<none>:<none>t untaggedt taggeds %Y-%m-%d %H:%M:%S %ZR� R� t VirtualSizes {0}_HumanRx N( s SizeR� ( Ru R� R# R Rt R R� R� R� R� R� R& R� R� R R (
R~ R^ R� R� t imgt img_idR� t img_statet buckett img_keyRb t context_dataRh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� | s@
%
3%
c C@ s
t d � S( s�
Returns a dictionary of system-wide information. Equivalent to running
the ``docker info`` Docker CLI command.
CLI Example:
.. code-block:: bash
salt myminion docker.info
R� ( R� ( ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s c C@ s y t | � SWn( t k
r8 } d | j k r9 � q9 n Xy t | � SWn+ t k
rt } | j j d � su � qu n Xy t | � SWn+ t k
r� } | j j d � s� � q� n Xy t | � SWn+ t k
r� } | j j d � s� � q� n Xt d j | � � � d S( s�
.. versionchanged:: 2017.7.0
Volumes and networks are now checked, in addition to containers and
images.
This is a generic container/image/volume/network inspecton function. It
will run the following functions in order:
- :py:func:`docker.inspect_container
<salt.modules.dockermod.inspect_container>`
- :py:func:`docker.inspect_image <salt.modules.dockermod.inspect_image>`
- :py:func:`docker.inspect_volume <salt.modules.dockermod.inspect_volume>`
- :py:func:`docker.inspect_network <salt.modules.dockermod.inspect_network>`
The first of these to find a match will be returned.
name
Container/image/volume/network name or ID
**RETURN DATA**
A dictionary of container/image/volume/network information
CLI Example:
.. code-block:: bash
salt myminion docker.inspect mycontainer
salt myminion docker.inspect busybox
s does not exists Error 404s6 Error 404: No such image/container/volume/network: {0}N( R R t strerrorR R� t inspect_volumeRK R& ( R� Rg ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR@ � s, !
c C@ s
t d | � S( s�
Retrieves container information. Equivalent to running the ``docker
inspect`` Docker CLI command, but will only look for container information.
name
Container name or ID
**RETURN DATA**
A dictionary of container information
CLI Example:
.. code-block:: bash
salt myminion docker.inspect_container mycontainer
salt myminion docker.inspect_container 0123456789ab
R ( R� ( R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR
s c C@ sP t d | � } x: d D]2 } | | k r t | | � | d j | � <q q W| S( s�
Retrieves image information. Equivalent to running the ``docker inspect``
Docker CLI command, but will only look for image information.
.. note::
To inspect an image, it must have been pulled from a registry or built
locally. Images on a Docker registry which have not been pulled cannot
be inspected.
name
Image name or ID
**RETURN DATA**
A dictionary of image information
CLI Examples:
.. code-block:: bash
salt myminion docker.inspect_image busybox
salt myminion docker.inspect_image centos:6
salt myminion docker.inspect_image 0123456789ab
R R� R� s {0}_Human( s Sizes VirtualSize( R� R� R& ( R� Rh Rb ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR " s
$c K@ s� t � } x� t j t d | j d t � � � D]a } | j d � } | sO q. n x= g | p^ g D] } | j d � ^ q_ D] } | j | � qx Wq. Wt | � S( s�
Returns a list of containers by name. This is different from
:py:func:`docker.ps <salt.modules.dockermod.ps_>` in that
:py:func:`docker.ps <salt.modules.dockermod.ps_>` returns its results
organized by container ID.
all : False
If ``True``, stopped containers will be included in return data
CLI Example:
.. code-block:: bash
salt myminion docker.inspect_image <image>
R Ry R� ( RJ R RV R
R# R R| t addR� ( R^ Rh R� t namesR� t c_name( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt list_containersD s +/c C@ s\ t � } xF t j t � � D]2 } | j d � s7 q n | j t | d � � q Wt | � S( s}
Returns a list of tagged images
CLI Example:
.. code-block:: bash
salt myminion docker.list_tags
R� ( RJ R RV R� R# R R� ( Rh R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt list_tags^ s
c C@ sS y t | � } | d SWn4 t k
r+ n$ t k
rN t j d | | � n Xt S( s�
.. versionadded:: 2018.3.0
Given an image name (or partial image ID), return the full image ID. If no
match is found among the locally-pulled images, then ``False`` will be
returned.
CLI Examples:
.. code-block:: bash
salt myminion docker.resolve_image_id foo
salt myminion docker.resolve_image_id foo:bar
salt myminion docker.resolve_image_id 36540f359ca3
R� sF Inspecting docker image '%s' returned an unexpected data structure: %s( R R R� R[ R� R ( R� t inspect_result( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt resolve_image_idp s
c K@ s� t d | � } | j d t � } | r9 t d | � n | d k rY t d d d � n y5 t | � } | d } | r� | r� | Sn | d SWnE t k
r� t St k
r� t j d | | � n t k
r� n X| r� | d
g S| d
S( s�
.. versionadded:: 2017.7.2
.. versionchanged:: 2018.3.0
Instead of matching against pulled tags using
:py:func:`docker.list_tags <salt.modules.dockermod.list_tags>`, this
function now simply inspects the passed image name using
:py:func:`docker.inspect_image <salt.modules.dockermod.inspect_image>`
and returns the first matching tag. If no matching tags are found, it
is assumed that the passed image is an untagged image ID, and the full
ID is returned.
Inspects the specified image name and returns the first matching tag in the
inspect results. If the specified image is not pulled locally, this
function will return ``False``.
name
Image name to resolve. If the image is found but there are no tags,
this means that the image name passed was an untagged image. In this
case the image ID will be returned.
all : False
If ``True``, a list of all matching tags will be returned. If the image
is found but there are no tags, then a list will still be returned, but
it will simply contain the image ID.
.. versionadded:: 2018.3.0
tags
.. deprecated:: 2018.3.0
Ignored if passed, will be removed in the Neon release.
CLI Examples:
.. code-block:: bash
salt myminion docker.resolve_tag busybox
salt myminion docker.resolve_tag centos:7 all=True
salt myminion docker.resolve_tag c9f378ac27d9
s args.clean_kwargsR s args.invalid_kwargss versions.warn_untilt Neonsw The 'tags' argument to docker.resolve_tag is deprecated. It no longer is used, and will be removed in the Neon release.R� i sF Inspecting docker image '%s' returned an unexpected data structure: %sR� N(
Rs Rt R R R R R� R[ R� R� ( R� t tagsR^ t all_R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt resolve_tag� s0 (
c K@ s� t d | � } d | k r+ t d � � n y t | d � | d <Wnx t k
rV nh t t f k
r� t r� y t j | d � | d <Wq� t k
r� } t
j d | d | � q� Xq� n Xt j
j j t d | | � � S( s
.. versionchanged:: 2018.3.0
Support for all of docker-py's `logs()`_ function's arguments, with the
exception of ``stream``.
Returns the logs for the container. An interface to docker-py's `logs()`_
function.
name
Container name or ID
stdout : True
Return stdout lines
stderr : True
Return stdout lines
timestamps : False
Show timestamps
tail : all
Output specified number of lines at the end of logs. Either an integer
number of lines or the string ``all``.
since
Show logs since the specified time, passed as a UNIX epoch timestamp.
Optionally, if timelib_ is installed on the minion the timestamp can be
passed as a string which will be resolved to a date using
``timelib.strtodatetime()``.
follow : False
If ``True``, this function will block until the container exits and
return the logs when it does. The default behavior is to return what is
in the log at the time this function is executed.
.. note:
Since it blocks, this option should be used with caution.
CLI Examples:
.. code-block:: bash
# All logs
salt myminion docker.logs mycontainer
# Last 100 lines of log
salt myminion docker.logs mycontainer tail=100
# Just stderr
salt myminion docker.logs mycontainer stdout=False
# Logs since a specific UNIX timestamp
salt myminion docker.logs mycontainer since=1511688459
# Flexible format for "since" argument (requires timelib)
salt myminion docker.logs mycontainer since='1 hour ago'
salt myminion docker.logs mycontainer since='1 week ago'
salt myminion docker.logs mycontainer since='1 fortnight ago'
s args.clean_kwargsR� s& The 'stream' argument is not supportedt sinces3 docker.logs: Failed to parse '%s' using timelib: %st logs( Rs R R� R� RM R� t HAS_TIMELIBt timelibt
strtodatetimeR R[ R� RS RT t stringutilst
to_unicodeR� ( R� R^ Rg ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s" 9
c C@ s t | � d d S( s�
Returns the PID of a container
name
Container name or ID
CLI Example:
.. code-block:: bash
salt myminion docker.pid mycontainer
salt myminion docker.pid 0123456789ab
Rj t Pid( R ( R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt pid. s c @ s� t t j d | � � } | r9 t j t d t � | � n | g } | d k rW d } n� t | t j
� r{ d j | � } n� d j | � } y^ | j d � \ } } } | j
� } | j � s� | d
k r� t | � � n | d | } Wn t k
rt | � � n Xi } x^ | D]V }
t |
� j d i � j d
i � � t � f d � t j � | � D� � | |
<qW| s�| j | i � S| S( sR
Returns port mapping information for a given container. Equivalent to
running the ``docker port`` Docker CLI command.
name
Container name or ID
.. versionchanged:: 2019.2.0
This value can now be a pattern expression (using the
pattern-matching characters defined in fnmatch_). If a pattern
expression is used, this function will return a dictionary mapping
container names which match the pattern to the mappings for those
containers. When no pattern expression is used, a dictionary of the
mappings for the specified container name will be returned.
.. _fnmatch: https://docs.python.org/2/library/fnmatch.html
private_port : None
If specified, get information for that specific port. Can be specified
either as a port number (i.e. ``5000``), or as a port number plus the
protocol (i.e. ``5000/udp``).
If this argument is omitted, all port mappings will be returned.
**RETURN DATA**
A dictionary of port mappings, with the keys being the port and the values
being the mapping(s) for that port.
CLI Examples:
.. code-block:: bash
salt myminion docker.port mycontainer
salt myminion docker.port mycontainer 5000
salt myminion docker.port mycontainer 5000/udp
s [*?\[]R t *s {0}/*si Invalid private_port '{0}'. Must either be a port number, or be in port/protocol notation (e.g. 5000/tcp)R� t tcpt udpR- t Portsc 3@ s | ] } | � | f Vq d S( N( ( R� R� ( t mappings( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pys <genexpr>� s N( R� R� ( R R� t searcht fnmatcht filterR� RX R R� R t
integer_typesR& t partitionR� t isdigitR R; R R# RI ( R� t private_portt pattern_usedR� t patternR� t port_numR6 t protocolRh R� ( ( R� s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt port? s0 (!
!c K@ s� t d d t d | �} i d d 6} i } x� | D]� } | j d d � } | d k r\ q2 n xy | D]q } | j d d � j � j d � r� d
n d } | j | i � } | j | | � }
| | | j | i � |
<qc Wd | j | i � k r2 t j d t j
| | d � � | | d
<q2 q2 Wt j | j d
i � � } | j d t
� rt| j t j | j d i � � � n | j d t
� r�x% | D] } t | � | | d <q�Wn | j d t
� r�| j d i � j d i � j t d � � n | S( s6
Returns information about the Docker containers on the Minion. Equivalent
to running the ``docker ps`` Docker CLI command.
all : False
If ``True``, stopped containers will also be returned
host: False
If ``True``, local host's network topology will be included
verbose : False
If ``True``, a ``docker inspect`` will be run on each container
returned.
filters: None
A dictionary of filters to be processed on the container list.
Available filters:
- exited (int): Only containers with specified exit code
- status (str): One of restarting, running, paused, exited
- label (str): format either "key" or "key=value"
**RETURN DATA**
A dictionary with each key being an container ID, and each value some
general info about that container (time created, name, command, etc.)
CLI Example:
.. code-block:: bash
salt myminion docker.ps
salt myminion docker.ps all=True
salt myminion docker.ps filters="{'label': 'role=web'}"
Ra R t filtersR� R� R� R� R� s up Rn Ro s %Y-%m-%d %H:%M:%S %ZR� R~ Rx R� t
interfacess network.interfacesN( R� RX Rt R R# R� R� R� R� R� R� R� R� R R R RP ( R� R^ R� R� R� R t c_idR� t c_stateR� t c_keyRh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR
� s: %
' )%
c C@ sA d j | � } | t k r# t | St t | � � t | <t | S( s9
Returns the state of the container
name
Container name or ID
**RETURN DATA**
A string representing the current state of the container (either
``running``, ``paused``, or ``stopped``)
CLI Example:
.. code-block:: bash
salt myminion docker.state mycontainer
s docker.state.{0}( R& Ru Rq R ( R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s
c
C@ s[ t d | � } | s- t d j | � � � n i d d 6d d 6d d 6d d
6} g } | rk | j d � n | r� | j d � n i } xl | D]d } | j d d � } | d k r� x= | D]2 } | j | | � }
| | | j | i � |
<q� Wq� q� W| s | Si } xN t j | � D]= \ } } x. | D]& } | j | t
� r)| | | <Pq)q)WqW| S(
s�
Searches the registry for an image
name
Search keyword
official : False
Limit results to official builds
trusted : False
Limit results to `trusted builds`_
**RETURN DATA**
A dictionary with each key being the name of an image, and the following
information for each image:
- ``Description`` - Image description
- ``Official`` - A boolean (``True`` if an official build, ``False`` if
not)
- ``Stars`` - Number of stars the image has on the registry
- ``Trusted`` - A boolean (``True`` if a trusted build, ``False`` if not)
CLI Example:
.. code-block:: bash
salt myminion docker.search centos
salt myminion docker.search centos official=True
R� s) No images matched the search string '{0}'t Descriptiont descriptiont Officialt is_officialt Trustedt
is_trustedt Starst
star_countR� N( R� R R& R/ Rt R R# R� R R` R (
R� t officialt trustedR� R� R Rt R� R� R` t
mapped_keyRh Ra ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s<
%
c C@ s� t d | � } i } x( t | d � D] \ } } | | | <q& Wg } xP | d D]D } i } x( t | � D] \ } } | | | | <qj W| j | � qQ W| S( sK
Runs the `docker top` command on a specific container
name
Container name or ID
CLI Example:
**RETURN DATA**
A list of dictionaries containing information about each process
.. code-block:: bash
salt myminion docker.top mycontainer
salt myminion docker.top 0123456789ab
t topt Titlest Processes( R� t enumerateR/ ( R� R� t columnst idxt col_nameRh t processt cur_procRa ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� ; s c C@ s� t d � } t j t � } d | k r� | j t j | d � � } | r� t g | j d � j d � D] } t
| � ^ qe � | d <q� n d | k r� | j t j | d � � } | r� t g | j d � j d � D] } t
| � ^ q� � | d <q� n | S( s�
Returns a dictionary of Docker version information. Equivalent to running
the ``docker version`` Docker CLI command.
CLI Example:
.. code-block:: bash
salt myminion docker.version
R" t Versioni R R t
ApiVersiont ApiVersionInfo( R� R� R� t
VERSION_REt matchR t text_typet tuplet groupR� R� ( Rh t
version_reR� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR" ` s > >c C@ s3 t j d j | � � t d d � | j � D� � S( Ns" creating networking config from {}t create_networking_configc S@ s( i | ] \ } } t d | � | � q S( t create_endpoint_config( R� ( R� t kt v( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pys
<dictcomp> s ( R[ R\ R& R� t items( R ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR | s c K@ sy | j d t � o t | � r2 t | d | �n t d | d | d | | � \ } } | ru t j d t | � � n t j d | t k r� d j
| � n d | � t j � } t d
| d | | �}
t j � | |
d <t
� | t k rt |
d
� d j d � } n | |
d <| ruy t | � Wn9 t k
rg} t d d i |
d 6| j � d 6�� n Xt |
d <n |
S( s�]
Create a new container
image
Image from which to create the container
name
Name for the new container. If not provided, Docker will randomly
generate one for you (it will be included in the return data).
start : False
If ``True``, start container after creating it
.. versionadded:: 2018.3.0
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:
.. code-block:: bash
salt myminion docker.create image=centos:7.3.1611 skip_translate=environment environment="{'FOO': 'bar'}"
See the following links for more information:
- `docker-py Low-level API`_
- `Docker Engine API`_
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. 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``
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.
**CONTAINER CONFIGURATION ARGUMENTS**
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).
Examples:
- ``auto_remove=True``
- ``rm=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 ``ro`` 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 Python list,
however in cases where both ro/rw and an selinux context are specified,
the binds *must* be specified as a Python list.
Examples:
- ``binds=/srv/www:/var/www:ro``
- ``binds=/srv/www:/var/www:rw``
- ``binds=/srv/www:/var/www``
- ``binds="['/srv/www:/var/www:ro,Z']"``
- ``binds="['/srv/www:/var/www:rw,Z']"``
- ``binds=/srv/www:/var/www:Z``
.. note::
The second and third examples above are equivalent to each other,
as are the last two examples.
blkio_weight
Block IO weight (relative weight), accepts a weight value between 10
and 1000.
Example: ``blkio_weight=100``
blkio_weight_device
Block IO weight (relative device weight), specified as a list of
expressions in the format ``PATH:WEIGHT``
Example: ``blkio_weight_device=/dev/sda:100``
cap_add
List of capabilities to add within the container. Can be passed as a
comma-separated list or a Python list. Requires Docker 1.2.0 or
newer.
Examples:
- ``cap_add=SYS_ADMIN,MKNOD``
- ``cap_add="[SYS_ADMIN, MKNOD]"``
cap_drop
List of capabilities to drop within the container. Can be passed as a
comma-separated string or a Python list. Requires Docker 1.2.0 or
newer.
Examples:
- ``cap_drop=SYS_ADMIN,MKNOD``,
- ``cap_drop="[SYS_ADMIN, MKNOD]"``
command (or *cmd*)
Command to run in the container
Example: ``command=bash`` or ``cmd=bash``
.. versionchanged:: 2015.8.1
``cmd`` is now also accepted
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``).
Examples:
- ``cpuset_cpus="0-3"``
- ``cpuset="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.
Examples:
- ``cpuset_mems="0-3"``
- ``cpuset_mems="0,1"``
cpu_group
The length of a CPU period in microseconds
Example: ``cpu_group=100000``
cpu_period
Microseconds of CPU time that the container can get in a CPU period
Example: ``cpu_period=50000``
cpu_shares
CPU shares (relative weight), specified as an integer between 2 and 1024.
Example: ``cpu_shares=512``
detach : False
If ``True``, run the container's command in the background (daemon
mode)
Example: ``detach=True``
devices
List of host devices to expose within the container
Examples:
- ``devices="/dev/net/tun,/dev/xvda1:/dev/xvda1,/dev/xvdb1:/dev/xvdb1:r"``
- ``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``.
Examples:
- ``device_read_bps="/dev/sda:1mb,/dev/sdb:5mb"``
- ``device_read_bps="['/dev/sda:100mb', '/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.
Examples:
- ``device_read_iops="/dev/sda:1000,/dev/sdb:500"``
- ``device_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``.
Examples:
- ``device_write_bps="/dev/sda:100mb,/dev/sdb:50mb"``
- ``device_write_bps="['/dev/sda:100mb', '/dev/sdb:50mb']"``
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.
Examples:
- ``device_read_iops="/dev/sda:1000,/dev/sdb:500"``
- ``device_read_iops="['/dev/sda:1000', '/dev/sdb:500']"``
dns
List of DNS nameservers. Can be passed as a comma-separated list or a
Python list.
Examples:
- ``dns=8.8.8.8,8.8.4.4``
- ``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
Example: ``dns_opt=ndots:9``
dns_search
List of DNS search domains. Can be passed as a comma-separated list
or a Python list.
Examples:
- ``dns_search=foo1.domain.tld,foo2.domain.tld``
- ``dns_search="[foo1.domain.tld, foo2.domain.tld]"``
domainname
The domain name to use for the container
Example: ``domainname=domain.tld``
entrypoint
Entrypoint for the container. Either a string (e.g. ``"mycmd --arg1
--arg2"``) or a Python list (e.g. ``"['mycmd', '--arg1', '--arg2']"``)
Examples:
- ``entrypoint="cat access.log"``
- ``entrypoint="['cat', 'access.log']"``
environment (or *env*)
Either a dictionary of environment variable names and their values, or
a Python list of strings in the format ``VARNAME=value``.
Examples:
- ``environment='VAR1=value,VAR2=value'``
- ``environment="['VAR1=value', 'VAR2=value']"``
- ``environment="{'VAR1': 'value', 'VAR2': 'value'}"``
extra_hosts
Additional hosts to add to the container's /etc/hosts file. Can be
passed as a comma-separated list or a Python list. Requires Docker
1.3.0 or newer.
Examples:
- ``extra_hosts=web1:10.9.8.7,web2:10.9.8.8``
- ``extra_hosts="['web1:10.9.8.7', 'web2:10.9.8.8']"``
- ``extra_hosts="{'web1': '10.9.8.7', 'web2': '10.9.8.8'}"``
.. note::
To skip IP address validation, use ``validate_ip_addrs=False``
group_add
List of additional group names and/or IDs that the container process
will run as
Examples:
- ``group_add=web,network``
- ``group_add="['web', 'network']"``
hostname
Hostname of the container. If not provided, and if a ``name`` has been
provided, the ``hostname`` will default to the ``name`` that was
passed.
Example: ``hostname=web1``
.. warning::
If the container is started with ``network_mode=host``, the
hostname will be overridden by the hostname of the Minion.
interactive (or *stdin_open*): False
Leave stdin open, even if not attached
Examples:
- ``interactive=True``
- ``stdin_open=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
Examples:
- ``ipc_mode=container:foo``
- ``ipc=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
Example: ``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 (or *label*)
Add metadata to the container. Labels can be set both with and without
values:
Examples:
- ``labels=foo,bar=baz``
- ``labels="['foo', 'bar=baz']"``
.. versionchanged:: 2018.3.0
Labels both with and without values can now be mixed. Earlier
releases only permitted one method or the other.
links
Link this container to another. Links should be specified in the format
``<container_name_or_id>:<link_alias>``. Multiple links can be passed,
ether as a comma separated list or a Python list.
Examples:
- ``links=web1:link1,web2:link2``,
- ``links="['web1:link1', 'web2:link2']"``
- ``links="{'web1': 'link1', 'web2': 'link2'}"``
log_driver
Set container's logging driver. Requires Docker 1.6 or newer.
Example:
- ``log_driver=syslog``
.. 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/
log_opt
Config options for the ``log_driver`` config option. Requires Docker
1.6 or newer.
Example:
- ``log_opt="syslog-address=tcp://192.168.0.42,syslog-facility=daemon"``
- ``log_opt="['syslog-address=tcp://192.168.0.42', 'syslog-facility=daemon']"``
- ``log_opt="{'syslog-address': 'tcp://192.168.0.42', 'syslog-facility': 'daemon'}"``
lxc_conf
Additional LXC configuration parameters to set before starting the
container.
Examples:
- ``lxc_conf="lxc.utsname=docker,lxc.arch=x86_64"``
- ``lxc_conf="['lxc.utsname=docker', 'lxc.arch=x86_64']"``
- ``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.
Example: ``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.
Examples:
- ``mem_limit=512M``
- ``memory=1073741824``
mem_swappiness
Tune a container's memory swappiness behavior. Accepts an integer
between 0 and 100.
Example: ``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.
Examples:
- ``memswap_limit=1G``
- ``memory_swap=2147483648``
network_disabled : False
If ``True``, networking will be disabled within the container
Example: ``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
.. warning::
Using ``host`` mode gives the container full access to the hosts
system's services (such as D-Bus), and is therefore considered
insecure.
Examples:
- ``network_mode=null``
- ``network_mode=container:web1``
oom_kill_disable
Whether to disable OOM killer
Example: ``oom_kill_disable=False``
oom_score_adj
An integer value containing the score given to the container in order
to tune OOM killer preferences
Example: ``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.
Example: ``pid_mode=host``
pids_limit
Set the container's PID limit. Set to ``-1`` for unlimited.
Example: ``pids_limit=2000``
port_bindings (or *publish*)
Bind exposed ports which were exposed using the ``ports`` argument to
:py:func:`docker.create <salt.modules.dockermod.create>`. These
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 passed as a Python
list. The below two examples are equivalent:
- ``port_bindings="5000:5000,2123:2123/udp,8080"``
- ``port_bindings="['5000:5000', '2123:2123/udp', 8080]"``
Port bindings can also include ranges:
- ``port_bindings="14505-14506:4505-4506"``
.. 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 be passed as
comma-separated list or a Python list. If the protocol is omitted, the
port will be assumed to be a TCP port.
Examples:
- ``ports=1111,2222/udp``
- ``ports="[1111, '2222/udp']"``
privileged : False
If ``True``, runs the exec process with extended privileges
Example: ``privileged=True``
publish_all_ports (or *publish_all*): False
Publish all ports to the host
Example: ``publish_all_ports=True``
read_only : False
If ``True``, mount the container’s root filesystem as read only
Example: ``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.
Examples:
- ``restart_policy=on-failure:5``
- ``restart_policy=always``
security_opt
Security configuration for MLS systems such as SELinux and AppArmor.
Can be passed as a comma-separated list or a Python list.
Examples:
- ``security_opt=apparmor:unconfined,param2:value2``
- ``security_opt='["apparmor:unconfined", "param2:value2"]'``
.. 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
Example: ``shm_size=128M``
stop_signal
The signal used to stop the container. The default is ``SIGTERM``.
Example: ``stop_signal=SIGRTMIN+3``
stop_timeout
Timeout to stop the container, in seconds
Example: ``stop_timeout=5``
storage_opt
Storage driver options for the container
Examples:
- ``storage_opt='dm.basesize=40G'``
- ``storage_opt="['dm.basesize=40G']"``
- ``storage_opt="{'dm.basesize': '40G'}"``
sysctls (or *sysctl*)
Set sysctl options for the container
Examples:
- ``sysctl='fs.nr_open=1048576,kernel.pid_max=32768'``
- ``sysctls="['fs.nr_open=1048576', 'kernel.pid_max=32768']"``
- ``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. Can be passed as Python
list of PATH:VALUE mappings, or a Python dictionary. However, since
commas usually appear in the values, this option *cannot* be passed as
a comma-separated list.
Examples:
- ``tmpfs="['/run:rw,noexec,nosuid,size=65536k', '/var/lib/mysql:rw,noexec,nosuid,size=600m']"``
- ``tmpfs="{'/run': 'rw,noexec,nosuid,size=65536k', '/var/lib/mysql': 'rw,noexec,nosuid,size=600m'}"``
tty : False
Attach TTYs
Example: ``tty=True``
ulimits (or *ulimit*)
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 passed as a comma-separated list or a Python list.
Examples:
- ``ulimits="nofile=1024:1024,nproc=60"``
- ``ulimits="['nofile=1024:1024', 'nproc=60']"``
user
User under which to run exec process
Example: ``user=foo``
userns_mode (or *user_ns_mode*)
Sets the user namsepace mode, when the user namespace remapping option
is enabled.
Example: ``userns_mode=host``
volumes (or *volume*)
List of directories to expose as volumes. Can be passed as a
comma-separated list or a Python list.
Examples:
- ``volumes=/mnt/vol1,/mnt/vol2``
- ``volume="['/mnt/vol1', '/mnt/vol2']"``
volumes_from
Container names or IDs from which the container will get volumes. Can
be passed as a comma-separated list or a Python list.
Example: ``volumes_from=foo``, ``volumes_from=foo,bar``,
``volumes_from="[foo, bar]"``
volume_driver
Sets the container's volume driver
Example: ``volume_driver=foobar``
working_dir (or *workdir*)
Working directory inside the container
Examples:
- ``working_dir=/var/log/nginx``
- ``workdir=/var/www/myapp``
**RETURN DATA**
A dictionary containing the following keys:
- ``Id`` - ID of the newly-created container
- ``Name`` - Name of the newly-created container
CLI Example:
.. code-block:: bash
# Create a data-only container
salt myminion docker.create myuser/mycontainer volumes="/mnt/vol1,/mnt/vol2"
# Create a CentOS 7 container that will stay running once started
salt myminion docker.create centos:7 name=mycent7 interactive=True tty=True command=bash
R@ Rr R R R sU The following arguments were ignored because they are not recognized by docker-py: %ssE docker.create: creating container %susing the following arguments: %ss with name '{0}' R� R
R� t Time_ElapsedR� R� R� s( Failed to start container after creationR� R� R� t Started( Rt RX R� R� R R[ R� R� R\ R R& R� R� R� R R| R R R� ( t imageR� R R R R Rr R^ t
unused_kwargst time_startedR� Rg ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt create� sH � � �
!
c
K@ sI |
j d t � r2 t | � r2 t | d | �n d- } | d- k r� y t d | � } Wn t k
rk q� X| d k r� | o� | r� t d j | � � � q� | s� t d j | � � � q� t | d | �} n i }
xC t d � d D]1 } y |
j | � |
| <Wq� t
k
rq� Xq� W|
j d d- � t d
| d | d | |
� \ }
} |
j d
i � j d t
� } | r�t j d t | � � n | rt | t j � r�d � | j d � D� } n t | t � s�t d � t j | � D� � rt d � � qn t j d | d- k r'd j | � n d |
� t j � } t d | d | |
�} | rh| | d <n | d- k r�t | d � d j d � } n | | d <d � } i | d 6} y| ryy< x5 t j | � D]$ \ } } t d | d | | � q�WWqyt k
ru} | rZy t | � WqZt k
rV} | j d g � j d! j | � � qZXn t | j! � d" | �� qyXn g } t" | d � | syJ xC t d | d d t d# t
�D]" } | j t# j$ j% j& | � � q�WWqt k
rd$ } | | | � qXn t j � | | d% <t' � | s�d j( | � | d& <| s�y t | d � } Wn t k
ru| | d' � q�X| j d( i � } | j d) � } | d* k r�| | d+ � n | j d, � | d, <q�n Wnu t k
rD} y | j) | j* � Wn3 t+ t, f k
r(| j d g � j | j* � n Xt | j! � d" | �� n X| S(. s
.. versionadded:: 2018.3.0
Equivalent to ``docker run`` on the Docker CLI. Runs the container, waits
for it to exit, and returns the container's logs when complete.
.. note::
Not to be confused with :py:func:`docker.run
<salt.modules.dockermod.run>`, which provides a :py:func:`cmd.run
<salt.modules.cmdmod.run>`-like interface for executing commands in a
running container.
This function accepts the same arguments as :py:func:`docker.create
<salt.modules.dockermod.create>`, with the exception of ``start``. In
addition, it accepts the arguments from :py:func:`docker.logs
<salt.modules.dockermod.logs>`, with the exception of ``follow``, to
control how logs are returned. Finally, the ``bg`` argument described below
can be used to optionally run the container in the background (the default
behavior is to block until the container exits).
bg : False
If ``True``, this function will not wait for the container to exit and
will not return its logs. It will however return the container's name
and ID, allowing for :py:func:`docker.logs
<salt.modules.dockermod.logs>` to be used to view the logs.
.. note::
The logs will be inaccessible once the container exits if
``auto_remove`` is set to ``True``, so keep this in mind.
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.
networks
Networks to which the container should be connected. If automatic IP
configuration is being used, the networks can be a simple list of
network names. If custom IP configuration is being used, then this
argument must be passed as a dictionary.
CLI Examples:
.. code-block:: bash
salt myminion docker.run_container myuser/myimage command=/usr/local/bin/myscript.sh
# Run container in the background
salt myminion docker.run_container myuser/myimage command=/usr/local/bin/myscript.sh bg=True
# Connecting to two networks using automatic IP configuration
salt myminion docker.run_container myuser/myimage command='perl /scripts/sync.py' networks=net1,net2
# net1 using automatic IP, net2 using static IPv4 address
salt myminion docker.run_container myuser/myimage command='perl /scripts/sync.py' networks='{"net1": {}, "net2": {"ipv4_address": "192.168.27.12"}}'
R@ Rr s docker.stateRn sw Container '{0}' exists and is running. Run with replace=True and force=True to force removal of the existing container.sN Container '{0}' exists. Run with replace=True to remove the existing containert forceR� R� R R R R t
AutoRemovesU The following arguments were ignored because they are not recognized by docker-py: %sc S@ s i | ] } i | � q S( ( ( R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pys
<dictcomp>
s t ,c s@ s | ] } t | t � Vq d S( N( R� RI ( R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pys <genexpr>
s s$ Invalid format for networks argumentsE docker.create: creating container %susing the following arguments: %ss with name '{0}' R� R
R� t ReplacesR� R� R� c S@ sc | j d d � } | d k r* | g } n+ t | t � rI | j | � n | | g } | | d <d S( Nt Warnings( Rt R R� R� R/ ( Rh R� t warnings( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _append_warning
s t returns# docker.connect_container_to_networkt other_errorss$ Failed to auto_remove container: {0}R� t
timestampss� Failed to get logs from container. This may be because the container exited before Salt was able to attach to it to retrieve the logs. Consider setting auto_remove to False.R� t Logss) Failed to inspect container after runningRj R� t exiteds Container state is not 'exited't ExitCodeN(- Rt RX R� R� R RP R R& R R R� R R# R R[ R� R� R� R t string_typesR� RI R RV R R\ R� R� R R| R` R� R/ R� R RS RT R� R� R� R' R R� R� RM ( R� R� R R R Rr t bgR� R� R R^ t removed_idst pre_statet
log_kwargst argnameR� t auto_removeR� Rh R R R3 t net_confRg t rm_excR� R4 R� Rc t cstatet cstatus( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt
run_container� s� G
$
c C@ s� t | � } | d k r0 t d j | � � � n t j j | � sQ t d � � n t j j | � r� t j j | t j j | � � } | } n� t j j
| � d } t j j | � s| r� y t j | � Wqt k
r� } t d j | | � � � qXqt d j | � � � n | rFt j j
| � rFt d j | � � � n t j j | � sgt d � � n� t | d j t j | � � d
t �d k r�t | d j t j | � � d
t �d k r�t d � � q�n t d
j | � � � t | | � } | t d | d � k r*t j d | | | � t St j d | | | � y d j | | f � } Wn# t k
r~d j | | � } n Xd d | | g }
t d |
d t �| t d | d � k S( s;
Copy a file from inside a container to the Minion
name
Container name
source
Path of the file on the container's filesystem
dest
Destination on the Minion. Must be an absolute path. If the destination
is a directory, the file will be copied into that directory.
overwrite : False
Unless this option is set to ``True``, then if a file exists at the
location specified by the ``dest`` argument, an error will be raised.
makedirs : False
Create the parent directory on the container if it does not already
exist.
**RETURN DATA**
A boolean (``True`` if successful, otherwise ``False``)
CLI Example:
.. code-block:: bash
salt myminion docker.copy_from mycontainer /var/log/nginx/access.log /home/myuser
Rn s Container '{0}' is not runnings! Destination path must be absolutei s- Unable to make destination directory {0}: {1}s Directory {0} does not existsG Destination path {0} already exists. Use overwrite=True to overwrite its Source path must be absolutes test -e {0}R� s test -f {0}s Source must be a regular files Source file {0} does not exists file.get_sumt md5s- %s:%s and %s are the same file, skipping copys/ Copying %s from container '%s' to local path %st :s {0}:{1}R t cps cmd.runRA ( R� R R& RQ R� t isabsR t isdirR' t basenameR� t makedirst OSErrorR� Re R� R� RX R� RP R[ R\ R� R ( R� t sourcet destt overwriteR R� t dest_dirRg t
source_md5t src_pathRv ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt copy_fromw
sf " !
R c C@ sN | d k r t � } n t d | t d | � | d t d | d | d | �S( s
Copy a file from the host into a container
name
Container name
source
File to be copied to the container. Can be a local path on the Minion
or a remote file from the Salt fileserver.
dest
Destination on the container. Must be an absolute path. If the
destination is a directory, the file will be copied into that
directory.
exec_driver : None
If not passed, the execution driver will be detected as described
:ref:`above <docker-execution-driver>`.
overwrite : False
Unless this option is set to ``True``, then if a file exists at the
location specified by the ``dest`` argument, an error will be raised.
makedirs : False
Create the parent directory on the container if it does not already
exist.
**RETURN DATA**
A boolean (``True`` if successful, otherwise ``False``)
CLI Example:
.. code-block:: bash
salt myminion docker.copy_to mycontainer /tmp/foo /root/foo
s container_resource.copy_tos container_resource.cache_filet container_typet exec_driverR" R N( R R� RP R% ( R� R R! R( R" R ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt copy_to�
s -
c
K@ s\ d j | � } y% t j j | � s3 t | � � n Wn t k
rS t | � � n Xt j j | � r� | r� t d j | � � � n | d k r | j d � s� | j d � r� d } q]| j d � s� | j d � r� d } q]| j d � s� | j d
� r]t
r d } qt d � � q]n? | d
k r3d } n* | d k rHd } n | d k r]d } n | r�| d! k r�t d j | � � � n t j j | � } t j j | � s | s�t d j | � � � n y t j
| � Wq t k
r} t d j | | � � � q Xn | d k r^y t j | d � } Wq�t k
rZ} t d j | | � � � q�Xn6 | d k ryt j � }
n | d k r�t j � }
n t j � } z6y� | d k r�t d | d � } n t d | � } d }
xi |
d k rH| j d � }
|
r�| d" k r5|
j |
� } | rB| j | � qBqE| j |
� q�q�W| d# k rz|
j � } | rz| j | � qzn | j � WnM t k
r�} y t j | � Wn t k
r�n Xt d j | � � � n XWd | j � Xi t j � | d 6} | | d <t j | � j | d <t! | d � | d <| j" t# t$ � rXt% d | � | d <n | S($ sv
Exports a container to a tar archive. It can also optionally compress that
tar archive, and push it up to the Master.
name
Container name or ID
path
Absolute path on the Minion where the container will be exported
overwrite : False
Unless this option is set to ``True``, then if a file exists at the
location specified by the ``path`` argument, an error will be raised.
makedirs : False
If ``True``, then if the parent directory of the file specified by the
``path`` argument does not exist, Salt will attempt to create it.
compression : None
Can be set to any of the following:
- ``gzip`` or ``gz`` for gzip compression
- ``bzip2`` or ``bz2`` for bzip2 compression
- ``xz`` or ``lzma`` for XZ compression (requires `xz-utils`_, as well
as the ``lzma`` module from Python 3.3, available in Python 2 and
Python 3.0-3.2 as `backports.lzma`_)
This parameter can be omitted and Salt will attempt to determine the
compression type by examining the filename passed in the ``path``
parameter.
.. _`xz-utils`: http://tukaani.org/xz/
.. _`backports.lzma`: https://pypi.python.org/pypi/backports.lzma
push : False
If ``True``, the container will be pushed to the master using
:py:func:`cp.push <salt.modules.cp.push>`.
.. note::
This requires :conf_master:`file_recv` to be set to ``True`` on the
Master.
**RETURN DATA**
A dictionary will containing the following keys:
- ``Path`` - Path of the file that was exported
- ``Push`` - Reports whether or not the file was successfully pushed to the
Master
*(Only present if push=True)*
- ``Size`` - Size of the file, in bytes
- ``Size_Human`` - Size of the file, in human-readable units
- ``Time_Elapsed`` - Time in seconds taken to perform the export
CLI Examples:
.. code-block:: bash
salt myminion docker.export mycontainer /tmp/mycontainer.tar
salt myminion docker.export mycontainer /tmp/mycontainer.tar.xz push=True
s Path '{0}' is not absolutes {0} already existss .tar.gzs .tgzt gzips .tar.bz2s .tbz2t bzip2s .tar.xzs .txzt xzsd XZ compression unavailable. Install the backports.lzma module and xz-utils to enable XZ compression.t gzt bz2t lzmas Invalid compression type '{0}'sR Parent dir {0} of destination path does not exist. Use makedirs=True to create it.s" Unable to make parent dir {0}: {1}t wbs# Unable to open {0} for writing: {1}s files.fopent exportR� i s+ Error occurred during container export: {0}NR� R� R� t
Size_Humans cp.pusht Push( s gzipR+ R, ( R+ R, ( R+ R, (& R& RQ R� R R R; R� R R Rq t HAS_LZMAt dirnameR R R R* t openR. t
BZ2CompressorR/ t LZMACompressorR� Rs R� t readt compresst writet flushR RL t closet statt st_sizeR� R# R� R RP ( R� R� R" R t compressionR^ R� t
parent_dirRg t outt
compressorR� R� t bufR� Rh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR1 # s� G
c
K@ sN t d | � } | j d t � } | j d d � } t } | rQ t d | � n t | � d k r� | pl | r� t d j | � � � n | r� | r� t | � } y | d d } Wn! t k
r� t j
d | � n Xt | d | �n t d
t
� } | st d | d | d
| �n t � g | D]! } | t d
t
� k r)| ^ q)S( sv
Removes a container
name
Container name or ID
force : False
If ``True``, the container will be killed first before removal, as the
Docker API will not permit a running container to be removed. This
option is set to ``False`` by default to prevent accidental removal of
a running container.
stop : False
If ``True``, the container will be stopped first before removal, as the
Docker API will not permit a running container to be removed. This
option is set to ``False`` by default to prevent accidental removal of
a running container.
.. versionadded:: 2017.7.0
timeout
Optional timeout to be passed to :py:func:`docker.stop
<salt.modules.dockermod.stop>` if stopping the container.
.. versionadded:: 2018.3.0
volumes : False
Also remove volumes associated with container
**RETURN DATA**
A list of the IDs of containers which were removed
CLI Example:
.. code-block:: bash
salt myminion docker.rm mycontainer
salt myminion docker.rm mycontainer force=True
s args.clean_kwargst stopR< s args.invalid_kwargsRn sL Container '{0}' is running, use force=True to forcibly remove this containerR R s[ Failed to find AutoRemove in inspect results, Docker API may have changed. Full results: %sR t remove_containerR� R� N( Rs Rt R R R� R R& R R� R[ R� RE R
RX R� R� (
R� R� t volumesR^ t stop_R< R Rp R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR � s0 ,
c C@ sJ t | � d } t j d | | | � t d | | � t | � d | k S( s�
.. versionadded:: 2017.7.0
Renames a container. Returns ``True`` if successful, and raises an error if
the API returns one. If unsuccessful and the API returns no error (should
not happen), then ``False`` will be returned.
name
Name or ID of existing container
new_name
New name to assign to container
CLI Example:
.. code-block:: bash
salt myminion docker.rename foo bar
R� s( Renaming container '%s' (ID: %s) to '%s't rename( R R[ R\ R� ( R� t new_nameR� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRI " s c
C@ s� t � | d k r- t d d d � | }
n | s9 | r� | rU | rU t d � � q� t | t j � sy t j | � } n t | t j � s� t j | � } q� n | r� | r� d j | | � n d } t j � } t
d d | d | d t d
| d | d | d
| d | �}
i t j � | d 6} t � |
sIt
d j | � � � n g } x0 |
D]( } | j t j j j | d t �� qVWg } x� | D]� } y t t | � � } Wn t k
r�q�n X| d k r�t | | � n | d k r�t | | � q�| d k r�t | | � q�q�Wd | k r�d j | � } t j | � t j | � | rt| d j d j | � � 7} n t
| � � n t | d d t �} | r�| | d <n d j | � | d <| r�| | d <n | r�| j d d � n | S( s�
.. versionchanged:: 2018.3.0
If the built image should be tagged, then the repository and tag must
now be passed separately using the ``repository`` and ``tag``
arguments, rather than together in the (now deprecated) ``image``
argument.
Builds a docker image from a Dockerfile or a URL
path
Path to directory on the Minion containing a Dockerfile
repository
Optional repository name for the image being built
.. versionadded:: 2018.3.0
tag : latest
Tag name for the image (required if ``repository`` is passed)
.. versionadded:: 2018.3.0
image
.. deprecated:: 2018.3.0
Use both ``repository`` and ``tag`` instead
cache : True
Set to ``False`` to force the build process not to use the Docker image
cache, and pull all required intermediate image layers
rm : True
Remove intermediate containers created during build
api_response : False
If ``True``: an ``API_Response`` key will be present in the return
data, containing the raw output from the Docker API.
fileobj
Allows for a file-like object containing the contents of the Dockerfile
to be passed in place of a file ``path`` argument. This argument should
not be used from the CLI, only from other Salt code.
dockerfile
Allows for an alternative Dockerfile to be specified. Path to
alternative Dockefile is relative to the build path for the Docker
container.
.. versionadded:: 2016.11.0
buildargs
A dictionary of build arguments provided to the docker build process.
**RETURN DATA**
A dictionary containing one or more of the following keys:
- ``Id`` - ID of the newly-built image
- ``Time_Elapsed`` - Time in seconds taken to perform the build
- ``Intermediate_Containers`` - IDs of containers created during the course
of the build process
*(Only present if rm=False)*
- ``Images`` - A dictionary containing one or more of the following keys:
- ``Already_Pulled`` - Layers that that were already present on the
Minion
- ``Pulled`` - Layers that that were pulled
*(Only present if the image specified by the "repository" and "tag"
arguments was not present on the Minion, or if cache=False)*
- ``Status`` - A string containing a summary of the pull action (usually a
message saying that an image was downloaded, or that it was up to date).
*(Only present if the image specified by the "repository" and "tag"
arguments was not present on the Minion, or if cache=False)*
CLI Example:
.. code-block:: bash
salt myminion docker.build /path/to/docker/build/dir
salt myminion docker.build https://github.com/myuser/myrepo.git repository=myimage tag=latest
salt myminion docker.build /path/to/docker/build/dir dockerfile=Dockefile.different repository=myimage tag=dev
s versions.warn_untilR� sZ The 'image' argument to docker.build has been deprecated, please use 'repository' instead.s2 If tagging, both a repository and tag are requireds {0}:{1}t buildR� R Rm t fileobjR t nocachet
dockerfilet buildargsR� s: Build failed for {0}, no response returned from Docker APIt clsR� R� R� R� s Build failed for {0}s . Error(s) follow:
{0}s
R R� s Failed to tag image as {0}t Warningt API_ResponseR� N( R� R Rs R R� R R R� R& R� R� R R� R R{ RS RT RU RV R, t nextt itert
StopIterationR� R� R R[ R� R' R� RX Rt ( R� t
repositoryR t cacheR t api_responseRL RN RO R� t respositoryt image_tagR� R� Rh t stream_dataR4 R� R� t item_typeR� t resolved_tag( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRK ? s~ _
$
&
t latestc C@ s# | d k r& t d d d � | } n t | t j � sJ t j | � } n t | t j � sn t j | � } n t j � } t d | d | d | d | d | �} i t j � | d 6} t � d }
x( d D] } | | k r� | | }
Pq� q� W|
d k r t d
� � n | | d <|
| d
<| S( sq
.. versionchanged:: 2018.3.0
The repository and tag must now be passed separately using the
``repository`` and ``tag`` arguments, rather than together in the (now
deprecated) ``image`` argument.
Commits a container, thereby promoting it to an image. Equivalent to
running the ``docker commit`` Docker CLI command.
name
Container name or ID to commit
repository
Repository name for the image being committed
.. versionadded:: 2018.3.0
tag : latest
Tag name for the image
.. versionadded:: 2018.3.0
image
.. deprecated:: 2018.3.0
Use both ``repository`` and ``tag`` instead
message
Commit message (Optional)
author
Author name (Optional)
**RETURN DATA**
A dictionary containing the following keys:
- ``Id`` - ID of the newly-created image
- ``Image`` - Name of the newly-created image
- ``Time_Elapsed`` - Time in seconds taken to perform the commit
CLI Example:
.. code-block:: bash
salt myminion docker.commit mycontainer myuser/myimage mytag
s versions.warn_untilR� s[ The 'image' argument to docker.commit has been deprecated, please use 'repository' instead.t commitRV R R t authorR� R� R� t IDs( No image ID was returned in API responseR� N( s Ids idRa (
R Rs R� R R R� R� R� R� R ( R� RV R R R` R� RY R� R� Rh R} R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR_ � s: 6
c C@ s� t d t � } g t | � D]$ } | | d d k r | d ^ q } | sP | Si } x� | D] } y& t | d | �| j | i � d <Wq] t k
r� } | j � } t j | � | | j | i � d <t
| | d <q] Xq] W| S( s�
Return top-level images (those on which no other images depend) which do
not have a tag assigned to them. These include:
- Images which were once tagged but were later untagged, such as those
which were superseded by committing a new copy of an existing tagged
image.
- Images which were loaded using :py:func:`docker.load
<salt.modules.dockermod.load>` (or the ``docker load`` Docker CLI
command), but not tagged.
prune : False
Remove these images
force : False
If ``True``, and if ``prune=True``, then forcibly remove these images.
**RETURN DATA**
If ``prune=False``, the return data will be a list of dangling image IDs.
If ``prune=True``, the return data will be a dictionary with each key being
the ID of the dangling image, and the following information for each image:
- ``Comment`` - Any error encountered when trying to prune a dangling image
*(Only present if prune failed)*
- ``Removed`` - A boolean (``True`` if prune was successful, ``False`` if
not)
CLI Example:
.. code-block:: bash
salt myminion docker.dangling
salt myminion docker.dangling prune=True
R R� i R� t Removedt CommentN( R� RX R� R t rmiR� R R� R[ R� R ( t pruneR� t
all_imagesR� t dangling_imagesRh R� Rg R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt danglingT s '$
&
c C@ s� | d k r& t d d d � | } n t | t j � sJ t j | � } n t | t j � sn t j | � } n t d | � } t j � } t d | d | d | �} i t j � | d 6} t � | s� t
d j | � � � n | r� | | d
<n g }
xy | D]q } y t t
| � � } Wn t k
r3qn X| d k rVt | | | | � q| d k rt |
| � qqWd
| k r�d j | � }
|
r�|
d j d j |
� � 7}
n t
|
� � n | S( sd
.. versionchanged:: 2018.3.0
The repository and tag must now be passed separately using the
``repository`` and ``tag`` arguments, rather than together in the (now
deprecated) ``image`` argument.
Imports content from a local tarball or a URL as a new docker image
source
Content to import (URL or absolute path to a tarball). URL can be a
file on the Salt fileserver (i.e.
``salt://path/to/rootfs/tarball.tar.xz``. To import a file from a
saltenv other than ``base`` (e.g. ``dev``), pass it at the end of the
URL (ex. ``salt://path/to/rootfs/tarball.tar.xz?saltenv=dev``).
repository
Repository name for the image being imported
.. versionadded:: 2018.3.0
tag : latest
Tag name for the image
.. versionadded:: 2018.3.0
image
.. deprecated:: 2018.3.0
Use both ``repository`` and ``tag`` instead
api_response : False
If ``True`` an ``api_response`` key will be present in the return data,
containing the raw output from the Docker API.
**RETURN DATA**
A dictionary containing the following keys:
- ``Id`` - ID of the newly-created image
- ``Image`` - Name of the newly-created image
- ``Time_Elapsed`` - Time in seconds taken to perform the commit
CLI Example:
.. code-block:: bash
salt myminion docker.import /tmp/cent7-minimal.tar.xz myuser/centos
salt myminion docker.import /tmp/cent7-minimal.tar.xz myuser/centos:7
salt myminion docker.import salt://dockerimages/cent7-minimal.tar.xz myuser/centos:7
s versions.warn_untilR� s[ The 'image' argument to docker.import has been deprecated, please use 'repository' instead.s container_resource.cache_filet import_imageRV R R� s; Import failed for {0}, no response returned from Docker APIRR R� R� R� s Import failed for {0}s . Error(s) follow:
{0}s
N( R Rs R� R R R� RP R� R� R� R R& RS RT RU R� R R' ( R RV R RX R� RY R� R� R� Rh R� R� R\ R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR � sP 8
c
C@ ss | d k r& t d d d � | } n | s2 | rN | o; | rN t d � � n t d | � } t j j | � s� t d j | � � � n t d t
� } d d d
| g } t j � } t d | � } i t j � | d 6}
t � t d t
� } | d
d k rDd j | � } | d r5| d j | d � 7} n t | � � n | |
d <g | D] }
|
| k rU|
^ qU} g | D] }
|
d ^ qz|
d <t
| d | �} | s�| rot | � d k r�d j d j | � � |
d <qod j | | � } y* t | d d | d | �} | |
d <Wqot k
r<d |
d <qot k
rk} d j | d | | � |
d <qoXn |
S(! s�
.. versionchanged:: 2018.3.0
If the loaded image should be tagged, then the repository and tag must
now be passed separately using the ``repository`` and ``tag``
arguments, rather than together in the (now deprecated) ``image``
argument.
Load a tar archive that was created using :py:func:`docker.save
<salt.modules.dockermod.save>` (or via the Docker CLI using ``docker save``).
path
Path to docker tar archive. Path can be a file on the Minion, or the
URL of a file on the Salt fileserver (i.e.
``salt://path/to/docker/saved/image.tar``). To load a file from a
saltenv other than ``base`` (e.g. ``dev``), pass it at the end of the
URL (ex. ``salt://path/to/rootfs/tarball.tar.xz?saltenv=dev``).
repository
If specified, the topmost layer of the newly-loaded image will be
tagged with the specified repo using :py:func:`docker.tag
<salt.modules.dockermod.tag_>`. If a repository name is provided, then
the ``tag`` argument is also required.
.. versionadded:: 2018.3.0
tag
Tag name to go along with the repository name, if the loaded image is
to be tagged.
.. versionadded:: 2018.3.0
image
.. deprecated:: 2018.3.0
Use both ``repository`` and ``tag`` instead
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``Path`` - Path of the file that was saved
- ``Layers`` - A list containing the IDs of the layers which were loaded.
Any layers in the file that was loaded, which were already present on the
Minion, will not be included.
- ``Image`` - Name of tag applied to topmost layer
*(Only present if tag was specified and tagging was successful)*
- ``Time_Elapsed`` - Time in seconds taken to load the file
- ``Warning`` - Message describing any problems encountered in attemp to
tag the topmost layer
*(Only present if tag was specified and tagging failed)*
CLI Example:
.. code-block:: bash
salt myminion docker.load /path/to/image.tar
salt myminion docker.load salt://path/to/docker/saved/image.tar repository=myuser/myimage tag=mytag
s versions.warn_untilR� sY The 'image' argument to docker.load has been deprecated, please use 'repository' instead.s2 If tagging, both a repository and tag are requireds container_resource.cache_files Source file {0} does not existR R t loads -is cmd.run_allR� Re i s Failed to load image(s) from {0}Rn s : {0}R� i R� R� i sI More than one top-level image layer was loaded ({0}), no image was taggeds , RQ s {0}:{1}RV R R� s: No top-level image layers were loaded, no image was taggeds Failed to tag {0} as {1}: {2}N( R Rs R RP RQ R� t isfileR R& R� RX R� R� R� t lenR' R R� R ( R� RV R R� RY t
local_pathR� Rv R� R� Rh R� R� R� t
new_layerst top_level_imagest tagged_imageRg ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRj � sX >
%!
c C@ st g } d d d | g } x7 t t d | d t �j � � D] } | j | � q; W| sp t d j | � � � n | S( s&
Returns a list of the IDs of layers belonging to the specified image, with
the top-most layer (the one correspnding to the passed name) appearing
last.
name
Image name or ID
CLI Example:
.. code-block:: bash
salt myminion docker.layers centos:7
R R� s -qs cmd.run_stdoutRA s Image '{0}' not found( R� RP R R- R/ R R& ( R� Rh Rv R4 ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt layers~ s #c C@ s� t � i t d 6| d 6} | r. | | d <n t j � } t d | | � } i t j � | d 6d d 6} t � | s� t d j | � � � n | r� | | d <n g } x� | D]� } t j d
| � y t j
j j | � } Wn; t
k
r}
t d j | � d i |
j � d
6�� n Xy t t | � � } Wn t k
rHq� n X| d k ret | | � q� | d k r� t | | � q� q� W| r�| | d <d | d <n | S( s%
.. versionchanged:: 2018.3.0
If no tag is specified in the ``image`` argument, all tags for the
image will be pulled. For this reason is it recommended to pass
``image`` using the ``repo:tag`` notation.
Pulls an image from a Docker registry
image
Image to be pulled
insecure_registry : False
If ``True``, the Docker client will permit the use of insecure
(non-HTTPS) registries.
api_response : False
If ``True``, an ``API_Response`` key will be present in the return
data, containing the raw output from the Docker API.
.. note::
This may result in a **lot** of additional return data, especially
for larger images.
client_timeout
Timeout in seconds for the Docker client. This is not a timeout for
this function, but for receiving a response from the API.
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``Layers`` - A dictionary containing one or more of the following keys:
- ``Already_Pulled`` - Layers that that were already present on the
Minion
- ``Pulled`` - Layers that that were pulled
- ``Status`` - A string containing a summary of the pull action (usually a
message saying that an image was downloaded, or that it was up to date).
- ``Time_Elapsed`` - Time in seconds taken to perform the pull
CLI Example:
.. code-block:: bash
salt myminion docker.pull centos
salt myminion docker.pull centos:6
R� Rr t insecure_registryR� R� i Re s9 Pull failed for {0}, no response returned from Docker APIRR s pull event: %ss$ Unable to interpret API event: '{0}'R� t ErrorR� R� Rf i ( R� RX R� R� R� R R& R[ R\ RS RT RU RV R R� RS RT RU R� R ( R� Rr RX Rr R^ R� R� Rh R� t eventRg t
event_type( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � sH 5
c C@ s� t | t j � s$ t j | � } n i t d 6| d 6} | rK | | d <n t j � } t d | | � } i t j � | d 6d d 6} t � | s� t d j | � � � n | r� | | d <n g } x� | D]� } y t
j j j
| � } Wn; t k
r(}
t d
j | � d i |
j � d 6�� n Xy t t | � � } Wn t k
rUq� n X| d
k rrt | | � q� | d k r� t | | � q� q� W| r�| | d <d | d <n | S( s
.. versionchanged:: 2015.8.4
The ``Id`` and ``Image`` keys are no longer present in the return data.
This is due to changes in the Docker Remote API.
Pushes an image to a Docker registry. See the documentation at top of this
page to configure authentication credentials.
image
Image to be pushed. If just the repository name is passed, then all
tagged images for the specified repo will be pushed. If the image name
is passed in ``repo:tag`` notation, only the specified image will be
pushed.
insecure_registry : False
If ``True``, the Docker client will permit the use of insecure
(non-HTTPS) registries.
api_response : False
If ``True``, an ``API_Response`` key will be present in the return
data, containing the raw output from the Docker API.
client_timeout
Timeout in seconds for the Docker client. This is not a timeout for
this function, but for receiving a response from the API.
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``Layers`` - A dictionary containing one or more of the following keys:
- ``Already_Pushed`` - Layers that that were already present on the
Minion
- ``Pushed`` - Layers that that were pushed
- ``Time_Elapsed`` - Time in seconds taken to perform the push
CLI Example:
.. code-block:: bash
salt myminion docker.push myuser/mycontainer
salt myminion docker.push myuser/mycontainer:mytag
R� Rr Rr R� R� i Re s9 Push failed for {0}, no response returned from Docker APIRR s$ Unable to interpret API event: '{0}'R� Rs R� R� Rf i ( R� R R R� RX R� R� R� R R& RS RT RU RV R R� RS RT RU R� R ( R� Rr RX Rr R^ R� R� Rh R� Rt Rg Ru ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � sH 1
c
O@ s t d t � } t � } | j d t � } | j d t � } g } xK| D]C} t | � d } y# t d | d | d | d t �WqJ t j j k
r�} | j
j d k rg| j | j
� t | � }
|
d s� |
d
r�d } |
d r| d j d
j |
d � � 7} n |
d
rT|
d r1| d 7} n | d j d
j |
d
� � 7} n | j | � q�q�| j d j | j
j | j
� � qJ XqJ Wt � i g | D]! } | t d t � k r�| ^ q�d 6g | D] } | t � k r�| ^ q�d 6d d 6}
| r| |
d <d |
d <n |
S( s;
Removes an image
name
Name (in ``repo:tag`` notation) or ID of image.
force : False
If ``True``, the image will be removed even if the Minion has
containers created from that image
prune : True
If ``True``, untagged parent image layers will be removed as well, set
this to ``False`` to keep them.
**RETURN DATA**
A dictionary will be returned, containing the following two keys:
- ``Layers`` - A list of the IDs of image layers that were removed
- ``Tags`` - A list of the tags that were removed
- ``Errors`` - A list of any errors that were encountered
CLI Examples:
.. code-block:: bash
salt myminion docker.rmi busybox
salt myminion docker.rmi busybox force=True
salt myminion docker.rmi foo bar baz
R R� Re R� t remove_imaget nopruneR� i� R0 Rz s Image is in use by s container(s): {0}s , s and s
image(s): {0}s Error {0}: {1}R� t Tagsi Re Rf i ( R� RX R� R# R R R� R R� R� R� R� R/ R� R� R& R' R� ( R� R^ t
pre_imagest pre_tagsR� Rw R� R� R} Rg t depsR� R� Rh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRd Y sJ !
#2)
c
K@ s d j | � } y% t j j | � s3 t | � � n Wn t k
rS t | � � n Xt j j | � r� | r� t d j | � � � n | d% k r | j d � s� | j d � r� d } q]| j d � s� | j d � r� d } q]| j d � s� | j d
� r]t
r d } qt d � � q]n? | d
k r3d } n* | d k rHd } n | d k r]d } n | r�| d. k r�t d j | � � � n t j j | � } t j j | � s�| s�t d j | � � � q�n | r�t
d � } n | } | t | � d k r| n
t | � d } d d d | | g }
t j � } t d |
d t �} | d d k r�d j | � } | d r�| d j | d � 7} n t | � � n | r�| d k r�y t j | d � }
Wq,t k
r�} t d j | | � � � q,Xn6 | d k rt j � } n | d k r,t j � } n zCy� t
d! | d" � �� } | d k rjt
d! | d � }
n d% } xi | d# k r�| j d$ � } | rs| d/ k r�| j | � } | r�|
j | � q�q�|
j | � qsqsW| d0 k r
| j � } | r
|
j | � q
n |
j � Wd% QXWnM t k
rm} y t j | � Wn t k
rTn Xt d& j | � � � n XWd% y t j | � Wn t k
r�n X|
j � Xn i t j � | d' 6} | | d( <t j | � j! | d) <t" | d) � | d* <| j# d+ t � rt d, | � | d- <n | S(1 s&
Saves an image and to a file on the minion. Equivalent to running the
``docker save`` Docker CLI command, but unlike ``docker save`` this will
also work on named images instead of just images IDs.
name
Name or ID of image. Specify a specific tag by using the ``repo:tag``
notation.
path
Absolute path on the Minion where the image will be exported
overwrite : False
Unless this option is set to ``True``, then if the destination file
exists an error will be raised.
makedirs : False
If ``True``, then if the parent directory of the file specified by the
``path`` argument does not exist, Salt will attempt to create it.
compression : None
Can be set to any of the following:
- ``gzip`` or ``gz`` for gzip compression
- ``bzip2`` or ``bz2`` for bzip2 compression
- ``xz`` or ``lzma`` for XZ compression (requires `xz-utils`_, as well
as the ``lzma`` module from Python 3.3, available in Python 2 and
Python 3.0-3.2 as `backports.lzma`_)
This parameter can be omitted and Salt will attempt to determine the
compression type by examining the filename passed in the ``path``
parameter.
.. note::
Since the Docker API does not support ``docker save``, compression
will be a bit slower with this function than with
:py:func:`docker.export <salt.modules.dockermod.export>` since the
image(s) will first be saved and then the compression done
afterwards.
.. _`xz-utils`: http://tukaani.org/xz/
.. _`backports.lzma`: https://pypi.python.org/pypi/backports.lzma
push : False
If ``True``, the container will be pushed to the master using
:py:func:`cp.push <salt.modules.cp.push>`.
.. note::
This requires :conf_master:`file_recv` to be set to ``True`` on the
Master.
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``Path`` - Path of the file that was saved
- ``Push`` - Reports whether or not the file was successfully pushed to the
Master
*(Only present if push=True)*
- ``Size`` - Size of the file, in bytes
- ``Size_Human`` - Size of the file, in human-readable units
- ``Time_Elapsed`` - Time in seconds taken to perform the save
CLI Examples:
.. code-block:: bash
salt myminion docker.save centos:7 /tmp/cent7.tar
salt myminion docker.save 0123456789ab cdef01234567 /tmp/saved.tar
s Path '{0}' is not absolutes {0} already existss .tar.gzs .tgzR* s .tar.bz2s .tbz2R+ s .tar.xzs .txzR, sd XZ compression unavailable. Install the backports.lzma module and xz-utils to enable XZ compression.R- R. R/ s Invalid compression type '{0}'sT Parent dir '{0}' of destination path does not exist. Use makedirs=True to create it.s
files.mkstempR� R� R t saves -os cmd.run_allRA Re i s Failed to save image(s) to {0}Rn s : {0}R0 s# Unable to open {0} for writing: {1}s files.fopent rbR� i Ns% Error occurred during image save: {0}R� R� R� R2 R� s cp.pushR3 ( s gzips bzip2s xz( s bzip2s xz( s bzip2s xz($ R& RQ R� R R R; R� R R Rq R4 R5 R Rs R R� RP R R* R6 R R. R7 R/ R8 R9 R: R; R< R RL R= R> R? R� R# ( R� R� R" R R@ R^ R� RA t
saved_patht
image_to_saveRv R� R� RB Rg RC t uncompressedRD R� Rh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR| � s� P
,
c C@ s� | d k r& t d d d � | } n t | t j � sJ t j | � } n t | t j � sn t j | � } n t | � d } t d | d | d | d | �} t � | S( s?
.. versionchanged:: 2018.3.0
The repository and tag must now be passed separately using the
``repository`` and ``tag`` arguments, rather than together in the (now
deprecated) ``image`` argument.
Tag an image into a repository and return ``True``. If the tag was
unsuccessful, an error will be raised.
name
ID of image
repository
Repository name for the image to be built
.. versionadded:: 2018.3.0
tag : latest
Tag name for the image to be built
.. versionadded:: 2018.3.0
image
.. deprecated:: 2018.3.0
Use both ``repository`` and ``tag`` instead
force : False
Force apply tag
CLI Example:
.. code-block:: bash
salt myminion docker.tag 0123456789ab myrepo/mycontainer mytag
s versions.warn_untilR� sX The 'image' argument to docker.tag has been deprecated, please use 'repository' instead.R� R RV R� N( R Rs R� R R R� R R� R� ( R� RV R R� R� RY R} R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR q s" $ c C@ s� | d k r t d | � } n | d k r> t d | � } n t d d | d | �} x` t | � D]R \ } } y t | d � d } Wn t k
r� qc qc X| rc | | | d <qc qc W| S( s/
.. versionchanged:: 2017.7.0
The ``names`` and ``ids`` can be passed as a comma-separated list now,
as well as a Python list.
.. versionchanged:: 2018.3.0
The ``Containers`` key for each network is no longer always empty.
List existing networks
names
Filter by name
ids
Filter by id
CLI Example:
.. code-block:: bash
salt myminion docker.networks names=network-web
salt myminion docker.networks ids=1f9d2454d0872b68dd9e8744c6e7a4c66b86f10abaccc21e14f7f014f729b2bc
s args.split_inputR R� t idsR� R0 N( R Rs R� R� RK R ( R� R� R� R� t netinfoRa ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR � s
c
K@ s� t d t j j j j d | d | d | t d | � �} d | k r� i } xT g d d g t d � d D] } | | k rk | ^ qk D] } | j | � | | <q� W| j d
d
� } | s� | r� t d | | � | d <q� n t d | | � }
t � |
S( s�$
.. versionchanged:: 2018.3.0
Support added for network configuration options other than ``driver``
and ``driver_opts``, as well as IPAM configuration.
Create a new network
.. note::
This function supports all arguments for network and IPAM pool
configuration which are available for the release of docker-py
installed on the minion. For that reason, the arguments described below
in the :ref:`NETWORK CONFIGURATION ARGUMENTS
<salt-modules-dockermod-create-network-netconf>` and :ref:`IP ADDRESS
MANAGEMENT (IPAM) <salt-modules-dockermod-create-network-ipam>`
sections may not accurately reflect what is available on the minion.
The :py:func:`docker.get_client_args
<salt.modules.dockermod.get_client_args>` function can be used to check
the available arguments for the installed version of docker-py (they
are found in the ``network_config`` and ``ipam_config`` sections of the
return data), but Salt will not prevent a user from attempting to use
an argument which is unsupported in the release of Docker which is
installed. In those cases, network creation be attempted but will fail.
name
Network name
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. See the following links
for more information:
- `docker-py Low-level API`_
- `Docker Engine API`_
.. versionadded:: 2018.3.0
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. However, if both the alias and the docker-py version of
the same argument (e.g. ``options`` and ``driver_opts``) 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.
.. versionadded:: 2018.3.0
validate_ip_addrs : True
For parameters which accept IP addresses as input, IP address
validation will be performed. To disable, set this to ``False``
.. note::
When validating subnets, whether or not the IP portion of the
subnet is a valid subnet boundary will not be checked. The IP will
portion will be validated, and the subnet size will be checked to
confirm it is a valid number (1-32 for IPv4, 1-128 for IPv6).
.. versionadded:: 2018.3.0
.. _salt-modules-dockermod-create-network-netconf:
**NETWORK CONFIGURATION ARGUMENTS**
driver
Network driver
Example: ``driver=macvlan``
driver_opts (or *driver_opt*, or *options*)
Options for the network driver. Either a dictionary of option names and
values or a Python list of strings in the format ``varname=value``.
Examples:
- ``driver_opts='macvlan_mode=bridge,parent=eth0'``
- ``driver_opts="['macvlan_mode=bridge', 'parent=eth0']"``
- ``driver_opts="{'macvlan_mode': 'bridge', 'parent': 'eth0'}"``
check_duplicate : True
If ``True``, checks for networks with duplicate names. Since networks
are primarily keyed based on a random ID and not on the name, and
network name is strictly a user-friendly alias to the network which is
uniquely identified using ID, there is no guaranteed way to check for
duplicates. This option providess a best effort, checking for any
networks which have the same name, but it is not guaranteed to catch
all name collisions.
Example: ``check_duplicate=False``
internal : False
If ``True``, restricts external access to the network
Example: ``internal=True``
labels
Add metadata to the network. Labels can be set both with and without
values:
Examples (*with* values):
- ``labels="label1=value1,label2=value2"``
- ``labels="['label1=value1', 'label2=value2']"``
- ``labels="{'label1': 'value1', 'label2': 'value2'}"``
Examples (*without* values):
- ``labels=label1,label2``
- ``labels="['label1', 'label2']"``
enable_ipv6 (or *ipv6*) : False
Enable IPv6 on the network
Example: ``enable_ipv6=True``
.. note::
While it should go without saying, this argument must be set to
``True`` to :ref:`configure an IPv6 subnet
<salt-states-docker-network-present-ipam>`. Also, if this option is
turned on without an IPv6 subnet explicitly configured, you will
get an error unless you have set up a fixed IPv6 subnet. Consult
the `Docker IPv6 docs`_ for information on how to do this.
.. _`Docker IPv6 docs`: https://docs.docker.com/v17.09/engine/userguide/networking/default_network/ipv6/
attachable : False
If ``True``, and the network is in the global scope, non-service
containers on worker nodes will be able to connect to the network.
Example: ``attachable=True``
.. note::
While support for this option was added in API version 1.24, its
value was not added to the inpsect results until API version 1.26.
The version of Docker which is available for CentOS 7 runs API
version 1.24, meaning that while Salt can pass this argument to the
API, it has no way of knowing the value of this config option in an
existing Docker network.
scope
Specify the network's scope (``local``, ``global`` or ``swarm``)
Example: ``scope=local``
ingress : False
If ``True``, create an ingress network which provides the routing-mesh in
swarm mode
Example: ``ingress=True``
.. _salt-modules-dockermod-create-network-ipam:
**IP ADDRESS MANAGEMENT (IPAM)**
This function supports networks with either IPv4, or both IPv4 and IPv6. If
configuring IPv4, then you can pass the IPAM arguments as shown below, as
individual arguments on the Salt CLI. However, if configuring IPv4 and
IPv6, the arguments must be passed as a list of dictionaries, in the
``ipam_pools`` argument. See the **CLI Examples** below. `These docs`_ also
have more information on these arguments.
.. _`These docs`: http://docker-py.readthedocs.io/en/stable/api.html#docker.types.IPAMPool
*IPAM ARGUMENTS*
ipam_driver
IPAM driver to use, if different from the default one
Example: ``ipam_driver=foo``
ipam_opts
Options for the IPAM driver. Either a dictionary of option names
and values or a Python list of strings in the format
``varname=value``.
Examples:
- ``ipam_opts='foo=bar,baz=qux'``
- ``ipam_opts="['foo=bar', 'baz=quz']"``
- ``ipam_opts="{'foo': 'bar', 'baz': 'qux'}"``
*IPAM POOL ARGUMENTS*
subnet
Subnet in CIDR format that represents a network segment
Example: ``subnet=192.168.50.0/25``
iprange (or *ip_range*)
Allocate container IP from a sub-range within the subnet
Subnet in CIDR format that represents a network segment
Example: ``iprange=192.168.50.64/26``
gateway
IPv4 gateway for the master subnet
Example: ``gateway=192.168.50.1``
aux_addresses (or *aux_address*)
A dictionary of mapping container names to IP addresses which should be
allocated for them should they connect to the network. Either a
dictionary of option names and values or a Python list of strings in
the format ``host=ipaddr``.
Examples:
- ``aux_addresses='foo.bar.tld=192.168.50.10,hello.world.tld=192.168.50.11'``
- ``aux_addresses="['foo.bar.tld=192.168.50.10', 'hello.world.tld=192.168.50.11']"``
- ``aux_addresses="{'foo.bar.tld': '192.168.50.10', 'hello.world.tld': '192.168.50.11'}"``
CLI Examples:
.. code-block:: bash
salt myminion docker.create_network web_network driver=bridge
# IPv4
salt myminion docker.create_network macvlan_network driver=macvlan driver_opts="{'parent':'eth0'}" gateway=172.20.0.1 subnet=172.20.0.0/24
# IPv4 and IPv6
salt myminion docker.create_network mynet ipam_pools='[{"subnet": "10.0.0.0/24", "gateway": "10.0.0.1"}, {"subnet": "fe3f:2180:26:1::60/123", "gateway": "fe3f:2180:26:1::61"}]'
s docker.translate_inputR R R s args.clean_kwargst ipamt ipam_drivert ipam_optst ipam_configt
ipam_poolss docker.create_ipam_configt create_network( (
Rs RS RT R R t networkR Rt R� R� ( R� R R R Rr R^ t ipam_kwargsR� R` R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s* � c C@ s t d | � } t � t S( s
Remove a network
network_id
Network name or ID
CLI Examples:
.. code-block:: bash
salt myminion docker.remove_network mynet
salt myminion docker.remove_network 1f9d2454d0872b68dd9e8744c6e7a4c66b86f10abaccc21e14f7f014f729b2bc
t remove_network( R� R� RX ( t
network_idR� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s c C@ s t d | � } t � | S( s�
Inspect Network
network_id
ID of network
CLI Example:
.. code-block:: bash
salt myminion docker.inspect_network 1f9d2454d0872b68dd9e8744c6e7a4c66b86f10abaccc21e14f7f014f729b2bc
RK ( R� R� ( R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRK � s
c K@ s� t d | � } | j d d � } | d k rH t d d d � | } n t j d | | | � t d | | | � } t j d | | � t � t S(
sv
.. versionadded:: 2015.8.3
.. versionchanged:: 2017.7.0
Support for ``ipv4_address`` argument added
.. versionchanged:: 2018.3.0
All arguments are now passed through to
`connect_container_to_network()`_, allowing for any new arguments added
to this function to be supported automagically.
Connect container to network. See the `connect_container_to_network()`_
docs for information on supported arguments.
container
Container name or ID
net_id
Network name or ID
CLI Examples:
.. code-block:: bash
salt myminion docker.connect_container_to_network web-1 mynet
salt myminion docker.connect_container_to_network web-1 mynet ipv4_address=10.20.0.10
salt myminion docker.connect_container_to_network web-1 1f9d2454d0872b68dd9e8744c6e7a4c66b86f10abaccc21e14f7f014f729b2bc
s args.clean_kwargsR� s versions.warn_untilR� s[ The 'network_id' argument to docker.build has been deprecated, please use 'net_id' instead.sN Connecting container '%s' to network '%s' with the following configuration: %st connect_container_to_networks5 Successfully connected container '%s' to network '%s'N( Rs Rt R R[ R\ R� R� RX ( R t net_idR^ R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� s&
c C@ sC t j d | | � t d | | � } t j d | | � t � t S( s�
.. versionadded:: 2015.8.3
Disconnect container from network
container
Container name or ID
network_id
Network name or ID
CLI Examples:
.. code-block:: bash
salt myminion docker.disconnect_container_from_network web-1 mynet
salt myminion docker.disconnect_container_from_network web-1 1f9d2454d0872b68dd9e8744c6e7a4c66b86f10abaccc21e14f7f014f729b2bc
s. Disconnecting container '%s' from network '%s't! disconnect_container_from_networks: Successfully disconnected container '%s' from network '%s'( R[ R\ R� R� RX ( R R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� A s
c C@ s� t | � } g } g } xj | D]b } y t | | � | j | � Wq t k
r� } | j � } d | k r� | j | � q� q Xq W| r� t d d i | d 6| d 6�� n | S( sG
.. versionadded:: 2018.3.0
Runs :py:func:`docker.disconnect_container_from_network
<salt.modules.dockermod.disconnect_container_from_network>` on all
containers connected to the specified network, and returns the names of all
containers that were disconnected.
network_id
Network name or ID
CLI Examples:
.. code-block:: bash
salt myminion docker.disconnect_all_containers_from_network mynet
salt myminion docker.disconnect_all_containers_from_network 1f9d2454d0872b68dd9e8744c6e7a4c66b86f10abaccc21e14f7f014f729b2bc
t 404s+ One or more containers failed to be removedR� t removedR� ( Rd R� R/ R R� ( R� RR Rh t failedt cnameRg R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt& disconnect_all_containers_from_networkc s
c C@ s t d d | �} | S( s�
List existing volumes
.. versionadded:: 2015.8.4
filters
There is one available filter: dangling=true
CLI Example:
.. code-block:: bash
salt myminion docker.volumes filters="{'dangling': True}"
RG R� ( R� ( R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRG � s c C@ s& t d | d | d | �} t � | S( s-
Create a new volume
.. versionadded:: 2015.8.4
name
name of volume
driver
Driver of the volume
driver_opts
Options for the driver volume
CLI Example:
.. code-block:: bash
salt myminion docker.create_volume my_volume driver=local
t
create_volumeR� t driver_opts( R� R� ( R� R� R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s c C@ s t d | � } t � t S( s�
Remove a volume
.. versionadded:: 2015.8.4
name
Name of volume
CLI Example:
.. code-block:: bash
salt myminion docker.remove_volume my_volume
t
remove_volume( R� R� RX ( R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s c C@ s t d | � } t � | S( s�
Inspect Volume
.. versionadded:: 2015.8.4
name
Name of volume
CLI Example:
.. code-block:: bash
salt myminion docker.inspect_volume my_volume
R� ( R� R� ( R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s c C@ s t | d d � S( s5
Kill all processes in a running container instead of performing a graceful
shutdown
name
Container name or ID
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``status`` - A dictionary showing the prior state of the container as
well as the new state
- ``result`` - A boolean noting whether or not the action was successful
- ``comment`` - Only present if the container cannot be killed
CLI Example:
.. code-block:: bash
salt myminion docker.kill mycontainer
t killRo ( R� ( R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s c C@ sX t | � } | d k rH i t d 6i | d 6| d 6d 6d j | � d 6St | d d � S(
s�
Pauses a container
name
Container name or ID
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``status`` - A dictionary showing the prior state of the container as
well as the new state
- ``result`` - A boolean noting whether or not the action was successful
- ``comment`` - Only present if the container cannot be paused
CLI Example:
.. code-block:: bash
salt myminion docker.pause mycontainer
Ro R� R� R� R� s( Container '{0}' is stopped, cannot pauseR� t pauseRl ( R� R R& R� ( R� t
orig_state( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� s
t freezei
c C@ s3 t | d d d | �} | d r/ t | d <n | S( s�
Restarts a container
name
Container name or ID
timeout : 10
Timeout in seconds after which the container will be killed (if it has
not yet gracefully shut down)
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``status`` - A dictionary showing the prior state of the container as
well as the new state
- ``result`` - A boolean noting whether or not the action was successful
- ``restarted`` - If restart was successful, this key will be present and
will be set to ``True``.
CLI Examples:
.. code-block:: bash
salt myminion docker.restart mycontainer
salt myminion docker.restart mycontainer timeout=20
R� Rn R< R� t restarted( R� RX ( R� R< Rh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� ( s
c C@ s t d | d | �t S( s%
Send a signal to a container. 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.
name
Container name or ID
signal
Signal to send to container
**RETURN DATA**
If the signal was successfully sent, ``True`` will be returned. Otherwise,
an error will be raised.
CLI Example:
.. code-block:: bash
salt myminion docker.signal mycontainer SIGHUP
R� R
( R� RX ( R� R
( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR L s c C@ sX t | � } | d k rH i t d 6i | d 6| d 6d 6d j | � d 6St | d d � S(
s�
Start a container
name
Container name or ID
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``status`` - A dictionary showing the prior state of the container as
well as the new state
- ``result`` - A boolean noting whether or not the action was successful
- ``comment`` - Only present if the container cannot be started
CLI Example:
.. code-block:: bash
salt myminion docker.start mycontainer
Rl R� R� R� R� s' Container '{0}' is paused, cannot startR� R Rn ( R� R R& R� ( R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR h s
c K@ s
| d k rJ y t | � d d } WqJ t k
rF t j j j } qJ Xn t | � } | d k r� | j d t � r� t
| d d � } | d t k r� d j | � | d <| Sq� i t d 6i | d 6| d
6d 6d j | � d 6Sn t
| d
d d | �} | | d d <| S( s�
Stops a running container
name
Container name or ID
unpause : False
If ``True`` and the container is paused, it will be unpaused before
attempting to stop the container.
timeout
Timeout in seconds after which the container will be killed (if it has
not yet gracefully shut down)
.. versionchanged:: 2017.7.0
If this argument is not passed, then the container's configuration
will be checked. If the container was created using the
``stop_timeout`` argument, then the configured timeout will be
used, otherwise the timeout will be 10 seconds.
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``status`` - A dictionary showing the prior state of the container as
well as the new state
- ``result`` - A boolean noting whether or not the action was successful
- ``comment`` - Only present if the container can not be stopped
CLI Examples:
.. code-block:: bash
salt myminion docker.stop mycontainer
salt myminion docker.stop mycontainer unpause=True
salt myminion docker.stop mycontainer timeout=20
R t StopTimeoutRl t unpauseRn R� s! Failed to unpause container '{0}'R� R� R� R� sK Container '{0}' is paused, run with unpause=True to unpause before stoppingRE Ro R< N( R R R� RS RT R t SHUTDOWN_TIMEOUTR� R# R R� R& ( R� R< R^ R� t unpause_resultRh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRE � s& (
c C@ sX t | � } | d k rH i t d 6i | d 6| d 6d 6d j | � d 6St | d d � S(
s�
Unpauses a container
name
Container name or ID
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``status`` - A dictionary showing the prior state of the container as
well as the new state
- ``result`` - A boolean noting whether or not the action was successful
- ``comment`` - Only present if the container can not be unpaused
CLI Example:
.. code-block:: bash
salt myminion docker.pause mycontainer
Ro R� R� R� R� s* Container '{0}' is stopped, cannot unpauseR� R� Rn ( R� R R& R� ( R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s
t unfreezec C@ s" y t | � } Wn) t k
r; i | d 6d j | � d 6SX| d k } t d | � } t � y t | � } Wn t k
r� d } n X| r� | } n | d k r� t } n t } i | d 6i | d 6| d 6d 6| d 6} | r� d
j | � | d <n | r | d r | d d k | d <n | S(
s�
Wait for the container to exit gracefully, and return its exit code
.. note::
This function will block until the container is stopped.
name
Container name or ID
ignore_already_stopped
Boolean flag that prevents execution to fail, if a container
is already stopped.
fail_on_exit_status
Boolean flag to report execution as failure if ``exit_status``
is different than 0.
**RETURN DATA**
A dictionary will be returned, containing the following keys:
- ``status`` - A dictionary showing the prior state of the container as
well as the new state
- ``result`` - A boolean noting whether or not the action was successful
- ``exit_status`` - Exit status for the container
- ``comment`` - Only present if the container is already stopped
CLI Example:
.. code-block:: bash
salt myminion docker.wait mycontainer
R� s Container '{0}' absentR� Ro t waitR� R� R� t exit_statuss Container '{0}' already stoppedi N( R� R R& R� R� R RX R ( R� t ignore_already_stoppedt fail_on_exit_statusR� t already_stoppedR� R� t successR� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s2 $
c K@ s� | d k r. t | | | | f � r. t } n t d | � } xG t | � D]9 } t | | t � sK t j j j
| | � | | <qK qK Wi } | s� | r� t d d | �| d <n | s� | r� t d d | �| d <n | s� | r� t d d | �| d <n | s | rby t d d | �| d
<Wqbt k
r^t d t d t d
d � � t � | d
<qbXn | r�t d d | �| d <n | S( s!
.. versionadded:: 2019.2.0
Prune Docker's various subsystems
.. note::
This requires docker-py version 2.1.0 or later.
containers : False
If ``True``, prunes stopped containers (documentation__)
.. __: https://docs.docker.com/engine/reference/commandline/container_prune/#filtering
images : False
If ``True``, prunes unused images (documentation__)
.. __: https://docs.docker.com/engine/reference/commandline/image_prune/#filtering
networks : False
If ``False``, prunes unreferenced networks (documentation__)
.. __: https://docs.docker.com/engine/reference/commandline/network_prune/#filtering)
build : False
If ``True``, clears the builder cache
.. note::
Only supported in Docker 17.07.x and newer. Additionally, filters
do not apply to this argument.
volumes : False
If ``True``, prunes unreferenced volumes (documentation__)
.. __: https://docs.docker.com/engine/reference/commandline/volume_prune/
system
If ``True``, prunes containers, images, networks, and builder cache.
Assumed to be ``True`` if none of ``containers``, ``images``,
``networks``, or ``build`` are set to ``True``.
.. note::
``volumes=True`` must still be used to prune volumes
filters
- ``dangling=True`` (images only) - remove only dangling images
- ``until=<timestamp>`` - only remove objects created before given
timestamp. Not applicable to volumes. See the documentation links
above for examples of valid time expressions.
- ``label`` - only remove objects matching the label expression. Valid
expressions include ``labelname`` or ``labelname=value``.
CLI Examples:
.. code-block:: bash
salt myminion docker.prune system=True
salt myminion docker.prune system=True until=12h
salt myminion docker.prune images=True dangling=True
salt myminion docker.prune images=True label=foo,bar=baz
s args.clean_kwargst prune_containersR� Ra t prune_imagesR� t prune_networksR t prune_buildRK t _resultt _postt _urls /build/prunet
prune_volumesRG N(
R R6 RX Rs R� R� R RS RT Rw t split_inputR� R ( Ra R R� RK RG t systemR� t fnameRh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRe 7 s4 @% $
R\ c
C@ s} | d k r t � } n t d | | d t d | d | d | d | d | d | d | d
| � }
| d
k rq |
S|
| Sd S( s/
Common logic for docker.run functions
s container_resource.runR' R( R� t stdinRA Rl R� t use_vtt keep_envR N( Ns all( R R� RP R% ( R� Rv R( R� R� RA Rl R� R� R� Rh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _run� s" t basec C@ s� d � } t d d d d d d t j j | � d � }
| r� t d | |
| | � } | s� | |
� i d
d 6d d 6d
d 6d
d 6t d 6SnZ t d | | � } | s� | |
� i d
d 6d d 6d
d 6d
d 6t d 6St j | |
� | d k rt � } n t
| |
|
d | �t | d |
� t | | rM|
d t
j | � n |
d | d | d | d | d | d |
d | �} | |
� t | d |
� | S( s5
Common logic to run a script on a container
c S@ sD y t j | � Wn, t t f k
r? } t j d | | � n Xd S( s>
Remove the tempfile allocated for the script
s- cmd.script: Unable to clean tempfile '%s': %sN( RQ RL t IOErrorR R[ R� ( R� Rg ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _cleanup_tempfile� s s
files.mkstempt dirs /tmpt prefixRS t suffixi s cp.get_templatei R� Re R� Ro Rn t cache_errors
cp.cache_fileR( s
chmod 700 t R� RA Rl R� R� R� s rm N( Rs RQ R� t splitextRP RX t shutilt copyfileR R� R) t runt run_allR R� ( R� R t saltenvRw t templateR( R� RA Rl R� R� R� R� R� t fn_Rh ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _script� sN
#
c C@ s= t | | d | d d d | d | d | d | d | d | �S(
s5
Run :py:func:`cmd.retcode <salt.modules.cmdmod.retcode>` within a container
name
Container name or ID in which to run the command
cmd
Command to run
exec_driver : None
If not passed, the execution driver will be detected as described
:ref:`above <docker-execution-driver>`.
stdin : None
Standard input to be used for the command
output_loglevel : debug
Level at which to log the output from the command. Set to ``quiet`` to
suppress logging.
use_vt : False
Use SaltStack's utils.vt to stream output to console.
keep_env : None
If not passed, only a sane default PATH environment variable will be
set. If ``True``, all environment variables from the container's host
will be kept. Otherwise, a comma-separated list (or Python list) of
environment variable names can be passed, and those environment
variables will be kept.
CLI Example:
.. code-block:: bash
salt myminion docker.retcode mycontainer 'ls -l /etc'
R( R� Re R� RA Rl R� R� R� ( R� ( R� Rv R( R� RA Rl R� R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyRe s -c C@ s= t | | d | d d d | d | d | d | d | d | �S(
s)
Run :py:func:`cmd.run <salt.modules.cmdmod.run>` within a container
name
Container name or ID in which to run the command
cmd
Command to run
exec_driver : None
If not passed, the execution driver will be detected as described
:ref:`above <docker-execution-driver>`.
stdin : None
Standard input to be used for the command
output_loglevel : debug
Level at which to log the output from the command. Set to ``quiet`` to
suppress logging.
use_vt : False
Use SaltStack's utils.vt to stream output to console.
keep_env : None
If not passed, only a sane default PATH environment variable will be
set. If ``True``, all environment variables from the container's host
will be kept. Otherwise, a comma-separated list (or Python list) of
environment variable names can be passed, and those environment
variables will be kept.
CLI Example:
.. code-block:: bash
salt myminion docker.run mycontainer 'ls -l /etc'
R( R� R� RA Rl R� R� R� N( R� R ( R� Rv R( R� RA Rl R� R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� @ s -c C@ s= t | | d | d d d | d | d | d | d | d | �S(
s�
Run :py:func:`cmd.run_all <salt.modules.cmdmod.run_all>` within a container
.. note::
While the command is run within the container, it is initiated from the
host. Therefore, the PID in the return dict is from the host, not from
the container.
name
Container name or ID in which to run the command
cmd
Command to run
exec_driver : None
If not passed, the execution driver will be detected as described
:ref:`above <docker-execution-driver>`.
stdin : None
Standard input to be used for the command
output_loglevel : debug
Level at which to log the output from the command. Set to ``quiet`` to
suppress logging.
use_vt : False
Use SaltStack's utils.vt to stream output to console.
keep_env : None
If not passed, only a sane default PATH environment variable will be
set. If ``True``, all environment variables from the container's host
will be kept. Otherwise, a comma-separated list (or Python list) of
environment variable names can be passed, and those environment
variables will be kept.
CLI Example:
.. code-block:: bash
salt myminion docker.run_all mycontainer 'ls -l /etc'
R( R� R R� RA Rl R� R� R� ( R� ( R� Rv R( R� RA Rl R� R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� y s 3c C@ s= t | | d | d d d | d | d | d | d | d | �S(
sB
Run :py:func:`cmd.run_stderr <salt.modules.cmdmod.run_stderr>` within a
container
name
Container name or ID in which to run the command
cmd
Command to run
exec_driver : None
If not passed, the execution driver will be detected as described
:ref:`above <docker-execution-driver>`.
stdin : None
Standard input to be used for the command
output_loglevel : debug
Level at which to log the output from the command. Set to ``quiet`` to
suppress logging.
use_vt : False
Use SaltStack's utils.vt to stream output to console.
keep_env : None
If not passed, only a sane default PATH environment variable will be
set. If ``True``, all environment variables from the container's host
will be kept. Otherwise, a comma-separated list (or Python list) of
environment variable names can be passed, and those environment
variables will be kept.
CLI Example:
.. code-block:: bash
salt myminion docker.run_stderr mycontainer 'ls -l /etc'
R( R� Rn R� RA Rl R� R� R� ( R� ( R� Rv R( R� RA Rl R� R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt
run_stderr� s .c C@ s= t | | d | d d d | d | d | d | d | d | �S(
sB
Run :py:func:`cmd.run_stdout <salt.modules.cmdmod.run_stdout>` within a
container
name
Container name or ID in which to run the command
cmd
Command to run
exec_driver : None
If not passed, the execution driver will be detected as described
:ref:`above <docker-execution-driver>`.
stdin : None
Standard input to be used for the command
output_loglevel : debug
Level at which to log the output from the command. Set to ``quiet`` to
suppress logging.
use_vt : False
Use SaltStack's utils.vt to stream output to console.
keep_env : None
If not passed, only a sane default PATH environment variable will be
set. If ``True``, all environment variables from the container's host
will be kept. Otherwise, a comma-separated list (or Python list) of
environment variable names can be passed, and those environment
variables will be kept.
CLI Example:
.. code-block:: bash
salt myminion docker.run_stdout mycontainer 'ls -l /etc'
R( R� Ro R� RA Rl R� R� R� ( R� ( R� Rv R( R� RA Rl R� R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s .c C@ sI t | | d | d | d | d | d | d | d | d | d |
d
| �
S( s�
Run :py:func:`cmd.script <salt.modules.cmdmod.script>` within a container
.. note::
While the command is run within the container, it is initiated from the
host. Therefore, the PID in the return dict is from the host, not from
the container.
name
Container name or ID
source
Path to the script. Can be a local path on the Minion or a remote file
from the Salt fileserver.
args
A string containing additional command-line options to pass to the
script.
template : None
Templating engine to use on the script before running.
exec_driver : None
If not passed, the execution driver will be detected as described
:ref:`above <docker-execution-driver>`.
stdin : None
Standard input to be used for the script
output_loglevel : debug
Level at which to log the output from the script. Set to ``quiet`` to
suppress logging.
use_vt : False
Use SaltStack's utils.vt to stream output to console.
keep_env : None
If not passed, only a sane default PATH environment variable will be
set. If ``True``, all environment variables from the container's host
will be kept. Otherwise, a comma-separated list (or Python list) of
environment variable names can be passed, and those environment
variables will be kept.
CLI Example:
.. code-block:: bash
salt myminion docker.script mycontainer salt://docker_script.py
salt myminion docker.script mycontainer salt://scripts/runme.sh 'arg1 arg2 "arg 3"'
salt myminion docker.script mycontainer salt://scripts/runme.sh stdin='one\ntwo\nthree\nfour\nfive\n' output_loglevel=quiet
R� Rw R� R( R� RA Rl R� R� R� ( R� ( R� R R� Rw R� R( R� RA Rl R� R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt script, s @c C@ sM t | | d | d | d | d | d | d | d | d | d |
d
| �
d S( sA
Run :py:func:`cmd.script_retcode <salt.modules.cmdmod.script_retcode>`
within a container
name
Container name or ID
source
Path to the script. Can be a local path on the Minion or a remote file
from the Salt fileserver.
args
A string containing additional command-line options to pass to the
script.
template : None
Templating engine to use on the script before running.
exec_driver : None
If not passed, the execution driver will be detected as described
:ref:`above <docker-execution-driver>`.
stdin : None
Standard input to be used for the script
output_loglevel : debug
Level at which to log the output from the script. Set to ``quiet`` to
suppress logging.
use_vt : False
Use SaltStack's utils.vt to stream output to console.
keep_env : None
If not passed, only a sane default PATH environment variable will be
set. If ``True``, all environment variables from the container's host
will be kept. Otherwise, a comma-separated list (or Python list) of
environment variable names can be passed, and those environment
variables will be kept.
CLI Example:
.. code-block:: bash
salt myminion docker.script_retcode mycontainer salt://docker_script.py
salt myminion docker.script_retcode mycontainer salt://scripts/runme.sh 'arg1 arg2 "arg 3"'
salt myminion docker.script_retcode mycontainer salt://scripts/runme.sh stdin='one\ntwo\nthree\nfour\nfive\n' output_loglevel=quiet
R� Rw R� R( R� RA Rl R� R� R� Re ( R� ( R� R R� Rw R� R( R� RA Rl R� R� R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt script_retcodez s ;c C@ s) d t k r% t j j t � t d <n d S( s9
Create a file client and add it to the context.
s
cp.fileclientN( Ru RS t
fileclientt get_file_clientRH ( ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _mk_fileclient� s c C@ s) t j j d d j t j � j d � � S( Ns /tmps salt.docker.{0}i ( RQ R� R' R& t uuidt uuid4t hex( ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _generate_tmp_path� s R� c C@ s] t | | � } t j j j j | | � } t � t j j j j t d | | | | � } | S( sa
Prepares a self contained tarball that has the state
to be applied in the container
s
cp.fileclient( t _compile_stateRS t clientt sshR� t lowstate_file_refsR� t prep_trans_tarRu ( R� t sls_optst modst pillart extra_filerefst chunkst refst trans_tar( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt _prepare_trans_tar� s c C@ s� t | � } | s | j � S| j i | | d 6� \ } } | j j | � \ } } | | 7} | | j j | � 7} | r~ | S| j j | � \ } } | | 7} | j j | � } | r� | S| j j | � S( sB
Generates the chunks of lowdata from the list of modules
R� ( R t compile_low_chunkst render_highstateR� t reconcile_extendt verify_hight requisite_int
apply_excludet compile_high_data( R� R� t st_t high_dataR� t
ext_errorst
req_in_errors( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR� � s
c O@ s� t � } d d | g } t | t j | � � } | d d k rV i t d 6| d d 6S| d( k rq t d � � n t d t d
d t d d
d � d t d d d � �} t
| | t j j
| t j j | � � � } d d d j | t j j | � � g } t | t j | � � } | d d k r=i t d 6| d d 6Sz�d j t j d � t j j
| d � d d d t j j
| d � d t j j
| d � d d d d d | g t | � g | j � D]- \ } }
| j d! � s�d" j | |
� ^ q�} t | t j t t | � � � } | d d k r9t | d � � n yi t d# | d$ � } | j d% | � }
t |
t � r�d |
k r�|
d t d <q�n |
j d& | � SWn t k
r�i t d 6d' d 6SXWd( d) d* | g } t | t j | � � Xd( S(+ s�
Executes a Salt function inside a running container
.. versionadded:: 2016.11.0
The container does not need to have Salt installed, but Python is required.
name
Container name or ID
function
Salt execution module function
CLI Example:
.. code-block:: bash
salt myminion docker.call test.ping
salt myminion test.arg arg1 arg2 key1=val1
salt myminion dockerng.call compassionate_mirzakhani test.arg arg1 arg2 key1=val1
t mkdirs -pRe i R� Rn R� s Missing function parameters
thin.gen_thint cachedirt
extra_modss
config.optiont thin_extra_modsR� t so_modst thin_so_modst pythons -cs> import tarfile; tarfile.open("{0}/{1}").extractall(path="{0}")s python{0}s salt-calls
--metadatas --locals
--log-fileR[ s
--cachedirRW s --outRU s -lRm s --t __s {0}={1}s json.find_jsonRo t localR s$ Can't parse container command outputNR s -rf( R� R� t
subprocesst list2cmdlineR R R Rs RH RP R) RQ R� R' R R& t sysR: R� R� R� R R( R# R� RI Ru RM ( R� t functionRw R^ t thin_dest_patht mkdirp_thin_argvRh t thin_patht untar_cmdR` t valuet salt_argvR� R� t rm_thin_argv( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt call� sF
- �!
c K@ s# | r t | | | � St | | � S( s�
.. versionadded:: 2019.2.0
Apply states! This function will call highstate or state.sls based on the
arguments passed in, ``apply`` is intended to be the main gateway for
all state executions.
CLI Example:
.. code-block:: bash
salt 'docker' docker.apply web01
salt 'docker' docker.apply web01 test
salt 'docker' docker.apply web01 test,pkgs
( R R ( R� R� R^ ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR T s c K@ s} | r. g | j d � D] } | j � ^ q n g } | j d d � } d | k r_ d | d <n t d t | � } t | d � } t j j t | t d d | d | d �j
� } | r� t | t � r� | j
| � n t | | d
| d | d | j d d � �} t � } d
d | g }
t | t j |
� � } | d d k r[i t d 6| d d 6Sd } zl t d | d � } t | | t j j | d � d t � d t �t | d t j j | d � | d � } Wd d d | g }
t | t j |
� � y t j | � Wn, t t f k
r4} t j d | | � n XXt | t � sRd t d <n' t d | � sod t d <n
d t d <| S(! s�
Apply the states defined by the specified SLS modules to the running
container
.. versionadded:: 2016.11.0
The container does not need to have Salt installed, but Python is required.
name
Container name or ID
mods : None
A string containing comma-separated list of SLS with defined states to
apply to the container.
saltenv : base
Specify the environment from which to retrieve the SLS indicated by the
`mods` parameter.
pillarenv
Specify a Pillar environment to be used when applying states. This
can also be set in the minion config file using the
:conf_minion:`pillarenv` option. When neither the
:conf_minion:`pillarenv` minion config option nor this CLI argument is
used, all Pillar environments will be merged together.
.. versionadded:: 2018.3.0
pillar
Custom Pillar values, passed as a dictionary of key-value pairs
.. note::
Values passed this way will override Pillar values set via
``pillar_roots`` or an external Pillar source.
.. versionadded:: 2018.3.0
CLI Example:
.. code-block:: bash
salt myminion docker.sls compassionate_mirzakhani mods=rails,web
R R� R� R� s state.get_sls_optss grains.itemsR� t pillar_overridet pillarenvR� R� R� R� s -pRe i R� Rn R� s hashutils.get_hasht sha256s salt_state.tgzR( R" s state.pkgNR s -rfs3 docker.sls: Unable to remove state tarball '%s': %si s state.check_resulti (! R� R� Rt R Rs RH R� RS R� t
get_pillart compile_pillarR� RI R R� R# R� R� R� R� R R) RQ R� R' R� RX RL R� R R[ R� Ru ( R� R� R^ R� R� R� t grainsR� R� t trans_dest_patht mkdirp_trans_argvRh t trans_tar_sha256t
rm_trans_argvRg ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR i sh -4
c K@ s t | d d | �S( s�
Apply a highstate to the running container
.. versionadded:: 2019.2.0
The container does not need to have Salt installed, but Python is required.
name
Container name or ID
saltenv : base
Specify the environment from which to retrieve the SLS indicated by the
`mods` parameter.
CLI Example:
.. code-block:: bash
salt myminion docker.highstate compassionate_mirzakhani
R� R� ( R ( R� R� R^ ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyR � s s opensuse/pythonc
K@ s6 | j d d � } | d k r8 t d d d � | } n t d t j | � � } x- d D]% } y | | =WqX t k
r| qX XqX Wt d | d d d t d t | � } | d }
zk t |
� t |
| | � } | r� t d
| � r� t
| � � n | t k rt |
| d | �} n Wd t
|
� t |
� X| S( sX
.. versionchanged:: 2018.3.0
The repository and tag must now be passed separately using the
``repository`` and ``tag`` arguments, rather than together in the (now
deprecated) ``image`` argument.
Build a Docker image using the specified SLS modules on top of base image
.. versionadded:: 2016.11.0
The base image does not need to have Salt installed, but Python is required.
repository
Repository name for the image to be built
.. versionadded:: 2018.3.0
tag : latest
Tag name for the image to be built
.. versionadded:: 2018.3.0
name
.. deprecated:: 2018.3.0
Use both ``repository`` and ``tag`` instead
base : opensuse/python
Name or ID of the base image
mods
A string containing comma-separated list of SLS with defined states to
apply to the base image.
saltenv : base
Specify the environment from which to retrieve the SLS indicated by the
`mods` parameter.
pillarenv
Specify a Pillar environment to be used when applying states. This
can also be set in the minion config file using the
:conf_minion:`pillarenv` option. When neither the
:conf_minion:`pillarenv` minion config option nor this CLI argument is
used, all Pillar environments will be merged together.
.. versionadded:: 2018.3.0
pillar
Custom Pillar values, passed as a dictionary of key-value pairs
.. note::
Values passed this way will override Pillar values set via
``pillar_roots`` or an external Pillar source.
.. versionadded:: 2018.3.0
dryrun: False
when set to True the container will not be committed at the end of
the build. The dryrun succeed also when the state contains errors.
**RETURN DATA**
A dictionary with the ID of the new container. In case of a dryrun,
the state result is returned and the container gets removed.
CLI Example:
.. code-block:: bash
salt myminion docker.sls_build imgname base=mybase mods=rails,web
R� s versions.warn_untilR� s] The 'name' argument to docker.sls_build has been deprecated, please use 'repository' instead.s args.clean_kwargsR� Rv t interactivet ttyR� s sleep infinityR� s state.check_resultR N( s images names cmds interactives ttys extra_filerefs( Rt R Rs R� R� R� R� RX R R R R R_ RE R ( RV R R� R� t dryrunR^ R� R R` Rh R� ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt sls_build� s8 M
(� t __doc__t
__future__R t
__docformat__R. R� R� R{ R* RU t loggingRQ R� R� R� R� R� R� R� R� t salt.exceptionsR R t salt.extR t salt.ext.six.movesR t% salt.utils.docker.translate.containerRS t# salt.utils.docker.translate.networkt salt.utils.functoolst salt.utils.jsont salt.utils.patht salt.pillart salt.fileclientt
salt.stateR t salt.client.ssh.stateR RX R t ImportErrorR t PY2t backports.lzmaR/ R4 R� R� R RT R� t whichR� t getLoggerR8 R[ t __func_alias__R$ R! R� t objectRO R% t __virtual_aliases__t __proxyenabled__t
__outputter__R+ t JSONDecoderR, R Ri Rq R} R� R� R� R� R� R� R R� R� R� R� R� R� R� R� R� R� R R R R+ t alias_functionR, RS R_ Rd Rj R� R� R� R� R� R� R@ R R R� R� R� R� R� R� R� R
R� R� R� R" R t CLIENT_TIMEOUTR� R R& R R) R1 R RI RK R_ Rh R Rj Rq R� R� Rd R| R R R� R� RK R� R� R� RG R� R� R� R� R� R� R� R R RE R� R� R� Re R� R� Re R� R� R� R� R� R� R� R� R� R� R� R R R R ( ( ( s: /usr/lib/python2.7/site-packages/salt/modules/dockermod.pyt <module>� s`
&
4 & 0 < 2 7 [ � I , c ( * ! Y E ; " L T O L F % � � � �p 6 �I � W; l� a\ N �=+� 5 " * " $ "C"D d> 3 3 9 4 4 E > X u
Mini Shell