File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/models.tar
Back
secrets.py 0000644 00000003465 15027745625 0006613 0 ustar 00 from ..api import APIClient from .resource import Collection, Model class Secret(Model): """A secret.""" id_attribute = 'ID' def __repr__(self): return f"<{self.__class__.__name__}: '{self.name}'>" @property def name(self): return self.attrs['Spec']['Name'] def remove(self): """ Remove this secret. Raises: :py:class:`docker.errors.APIError` If secret failed to remove. """ return self.client.api.remove_secret(self.id) class SecretCollection(Collection): """Secrets on the Docker server.""" model = Secret def create(self, **kwargs): obj = self.client.api.create_secret(**kwargs) obj.setdefault("Spec", {})["Name"] = kwargs.get("name") return self.prepare_model(obj) create.__doc__ = APIClient.create_secret.__doc__ def get(self, secret_id): """ Get a secret. Args: secret_id (str): Secret ID. Returns: (:py:class:`Secret`): The secret. Raises: :py:class:`docker.errors.NotFound` If the secret does not exist. :py:class:`docker.errors.APIError` If the server returns an error. """ return self.prepare_model(self.client.api.inspect_secret(secret_id)) def list(self, **kwargs): """ List secrets. Similar to the ``docker secret ls`` command. Args: filters (dict): Server-side list filtering options. Returns: (list of :py:class:`Secret`): The secrets. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ resp = self.client.api.secrets(**kwargs) return [self.prepare_model(obj) for obj in resp] swarm.py 0000644 00000020142 15027745625 0006263 0 ustar 00 from docker.api import APIClient from docker.errors import APIError from .resource import Model class Swarm(Model): """ The server's Swarm state. This a singleton that must be reloaded to get the current state of the Swarm. """ id_attribute = 'ID' def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if self.client: try: self.reload() except APIError as e: # FIXME: https://github.com/docker/docker/issues/29192 if e.response.status_code not in (406, 503): raise @property def version(self): """ The version number of the swarm. If this is not the same as the server, the :py:meth:`update` function will not work and you will need to call :py:meth:`reload` before calling it again. """ return self.attrs.get('Version').get('Index') def get_unlock_key(self): return self.client.api.get_unlock_key() get_unlock_key.__doc__ = APIClient.get_unlock_key.__doc__ def init(self, advertise_addr=None, listen_addr='0.0.0.0:2377', force_new_cluster=False, default_addr_pool=None, subnet_size=None, data_path_addr=None, data_path_port=None, **kwargs): """ Initialize a new swarm on this Engine. Args: advertise_addr (str): Externally reachable address advertised to other nodes. This can either be an address/port combination in the form ``192.168.1.1:4567``, or an interface followed by a port number, like ``eth0:4567``. If the port number is omitted, the port number from the listen address is used. If not specified, it will be automatically detected when possible. listen_addr (str): Listen address used for inter-manager communication, as well as determining the networking interface used for the VXLAN Tunnel Endpoint (VTEP). This can either be an address/port combination in the form ``192.168.1.1:4567``, or an interface followed by a port number, like ``eth0:4567``. If the port number is omitted, the default swarm listening port is used. Default: ``0.0.0.0:2377`` force_new_cluster (bool): Force creating a new Swarm, even if already part of one. Default: False default_addr_pool (list of str): Default Address Pool specifies default subnet pools for global scope networks. Each pool should be specified as a CIDR block, like '10.0.0.0/8'. Default: None subnet_size (int): SubnetSize specifies the subnet size of the networks created from the default subnet pool. Default: None data_path_addr (string): Address or interface to use for data path traffic. For example, 192.168.1.1, or an interface, like eth0. data_path_port (int): Port number to use for data path traffic. Acceptable port range is 1024 to 49151. If set to ``None`` or 0, the default port 4789 will be used. Default: None task_history_retention_limit (int): Maximum number of tasks history stored. snapshot_interval (int): Number of logs entries between snapshot. keep_old_snapshots (int): Number of snapshots to keep beyond the current snapshot. log_entries_for_slow_followers (int): Number of log entries to keep around to sync up slow followers after a snapshot is created. heartbeat_tick (int): Amount of ticks (in seconds) between each heartbeat. election_tick (int): Amount of ticks (in seconds) needed without a leader to trigger a new election. dispatcher_heartbeat_period (int): The delay for an agent to send a heartbeat to the dispatcher. node_cert_expiry (int): Automatic expiry for nodes certificates. external_ca (dict): Configuration for forwarding signing requests to an external certificate authority. Use ``docker.types.SwarmExternalCA``. name (string): Swarm's name labels (dict): User-defined key/value metadata. signing_ca_cert (str): The desired signing CA certificate for all swarm node TLS leaf certificates, in PEM format. signing_ca_key (str): The desired signing CA key for all swarm node TLS leaf certificates, in PEM format. ca_force_rotate (int): An integer whose purpose is to force swarm to generate a new signing CA certificate and key, if none have been specified. autolock_managers (boolean): If set, generate a key and use it to lock data stored on the managers. log_driver (DriverConfig): The default log driver to use for tasks created in the orchestrator. Returns: (str): The ID of the created node. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> client.swarm.init( advertise_addr='eth0', listen_addr='0.0.0.0:5000', force_new_cluster=False, default_addr_pool=['10.20.0.0/16], subnet_size=24, snapshot_interval=5000, log_entries_for_slow_followers=1200 ) """ init_kwargs = { 'advertise_addr': advertise_addr, 'listen_addr': listen_addr, 'force_new_cluster': force_new_cluster, 'default_addr_pool': default_addr_pool, 'subnet_size': subnet_size, 'data_path_addr': data_path_addr, 'data_path_port': data_path_port, } init_kwargs['swarm_spec'] = self.client.api.create_swarm_spec(**kwargs) node_id = self.client.api.init_swarm(**init_kwargs) self.reload() return node_id def join(self, *args, **kwargs): return self.client.api.join_swarm(*args, **kwargs) join.__doc__ = APIClient.join_swarm.__doc__ def leave(self, *args, **kwargs): return self.client.api.leave_swarm(*args, **kwargs) leave.__doc__ = APIClient.leave_swarm.__doc__ def reload(self): """ Inspect the swarm on the server and store the response in :py:attr:`attrs`. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ self.attrs = self.client.api.inspect_swarm() def unlock(self, key): return self.client.api.unlock_swarm(key) unlock.__doc__ = APIClient.unlock_swarm.__doc__ def update(self, rotate_worker_token=False, rotate_manager_token=False, rotate_manager_unlock_key=False, **kwargs): """ Update the swarm's configuration. It takes the same arguments as :py:meth:`init`, except ``advertise_addr``, ``listen_addr``, and ``force_new_cluster``. In addition, it takes these arguments: Args: rotate_worker_token (bool): Rotate the worker join token. Default: ``False``. rotate_manager_token (bool): Rotate the manager join token. Default: ``False``. rotate_manager_unlock_key (bool): Rotate the manager unlock key. Default: ``False``. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ # this seems to have to be set if kwargs.get('node_cert_expiry') is None: kwargs['node_cert_expiry'] = 7776000000000000 return self.client.api.update_swarm( version=self.version, swarm_spec=self.client.api.create_swarm_spec(**kwargs), rotate_worker_token=rotate_worker_token, rotate_manager_token=rotate_manager_token, rotate_manager_unlock_key=rotate_manager_unlock_key ) volumes.py 0000644 00000005440 15027745625 0006630 0 ustar 00 from ..api import APIClient from .resource import Collection, Model class Volume(Model): """A volume.""" id_attribute = 'Name' @property def name(self): """The name of the volume.""" return self.attrs['Name'] def remove(self, force=False): """ Remove this volume. Args: force (bool): Force removal of volumes that were already removed out of band by the volume driver plugin. Raises: :py:class:`docker.errors.APIError` If volume failed to remove. """ return self.client.api.remove_volume(self.id, force=force) class VolumeCollection(Collection): """Volumes on the Docker server.""" model = Volume def create(self, name=None, **kwargs): """ Create a volume. Args: name (str): Name of the volume. If not specified, the engine generates a name. driver (str): Name of the driver used to create the volume driver_opts (dict): Driver options as a key-value dictionary labels (dict): Labels to set on the volume Returns: (:py:class:`Volume`): The volume created. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> volume = client.volumes.create(name='foobar', driver='local', driver_opts={'foo': 'bar', 'baz': 'false'}, labels={"key": "value"}) """ obj = self.client.api.create_volume(name, **kwargs) return self.prepare_model(obj) def get(self, volume_id): """ Get a volume. Args: volume_id (str): Volume name. Returns: (:py:class:`Volume`): The volume. Raises: :py:class:`docker.errors.NotFound` If the volume does not exist. :py:class:`docker.errors.APIError` If the server returns an error. """ return self.prepare_model(self.client.api.inspect_volume(volume_id)) def list(self, **kwargs): """ List volumes. Similar to the ``docker volume ls`` command. Args: filters (dict): Server-side list filtering options. Returns: (list of :py:class:`Volume`): The volumes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ resp = self.client.api.volumes(**kwargs) if not resp.get('Volumes'): return [] return [self.prepare_model(obj) for obj in resp['Volumes']] def prune(self, filters=None): return self.client.api.prune_volumes(filters=filters) prune.__doc__ = APIClient.prune_volumes.__doc__ __pycache__/nodes.cpython-310.pyc 0000644 00000007263 15027745625 0012612 0 ustar 00 o �hp � @ s4 d dl mZmZ G dd� de�ZG dd� de�ZdS )� )� Collection�Modelc @ s2 e Zd ZdZdZedd� �Zdd� Zd dd �Zd S ) �NodezA node in a swarm.�IDc C s | j �d��d�S )z� The version number of the service. If this is not the same as the server, the :py:meth:`update` function will not work and you will need to call :py:meth:`reload` before calling it again. �Version�Index)�attrs�get��self� r �I/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/nodes.py�version s z Node.versionc C s | j j�| j| j|�S )a� Update the node's configuration. Args: node_spec (dict): Configuration settings to update. Any values not provided will be removed. Default: ``None`` Returns: `True` if the request went through. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> node_spec = {'Availability': 'active', 'Name': 'node-name', 'Role': 'manager', 'Labels': {'foo': 'bar'} } >>> node.update(node_spec) )�client�api� update_node�idr )r � node_specr r r �update s z Node.updateFc C s | j jj| j|d�S )a� Remove this node from the swarm. Args: force (bool): Force remove an active node. Default: `False` Returns: `True` if the request was successful. Raises: :py:class:`docker.errors.NotFound` If the node doesn't exist in the swarm. :py:class:`docker.errors.APIError` If the server returns an error. )�force)r r � remove_noder )r r r r r �remove, s z Node.removeN)F) �__name__� __module__� __qualname__�__doc__� id_attribute�propertyr r r r r r r r s r c @ s$ e Zd ZdZeZdd� Zdd� ZdS )�NodeCollectionzNodes on the Docker server.c C s | � | jj�|��S )a Get a node. Args: node_id (string): ID of the node to be inspected. Returns: A :py:class:`Node` object. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )� prepare_modelr r � inspect_node)r �node_idr r r r D s zNodeCollection.getc s" � fdd�� j jj|i |��D �S )a� List swarm nodes. Args: filters (dict): Filters to process on the nodes list. Valid filters: ``id``, ``name``, ``membership`` and ``role``. Default: ``None`` Returns: A list of :py:class:`Node` objects. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> client.nodes.list(filters={'role': 'manager'}) c s g | ]}� � |��qS r )r )�.0�nr r r � <listcomp>h s ��z'NodeCollection.list.<locals>.<listcomp>)r r �nodes)r �args�kwargsr r r �listT s �zNodeCollection.listN)r r r r r �modelr r( r r r r r @ s r N)�resourcer r r r r r r r �<module> s < __pycache__/services.cpython-310.pyc 0000644 00000031360 15027745625 0013320 0 ustar 00 o �hd6 � @ s� d dl Z d dlmZmZ d dlmZmZmZmZ ddl m Z m Z G dd� de �Z G dd � d e �Z g d �Zg d �Zg d �Zg d �Zdd� ZdS )� N)�InvalidArgument� create_unexpected_kwargs_error)� ContainerSpec� Placement� ServiceMode� TaskTemplate� )� Collection�Modelc @ s^ e Zd ZdZdZedd� �Zedd� �Zdd� Zdd d �Z d d � Z dd� Z dd� Z dd� Z d S )�Servicez A service.�IDc C s | j d d S )zThe service's name.�Spec�Name)�attrs��self� r �L/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/services.py�name s z Service.namec C s | j �d��d�S )z� The version number of the service. If this is not the same as the server, the :py:meth:`update` function will not work and you will need to call :py:meth:`reload` before calling it again. �Version�Index)r �getr r r r �version s zService.versionc C s | j j�| j�S )z� Stop and remove the service. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�client�api�remove_service�idr r r r �remove s zService.removeNc C s& |du ri }| j |d< | jjj|d�S )a� List the tasks in this service. Args: filters (dict): A map of filters to process on the tasks list. Valid filters: ``id``, ``name``, ``node``, ``label``, and ``desired-state``. Returns: :py:class:`list`: List of task dictionaries. Raises: :py:class:`docker.errors.APIError` If the server returns an error. N�service)�filters)r r r �tasks)r r r r r r % s z Service.tasksc K s� d|vr| j d d d }|d |d< |�d�du r/| j d d }t|�dd ��}|d |d< td |�}| jjj| j| jfi |��S ) a) Update a service's configuration. Similar to the ``docker service update`` command. Takes the same parameters as :py:meth:`~ServiceCollection.create`. Raises: :py:class:`docker.errors.APIError` If the server returns an error. �imager r r �Image� force_updateT� ForceUpdater r �update) r r �int�_get_create_service_kwargsr r �update_servicer r )r �kwargs�spec� task_template� current_value� create_kwargsr r r r% : s ��zService.updatec K s6 | j d d d �dd�}| jjj| jfd|i|��S )a� Get log stream for the service. Note: This method works only for services with the ``json-file`` or ``journald`` logging drivers. Args: details (bool): Show extra details provided to logs. Default: ``False`` follow (bool): Keep connection open to read logs as they are sent by the Engine. Default: ``False`` stdout (bool): Return logs from ``stdout``. Default: ``False`` stderr (bool): Return logs from ``stderr``. Default: ``False`` since (int): UNIX timestamp for the logs staring point. Default: 0 timestamps (bool): Add timestamps to every log line. tail (string or int): Number of log lines to be returned, counting from the current end of the logs. Specify an integer or ``'all'`` to output all log lines. Default: ``all`` Returns: generator: Logs for the service. r r r �TTYF�is_tty)r r r r � service_logsr )r r) r/ r r r �logsW s � z Service.logsc C sB d| j d d �� v rtd��td|�}| jjj| j| j|dd�S )z� Scale service container. Args: replicas (int): The number of containers that should be running. Returns: bool: ``True`` if successful. �Globalr �Modez Cannot scale a global container� replicatedT)�mode�fetch_current_spec) r �keysr r r r r( r r )r �replicas� service_moder r r �scalet s �z Service.scalec C s | j ddd�S )z� Force update the service even if no changes require it. Returns: bool: ``True`` if successful. T)r# r6 )r% r r r r r# � s zService.force_update�N)�__name__� __module__� __qualname__�__doc__� id_attribute�propertyr r r r r% r1 r: r# r r r r r s r c @ s0 e Zd ZdZeZd dd�Zd dd�Zdd� ZdS ) �ServiceCollectionz Services on the Docker server.Nc K s8 ||d< ||d< t d|�}| jjjdi |��}| �|�S )a� Create a service. Similar to the ``docker service create`` command. Args: image (str): The image name to use for the containers. command (list of str or str): Command to run. args (list of str): Arguments to the command. constraints (list of str): :py:class:`~docker.types.Placement` constraints. preferences (list of tuple): :py:class:`~docker.types.Placement` preferences. maxreplicas (int): :py:class:`~docker.types.Placement` maxreplicas or (int) representing maximum number of replicas per node. platforms (list of tuple): A list of platform constraints expressed as ``(arch, os)`` tuples. container_labels (dict): Labels to apply to the container. endpoint_spec (EndpointSpec): Properties that can be configured to access and load balance a service. Default: ``None``. env (list of str): Environment variables, in the form ``KEY=val``. hostname (string): Hostname to set on the container. init (boolean): Run an init inside the container that forwards signals and reaps processes isolation (string): Isolation technology used by the service's containers. Only used for Windows containers. labels (dict): Labels to apply to the service. log_driver (str): Log driver to use for containers. log_driver_options (dict): Log driver options. mode (ServiceMode): Scheduling mode for the service. Default:``None`` mounts (list of str): Mounts for the containers, in the form ``source:target:options``, where options is either ``ro`` or ``rw``. name (str): Name to give to the service. networks (:py:class:`list`): List of network names or IDs or :py:class:`~docker.types.NetworkAttachmentConfig` to attach the service to. Default: ``None``. resources (Resources): Resource limits and reservations. restart_policy (RestartPolicy): Restart policy for containers. secrets (list of :py:class:`~docker.types.SecretReference`): List of secrets accessible to containers for this service. stop_grace_period (int): Amount of time to wait for containers to terminate before forcefully killing them. update_config (UpdateConfig): Specification for the update strategy of the service. Default: ``None`` rollback_config (RollbackConfig): Specification for the rollback strategy of the service. Default: ``None`` user (str): User to run commands as. workdir (str): Working directory for commands to run. tty (boolean): Whether a pseudo-TTY should be allocated. groups (:py:class:`list`): A list of additional groups that the container process will run as. open_stdin (boolean): Open ``stdin`` read_only (boolean): Mount the container's root filesystem as read only. stop_signal (string): Set signal to stop the service's containers healthcheck (Healthcheck): Healthcheck configuration for this service. hosts (:py:class:`dict`): A set of host to IP mappings to add to the container's `hosts` file. dns_config (DNSConfig): Specification for DNS related configurations in resolver configuration file. configs (:py:class:`list`): List of :py:class:`~docker.types.ConfigReference` that will be exposed to the service. privileges (Privileges): Security options for the service's containers. cap_add (:py:class:`list`): A list of kernel capabilities to add to the default set for the container. cap_drop (:py:class:`list`): A list of kernel capabilities to drop from the default set for the container. sysctls (:py:class:`dict`): A dict of sysctl values to add to the container Returns: :py:class:`Service`: The created service. Raises: :py:class:`docker.errors.APIError` If the server returns an error. r! �command�createNr )r' r r �create_servicer )r r! rC r) r- � service_idr r r rD � s R zServiceCollection.createc C s | � | jj�||��S )a} Get a service. Args: service_id (str): The ID of the service. insert_defaults (boolean): If true, default values will be merged into the output. Returns: :py:class:`Service`: The service. Raises: :py:class:`docker.errors.NotFound` If the service does not exist. :py:class:`docker.errors.APIError` If the server returns an error. :py:class:`docker.errors.InvalidVersion` If one of the arguments is not supported with the current API version. )� prepare_modelr r �inspect_service)r rF �insert_defaultsr r r r � s �zServiceCollection.getc s" � fdd�� j jjdi |��D �S )a List services. Args: filters (dict): Filters to process on the nodes list. Valid filters: ``id``, ``name`` , ``label`` and ``mode``. Default: ``None``. status (bool): Include the service task count of running and desired tasks. Default: ``None``. Returns: list of :py:class:`Service`: The services. Raises: :py:class:`docker.errors.APIError` If the server returns an error. c s g | ]}� � |��qS r )rG )�.0�sr r r � <listcomp> s ��z*ServiceCollection.list.<locals>.<listcomp>Nr )r r �services)r r) r r r �list s �zServiceCollection.listr; ) r< r= r> r? r �modelrD r rN r r r r rB � s X rB )�args�cap_add�cap_droprC �configs� dns_config�env�groups� healthcheck�hostname�hostsr! �init� isolation�labels�mounts� open_stdin� privileges� read_only�secrets�stop_grace_period� stop_signal�tty�user�workdir�sysctls)�networks� resources�restart_policy)r r\ r5 � update_config�rollback_config� endpoint_spec)� constraints� preferences� platforms� maxreplicasc C sd i }t � |�D ] }|tv r|�|�||< qi }t � |�D ] }|tv r)|�|�||< q i }t � |�D ] }|tv r>|�|�||< q1d|v rJ|�d�|d< i }t � |�D ] }|tv r^|�|�||< qQtd i |��}||d< d|v r||�d�|�di �d�|d< | dkr�d|v r�|�d�|d< |�d d �}||d < |r�t| |��td i |��}||d < t d i |��|d < |S )N�container_labelsr\ � placement� log_driver�log_driver_options)r �Optionsr% r# r6 T�container_specr+ r ) �copy�CREATE_SERVICE_KWARGS�pop�CONTAINER_SPEC_KWARGS�TASK_TEMPLATE_KWARGS�PLACEMENT_KWARGSr r r r ) � func_namer) r- �key�container_spec_kwargs�task_template_kwargsrs r6 rw r r r r' V sN ���� � r' )rx � docker.errorsr r � docker.typesr r r r �resourcer r r rB r{ r| ry r} r' r r r r �<module> s __pycache__/__init__.cpython-310.pyc 0000644 00000000251 15027745625 0013227 0 ustar 00 o �h � @ s d S )N� r r r �L/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/__init__.py�<module> s __pycache__/plugins.cpython-310.pyc 0000644 00000015564 15027745625 0013166 0 ustar 00 o �hS � @ s@ d dl mZ ddlmZmZ G dd� de�ZG dd� de�ZdS ) � )�errors� )� Collection�Modelc @ st e Zd ZdZdd� Zedd� �Zedd� �Zedd � �Zd d � Z dd d�Z ddd�Z dd� Z ddd�Z ddd�ZdS ) �Pluginz! A plugin on the server. c C s d| j j� d| j� d�S )N�<z: 'z'>)� __class__�__name__�name��self� r �K/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/plugins.py�__repr__ s zPlugin.__repr__c C � | j �d�S )z$ The plugin's name. �Name��attrs�getr r r r r � z Plugin.namec C r )z0 Whether the plugin is enabled. �Enabledr r r r r �enabled r zPlugin.enabledc C r )zG A dictionary representing the plugin's configuration. �Settingsr r r r r �settings r zPlugin.settingsc C � | j j�| j|� | �� dS )a Update the plugin's settings. Args: options (dict): A key-value mapping of options. Raises: :py:class:`docker.errors.APIError` If the server returns an error. N)�client�api�configure_pluginr �reload)r �optionsr r r � configure! � zPlugin.configureFc C r )z� Disable the plugin. Args: force (bool): Force disable. Default: False Raises: :py:class:`docker.errors.APIError` If the server returns an error. N)r r �disable_pluginr r �r �forcer r r �disable/ s zPlugin.disable� c C r )z� Enable the plugin. Args: timeout (int): Timeout in seconds. Default: 0 Raises: :py:class:`docker.errors.APIError` If the server returns an error. N)r r � enable_pluginr r )r �timeoutr r r �enable> r! z Plugin.enablec C s | j j�| j�S )a Push the plugin to a remote registry. Returns: A dict iterator streaming the status of the upload. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r � push_pluginr r r r r �pushL s z Plugin.pushc C s | j jj| j|d�S )a. Remove the plugin from the server. Args: force (bool): Remove even if the plugin is enabled. Default: False Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r$ )r r � remove_pluginr r# r r r �removeY s z Plugin.removeNc c sT � | j r t�d��|du r| j}| jj�|�}| jj�| j||�E dH | �� dS )aR Upgrade the plugin. Args: remote (string): Remote reference to upgrade to. The ``:latest`` tag is optional and is the default if omitted. Default: this plugin's name. Returns: A generator streaming the decoded API logs z)Plugin must be disabled before upgrading.N) r r � DockerErrorr r r �plugin_privileges�upgrade_pluginr )r �remote� privilegesr r r �upgradeg s � � � zPlugin.upgrade�F)r& �N)r � __module__� __qualname__�__doc__r �propertyr r r r r% r) r+ r- r3 r r r r r s r c @ s4 e Zd ZeZd dd�Zdd� Zd dd�Zd d � ZdS ) �PluginCollectionFc C s | j j�|||� | �|�S )aC Create a new plugin. Args: name (string): The name of the plugin. The ``:latest`` tag is optional, and is the default if omitted. plugin_data_dir (string): Path to the plugin data directory. Plugin data directory must contain the ``config.json`` manifest file and the ``rootfs`` directory. gzip (bool): Compress the context using gzip. Default: False Returns: (:py:class:`Plugin`): The newly created plugin. )r r � create_pluginr )r r �plugin_data_dir�gzipr r r �create� s zPluginCollection.createc C s | � | jj�|��S )ah Gets a plugin. Args: name (str): The name of the plugin. Returns: (:py:class:`Plugin`): The plugin. Raises: :py:class:`docker.errors.NotFound` If the plugin does not exist. :py:class:`docker.errors.APIError` If the server returns an error. )� prepare_modelr r �inspect_plugin)r r r r r r � s zPluginCollection.getNc C s8 | j j�|�}| j j�|||�}|D ]}q| �|p|�S )a� Pull and install a plugin. Args: remote_name (string): Remote reference for the plugin to install. The ``:latest`` tag is optional, and is the default if omitted. local_name (string): Local name for the pulled plugin. The ``:latest`` tag is optional, and is the default if omitted. Optional. Returns: (:py:class:`Plugin`): The installed plugin Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r r/ � pull_pluginr )r � remote_name� local_namer2 �it�_datar r r �install� s zPluginCollection.installc s � j j�� }� fdd�|D �S )z� List plugins installed on the server. Returns: (list of :py:class:`Plugin`): The plugins. Raises: :py:class:`docker.errors.APIError` If the server returns an error. c s g | ]}� � |��qS r )r? )�.0�rr r r � <listcomp>� s z)PluginCollection.list.<locals>.<listcomp>)r r �plugins)r �respr r r �list� s zPluginCollection.listr4 r5 ) r r6 r7 r �modelr> r rF rL r r r r r: � s r: N)� r �resourcer r r r: r r r r �<module> s ~ __pycache__/volumes.cpython-310.pyc 0000644 00000007230 15027745625 0013166 0 ustar 00 o �h � @ s@ d dl mZ ddlmZmZ G dd� de�ZG dd� de�ZdS ) � )� APIClient� )� Collection�Modelc @ s* e Zd ZdZdZedd� �Zd dd�ZdS ) �Volumez A volume.�Namec C s | j d S )zThe name of the volume.r )�attrs��self� r �K/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/volumes.py�name s z Volume.nameFc C s | j jj| j|d�S )a% Remove this volume. Args: force (bool): Force removal of volumes that were already removed out of band by the volume driver plugin. Raises: :py:class:`docker.errors.APIError` If volume failed to remove. )�force)�client�api� remove_volume�id)r r r r r �remove s z Volume.removeN)F)�__name__� __module__� __qualname__�__doc__� id_attribute�propertyr r r r r r r s r c @ sB e Zd ZdZeZd dd�Zdd� Zdd� Zd d d �Z e j je _dS ) �VolumeCollectionz Volumes on the Docker server.Nc K s | j jj|fi |��}| �|�S )a� Create a volume. Args: name (str): Name of the volume. If not specified, the engine generates a name. driver (str): Name of the driver used to create the volume driver_opts (dict): Driver options as a key-value dictionary labels (dict): Labels to set on the volume Returns: (:py:class:`Volume`): The volume created. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> volume = client.volumes.create(name='foobar', driver='local', driver_opts={'foo': 'bar', 'baz': 'false'}, labels={"key": "value"}) )r r � create_volume� prepare_model)r r �kwargs�objr r r �create s zVolumeCollection.createc C s | � | jj�|��S )ae Get a volume. Args: volume_id (str): Volume name. Returns: (:py:class:`Volume`): The volume. Raises: :py:class:`docker.errors.NotFound` If the volume does not exist. :py:class:`docker.errors.APIError` If the server returns an error. )r r r �inspect_volume)r � volume_idr r r �get< s zVolumeCollection.getc s8 � j jjdi |��}|�d�sg S � fdd�|d D �S )aT List volumes. Similar to the ``docker volume ls`` command. Args: filters (dict): Server-side list filtering options. Returns: (list of :py:class:`Volume`): The volumes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. �Volumesc s g | ]}� � |��qS r )r )�.0r r r r � <listcomp>_ s z)VolumeCollection.list.<locals>.<listcomp>Nr )r r �volumesr" )r r �respr r r �listN s zVolumeCollection.listc C s | j jj|d�S )N)�filters)r r � prune_volumes)r r) r r r �prunea s zVolumeCollection.prune)N) r r r r r �modelr r" r( r+ r r* r r r r r s r N)r r �resourcer r r r r r r r �<module> s __pycache__/swarm.cpython-310.pyc 0000644 00000020130 15027745625 0012617 0 ustar 00 o �hb � @ s8 d dl mZ d dlmZ ddlmZ G dd� de�ZdS )� )� APIClient)�APIError� )�Modelc s� e Zd ZdZdZ� fdd�Zedd� �Zdd� Ze jje_ dd d �Z dd� Z e j je _dd� Z e jje _dd� Zdd� Ze jje_ ddd�Z� ZS )�Swarmzu The server's Swarm state. This a singleton that must be reloaded to get the current state of the Swarm. �IDc s` t � j|i |�� | jr.z| �� W d S ty- } z|jjdvr"� W Y d }~d S d }~ww d S )N)i� i� )�super�__init__�client�reloadr �response� status_code)�self�args�kwargs�e�� __class__� �I/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/swarm.pyr s ����zSwarm.__init__c C s | j �d��d�S )z� The version number of the swarm. If this is not the same as the server, the :py:meth:`update` function will not work and you will need to call :py:meth:`reload` before calling it again. �Version�Index)�attrs�get�r r r r �version s z Swarm.versionc C s | j j�� S �N)r �api�get_unlock_keyr r r r r ! s zSwarm.get_unlock_keyN� 0.0.0.0:2377Fc K sL |||||||d�} | j jjdi |��| d< | j jjdi | ��} | �� | S )a Initialize a new swarm on this Engine. Args: advertise_addr (str): Externally reachable address advertised to other nodes. This can either be an address/port combination in the form ``192.168.1.1:4567``, or an interface followed by a port number, like ``eth0:4567``. If the port number is omitted, the port number from the listen address is used. If not specified, it will be automatically detected when possible. listen_addr (str): Listen address used for inter-manager communication, as well as determining the networking interface used for the VXLAN Tunnel Endpoint (VTEP). This can either be an address/port combination in the form ``192.168.1.1:4567``, or an interface followed by a port number, like ``eth0:4567``. If the port number is omitted, the default swarm listening port is used. Default: ``0.0.0.0:2377`` force_new_cluster (bool): Force creating a new Swarm, even if already part of one. Default: False default_addr_pool (list of str): Default Address Pool specifies default subnet pools for global scope networks. Each pool should be specified as a CIDR block, like '10.0.0.0/8'. Default: None subnet_size (int): SubnetSize specifies the subnet size of the networks created from the default subnet pool. Default: None data_path_addr (string): Address or interface to use for data path traffic. For example, 192.168.1.1, or an interface, like eth0. data_path_port (int): Port number to use for data path traffic. Acceptable port range is 1024 to 49151. If set to ``None`` or 0, the default port 4789 will be used. Default: None task_history_retention_limit (int): Maximum number of tasks history stored. snapshot_interval (int): Number of logs entries between snapshot. keep_old_snapshots (int): Number of snapshots to keep beyond the current snapshot. log_entries_for_slow_followers (int): Number of log entries to keep around to sync up slow followers after a snapshot is created. heartbeat_tick (int): Amount of ticks (in seconds) between each heartbeat. election_tick (int): Amount of ticks (in seconds) needed without a leader to trigger a new election. dispatcher_heartbeat_period (int): The delay for an agent to send a heartbeat to the dispatcher. node_cert_expiry (int): Automatic expiry for nodes certificates. external_ca (dict): Configuration for forwarding signing requests to an external certificate authority. Use ``docker.types.SwarmExternalCA``. name (string): Swarm's name labels (dict): User-defined key/value metadata. signing_ca_cert (str): The desired signing CA certificate for all swarm node TLS leaf certificates, in PEM format. signing_ca_key (str): The desired signing CA key for all swarm node TLS leaf certificates, in PEM format. ca_force_rotate (int): An integer whose purpose is to force swarm to generate a new signing CA certificate and key, if none have been specified. autolock_managers (boolean): If set, generate a key and use it to lock data stored on the managers. log_driver (DriverConfig): The default log driver to use for tasks created in the orchestrator. Returns: (str): The ID of the created node. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> client.swarm.init( advertise_addr='eth0', listen_addr='0.0.0.0:5000', force_new_cluster=False, default_addr_pool=['10.20.0.0/16], subnet_size=24, snapshot_interval=5000, log_entries_for_slow_followers=1200 ) )�advertise_addr� listen_addr�force_new_cluster�default_addr_pool� subnet_size�data_path_addr�data_path_port� swarm_specNr )r r �create_swarm_spec� init_swarmr ) r r r! r" r# r$ r% r& r � init_kwargs�node_idr r r �init% s V� z Swarm.initc O � | j jj|i |��S r )r r � join_swarm�r r r r r r �join� � z Swarm.joinc O r- r )r r � leave_swarmr/ r r r �leave� r1 z Swarm.leavec C s | j j�� | _dS )z� Inspect the swarm on the server and store the response in :py:attr:`attrs`. Raises: :py:class:`docker.errors.APIError` If the server returns an error. N)r r � inspect_swarmr r r r r r � s z Swarm.reloadc C s | j j�|�S r )r r � unlock_swarm)r �keyr r r �unlock� s z Swarm.unlockc K s@ |� d�du r d|d< | jjj| j| jjjdi |��|||d�S )a� Update the swarm's configuration. It takes the same arguments as :py:meth:`init`, except ``advertise_addr``, ``listen_addr``, and ``force_new_cluster``. In addition, it takes these arguments: Args: rotate_worker_token (bool): Rotate the worker join token. Default: ``False``. rotate_manager_token (bool): Rotate the manager join token. Default: ``False``. rotate_manager_unlock_key (bool): Rotate the manager unlock key. Default: ``False``. Raises: :py:class:`docker.errors.APIError` If the server returns an error. �node_cert_expiryNl �+� � )r r' �rotate_worker_token�rotate_manager_token�rotate_manager_unlock_keyr )r r r � update_swarmr r( )r r9 r: r; r r r r �update� s �z Swarm.update)Nr FNNNN)FFF)�__name__� __module__� __qualname__�__doc__� id_attributer �propertyr r r r, r0 r. r3 r2 r r7 r5 r= � __classcell__r r r r r s, �c �r N)� docker.apir � docker.errorsr �resourcer r r r r r �<module> s __pycache__/images.cpython-310.pyc 0000644 00000043737 15027745625 0012755 0 ustar 00 o �hPF � @ s� d dl Z d dlZd dlZddlmZ ddlmZ ddlmZm Z m Z ddl m Z ddl mZ dd lmZmZ G d d � d e�ZG d d � d e�ZG dd� de�Zdd� ZdS )� N� )� APIClient)�DEFAULT_DATA_CHUNK_SIZE)� BuildError�ImageLoadError�InvalidArgument)�parse_repository_tag)� json_stream� )� Collection�Modelc @ sf e Zd ZdZdd� Zedd� �Zedd� �Zedd � �Zd d � Z dd d�Z e d fdd�Z ddd�Z dS )�Imagez! An image on the server. c C s" d� | j�}d| jj� d|� d�S )Nz', '�<z: 'z'>)�join�tags� __class__�__name__)�self�tag_str� r �J/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/images.py�__repr__ s zImage.__repr__c C s | j d �d�}|p i S )z7 The labels of an image as dictionary. �Config�Labels��attrs�get)r �resultr r r �labels s z Image.labelsc C s( | j �d�r | j dd� S | j dd� S )�f The ID of the image truncated to 12 characters, plus the ``sha256:`` prefix. �sha256:N� � )�id� startswith�r r r r �short_id s zImage.short_idc C s& | j �d�}|du r g }dd� |D �S )z# The image's tags. �RepoTagsNc S s g | ]}|d kr|�qS )z <none>:<none>r )�.0�tagr r r � <listcomp>/ s z Image.tags.<locals>.<listcomp>r )r r r r r r ' s z Image.tagsc C s | j j�| j�S )z� Show the history of an image. Returns: (list): The history of the image. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�client�api�historyr# r% r r r r- 1 s z Image.historyFc C s | j jj| j||d�S )a Remove this image. Args: force (bool): Force removal of the image noprune (bool): Do not delete untagged parents Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�force�noprune)r+ r, � remove_imager# )r r. r/ r r r �remove> s �z Image.removec C sT | j }|r"| jr | jd n|}t|t�r"|| jvr t|� d���|}| jj�||�S )a� Get a tarball of an image. Similar to the ``docker save`` command. Args: chunk_size (int): The generator will return up to that much data per iteration, but may return less. If ``None``, data will be streamed as it is received. Default: 2 MB named (str or bool): If ``False`` (default), the tarball will not retain repository and tag information for this image. If set to ``True``, the first tag in the :py:attr:`~tags` list will be used to identify the image. Alternatively, any element of the :py:attr:`~tags` list can be used as an argument to use that specific tag as the saved identifier. Returns: (generator): A stream of raw archive data. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> image = cli.images.get("busybox:latest") >>> f = open('/tmp/busybox-latest.tar', 'wb') >>> for chunk in image.save(): >>> f.write(chunk) >>> f.close() r z" is not a valid tag for this image)r# r � isinstance�strr r+ r, � get_image)r � chunk_size�named�imgr r r �saveP s �z Image.saveNc K s | j jj| j|fd|i|��S )a� Tag this image into a repository. Similar to the ``docker tag`` command. Args: repository (str): The repository to set for the tag tag (str): The tag name force (bool): Force Raises: :py:class:`docker.errors.APIError` If the server returns an error. Returns: (bool): ``True`` if successful r) )r+ r, r) r# �r � repositoryr) �kwargsr r r r) z s z Image.tag)FF�N)r � __module__� __qualname__�__doc__r �propertyr r& r r- r1 r r8 r) r r r r r s *r c s\ e Zd ZdZ� fdd�Zedd� �Zedd� �Zdd d �Zd d � Z d d� Z e j je _� Z S )� RegistryDatazO Image metadata stored on the registry, including available platforms. c s t � j|i |�� || _d S r< )�super�__init__� image_name)r rD �argsr; �r r r rC � s zRegistryData.__init__c C s | j d d S )z' The ID of the object. � Descriptor�digest)r r% r r r r# � s zRegistryData.idc C s | j dd� S )r Nr! )r# r% r r r r& � s zRegistryData.short_idNc C s" t | j�\}}| jj|| j|d�S )z� Pull the image digest. Args: platform (str): The platform to pull the image for. Default: ``None`` Returns: (:py:class:`Image`): A reference to the pulled image. )r) �platform)r rD � collection�pullr# )r rI r: �_r r r rK � s zRegistryData.pullc C s� |r>t |t�s>|�d�}t|�dkst|�dk r td|� d���d|d i}t|�dkr2|d |d < t|�dkr>|d |d < t|| j�� �| jd v S ) a� Check whether the given platform identifier is available for this digest. Args: platform (str or dict): A string using the ``os[/arch[/variant]]`` format, or a platform dictionary. Returns: (bool): ``True`` if the platform is recognized as available, ``False`` otherwise. Raises: :py:class:`docker.errors.InvalidArgument` If the platform argument is not a valid descriptor. �/� r �"z$" is not a valid platform descriptor�osr r �variant� architecture� Platforms) r2 �dict�split�lenr �normalize_platformr+ �versionr )r rI �partsr r r � has_platform� s � ��zRegistryData.has_platformc C s | j j�| j�| _d S r< )r+ r, �inspect_distributionrD r r% r r r �reload� s zRegistryData.reloadr< ) r r= r> r? rC r@ r# r& rK rZ r\ r � __classcell__r r rF r rA � s rA c @ s� e Zd ZeZdd� Zdd� Zddd�Zdd d �Zd d � Z dd d�Z ddd�Z e j j e _ dd� Ze jj e_ dd� Ze jj e_ ddd�Ze jj e_ dd� Ze jj e_ dS ) �ImageCollectionc K s� | j jjdi |��}t|t�r| �|�S d}d}t�t|��\}}|D ]"}d|v r0t |d |��d|v rCt � d|d �}|rC|� d�}|}q#|rO| �|�|fS t |pSd|��)a� Build an image and return it. Similar to the ``docker build`` command. Either ``path`` or ``fileobj`` must be set. If you already have a tar file for the Docker build context (including a Dockerfile), pass a readable file-like object to ``fileobj`` and also pass ``custom_context=True``. If the stream is also compressed, set ``encoding`` to the correct value (e.g ``gzip``). If you want to get the raw output of the build, use the :py:meth:`~docker.api.build.BuildApiMixin.build` method in the low-level API. Args: path (str): Path to the directory containing the Dockerfile fileobj: A file object to use as the Dockerfile. (Or a file-like object) tag (str): A tag to add to the final image quiet (bool): Whether to return the status nocache (bool): Don't use the cache when set to ``True`` rm (bool): Remove intermediate containers. The ``docker build`` command now defaults to ``--rm=true``, but we have kept the old default of `False` to preserve backward compatibility timeout (int): HTTP timeout custom_context (bool): Optional if using ``fileobj`` encoding (str): The encoding for a stream. Set to ``gzip`` for compressing pull (bool): Downloads any updates to the FROM image in Dockerfiles forcerm (bool): Always remove intermediate containers, even after unsuccessful builds dockerfile (str): path within the build context to the Dockerfile buildargs (dict): A dictionary of build arguments container_limits (dict): A dictionary of limits applied to each container created by the build process. Valid keys: - memory (int): set memory limit for build - memswap (int): Total memory (memory + swap), -1 to disable swap - cpushares (int): CPU shares (relative weight) - cpusetcpus (str): CPUs in which to allow execution, e.g., ``"0-3"``, ``"0,1"`` shmsize (int): Size of `/dev/shm` in bytes. The size must be greater than 0. If omitted the system uses 64MB labels (dict): A dictionary of labels to set on the image cache_from (list): A list of images used for build cache resolution target (str): Name of the build-stage to build in a multi-stage Dockerfile network_mode (str): networking mode for the run commands during build squash (bool): Squash the resulting images layers into a single layer. extra_hosts (dict): Extra hosts to add to /etc/hosts in building containers, as a mapping of hostname to IP address. platform (str): Platform in the format ``os[/arch[/variant]]``. isolation (str): Isolation technology used during build. Default: `None`. use_config_proxy (bool): If ``True``, and if the docker client configuration file (``~/.docker/config.json`` by default) contains a proxy configuration, the corresponding environment variables will be set in the container being built. Returns: (tuple): The first item is the :py:class:`Image` object for the image that was built. The second item is a generator of the build logs as JSON-decoded objects. Raises: :py:class:`docker.errors.BuildError` If there is an error during the build. :py:class:`docker.errors.APIError` If the server returns any other error. ``TypeError`` If neither ``path`` nor ``fileobj`` is specified. N�error�streamz*(^Successfully built |sha256:)([0-9a-f]+)$r �Unknownr ) r+ r, �buildr2 r3 r � itertools�teer r �re�search�group) r r; �resp� last_event�image_id� result_stream�internal_stream�chunk�matchr r r rb � s( L � zImageCollection.buildc C s | � | jj�|��S )am Gets an image. Args: name (str): The name of the image. Returns: (:py:class:`Image`): The image. Raises: :py:class:`docker.errors.ImageNotFound` If the image does not exist. :py:class:`docker.errors.APIError` If the server returns an error. )� prepare_modelr+ r, � inspect_image)r �namer r r r = s zImageCollection.getNc C s t || jj�||�| j| d�S )a Gets the registry data for an image. Args: name (str): The name of the image. auth_config (dict): Override the credentials that are found in the config for this request. ``auth_config`` should contain the ``username`` and ``password`` keys to be valid. Returns: (:py:class:`RegistryData`): The data object. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )rD r r+ rJ )rA r+ r, r[ )r rq � auth_configr r r �get_registry_dataO s �z!ImageCollection.get_registry_dataFc s& � j jj|||d�}� fdd�|D �S )a� List images on the server. Args: name (str): Only show images belonging to the repository ``name`` all (bool): Show intermediate image layers. By default, these are filtered out. filters (dict): Filters to be processed on the image list. Available filters: - ``dangling`` (bool) - `label` (str|list): format either ``"key"``, ``"key=value"`` or a list of such. Returns: (list of :py:class:`Image`): The images. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )rq �all�filtersc s g | ] }� � |d ��qS )�Id�r )r( �rr% r r r* } s z(ImageCollection.list.<locals>.<listcomp>)r+ r, �images)r rq rt ru rh r r% r �listg s zImageCollection.listc sr � j j�|�}g }|D ]$}d|v r%t�d|d �}|r%|�d�}|�|� d|v r/t|d ��q � fdd�|D �S )a� Load an image that was previously saved using :py:meth:`~docker.models.images.Image.save` (or ``docker save``). Similar to ``docker load``. Args: data (binary): Image data to be loaded. Returns: (list of :py:class:`Image`): The images. Raises: :py:class:`docker.errors.APIError` If the server returns an error. r` z)(^Loaded image ID: |^Loaded image: )(.+)$r r_ c s g | ]}� � |��qS r rw )r( �ir% r r r* � s z(ImageCollection.load.<locals>.<listcomp>)r+ r, � load_imagere rf rg �appendr )r �datarh ry rm rn rj r r% r �load s � �zImageCollection.loadc K s� t |�\}}|p |p d}d|v rtjddd� |d= | jjj|f|d|d�|��}|D ]}q+|sD|�d�r7d nd }| �|� |� |� ��S | �|�S ) a� Pull an image of the given name and return it. Similar to the ``docker pull`` command. If ``tag`` is ``None`` or empty, it is set to ``latest``. If ``all_tags`` is set, the ``tag`` parameter is ignored and all image tags will be pulled. If you want to get the raw pull output, use the :py:meth:`~docker.api.image.ImageApiMixin.pull` method in the low-level API. Args: repository (str): The repository to pull tag (str): The tag to pull auth_config (dict): Override the credentials that are found in the config for this request. ``auth_config`` should contain the ``username`` and ``password`` keys to be valid. platform (str): Platform in the format ``os[/arch[/variant]]`` all_tags (bool): Pull all image tags Returns: (:py:class:`Image` or list): The image that has been pulled. If ``all_tags`` is True, the method will return a list of :py:class:`Image` objects belonging to this repository. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> # Pull the image tagged `latest` in the busybox repo >>> image = client.images.pull('busybox') >>> # Pull all tags in the busybox repo >>> images = client.images.pull('busybox', all_tags=True) �latestr` zH`stream` is not a valid parameter for this method and will be overriddenr )� stacklevelT)r) r` �all_tagsr �@�:) r �warnings�warnr+ r, rK r$ r rz ) r r: r) r� r; � image_tag�pull_logrL �sepr r r rK � s* & ���� zImageCollection.pullc K s | j jj|fd|i|��S )Nr) )r+ r, �pushr9 r r r r� � s zImageCollection.pushc O s | j jj|i |�� d S r< )r+ r, r0 �r rE r; r r r r1 � s zImageCollection.removec O � | j jj|i |��S r< )r+ r, rf r� r r r rf � � zImageCollection.searchc C s | j jj|d�S )N)ru )r+ r, � prune_images)r ru r r r �prune� s zImageCollection.prunec O r� r< )r+ r, � prune_buildsr� r r r r� � r� z ImageCollection.prune_buildsr< )NFN)NF)r r= r> r �modelrb r rs rz r rK r� r r? r1 r0 rf r� r� r� r r r r r^ � s$ a > r^ c C s8 | d u ri } d| vr|d | d< d| vr|d | d< | S )NrP �OsrR �Archr )rI � engine_infor r r rW � s rW )rc re r� r, r � constantsr �errorsr r r �utilsr �utils.json_streamr �resourcer r r rA r^ rW r r r r �<module> s K __pycache__/secrets.cpython-310.pyc 0000644 00000005354 15027745625 0013151 0 ustar 00 o �h5 � @ s@ d dl mZ ddlmZmZ G dd� de�ZG dd� de�ZdS ) � )� APIClient� )� Collection�Modelc @ s0 e Zd ZdZdZdd� Zedd� �Zdd� Zd S ) �Secretz A secret.�IDc C s d| j j� d| j� d�S )N�<z: 'z'>)� __class__�__name__�name��self� r �K/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/secrets.py�__repr__ s zSecret.__repr__c C s | j d d S )N�Spec�Name)�attrsr r r r r s z Secret.namec C s | j j�| j�S )z� Remove this secret. Raises: :py:class:`docker.errors.APIError` If secret failed to remove. )�client�api� remove_secret�idr r r r �remove s z Secret.removeN) r � __module__� __qualname__�__doc__� id_attributer �propertyr r r r r r r s r c @ s6 e Zd ZdZeZdd� Zejje_dd� Z dd� Z dS ) �SecretCollectionz Secrets on the Docker server.c K s4 | j jjdi |��}|�d�|�di �d< | �|�S )Nr r r r )r r � create_secret�get� setdefault� prepare_model)r �kwargs�objr r r �create s zSecretCollection.createc C s | � | jj�|��S )ac Get a secret. Args: secret_id (str): Secret ID. Returns: (:py:class:`Secret`): The secret. Raises: :py:class:`docker.errors.NotFound` If the secret does not exist. :py:class:`docker.errors.APIError` If the server returns an error. )r" r r �inspect_secret)r � secret_idr r r r % s zSecretCollection.getc s& � j jjdi |��}� fdd�|D �S )aT List secrets. Similar to the ``docker secret ls`` command. Args: filters (dict): Server-side list filtering options. Returns: (list of :py:class:`Secret`): The secrets. Raises: :py:class:`docker.errors.APIError` If the server returns an error. c s g | ]}� � |��qS r )r" )�.0r$ r r r � <listcomp>F s z)SecretCollection.list.<locals>.<listcomp>Nr )r r �secrets)r r# �respr r r �list7 s zSecretCollection.listN) r r r r r �modelr% r r r r, r r r r r s r N)r r �resourcer r r r r r r r �<module> s __pycache__/configs.cpython-310.pyc 0000644 00000005354 15027745625 0013131 0 ustar 00 o �h5 � @ s@ d dl mZ ddlmZmZ G dd� de�ZG dd� de�ZdS ) � )� APIClient� )� Collection�Modelc @ s0 e Zd ZdZdZdd� Zedd� �Zdd� Zd S ) �Configz A config.�IDc C s d| j j� d| j� d�S )N�<z: 'z'>)� __class__�__name__�name��self� r �K/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/configs.py�__repr__ s zConfig.__repr__c C s | j d d S )N�Spec�Name)�attrsr r r r r s z Config.namec C s | j j�| j�S )z� Remove this config. Raises: :py:class:`docker.errors.APIError` If config failed to remove. )�client�api� remove_config�idr r r r �remove s z Config.removeN) r � __module__� __qualname__�__doc__� id_attributer �propertyr r r r r r r s r c @ s6 e Zd ZdZeZdd� Zejje_dd� Z dd� Z dS ) �ConfigCollectionz Configs on the Docker server.c K s4 | j jjdi |��}|�d�|�di �d< | �|�S )Nr r r r )r r � create_config�get� setdefault� prepare_model)r �kwargs�objr r r �create s zConfigCollection.createc C s | � | jj�|��S )ac Get a config. Args: config_id (str): Config ID. Returns: (:py:class:`Config`): The config. Raises: :py:class:`docker.errors.NotFound` If the config does not exist. :py:class:`docker.errors.APIError` If the server returns an error. )r" r r �inspect_config)r � config_idr r r r % s zConfigCollection.getc s& � j jjdi |��}� fdd�|D �S )aT List configs. Similar to the ``docker config ls`` command. Args: filters (dict): Server-side list filtering options. Returns: (list of :py:class:`Config`): The configs. Raises: :py:class:`docker.errors.APIError` If the server returns an error. c s g | ]}� � |��qS r )r" )�.0r$ r r r � <listcomp>F s z)ConfigCollection.list.<locals>.<listcomp>Nr )r r �configs)r r# �respr r r �list7 s zConfigCollection.listN) r r r r r �modelr% r r r r, r r r r r s r N)r r �resourcer r r r r r r r �<module> s __pycache__/containers.cpython-310.pyc 0000644 00000127622 15027745625 0013651 0 ustar 00 o �h�� � @ s� d dl Z d dlZd dlmZ ddlmZ ddlmZ ddlm Z m Z m Z m Z m Z ddlmZmZ ddlmZ d d lmZ d d lmZmZ G d d � d e�ZG dd� de�Zg d�Zg d�Zdd� Z dd� Z edd�Z dS )� N)� namedtuple� )� APIClient)�DEFAULT_DATA_CHUNK_SIZE)�ContainerError�DockerException� ImageNotFound�NotFound� create_unexpected_kwargs_error)� HostConfig�NetworkingConfig)� version_gte� )�Image)� Collection�Modelc @ s e Zd ZdZedd� �Zedd� �Zedd� �Zedd � �Zed d � �Z ed d � �Z dd� Z dd� Z d>dd�Z dd� Z d?dd�Zefd d �Zedfd d �Zd@d d!�Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!dS )A� ContaineraI Local representation of a container object. Detailed configuration may be accessed through the :py:attr:`attrs` attribute. Note that local attributes are cached; users may call :py:meth:`reload` to query the Docker daemon for the current properties, causing :py:attr:`attrs` to be refreshed. c C s$ | j �d�dur| j d �d�S dS )z, The name of the container. �NameN�/)�attrs�get�lstrip��self� r �N/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/containers.py�name s �zContainer.namec C s8 | j �d| j d �}|du rdS | jj�|�d�d �S )z- The image of the container. �ImageIDr N�:r )r r �client�images�split)r �image_idr r r �image$ s zContainer.imagec C s> z | j d �d�}|p i W S ty } ztd�|�d}~ww )z: The labels of a container as dictionary. �Config�LabelszYLabel data is not available for sparse objects. Call reload() to retrieve all informationN)r r �KeyErrorr )r �result�ker r r �labels. s ����zContainer.labelsc C s( t | jd t�r| jd d S | jd S )zW The status of the container. For example, ``running``, or ``exited``. �State�Status)� isinstancer �dictr r r r �status< s zContainer.statusc C s | j �di ��di ��dd�S )zm The healthcheck status of the container. For example, ``healthy`, or ``unhealthy`. r* �Healthr+ �unknown�r r r r r r �healthE s zContainer.healthc C s | j �di ��di �S )zG The ports that the container exposes as a dictionary. �NetworkSettings�Portsr1 r r r r �portsN s zContainer.portsc K � | j jj| jfi |��S )a Attach to this container. :py:meth:`logs` 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: 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. Returns: By default, the container's output as a single string. If ``stream=True``, an iterator of output strings. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r �api�attach�id�r �kwargsr r r r8 U s zContainer.attachc K r6 )a� Like :py:meth:`attach`, but returns the underlying socket-like object for the HTTP request. Args: params (dict): Dictionary of request parameters (e.g. ``stdout``, ``stderr``, ``stream``). ws (bool): Use websockets instead of raw HTTP. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 � attach_socketr9 r: r r r r< o � zContainer.attach_socketNc K s0 | j jj| jf||d�|��}| j j�|d �S )a Commit a container to an image. Similar to the ``docker commit`` command. Args: 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 pause (bool): Whether to pause the container before committing 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. )� repository�tag�Id)r r7 �commitr9 r r )r r> r? r; �respr r r rA s �zContainer.commitc C � | j j�| j�S )a' Inspect changes on a container's filesystem. Returns: (list) A list of dictionaries containing the attributes `Path` and `Kind`. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �diffr9 r r r r rD � s zContainer.diffTF� c C sp | j jj| j|||||||| | d� }| j jj|d ||| | | d�}| s%| r*td|�S t| j j�|d �d |�S )a1 Run a command inside this container. Similar to ``docker exec``. Args: cmd (str or list): Command to be executed stdout (bool): Attach to stdout. Default: ``True`` stderr (bool): Attach to stderr. Default: ``True`` stdin (bool): Attach to stdin. Default: ``False`` tty (bool): Allocate a pseudo-TTY. Default: False privileged (bool): Run as privileged. user (str): User to execute command as. Default: root detach (bool): If true, detach from the exec command. Default: False stream (bool): Stream response data. Default: False socket (bool): Return the connection socket to allow custom read/write operations. Default: False environment (dict or list): A dictionary or a list of strings in the following format ``["PASSWORD=xxx"]`` or ``{"PASSWORD": "xxx"}``. workdir (str): Path to working directory for this exec session demux (bool): Return stdout and stderr separately Returns: (ExecResult): A tuple of (exit_code, output) exit_code: (int): Exit code for the executed command or ``None`` if either ``stream`` or ``socket`` is ``True``. output: (generator, bytes, or tuple): If ``stream=True``, a generator yielding response chunks. If ``socket=True``, a socket object for the connection. If ``demux=True``, a tuple of two bytes: stdout and stderr. A bytestring containing response data otherwise. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�stdout�stderr�stdin�tty� privileged�user� environment�workdirr@ )�detachrI �stream�socket�demuxN�ExitCode)r r7 � exec_creater9 � exec_start� ExecResult� exec_inspect)r �cmdrF rG rH rI rJ rK rN rO rP rL rM rQ rB � exec_outputr r r �exec_run� s )�� �zContainer.exec_runc C � | j j�| j|�S )a� Export the contents of the container's filesystem as a tar archive. Args: chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB Returns: (str): The filesystem tar archive Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �exportr9 )r � chunk_sizer r r r[ � s zContainer.exportc C s | j j�| j|||�S )a� Retrieve a file or folder from the container in the form of a tar archive. Args: path (str): Path to the file or folder to retrieve chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB encode_stream (bool): Determines if data should be encoded (gzip-compressed) during transmission. Default: False Returns: (tuple): First element is a raw tar data stream. Second element is a dict containing ``stat`` information on the specified ``path``. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> f = open('./sh_bin.tar', 'wb') >>> bits, stat = container.get_archive('/bin/sh') >>> print(stat) {'name': 'sh', 'size': 1075464, 'mode': 493, 'mtime': '2018-10-01T15:37:48-07:00', 'linkTarget': ''} >>> for chunk in bits: ... f.write(chunk) >>> f.close() )r r7 � get_archiver9 )r �pathr\ � encode_streamr r r r] � s !�zContainer.get_archivec C s | j jj| j|d�S )a Kill or send a signal to the container. Args: signal (str or int): The signal to send. Defaults to ``SIGKILL`` Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�signal)r r7 �killr9 )r r` r r r ra � zContainer.killc K r6 )a Get logs from this container. Similar to the ``docker logs`` command. The ``stream`` parameter makes the ``logs`` function return a blocking generator you can iterate over to retrieve log output as it happens. Args: stdout (bool): Get ``STDOUT``. Default ``True`` stderr (bool): Get ``STDERR``. Default ``True`` stream (bool): Stream the response. Default ``False`` timestamps (bool): Show timestamps. Default ``False`` tail (str or int): Output specified number of lines at the end of logs. Either an integer of number of lines or the string ``all``. Default ``all`` since (datetime, int, or float): Show logs since a given datetime, integer epoch (in seconds) or float (in nanoseconds) follow (bool): Follow log output. Default ``False`` until (datetime, int, or float): Show logs that occurred before the given datetime, integer epoch (in seconds), or float (in nanoseconds) Returns: (generator of bytes or bytes): Logs from the container. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �logsr9 r: r r r rc % s zContainer.logsc C rC )z� Pauses all processes within this container. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �pauser9 r r r r rd D � zContainer.pausec C � | j j�| j||�S )a� Insert a file or folder in this container using a tar archive as source. Args: path (str): Path inside the container where the file(s) will be extracted. Must exist. data (bytes or stream): tar data to be extracted Returns: (bool): True if the call succeeds. Raises: :py:class:`~docker.errors.APIError` If an error occurs. )r r7 � put_archiver9 )r r^ �datar r r rg N s zContainer.put_archivec K r6 )a� Remove this container. Similar to the ``docker rm`` command. Args: v (bool): Remove the volumes associated with the container link (bool): Remove the specified link and not the underlying container force (bool): Force the removal of a running container (uses ``SIGKILL``) Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �remove_containerr9 r: r r r �remove` s zContainer.removec C rZ )a Rename this container. Similar to the ``docker rename`` command. Args: name (str): New name for the container Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �renamer9 )r r r r r rk q s zContainer.renamec C rf )a Resize the tty session. Args: height (int): Height of tty session width (int): Width of tty session Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �resizer9 )r �height�widthr r r rl ~ rb zContainer.resizec K r6 )a� Restart this container. Similar to the ``docker restart`` command. Args: timeout (int): Number of seconds to try to stop for before killing the container. Once killed it will then be restarted. Default is 10 seconds. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �restartr9 r: r r r ro � s zContainer.restartc K r6 )z� Start this container. Similar to the ``docker start`` command, but doesn't support attach options. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �startr9 r: r r r rp � s zContainer.startc K r6 )a# Stream statistics for this container. Similar to the ``docker stats`` command. Args: decode (bool): If set to true, stream will be decoded into dicts on the fly. Only applicable if ``stream`` is True. False by default. stream (bool): If set to false, only the current stats will be returned instead of a stream. True by default. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �statsr9 r: r r r rq � s zContainer.statsc K r6 )aU Stops a container. Similar to the ``docker stop`` command. Args: timeout (int): Timeout in seconds to wait for the container to stop before sending a ``SIGKILL``. Default: 10 Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �stopr9 r: r r r rr � s zContainer.stopc K r6 )aH Display the running processes of the container. Args: ps_args (str): An optional arguments passed to ps (e.g. ``aux``) Returns: (str): The output of the top Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �topr9 r: r r r rs � r= z Container.topc C rC )z� Unpause all processes within the container. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �unpauser9 r r r r rt � re zContainer.unpausec K r6 )a Update resource configuration of the containers. Args: blkio_weight (int): Block IO (relative weight), between 10 and 1000 cpu_period (int): Limit CPU CFS (Completely Fair Scheduler) period cpu_quota (int): Limit CPU CFS (Completely Fair Scheduler) quota cpu_shares (int): CPU shares (relative weight) cpuset_cpus (str): CPUs in which to allow execution cpuset_mems (str): MEMs in which to allow execution mem_limit (int or str): Memory limit mem_reservation (int or str): Memory soft limit memswap_limit (int or str): Total memory (memory + swap), -1 to disable swap kernel_memory (int or str): Kernel memory limit restart_policy (dict): Restart policy dictionary Returns: (dict): Dictionary containing a ``Warnings`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �update_containerr9 r: r r r �update� s zContainer.updatec K r6 )a� Block until the container stops, then return its exit code. Similar to the ``docker wait`` command. Args: timeout (int): Request timeout condition (str): Wait until a container state reaches the given condition, either ``not-running`` (default), ``next-exit``, or ``removed`` Returns: (dict): The API's response as a Python dictionary, including the container's exit code under the ``StatusCode`` attribute. Raises: :py:class:`requests.exceptions.ReadTimeout` If the timeout is exceeded. :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �waitr9 r: r r r rw � s zContainer.wait)NN) TTFFFrE FFFNNF�N)"�__name__� __module__� __qualname__�__doc__�propertyr r# r) r. r2 r5 r8 r< rA rD rY r r[ r] ra rc rd rg rj rk rl ro rp rq rr rs rt rv rw r r r r r sR � : � $ r c @ sR e Zd ZeZ ddd�Zddd�Zdd � Z dd d �Zdd d�Z e j j e _ dS )�ContainerCollectionNTFc K s� t |t�r|j}|�dd�}|�dd�}|�dd�} |r/|r/t| jjjd�r+d|d< nt d ��|�d �r=|�d �r=t d ��|�d �rK|�d �sKt d��z| j d|||d�|��} W n t yw | jj j || d� | j d|||d�|��} Y nw | �� |r�| S | jd d d } d} | dks�| dkr�| j||ddd�} | �� d } | dkr�d} |�d�s�| jddd�} |r�| �� | dkr�t| | ||| ��|s�| du r�| S d�| �S ) a�A Run a container. By default, it will wait for the container to finish and return its logs, similar to ``docker run``. If the ``detach`` argument is ``True``, it will start the container and immediately return a :py:class:`Container` object, similar to ``docker run -d``. Example: Run a container and get its output: >>> import docker >>> client = docker.from_env() >>> client.containers.run('alpine', 'echo hello world') b'hello world\n' Run a container and detach: >>> container = client.containers.run('bfirsh/reticulate-splines', detach=True) >>> container.logs() 'Reticulating spline 1...\nReticulating spline 2...\n' Args: image (str): The image to run. command (str or list): The command to run in the container. auto_remove (bool): enable auto-removal of the container on daemon side when the container's process exits. blkio_weight_device: Block IO weight (relative device weight) in the form of: ``[{"Path": "device_path", "Weight": weight}]``. blkio_weight: Block IO weight (relative weight), accepts a weight value between 10 and 1000. cap_add (list of str): Add kernel capabilities. For example, ``["SYS_ADMIN", "MKNOD"]``. cap_drop (list of str): Drop kernel capabilities. cgroup_parent (str): Override the default parent cgroup. cgroupns (str): Override the default cgroup namespace mode for the container. One of: - ``private`` the container runs in its own private cgroup namespace. - ``host`` use the host system's cgroup namespace. cpu_count (int): Number of usable CPUs (Windows only). cpu_percent (int): Usable percentage of the available CPUs (Windows only). cpu_period (int): The length of a CPU period in microseconds. cpu_quota (int): Microseconds of CPU time that the container can get in a CPU period. cpu_rt_period (int): Limit CPU real-time period in microseconds. cpu_rt_runtime (int): Limit CPU real-time runtime in microseconds. cpu_shares (int): CPU shares (relative weight). cpuset_cpus (str): CPUs in which to allow execution (``0-3``, ``0,1``). cpuset_mems (str): Memory nodes (MEMs) in which to allow execution (``0-3``, ``0,1``). Only effective on NUMA systems. detach (bool): Run container in the background and return a :py:class:`Container` object. device_cgroup_rules (:py:class:`list`): A list of cgroup rules to apply to the container. device_read_bps: Limit read rate (bytes per second) from a device in the form of: `[{"Path": "device_path", "Rate": rate}]` device_read_iops: Limit read rate (IO per second) from a device. device_write_bps: Limit write rate (bytes per second) from a device. device_write_iops: Limit write rate (IO per second) from a device. devices (:py:class:`list`): Expose host devices to the container, as a list of strings in the form ``<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. domainname (str or list): Set custom DNS search domains. entrypoint (str or list): The entrypoint for the container. environment (dict or list): Environment variables to set inside the container, as a dictionary or a list of strings in the format ``["SOMEVARIABLE=xxx"]``. extra_hosts (dict): Additional hostnames to resolve inside the container, as a mapping of hostname to IP address. group_add (:py:class:`list`): List of additional group names and/or IDs that the container process will run as. healthcheck (dict): Specify a test to perform to check that the container is healthy. The dict takes the following keys: - test (:py:class:`list` or str): Test to perform to determine container health. Possible values: - Empty list: Inherit healthcheck from parent image - ``["NONE"]``: Disable healthcheck - ``["CMD", args...]``: exec arguments directly. - ``["CMD-SHELL", command]``: Run command in the system's default shell. If a string is provided, it will be used as a ``CMD-SHELL`` command. - interval (int): The time to wait between checks in nanoseconds. It should be 0 or at least 1000000 (1 ms). - timeout (int): The time to wait before considering the check to have hung. It should be 0 or at least 1000000 (1 ms). - retries (int): The number of consecutive failures needed to consider a container as unhealthy. - start_period (int): Start period for the container to initialize before starting health-retries countdown in nanoseconds. It should be 0 or at least 1000000 (1 ms). hostname (str): Optional hostname for the container. init (bool): Run an init inside the container that forwards signals and reaps processes init_path (str): Path to the docker-init binary ipc_mode (str): Set the IPC mode for the container. isolation (str): Isolation technology to use. Default: `None`. kernel_memory (int or str): Kernel memory limit labels (dict or list): A dictionary of name-value labels (e.g. ``{"label1": "value1", "label2": "value2"}``) or a list of names of labels to set with empty values (e.g. ``["label1", "label2"]``) links (dict): Mapping of links using the ``{'container': 'alias'}`` format. The alias is optional. Containers declared in this dict will be linked to the new container using the provided alias. Default: ``None``. log_config (LogConfig): Logging configuration. lxc_conf (dict): LXC config. mac_address (str): MAC address to assign to the container. mem_limit (int or str): Memory limit. Accepts float values (which represent the memory limit of the created container in bytes) or a string with a units identification char (``100000b``, ``1000k``, ``128m``, ``1g``). If a string is specified without a units character, bytes are assumed as an intended unit. mem_reservation (int or str): Memory soft limit. mem_swappiness (int): Tune a container's memory swappiness behavior. Accepts number between 0 and 100. memswap_limit (str or int): Maximum amount of memory + swap a container is allowed to consume. mounts (:py:class:`list`): Specification for mounts to be added to the container. More powerful alternative to ``volumes``. Each item in the list is expected to be a :py:class:`docker.types.Mount` object. name (str): The name for this container. nano_cpus (int): CPU quota in units of 1e-9 CPUs. network (str): Name of the network this container will be connected to at creation time. You can connect to additional networks using :py:meth:`Network.connect`. Incompatible with ``network_mode``. network_disabled (bool): Disable networking. network_mode (str): One of: - ``bridge`` Create a new network stack for the container on the bridge network. - ``none`` No networking for this container. - ``container:<name|id>`` Reuse another container's network stack. - ``host`` Use the host network stack. This mode is incompatible with ``ports``. Incompatible with ``network``. networking_config (Dict[str, EndpointConfig]): Dictionary of EndpointConfig objects for each container network. The key is the name of the network. Defaults to ``None``. Used in conjuction with ``network``. Incompatible with ``network_mode``. oom_kill_disable (bool): Whether to disable OOM killer. oom_score_adj (int): An integer value containing the score given to the container in order to tune OOM killer preferences. pid_mode (str): If set to ``host``, use the host PID namespace inside the container. pids_limit (int): Tune a container's pids limit. Set ``-1`` for unlimited. platform (str): Platform in the format ``os[/arch[/variant]]``. Only used if the method needs to pull the requested image. ports (dict): Ports to bind inside the container. The keys of the dictionary are the ports to bind inside the container, either as an integer or a string in the form ``port/protocol``, where the protocol is either ``tcp``, ``udp``, or ``sctp``. The values of the dictionary are the corresponding ports to open on the host, which can be either: - The port number, as an integer. For example, ``{'2222/tcp': 3333}`` will expose port 2222 inside the container as port 3333 on the host. - ``None``, to assign a random host port. For example, ``{'2222/tcp': None}``. - A tuple of ``(address, port)`` if you want to specify the host interface. For example, ``{'1111/tcp': ('127.0.0.1', 1111)}``. - A list of integers, if you want to bind multiple host ports to a single container port. For example, ``{'1111/tcp': [1234, 4567]}``. Incompatible with ``host`` network mode. privileged (bool): Give extended privileges to this container. publish_all_ports (bool): Publish all ports to the host. read_only (bool): Mount the container's root filesystem as read only. remove (bool): Remove the container when it has finished running. Default: ``False``. restart_policy (dict): Restart the container when it exits. Configured as a dictionary with keys: - ``Name`` One of ``on-failure``, or ``always``. - ``MaximumRetryCount`` Number of times to restart the container on failure. For example: ``{"Name": "on-failure", "MaximumRetryCount": 5}`` runtime (str): Runtime to use with this container. security_opt (:py:class:`list`): A list of string values to customize labels for MLS systems, such as SELinux. shm_size (str or int): Size of /dev/shm (e.g. ``1G``). stdin_open (bool): Keep ``STDIN`` open even if not attached. stdout (bool): Return logs from ``STDOUT`` when ``detach=False``. Default: ``True``. stderr (bool): Return logs from ``STDERR`` when ``detach=False``. Default: ``False``. stop_signal (str): The stop signal to use to stop the container (e.g. ``SIGINT``). storage_opt (dict): Storage driver options per container as a key-value mapping. stream (bool): If true and ``detach`` is false, return a log generator instead of a string. Ignored if ``detach`` is true. Default: ``False``. sysctls (dict): Kernel parameters to set in the container. tmpfs (dict): Temporary filesystems to mount, as a dictionary mapping a path inside the container to options for that path. For example: .. code-block:: python { '/mnt/vol2': '', '/mnt/vol1': 'size=3G,uid=1000' } tty (bool): Allocate a pseudo-TTY. ulimits (:py:class:`list`): Ulimits to set inside the container, as a list of :py:class:`docker.types.Ulimit` instances. use_config_proxy (bool): If ``True``, and if the docker client configuration file (``~/.docker/config.json`` by default) contains a proxy configuration, the corresponding environment variables will be set in the container being built. user (str or int): Username or UID to run commands as inside the container. userns_mode (str): Sets the user namespace mode for the container when user namespace remapping option is enabled. Supported values are: ``host`` uts_mode (str): Sets the UTS namespace mode for the container. Supported values are: ``host`` version (str): The version of the API to use. Set to ``auto`` to automatically detect the server's version. Default: ``1.35`` volume_driver (str): The name of a volume driver/plugin. volumes (dict or list): A dictionary to configure volumes mounted inside the container. The key is either the host path or a volume name, and the value is a dictionary with the keys: - ``bind`` The path to mount the volume inside the container - ``mode`` Either ``rw`` to mount the volume read/write, or ``ro`` to mount it read-only. For example: .. code-block:: python {'/home/user1/': {'bind': '/mnt/vol2', 'mode': 'rw'}, '/var/www': {'bind': '/mnt/vol1', 'mode': 'ro'}} Or a list of strings which each one of its elements specifies a mount volume. For example: .. code-block:: python ['/home/user1/:/mnt/vol2','/var/www:/mnt/vol1'] volumes_from (:py:class:`list`): List of container names or IDs to get volumes from. working_dir (str): Path to the working directory. Returns: The container logs, either ``STDOUT``, ``STDERR``, or both, depending on the value of the ``stdout`` and ``stderr`` arguments. ``STDOUT`` and ``STDERR`` may be read only if either ``json-file`` or ``journald`` logging driver used. Thus, if you are using none of these drivers, a ``None`` object is returned instead. See the `Engine API documentation <https://docs.docker.com/engine/api/v1.30/#operation/ContainerLogs/>`_ for full details. If ``detach`` is ``True``, a :py:class:`Container` object is returned instead. Raises: :py:class:`docker.errors.ContainerError` If the container exits with a non-zero exit code and ``detach`` is ``False``. :py:class:`docker.errors.ImageNotFound` If the specified image does not exist. :py:class:`docker.errors.APIError` If the server returns an error. rO FrN �platformNz1.25T� auto_removezQThe options 'detach' and 'remove' cannot be used together in api versions < 1.25.�network� network_modezBThe options "network" and "network_mode" can not be used together.�networking_configzAThe option "networking_config" can not be used without "network".)r# �commandrN )r r � LogConfig�Typez json-file�journald)rF rG rO �follow� StatusCoder )rF rG � r )r, r r9 �popr r r r7 �_version� RuntimeError�creater r �pullrp r rc rw rj r �join)r r# r� rF rG rj r; rO rN r � container�logging_driver�out� exit_statusr r r �run sp > �� � � � ��� � zContainerCollection.runc K sX t |t�r|j}||d< ||d< | jjj|d< t|�}| jjjdi |��}| �|d �S )a� Create a container without starting it. Similar to ``docker create``. Takes the same arguments as :py:meth:`run`, except for ``stdout``, ``stderr``, and ``remove``. Returns: A :py:class:`Container` object. Raises: :py:class:`docker.errors.ImageNotFound` If the specified image does not exist. :py:class:`docker.errors.APIError` If the server returns an error. r# r� �versionr@ Nr ) r, r r9 r r7 r� �_create_container_args�create_containerr )r r# r� r; � create_kwargsrB r r r r� � s zContainerCollection.createc C s | j j�|�}| �|�S )a� Get a container by name or ID. Args: container_id (str): Container name or ID. Returns: A :py:class:`Container` object. Raises: :py:class:`docker.errors.NotFound` If the container does not exist. :py:class:`docker.errors.APIError` If the server returns an error. )r r7 �inspect_container� prepare_model)r � container_idrB r r r r � s zContainerCollection.get���c sp � j jj|||||d�}|r� fdd�|D �S g } |D ]} z | �� �| d �� W q ty5 |s3� Y qw | S )af List containers. Similar to the ``docker ps`` command. Args: all (bool): Show all containers. Only running containers are shown by default since (str): Show only containers created since Id or Name, include non-running ones before (str): Show only container created before Id or Name, include non-running ones limit (int): Show `limit` last created containers, include non-running ones filters (dict): Filters to be processed on the image list. Available filters: - `exited` (int): Only containers with specified exit code - `status` (str): One of ``restarting``, ``running``, ``paused``, ``exited`` - `label` (str|list): format either ``"key"``, ``"key=value"`` or a list of such. - `id` (str): The id of the container. - `name` (str): The name of the container. - `ancestor` (str): Filter by container ancestor. Format of ``<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>`_. sparse (bool): Do not inspect containers. Returns partial information, but guaranteed not to block. Use :py:meth:`Container.reload` on resulting objects to retrieve all attributes. Default: ``False`` ignore_removed (bool): Ignore failures due to missing containers when attempting to inspect containers from the original list. Set to ``True`` if race conditions are likely. Has no effect if ``sparse=True``. Default: ``False`` Returns: (list of :py:class:`Container`) Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�all�before�filters�limit�sincec s g | ]}� � |��qS r )r� )�.0�rr r r � <listcomp>� s z,ContainerCollection.list.<locals>.<listcomp>r@ )r r7 � containers�appendr r ) r r� r� r� r� r� �sparse�ignore_removedrB r� r� r r r �list� s 4� ��zContainerCollection.listc C s | j jj|d�S )N)r� )r r7 �prune_containers)r r� r r r �prune s zContainerCollection.prune)NTFFrx )FNNr� NFF) ry rz r{ r �modelr� r� r r� r� r r� r| r r r r r~ s � } � Dr~ )r� rN � domainname� entrypointrL � healthcheck�hostnamer# r) � mac_addressr �network_disabledr � stdin_open� stop_signalrI �use_config_proxyrK � working_dir)?r� �blkio_weight_device� blkio_weight�cap_add�cap_drop� cgroup_parent�cgroupns� cpu_count� cpu_percent� cpu_period� cpu_quota� cpu_shares� cpuset_cpus� cpuset_mems� cpu_rt_period�cpu_rt_runtime�device_cgroup_rules�device_read_bps�device_read_iops�device_write_bps�device_write_iops�devices�device_requests�dns_opt� dns_search�dns� extra_hosts� group_add�init� init_path�ipc_mode� isolation� kernel_memory�links� log_config�lxc_conf� mem_limit�mem_reservation�mem_swappiness� memswap_limit�mounts� nano_cpusr� �oom_kill_disable� oom_score_adj�pid_mode� pids_limitrJ �publish_all_ports� read_only�restart_policy� security_opt�shm_size� storage_opt�sysctls�tmpfs�ulimits� userns_mode�uts_moder� � volume_driver� volumes_from�runtimec C sZ i }t � | �D ] }|tv r| �|�||< qi }t � | �D ] }|tv r)| �|�||< q | �di �}|r6||d< | �di �}|rB||d< | �dd�}| �dd�}|rh|rX||vrXd}|r^t|�n|di|d< ||d< | rotd | ��tdi |��|d < |d �d �}|r�d d � t|� � �D �|d< |r�t |t �r�dd � |� � D �|d< |S dd � |D �|d< |S )zK Convert arguments to create() to arguments to create_container(). r5 � port_bindings�volumes�bindsr� Nr� r� r� � host_config� PortBindingsc S s g | ] }t |�d d���qS )r r )�tupler! )r� �pr r r r� � s �z*_create_container_args.<locals>.<listcomp>c S s g | ]}|� d ��qS )�bind)r �r� �vr r r r� � s �c S s g | ]}t |��qS r )�_host_volume_from_bindr� r r r r� � s �r ) �copy�RUN_CREATE_KWARGSr� �RUN_HOST_CONFIG_KWARGSr r r r �sorted�keysr, r- �values) r; r� �key�host_config_kwargsr5 r� r� r� r� r r r r� b s^ �� ��� � �� �r� c C sr t �| �\}}|�dd�}t|�dks|d dv r ||d S |d �d�s-|d �d�r5|d d d� S |d S )Nr r )�ro�rwr z:roz:rw���)�ntpath� splitdriver! �len�endswith)r� �drive�rest�bitsr r r r� � s r� rU zexit_code,output) r� r � collectionsr r7 r � constantsr �errorsr r r r r �typesr r �utilsr r r �resourcer r r r~ r� r r� r� rU r r r r �<module> s2 xC> __pycache__/networks.cpython-310.pyc 0000644 00000021225 15027745625 0013350 0 ustar 00 o �h � @ sX d dl mZ d dlmZ ddlmZ ddlmZmZ G dd� de�Z G dd � d e�Z d S ) � )� APIClient)� version_gte� )� Container)� Collection�Modelc @ s@ e Zd ZdZedd� �Zedd� �Zdd� Zdd � Zd d � Z d S ) �Networkz A Docker network. c C s | j �d�S )z* The name of the network. �Name)�attrs�get��self� r �L/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/networks.py�name s z Network.namec s" � fdd�� j �d�p i �� D �S )z� The containers that are connected to the network, as a list of :py:class:`~docker.models.containers.Container` objects. c s g | ] }� j j�|��qS r )�client� containersr )�.0�cidr r r � <listcomp> s �z&Network.containers.<locals>.<listcomp>� Containers)r r �keysr r r r r s �zNetwork.containersc O �0 t |t�r|j}| jjj|| jg|�R i |��S )a Connect a container to this network. Args: container (str): Container to connect to this network, as either an ID, name, or :py:class:`~docker.models.containers.Container` object. 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 (:py:class:`list`): A list of links for this endpoint. Containers declared in this list will be linkedto this container. 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``. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )� isinstancer �idr �api� connect_container_to_network�r � container�args�kwargsr r r �connect s ���zNetwork.connectc O r )a� Disconnect a container from this network. Args: container (str): Container to disconnect from this network, as either an ID, name, or :py:class:`~docker.models.containers.Container` object. force (bool): Force the container to disconnect from a network. Default: ``False`` Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r r r r �!disconnect_container_from_networkr r r r � disconnect> s ���zNetwork.disconnectc C s | j j�| j�S )z� Remove this network. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r r �remove_networkr r r r r �removeS s zNetwork.removeN) �__name__� __module__� __qualname__�__doc__�propertyr r r! r# r% r r r r r s ! r c @ s@ e Zd ZdZeZdd� Zdd� Zdd� Zd d d �Z e j je _dS ) �NetworkCollectionz( Networks on the Docker server. c O s* | j jj|g|�R i |��}| �|d �S )a� Create a network. Similar to the ``docker network create``. Args: name (str): Name of the network driver (str): Name of the driver used to create the network options (dict): Driver options as a key-value dictionary ipam (IPAMConfig): Optional custom IP scheme for the network. check_duplicate (bool): Request daemon to check for networks with same name. Default: ``None``. internal (bool): Restrict external access to the network. Default ``False``. labels (dict): Map of labels to set on the network. Default ``None``. enable_ipv6 (bool): Enable IPv6 on the network. Default ``False``. attachable (bool): If enabled, and the network is in the global scope, non-service containers on worker nodes will be able to connect to the network. scope (str): Specify the network's scope (``local``, ``global`` or ``swarm``) ingress (bool): If set, create an ingress network which provides the routing-mesh in swarm mode. Returns: (:py:class:`Network`): The network that was created. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: A network using the bridge driver: >>> client.networks.create("network1", driver="bridge") You can also create more advanced networks with custom IPAM configurations. For example, setting the subnet to ``192.168.52.0/24`` and gateway address to ``192.168.52.254``. .. code-block:: python >>> ipam_pool = docker.types.IPAMPool( subnet='192.168.52.0/24', gateway='192.168.52.254' ) >>> ipam_config = docker.types.IPAMConfig( pool_configs=[ipam_pool] ) >>> client.networks.create( "network1", driver="bridge", ipam=ipam_config ) �Id)r r �create_networkr )r r r r �respr r r �created s 8zNetworkCollection.createc O s" | � | jjj|g|�R i |���S )aU Get a network by its ID. Args: network_id (str): The ID of the network. verbose (bool): Retrieve the service details across the cluster in swarm mode. scope (str): Filter the network by scope (``swarm``, ``global`` or ``local``). Returns: (:py:class:`Network`) The network. Raises: :py:class:`docker.errors.NotFound` If the network does not exist. :py:class:`docker.errors.APIError` If the server returns an error. )� prepare_modelr r �inspect_network)r � network_idr r r r r r � s �zNetworkCollection.getc s\ |� dd�}� jjj|i |��}� fdd�|D �}|r,t� jjjd�r,|D ]}|�� q%|S )a� List networks. Similar to the ``docker network ls`` command. Args: names (:py:class:`list`): List of names to filter by. ids (:py:class:`list`): List of ids to filter by. filters (dict): Filters to be processed on the network list. Available filters: - ``driver=[<driver-name>]`` Matches a network's driver. - `label` (str|list): format either ``"key"``, ``"key=value"`` or a list of such. - ``type=["custom"|"builtin"]`` Filters networks by type. greedy (bool): Fetch more details for each network individually. You might want this to get the containers attached to them. Returns: (list of :py:class:`Network`) The networks on the server. Raises: :py:class:`docker.errors.APIError` If the server returns an error. �greedyFc s g | ]}� � |��qS r )r0 )r �itemr r r r � s z*NetworkCollection.list.<locals>.<listcomp>z1.28)�popr r �networksr �_version�reload)r r r r3 r. r6 �netr r r �list� s zNetworkCollection.listNc C s | j jj|d�S )N)�filters)r r �prune_networks)r r; r r r �prune� s zNetworkCollection.prune)N) r& r' r( r) r �modelr/ r r: r= r r< r r r r r+ ^ s ; r+ N) r r �utilsr r r �resourcer r r r+ r r r r �<module> s W __pycache__/resource.cpython-310.pyc 0000644 00000006133 15027745625 0013324 0 ustar 00 o �h � @ s G d d� d�Z G dd� d�ZdS )c @ sV e Zd ZdZdZddd�Zdd� Zdd � Zd d � Ze d d � �Z e dd� �Z dd� Z dS )�ModelzF A base class for representing a single object on the server. �IdNc C s* || _ || _|| _| jd u ri | _d S d S �N)�client� collection�attrs)�selfr r r � r �L/usr/local/CyberPanel/lib/python3.10/site-packages/docker/models/resource.py�__init__ s �zModel.__init__c C s d| j j� d| j� d�S )N�<z: �>)� __class__�__name__�short_id�r r r r �__repr__ � zModel.__repr__c C s t || j�o | j|jkS r )� isinstancer �id)r �otherr r r �__eq__ r z Model.__eq__c C s t | jj� d| j� ��S )N�:)�hashr r r r r r r �__hash__ r zModel.__hash__c C s | j �| j�S )z' The ID of the object. )r �get� id_attributer r r r r � zModel.idc C s | j dd� S )zC The ID of the object, truncated to 12 characters. N� )r r r r r r # r zModel.short_idc C s | j �| j�}|j| _dS )zh Load this object from the server again and update ``attrs`` with the new data. N)r r r r )r � new_modelr r r �reload* s z Model.reload)NNN) r � __module__� __qualname__�__doc__r r r r r �propertyr r r r r r r r s r c @ sH e Zd ZdZdZddd�Zdd� Zdd� Zd d � Zdd d �Z d d� Z dS )� Collectionz[ A base class for representing all objects of a particular type on the server. Nc C s || _ d S r )r )r r r r r r < s zCollection.__init__c O s t d| jj� d���)N�'zh' object is not callable. You might be trying to use the old (pre-2.0) API - use docker.APIClient if so.)� TypeErrorr r )r �args�kwargsr r r �__call__A s �zCollection.__call__c C � t �r ��NotImplementedErrorr r r r �listH � zCollection.listc C r* r r+ )r �keyr r r r K r. zCollection.getc C r* r r+ �r r r r r �createN r. zCollection.createc C sP t |t�r| j|_| |_|S t |t�r | j|| j| d�S td| jj� d|� ���)z: Create a model from a set of attributes. )r r r z Can't create z from )r r r r �dict�model� Exceptionr r0 r r r � prepare_modelQ s zCollection.prepare_modelr ) r r r! r" r3 r r) r- r r1 r5 r r r r r$ 3 s r$ N)r r$ r r r r �<module> s 2 resource.py 0000644 00000005024 15027745625 0006763 0 ustar 00 class Model: """ A base class for representing a single object on the server. """ id_attribute = 'Id' def __init__(self, attrs=None, client=None, collection=None): #: A client pointing at the server that this object is on. self.client = client #: The collection that this model is part of. self.collection = collection #: The raw representation of this object from the API self.attrs = attrs if self.attrs is None: self.attrs = {} def __repr__(self): return f"<{self.__class__.__name__}: {self.short_id}>" def __eq__(self, other): return isinstance(other, self.__class__) and self.id == other.id def __hash__(self): return hash(f"{self.__class__.__name__}:{self.id}") @property def id(self): """ The ID of the object. """ return self.attrs.get(self.id_attribute) @property def short_id(self): """ The ID of the object, truncated to 12 characters. """ return self.id[:12] def reload(self): """ Load this object from the server again and update ``attrs`` with the new data. """ new_model = self.collection.get(self.id) self.attrs = new_model.attrs class Collection: """ A base class for representing all objects of a particular type on the server. """ #: The type of object this collection represents, set by subclasses model = None def __init__(self, client=None): #: The client pointing at the server that this collection of objects #: is on. self.client = client def __call__(self, *args, **kwargs): raise TypeError( f"'{self.__class__.__name__}' object is not callable. " "You might be trying to use the old (pre-2.0) API - " "use docker.APIClient if so." ) def list(self): raise NotImplementedError def get(self, key): raise NotImplementedError def create(self, attrs=None): raise NotImplementedError def prepare_model(self, attrs): """ Create a model from a set of attributes. """ if isinstance(attrs, Model): attrs.client = self.client attrs.collection = self return attrs elif isinstance(attrs, dict): return self.model(attrs=attrs, client=self.client, collection=self) else: raise Exception(f"Can't create {self.model.__name__} from {attrs}") plugins.py 0000644 00000013523 15027745625 0006620 0 ustar 00 from .. import errors from .resource import Collection, Model class Plugin(Model): """ A plugin on the server. """ def __repr__(self): return f"<{self.__class__.__name__}: '{self.name}'>" @property def name(self): """ The plugin's name. """ return self.attrs.get('Name') @property def enabled(self): """ Whether the plugin is enabled. """ return self.attrs.get('Enabled') @property def settings(self): """ A dictionary representing the plugin's configuration. """ return self.attrs.get('Settings') def configure(self, options): """ Update the plugin's settings. Args: options (dict): A key-value mapping of options. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ self.client.api.configure_plugin(self.name, options) self.reload() def disable(self, force=False): """ Disable the plugin. Args: force (bool): Force disable. Default: False Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ self.client.api.disable_plugin(self.name, force) self.reload() def enable(self, timeout=0): """ Enable the plugin. Args: timeout (int): Timeout in seconds. Default: 0 Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ self.client.api.enable_plugin(self.name, timeout) self.reload() def push(self): """ Push the plugin to a remote registry. Returns: A dict iterator streaming the status of the upload. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.push_plugin(self.name) def remove(self, force=False): """ Remove the plugin from the server. Args: force (bool): Remove even if the plugin is enabled. Default: False Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.remove_plugin(self.name, force=force) def upgrade(self, remote=None): """ Upgrade the plugin. Args: remote (string): Remote reference to upgrade to. The ``:latest`` tag is optional and is the default if omitted. Default: this plugin's name. Returns: A generator streaming the decoded API logs """ if self.enabled: raise errors.DockerError( 'Plugin must be disabled before upgrading.' ) if remote is None: remote = self.name privileges = self.client.api.plugin_privileges(remote) yield from self.client.api.upgrade_plugin( self.name, remote, privileges, ) self.reload() class PluginCollection(Collection): model = Plugin def create(self, name, plugin_data_dir, gzip=False): """ Create a new plugin. Args: name (string): The name of the plugin. The ``:latest`` tag is optional, and is the default if omitted. plugin_data_dir (string): Path to the plugin data directory. Plugin data directory must contain the ``config.json`` manifest file and the ``rootfs`` directory. gzip (bool): Compress the context using gzip. Default: False Returns: (:py:class:`Plugin`): The newly created plugin. """ self.client.api.create_plugin(name, plugin_data_dir, gzip) return self.get(name) def get(self, name): """ Gets a plugin. Args: name (str): The name of the plugin. Returns: (:py:class:`Plugin`): The plugin. Raises: :py:class:`docker.errors.NotFound` If the plugin does not exist. :py:class:`docker.errors.APIError` If the server returns an error. """ return self.prepare_model(self.client.api.inspect_plugin(name)) def install(self, remote_name, local_name=None): """ Pull and install a plugin. Args: remote_name (string): Remote reference for the plugin to install. The ``:latest`` tag is optional, and is the default if omitted. local_name (string): Local name for the pulled plugin. The ``:latest`` tag is optional, and is the default if omitted. Optional. Returns: (:py:class:`Plugin`): The installed plugin Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ privileges = self.client.api.plugin_privileges(remote_name) it = self.client.api.pull_plugin(remote_name, privileges, local_name) for _data in it: pass return self.get(local_name or remote_name) def list(self): """ List plugins installed on the server. Returns: (list of :py:class:`Plugin`): The plugins. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ resp = self.client.api.plugins() return [self.prepare_model(r) for r in resp] images.py 0000644 00000043120 15027745625 0006400 0 ustar 00 import itertools import re import warnings from ..api import APIClient from ..constants import DEFAULT_DATA_CHUNK_SIZE from ..errors import BuildError, ImageLoadError, InvalidArgument from ..utils import parse_repository_tag from ..utils.json_stream import json_stream from .resource import Collection, Model class Image(Model): """ An image on the server. """ def __repr__(self): tag_str = "', '".join(self.tags) return f"<{self.__class__.__name__}: '{tag_str}'>" @property def labels(self): """ The labels of an image as dictionary. """ result = self.attrs['Config'].get('Labels') return result or {} @property def short_id(self): """ The ID of the image truncated to 12 characters, plus the ``sha256:`` prefix. """ if self.id.startswith('sha256:'): return self.id[:19] return self.id[:12] @property def tags(self): """ The image's tags. """ tags = self.attrs.get('RepoTags') if tags is None: tags = [] return [tag for tag in tags if tag != '<none>:<none>'] def history(self): """ Show the history of an image. Returns: (list): The history of the image. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.history(self.id) def remove(self, force=False, noprune=False): """ Remove this image. Args: force (bool): Force removal of the image noprune (bool): Do not delete untagged parents Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.remove_image( self.id, force=force, noprune=noprune, ) def save(self, chunk_size=DEFAULT_DATA_CHUNK_SIZE, named=False): """ Get a tarball of an image. Similar to the ``docker save`` command. Args: chunk_size (int): The generator will return up to that much data per iteration, but may return less. If ``None``, data will be streamed as it is received. Default: 2 MB named (str or bool): If ``False`` (default), the tarball will not retain repository and tag information for this image. If set to ``True``, the first tag in the :py:attr:`~tags` list will be used to identify the image. Alternatively, any element of the :py:attr:`~tags` list can be used as an argument to use that specific tag as the saved identifier. Returns: (generator): A stream of raw archive data. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> image = cli.images.get("busybox:latest") >>> f = open('/tmp/busybox-latest.tar', 'wb') >>> for chunk in image.save(): >>> f.write(chunk) >>> f.close() """ img = self.id if named: img = self.tags[0] if self.tags else img if isinstance(named, str): if named not in self.tags: raise InvalidArgument( f"{named} is not a valid tag for this image" ) img = named return self.client.api.get_image(img, chunk_size) def tag(self, repository, tag=None, **kwargs): """ Tag this image into a repository. Similar to the ``docker tag`` command. Args: repository (str): The repository to set for the tag tag (str): The tag name force (bool): Force Raises: :py:class:`docker.errors.APIError` If the server returns an error. Returns: (bool): ``True`` if successful """ return self.client.api.tag(self.id, repository, tag=tag, **kwargs) class RegistryData(Model): """ Image metadata stored on the registry, including available platforms. """ def __init__(self, image_name, *args, **kwargs): super().__init__(*args, **kwargs) self.image_name = image_name @property def id(self): """ The ID of the object. """ return self.attrs['Descriptor']['digest'] @property def short_id(self): """ The ID of the image truncated to 12 characters, plus the ``sha256:`` prefix. """ return self.id[:19] def pull(self, platform=None): """ Pull the image digest. Args: platform (str): The platform to pull the image for. Default: ``None`` Returns: (:py:class:`Image`): A reference to the pulled image. """ repository, _ = parse_repository_tag(self.image_name) return self.collection.pull(repository, tag=self.id, platform=platform) def has_platform(self, platform): """ Check whether the given platform identifier is available for this digest. Args: platform (str or dict): A string using the ``os[/arch[/variant]]`` format, or a platform dictionary. Returns: (bool): ``True`` if the platform is recognized as available, ``False`` otherwise. Raises: :py:class:`docker.errors.InvalidArgument` If the platform argument is not a valid descriptor. """ if platform and not isinstance(platform, dict): parts = platform.split('/') if len(parts) > 3 or len(parts) < 1: raise InvalidArgument( f'"{platform}" is not a valid platform descriptor' ) platform = {'os': parts[0]} if len(parts) > 2: platform['variant'] = parts[2] if len(parts) > 1: platform['architecture'] = parts[1] return normalize_platform( platform, self.client.version() ) in self.attrs['Platforms'] def reload(self): self.attrs = self.client.api.inspect_distribution(self.image_name) reload.__doc__ = Model.reload.__doc__ class ImageCollection(Collection): model = Image def build(self, **kwargs): """ Build an image and return it. Similar to the ``docker build`` command. Either ``path`` or ``fileobj`` must be set. If you already have a tar file for the Docker build context (including a Dockerfile), pass a readable file-like object to ``fileobj`` and also pass ``custom_context=True``. If the stream is also compressed, set ``encoding`` to the correct value (e.g ``gzip``). If you want to get the raw output of the build, use the :py:meth:`~docker.api.build.BuildApiMixin.build` method in the low-level API. Args: path (str): Path to the directory containing the Dockerfile fileobj: A file object to use as the Dockerfile. (Or a file-like object) tag (str): A tag to add to the final image quiet (bool): Whether to return the status nocache (bool): Don't use the cache when set to ``True`` rm (bool): Remove intermediate containers. The ``docker build`` command now defaults to ``--rm=true``, but we have kept the old default of `False` to preserve backward compatibility timeout (int): HTTP timeout custom_context (bool): Optional if using ``fileobj`` encoding (str): The encoding for a stream. Set to ``gzip`` for compressing pull (bool): Downloads any updates to the FROM image in Dockerfiles forcerm (bool): Always remove intermediate containers, even after unsuccessful builds dockerfile (str): path within the build context to the Dockerfile buildargs (dict): A dictionary of build arguments container_limits (dict): A dictionary of limits applied to each container created by the build process. Valid keys: - memory (int): set memory limit for build - memswap (int): Total memory (memory + swap), -1 to disable swap - cpushares (int): CPU shares (relative weight) - cpusetcpus (str): CPUs in which to allow execution, e.g., ``"0-3"``, ``"0,1"`` shmsize (int): Size of `/dev/shm` in bytes. The size must be greater than 0. If omitted the system uses 64MB labels (dict): A dictionary of labels to set on the image cache_from (list): A list of images used for build cache resolution target (str): Name of the build-stage to build in a multi-stage Dockerfile network_mode (str): networking mode for the run commands during build squash (bool): Squash the resulting images layers into a single layer. extra_hosts (dict): Extra hosts to add to /etc/hosts in building containers, as a mapping of hostname to IP address. platform (str): Platform in the format ``os[/arch[/variant]]``. isolation (str): Isolation technology used during build. Default: `None`. use_config_proxy (bool): If ``True``, and if the docker client configuration file (``~/.docker/config.json`` by default) contains a proxy configuration, the corresponding environment variables will be set in the container being built. Returns: (tuple): The first item is the :py:class:`Image` object for the image that was built. The second item is a generator of the build logs as JSON-decoded objects. Raises: :py:class:`docker.errors.BuildError` If there is an error during the build. :py:class:`docker.errors.APIError` If the server returns any other error. ``TypeError`` If neither ``path`` nor ``fileobj`` is specified. """ resp = self.client.api.build(**kwargs) if isinstance(resp, str): return self.get(resp) last_event = None image_id = None result_stream, internal_stream = itertools.tee(json_stream(resp)) for chunk in internal_stream: if 'error' in chunk: raise BuildError(chunk['error'], result_stream) if 'stream' in chunk: match = re.search( r'(^Successfully built |sha256:)([0-9a-f]+)$', chunk['stream'] ) if match: image_id = match.group(2) last_event = chunk if image_id: return (self.get(image_id), result_stream) raise BuildError(last_event or 'Unknown', result_stream) def get(self, name): """ Gets an image. Args: name (str): The name of the image. Returns: (:py:class:`Image`): The image. Raises: :py:class:`docker.errors.ImageNotFound` If the image does not exist. :py:class:`docker.errors.APIError` If the server returns an error. """ return self.prepare_model(self.client.api.inspect_image(name)) def get_registry_data(self, name, auth_config=None): """ Gets the registry data for an image. Args: name (str): The name of the image. auth_config (dict): Override the credentials that are found in the config for this request. ``auth_config`` should contain the ``username`` and ``password`` keys to be valid. Returns: (:py:class:`RegistryData`): The data object. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return RegistryData( image_name=name, attrs=self.client.api.inspect_distribution(name, auth_config), client=self.client, collection=self, ) def list(self, name=None, all=False, filters=None): """ List images on the server. Args: name (str): Only show images belonging to the repository ``name`` all (bool): Show intermediate image layers. By default, these are filtered out. filters (dict): Filters to be processed on the image list. Available filters: - ``dangling`` (bool) - `label` (str|list): format either ``"key"``, ``"key=value"`` or a list of such. Returns: (list of :py:class:`Image`): The images. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ resp = self.client.api.images(name=name, all=all, filters=filters) return [self.get(r["Id"]) for r in resp] def load(self, data): """ Load an image that was previously saved using :py:meth:`~docker.models.images.Image.save` (or ``docker save``). Similar to ``docker load``. Args: data (binary): Image data to be loaded. Returns: (list of :py:class:`Image`): The images. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ resp = self.client.api.load_image(data) images = [] for chunk in resp: if 'stream' in chunk: match = re.search( r'(^Loaded image ID: |^Loaded image: )(.+)$', chunk['stream'] ) if match: image_id = match.group(2) images.append(image_id) if 'error' in chunk: raise ImageLoadError(chunk['error']) return [self.get(i) for i in images] def pull(self, repository, tag=None, all_tags=False, **kwargs): """ Pull an image of the given name and return it. Similar to the ``docker pull`` command. If ``tag`` is ``None`` or empty, it is set to ``latest``. If ``all_tags`` is set, the ``tag`` parameter is ignored and all image tags will be pulled. If you want to get the raw pull output, use the :py:meth:`~docker.api.image.ImageApiMixin.pull` method in the low-level API. Args: repository (str): The repository to pull tag (str): The tag to pull auth_config (dict): Override the credentials that are found in the config for this request. ``auth_config`` should contain the ``username`` and ``password`` keys to be valid. platform (str): Platform in the format ``os[/arch[/variant]]`` all_tags (bool): Pull all image tags Returns: (:py:class:`Image` or list): The image that has been pulled. If ``all_tags`` is True, the method will return a list of :py:class:`Image` objects belonging to this repository. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> # Pull the image tagged `latest` in the busybox repo >>> image = client.images.pull('busybox') >>> # Pull all tags in the busybox repo >>> images = client.images.pull('busybox', all_tags=True) """ repository, image_tag = parse_repository_tag(repository) tag = tag or image_tag or 'latest' if 'stream' in kwargs: warnings.warn( '`stream` is not a valid parameter for this method' ' and will be overridden', stacklevel=1, ) del kwargs['stream'] pull_log = self.client.api.pull( repository, tag=tag, stream=True, all_tags=all_tags, **kwargs ) for _ in pull_log: # We don't do anything with the logs, but we need # to keep the connection alive and wait for the image # to be pulled. pass if not all_tags: sep = '@' if tag.startswith('sha256:') else ':' return self.get(f'{repository}{sep}{tag}') return self.list(repository) def push(self, repository, tag=None, **kwargs): return self.client.api.push(repository, tag=tag, **kwargs) push.__doc__ = APIClient.push.__doc__ def remove(self, *args, **kwargs): self.client.api.remove_image(*args, **kwargs) remove.__doc__ = APIClient.remove_image.__doc__ def search(self, *args, **kwargs): return self.client.api.search(*args, **kwargs) search.__doc__ = APIClient.search.__doc__ def prune(self, filters=None): return self.client.api.prune_images(filters=filters) prune.__doc__ = APIClient.prune_images.__doc__ def prune_builds(self, *args, **kwargs): return self.client.api.prune_builds(*args, **kwargs) prune_builds.__doc__ = APIClient.prune_builds.__doc__ def normalize_platform(platform, engine_info): if platform is None: platform = {} if 'os' not in platform: platform['os'] = engine_info['Os'] if 'architecture' not in platform: platform['architecture'] = engine_info['Arch'] return platform containers.py 0000644 00000133217 15027745625 0007307 0 ustar 00 import copy import ntpath from collections import namedtuple from ..api import APIClient from ..constants import DEFAULT_DATA_CHUNK_SIZE from ..errors import ( ContainerError, DockerException, ImageNotFound, NotFound, create_unexpected_kwargs_error, ) from ..types import HostConfig, NetworkingConfig from ..utils import version_gte from .images import Image from .resource import Collection, Model class Container(Model): """ Local representation of a container object. Detailed configuration may be accessed through the :py:attr:`attrs` attribute. Note that local attributes are cached; users may call :py:meth:`reload` to query the Docker daemon for the current properties, causing :py:attr:`attrs` to be refreshed. """ @property def name(self): """ The name of the container. """ if self.attrs.get('Name') is not None: return self.attrs['Name'].lstrip('/') @property def image(self): """ The image of the container. """ image_id = self.attrs.get('ImageID', self.attrs['Image']) if image_id is None: return None return self.client.images.get(image_id.split(':')[1]) @property def labels(self): """ The labels of a container as dictionary. """ try: result = self.attrs['Config'].get('Labels') return result or {} except KeyError as ke: raise DockerException( 'Label data is not available for sparse objects. Call reload()' ' to retrieve all information' ) from ke @property def status(self): """ The status of the container. For example, ``running``, or ``exited``. """ if isinstance(self.attrs['State'], dict): return self.attrs['State']['Status'] return self.attrs['State'] @property def health(self): """ The healthcheck status of the container. For example, ``healthy`, or ``unhealthy`. """ return self.attrs.get('State', {}).get('Health', {}).get('Status', 'unknown') @property def ports(self): """ The ports that the container exposes as a dictionary. """ return self.attrs.get('NetworkSettings', {}).get('Ports', {}) def attach(self, **kwargs): """ Attach to this container. :py:meth:`logs` 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: 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. Returns: By default, the container's output as a single string. If ``stream=True``, an iterator of output strings. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.attach(self.id, **kwargs) def attach_socket(self, **kwargs): """ Like :py:meth:`attach`, but returns the underlying socket-like object for the HTTP request. Args: params (dict): Dictionary of request parameters (e.g. ``stdout``, ``stderr``, ``stream``). ws (bool): Use websockets instead of raw HTTP. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.attach_socket(self.id, **kwargs) def commit(self, repository=None, tag=None, **kwargs): """ Commit a container to an image. Similar to the ``docker commit`` command. Args: 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 pause (bool): Whether to pause the container before committing 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. """ resp = self.client.api.commit(self.id, repository=repository, tag=tag, **kwargs) return self.client.images.get(resp['Id']) def diff(self): """ Inspect changes on a container's filesystem. Returns: (list) A list of dictionaries containing the attributes `Path` and `Kind`. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.diff(self.id) def exec_run(self, cmd, stdout=True, stderr=True, stdin=False, tty=False, privileged=False, user='', detach=False, stream=False, socket=False, environment=None, workdir=None, demux=False): """ Run a command inside this container. Similar to ``docker exec``. Args: cmd (str or list): Command to be executed stdout (bool): Attach to stdout. Default: ``True`` stderr (bool): Attach to stderr. Default: ``True`` stdin (bool): Attach to stdin. Default: ``False`` tty (bool): Allocate a pseudo-TTY. Default: False privileged (bool): Run as privileged. user (str): User to execute command as. Default: root detach (bool): If true, detach from the exec command. Default: False stream (bool): Stream response data. Default: False socket (bool): Return the connection socket to allow custom read/write operations. Default: False environment (dict or list): A dictionary or a list of strings in the following format ``["PASSWORD=xxx"]`` or ``{"PASSWORD": "xxx"}``. workdir (str): Path to working directory for this exec session demux (bool): Return stdout and stderr separately Returns: (ExecResult): A tuple of (exit_code, output) exit_code: (int): Exit code for the executed command or ``None`` if either ``stream`` or ``socket`` is ``True``. output: (generator, bytes, or tuple): If ``stream=True``, a generator yielding response chunks. If ``socket=True``, a socket object for the connection. If ``demux=True``, a tuple of two bytes: stdout and stderr. A bytestring containing response data otherwise. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ resp = self.client.api.exec_create( self.id, cmd, stdout=stdout, stderr=stderr, stdin=stdin, tty=tty, privileged=privileged, user=user, environment=environment, workdir=workdir, ) exec_output = self.client.api.exec_start( resp['Id'], detach=detach, tty=tty, stream=stream, socket=socket, demux=demux ) if socket or stream: return ExecResult(None, exec_output) return ExecResult( self.client.api.exec_inspect(resp['Id'])['ExitCode'], exec_output ) def export(self, chunk_size=DEFAULT_DATA_CHUNK_SIZE): """ Export the contents of the container's filesystem as a tar archive. Args: chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB Returns: (str): The filesystem tar archive Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.export(self.id, chunk_size) def get_archive(self, path, chunk_size=DEFAULT_DATA_CHUNK_SIZE, encode_stream=False): """ Retrieve a file or folder from the container in the form of a tar archive. Args: path (str): Path to the file or folder to retrieve chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB encode_stream (bool): Determines if data should be encoded (gzip-compressed) during transmission. Default: False Returns: (tuple): First element is a raw tar data stream. Second element is a dict containing ``stat`` information on the specified ``path``. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> f = open('./sh_bin.tar', 'wb') >>> bits, stat = container.get_archive('/bin/sh') >>> print(stat) {'name': 'sh', 'size': 1075464, 'mode': 493, 'mtime': '2018-10-01T15:37:48-07:00', 'linkTarget': ''} >>> for chunk in bits: ... f.write(chunk) >>> f.close() """ return self.client.api.get_archive(self.id, path, chunk_size, encode_stream) def kill(self, signal=None): """ Kill or send a signal to the container. Args: signal (str or int): The signal to send. Defaults to ``SIGKILL`` Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.kill(self.id, signal=signal) def logs(self, **kwargs): """ Get logs from this container. Similar to the ``docker logs`` command. The ``stream`` parameter makes the ``logs`` function return a blocking generator you can iterate over to retrieve log output as it happens. Args: stdout (bool): Get ``STDOUT``. Default ``True`` stderr (bool): Get ``STDERR``. Default ``True`` stream (bool): Stream the response. Default ``False`` timestamps (bool): Show timestamps. Default ``False`` tail (str or int): Output specified number of lines at the end of logs. Either an integer of number of lines or the string ``all``. Default ``all`` since (datetime, int, or float): Show logs since a given datetime, integer epoch (in seconds) or float (in nanoseconds) follow (bool): Follow log output. Default ``False`` until (datetime, int, or float): Show logs that occurred before the given datetime, integer epoch (in seconds), or float (in nanoseconds) Returns: (generator of bytes or bytes): Logs from the container. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.logs(self.id, **kwargs) def pause(self): """ Pauses all processes within this container. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.pause(self.id) def put_archive(self, path, data): """ Insert a file or folder in this container using a tar archive as source. Args: path (str): Path inside the container where the file(s) will be extracted. Must exist. data (bytes or stream): tar data to be extracted Returns: (bool): True if the call succeeds. Raises: :py:class:`~docker.errors.APIError` If an error occurs. """ return self.client.api.put_archive(self.id, path, data) def remove(self, **kwargs): """ Remove this container. Similar to the ``docker rm`` command. Args: v (bool): Remove the volumes associated with the container link (bool): Remove the specified link and not the underlying container force (bool): Force the removal of a running container (uses ``SIGKILL``) Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.remove_container(self.id, **kwargs) def rename(self, name): """ Rename this container. Similar to the ``docker rename`` command. Args: name (str): New name for the container Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.rename(self.id, name) def resize(self, height, width): """ Resize the tty session. Args: height (int): Height of tty session width (int): Width of tty session Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.resize(self.id, height, width) def restart(self, **kwargs): """ Restart this container. Similar to the ``docker restart`` command. Args: timeout (int): Number of seconds to try to stop for before killing the container. Once killed it will then be restarted. Default is 10 seconds. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.restart(self.id, **kwargs) def start(self, **kwargs): """ Start this container. Similar to the ``docker start`` command, but doesn't support attach options. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.start(self.id, **kwargs) def stats(self, **kwargs): """ Stream statistics for this container. Similar to the ``docker stats`` command. Args: decode (bool): If set to true, stream will be decoded into dicts on the fly. Only applicable if ``stream`` is True. False by default. stream (bool): If set to false, only the current stats will be returned instead of a stream. True by default. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.stats(self.id, **kwargs) def stop(self, **kwargs): """ Stops a container. Similar to the ``docker stop`` command. Args: timeout (int): Timeout in seconds to wait for the container to stop before sending a ``SIGKILL``. Default: 10 Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.stop(self.id, **kwargs) def top(self, **kwargs): """ Display the running processes of the container. Args: ps_args (str): An optional arguments passed to ps (e.g. ``aux``) Returns: (str): The output of the top Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.top(self.id, **kwargs) def unpause(self): """ Unpause all processes within the container. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.unpause(self.id) def update(self, **kwargs): """ Update resource configuration of the containers. Args: blkio_weight (int): Block IO (relative weight), between 10 and 1000 cpu_period (int): Limit CPU CFS (Completely Fair Scheduler) period cpu_quota (int): Limit CPU CFS (Completely Fair Scheduler) quota cpu_shares (int): CPU shares (relative weight) cpuset_cpus (str): CPUs in which to allow execution cpuset_mems (str): MEMs in which to allow execution mem_limit (int or str): Memory limit mem_reservation (int or str): Memory soft limit memswap_limit (int or str): Total memory (memory + swap), -1 to disable swap kernel_memory (int or str): Kernel memory limit restart_policy (dict): Restart policy dictionary Returns: (dict): Dictionary containing a ``Warnings`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.update_container(self.id, **kwargs) def wait(self, **kwargs): """ Block until the container stops, then return its exit code. Similar to the ``docker wait`` command. Args: timeout (int): Request timeout condition (str): Wait until a container state reaches the given condition, either ``not-running`` (default), ``next-exit``, or ``removed`` Returns: (dict): The API's response as a Python dictionary, including the container's exit code under the ``StatusCode`` attribute. Raises: :py:class:`requests.exceptions.ReadTimeout` If the timeout is exceeded. :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.wait(self.id, **kwargs) class ContainerCollection(Collection): model = Container def run(self, image, command=None, stdout=True, stderr=False, remove=False, **kwargs): """ Run a container. By default, it will wait for the container to finish and return its logs, similar to ``docker run``. If the ``detach`` argument is ``True``, it will start the container and immediately return a :py:class:`Container` object, similar to ``docker run -d``. Example: Run a container and get its output: >>> import docker >>> client = docker.from_env() >>> client.containers.run('alpine', 'echo hello world') b'hello world\\n' Run a container and detach: >>> container = client.containers.run('bfirsh/reticulate-splines', detach=True) >>> container.logs() 'Reticulating spline 1...\\nReticulating spline 2...\\n' Args: image (str): The image to run. command (str or list): The command to run in the container. auto_remove (bool): enable auto-removal of the container on daemon side when the container's process exits. blkio_weight_device: Block IO weight (relative device weight) in the form of: ``[{"Path": "device_path", "Weight": weight}]``. blkio_weight: Block IO weight (relative weight), accepts a weight value between 10 and 1000. cap_add (list of str): Add kernel capabilities. For example, ``["SYS_ADMIN", "MKNOD"]``. cap_drop (list of str): Drop kernel capabilities. cgroup_parent (str): Override the default parent cgroup. cgroupns (str): Override the default cgroup namespace mode for the container. One of: - ``private`` the container runs in its own private cgroup namespace. - ``host`` use the host system's cgroup namespace. cpu_count (int): Number of usable CPUs (Windows only). cpu_percent (int): Usable percentage of the available CPUs (Windows only). cpu_period (int): The length of a CPU period in microseconds. cpu_quota (int): Microseconds of CPU time that the container can get in a CPU period. cpu_rt_period (int): Limit CPU real-time period in microseconds. cpu_rt_runtime (int): Limit CPU real-time runtime in microseconds. cpu_shares (int): CPU shares (relative weight). cpuset_cpus (str): CPUs in which to allow execution (``0-3``, ``0,1``). cpuset_mems (str): Memory nodes (MEMs) in which to allow execution (``0-3``, ``0,1``). Only effective on NUMA systems. detach (bool): Run container in the background and return a :py:class:`Container` object. device_cgroup_rules (:py:class:`list`): A list of cgroup rules to apply to the container. device_read_bps: Limit read rate (bytes per second) from a device in the form of: `[{"Path": "device_path", "Rate": rate}]` device_read_iops: Limit read rate (IO per second) from a device. device_write_bps: Limit write rate (bytes per second) from a device. device_write_iops: Limit write rate (IO per second) from a device. devices (:py:class:`list`): Expose host devices to the container, as a list of strings in the form ``<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. domainname (str or list): Set custom DNS search domains. entrypoint (str or list): The entrypoint for the container. environment (dict or list): Environment variables to set inside the container, as a dictionary or a list of strings in the format ``["SOMEVARIABLE=xxx"]``. extra_hosts (dict): Additional hostnames to resolve inside the container, as a mapping of hostname to IP address. group_add (:py:class:`list`): List of additional group names and/or IDs that the container process will run as. healthcheck (dict): Specify a test to perform to check that the container is healthy. The dict takes the following keys: - test (:py:class:`list` or str): Test to perform to determine container health. Possible values: - Empty list: Inherit healthcheck from parent image - ``["NONE"]``: Disable healthcheck - ``["CMD", args...]``: exec arguments directly. - ``["CMD-SHELL", command]``: Run command in the system's default shell. If a string is provided, it will be used as a ``CMD-SHELL`` command. - interval (int): The time to wait between checks in nanoseconds. It should be 0 or at least 1000000 (1 ms). - timeout (int): The time to wait before considering the check to have hung. It should be 0 or at least 1000000 (1 ms). - retries (int): The number of consecutive failures needed to consider a container as unhealthy. - start_period (int): Start period for the container to initialize before starting health-retries countdown in nanoseconds. It should be 0 or at least 1000000 (1 ms). hostname (str): Optional hostname for the container. init (bool): Run an init inside the container that forwards signals and reaps processes init_path (str): Path to the docker-init binary ipc_mode (str): Set the IPC mode for the container. isolation (str): Isolation technology to use. Default: `None`. kernel_memory (int or str): Kernel memory limit labels (dict or list): A dictionary of name-value labels (e.g. ``{"label1": "value1", "label2": "value2"}``) or a list of names of labels to set with empty values (e.g. ``["label1", "label2"]``) links (dict): Mapping of links using the ``{'container': 'alias'}`` format. The alias is optional. Containers declared in this dict will be linked to the new container using the provided alias. Default: ``None``. log_config (LogConfig): Logging configuration. lxc_conf (dict): LXC config. mac_address (str): MAC address to assign to the container. mem_limit (int or str): Memory limit. Accepts float values (which represent the memory limit of the created container in bytes) or a string with a units identification char (``100000b``, ``1000k``, ``128m``, ``1g``). If a string is specified without a units character, bytes are assumed as an intended unit. mem_reservation (int or str): Memory soft limit. mem_swappiness (int): Tune a container's memory swappiness behavior. Accepts number between 0 and 100. memswap_limit (str or int): Maximum amount of memory + swap a container is allowed to consume. mounts (:py:class:`list`): Specification for mounts to be added to the container. More powerful alternative to ``volumes``. Each item in the list is expected to be a :py:class:`docker.types.Mount` object. name (str): The name for this container. nano_cpus (int): CPU quota in units of 1e-9 CPUs. network (str): Name of the network this container will be connected to at creation time. You can connect to additional networks using :py:meth:`Network.connect`. Incompatible with ``network_mode``. network_disabled (bool): Disable networking. network_mode (str): One of: - ``bridge`` Create a new network stack for the container on the bridge network. - ``none`` No networking for this container. - ``container:<name|id>`` Reuse another container's network stack. - ``host`` Use the host network stack. This mode is incompatible with ``ports``. Incompatible with ``network``. networking_config (Dict[str, EndpointConfig]): Dictionary of EndpointConfig objects for each container network. The key is the name of the network. Defaults to ``None``. Used in conjuction with ``network``. Incompatible with ``network_mode``. oom_kill_disable (bool): Whether to disable OOM killer. oom_score_adj (int): An integer value containing the score given to the container in order to tune OOM killer preferences. pid_mode (str): If set to ``host``, use the host PID namespace inside the container. pids_limit (int): Tune a container's pids limit. Set ``-1`` for unlimited. platform (str): Platform in the format ``os[/arch[/variant]]``. Only used if the method needs to pull the requested image. ports (dict): Ports to bind inside the container. The keys of the dictionary are the ports to bind inside the container, either as an integer or a string in the form ``port/protocol``, where the protocol is either ``tcp``, ``udp``, or ``sctp``. The values of the dictionary are the corresponding ports to open on the host, which can be either: - The port number, as an integer. For example, ``{'2222/tcp': 3333}`` will expose port 2222 inside the container as port 3333 on the host. - ``None``, to assign a random host port. For example, ``{'2222/tcp': None}``. - A tuple of ``(address, port)`` if you want to specify the host interface. For example, ``{'1111/tcp': ('127.0.0.1', 1111)}``. - A list of integers, if you want to bind multiple host ports to a single container port. For example, ``{'1111/tcp': [1234, 4567]}``. Incompatible with ``host`` network mode. privileged (bool): Give extended privileges to this container. publish_all_ports (bool): Publish all ports to the host. read_only (bool): Mount the container's root filesystem as read only. remove (bool): Remove the container when it has finished running. Default: ``False``. restart_policy (dict): Restart the container when it exits. Configured as a dictionary with keys: - ``Name`` One of ``on-failure``, or ``always``. - ``MaximumRetryCount`` Number of times to restart the container on failure. For example: ``{"Name": "on-failure", "MaximumRetryCount": 5}`` runtime (str): Runtime to use with this container. security_opt (:py:class:`list`): A list of string values to customize labels for MLS systems, such as SELinux. shm_size (str or int): Size of /dev/shm (e.g. ``1G``). stdin_open (bool): Keep ``STDIN`` open even if not attached. stdout (bool): Return logs from ``STDOUT`` when ``detach=False``. Default: ``True``. stderr (bool): Return logs from ``STDERR`` when ``detach=False``. Default: ``False``. stop_signal (str): The stop signal to use to stop the container (e.g. ``SIGINT``). storage_opt (dict): Storage driver options per container as a key-value mapping. stream (bool): If true and ``detach`` is false, return a log generator instead of a string. Ignored if ``detach`` is true. Default: ``False``. sysctls (dict): Kernel parameters to set in the container. tmpfs (dict): Temporary filesystems to mount, as a dictionary mapping a path inside the container to options for that path. For example: .. code-block:: python { '/mnt/vol2': '', '/mnt/vol1': 'size=3G,uid=1000' } tty (bool): Allocate a pseudo-TTY. ulimits (:py:class:`list`): Ulimits to set inside the container, as a list of :py:class:`docker.types.Ulimit` instances. use_config_proxy (bool): If ``True``, and if the docker client configuration file (``~/.docker/config.json`` by default) contains a proxy configuration, the corresponding environment variables will be set in the container being built. user (str or int): Username or UID to run commands as inside the container. userns_mode (str): Sets the user namespace mode for the container when user namespace remapping option is enabled. Supported values are: ``host`` uts_mode (str): Sets the UTS namespace mode for the container. Supported values are: ``host`` version (str): The version of the API to use. Set to ``auto`` to automatically detect the server's version. Default: ``1.35`` volume_driver (str): The name of a volume driver/plugin. volumes (dict or list): A dictionary to configure volumes mounted inside the container. The key is either the host path or a volume name, and the value is a dictionary with the keys: - ``bind`` The path to mount the volume inside the container - ``mode`` Either ``rw`` to mount the volume read/write, or ``ro`` to mount it read-only. For example: .. code-block:: python {'/home/user1/': {'bind': '/mnt/vol2', 'mode': 'rw'}, '/var/www': {'bind': '/mnt/vol1', 'mode': 'ro'}} Or a list of strings which each one of its elements specifies a mount volume. For example: .. code-block:: python ['/home/user1/:/mnt/vol2','/var/www:/mnt/vol1'] volumes_from (:py:class:`list`): List of container names or IDs to get volumes from. working_dir (str): Path to the working directory. Returns: The container logs, either ``STDOUT``, ``STDERR``, or both, depending on the value of the ``stdout`` and ``stderr`` arguments. ``STDOUT`` and ``STDERR`` may be read only if either ``json-file`` or ``journald`` logging driver used. Thus, if you are using none of these drivers, a ``None`` object is returned instead. See the `Engine API documentation <https://docs.docker.com/engine/api/v1.30/#operation/ContainerLogs/>`_ for full details. If ``detach`` is ``True``, a :py:class:`Container` object is returned instead. Raises: :py:class:`docker.errors.ContainerError` If the container exits with a non-zero exit code and ``detach`` is ``False``. :py:class:`docker.errors.ImageNotFound` If the specified image does not exist. :py:class:`docker.errors.APIError` If the server returns an error. """ if isinstance(image, Image): image = image.id stream = kwargs.pop('stream', False) detach = kwargs.pop('detach', False) platform = kwargs.get('platform', None) if detach and remove: if version_gte(self.client.api._version, '1.25'): kwargs["auto_remove"] = True else: raise RuntimeError("The options 'detach' and 'remove' cannot " "be used together in api versions < 1.25.") if kwargs.get('network') and kwargs.get('network_mode'): raise RuntimeError( 'The options "network" and "network_mode" can not be used ' 'together.' ) if kwargs.get('networking_config') and not kwargs.get('network'): raise RuntimeError( 'The option "networking_config" can not be used ' 'without "network".' ) try: container = self.create(image=image, command=command, detach=detach, **kwargs) except ImageNotFound: self.client.images.pull(image, platform=platform) container = self.create(image=image, command=command, detach=detach, **kwargs) container.start() if detach: return container logging_driver = container.attrs['HostConfig']['LogConfig']['Type'] out = None if logging_driver == 'json-file' or logging_driver == 'journald': out = container.logs( stdout=stdout, stderr=stderr, stream=True, follow=True ) exit_status = container.wait()['StatusCode'] if exit_status != 0: out = None if not kwargs.get('auto_remove'): out = container.logs(stdout=False, stderr=True) if remove: container.remove() if exit_status != 0: raise ContainerError( container, exit_status, command, image, out ) if stream or out is None: return out return b''.join(out) def create(self, image, command=None, **kwargs): """ Create a container without starting it. Similar to ``docker create``. Takes the same arguments as :py:meth:`run`, except for ``stdout``, ``stderr``, and ``remove``. Returns: A :py:class:`Container` object. Raises: :py:class:`docker.errors.ImageNotFound` If the specified image does not exist. :py:class:`docker.errors.APIError` If the server returns an error. """ if isinstance(image, Image): image = image.id kwargs['image'] = image kwargs['command'] = command kwargs['version'] = self.client.api._version create_kwargs = _create_container_args(kwargs) resp = self.client.api.create_container(**create_kwargs) return self.get(resp['Id']) def get(self, container_id): """ Get a container by name or ID. Args: container_id (str): Container name or ID. Returns: A :py:class:`Container` object. Raises: :py:class:`docker.errors.NotFound` If the container does not exist. :py:class:`docker.errors.APIError` If the server returns an error. """ resp = self.client.api.inspect_container(container_id) return self.prepare_model(resp) def list(self, all=False, before=None, filters=None, limit=-1, since=None, sparse=False, ignore_removed=False): """ List containers. Similar to the ``docker ps`` command. Args: all (bool): Show all containers. Only running containers are shown by default since (str): Show only containers created since Id or Name, include non-running ones before (str): Show only container created before Id or Name, include non-running ones limit (int): Show `limit` last created containers, include non-running ones filters (dict): Filters to be processed on the image list. Available filters: - `exited` (int): Only containers with specified exit code - `status` (str): One of ``restarting``, ``running``, ``paused``, ``exited`` - `label` (str|list): format either ``"key"``, ``"key=value"`` or a list of such. - `id` (str): The id of the container. - `name` (str): The name of the container. - `ancestor` (str): Filter by container ancestor. Format of ``<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>`_. sparse (bool): Do not inspect containers. Returns partial information, but guaranteed not to block. Use :py:meth:`Container.reload` on resulting objects to retrieve all attributes. Default: ``False`` ignore_removed (bool): Ignore failures due to missing containers when attempting to inspect containers from the original list. Set to ``True`` if race conditions are likely. Has no effect if ``sparse=True``. Default: ``False`` Returns: (list of :py:class:`Container`) Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ resp = self.client.api.containers(all=all, before=before, filters=filters, limit=limit, since=since) if sparse: return [self.prepare_model(r) for r in resp] else: containers = [] for r in resp: try: containers.append(self.get(r['Id'])) # a container may have been removed while iterating except NotFound: if not ignore_removed: raise return containers def prune(self, filters=None): return self.client.api.prune_containers(filters=filters) prune.__doc__ = APIClient.prune_containers.__doc__ # kwargs to copy straight from run to create RUN_CREATE_KWARGS = [ 'command', 'detach', 'domainname', 'entrypoint', 'environment', 'healthcheck', 'hostname', 'image', 'labels', 'mac_address', 'name', 'network_disabled', 'platform', 'stdin_open', 'stop_signal', 'tty', 'use_config_proxy', 'user', 'working_dir', ] # kwargs to copy straight from run to host_config RUN_HOST_CONFIG_KWARGS = [ 'auto_remove', 'blkio_weight_device', 'blkio_weight', 'cap_add', 'cap_drop', 'cgroup_parent', 'cgroupns', 'cpu_count', 'cpu_percent', 'cpu_period', 'cpu_quota', 'cpu_shares', 'cpuset_cpus', 'cpuset_mems', 'cpu_rt_period', 'cpu_rt_runtime', 'device_cgroup_rules', 'device_read_bps', 'device_read_iops', 'device_write_bps', 'device_write_iops', 'devices', 'device_requests', 'dns_opt', 'dns_search', 'dns', 'extra_hosts', 'group_add', 'init', 'init_path', 'ipc_mode', 'isolation', 'kernel_memory', 'links', 'log_config', 'lxc_conf', 'mem_limit', 'mem_reservation', 'mem_swappiness', 'memswap_limit', 'mounts', 'nano_cpus', 'network_mode', 'oom_kill_disable', 'oom_score_adj', 'pid_mode', 'pids_limit', 'privileged', 'publish_all_ports', 'read_only', 'restart_policy', 'security_opt', 'shm_size', 'storage_opt', 'sysctls', 'tmpfs', 'ulimits', 'userns_mode', 'uts_mode', 'version', 'volume_driver', 'volumes_from', 'runtime' ] def _create_container_args(kwargs): """ Convert arguments to create() to arguments to create_container(). """ # Copy over kwargs which can be copied directly create_kwargs = {} for key in copy.copy(kwargs): if key in RUN_CREATE_KWARGS: create_kwargs[key] = kwargs.pop(key) host_config_kwargs = {} for key in copy.copy(kwargs): if key in RUN_HOST_CONFIG_KWARGS: host_config_kwargs[key] = kwargs.pop(key) # Process kwargs which are split over both create and host_config ports = kwargs.pop('ports', {}) if ports: host_config_kwargs['port_bindings'] = ports volumes = kwargs.pop('volumes', {}) if volumes: host_config_kwargs['binds'] = volumes network = kwargs.pop('network', None) networking_config = kwargs.pop('networking_config', None) if network: if networking_config: # Sanity check: check if the network is defined in the # networking config dict, otherwise switch to None if network not in networking_config: networking_config = None create_kwargs['networking_config'] = NetworkingConfig( networking_config ) if networking_config else {network: None} host_config_kwargs['network_mode'] = network # All kwargs should have been consumed by this point, so raise # error if any are left if kwargs: raise create_unexpected_kwargs_error('run', kwargs) create_kwargs['host_config'] = HostConfig(**host_config_kwargs) # Fill in any kwargs which need processing by create_host_config first port_bindings = create_kwargs['host_config'].get('PortBindings') if port_bindings: # sort to make consistent for tests create_kwargs['ports'] = [tuple(p.split('/', 1)) for p in sorted(port_bindings.keys())] if volumes: if isinstance(volumes, dict): create_kwargs['volumes'] = [ v.get('bind') for v in volumes.values() ] else: create_kwargs['volumes'] = [ _host_volume_from_bind(v) for v in volumes ] return create_kwargs def _host_volume_from_bind(bind): drive, rest = ntpath.splitdrive(bind) bits = rest.split(':', 1) if len(bits) == 1 or bits[1] in ('ro', 'rw'): return drive + bits[0] elif bits[1].endswith(':ro') or bits[1].endswith(':rw'): return bits[1][:-3] else: return bits[1] ExecResult = namedtuple('ExecResult', 'exit_code,output') """ A result of Container.exec_run with the properties ``exit_code`` and ``output``. """ services.py 0000644 00000033144 15027745625 0006763 0 ustar 00 import copy from docker.errors import InvalidArgument, create_unexpected_kwargs_error from docker.types import ContainerSpec, Placement, ServiceMode, TaskTemplate from .resource import Collection, Model class Service(Model): """A service.""" id_attribute = 'ID' @property def name(self): """The service's name.""" return self.attrs['Spec']['Name'] @property def version(self): """ The version number of the service. If this is not the same as the server, the :py:meth:`update` function will not work and you will need to call :py:meth:`reload` before calling it again. """ return self.attrs.get('Version').get('Index') def remove(self): """ Stop and remove the service. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.remove_service(self.id) def tasks(self, filters=None): """ List the tasks in this service. Args: filters (dict): A map of filters to process on the tasks list. Valid filters: ``id``, ``name``, ``node``, ``label``, and ``desired-state``. Returns: :py:class:`list`: List of task dictionaries. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ if filters is None: filters = {} filters['service'] = self.id return self.client.api.tasks(filters=filters) def update(self, **kwargs): """ Update a service's configuration. Similar to the ``docker service update`` command. Takes the same parameters as :py:meth:`~ServiceCollection.create`. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ # Image is required, so if it hasn't been set, use current image if 'image' not in kwargs: spec = self.attrs['Spec']['TaskTemplate']['ContainerSpec'] kwargs['image'] = spec['Image'] if kwargs.get('force_update') is True: task_template = self.attrs['Spec']['TaskTemplate'] current_value = int(task_template.get('ForceUpdate', 0)) kwargs['force_update'] = current_value + 1 create_kwargs = _get_create_service_kwargs('update', kwargs) return self.client.api.update_service( self.id, self.version, **create_kwargs ) def logs(self, **kwargs): """ Get log stream for the service. Note: This method works only for services with the ``json-file`` or ``journald`` logging drivers. Args: details (bool): Show extra details provided to logs. Default: ``False`` follow (bool): Keep connection open to read logs as they are sent by the Engine. Default: ``False`` stdout (bool): Return logs from ``stdout``. Default: ``False`` stderr (bool): Return logs from ``stderr``. Default: ``False`` since (int): UNIX timestamp for the logs staring point. Default: 0 timestamps (bool): Add timestamps to every log line. tail (string or int): Number of log lines to be returned, counting from the current end of the logs. Specify an integer or ``'all'`` to output all log lines. Default: ``all`` Returns: generator: Logs for the service. """ is_tty = self.attrs['Spec']['TaskTemplate']['ContainerSpec'].get( 'TTY', False ) return self.client.api.service_logs(self.id, is_tty=is_tty, **kwargs) def scale(self, replicas): """ Scale service container. Args: replicas (int): The number of containers that should be running. Returns: bool: ``True`` if successful. """ if 'Global' in self.attrs['Spec']['Mode'].keys(): raise InvalidArgument('Cannot scale a global container') service_mode = ServiceMode('replicated', replicas) return self.client.api.update_service(self.id, self.version, mode=service_mode, fetch_current_spec=True) def force_update(self): """ Force update the service even if no changes require it. Returns: bool: ``True`` if successful. """ return self.update(force_update=True, fetch_current_spec=True) class ServiceCollection(Collection): """Services on the Docker server.""" model = Service def create(self, image, command=None, **kwargs): """ Create a service. Similar to the ``docker service create`` command. Args: image (str): The image name to use for the containers. command (list of str or str): Command to run. args (list of str): Arguments to the command. constraints (list of str): :py:class:`~docker.types.Placement` constraints. preferences (list of tuple): :py:class:`~docker.types.Placement` preferences. maxreplicas (int): :py:class:`~docker.types.Placement` maxreplicas or (int) representing maximum number of replicas per node. platforms (list of tuple): A list of platform constraints expressed as ``(arch, os)`` tuples. container_labels (dict): Labels to apply to the container. endpoint_spec (EndpointSpec): Properties that can be configured to access and load balance a service. Default: ``None``. env (list of str): Environment variables, in the form ``KEY=val``. hostname (string): Hostname to set on the container. init (boolean): Run an init inside the container that forwards signals and reaps processes isolation (string): Isolation technology used by the service's containers. Only used for Windows containers. labels (dict): Labels to apply to the service. log_driver (str): Log driver to use for containers. log_driver_options (dict): Log driver options. mode (ServiceMode): Scheduling mode for the service. Default:``None`` mounts (list of str): Mounts for the containers, in the form ``source:target:options``, where options is either ``ro`` or ``rw``. name (str): Name to give to the service. networks (:py:class:`list`): List of network names or IDs or :py:class:`~docker.types.NetworkAttachmentConfig` to attach the service to. Default: ``None``. resources (Resources): Resource limits and reservations. restart_policy (RestartPolicy): Restart policy for containers. secrets (list of :py:class:`~docker.types.SecretReference`): List of secrets accessible to containers for this service. stop_grace_period (int): Amount of time to wait for containers to terminate before forcefully killing them. update_config (UpdateConfig): Specification for the update strategy of the service. Default: ``None`` rollback_config (RollbackConfig): Specification for the rollback strategy of the service. Default: ``None`` user (str): User to run commands as. workdir (str): Working directory for commands to run. tty (boolean): Whether a pseudo-TTY should be allocated. groups (:py:class:`list`): A list of additional groups that the container process will run as. open_stdin (boolean): Open ``stdin`` read_only (boolean): Mount the container's root filesystem as read only. stop_signal (string): Set signal to stop the service's containers healthcheck (Healthcheck): Healthcheck configuration for this service. hosts (:py:class:`dict`): A set of host to IP mappings to add to the container's `hosts` file. dns_config (DNSConfig): Specification for DNS related configurations in resolver configuration file. configs (:py:class:`list`): List of :py:class:`~docker.types.ConfigReference` that will be exposed to the service. privileges (Privileges): Security options for the service's containers. cap_add (:py:class:`list`): A list of kernel capabilities to add to the default set for the container. cap_drop (:py:class:`list`): A list of kernel capabilities to drop from the default set for the container. sysctls (:py:class:`dict`): A dict of sysctl values to add to the container Returns: :py:class:`Service`: The created service. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ kwargs['image'] = image kwargs['command'] = command create_kwargs = _get_create_service_kwargs('create', kwargs) service_id = self.client.api.create_service(**create_kwargs) return self.get(service_id) def get(self, service_id, insert_defaults=None): """ Get a service. Args: service_id (str): The ID of the service. insert_defaults (boolean): If true, default values will be merged into the output. Returns: :py:class:`Service`: The service. Raises: :py:class:`docker.errors.NotFound` If the service does not exist. :py:class:`docker.errors.APIError` If the server returns an error. :py:class:`docker.errors.InvalidVersion` If one of the arguments is not supported with the current API version. """ return self.prepare_model( self.client.api.inspect_service(service_id, insert_defaults) ) def list(self, **kwargs): """ List services. Args: filters (dict): Filters to process on the nodes list. Valid filters: ``id``, ``name`` , ``label`` and ``mode``. Default: ``None``. status (bool): Include the service task count of running and desired tasks. Default: ``None``. Returns: list of :py:class:`Service`: The services. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return [ self.prepare_model(s) for s in self.client.api.services(**kwargs) ] # kwargs to copy straight over to ContainerSpec CONTAINER_SPEC_KWARGS = [ 'args', 'cap_add', 'cap_drop', 'command', 'configs', 'dns_config', 'env', 'groups', 'healthcheck', 'hostname', 'hosts', 'image', 'init', 'isolation', 'labels', 'mounts', 'open_stdin', 'privileges', 'read_only', 'secrets', 'stop_grace_period', 'stop_signal', 'tty', 'user', 'workdir', 'sysctls', ] # kwargs to copy straight over to TaskTemplate TASK_TEMPLATE_KWARGS = [ 'networks', 'resources', 'restart_policy', ] # kwargs to copy straight over to create_service CREATE_SERVICE_KWARGS = [ 'name', 'labels', 'mode', 'update_config', 'rollback_config', 'endpoint_spec', ] PLACEMENT_KWARGS = [ 'constraints', 'preferences', 'platforms', 'maxreplicas', ] def _get_create_service_kwargs(func_name, kwargs): # Copy over things which can be copied directly create_kwargs = {} for key in copy.copy(kwargs): if key in CREATE_SERVICE_KWARGS: create_kwargs[key] = kwargs.pop(key) container_spec_kwargs = {} for key in copy.copy(kwargs): if key in CONTAINER_SPEC_KWARGS: container_spec_kwargs[key] = kwargs.pop(key) task_template_kwargs = {} for key in copy.copy(kwargs): if key in TASK_TEMPLATE_KWARGS: task_template_kwargs[key] = kwargs.pop(key) if 'container_labels' in kwargs: container_spec_kwargs['labels'] = kwargs.pop('container_labels') placement = {} for key in copy.copy(kwargs): if key in PLACEMENT_KWARGS: placement[key] = kwargs.pop(key) placement = Placement(**placement) task_template_kwargs['placement'] = placement if 'log_driver' in kwargs: task_template_kwargs['log_driver'] = { 'Name': kwargs.pop('log_driver'), 'Options': kwargs.pop('log_driver_options', {}) } if func_name == 'update': if 'force_update' in kwargs: task_template_kwargs['force_update'] = kwargs.pop('force_update') # fetch the current spec by default if updating the service # through the model fetch_current_spec = kwargs.pop('fetch_current_spec', True) create_kwargs['fetch_current_spec'] = fetch_current_spec # All kwargs should have been consumed by this point, so raise # error if any are left if kwargs: raise create_unexpected_kwargs_error(func_name, kwargs) container_spec = ContainerSpec(**container_spec_kwargs) task_template_kwargs['container_spec'] = container_spec create_kwargs['task_template'] = TaskTemplate(**task_template_kwargs) return create_kwargs nodes.py 0000644 00000005560 15027745625 0006251 0 ustar 00 from .resource import Collection, Model class Node(Model): """A node in a swarm.""" id_attribute = 'ID' @property def version(self): """ The version number of the service. If this is not the same as the server, the :py:meth:`update` function will not work and you will need to call :py:meth:`reload` before calling it again. """ return self.attrs.get('Version').get('Index') def update(self, node_spec): """ Update the node's configuration. Args: node_spec (dict): Configuration settings to update. Any values not provided will be removed. Default: ``None`` Returns: `True` if the request went through. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> node_spec = {'Availability': 'active', 'Name': 'node-name', 'Role': 'manager', 'Labels': {'foo': 'bar'} } >>> node.update(node_spec) """ return self.client.api.update_node(self.id, self.version, node_spec) def remove(self, force=False): """ Remove this node from the swarm. Args: force (bool): Force remove an active node. Default: `False` Returns: `True` if the request was successful. Raises: :py:class:`docker.errors.NotFound` If the node doesn't exist in the swarm. :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.remove_node(self.id, force=force) class NodeCollection(Collection): """Nodes on the Docker server.""" model = Node def get(self, node_id): """ Get a node. Args: node_id (string): ID of the node to be inspected. Returns: A :py:class:`Node` object. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.prepare_model(self.client.api.inspect_node(node_id)) def list(self, *args, **kwargs): """ List swarm nodes. Args: filters (dict): Filters to process on the nodes list. Valid filters: ``id``, ``name``, ``membership`` and ``role``. Default: ``None`` Returns: A list of :py:class:`Node` objects. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> client.nodes.list(filters={'role': 'manager'}) """ return [ self.prepare_model(n) for n in self.client.api.nodes(*args, **kwargs) ] networks.py 0000644 00000017432 15027745625 0007016 0 ustar 00 from ..api import APIClient from ..utils import version_gte from .containers import Container from .resource import Collection, Model class Network(Model): """ A Docker network. """ @property def name(self): """ The name of the network. """ return self.attrs.get('Name') @property def containers(self): """ The containers that are connected to the network, as a list of :py:class:`~docker.models.containers.Container` objects. """ return [ self.client.containers.get(cid) for cid in (self.attrs.get('Containers') or {}).keys() ] def connect(self, container, *args, **kwargs): """ Connect a container to this network. Args: container (str): Container to connect to this network, as either an ID, name, or :py:class:`~docker.models.containers.Container` object. 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 (:py:class:`list`): A list of links for this endpoint. Containers declared in this list will be linkedto this container. 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``. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ if isinstance(container, Container): container = container.id return self.client.api.connect_container_to_network( container, self.id, *args, **kwargs ) def disconnect(self, container, *args, **kwargs): """ Disconnect a container from this network. Args: container (str): Container to disconnect from this network, as either an ID, name, or :py:class:`~docker.models.containers.Container` object. force (bool): Force the container to disconnect from a network. Default: ``False`` Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ if isinstance(container, Container): container = container.id return self.client.api.disconnect_container_from_network( container, self.id, *args, **kwargs ) def remove(self): """ Remove this network. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self.client.api.remove_network(self.id) class NetworkCollection(Collection): """ Networks on the Docker server. """ model = Network def create(self, name, *args, **kwargs): """ Create a network. Similar to the ``docker network create``. Args: name (str): Name of the network driver (str): Name of the driver used to create the network options (dict): Driver options as a key-value dictionary ipam (IPAMConfig): Optional custom IP scheme for the network. check_duplicate (bool): Request daemon to check for networks with same name. Default: ``None``. internal (bool): Restrict external access to the network. Default ``False``. labels (dict): Map of labels to set on the network. Default ``None``. enable_ipv6 (bool): Enable IPv6 on the network. Default ``False``. attachable (bool): If enabled, and the network is in the global scope, non-service containers on worker nodes will be able to connect to the network. scope (str): Specify the network's scope (``local``, ``global`` or ``swarm``) ingress (bool): If set, create an ingress network which provides the routing-mesh in swarm mode. Returns: (:py:class:`Network`): The network that was created. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: A network using the bridge driver: >>> client.networks.create("network1", driver="bridge") You can also create more advanced networks with custom IPAM configurations. For example, setting the subnet to ``192.168.52.0/24`` and gateway address to ``192.168.52.254``. .. code-block:: python >>> ipam_pool = docker.types.IPAMPool( subnet='192.168.52.0/24', gateway='192.168.52.254' ) >>> ipam_config = docker.types.IPAMConfig( pool_configs=[ipam_pool] ) >>> client.networks.create( "network1", driver="bridge", ipam=ipam_config ) """ resp = self.client.api.create_network(name, *args, **kwargs) return self.get(resp['Id']) def get(self, network_id, *args, **kwargs): """ Get a network by its ID. Args: network_id (str): The ID of the network. verbose (bool): Retrieve the service details across the cluster in swarm mode. scope (str): Filter the network by scope (``swarm``, ``global`` or ``local``). Returns: (:py:class:`Network`) The network. Raises: :py:class:`docker.errors.NotFound` If the network does not exist. :py:class:`docker.errors.APIError` If the server returns an error. """ return self.prepare_model( self.client.api.inspect_network(network_id, *args, **kwargs) ) def list(self, *args, **kwargs): """ List networks. Similar to the ``docker network ls`` command. Args: names (:py:class:`list`): List of names to filter by. ids (:py:class:`list`): List of ids to filter by. filters (dict): Filters to be processed on the network list. Available filters: - ``driver=[<driver-name>]`` Matches a network's driver. - `label` (str|list): format either ``"key"``, ``"key=value"`` or a list of such. - ``type=["custom"|"builtin"]`` Filters networks by type. greedy (bool): Fetch more details for each network individually. You might want this to get the containers attached to them. Returns: (list of :py:class:`Network`) The networks on the server. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ greedy = kwargs.pop('greedy', False) resp = self.client.api.networks(*args, **kwargs) networks = [self.prepare_model(item) for item in resp] if greedy and version_gte(self.client.api._version, '1.28'): for net in networks: net.reload() return networks def prune(self, filters=None): return self.client.api.prune_networks(filters=filters) prune.__doc__ = APIClient.prune_networks.__doc__ configs.py 0000644 00000003465 15027745625 0006573 0 ustar 00 from ..api import APIClient from .resource import Collection, Model class Config(Model): """A config.""" id_attribute = 'ID' def __repr__(self): return f"<{self.__class__.__name__}: '{self.name}'>" @property def name(self): return self.attrs['Spec']['Name'] def remove(self): """ Remove this config. Raises: :py:class:`docker.errors.APIError` If config failed to remove. """ return self.client.api.remove_config(self.id) class ConfigCollection(Collection): """Configs on the Docker server.""" model = Config def create(self, **kwargs): obj = self.client.api.create_config(**kwargs) obj.setdefault("Spec", {})["Name"] = kwargs.get("name") return self.prepare_model(obj) create.__doc__ = APIClient.create_config.__doc__ def get(self, config_id): """ Get a config. Args: config_id (str): Config ID. Returns: (:py:class:`Config`): The config. Raises: :py:class:`docker.errors.NotFound` If the config does not exist. :py:class:`docker.errors.APIError` If the server returns an error. """ return self.prepare_model(self.client.api.inspect_config(config_id)) def list(self, **kwargs): """ List configs. Similar to the ``docker config ls`` command. Args: filters (dict): Server-side list filtering options. Returns: (list of :py:class:`Config`): The configs. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ resp = self.client.api.configs(**kwargs) return [self.prepare_model(obj) for obj in resp] __init__.py 0000644 00000000000 15027745625 0006660 0 ustar 00
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings