File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/api.tar
Back
secret.py 0000644 00000005465 15027743616 0006430 0 ustar 00 import base64 from .. import errors, utils class SecretApiMixin: @utils.minimum_version('1.25') def create_secret(self, name, data, labels=None, driver=None): """ Create a secret Args: name (string): Name of the secret data (bytes): Secret data to be stored labels (dict): A mapping of labels to assign to the secret driver (DriverConfig): A custom driver configuration. If unspecified, the default ``internal`` driver will be used Returns (dict): ID of the newly created secret """ if not isinstance(data, bytes): data = data.encode('utf-8') data = base64.b64encode(data) data = data.decode('ascii') body = { 'Data': data, 'Name': name, 'Labels': labels } if driver is not None: if utils.version_lt(self._version, '1.31'): raise errors.InvalidVersion( 'Secret driver is only available for API version > 1.31' ) body['Driver'] = driver url = self._url('/secrets/create') return self._result( self._post_json(url, data=body), True ) @utils.minimum_version('1.25') @utils.check_resource('id') def inspect_secret(self, id): """ Retrieve secret metadata Args: id (string): Full ID of the secret to inspect Returns (dict): A dictionary of metadata Raises: :py:class:`docker.errors.NotFound` if no secret with that ID exists """ url = self._url('/secrets/{0}', id) return self._result(self._get(url), True) @utils.minimum_version('1.25') @utils.check_resource('id') def remove_secret(self, id): """ Remove a secret Args: id (string): Full ID of the secret to remove Returns (boolean): True if successful Raises: :py:class:`docker.errors.NotFound` if no secret with that ID exists """ url = self._url('/secrets/{0}', id) res = self._delete(url) self._raise_for_status(res) return True @utils.minimum_version('1.25') def secrets(self, filters=None): """ List secrets Args: filters (dict): A map of filters to process on the secrets list. Available filters: ``names`` Returns (list): A list of secrets """ url = self._url('/secrets') params = {} if filters: params['filters'] = utils.convert_filters(filters) return self._result(self._get(url, params=params), True) service.py 0000644 00000045417 15027743616 0006604 0 ustar 00 from .. import auth, errors, utils from ..types import ServiceMode def _check_api_features(version, task_template, update_config, endpoint_spec, rollback_config): def raise_version_error(param, min_version): raise errors.InvalidVersion( f'{param} is not supported in API version < {min_version}' ) if update_config is not None: if utils.version_lt(version, '1.25'): if 'MaxFailureRatio' in update_config: raise_version_error('UpdateConfig.max_failure_ratio', '1.25') if 'Monitor' in update_config: raise_version_error('UpdateConfig.monitor', '1.25') if utils.version_lt(version, '1.28'): if update_config.get('FailureAction') == 'rollback': raise_version_error( 'UpdateConfig.failure_action rollback', '1.28' ) if utils.version_lt(version, '1.29'): if 'Order' in update_config: raise_version_error('UpdateConfig.order', '1.29') if rollback_config is not None: if utils.version_lt(version, '1.28'): raise_version_error('rollback_config', '1.28') if utils.version_lt(version, '1.29'): if 'Order' in update_config: raise_version_error('RollbackConfig.order', '1.29') if endpoint_spec is not None: if utils.version_lt(version, '1.32') and 'Ports' in endpoint_spec: if any(p.get('PublishMode') for p in endpoint_spec['Ports']): raise_version_error('EndpointSpec.Ports[].mode', '1.32') if task_template is not None: if 'ForceUpdate' in task_template and utils.version_lt( version, '1.25'): raise_version_error('force_update', '1.25') if task_template.get('Placement'): if utils.version_lt(version, '1.30'): if task_template['Placement'].get('Platforms'): raise_version_error('Placement.platforms', '1.30') if utils.version_lt(version, '1.27'): if task_template['Placement'].get('Preferences'): raise_version_error('Placement.preferences', '1.27') if task_template.get('ContainerSpec'): container_spec = task_template.get('ContainerSpec') if utils.version_lt(version, '1.25'): if container_spec.get('TTY'): raise_version_error('ContainerSpec.tty', '1.25') if container_spec.get('Hostname') is not None: raise_version_error('ContainerSpec.hostname', '1.25') if container_spec.get('Hosts') is not None: raise_version_error('ContainerSpec.hosts', '1.25') if container_spec.get('Groups') is not None: raise_version_error('ContainerSpec.groups', '1.25') if container_spec.get('DNSConfig') is not None: raise_version_error('ContainerSpec.dns_config', '1.25') if container_spec.get('Healthcheck') is not None: raise_version_error('ContainerSpec.healthcheck', '1.25') if utils.version_lt(version, '1.28'): if container_spec.get('ReadOnly') is not None: raise_version_error('ContainerSpec.dns_config', '1.28') if container_spec.get('StopSignal') is not None: raise_version_error('ContainerSpec.stop_signal', '1.28') if utils.version_lt(version, '1.30'): if container_spec.get('Configs') is not None: raise_version_error('ContainerSpec.configs', '1.30') if container_spec.get('Privileges') is not None: raise_version_error('ContainerSpec.privileges', '1.30') if utils.version_lt(version, '1.35'): if container_spec.get('Isolation') is not None: raise_version_error('ContainerSpec.isolation', '1.35') if utils.version_lt(version, '1.38'): if container_spec.get('Init') is not None: raise_version_error('ContainerSpec.init', '1.38') if task_template.get('Resources'): if utils.version_lt(version, '1.32'): if task_template['Resources'].get('GenericResources'): raise_version_error('Resources.generic_resources', '1.32') def _merge_task_template(current, override): merged = current.copy() if override is not None: for ts_key, ts_value in override.items(): if ts_key == 'ContainerSpec': if 'ContainerSpec' not in merged: merged['ContainerSpec'] = {} for cs_key, cs_value in override['ContainerSpec'].items(): if cs_value is not None: merged['ContainerSpec'][cs_key] = cs_value elif ts_value is not None: merged[ts_key] = ts_value return merged class ServiceApiMixin: @utils.minimum_version('1.24') def create_service( self, task_template, name=None, labels=None, mode=None, update_config=None, networks=None, endpoint_config=None, endpoint_spec=None, rollback_config=None ): """ Create a service. Args: task_template (TaskTemplate): Specification of the task to start as part of the new service. name (string): User-defined name for the service. Optional. labels (dict): A map of labels to associate with the service. Optional. mode (ServiceMode): Scheduling mode for the service (replicated or global). Defaults to replicated. 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`` networks (:py:class:`list`): List of network names or IDs or :py:class:`~docker.types.NetworkAttachmentConfig` to attach the service to. Default: ``None``. endpoint_spec (EndpointSpec): Properties that can be configured to access and load balance a service. Default: ``None``. Returns: A dictionary containing an ``ID`` key for the newly created service. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ _check_api_features( self._version, task_template, update_config, endpoint_spec, rollback_config ) url = self._url('/services/create') headers = {} image = task_template.get('ContainerSpec', {}).get('Image', None) if image is None: raise errors.DockerException( 'Missing mandatory Image key in ContainerSpec' ) if mode and not isinstance(mode, dict): mode = ServiceMode(mode) registry, repo_name = auth.resolve_repository_name(image) auth_header = auth.get_config_header(self, registry) if auth_header: headers['X-Registry-Auth'] = auth_header if utils.version_lt(self._version, '1.25'): networks = networks or task_template.pop('Networks', None) data = { 'Name': name, 'Labels': labels, 'TaskTemplate': task_template, 'Mode': mode, 'Networks': utils.convert_service_networks(networks), 'EndpointSpec': endpoint_spec } if update_config is not None: data['UpdateConfig'] = update_config if rollback_config is not None: data['RollbackConfig'] = rollback_config return self._result( self._post_json(url, data=data, headers=headers), True ) @utils.minimum_version('1.24') @utils.check_resource('service') def inspect_service(self, service, insert_defaults=None): """ Return information about a service. Args: service (str): Service name or ID. insert_defaults (boolean): If true, default values will be merged into the service inspect output. Returns: (dict): A dictionary of the server-side representation of the service, including all relevant properties. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/services/{0}', service) params = {} if insert_defaults is not None: if utils.version_lt(self._version, '1.29'): raise errors.InvalidVersion( 'insert_defaults is not supported in API version < 1.29' ) params['insertDefaults'] = insert_defaults return self._result(self._get(url, params=params), True) @utils.minimum_version('1.24') @utils.check_resource('task') def inspect_task(self, task): """ Retrieve information about a task. Args: task (str): Task ID Returns: (dict): Information about the task. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/tasks/{0}', task) return self._result(self._get(url), True) @utils.minimum_version('1.24') @utils.check_resource('service') def remove_service(self, service): """ Stop and remove a service. Args: service (str): Service name or ID Returns: ``True`` if successful. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/services/{0}', service) resp = self._delete(url) self._raise_for_status(resp) return True @utils.minimum_version('1.24') def services(self, filters=None, status=None): """ 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: A list of dictionaries containing data about each service. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = { 'filters': utils.convert_filters(filters) if filters else None } if status is not None: if utils.version_lt(self._version, '1.41'): raise errors.InvalidVersion( 'status is not supported in API version < 1.41' ) params['status'] = status url = self._url('/services') return self._result(self._get(url, params=params), True) @utils.minimum_version('1.25') @utils.check_resource('service') def service_logs(self, service, details=False, follow=False, stdout=False, stderr=False, since=0, timestamps=False, tail='all', is_tty=None): """ Get log stream for a service. Note: This endpoint works only for services with the ``json-file`` or ``journald`` logging drivers. Args: service (str): ID or name of the service 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`` is_tty (bool): Whether the service's :py:class:`ContainerSpec` enables the TTY option. If omitted, the method will query the Engine for the information, causing an additional roundtrip. Returns (generator): Logs for the service. """ params = { 'details': details, 'follow': follow, 'stdout': stdout, 'stderr': stderr, 'since': since, 'timestamps': timestamps, 'tail': tail } url = self._url('/services/{0}/logs', service) res = self._get(url, params=params, stream=True) if is_tty is None: is_tty = self.inspect_service( service )['Spec']['TaskTemplate']['ContainerSpec'].get('TTY', False) return self._get_result_tty(True, res, is_tty) @utils.minimum_version('1.24') def tasks(self, filters=None): """ Retrieve a list of tasks. Args: filters (dict): A map of filters to process on the tasks list. Valid filters: ``id``, ``name``, ``service``, ``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. """ params = { 'filters': utils.convert_filters(filters) if filters else None } url = self._url('/tasks') return self._result(self._get(url, params=params), True) @utils.minimum_version('1.24') @utils.check_resource('service') def update_service(self, service, version, task_template=None, name=None, labels=None, mode=None, update_config=None, networks=None, endpoint_config=None, endpoint_spec=None, fetch_current_spec=False, rollback_config=None): """ Update a service. Args: service (string): A service identifier (either its name or service ID). version (int): The version number of the service object being updated. This is required to avoid conflicting writes. task_template (TaskTemplate): Specification of the updated task to start as part of the service. name (string): New name for the service. Optional. labels (dict): A map of labels to associate with the service. Optional. mode (ServiceMode): Scheduling mode for the service (replicated or global). Defaults to replicated. 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`` networks (:py:class:`list`): List of network names or IDs or :py:class:`~docker.types.NetworkAttachmentConfig` to attach the service to. Default: ``None``. endpoint_spec (EndpointSpec): Properties that can be configured to access and load balance a service. Default: ``None``. fetch_current_spec (boolean): Use the undefined settings from the current specification of the service. Default: ``False`` Returns: A dictionary containing a ``Warnings`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ _check_api_features( self._version, task_template, update_config, endpoint_spec, rollback_config ) if fetch_current_spec: inspect_defaults = True if utils.version_lt(self._version, '1.29'): inspect_defaults = None current = self.inspect_service( service, insert_defaults=inspect_defaults )['Spec'] else: current = {} url = self._url('/services/{0}/update', service) data = {} headers = {} data['Name'] = current.get('Name') if name is None else name data['Labels'] = current.get('Labels') if labels is None else labels if mode is not None: if not isinstance(mode, dict): mode = ServiceMode(mode) data['Mode'] = mode else: data['Mode'] = current.get('Mode') data['TaskTemplate'] = _merge_task_template( current.get('TaskTemplate', {}), task_template ) container_spec = data['TaskTemplate'].get('ContainerSpec', {}) image = container_spec.get('Image', None) if image is not None: registry, repo_name = auth.resolve_repository_name(image) auth_header = auth.get_config_header(self, registry) if auth_header: headers['X-Registry-Auth'] = auth_header if update_config is not None: data['UpdateConfig'] = update_config else: data['UpdateConfig'] = current.get('UpdateConfig') if rollback_config is not None: data['RollbackConfig'] = rollback_config else: data['RollbackConfig'] = current.get('RollbackConfig') if networks is not None: converted_networks = utils.convert_service_networks(networks) if utils.version_lt(self._version, '1.25'): data['Networks'] = converted_networks else: data['TaskTemplate']['Networks'] = converted_networks elif utils.version_lt(self._version, '1.25'): data['Networks'] = current.get('Networks') elif data['TaskTemplate'].get('Networks') is None: current_task_template = current.get('TaskTemplate', {}) current_networks = current_task_template.get('Networks') if current_networks is None: current_networks = current.get('Networks') if current_networks is not None: data['TaskTemplate']['Networks'] = current_networks if endpoint_spec is not None: data['EndpointSpec'] = endpoint_spec else: data['EndpointSpec'] = current.get('EndpointSpec') resp = self._post_json( url, data=data, params={'version': version}, headers=headers ) return self._result(resp, json=True) swarm.py 0000644 00000043251 15027743616 0006267 0 ustar 00 import http.client as http_client import logging from .. import errors, types, utils from ..constants import DEFAULT_SWARM_ADDR_POOL, DEFAULT_SWARM_SUBNET_SIZE log = logging.getLogger(__name__) class SwarmApiMixin: def create_swarm_spec(self, *args, **kwargs): """ Create a :py:class:`docker.types.SwarmSpec` instance that can be used as the ``swarm_spec`` argument in :py:meth:`~docker.api.swarm.SwarmApiMixin.init_swarm`. Args: 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_cas (:py:class:`list`): Configuration for forwarding signing requests to an external certificate authority. Use a list of :py:class:`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: :py:class:`docker.types.SwarmSpec` Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> spec = client.api.create_swarm_spec( snapshot_interval=5000, log_entries_for_slow_followers=1200 ) >>> client.api.init_swarm( advertise_addr='eth0', listen_addr='0.0.0.0:5000', force_new_cluster=False, swarm_spec=spec ) """ ext_ca = kwargs.pop('external_ca', None) if ext_ca: kwargs['external_cas'] = [ext_ca] return types.SwarmSpec(self._version, *args, **kwargs) @utils.minimum_version('1.24') def get_unlock_key(self): """ Get the unlock key for this Swarm manager. Returns: A ``dict`` containing an ``UnlockKey`` member """ return self._result(self._get(self._url('/swarm/unlockkey')), True) @utils.minimum_version('1.24') def init_swarm(self, advertise_addr=None, listen_addr='0.0.0.0:2377', force_new_cluster=False, swarm_spec=None, default_addr_pool=None, subnet_size=None, data_path_addr=None, data_path_port=None): """ Initialize a new Swarm using the current connected engine as the first node. Args: advertise_addr (string): 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 ``advertise_addr`` is not specified, it will be automatically detected when possible. Default: None listen_addr (string): 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 swarm_spec (dict): Configuration settings of the new Swarm. Use ``APIClient.create_swarm_spec`` to generate a valid configuration. Default: None default_addr_pool (list of strings): 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 Returns: (str): The ID of the created node. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/swarm/init') if swarm_spec is not None and not isinstance(swarm_spec, dict): raise TypeError('swarm_spec must be a dictionary') if default_addr_pool is not None: if utils.version_lt(self._version, '1.39'): raise errors.InvalidVersion( 'Address pool is only available for API version >= 1.39' ) # subnet_size becomes 0 if not set with default_addr_pool if subnet_size is None: subnet_size = DEFAULT_SWARM_SUBNET_SIZE if subnet_size is not None: if utils.version_lt(self._version, '1.39'): raise errors.InvalidVersion( 'Subnet size is only available for API version >= 1.39' ) # subnet_size is ignored if set without default_addr_pool if default_addr_pool is None: default_addr_pool = DEFAULT_SWARM_ADDR_POOL data = { 'AdvertiseAddr': advertise_addr, 'ListenAddr': listen_addr, 'DefaultAddrPool': default_addr_pool, 'SubnetSize': subnet_size, 'ForceNewCluster': force_new_cluster, 'Spec': swarm_spec, } if data_path_addr is not None: if utils.version_lt(self._version, '1.30'): raise errors.InvalidVersion( 'Data address path is only available for ' 'API version >= 1.30' ) data['DataPathAddr'] = data_path_addr if data_path_port is not None: if utils.version_lt(self._version, '1.40'): raise errors.InvalidVersion( 'Data path port is only available for ' 'API version >= 1.40' ) data['DataPathPort'] = data_path_port response = self._post_json(url, data=data) return self._result(response, json=True) @utils.minimum_version('1.24') def inspect_swarm(self): """ Retrieve low-level information about the current swarm. Returns: A dictionary containing data about the swarm. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/swarm') return self._result(self._get(url), True) @utils.check_resource('node_id') @utils.minimum_version('1.24') def inspect_node(self, node_id): """ Retrieve low-level information about a swarm node Args: node_id (string): ID of the node to be inspected. Returns: A dictionary containing data about this node. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/nodes/{0}', node_id) return self._result(self._get(url), True) @utils.minimum_version('1.24') def join_swarm(self, remote_addrs, join_token, listen_addr='0.0.0.0:2377', advertise_addr=None, data_path_addr=None): """ Make this Engine join a swarm that has already been created. Args: remote_addrs (:py:class:`list`): Addresses of one or more manager nodes already participating in the Swarm to join. join_token (string): Secret token for joining this Swarm. listen_addr (string): Listen address used for inter-manager communication if the node gets promoted to manager, as well as determining the networking interface used for the VXLAN Tunnel Endpoint (VTEP). Default: ``'0.0.0.0:2377`` advertise_addr (string): 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 AdvertiseAddr is not specified, it will be automatically detected when possible. 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. Returns: ``True`` if the request went through. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ data = { 'RemoteAddrs': remote_addrs, 'ListenAddr': listen_addr, 'JoinToken': join_token, 'AdvertiseAddr': advertise_addr, } if data_path_addr is not None: if utils.version_lt(self._version, '1.30'): raise errors.InvalidVersion( 'Data address path is only available for ' 'API version >= 1.30' ) data['DataPathAddr'] = data_path_addr url = self._url('/swarm/join') response = self._post_json(url, data=data) self._raise_for_status(response) return True @utils.minimum_version('1.24') def leave_swarm(self, force=False): """ Leave a swarm. Args: force (bool): Leave the swarm even if this node is a manager. Default: ``False`` Returns: ``True`` if the request went through. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/swarm/leave') response = self._post(url, params={'force': force}) # Ignore "this node is not part of a swarm" error if force and response.status_code == http_client.NOT_ACCEPTABLE: return True # FIXME: Temporary workaround for 1.13.0-rc bug # https://github.com/docker/docker/issues/29192 if force and response.status_code == http_client.SERVICE_UNAVAILABLE: return True self._raise_for_status(response) return True @utils.minimum_version('1.24') def nodes(self, filters=None): """ 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 dictionaries containing data about each swarm node. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/nodes') params = {} if filters: params['filters'] = utils.convert_filters(filters) return self._result(self._get(url, params=params), True) @utils.check_resource('node_id') @utils.minimum_version('1.24') def remove_node(self, node_id, force=False): """ Remove a node from the swarm. Args: node_id (string): ID of the node to be removed. force (bool): Force remove an active node. Default: `False` Raises: :py:class:`docker.errors.NotFound` If the node referenced doesn't exist in the swarm. :py:class:`docker.errors.APIError` If the server returns an error. Returns: `True` if the request was successful. """ url = self._url('/nodes/{0}', node_id) params = { 'force': force } res = self._delete(url, params=params) self._raise_for_status(res) return True @utils.minimum_version('1.24') def unlock_swarm(self, key): """ Unlock a locked swarm. Args: key (string): The unlock key as provided by :py:meth:`get_unlock_key` Raises: :py:class:`docker.errors.InvalidArgument` If the key argument is in an incompatible format :py:class:`docker.errors.APIError` If the server returns an error. Returns: `True` if the request was successful. Example: >>> key = client.api.get_unlock_key() >>> client.unlock_swarm(key) """ if isinstance(key, dict): if 'UnlockKey' not in key: raise errors.InvalidArgument('Invalid unlock key format') else: key = {'UnlockKey': key} url = self._url('/swarm/unlock') res = self._post_json(url, data=key) self._raise_for_status(res) return True @utils.minimum_version('1.24') def update_node(self, node_id, version, node_spec=None): """ Update the node's configuration Args: node_id (string): ID of the node to be updated. version (int): The version number of the node object being updated. This is required to avoid conflicting writes. 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'} } >>> client.api.update_node(node_id='24ifsmvkjbyhk', version=8, node_spec=node_spec) """ url = self._url('/nodes/{0}/update?version={1}', node_id, str(version)) res = self._post_json(url, data=node_spec) self._raise_for_status(res) return True @utils.minimum_version('1.24') def update_swarm(self, version, swarm_spec=None, rotate_worker_token=False, rotate_manager_token=False, rotate_manager_unlock_key=False): """ Update the Swarm's configuration Args: version (int): The version number of the swarm object being updated. This is required to avoid conflicting writes. swarm_spec (dict): Configuration settings to update. Use :py:meth:`~docker.api.swarm.SwarmApiMixin.create_swarm_spec` to generate a valid configuration. Default: ``None``. 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``. Returns: ``True`` if the request went through. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/swarm/update') params = { 'rotateWorkerToken': rotate_worker_token, 'rotateManagerToken': rotate_manager_token, 'version': version } if rotate_manager_unlock_key: if utils.version_lt(self._version, '1.25'): raise errors.InvalidVersion( 'Rotate manager unlock key ' 'is only available for API version >= 1.25' ) params['rotateManagerUnlockKey'] = rotate_manager_unlock_key response = self._post_json(url, data=swarm_spec, params=params) self._raise_for_status(response) return True __pycache__/network.cpython-310.pyc 0000644 00000022157 15027743616 0013170 0 ustar 00 o �h�) � @ s> d dl mZ d dlmZ d dlmZmZmZ G dd� d�ZdS )� )�utils)�InvalidVersion)�check_resource�minimum_version� version_ltc @ s� e Zd Zddd�Z ddd�Zed�ddd ��Zed �d d � �Zed �dd d��Z ed� ddd��Z ed� ddd��Z dS )�NetworkApiMixinNc C sX |du ri }|r ||d< |r||d< dt �|�i}| �d�}| j||d�}| j|dd�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=[<key>]``, ``label=[<key>=<value>]`` or a list of such. - ``type=["custom"|"builtin"]`` Filters networks by type. Returns: (dict): List of network objects. Raises: :py:class:`docker.errors.APIError` If the server returns an error. N�name�id�filtersz /networks��paramsT��json)r �convert_filters�_url�_get�_result)�self�names�idsr r �url�res� r �H/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/network.py�networks s zNetworkApiMixin.networksFc C s2 |dur t |t�s td��|||||d�} |dur0t| jd�r#td��t |t�s,td��|| d< |r@t| jd�r<td��d | d < |rPt| jd �rLtd ��d | d < | durbt| jd�r^td��| | d< | durtt| jd�rptd��| | d< | dur�t| jd�r�td��| | d< | �d�} | j| | d�}| j|d 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: (dict): The created network reference object Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: A network using the bridge driver: >>> client.api.create_network("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.api.create_network("network1", driver="bridge", ipam=ipam_config) Nz options must be a dictionary)�Name�Driver�Options�IPAM�CheckDuplicatez1.23z*network labels were introduced in API 1.23zlabels must be a dictionary�Labelsz&enable_ipv6 was introduced in API 1.23T� EnableIPv6�1.22z9Internal networks are not supported in API version < 1.22�Internalz1.24z1attachable is not supported in API version < 1.24� Attachablez1.29z.ingress is not supported in API version < 1.29�Ingressz1.30z,scope is not supported in API version < 1.30�Scopez/networks/create��datar ) � isinstance�dict� TypeErrorr �_versionr r � _post_jsonr )r r �driver�options�ipam�check_duplicate�internal�labels� enable_ipv6� attachable�scope�ingressr( r r r r r �create_network( s^ 7� � � � � � z NetworkApiMixin.create_networkz1.25c C s6 i }|r t �|�|d< | �d�}| �| j||d�d�S )a� Delete unused networks Args: filters (dict): Filters to process on the prune list. Returns: (dict): A dict containing a list of deleted network names and the amount of disk space reclaimed in bytes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. r z/networks/pruner T)r r r r �_post)r r r r r r r �prune_networks� s z NetworkApiMixin.prune_networks�net_idc C s$ | � d|�}| �|�}| �|� dS )z� Remove a network. Similar to the ``docker network rm`` command. Args: net_id (str): The network's id � /networks/{0}N)r �_delete�_raise_for_status)r r; r r r r r �remove_network� s z NetworkApiMixin.remove_networkc C st i }|durt | jd�rtd��||d< |dur&t | jd�r"td��||d< | �d|�}| j||d �}| j|d d �S ) aD Get detailed information about a network. Args: net_id (str): ID of network verbose (bool): Show the service details across the cluster in swarm mode. scope (str): Filter the network by scope (``swarm``, ``global`` or ``local``). Nz1.28z"verbose was introduced in API 1.28�verbosez1.31z scope was introduced in API 1.31r6 r< r Tr )r r, r r r r )r r; r@ r6 r r r r r r �inspect_network� s z NetworkApiMixin.inspect_network� containerc C sF || j ||||||| d�d�} | �d|�} | j| | d�} | �| � dS )aF Connect a container to a network. Args: container (str): container-id/name to be connected to the network net_id (str): network id 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 linked to 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. mac_address (str): The MAC address of this container on the network. Defaults to ``None``. )�aliases�links� ipv4_address� ipv6_address�link_local_ips� driver_opt� mac_address)� Container�EndpointConfigz/networks/{0}/connectr' N)�create_endpoint_configr r- r> ) r rB r; rE rF rC rD rG rH rI r( r r r r r � connect_container_to_network� s �� z,NetworkApiMixin.connect_container_to_networkc C sP d|i}|rt | jd�rtd��||d< | �d|�}| j||d�}| �|� dS )aA Disconnect a container from a network. Args: container (str): container ID or name to be disconnected from the network net_id (str): network ID force (bool): Force the container to disconnect from a network. Default: ``False`` rJ r" z,Forced disconnect was introduced in API 1.22�Forcez/networks/{0}/disconnectr' N)r r, r r r- r> )r rB r; �forcer( r r r r r �!disconnect_container_from_network� s � z1NetworkApiMixin.disconnect_container_from_network)NNN) NNNNFNFNNN)N)NN)NNNNNNN)F) �__name__� __module__� __qualname__r r8 r r: r r? rA rM rP r r r r r s, ! �r �(�r N)� r �errorsr r r r r r r r r �<module> s __pycache__/__init__.cpython-310.pyc 0000644 00000000316 15027743616 0013227 0 ustar 00 o �h � @ s d dl mZ dS )� )� APIClientN)�clientr � r r �I/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/__init__.py�<module> s __pycache__/client.cpython-310.pyc 0000644 00000035514 15027743616 0012756 0 ustar 00 o �h�K � @ s� d dl Z d dlZd dlZd dlmZ d dlZd dlZd dlZddlm Z ddl m Z m Z m Z mZmZmZmZmZ ddlmZmZmZmZ ddlmZ ddlmZ dd l m Z m Z m Z m Z dd l m!Z! dd l"m#Z# dd l$m%Z%m&Z&m'Z' d dl(m)Z) d dl m*Z* d dl+m,Z, d dl-m.Z. d dl/m0Z0 d dl1m2Z2 d dl3m4Z4 d dl5m6Z6 d dl7m8Z8 d dl9m:Z: d dl;m<Z< d dl=m>Z> zddlm?Z? W n e@y� Y nw zddlmAZA W n e@y� Y nw G d d � d ejBe)e*e,e.e0e2e4e6e8e:e<e>�ZCdS ) � N)�partial� )�auth)�DEFAULT_MAX_POOL_SIZE�DEFAULT_NUM_POOLS�DEFAULT_NUM_POOLS_SSH�DEFAULT_TIMEOUT_SECONDS�DEFAULT_USER_AGENT�IS_WINDOWS_PLATFORM�MINIMUM_DOCKER_API_VERSION�STREAM_HEADER_SIZE_BYTES)�DockerException�InvalidVersion�TLSParameterError�$create_api_error_from_http_exception)� TLSConfig)�UnixHTTPAdapter)�check_resource�config�update_headers�utils)� json_stream)� ProxyConfig)�consume_socket_output� demux_adaptor� frames_iter� )� BuildApiMixin)�ConfigApiMixin)�ContainerApiMixin)�DaemonApiMixin)� ExecApiMixin)� ImageApiMixin)�NetworkApiMixin)�PluginApiMixin)�SecretApiMixin)�ServiceApiMixin)� SwarmApiMixin)�VolumeApiMixin)�NpipeHTTPAdapter)�SSHHTTPAdapterc sR e Zd ZdZejjg d� Zddededdde f � fdd� Z dd� Z d d � Z e d d � �Ze d d� �Ze dd� �Ze dd� �Zdd� Zdd� Zd@dd�Zdd� ZdAdd �Zed �dAd d ��Zd d!� Zd"d#� ZdBd$d%�Zd&d'� Z d(d)� Z dCd,d-�Z dDd.d/�Z d0d1� Z ed �d2d3� �Z!d4d5� Z"d6d7� Z#d8d9� Z$� fd:d;�Z%e&d<d=� �Z'dAd>d?�Z(� Z)S )E� APIClientaW A low-level client for the Docker Engine API. Example: >>> import docker >>> client = docker.APIClient(base_url='unix://var/run/docker.sock') >>> client.version() {u'ApiVersion': u'1.33', u'Arch': u'amd64', u'BuildTime': u'2017-11-19T18:46:37.000000000+00:00', u'GitCommit': u'f4ffd2511c', u'GoVersion': u'go1.9.2', u'KernelVersion': u'4.14.3-1-ARCH', u'MinAPIVersion': u'1.12', u'Os': u'linux', u'Version': u'17.10.0-ce'} Args: base_url (str): URL to the Docker server. For example, ``unix:///var/run/docker.sock`` or ``tcp://127.0.0.1:1234``. version (str): The version of the API to use. Set to ``auto`` to automatically detect the server's version. Default: ``1.35`` timeout (int): Default timeout for API calls, in seconds. tls (bool or :py:class:`~docker.tls.TLSConfig`): Enable TLS. Pass ``True`` to enable it with default options, or pass a :py:class:`~docker.tls.TLSConfig` object to use custom configuration. user_agent (str): Set a custom user agent for requests to the server. credstore_env (dict): Override environment variables when calling the credential store process. use_ssh_client (bool): If set to `True`, an ssh connection is made via shelling out to the ssh client. Ensure the ssh client is installed and configured on the host. max_pool_size (int): The maximum number of connections to save in the pool. )� _auth_configs�_general_configs�_version�base_url�timeoutNFc s� t � �� |r |s td��|| _|| _|| jd< t�� | _| j� di �} z| | } W n t y9 | � di �} Y nw t � | �| _ tj| j|d�| _|| _tj|tt|�d�}|�d�r_|p^tnt}|�d�r�t|||| d �| _| �d | j� | � d d � d | _n�|�d�r�ts�t d��z t |||| d �| _W n t y� } zt d�| �d } ~ ww | �d | j� d| _nT|�d�r�z t |||| |d�| _W n t y� } zt d�| �d } ~ ww | �d| j� | � d d � d| _n t!|t"�r�|�#| � n|�rt$j%j&|d�| _| �d | j� || _|d u �st!|t'��r |�(� dk�r | �)� | _*n|| _*t!| j*t'��s3t dt+|�j,� ���t�-| j*t.��rCt/dt.� d���d S )Nz5If using TLS, the base_url argument must be provided.z User-Agent�proxies�default)� config_dict� credstore_env)�tlszssh://z http+unix://)�pool_connections� max_pool_sizezhttp+docker://�http://�https://zhttp+docker://localhostznpipe://z2The npipe:// protocol is only supported on Windowsz4Install pypiwin32 package to enable npipe:// support�http+docker://localnpipe)r6 r7 � shell_outz1Install paramiko package to enable ssh:// support�http+docker://ssh)r6 �autoz2Version parameter must be a string or None. Found zAPI versions below z) are no longer supported by this library.)0�super�__init__r r/ r0 �headersr �load_general_configr- �get�KeyErrorr � from_dict�_proxy_configsr � load_configr, r4 r � parse_hostr �bool� startswithr r r �_custom_adapter�mount�_unmountr r) � NameErrorr* � isinstancer �configure_client�requests�adapters� HTTPAdapter�str�lower�_retrieve_server_versionr. �type�__name__� version_ltr r ) �selfr/ �versionr0 r5 � user_agent� num_poolsr4 �use_ssh_clientr7 � proxy_configr1 �err�� __class__� �G/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/client.pyr? s s� � � � ���� � � ����� ����� � � �� ��zAPIClient.__init__c C s\ z | j dd�d W S ty } ztd�|�d }~w ty- } ztd|� ��|�d }~ww )NF)� api_version� ApiVersionzAInvalid response from docker daemon: key "ApiVersion" is missing.z)Error while fetching server API version: )rZ rC r � Exception)rY �ke�erb rb rc rU � s" �������z"APIClient._retrieve_server_versionc C s |� d| j� |S )zjPrepare the kwargs for an HTTP request by inserting the timeout parameter, if not already present.r0 )� setdefaultr0 )rY �kwargsrb rb rc �_set_request_timeout� s z APIClient._set_request_timeoutc K � | j |fi | �|���S �N)�postrk �rY �urlrj rb rb rc �_post� � zAPIClient._postc K rl rm )rB rk ro rb rb rc �_get� rr zAPIClient._getc K rl rm )�putrk ro rb rb rc �_put� rr zAPIClient._putc K rl rm )�deleterk ro rb rb rc �_delete� rr zAPIClient._deletec O s� |D ]}t |t�std|� dt|�� d���qttjjdd�}t||�}|j |� }|� dd�r:| j � d| j � |� �S | j � |� �S ) Nz Expected a string but found z (z ) insteadz/:)�safe� versioned_apiTz/v) rN rS � ValueErrorrV r �urllib�parse�quote�map�formatrB r/ r. )rY �pathfmt�argsrj �arg�quote_f�formatted_pathrb rb rc �_url s �� zAPIClient._urlc C s6 z|� � W dS tjjy } zt|�|�d}~ww )z1Raises stored :class:`APIError`, if one occurred.N)�raise_for_statusrP � exceptions� HTTPErrorr )rY �responserh rb rb rc �_raise_for_status s ��zAPIClient._raise_for_statusc C s2 |r|rJ �| � |� |r|�� S |r|jS |jS rm )r� �json�content�text)rY r� r� �binaryrb rb rc �_result s zAPIClient._resultc K s� i }|d ur t |t�r t|�� �D ] \}}|d ur |||< qn|d ur%|}d|vr-i |d< d|d d< | j|fdt�|�i|��S )Nr@ zapplication/jsonz Content-Type�data)rN �dict�iter�itemsrq r� �dumps)rY rp r� rj �data2�k�vrb rb rc � _post_json! s �� zAPIClient._post_jsonc C s |pdddd�S )Nr )�stdout�stderr�streamrb )rY �overriderb rb rc �_attach_params1 s �zAPIClient._attach_params� containerc C sR | � d|�}tjd|| �|�d�}|�� j}|�ddd�}|�ddd�}| �|�S ) Nz/containers/{0}/attach/ws�POST)�paramsr8 zws://r r9 zwss://)r� rP �Requestr� �preparerp �replace� _create_websocket_connection)rY r� r� rp �req�full_urlrb rb rc �_attach_websocket8 s zAPIClient._attach_websocketc C s8 z dd l }|�|�W S ty } ztd�|�d }~ww )Nr z�The `websocket-client` library is required for using websocket connections. You can install the `docker` library with the [websocket] extra to install it.)� websocket�create_connection� ImportErrorr )rY rp r� �ierb rb rc r� A s ����z&APIClient._create_websocket_connectionc C s~ | � |� | jdkr|jjjjj}n | j�d�r |jjjj}n|jjjj}| j�d�r.|j}z||_ W |S t y> Y |S w )Nr: r< r9 ) r� r/ �raw�_fp�fp�sockrI �channel�_sock� _response�AttributeError)rY r� r� rb rb rc �_get_raw_response_socketM s ��z"APIClient._get_raw_response_socketc c s� � |j jjr;|rt| �|d��E dH dS |j }|js9|�d�}|s$dS |jjr1||�|jj�7 }|V |jrdS dS | j||d�V dS )z?Generator for data coming from a chunked-encoded HTTP response.FNr )r� ) r� r� �chunkedr �_stream_helper�closed�read� chunk_leftr� )rY r� �decode�readerr� rb rb rc r� c s � � zAPIClient._stream_helperc c sr � | j |dd�}t|�}d} || tk rdS |||t � }t�d|�\}}|t }|| } | }||| � V q)zMA generator of multiplexed data blocks read from a buffered response.T�r� r �>BxxxLN)r� �lenr �struct� unpack_from) rY r� �buf� buf_length�walker�header�_�length�start�endrb rb rc �_multiplexed_buffer_helperx s � �z$APIClient._multiplexed_buffer_helperc c s^ � | � |�}| �|� |j�t�}|sdS t�d|�\}}|s!q |j�|�}|s+dS |V q )zMA generator of multiplexed data blocks coming from a response stream.Tr� N)r� �_disable_socket_timeoutr� r� r r� �unpack)rY r� �socketr� r� r� r� rb rb rc �#_multiplexed_response_stream_helper� s � �z-APIClient._multiplexed_response_stream_helperr Tc c s6 � | � |� | �|�}| �|� |�||�E dH dS )z< Stream result for TTY-enabled container and raw binary dataN)r� r� r� � iter_content)rY r� � chunk_sizer� r� rb rb rc �_stream_raw_result� s � z APIClient._stream_raw_resultc C s` | � |�}t||�}|rdd� |D �}ndd� |D �}|r |S z t||d�W |�� S |�� w )z�Consume all data from the socket, close the response and return the data. If stream=True, then a generator is returned instead and the caller is responsible for closing the response. c s s � | ]}t |� V qd S rm )r )�.0�framerb rb rc � <genexpr>� � � z.APIClient._read_from_socket.<locals>.<genexpr>c s s � | ]\}}|V qd S rm rb )r� r� r� rb rb rc r� � r� )�demux)r� r r �close)rY r� r� �ttyr� r� �genrb rb rc �_read_from_socket� s zAPIClient._read_from_socketc C s\ |t |dd�g}|D ]!}t|d�sq d}t|d�r |�� }|du s%|dkr&q |�d� q dS )a Depending on the combination of python version and whether we're connecting over http or https, we might need to access _sock, which may or may not exist; or we may need to just settimeout on socket itself, which also may or may not have settimeout on it. To avoid missing the correct one, we try both. We also do not want to set the timeout if it is already disabled, as you run the risk of changing a socket that was non-blocking to blocking, for example when using gevent. r� N� settimeout���� gettimeoutg )�getattr�hasattrr� r� )rY r� �sockets�sr0 rb rb rc r� � s �z!APIClient._disable_socket_timeoutc C s | � |�}|d d S )N�Config�Tty)�inspect_container)rY r� �contrb rb rc � _check_is_tty� s zAPIClient._check_is_ttyc C s | � ||| �|��S rm )�_get_result_ttyr� )rY r� r� �resrb rb rc � _get_result� s zAPIClient._get_resultc C sP |r|r | � |�S | j|dd�S | �|� d}|r | �|�S |�t| �|���S )NTr� � )r� r� r� r� �join�listr� )rY r� r� �is_tty�seprb rb rc r� � s � �zAPIClient._get_result_ttyc G s |D ]}| j �|� qd S rm )rQ �pop)rY r� �protorb rb rc rL � s �zAPIClient._unmountc sH zt � �|�W S tjjy# } z| jr | jW Y d }~S |�d }~ww rm )r> � get_adapterrP r� � InvalidSchemarJ )rY rp rh r` rb rc r� � s ��zAPIClient.get_adapterc C s | j S rm )r. )rY rb rb rc rd s zAPIClient.api_versionc C s t j|| jd�| _dS )a. Force a reload of the auth configuration Args: dockercfg_path (str): Use a custom path for the Docker config file (default ``$HOME/.docker/config.json`` if present, otherwise ``$HOME/.dockercfg``) Returns: None )r4 N)r rF r4 r, )rY �dockercfg_pathrb rb rc � reload_config s �zAPIClient.reload_config)FFrm )F)r T)TF)*rW � __module__� __qualname__�__doc__rP �Session� __attrs__r r r r? rU rk r rq rs ru rw r� r� r� r� r� r r� r� r� r� r� r� r� r� r� r� r� r� rL r� �propertyrd r� � __classcell__rb rb r` rc r+ 9 sV &�j r+ )Dr� r� r{ � functoolsr rP �requests.adapters�requests.exceptions� r � constantsr r r r r r r r �errorsr r r r r5 r � transportr r r r r �utils.json_streamr � utils.proxyr � utils.socketr r r �buildr r r� r �daemonr �exec_apir! �imager" �networkr# �pluginr$ �secretr% �servicer& �swarmr' �volumer( r) r� r* r� r+ rb rb rb rc �<module> sj ( � � � __pycache__/volume.cpython-310.pyc 0000644 00000012133 15027743616 0012777 0 ustar 00 o �h� � @ s" d dl mZmZ G dd� d�ZdS )� )�errors�utilsc @ sJ e Zd Zddd�Z ddd�Zdd� Ze�d�dd d ��Zdd d �Z dS )�VolumeApiMixinNc C s6 d|rt �|�ndi}| �d�}| �| j||d�d�S )a List volumes currently registered by the docker daemon. Similar to the ``docker volume ls`` command. Args: filters (dict): Server-side list filtering options. Returns: (dict): Dictionary with list of volume objects as value of the ``Volumes`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> client.api.volumes() {u'Volumes': [{u'Driver': u'local', u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data', u'Name': u'foobar'}, {u'Driver': u'local', u'Mountpoint': u'/var/lib/docker/volumes/baz/_data', u'Name': u'baz'}]} �filtersNz/volumes��paramsT)r �convert_filters�_url�_result�_get��selfr r �url� r �G/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/volume.py�volumes s � zVolumeApiMixin.volumesc C s� | � d�}|durt|t�std��|||d�}|dur7t�d| j�dk r*t�d��t|t�s3td��||d < | � | j ||d �d �S ) a� Create and register a named volume Args: name (str): Name of the volume 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: (dict): The created volume reference object Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> volume = client.api.create_volume( ... name='foobar', ... driver='local', ... driver_opts={'foo': 'bar', 'baz': 'false'}, ... labels={"key": "value"}, ... ) ... print(volume) {u'Driver': u'local', u'Labels': {u'key': u'value'}, u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data', u'Name': u'foobar', u'Scope': u'local'} z/volumes/createNz driver_opts must be a dictionary)�Name�Driver� DriverOptsz1.23� z)volume labels were introduced in API 1.23zlabels must be a dictionary�Labels)�dataT) r � isinstance�dict� TypeErrorr �compare_version�_versionr �InvalidVersionr � _post_json)r �name�driver� driver_opts�labelsr r r r r � create_volume& s "�� z VolumeApiMixin.create_volumec C s | � d|�}| �| �|�d�S )a� Retrieve volume info by name. Args: name (str): volume name Returns: (dict): Volume information dictionary Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> client.api.inspect_volume('foobar') {u'Driver': u'local', u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data', u'Name': u'foobar'} � /volumes/{0}T)r r r )r r r r r r �inspect_volume] s z VolumeApiMixin.inspect_volume�1.25c C s6 i }|r t �|�|d< | �d�}| �| j||d�d�S )a� Delete unused volumes Args: filters (dict): Filters to process on the prune list. Returns: (dict): A dict containing a list of deleted volume names and the amount of disk space reclaimed in bytes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. r z/volumes/pruner T)r r r r �_postr r r r � prune_volumesv s z VolumeApiMixin.prune_volumesFc C sP i }|rt �| jd�rt�d��d|i}| jd||d�}| �|�}| �|� dS )az Remove a volume. Similar to the ``docker volume rm`` command. Args: name (str): The volume's name 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. r& z(force removal was introduced in API 1.25�forcer$ r N)r � version_ltr r r r �_delete�_raise_for_status)r r r) r r �respr r r � remove_volume� s � z VolumeApiMixin.remove_volume)N)NNNN)F) �__name__� __module__� __qualname__r r# r% r �minimum_versionr( r. r r r r r s ! �7 r N)� r r r r r r r �<module> s __pycache__/swarm.cpython-310.pyc 0000644 00000037670 15027743616 0012636 0 ustar 00 o �h�F � @ sT d dl mZ d dlZddlmZmZmZ ddlm Z m Z e� e �Z G dd� d�ZdS )� N� )�errors�types�utils)�DEFAULT_SWARM_ADDR_POOL�DEFAULT_SWARM_SUBNET_SIZEc @ s e Zd Zdd� Ze�d�dd� �Ze�d� d d d ��Ze�d�d d � �Ze� d �e�d�dd� ��Z e�d� d dd��Z e�d�d dd��Z e�d�d!dd��Z e� d �e�d�d dd���Ze�d�dd� �Ze�d�d!dd��Ze�d� d"d d ��ZdS )#� SwarmApiMixinc O s4 |� dd�}|r |g|d< tj| jg|�R i |��S )a^ Create a :py:class:`docker.types.SwarmSpec` instance that can be used as the ``swarm_spec`` argument in :py:meth:`~docker.api.swarm.SwarmApiMixin.init_swarm`. Args: 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_cas (:py:class:`list`): Configuration for forwarding signing requests to an external certificate authority. Use a list of :py:class:`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: :py:class:`docker.types.SwarmSpec` Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> spec = client.api.create_swarm_spec( snapshot_interval=5000, log_entries_for_slow_followers=1200 ) >>> client.api.init_swarm( advertise_addr='eth0', listen_addr='0.0.0.0:5000', force_new_cluster=False, swarm_spec=spec ) � external_caN� external_cas)�popr � SwarmSpec�_version)�self�args�kwargs�ext_ca� r �F/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/swarm.py�create_swarm_spec s 8 z SwarmApiMixin.create_swarm_specz1.24c C s | � | �| �d��d�S )z� Get the unlock key for this Swarm manager. Returns: A ``dict`` containing an ``UnlockKey`` member z/swarm/unlockkeyT)�_result�_get�_url)r r r r �get_unlock_keyI s z SwarmApiMixin.get_unlock_keyN� 0.0.0.0:2377Fc C s� | � d�} |durt|t�std��|dur(t�| jd�r"t�d��|du r(t }|dur>t�| jd�r8t�d��|du r>t }||||||d�} |dur[t�| jd�rWt�d ��|| d < |durot�| jd �rkt�d ��|| d < | j | | d�} | j | dd�S )a} Initialize a new Swarm using the current connected engine as the first node. Args: advertise_addr (string): 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 ``advertise_addr`` is not specified, it will be automatically detected when possible. Default: None listen_addr (string): 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 swarm_spec (dict): Configuration settings of the new Swarm. Use ``APIClient.create_swarm_spec`` to generate a valid configuration. Default: None default_addr_pool (list of strings): 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 Returns: (str): The ID of the created node. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z /swarm/initNz swarm_spec must be a dictionaryz1.39z6Address pool is only available for API version >= 1.39z5Subnet size is only available for API version >= 1.39)� AdvertiseAddr� ListenAddr�DefaultAddrPool� SubnetSize�ForceNewCluster�Spec�1.30�;Data address path is only available for API version >= 1.30� DataPathAddrz1.40z8Data path port is only available for API version >= 1.40� DataPathPort��dataT)�json) r � isinstance�dict� TypeErrorr � version_ltr r �InvalidVersionr r � _post_jsonr ) r �advertise_addr� listen_addr�force_new_cluster� swarm_spec�default_addr_pool� subnet_size�data_path_addr�data_path_port�urlr% �responser r r � init_swarmS sL 1��� ��zSwarmApiMixin.init_swarmc C s | � d�}| �| �|�d�S )a Retrieve low-level information about the current swarm. Returns: A dictionary containing data about the swarm. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/swarmT�r r r )r r5 r r r � inspect_swarm� s zSwarmApiMixin.inspect_swarm�node_idc C s | � d|�}| �| �|�d�S )aL Retrieve low-level information about a swarm node Args: node_id (string): ID of the node to be inspected. Returns: A dictionary containing data about this node. Raises: :py:class:`docker.errors.APIError` If the server returns an error. � /nodes/{0}Tr8 )r r: r5 r r r � inspect_node� s zSwarmApiMixin.inspect_nodec C s\ ||||d�}|durt �| jd�rt�d��||d< | �d�}| j||d�}| �|� dS ) a� Make this Engine join a swarm that has already been created. Args: remote_addrs (:py:class:`list`): Addresses of one or more manager nodes already participating in the Swarm to join. join_token (string): Secret token for joining this Swarm. listen_addr (string): Listen address used for inter-manager communication if the node gets promoted to manager, as well as determining the networking interface used for the VXLAN Tunnel Endpoint (VTEP). Default: ``'0.0.0.0:2377`` advertise_addr (string): 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 AdvertiseAddr is not specified, it will be automatically detected when possible. 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. Returns: ``True`` if the request went through. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )� RemoteAddrsr � JoinTokenr Nr r! r" z /swarm/joinr$ T)r r* r r r+ r r, �_raise_for_status) r � remote_addrs� join_tokenr. r- r3 r% r5 r6 r r r � join_swarm� s �� zSwarmApiMixin.join_swarmc C sR | � d�}| j|d|id�}|r|jtjkrdS |r"|jtjkr"dS | �|� dS )aP Leave a swarm. Args: force (bool): Leave the swarm even if this node is a manager. Default: ``False`` Returns: ``True`` if the request went through. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z /swarm/leave�force��paramsT)r �_post� status_code� http_client�NOT_ACCEPTABLE�SERVICE_UNAVAILABLEr? )r rC r5 r6 r r r � leave_swarm s zSwarmApiMixin.leave_swarmc C s6 | � d�}i }|rt�|�|d< | �| j||d�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 dictionaries containing data about each swarm node. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/nodes�filtersrD T)r r �convert_filtersr r )r rL r5 rE r r r �nodes' s zSwarmApiMixin.nodesc C s0 | � d|�}d|i}| j||d�}| �|� dS )a� Remove a node from the swarm. Args: node_id (string): ID of the node to be removed. force (bool): Force remove an active node. Default: `False` Raises: :py:class:`docker.errors.NotFound` If the node referenced doesn't exist in the swarm. :py:class:`docker.errors.APIError` If the server returns an error. Returns: `True` if the request was successful. r; rC rD T)r �_deleter? )r r: rC r5 rE �resr r r � remove_node? s � zSwarmApiMixin.remove_nodec C sL t |t�rd|vrt�d��nd|i}| �d�}| j||d�}| �|� dS )al Unlock a locked swarm. Args: key (string): The unlock key as provided by :py:meth:`get_unlock_key` Raises: :py:class:`docker.errors.InvalidArgument` If the key argument is in an incompatible format :py:class:`docker.errors.APIError` If the server returns an error. Returns: `True` if the request was successful. Example: >>> key = client.api.get_unlock_key() >>> client.unlock_swarm(key) � UnlockKeyzInvalid unlock key formatz /swarm/unlockr$ T)r' r( r �InvalidArgumentr r, r? )r �keyr5 rP r r r � unlock_swarmZ s � zSwarmApiMixin.unlock_swarmc C s. | � d|t|��}| j||d�}| �|� dS )a� Update the node's configuration Args: node_id (string): ID of the node to be updated. version (int): The version number of the node object being updated. This is required to avoid conflicting writes. 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'} } >>> client.api.update_node(node_id='24ifsmvkjbyhk', version=8, node_spec=node_spec) z /nodes/{0}/update?version={1}r$ T)r �strr, r? )r r: �version� node_specr5 rP r r r � update_node~ s zSwarmApiMixin.update_nodec C sX | � d�}|||d�}|r t�| jd�rt�d��||d< | j|||d�}| �|� dS )a� Update the Swarm's configuration Args: version (int): The version number of the swarm object being updated. This is required to avoid conflicting writes. swarm_spec (dict): Configuration settings to update. Use :py:meth:`~docker.api.swarm.SwarmApiMixin.create_swarm_spec` to generate a valid configuration. Default: ``None``. 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``. Returns: ``True`` if the request went through. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z /swarm/update)�rotateWorkerToken�rotateManagerTokenrW z1.25zCRotate manager unlock key is only available for API version >= 1.25�rotateManagerUnlockKey)r% rE T)r r r* r r r+ r, r? ) r rW r0 �rotate_worker_token�rotate_manager_token�rotate_manager_unlock_keyr5 rE r6 r r r � update_swarm� s �� zSwarmApiMixin.update_swarm)Nr FNNNNN)r NN)F)N)NFFF)�__name__� __module__� __qualname__r r �minimum_versionr r7 r9 �check_resourcer< rB rK rN rQ rU rY r` r r r r r sH = �b �2 # #�r )� http.client�clientrH �logging� r r r � constantsr r � getLoggerra �logr r r r r �<module> s __pycache__/plugin.cpython-310.pyc 0000644 00000020735 15027743616 0012775 0 ustar 00 o �h# � @ s" d dl mZmZ G dd� d�ZdS )� )�auth�utilsc @ s e Zd Ze�d�e�d�dd� ��Ze�d�d dd��Ze�d�d dd ��Ze�d�d d d ��Z e�d�d d� �Z e�d�d dd��Z e�d�dd� �Z e�d�dd� �Z e�d�e�d�dd� ��Ze�d�e�d�d dd���Ze�d�e�d�dd � ��ZdS ) �PluginApiMixinz1.25�namec C sH | � d|�}|}t|t�rdd� |�� D �}| j||d�}| �|� dS )aC Configure a plugin. Args: name (string): The name of the plugin. The ``:latest`` tag is optional, and is the default if omitted. options (dict): A key-value mapping of options Returns: ``True`` if successful z/plugins/{0}/setc S s g | ] \}}|� d |� ��qS )�=� )�.0�k�vr r �G/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/plugin.py� <listcomp> s z3PluginApiMixin.configure_plugin.<locals>.<listcomp>)�dataT)�_url� isinstance�dict�items� _post_json�_raise_for_status)�selfr �options�urlr �resr r r �configure_plugin s z PluginApiMixin.configure_pluginFc C sj | � d�}tj||ttj�|g ��d��}| j|d|i|d�}W d � n1 s)w Y | �|� dS )a* 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: ``True`` if successful z/plugins/create)�root�gzip�filesr )�paramsr NT)r r �create_archive�set�build�walk�_postr )r r �plugin_data_dirr r �archvr r r r � create_plugin s � � z PluginApiMixin.create_pluginc C �, | � d|�}| j|d|id�}| �|� dS )aP Disable an installed plugin. Args: name (string): The name of the plugin. The ``:latest`` tag is optional, and is the default if omitted. force (bool): To enable the force query parameter. Returns: ``True`` if successful z/plugins/{0}/disable�force�r T�r r! r �r r r& r r r r r �disable_plugin5 s z PluginApiMixin.disable_plugin� c C s0 | � d|�}d|i}| j||d�}| �|� dS )aV Enable an installed plugin. Args: name (string): The name of the plugin. The ``:latest`` tag is optional, and is the default if omitted. timeout (int): Operation timeout (in seconds). Default: 0 Returns: ``True`` if successful z/plugins/{0}/enable�timeoutr' Tr( )r r r, r r r r r r � enable_pluginG s z PluginApiMixin.enable_pluginc C s | � d|�}| �| �|�d�S )a Retrieve plugin metadata. Args: name (string): The name of the plugin. The ``:latest`` tag is optional, and is the default if omitted. Returns: A dict containing plugin info z/plugins/{0}/jsonT�r �_result�_get)r r r r r r �inspect_pluginZ s z PluginApiMixin.inspect_pluginNc C st | � d�}d|i}|r||d< i }t�|�\}}t�| |�} | r$| |d< | j||||dd�} | �| � | j| dd�S )a Pull and install a plugin. After the plugin is installed, it can be enabled using :py:meth:`~enable_plugin`. Args: remote (string): Remote reference for the plugin to install. The ``:latest`` tag is optional, and is the default if omitted. privileges (:py:class:`list`): A list of privileges the user consents to grant to the plugin. Can be retrieved using :py:meth:`~plugin_privileges`. name (string): Local name for the pulled plugin. The ``:latest`` tag is optional, and is the default if omitted. Returns: An iterable object streaming the decoded API logs z /plugins/pull�remoter �X-Registry-AuthT�r �headersr �stream��decode�r r �resolve_repository_name�get_config_headerr r �_stream_helper) r r2 � privilegesr r r r5 �registry� repo_name�header�responser r r � pull_plugini s � � zPluginApiMixin.pull_pluginc C s | � d�}| �| �|�d�S )z� Retrieve a list of installed plugins. Returns: A list of dicts, one per plugin z/pluginsTr. )r r r r r �plugins� s zPluginApiMixin.pluginsc C sT d|i}i }t �|�\}}t �| |�}|r||d< | �d�}| �| j|||d�d�S )al Retrieve list of privileges to be granted to a plugin. Args: name (string): Name of the remote plugin to examine. The ``:latest`` tag is optional, and is the default if omitted. Returns: A list of dictionaries representing the plugin's permissions r2 r3 z/plugins/privileges)r r5 T)r r: r; r r/ r0 )r r r r5 r> r? r@ r r r r �plugin_privileges� s � �z PluginApiMixin.plugin_privilegesc C s\ | � d|�}i }t�|�\}}t�| |�}|r||d< | j||d�}| �|� | j|dd�S )a Push a plugin to the registry. Args: name (string): Name of the plugin to upload. The ``:latest`` tag is optional, and is the default if omitted. Returns: ``True`` if successful z/plugins/{0}/pullr3 )r5 Tr7 )r r r: r; r! r r< )r r r r5 r> r? r@ r r r r � push_plugin� s zPluginApiMixin.push_pluginc C r% )a� Remove an installed plugin. Args: name (string): Name of the plugin to remove. The ``:latest`` tag is optional, and is the default if omitted. force (bool): Disable the plugin before removing. This may result in issues if the plugin is in use by a container. Returns: ``True`` if successful z /plugins/{0}r& r' T)r �_deleter r) r r r � remove_plugin� s z PluginApiMixin.remove_pluginz1.26c C sj | � d|�}d|i}i }t�|�\}}t�| |�} | r | |d< | j||||dd�} | �| � | j| dd�S )a� Upgrade an installed plugin. Args: name (string): Name of the plugin to upgrade. The ``:latest`` tag is optional and is the default if omitted. remote (string): Remote reference to upgrade to. The ``:latest`` tag is optional and is the default if omitted. privileges (:py:class:`list`): A list of privileges the user consents to grant to the plugin. Can be retrieved using :py:meth:`~plugin_privileges`. Returns: An iterable object streaming the decoded API logs z/plugins/{0}/upgrader2 r3 Tr4 r7 r9 ) r r r2 r= r r r5 r> r? r@ rA r r r �upgrade_plugin� s � � z PluginApiMixin.upgrade_plugin)F)r+ )N)�__name__� __module__� __qualname__r �minimum_version�check_resourcer r$ r* r- r1 rB rC rD rE rG rH r r r r r s6 % r N)� r r r r r r r �<module> s __pycache__/service.cpython-310.pyc 0000644 00000033502 15027743616 0013133 0 ustar 00 o �hK � @ sB d dl mZmZmZ d dlmZ dd� Zdd� ZG dd� d�Zd S ) � )�auth�errors�utils)� ServiceModec C sD dd� }|d urAt �| d�r d|v r|dd� d|v r |dd� t �| d�r2|�d �d kr2|d d� t �| d �rAd |v rA|dd � |d ur_t �| d�rP|dd� t �| d �r_d |v r_|dd � |d ur}t �| d�r}d|v r}tdd� |d D ��r}|dd� |d u�r�d|v r�t �| d�r�|dd� |�d�r�t �| d�r�|d �d�r�|dd� t �| d �r�|d �d �r�|d d � |�d ��r~|�d �}t �| d��r|�d �r�|d!d� |�d"�d ur�|d#d� |�d$�d ur�|d%d� |�d&�d ur�|d'd� |�d(�d u�r|d)d� |�d*�d u�r|d+d� t �| d��r5|�d,�d u�r(|d)d� |�d-�d u�r5|d.d� t �| d��rV|�d/�d u�rI|d0d� |�d1�d u�rV|d2d� t �| d3��rj|�d4�d u�rj|d5d3� t �| d6��r~|�d7�d u�r~|d8d6� |�d9��r�t �| d��r�|d9 �d:��r�|d;d� d S d S d S d S d S )<Nc S s t �| � d|� ���)Nz# is not supported in API version < )r �InvalidVersion)�param� min_version� r �H/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/service.py�raise_version_error s �z0_check_api_features.<locals>.raise_version_error�1.25�MaxFailureRatioz UpdateConfig.max_failure_ratio�MonitorzUpdateConfig.monitorz1.28� FailureAction�rollbackz$UpdateConfig.failure_action rollback�1.29�OrderzUpdateConfig.order�rollback_configzRollbackConfig.orderz1.32�Portsc s s � | ]}|� d �V qdS )� PublishModeN)�get)�.0�pr r r � <genexpr>( s � z&_check_api_features.<locals>.<genexpr>zEndpointSpec.Ports[].mode� ForceUpdate� force_update� Placementz1.30� PlatformszPlacement.platformsz1.27� PreferenceszPlacement.preferences� ContainerSpec�TTYzContainerSpec.tty�HostnamezContainerSpec.hostname�HostszContainerSpec.hosts�GroupszContainerSpec.groups� DNSConfigzContainerSpec.dns_config� HealthcheckzContainerSpec.healthcheck�ReadOnly� StopSignalzContainerSpec.stop_signal�ConfigszContainerSpec.configs� PrivilegeszContainerSpec.privilegesz1.35� IsolationzContainerSpec.isolationz1.38�InitzContainerSpec.init� Resources�GenericResourceszResources.generic_resources)r � version_ltr �any)�version� task_template� update_config� endpoint_specr r �container_specr r r �_check_api_features s� � � �2r5 c C sz | � � }|d ur;|�� D ].\}}|dkr2d|vr i |d< |d �� D ]\}}|d ur0||d |< q"q |d ur:|||< q |S )Nr )�copy�items)�current�override�merged�ts_key�ts_value�cs_key�cs_valuer r r �_merge_task_templatec s ���r? c @ s� e Zd Ze�d� ddd��Ze�d�e�d�ddd���Ze�d�e�d�d d � ��Ze�d�e�d�d d � ��Z e�d�dd d��Z e�d�e�d� d dd���Z e�d�ddd��Z e�d�e�d� d dd���Z dS ) �ServiceApiMixinz1.24Nc C s� t | j|||| � | �d�} i } |�di ��dd�} | du r#t�d��|r.t|t�s.t|�}t � | �\} }t � | | �}|rA|| d< t � | jd�rP|pO|�dd�}||||t �|�|d �}|durd||d < | durl| |d < | �| j| || d �d �S )a Create a service. Args: task_template (TaskTemplate): Specification of the task to start as part of the new service. name (string): User-defined name for the service. Optional. labels (dict): A map of labels to associate with the service. Optional. mode (ServiceMode): Scheduling mode for the service (replicated or global). Defaults to replicated. 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`` networks (:py:class:`list`): List of network names or IDs or :py:class:`~docker.types.NetworkAttachmentConfig` to attach the service to. Default: ``None``. endpoint_spec (EndpointSpec): Properties that can be configured to access and load balance a service. Default: ``None``. Returns: A dictionary containing an ``ID`` key for the newly created service. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/services/creater �ImageNz,Missing mandatory Image key in ContainerSpec�X-Registry-Authr �Networks)�Name�Labels� TaskTemplate�ModerC � EndpointSpec� UpdateConfig�RollbackConfig)�data�headersT)r5 �_version�_urlr r �DockerException� isinstance�dictr r �resolve_repository_name�get_config_headerr r. �pop�convert_service_networks�_result� _post_json)�selfr1 �name�labels�moder2 �networks�endpoint_configr3 r �urlrL �image�registry� repo_name� auth_headerrK r r r �create_services sB $ � � � �z ServiceApiMixin.create_service�servicec C sN | � d|�}i }|dur t�| jd�rt�d��||d< | �| j||d�d�S )a� Return information about a service. Args: service (str): Service name or ID. insert_defaults (boolean): If true, default values will be merged into the service inspect output. Returns: (dict): A dictionary of the server-side representation of the service, including all relevant properties. Raises: :py:class:`docker.errors.APIError` If the server returns an error. � /services/{0}Nr z6insert_defaults is not supported in API version < 1.29�insertDefaults��paramsT)rN r r. rM r r rV �_get)rX rd �insert_defaultsr^ rh r r r �inspect_service� s �z ServiceApiMixin.inspect_service�taskc C s | � d|�}| �| �|�d�S )a Retrieve information about a task. Args: task (str): Task ID Returns: (dict): Information about the task. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z /tasks/{0}T)rN rV ri )rX rl r^ r r r � inspect_task� s z ServiceApiMixin.inspect_taskc C s$ | � d|�}| �|�}| �|� dS )a Stop and remove a service. Args: service (str): Service name or ID Returns: ``True`` if successful. Raises: :py:class:`docker.errors.APIError` If the server returns an error. re T)rN �_delete�_raise_for_status)rX rd r^ �respr r r �remove_service� s z ServiceApiMixin.remove_servicec C s^ d|rt �|�ndi}|dur t �| jd�rt�d��||d< | �d�}| �| j||d�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: A list of dictionaries containing data about each service. Raises: :py:class:`docker.errors.APIError` If the server returns an error. �filtersNz1.41z-status is not supported in API version < 1.41�statusz /servicesrg T) r �convert_filtersr. rM r r rN rV ri )rX rr rs rh r^ r r r �services s �� zServiceApiMixin.servicesr F� �allc C sd |||||||d�} | � d|�} | j| | dd�} | du r+| �|�d d d �d d �} | �d| | �S ) ar Get log stream for a service. Note: This endpoint works only for services with the ``json-file`` or ``journald`` logging drivers. Args: service (str): ID or name of the service 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`` is_tty (bool): Whether the service's :py:class:`ContainerSpec` enables the TTY option. If omitted, the method will query the Engine for the information, causing an additional roundtrip. Returns (generator): Logs for the service. )�details�follow�stdout�stderr�since� timestamps�tailz/services/{0}/logsT)rh �streamN�SpecrF r r F)rN ri rk r �_get_result_tty) rX rd rx ry rz r{ r| r} r~ �is_ttyrh r^ �resr r r � service_logs% s. !� �����z ServiceApiMixin.service_logsc C s6 d|rt �|�ndi}| �d�}| �| j||d�d�S )a� Retrieve a list of tasks. Args: filters (dict): A map of filters to process on the tasks list. Valid filters: ``id``, ``name``, ``service``, ``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. rr Nz/tasksrg T)r rt rN rV ri )rX rr rh r^ r r r �tasksW s � zServiceApiMixin.tasksc C sL t | j||| | � | r d} t�| jd�rd} | j|| d�d }ni }| �d|�}i }i }|du r5|�d�n||d< |du rB|�d�n||d< |durXt|t�sSt |�}||d < n|�d �|d < t |�d i �|�|d < |d �d i �}|�d d�}|dur�t � |�\}}t � | |�}|r�||d < |dur�||d< n|�d�|d< | dur�| |d< n|�d�|d< |dur�t�|�}t�| jd�r�||d< n?||d d< n8t�| jd�r�|�d�|d< n)|d �d�du �r|�d i �}|�d�}|du r�|�d�}|du�r||d d< | du�r | |d< n|�d�|d< | j||d|i|d�}| j|dd�S )a� Update a service. Args: service (string): A service identifier (either its name or service ID). version (int): The version number of the service object being updated. This is required to avoid conflicting writes. task_template (TaskTemplate): Specification of the updated task to start as part of the service. name (string): New name for the service. Optional. labels (dict): A map of labels to associate with the service. Optional. mode (ServiceMode): Scheduling mode for the service (replicated or global). Defaults to replicated. 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`` networks (:py:class:`list`): List of network names or IDs or :py:class:`~docker.types.NetworkAttachmentConfig` to attach the service to. Default: ``None``. endpoint_spec (EndpointSpec): Properties that can be configured to access and load balance a service. Default: ``None``. fetch_current_spec (boolean): Use the undefined settings from the current specification of the service. Default: ``False`` Returns: A dictionary containing a ``Warnings`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Tr N)rj r� z/services/{0}/updaterD rE rG rF r rA rB rI rJ r rC rH r0 )rK rh rL )�json)r5 rM r r. rk rN r rP rQ r r? r rR rS rU rW rV )rX rd r0 r1 rY rZ r[ r2 r\ r] r3 �fetch_current_specr �inspect_defaultsr8 r^ rK rL r4 r_ r` ra rb �converted_networks�current_task_template�current_networksrp r r r �update_serviceo sz * ��� � �z ServiceApiMixin.update_service)NNNNNNNN)N)NN)FFFFrv Frw N) NNNNNNNNFN)�__name__� __module__� __qualname__r �minimum_versionrc �check_resourcerk rm rq ru r� r� r� r r r r r@ r sB �K �0 �r@ N) � r r r �typesr r5 r? r@ r r r r �<module> s ^ __pycache__/secret.cpython-310.pyc 0000644 00000006012 15027743616 0012754 0 ustar 00 o �h5 � @ s* d dl Z ddlmZmZ G dd� d�ZdS )� N� )�errors�utilsc @ sl e Zd Ze�d�d dd��Ze�d�e�d�dd� ��Ze�d�e�d�dd � ��Ze�d�d d d ��Z dS )�SecretApiMixinz1.25Nc C s| t |t�s |�d�}t�|�}|�d�}|||d�}|dur.t�| jd�r*t � d��||d< | � d�}| � | j ||d �d �S ) a� Create a secret Args: name (string): Name of the secret data (bytes): Secret data to be stored labels (dict): A mapping of labels to assign to the secret driver (DriverConfig): A custom driver configuration. If unspecified, the default ``internal`` driver will be used Returns (dict): ID of the newly created secret zutf-8�ascii)�Data�Name�LabelsNz1.31z6Secret driver is only available for API version > 1.31�Driverz/secrets/create)�dataT)� isinstance�bytes�encode�base64� b64encode�decoder � version_lt�_versionr �InvalidVersion�_url�_result� _post_json)�self�namer �labels�driver�body�url� r �G/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/secret.py� create_secret s$ �� �z SecretApiMixin.create_secret�idc C s | � d|�}| �| �|�d�S )a2 Retrieve secret metadata Args: id (string): Full ID of the secret to inspect Returns (dict): A dictionary of metadata Raises: :py:class:`docker.errors.NotFound` if no secret with that ID exists � /secrets/{0}T)r r �_get)r r! r r r r �inspect_secret- s z SecretApiMixin.inspect_secretc C s$ | � d|�}| �|�}| �|� dS )a% Remove a secret Args: id (string): Full ID of the secret to remove Returns (boolean): True if successful Raises: :py:class:`docker.errors.NotFound` if no secret with that ID exists r" T)r �_delete�_raise_for_status)r r! r �resr r r � remove_secret? s z SecretApiMixin.remove_secretc C s6 | � d�}i }|rt�|�|d< | �| j||d�d�S )z� List secrets Args: filters (dict): A map of filters to process on the secrets list. Available filters: ``names`` Returns (list): A list of secrets z/secrets�filters)�paramsT)r r �convert_filtersr r# )r r) r r* r r r �secretsS s zSecretApiMixin.secrets)NN)N) �__name__� __module__� __qualname__r �minimum_versionr �check_resourcer$ r( r, r r r r r s % r )r � r r r r r r r �<module> s __pycache__/exec_api.cpython-310.pyc 0000644 00000012717 15027743616 0013255 0 ustar 00 o �hB � @ s. d dl mZmZ d dlmZ G dd� d�ZdS )� )�errors�utils)�CancellableStreamc @ sP e Zd Ze�d� ddd��Zdd � Zdd d �Ze�d � dd d��ZdS )� ExecApiMixin� containerTF� Nc C s� | durt �| jd�rt�d��t|t�rt �|�}t| t�r%t j � | �} ||||||||| d� } | durEt �| jd�rAt�d��| | d< | rL| | d< n d| j v rX| j d | d< | � d |�} | j | | d �}| � |d �S ) aC Sets up an exec instance in a running container. Args: container (str): Target container where exec instance will be created 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 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 detach_keys (str): Override the key sequence for detaching a container. Format is a single character `[a-Z]` or `ctrl-<value>` where `<value>` is one of: `a-z`, `@`, `^`, `[`, `,` or `_`. ~/.docker/config.json is used by default. Returns: (dict): A dictionary with an exec ``Id`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Nz1.25z;Setting environment for exec is not supported in API < 1.25) � Container�User� Privileged�Tty� AttachStdin� AttachStdout� AttachStderr�Cmd�Envz1.35z/workdir is not supported for API version < 1.35� WorkingDir� detachKeysz/containers/{0}/exec)�dataT)r � version_lt�_versionr �InvalidVersion� isinstance�str� split_command�dict�format_environment�_general_configs�_url� _post_json�_result)�selfr �cmd�stdout�stderr�stdin�tty� privileged�user� environment�workdir� detach_keysr �url�res� r- �I/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/exec_api.py� exec_create s> #� � � zExecApiMixin.exec_createc C s2 t |t�r |�d�}| �| �d|��}| �|d�S )aL Return low-level information about an exec command. Args: exec_id (str): ID of the exec instance Returns: (dict): Dictionary of values returned by the endpoint. Raises: :py:class:`docker.errors.APIError` If the server returns an error. �Idz/exec/{0}/jsonT)r r �get�_getr r )r �exec_idr, r- r- r. � exec_inspectP s zExecApiMixin.exec_inspectc C sF t |t�r |�d�}||d�}| �d|�}| j||d�}| �|� dS )z� Resize the tty session used by the specified exec command. Args: exec_id (str): ID of the exec instance height (int): Height of tty session width (int): Width of tty session r0 )�h�wz/exec/{0}/resize)�paramsN)r r r1 r �_post�_raise_for_status)r r3 �height�widthr7 r+ r, r- r- r. � exec_resizec s zExecApiMixin.exec_resizer3 c C s� ||d�}|r i nddd�}| j | �d|�||dd�} |r-z | �| �W | �� S | �� w |r4| �| �S | j| |||d�} |rDt| | �S | S ) a? Start a previously set up exec instance. Args: exec_id (str): ID of the exec instance detach (bool): If true, detach from the exec command. Default: False tty (bool): Allocate a pseudo-TTY. Default: False stream (bool): Return response data progressively as an iterator of strings, rather than a single string. socket (bool): Return the connection socket to allow custom read/write operations. Must be closed by the caller when done. demux (bool): Return stdout and stderr separately Returns: (generator or str or tuple): If ``stream=True``, a generator yielding response chunks. If ``socket=True``, a socket object for the connection. A string containing response data otherwise. If ``demux=True``, a tuple with two elements of type byte: stdout and stderr. Raises: :py:class:`docker.errors.APIError` If the server returns an error. )r �Detach�Upgrade�tcp)� Connectionr> z/exec/{0}/startT)�headersr �stream)r% �demux)r r r �close�_get_raw_response_socket�_read_from_socketr ) r r3 �detachr% rB �socketrC r rA r, �outputr- r- r. � exec_startu s. �� � zExecApiMixin.exec_start) TTFFFr NNN)NN)FFFFF) �__name__� __module__� __qualname__r �check_resourcer/ r4 r< rJ r- r- r- r. r s �I �r N)r r r �typesr r r- r- r- r. �<module> s __pycache__/daemon.cpython-310.pyc 0000644 00000012612 15027743616 0012735 0 ustar 00 o �hx � @ s: d dl Z d dlmZ ddlmZmZmZ G dd� d�ZdS )� N)�datetime� )�auth�types�utilsc @ sP e Zd Ze�d�dd� �Zddd�Zdd� Z dd d �Zd d � Z ddd�Z dS )�DaemonApiMixinz1.25c C s | � d�}| �| �|�d�S )a( Get data usage information. Returns: (dict): A dictionary representing different resource categories and their respective data usage. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z /system/dfT��_url�_result�_get)�self�url� r �G/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/daemon.py�df s zDaemonApiMixin.dfNc C sx t |t�r t�|�}t |t�rt�|�}|rt�|�}|||d�}| �d�}| j||ddd�}| j||d�}t� ||�S )ar Get real-time events from the server. Similar to the ``docker events`` command. Args: since (UTC datetime or int): Get events from this point until (UTC datetime or int): Get events until this point filters (dict): Filter the events by event time, container or image decode (bool): If set to true, stream will be decoded into dicts on the fly. False by default. Returns: A :py:class:`docker.types.daemon.CancellableStream` generator Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> for event in client.events(decode=True) ... print(event) {u'from': u'image/with:tag', u'id': u'container-id', u'status': u'start', u'time': 1423339459} ... or >>> events = client.events() >>> for event in events: ... print(event) >>> # and cancel from another thread >>> events.close() )�since�until�filtersz/eventsTN)�params�stream�timeout)�decode) � isinstancer r �datetime_to_timestamp�convert_filtersr r �_stream_helperr �CancellableStream) r r r r r r r �responser r r r �events s & � zDaemonApiMixin.eventsc C s | � | �| �d��d�S )a Display system-wide information. Identical to the ``docker info`` command. Returns: (dict): The info as a dict Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/infoT�r r r �r r r r �infoS s zDaemonApiMixin.infoFc C s� |rt j�|�rtj|| jd�| _n| jr| jjr!tj| jd�| _| j�|�}|r5|� dd�|kr5|s5|S ||||d�}| j | � d�|d�} | j dkrU| j� |pRtj|� | j| dd �S ) a^ Authenticate with a registry. Similar to the ``docker login`` command. Args: username (str): The registry username password (str): The plaintext password email (str): The email for the registry account registry (str): URL to the registry. E.g. ``https://index.docker.io/v1/`` reauth (bool): Whether or not to refresh existing authentication on the Docker server. dockercfg_path (str): Use a custom path for the Docker config file (default ``$HOME/.docker/config.json`` if present, otherwise ``$HOME/.dockercfg``) Returns: (dict): The response from the login request Raises: :py:class:`docker.errors.APIError` If the server returns an error. )� credstore_env�usernameN)r# �password�email� serveraddressz/auth)�data�� T��json)�os�path�existsr � load_configr" � _auth_configs�is_empty�resolve_authconfig�get� _post_jsonr � status_code�add_auth� INDEX_NAMEr ) r r# r$ r% �registry�reauth�dockercfg_path�authcfg�req_datar r r r �logina s, �� �� zDaemonApiMixin.loginc C s | � | �| �d���dkS )a! Checks the server is responsive. An exception will be raised if it isn't responding. Returns: (bool) The response from the server. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/_ping�OKr r r r r �ping� s zDaemonApiMixin.pingTc C s" | j d|d�}| j| �|�dd�S )a& Returns version information from the server. Similar to the ``docker version`` command. Returns: (dict): The server version information Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/version)� versioned_apiTr) r )r � api_versionr r r r �version� s zDaemonApiMixin.version)NNNN)NNNFN)T) �__name__� __module__� __qualname__r �minimum_versionr r r! r< r> rA r r r r r s ; �9r )r+ r � r r r r r r r r �<module> s __pycache__/build.cpython-310.pyc 0000644 00000027760 15027743616 0012603 0 ustar 00 o �h�> � @ s\ d dl Z d dlZd dlZd dlZddlmZmZmZmZ e� e �Z G dd� d�Z dd� Z dS )� N� )�auth� constants�errors�utilsc @ sB e Zd Z d dd�Ze�d�d dd��Zd d � ZdS ) � BuildApiMixinNFTc ( C s d }} i } | p i } |p i }|du r|du rt d��|r%| dur%t�d��|dur7t�|�s7t�d|� d���| �� D ]} | tjvrKt�d|� d���q;|rW|sTt d��|} ne|durat�|�} n[|� d�ri|}nSt j � |�sst d��t j � |d �} d} t j �| �r�t| ��}!ttd d � d d � |!�� �� D ���} W d � n1 s�w Y t| |�} tj|| | |d�} |r�dn| } | �d�}"|||||| | | d�}#|#�| � |r�| j�� }$|$�� D ] \}%}&|�|%|&� q�|r�|#�dt � |�i� |�r t� | j d��r|#�d|i� nt� d��|�r&t� | j d��r!|#�dt � |�i� nt� d��|�rAt� | j d��r<|#�dt � |�i� nt� d��|�rYt� | j d ��rT|#�d |i� nt� d ��|�rqt� | j d��rl|#�d |i� nt� d ��|�r�t� | j d��r�|#�d!|i� nt� d"��|du�r�t�!| j d#��r�t� d$��t"|t#��r�t�$|�}|#�d%|i� |du�r�t�!| j d&��r�t� d'��||#d(< |du�r�t�!| j d)��r�t� d*��||#d+< | du�r�d,d-i} | �r�| | d.< | �%| � | j&|"| |#| d/|d0�}'| du�r|�s| �'� | j(|'|d1�S )2a� Similar to the ``docker build`` command. Either ``path`` or ``fileobj`` needs to be set. ``path`` can be a local path (to a directory containing a Dockerfile) or a remote URL. ``fileobj`` must be a readable file-like object to a Dockerfile. If you have a tar file for the Docker build context (including a Dockerfile) already, pass a readable file-like object to ``fileobj`` and also pass ``custom_context=True``. If the stream is compressed also, set ``encoding`` to the correct value (e.g ``gzip``). Example: >>> from io import BytesIO >>> from docker import APIClient >>> dockerfile = ''' ... # Shared Volume ... FROM busybox:buildroot-2014.02 ... VOLUME /data ... CMD ["/bin/sh"] ... ''' >>> f = BytesIO(dockerfile.encode('utf-8')) >>> cli = APIClient(base_url='tcp://127.0.0.1:2375') >>> response = [line for line in cli.build( ... fileobj=f, rm=True, tag='yourname/volume' ... )] >>> response ['{"stream":" ---\u003e a9eb17255234\n"}', '{"stream":"Step 1 : VOLUME /data\n"}', '{"stream":" ---\u003e Running in abdc1e6896c6\n"}', '{"stream":" ---\u003e 713bca62012e\n"}', '{"stream":"Removing intermediate container abdc1e6896c6\n"}', '{"stream":"Step 2 : CMD [\"/bin/sh\"]\n"}', '{"stream":" ---\u003e Running in dba30f2a1a7e\n"}', '{"stream":" ---\u003e 032b8b2855fc\n"}', '{"stream":"Removing intermediate container dba30f2a1a7e\n"}', '{"stream":"Successfully built 032b8b2855fc\n"}'] 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 gzip (bool): If set to ``True``, gzip compression/encoding is used 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"`` decode (bool): If set to ``True``, the returned stream will be decoded into dicts on the fly. Default ``False`` 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 (:py:class:`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: A generator for the build output. Raises: :py:class:`docker.errors.APIError` If the server returns an error. ``TypeError`` If neither ``path`` nor ``fileobj`` is specified. Nz,Either path or fileobj needs to be provided.z.Can not use custom encoding if gzip is enabledz invalid tag 'z': invalid reference formatz,You must specify fileobj with custom_context)zhttp://zhttps://zgit://z github.com/zgit@z-You must specify a directory to build in pathz .dockerignorec S s | dko | d dkS )N� r �#� )�xr r �F/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/build.py�<lambda>� � z%BuildApiMixin.build.<locals>.<lambda>c S s g | ]}|� � �qS r )�strip)�.0�liner r r � <listcomp>� r z'BuildApiMixin.build.<locals>.<listcomp>)�exclude� dockerfile�gzipr z/build)�t�remote�q�nocache�rm�forcerm�pullr � buildargsz1.22�shmsizez/shmsize was only introduced in API version 1.22z1.23�labelsz.labels was only introduced in API version 1.23z1.25� cachefromz2cache_from was only introduced in API version 1.25z1.29�targetz.target was only introduced in API version 1.29� networkmodez4network_mode was only introduced in API version 1.25�squashz.squash was only introduced in API version 1.25z1.27z3extra_hosts was only introduced in API version 1.27� extrahostsz1.32z0platform was only introduced in API version 1.32�platformz1.24z1isolation was only introduced in API version 1.24� isolationz Content-Typezapplication/tarzContent-EncodingT)�data�params�headers�stream�timeout)�decode))� TypeErrorr �DockerExceptionr � match_tag�keysr �CONTAINER_LIMITS_KEYS�mkbuildcontext� startswith�os�path�isdir�join�exists�open�list�filter�read� splitlines�process_dockerfile�tar�_url�update�_proxy_configs�get_environment�items� setdefault�json�dumps� version_gte�_version�InvalidVersion� version_lt� isinstance�dict�format_extra_hosts�_set_auth_headers�_post�close�_stream_helper)(�selfr5 �tag�quiet�fileobjr r r+ �custom_context�encodingr r r �container_limitsr, r r r r � cache_fromr! � network_moder# � extra_hostsr% r& �use_config_proxyr �contextr) �key� dockerignorer �f�ur( � proxy_args�k�v�responser r r �build s j � � �� � � � � ������ � � � � zBuildApiMixin.buildz1.31c C s� | � d�}|||fdkrt�| jd�rt�d��i }|dur%t�|�|d< |dur-||d< |dur5||d< | �| j||d �d �S ) a/ Delete the builder cache Args: filters (dict): Filters to process on the prune list. Needs Docker API v1.39+ Available filters: - dangling (bool): When set to true (or 1), prune only unused and untagged images. - until (str): Can be Unix timestamps, date formatted timestamps, or Go duration strings (e.g. 10m, 1h30m) computed relative to the daemon's local time. keep_storage (int): Amount of disk space in bytes to keep for cache. Needs Docker API v1.39+ all (bool): Remove all types of build cache. Needs Docker API v1.39+ Returns: (dict): A dictionary containing information about the operation's result. The ``SpaceReclaimed`` key indicates the amount of bytes of disk space reclaimed. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z /build/prune�NNNz1.39zS`filters`, `keep_storage`, and `all` args are only available for API version > 1.38N�filtersz keep-storage�all)r( T) r@ r rK rI r rJ �convert_filters�_resultrP )rS ri � keep_storagerj �urlr( r r r � prune_builds s ��zBuildApiMixin.prune_buildsc C s� t �d� | jr | jjrt �d� tj| jd�| _| jrP| j�� }tj|vr5tj |v r5|� tj i �|tj< t �dd� dd� |D ��� |rNt� |�|d< d S d S t �d � d S ) NzLooking for auth configz2No auth config in memory - loading from filesystem)� credstore_envzSending auth config (%s)z, c s s � | ]}t |�V qd S )N)�repr)r rd r r r � <genexpr>X s � z2BuildApiMixin._set_auth_headers.<locals>.<genexpr>zX-Registry-ConfigzNo auth config found) �log�debug� _auth_configs�is_emptyr � load_configrp �get_all_credentials� INDEX_URL� INDEX_NAME�getr7 � encode_header)rS r) � auth_datar r r rO A s* � � ��z BuildApiMixin._set_auth_headers)NNFNFFNFNFFNNFNFNNNNNNNNNTrh )�__name__� __module__� __qualname__rg r �minimum_versionro rO r r r r r s � +r c C s� | sdS | }t j�| �s0t j�|| �}tjr0|�tj�r0t j�|t tj�d � �}tj� |� �}t j� |�d t j� |�d ksJt j� ||��d�rkt |��}dt �d�d��|�� fW d � S 1 sfw Y | |krvt j� ||�} | d fS )N)NNr z..z .dockerfile.� r )r4 r5 �isabsr7 r �IS_WINDOWS_PLATFORMr3 �WINDOWS_LONGPATH_PREFIX�normpath�len� splitdrive�relpathr9 �random� getrandbitsr< )r r5 �abs_dockerfiler� �dfr r r r> c s. �� � � �r> )rF �loggingr4 r� r r r r r � getLoggerr~ rs r r> r r r r �<module> s Z __pycache__/config.cpython-310.pyc 0000644 00000005646 15027743616 0012750 0 ustar 00 o �h� � @ s& d dl Z ddlmZ G dd� d�ZdS )� N� )�utilsc @ sl e Zd Ze�d�d dd��Ze�d�e�d�dd� ��Ze�d�e�d�dd � ��Ze�d�d d d ��Z dS )�ConfigApiMixinz1.30Nc C sV t |t�s |�d�}t�|�}|�d�}||||d�}| �d�}| �| j||d�d�S )a Create a config Args: name (string): Name of the config data (bytes): Config data to be stored labels (dict): A mapping of labels to assign to the config templating (dict): dictionary containing the name of the templating driver to be used expressed as { name: <templating_driver_name>} Returns (dict): ID of the newly created config zutf-8�ascii)�Data�Name�Labels� Templatingz/configs/create)�dataT) � isinstance�bytes�encode�base64� b64encode�decode�_url�_result� _post_json)�self�namer �labels� templating�body�url� r �G/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/config.py� create_config s � �z ConfigApiMixin.create_config�idc C s | � d|�}| �| �|�d�S )a2 Retrieve config metadata Args: id (string): Full ID of the config to inspect Returns (dict): A dictionary of metadata Raises: :py:class:`docker.errors.NotFound` if no config with that ID exists � /configs/{0}T)r r �_get)r r r r r r �inspect_config' s z ConfigApiMixin.inspect_configc C s$ | � d|�}| �|�}| �|� dS )a% Remove a config Args: id (string): Full ID of the config to remove Returns (boolean): True if successful Raises: :py:class:`docker.errors.NotFound` if no config with that ID exists r T)r �_delete�_raise_for_status)r r r �resr r r � remove_config9 s z ConfigApiMixin.remove_configc C s6 | � d�}i }|rt�|�|d< | �| j||d�d�S )z� List configs Args: filters (dict): A map of filters to process on the configs list. Available filters: ``names`` Returns (list): A list of configs z/configs�filters)�paramsT)r r �convert_filtersr r )r r% r r& r r r �configsM s zConfigApiMixin.configs)NN)N) �__name__� __module__� __qualname__r �minimum_versionr �check_resourcer r$ r( r r r r r s r )r � r r r r r r �<module> s __pycache__/container.cpython-310.pyc 0000644 00000135641 15027743616 0013464 0 ustar 00 o �hj� � @ sV d dl m Z ddlmZmZ ddlmZ ddlmZmZm Z m Z m Z G dd� d�Z dS ) � )�datetime� )�errors�utils)�DEFAULT_DATA_CHUNK_SIZE)�CancellableStream�ContainerConfig�EndpointConfig� HostConfig�NetworkingConfigc @ sV e Zd Ze�d� dHdd��Ze�d�dIdd��Ze�d� dJd d ��Z dKd d �Z dLdd�Z dd� Z dMdd�Z dd� Z dd� Z dd� Ze�d�dd� �Ze�d�efd d ��Ze�d�edfd d ��Ze�d�d d!� �Ze�d�dNd"d#��Ze�d� dOd%d&��Ze�d�d'd(� �Ze�d�d)d*� �Ze�d�d+d,� �Ze�d-�dNd.d/��Ze�d�dPd0d1��Ze�d�d2d3� �Z e�d�d4d5� �Z e�d�dQd7d8��Z e�d�d9d:� �Z e�d�dRd;d<��Z e�d�dNd=d>��Z!e�d�dNd?d@��Z"e�d�dAdB� �Z#e�dC�e�d� dSdDdE���Z$e�d�dMdFdG��Z%dS )T�ContainerApiMixin� containerTFc C s� |rdpd|r dp d|rdpd|rdpdd�}ddd�}| � d|�} | j| ||dd �} | j| || �|�|d �} |r>t| | �S | S ) aI Attach to a container. The ``.logs()`` function is a wrapper around this method, which you can use instead if you want to fetch/stream container output without first retrieving the entire backlog. Args: container (str): The container to attach to. stdout (bool): Include stdout. stderr (bool): Include stderr. stream (bool): Return container output progressively as an iterator of strings, rather than a single string. logs (bool): Include the container's previous output. demux (bool): Keep stdout and stderr separate. Returns: By default, the container's output as a single string (two if ``demux=True``: one for stdout and one for stderr). If ``stream=True``, an iterator of output strings. If ``demux=True``, two iterators are returned: one for stdout and one for stderr. Raises: :py:class:`docker.errors.APIError` If the server returns an error. � r )�logs�stdout�stderr�stream�Upgrade�tcp�� Connectionr �/containers/{0}/attachT)�headers�paramsr )�demux)�_url�_post�_read_from_socket� _check_is_ttyr ) �selfr r r r r r r r �u�response�output� r# �J/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/container.py�attach s �� � zContainerApiMixin.attachNc C sz |du r dddd�}d|vrd| j v r| j d |d< |r"| �||�S ddd�}| �d|�}| �| j|d| �|�d |d ��S ) a& Like ``attach``, but returns the underlying socket-like object for the HTTP request. Args: container (str): The container to attach to. params (dict): Dictionary of request parameters (e.g. ``stdout``, ``stderr``, ``stream``). For ``detachKeys``, ~/.docker/config.json is used by default. ws (bool): Use websockets instead of raw HTTP. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Nr )r r r � detachKeysr r r r T�r r r )�_general_configs�_attach_websocketr �_get_raw_response_socket�post�_attach_params)r r r �wsr r r# r# r$ � attach_socketE s( � � ��z ContainerApiMixin.attach_socketc C s8 |||||||d�} | � d�} | j| j| || d�dd�S )a\ Commit a container to an image. Similar to the ``docker commit`` command. Args: container (str): The image hash of the container repository (str): The repository to push the image to tag (str): The tag to push message (str): A commit message author (str): The name of the author 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. )r �repo�tag�comment�author�pause�changesz/commit��datar T��json)r �_result� _post_json) r r � repositoryr0 �messager2 r3 r4 �confr r r# r# r$ �commitr s � �zContainerApiMixin.commit���c C s� |rdn||r dnd|rdnd|rdnd||d�} | r"t �| �| d< | �d�} | �| j| | d�d�} |r;dd � | D �S |rL| D ] } | d d d � | d < q?| S ) a6 List containers. Similar to the ``docker ps`` command. Args: quiet (bool): Only display numeric Ids all (bool): Show all containers. Only running containers are shown by default trunc (bool): Truncate output latest (bool): Show only the latest created container, include non-running ones. since (str): Show only containers created since Id or Name, include non-running ones before (str): Show only container created before Id or Name, include non-running ones limit (int): Show `limit` last created containers, include non-running ones size (bool): Display sizes filters (dict): Filters to be processed on the image list. Available filters: - `exited` (int): Only containers with specified exit code - `status` (str): One of ``restarting``, ``running``, ``paused``, ``exited`` - `label` (str|list): format either ``"key"``, ``"key=value"`` or a list of such. - `id` (str): The id of the container. - `name` (str): The name of the container. - `ancestor` (str): Filter by container ancestor. Format of ``<image-name>[:tag]``, ``<image-id>``, or ``<image@digest>``. - `before` (str): Only containers created before a particular container. Give the container name or id. - `since` (str): Only containers created after a particular container. Give container name or id. A comprehensive list can be found in the documentation for `docker ps <https://docs.docker.com/engine/reference/commandline/ps>`_. Returns: A list of dicts, one per container Raises: :py:class:`docker.errors.APIError` If the server returns an error. r r )�limit�all�size� trunc_cmd�since�before�filtersz/containers/json�r Tc S s g | ]}d |d i�qS )�Idr# )�.0�xr# r# r$ � <listcomp>� s z0ContainerApiMixin.containers.<locals>.<listcomp>rH N� )r �convert_filtersr r9 �_get)r �quietrA �trunc�latestrD rE r@ rB rF r r �resrJ r# r# r$ � containers� s" 2 � z ContainerApiMixin.containersc C s| t | t�r| g} t | t�rtj�| �} |r | j�| �p d} | �||||||||| | | | ||||||||||�}| �|| |�S )ar Creates a container. Parameters are similar to those for the ``docker run`` command except it doesn't support the attach options (``-a``). The arguments that are passed directly to this function are host-independent configuration options. Host-specific configuration is passed with the `host_config` argument. You'll normally want to use this method in combination with the :py:meth:`create_host_config` method to generate ``host_config``. **Port bindings** Port binding is done in two parts: first, provide a list of ports to open inside the container with the ``ports`` parameter, then declare bindings with the ``host_config`` parameter. For example: .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', ports=[1111, 2222], host_config=client.api.create_host_config(port_bindings={ 1111: 4567, 2222: None }) ) You can limit the host address on which the port will be exposed like such: .. code-block:: python client.api.create_host_config( port_bindings={1111: ('127.0.0.1', 4567)} ) Or without host port assignment: .. code-block:: python client.api.create_host_config(port_bindings={1111: ('127.0.0.1',)}) If you wish to use UDP instead of TCP (default), you need to declare ports as such in both the config and host config: .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', ports=[(1111, 'udp'), 2222], host_config=client.api.create_host_config(port_bindings={ '1111/udp': 4567, 2222: None }) ) To bind multiple host ports to a single container port, use the following syntax: .. code-block:: python client.api.create_host_config(port_bindings={ 1111: [1234, 4567] }) You can also bind multiple IPs to a single container port: .. code-block:: python client.api.create_host_config(port_bindings={ 1111: [ ('192.168.0.100', 1234), ('192.168.0.101', 1234) ] }) **Using volumes** Volume declaration is done in two parts. Provide a list of paths to use as mountpoints inside the container with the ``volumes`` parameter, and declare mappings from paths on the host in the ``host_config`` section. .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', volumes=['/mnt/vol1', '/mnt/vol2'], host_config=client.api.create_host_config(binds={ '/home/user1/': { 'bind': '/mnt/vol2', 'mode': 'rw', }, '/var/www': { 'bind': '/mnt/vol1', 'mode': 'ro', }, '/autofs/user1': { 'bind': '/mnt/vol3', 'mode': 'rw', 'propagation': 'shared' } }) ) You can alternatively specify binds as a list. This code is equivalent to the example above: .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', volumes=['/mnt/vol1', '/mnt/vol2', '/mnt/vol3'], host_config=client.api.create_host_config(binds=[ '/home/user1/:/mnt/vol2', '/var/www:/mnt/vol1:ro', '/autofs/user1:/mnt/vol3:rw,shared', ]) ) **Networking** You can specify networks to connect the container to by using the ``networking_config`` parameter. At the time of creation, you can only connect a container to a single networking, but you can create more connections by using :py:meth:`~connect_container_to_network`. For example: .. code-block:: python networking_config = client.api.create_networking_config({ 'network1': client.api.create_endpoint_config( ipv4_address='172.28.0.124', aliases=['foo', 'bar'], links=['container2'] ) }) ctnr = client.api.create_container( img, command, networking_config=networking_config ) Args: image (str): The image to run command (str or list): The command to be run in the container hostname (str): Optional hostname for the container user (str or int): Username or UID detach (bool): Detached mode: run container in the background and return container ID stdin_open (bool): Keep STDIN open even if not attached tty (bool): Allocate a pseudo-TTY ports (list of ints): A list of port numbers environment (dict or list): A dictionary or a list of strings in the following format ``["PASSWORD=xxx"]`` or ``{"PASSWORD": "xxx"}``. volumes (str or list): List of paths inside the container to use as volumes. network_disabled (bool): Disable networking name (str): A name for the container entrypoint (str or list): An entrypoint working_dir (str): Path to the working directory domainname (str): The domain name to use for the container host_config (dict): A dictionary created with :py:meth:`create_host_config`. mac_address (str): The Mac Address to assign the container labels (dict or list): A dictionary of name-value labels (e.g. ``{"label1": "value1", "label2": "value2"}``) or a list of names of labels to set with empty values (e.g. ``["label1", "label2"]``) stop_signal (str): The stop signal to use to stop the container (e.g. ``SIGINT``). stop_timeout (int): Timeout to stop the container, in seconds. Default: 10 networking_config (dict): A networking configuration generated by :py:meth:`create_networking_config`. runtime (str): Runtime to use with this container. healthcheck (dict): Specify a test to perform to check that the container is healthy. use_config_proxy (bool): If ``True``, and if the docker client configuration file (``~/.docker/config.json`` by default) contains a proxy configuration, the corresponding environment variables will be set in the container being created. platform (str): Platform in the format ``os[/arch[/variant]]``. Returns: A dictionary with an image 'Id' key and a 'Warnings' key. Raises: :py:class:`docker.errors.ImageNotFound` If the specified image does not exist. :py:class:`docker.errors.APIError` If the server returns an error. N) � isinstance�str�dictr �format_environment�_proxy_configs�inject_proxy_environment�create_container_config� create_container_from_config)r �image�command�hostname�user�detach� stdin_open�tty�ports� environment�volumes�network_disabled�name� entrypoint� working_dir� domainname� host_config� mac_address�labels� stop_signal�networking_config� healthcheck� stop_timeout�runtime�use_config_proxy�platform�configr# r# r$ �create_container� s( I ���z"ContainerApiMixin.create_containerc O � t | jg|�R i |��S �N)r �_version�r �args�kwargsr# r# r$ rZ � s z)ContainerApiMixin.create_container_configc C sR | � d�}d|i}|rt�| jd�rt�d��||d< | j|||d�}| �|d�S )Nz/containers/createrg �1.41z0platform is not supported for API version < 1.41rt r5 T)r r � version_ltry r �InvalidVersionr: r9 )r ru rg rt r r rR r# r# r$ r[ � s �� z.ContainerApiMixin.create_container_from_configc O s0 |si }d|v r t d��| j|d< t|i |��S )a| Create a dictionary for the ``host_config`` argument to :py:meth:`create_container`. Args: auto_remove (bool): enable auto-removal of the container on daemon side when the container's process exits. binds (dict): Volumes to bind. See :py:meth:`create_container` for more information. blkio_weight_device: Block IO weight (relative device weight) in the form of: ``[{"Path": "device_path", "Weight": weight}]``. blkio_weight: Block IO weight (relative weight), accepts a weight value between 10 and 1000. cap_add (list of str): Add kernel capabilities. For example, ``["SYS_ADMIN", "MKNOD"]``. cap_drop (list of str): Drop kernel capabilities. cpu_period (int): The length of a CPU period in microseconds. cpu_quota (int): Microseconds of CPU time that the container can get in a CPU period. cpu_shares (int): CPU shares (relative weight). cpuset_cpus (str): CPUs in which to allow execution (``0-3``, ``0,1``). cpuset_mems (str): Memory nodes (MEMs) in which to allow execution (``0-3``, ``0,1``). Only effective on NUMA systems. device_cgroup_rules (:py:class:`list`): A list of cgroup rules to apply to the container. device_read_bps: Limit read rate (bytes per second) from a device in the form of: `[{"Path": "device_path", "Rate": rate}]` device_read_iops: Limit read rate (IO per second) from a device. device_write_bps: Limit write rate (bytes per second) from a device. device_write_iops: Limit write rate (IO per second) from a device. devices (:py:class:`list`): Expose host devices to the container, as a list of strings in the form ``<path_on_host>:<path_in_container>:<cgroup_permissions>``. For example, ``/dev/sda:/dev/xvda:rwm`` allows the container to have read-write access to the host's ``/dev/sda`` via a node named ``/dev/xvda`` inside the container. device_requests (:py:class:`list`): Expose host resources such as GPUs to the container, as a list of :py:class:`docker.types.DeviceRequest` instances. dns (:py:class:`list`): Set custom DNS servers. dns_opt (:py:class:`list`): Additional options to be added to the container's ``resolv.conf`` file dns_search (:py:class:`list`): DNS search domains. extra_hosts (dict): Additional hostnames to resolve inside the container, as a mapping of hostname to IP address. group_add (:py:class:`list`): List of additional group names and/or IDs that the container process will run as. init (bool): Run an init inside the container that forwards signals and reaps processes ipc_mode (str): Set the IPC mode for the container. isolation (str): Isolation technology to use. Default: ``None``. links (dict): Mapping of links using the ``{'container': 'alias'}`` format. The alias is optional. Containers declared in this dict will be linked to the new container using the provided alias. Default: ``None``. log_config (LogConfig): Logging configuration lxc_conf (dict): LXC config. mem_limit (float or str): Memory limit. Accepts float values (which represent the memory limit of the created container in bytes) or a string with a units identification char (``100000b``, ``1000k``, ``128m``, ``1g``). If a string is specified without a units character, bytes are assumed as an mem_reservation (float or str): Memory soft limit. mem_swappiness (int): Tune a container's memory swappiness behavior. Accepts number between 0 and 100. memswap_limit (str or int): Maximum amount of memory + swap a container is allowed to consume. mounts (:py:class:`list`): Specification for mounts to be added to the container. More powerful alternative to ``binds``. Each item in the list is expected to be a :py:class:`docker.types.Mount` object. network_mode (str): One of: - ``bridge`` Create a new network stack for the container on the bridge network. - ``none`` No networking for this container. - ``container:<name|id>`` Reuse another container's network stack. - ``host`` Use the host network stack. This mode is incompatible with ``port_bindings``. oom_kill_disable (bool): Whether to disable OOM killer. oom_score_adj (int): An integer value containing the score given to the container in order to tune OOM killer preferences. pid_mode (str): If set to ``host``, use the host PID namespace inside the container. pids_limit (int): Tune a container's pids limit. Set ``-1`` for unlimited. port_bindings (dict): See :py:meth:`create_container` for more information. Imcompatible with ``host`` in ``network_mode``. privileged (bool): Give extended privileges to this container. publish_all_ports (bool): Publish all ports to the host. read_only (bool): Mount the container's root filesystem as read only. restart_policy (dict): Restart the container when it exits. Configured as a dictionary with keys: - ``Name`` One of ``on-failure``, or ``always``. - ``MaximumRetryCount`` Number of times to restart the container on failure. security_opt (:py:class:`list`): A list of string values to customize labels for MLS systems, such as SELinux. shm_size (str or int): Size of /dev/shm (e.g. ``1G``). storage_opt (dict): Storage driver options per container as a key-value mapping. sysctls (dict): Kernel parameters to set in the container. tmpfs (dict): Temporary filesystems to mount, as a dictionary mapping a path inside the container to options for that path. For example: .. code-block:: python { '/mnt/vol2': '', '/mnt/vol1': 'size=3G,uid=1000' } ulimits (:py:class:`list`): Ulimits to set inside the container, as a list of :py:class:`docker.types.Ulimit` instances. userns_mode (str): Sets the user namespace mode for the container when user namespace remapping option is enabled. Supported values are: ``host`` uts_mode (str): Sets the UTS namespace mode for the container. Supported values are: ``host`` volumes_from (:py:class:`list`): List of container names or IDs to get volumes from. runtime (str): Runtime to use with this container. Returns: (dict) A dictionary which can be passed to the ``host_config`` argument to :py:meth:`create_container`. Example: >>> client.api.create_host_config( ... privileged=True, ... cap_drop=['MKNOD'], ... volumes_from=['nostalgic_newton'], ... ) {'CapDrop': ['MKNOD'], 'LxcConf': None, 'Privileged': True, 'VolumesFrom': ['nostalgic_newton'], 'PublishAllPorts': False} �versionzAcreate_host_config() got an unexpected keyword argument 'version')� TypeErrorry r rz r# r# r$ �create_host_config� s � z$ContainerApiMixin.create_host_configc O s t |i |��S )a� Create a networking config dictionary to be used as the ``networking_config`` parameter in :py:meth:`create_container`. Args: endpoints_config (dict): A dictionary mapping network names to endpoint configurations generated by :py:meth:`create_endpoint_config`. Returns: (dict) A networking config. Example: >>> client.api.create_network('network1') >>> networking_config = client.api.create_networking_config({ 'network1': client.api.create_endpoint_config() }) >>> container = client.api.create_container( img, command, networking_config=networking_config ) )r rz r# r# r$ �create_networking_configk s z*ContainerApiMixin.create_networking_configc O rw )a� Create an endpoint config dictionary to be used with :py:meth:`create_networking_config`. Args: aliases (:py:class:`list`): A list of aliases for this endpoint. Names in that list can be used within the network to reach the container. Defaults to ``None``. links (dict): Mapping of links for this endpoint using the ``{'container': 'alias'}`` format. The alias is optional. Containers declared in this dict will be linked to this container using the provided alias. Defaults to ``None``. ipv4_address (str): The IP address of this container on the network, using the IPv4 protocol. Defaults to ``None``. ipv6_address (str): The IP address of this container on the network, using the IPv6 protocol. Defaults to ``None``. link_local_ips (:py:class:`list`): A list of link-local (IPv4/IPv6) addresses. driver_opt (dict): A dictionary of options to provide to the network driver. Defaults to ``None``. Returns: (dict) An endpoint config. Example: >>> endpoint_config = client.api.create_endpoint_config( aliases=['web', 'app'], links={'app_db': 'db', 'another': None}, ipv4_address='132.65.0.123' ) )r ry rz r# r# r$ �create_endpoint_config� s "z(ContainerApiMixin.create_endpoint_configc C � | � | �| �d|��d�S )ai Inspect changes on a container's filesystem. Args: container (str): The container to diff Returns: (list) A list of dictionaries containing the attributes `Path` and `Kind`. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/changesT�r9 rN r �r r r# r# r$ �diff� � �zContainerApiMixin.diffc C s$ | j | �d|�dd�}| �||d�S )a Export the contents of a filesystem as a tar archive. Args: container (str): The container to export chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB Returns: (generator): The archived filesystem data stream Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/exportT)r F)rN r �_stream_raw_result)r r � chunk_sizerR r# r# r$ �export� s �zContainerApiMixin.exportc C sr d|i}|r ddinddi}| � d|�}| j||d|d�}| �|� |j�d�} | �||d �| r6t�| �fS d fS ) a Retrieve a file or folder from a container in the form of a tar archive. Args: container (str): The container where the file is located path (str): Path to the file or folder to retrieve chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB encode_stream (bool): Determines if data should be encoded (gzip-compressed) during transmission. Default: False Returns: (tuple): First element is a raw tar data stream. Second element is a dict containing ``stat`` information on the specified ``path``. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> c = docker.APIClient() >>> f = open('./sh_bin.tar', 'wb') >>> bits, stat = c.api.get_archive(container, '/bin/sh') >>> print(stat) {'name': 'sh', 'size': 1075464, 'mode': 493, 'mtime': '2018-10-01T15:37:48-07:00', 'linkTarget': ''} >>> for chunk in bits: ... f.write(chunk) >>> f.close() �pathzAccept-Encodingz gzip, deflate�identity�/containers/{0}/archiveTr' z x-docker-container-path-statFN)r rN �_raise_for_statusr �getr� r �decode_json_header) r r r� r� � encode_streamr r �urlrR � encoded_statr# r# r$ � get_archive� s$ %����� ��z ContainerApiMixin.get_archivec C r� )a| Identical to the `docker inspect` command, but only for containers. Args: container (str): The container to inspect Returns: (dict): Similar to the output of `docker inspect`, but as a single dict Raises: :py:class:`docker.errors.APIError` If the server returns an error. �/containers/{0}/jsonTr� r� r# r# r$ �inspect_container r� z#ContainerApiMixin.inspect_containerc C sN | � d|�}i }|durt|t�st|�}||d< | j||d�}| �|� dS )aB Kill a container or send a signal to a container. Args: container (str): The container to kill signal (str or int): The signal to send. Defaults to ``SIGKILL`` Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/killN�signalrG )r rT rU �intr r� )r r r� r� r rR r# r# r$ �kill s zContainerApiMixin.killrA c C s� |du r|}|r dp d|rdpd|rdpd|rdpdd�} |dkr,t |t�r*|dk r,d}|| d< |durgt |t�rAt�|�| d< n&t |t�rO|dkrO|| d< nt |t�r]|dkr]|| d< n t�d t|�� ���| dur�t� | j d �rwt� d ��t | t�r�t�| �| d < n&t | t�r�| dkr�| | d < nt | t�r�| dkr�| | d < n t�d t| �� ���| � d|�} | j | | |d�} | �||| �} |r�t| | �S | S )a< Get logs from a container. Similar to the ``docker logs`` command. The ``stream`` parameter makes the ``logs`` function return a blocking generator you can iterate over to retrieve log output as it happens. Args: container (str): The container to get logs from stdout (bool): Get ``STDOUT``. Default ``True`` stderr (bool): Get ``STDERR``. Default ``True`` stream (bool): Stream the response. Default ``False`` timestamps (bool): Show timestamps. Default ``False`` tail (str or int): Output specified number of lines at the end of logs. Either an integer of number of lines or the string ``all``. Default ``all`` since (datetime, int, or float): Show logs since a given datetime, integer epoch (in seconds) or float (in fractional seconds) 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 fractional seconds) Returns: (generator of bytes or bytes) Raises: :py:class:`docker.errors.APIError` If the server returns an error. Nr r )r r � timestamps�followrA �tailrD g z:since value should be datetime or positive int/float, not z1.35z-until is not supported for API version < 1.35�untilz:until value should be datetime or positive int/float, not z/containers/{0}/logs)r r )rT r� r r �datetime_to_timestamp�floatr �InvalidArgument�typer~ ry r r rN � _get_resultr )r r r r r r� r� rD r� r� r r� rR r" r# r# r$ r 4 sX ! � ��� �� zContainerApiMixin.logsc C �$ | � d|�}| �|�}| �|� dS )z� Pauses all processes within a container. Args: container (str): The container to pause Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/pauseN�r r r� �r r r� rR r# r# r$ r3 � s zContainerApiMixin.pausec C s� | � | �d|��}| �|� |�� }t|�}d}|�di ��d�}|du r'dS d|v r0|�|�S dD ]}|�|� d|� ��}|rC |S q2|S )a# Lookup the public-facing port that is NAT-ed to ``private_port``. Identical to the ``docker port`` command. Args: container (str): The container to look up private_port (int): The private port to inspect Returns: (list of dict): The mapping for the host ports Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: .. code-block:: bash $ docker run -d -p 80:80 ubuntu:14.04 /bin/sleep 30 7174d6347063a83f412fad6124c99cffd25ffe1a0807eb4b7f9cec76ac8cb43b .. code-block:: python >>> client.api.port('7174d6347063', 80) [{'HostIp': '0.0.0.0', 'HostPort': '80'}] r� N�NetworkSettings�Ports�/)r �udp�sctp)rN r r� r8 rU r� )r r � private_portrR �json_�h_ports� port_settings�protocolr# r# r$ �port� s" �zContainerApiMixin.portc C s8 d|i}| � d|�}| j|||d�}| �|� |jdkS )a( Insert a file or folder in an existing container using a tar archive as source. Args: container (str): The container where the file(s) will be extracted path (str): Path inside the container where the file(s) will be extracted. Must exist. data (bytes or stream): tar data to be extracted Returns: (bool): True if the call succeeds. Raises: :py:class:`docker.errors.APIError` If the server returns an error. r� r� )r r6 �� )r �_putr� � status_code)r r r� r6 r r� rR r# r# r$ � put_archive� s z ContainerApiMixin.put_archivez1.25c C s6 i }|r t �|�|d< | �d�}| �| j||d�d�S )a� Delete stopped containers Args: filters (dict): Filters to process on the prune list. Returns: (dict): A dict containing a list of deleted container IDs and the amount of disk space reclaimed in bytes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. rF z/containers/prunerG T)r rM r r9 r )r rF r r� r# r# r$ �prune_containers� s z"ContainerApiMixin.prune_containersc C s0 |||d�}| j | �d|�|d�}| �|� dS )a Remove a container. Similar to the ``docker rm`` command. Args: container (str): The container to remove v (bool): Remove the volumes associated with the container link (bool): Remove the specified link and not the underlying container force (bool): Force the removal of a running container (uses ``SIGKILL``) Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�v�link�forcez/containers/{0}rG N)�_deleter r� )r r r� r� r� r rR r# r# r$ �remove_container� s �z"ContainerApiMixin.remove_containerc C s0 | � d|�}d|i}| j||d�}| �|� dS )a< Rename a container. Similar to the ``docker rename`` command. Args: container (str): ID of the container to rename name (str): New name for the container Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/renamerg rG Nr� )r r rg r� r rR r# r# r$ �rename s zContainerApiMixin.renamec C s2 ||d�}| � d|�}| j||d�}| �|� dS )aC Resize the tty session. Args: container (str or dict): The container to resize height (int): Height of tty session width (int): Width of tty session Raises: :py:class:`docker.errors.APIError` If the server returns an error. )�h�wz/containers/{0}/resizerG Nr� )r r �height�widthr r� rR r# r# r$ �resize! s zContainerApiMixin.resize� c C sH d|i}| � d|�}| j}|dur||7 }| j|||d�}| �|� dS )a� Restart a container. Similar to the ``docker restart`` command. Args: container (str or dict): The container to restart. If a dict, the ``Id`` key is used. timeout (int): Number of seconds to try to stop for before killing the container. Once killed it will then be restarted. Default is 10 seconds. Raises: :py:class:`docker.errors.APIError` If the server returns an error. �tz/containers/{0}/restartN�r �timeout�r r� r r� �r r r� r r� � conn_timeoutrR r# r# r$ �restart4 s zContainerApiMixin.restartc O s6 |s|r t �d��| �d|�}| �|�}| �|� dS )a� Start a container. Similar to the ``docker start`` command, but doesn't support attach options. **Deprecation warning:** Passing configuration options in ``start`` is no longer supported. Users are expected to provide host config options in the ``host_config`` parameter of :py:meth:`~ContainerApiMixin.create_container`. Args: container (str): The container to start Raises: :py:class:`docker.errors.APIError` If the server returns an error. :py:class:`docker.errors.DeprecatedMethod` If any argument besides ``container`` are provided. Example: >>> container = client.api.create_container( ... image='busybox:latest', ... command='/bin/sleep 30') >>> client.api.start(container=container.get('Id')) z|Providing configuration in the start() method is no longer supported. Use the host_config param in create_container instead.z/containers/{0}/startN)r �DeprecatedMethodr r r� )r r r{ r| r� rR r# r# r$ �startL s � zContainerApiMixin.startc C s� | � d|�}d|i}|dur t�| jd�rt�d��||d< |r4|r't�d��| j| j|d|d �|d �S |r;t�d ��| j | j||d �dd �S )a& Stream statistics for a specific container. Similar to the ``docker stats`` command. Args: container (str): The container to stream statistics from decode (bool): If set to true, stream will be decoded into dicts on the fly. Only applicable if ``stream`` is True. False by default. stream (bool): If set to false, only the current stats will be returned instead of a stream. True by default. one_shot (bool): If set to true, Only get a single stat instead of waiting for 2 cycles. Must be used with stream=false. False by default. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/statsr Nr} z0one_shot is not supported for API version < 1.41zone-shotz;one_shot is only available in conjunction with stream=FalseT)r r )�decodez8decode is only available in conjunction with stream=TruerG r7 ) r r r~ ry r r r� �_stream_helperrN r9 )r r r� r �one_shotr� r r# r# r$ �statsr s, �����zContainerApiMixin.statsc C sZ |du r i }d}nd|i}| � d|�}| j}|dur ||7 }| j|||d�}| �|� dS )a� Stops a container. Similar to the ``docker stop`` command. Args: container (str): The container to stop timeout (int): Timeout in seconds to wait for the container to stop before sending a ``SIGKILL``. If None, then the StopTimeout value of the container will be used. Default: None Raises: :py:class:`docker.errors.APIError` If the server returns an error. Nr� r� z/containers/{0}/stopr� r� r� r# r# r$ �stop� s zContainerApiMixin.stopc C s6 | � d|�}i }|dur||d< | �| j||d�d�S )a| Display the running processes of a container. Args: container (str): The container to inspect ps_args (str): An optional arguments passed to ps (e.g. ``aux``) Returns: (str): The output of the top Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/topN�ps_argsrG T)r r9 rN )r r r� r r r# r# r$ �top� s zContainerApiMixin.topc C r� )z� Unpause all processes within a container. Args: container (str): The container to unpause z/containers/{0}/unpauseNr� r� r# r# r$ �unpause� s zContainerApiMixin.unpausez1.22c C s� | � d|�} i }|r||d< |r||d< |r||d< |r ||d< |r&||d< |r,||d< |r5t�|�|d< | r>t�| �|d < | rGt�| �|d < | rPt�| �|d < | rbt�| jd �r^t�d ��| |d< | j| |d�}| �|d�S )aC Update resource configs of one or more containers. Args: container (str): The container to inspect blkio_weight (int): Block IO (relative weight), between 10 and 1000 cpu_period (int): Limit CPU CFS (Completely Fair Scheduler) period cpu_quota (int): Limit CPU CFS (Completely Fair Scheduler) quota cpu_shares (int): CPU shares (relative weight) cpuset_cpus (str): CPUs in which to allow execution cpuset_mems (str): MEMs in which to allow execution mem_limit (float or str): Memory limit mem_reservation (float or str): Memory soft limit memswap_limit (int or str): Total memory (memory + swap), -1 to disable swap kernel_memory (int or str): Kernel memory limit restart_policy (dict): Restart policy dictionary Returns: (dict): Dictionary containing a ``Warnings`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/update� BlkioWeight� CpuPeriod� CpuShares�CpuQuota� CpusetCpus� CpusetMems�Memory�MemoryReservation� MemorySwap� KernelMemoryz1.23z=restart policy update is not supported for API version < 1.23� RestartPolicy)r6 T) r r � parse_bytesr~ ry r r r: r9 )r r � blkio_weight� cpu_period� cpu_quota� cpu_shares� cpuset_cpus� cpuset_mems� mem_limit�mem_reservation� memswap_limit� kernel_memory�restart_policyr� r6 rR r# r# r$ �update_container� s< !� z"ContainerApiMixin.update_containerc C sT | � d|�}i }|dur t�| jd�rt�d��||d< | j|||d�}| �|d�S )a[ Block until a container stops, then return its exit code. Similar to the ``docker wait`` command. Args: container (str or dict): The container to wait on. If a dict, the ``Id`` key is used. timeout (int): Request timeout condition (str): Wait until a container state reaches the given condition, either ``not-running`` (default), ``next-exit``, or ``removed`` Returns: (dict): The API's response as a Python dictionary, including the container's exit code under the ``StatusCode`` attribute. Raises: :py:class:`requests.exceptions.ReadTimeout` If the timeout is exceeded. :py:class:`docker.errors.APIError` If the server returns an error. z/containers/{0}/waitNz1.30z6wait condition is not supported for API version < 1.30� condition)r� r T)r r r~ ry r r r r9 )r r r� r� r� r rR r# r# r$ �wait" s � zContainerApiMixin.wait)TTFFF)NF)NNNNTNN) FFFFNNr? FN)NNNFFFNNNFNNNNNNNNNNNNTN)NNrx )TTFFrA NNN)FFF)r� )NTN) NNNNNNNNNNN)&�__name__� __module__� __qualname__r �check_resourcer% r. r> rS rv rZ r[ r� r� r� r� r r� r� r� r� r r3 r� r� �minimum_versionr� r� r� r� r� r� r� r� r� r� r� r� r# r# r# r$ r s� �5 , �% �E � ^ !$ �4 �R 1 % / �@r N) r � r r � constantsr �typesr r r r r r r# r# r# r$ �<module> s __pycache__/image.cpython-310.pyc 0000644 00000043211 15027743616 0012553 0 ustar 00 o �h O � @ sb d dl Z d dlZddlmZmZmZ ddlmZ e �e �Z G dd� d�Z dd� Z d d d �Z dS ) � N� )�auth�errors�utils)�DEFAULT_DATA_CHUNK_SIZEc @ s. e Zd Ze�d�efdd��Ze�d�dd� �Zd*dd �Z d+d d �Z d,d d �Z d,dd�Z d,dd�Z d,dd�Z d,dd�Ze�d�dd� �Ze�d�e�d�d-dd���Zd-dd �Ze�d �d-d d ��Z d.d d!�Z d/d"d#�Ze�d�d0d$d%��Zd-d&d'�Ze�d�d1d(d)��ZdS )2� ImageApiMixin�imagec C s$ | j | �d|�dd�}| �||d�S )a� Get a tarball of an image. Similar to the ``docker save`` command. Args: image (str): Image name to get chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB Returns: (generator): A stream of raw archive data. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> image = client.api.get_image("busybox:latest") >>> f = open('/tmp/busybox-latest.tar', 'wb') >>> for chunk in image: >>> f.write(chunk) >>> f.close() z/images/{0}/getT)�streamF)�_get�_url�_stream_raw_result)�selfr � chunk_size�res� r �F/usr/local/CyberPanel/lib/python3.10/site-packages/docker/api/image.py� get_image s zImageApiMixin.get_imagec C s | � | �d|��}| �|d�S )a$ Show the history of an image. Args: image (str): The image to show history for Returns: (list): The history of the image Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/images/{0}/historyT)r r �_result)r r r r r r �history) s zImageApiMixin.historyNFc C s� |rdnd|r dndd�}|r&t �| jd�r||d< n |r"||d< nd|i}|r/t �|�|d< | �| j| �d�|d �d �}|rFd d � |D �S |S ) a List images. Similar to the ``docker images`` command. Args: name (str): Only show images belonging to the repository ``name`` quiet (bool): Only return numeric IDs as a list. 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: (dict or list): A list if ``quiet=True``, otherwise a dict. Raises: :py:class:`docker.errors.APIError` If the server returns an error. � r )�only_ids�all�1.25�filter� reference�filtersz /images/json��paramsTc S s g | ]}|d �qS )�Idr )�.0�xr r r � <listcomp>c s z(ImageApiMixin.images.<locals>.<listcomp>)r � version_lt�_version�convert_filtersr r r )r �name�quietr r r r r r r �images; s" � �zImageApiMixin.imagesc C s� |s |s t �d��| �d�}t|||t|t�r|nd|d�}ddi} |s+|�d�dkr6| �| j|d|d ��S t|t�r_t |d ��} | �| j|| || dd ��W d � S 1 sXw Y dS |red | d < | �| j|||| d��S )ad Import an image. Similar to the ``docker import`` command. If ``src`` is a string or unicode string, it will first be treated as a path to a tarball on the local system. If there is an error reading from that file, ``src`` will be treated as a URL instead to fetch the image from. You can also pass an open file handle as ``src``, in which case the data will be read from that file. If ``src`` is unset but ``image`` is set, the ``image`` parameter will be taken as the name of an existing image to import from. Args: src (str or file): Path to tarfile, URL, or file-like object repository (str): The repository to create tag (str): The tag to apply image (str): Use another image like the ``FROM`` Dockerfile parameter z(Must specify src or image to import from�/images/createN��src�changes� Content-Type�application/tar�fromSrc�-)�datar �rb�r0 r �headers�timeout�chunkedzTransfer-Encoding)r0 r r3 ) r �DockerExceptionr �_import_image_params� isinstance�str�getr �_post�open) r r* � repository�tagr r+ � stream_src�ur r3 �fr r r � import_imagef s8 � �� ��$��zImageApiMixin.import_imagec C s< | � d�}t||d|d�}ddi}| �| j||||dd��S )a@ Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but allows importing in-memory bytes data. Args: data (bytes collection): Bytes collection containing valid tar data repository (str): The repository to create tag (str): The tag to apply r( r/ r) r, r- Nr2 )r r7 r r; )r r0 r= r> r+ r@ r r3 r r r �import_image_from_data� s � ��z$ImageApiMixin.import_image_from_datac C � | j ||||d�S )aj Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only supports importing from a tar file on disk. Args: filename (str): Full path to a tar file. repository (str): The repository to create tag (str): The tag to apply Raises: IOError: File does not exist. �r* r= r> r+ �rB )r �filenamer= r> r+ r r r �import_image_from_file� s �z$ImageApiMixin.import_image_from_filec C s | j |d|||d�S )NT)r* r? r= r> r+ rF )r r r= r> r+ r r r �import_image_from_stream� s �z&ImageApiMixin.import_image_from_streamc C rD )a" Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only supports importing from a URL. Args: url (str): A URL pointing to a tar file. repository (str): The repository to create tag (str): The tag to apply rE rF )r �urlr= r> r+ r r r �import_image_from_url� s �z#ImageApiMixin.import_image_from_urlc C rD )aX Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only supports importing from another image, like the ``FROM`` Dockerfile parameter. Args: image (str): Image name to import from repository (str): The repository to create tag (str): The tag to apply )r r= r> r+ rF )r r r= r> r+ r r r �import_image_from_image� s �z%ImageApiMixin.import_image_from_imagec C s | � | �| �d|��d�S )a� Get detailed information about an image. Similar to the ``docker inspect`` command, but only for images. Args: image (str): The image to inspect Returns: (dict): Similar to the output of ``docker inspect``, but as a single dict Raises: :py:class:`docker.errors.APIError` If the server returns an error. z/images/{0}/jsonT�r r r )r r r r r � inspect_image� s �zImageApiMixin.inspect_imagez1.30c C sn t �|�\}}i }|du rt �| |�}|r||d< n t�d� t �|�|d< | �d|�}| �| j||d�d�S )a/ Get image digest and platform information by contacting the registry. Args: image (str): The image name to inspect 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: (dict): A dict containing distribution data Raises: :py:class:`docker.errors.APIError` If the server returns an error. N�X-Registry-Auth� Sending supplied auth configz/distribution/{0}/json)r3 T) r �resolve_repository_name�get_config_header�log�debug� encode_headerr r r )r r � auth_config�registry�_r3 �headerrJ r r r �inspect_distribution� s � �z"ImageApiMixin.inspect_distributionc C sn i }|durt �| jd�rt�d��||d< | j| �d�||dd�}t �| jd�r0| j|dd�S | � |� dS ) a9 Load an image that was previously saved using :py:meth:`~docker.api.image.ImageApiMixin.get_image` (or ``docker save``). Similar to ``docker load``. Args: data (binary): Image data to be loaded. quiet (boolean): Suppress progress details in response. Returns: (generator): Progress output as JSON objects. Only available for API version >= 1.23 Raises: :py:class:`docker.errors.APIError` If the server returns an error. Nz1.23z,quiet is not supported in API version < 1.23r& z /images/loadT)r0 r r ��decode) r r" r# r �InvalidVersionr; r � version_gte�_stream_helper�_raise_for_status)r r0 r& r r r r r � load_image# s ��zImageApiMixin.load_imager c C s: | � d�}i }|durt�|�|d< | �| j||d�d�S )a Delete unused images Args: filters (dict): Filters to process on the prune list. Available filters: - dangling (bool): When set to true (or 1), prune only unused and untagged images. Returns: (dict): A dict containing a list of deleted image IDs and the amount of disk space reclaimed in bytes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. z /images/pruneNr r T)r r r$ r r; )r r rJ r r r r � prune_imagesF s zImageApiMixin.prune_imagesc C s� t �|�\}}|p |p d}|rd}t�|�\} } ||d�} i } |du r0t�| | �} | r/| | d< n t�d� t�|�| d< |durPt �| j d�rLt � d��|| d< | j | � d �| | |dd �}| �|� |rk| j||d �S | �|�S ) aa Pulls an image. Similar to the ``docker pull`` command. Args: repository (str): The repository to pull tag (str): The tag to pull. If ``tag`` is ``None`` or empty, it is set to ``latest``. stream (bool): Stream the output as a generator. Make sure to consume the generator, otherwise pull might get cancelled. 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. decode (bool): Decode the JSON data from the server into dicts. Only applies with ``stream=True`` platform (str): Platform in the format ``os[/arch[/variant]]`` all_tags (bool): Pull all image tags, the ``tag`` parameter is ignored. Returns: (generator or str): The output Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> resp = client.api.pull('busybox', stream=True, decode=True) ... for line in resp: ... print(json.dumps(line, indent=4)) { "status": "Pulling image (latest) from busybox", "progressDetail": {}, "id": "e72ac664f4f0" } { "status": "Pulling image (latest) from busybox, endpoint: ...", "progressDetail": {}, "id": "e72ac664f4f0" } �latestN)r> � fromImagerO rP z1.32z0platform was only introduced in API version 1.32�platformr( )r r3 r r4 r[ )r �parse_repository_tagr rQ rR rS rT rU r" r# r r] r; r r` r_ r )r r= r> r rV r\ re �all_tags� image_tagrW � repo_namer r3 rY �responser r r �pull_ s< , � � � � zImageApiMixin.pullc C s� |s t �|�\}}t�|�\}}| �d|�}d|i} i } |du r-t�| |�} | r,| | d< n t�d� t�|�| d< | j |d| || d�} | � | � |rQ| j | |d�S | � | �S )aG Push an image or a repository to the registry. Similar to the ``docker push`` command. Args: repository (str): The repository to push to tag (str): An optional tag to push stream (bool): Stream the output as a blocking generator 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. decode (bool): Decode the JSON data from the server into dicts. Only applies with ``stream=True`` Returns: (generator or str): The output from the server. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> resp = client.api.push( ... 'yourname/app', ... stream=True, ... decode=True, ... ) ... for line in resp: ... print(line) {'status': 'Pushing repository yourname/app (1 tags)'} {'status': 'Pushing','progressDetail': {}, 'id': '511136ea3c5a'} {'status': 'Image already pushed, skipping', 'progressDetail':{}, 'id': '511136ea3c5a'} ... z/images/{0}/pushr> NrO rP )r3 r r r[ ) r rf r rQ r rR rS rT rU � _post_jsonr` r_ r ) r r= r> r rV r\ rW ri r@ r r3 rY rj r r r �push� s* & � � � zImageApiMixin.pushc C s, ||d�}| j | �d|�|d�}| �|d�S )z� Remove an image. Similar to the ``docker rmi`` command. Args: image (str): The image to remove force (bool): Force removal of the image noprune (bool): Do not delete untagged parents )�force�noprunez /images/{0}r T)�_deleter r )r r rn ro r r r r r � remove_image� s zImageApiMixin.remove_imagec C s4 d|i}|dur ||d< | � | j| �d�|d�d�S )a� Search for images on Docker Hub. Similar to the ``docker search`` command. Args: term (str): A term to search for. limit (int): The maximum number of results to return. Returns: (list of dicts): The response of the search. Raises: :py:class:`docker.errors.APIError` If the server returns an error. �termN�limitz/images/searchr TrM )r rr rs r r r r �search s �zImageApiMixin.searchc C sB |||rdndd�}| � d|�}| j||d�}| �|� |jdkS )aH Tag an image into a repository. Similar to the ``docker tag`` command. Args: image (str): The image to tag repository (str): The repository to set for the tag tag (str): The tag name force (bool): Force Returns: (bool): ``True`` if successful Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> client.api.tag('ubuntu', 'localhost:5000/ubuntu', 'latest', force=True) r r )r> �reporn z/images/{0}/tagr �� )r r; r` � status_code)r r r= r> rn r rJ r r r r r> s � zImageApiMixin.tag)NFFN)NNNNNF�NNN)N)NFNFNF)NFNF)FF�NF)�__name__� __module__� __qualname__r �check_resourcer r r r' rB rC rH rI rK rL rN �minimum_versionrZ ra rb rk rm rq rt r> r r r r r sV + �4 � � � � � "# �U �B r c C s. z t | t�o tj�| �W S ty Y dS w ry )r8 r9 �os�path�isfile� TypeError)r* r r r �is_file? s � �r� c C sF | |d�}|r ||d< n|rt |�s||d< nd|d< |r!||d< |S )N)ru r> rd r. r/ r+ )r� )ru r> r r* r+ r r r r r7 I s � r7 rx )�loggingr � r r r � constantsr � getLoggerrz rS r r� r7 r r r r �<module> s 9 � build.py 0000644 00000037277 15027743616 0006250 0 ustar 00 import json import logging import os import random from .. import auth, constants, errors, utils log = logging.getLogger(__name__) class BuildApiMixin: def build(self, path=None, tag=None, quiet=False, fileobj=None, nocache=False, rm=False, timeout=None, custom_context=False, encoding=None, pull=False, forcerm=False, dockerfile=None, container_limits=None, decode=False, buildargs=None, gzip=False, shmsize=None, labels=None, cache_from=None, target=None, network_mode=None, squash=None, extra_hosts=None, platform=None, isolation=None, use_config_proxy=True): """ Similar to the ``docker build`` command. Either ``path`` or ``fileobj`` needs to be set. ``path`` can be a local path (to a directory containing a Dockerfile) or a remote URL. ``fileobj`` must be a readable file-like object to a Dockerfile. If you have a tar file for the Docker build context (including a Dockerfile) already, pass a readable file-like object to ``fileobj`` and also pass ``custom_context=True``. If the stream is compressed also, set ``encoding`` to the correct value (e.g ``gzip``). Example: >>> from io import BytesIO >>> from docker import APIClient >>> dockerfile = ''' ... # Shared Volume ... FROM busybox:buildroot-2014.02 ... VOLUME /data ... CMD ["/bin/sh"] ... ''' >>> f = BytesIO(dockerfile.encode('utf-8')) >>> cli = APIClient(base_url='tcp://127.0.0.1:2375') >>> response = [line for line in cli.build( ... fileobj=f, rm=True, tag='yourname/volume' ... )] >>> response ['{"stream":" ---\\u003e a9eb17255234\\n"}', '{"stream":"Step 1 : VOLUME /data\\n"}', '{"stream":" ---\\u003e Running in abdc1e6896c6\\n"}', '{"stream":" ---\\u003e 713bca62012e\\n"}', '{"stream":"Removing intermediate container abdc1e6896c6\\n"}', '{"stream":"Step 2 : CMD [\\"/bin/sh\\"]\\n"}', '{"stream":" ---\\u003e Running in dba30f2a1a7e\\n"}', '{"stream":" ---\\u003e 032b8b2855fc\\n"}', '{"stream":"Removing intermediate container dba30f2a1a7e\\n"}', '{"stream":"Successfully built 032b8b2855fc\\n"}'] 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 gzip (bool): If set to ``True``, gzip compression/encoding is used 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"`` decode (bool): If set to ``True``, the returned stream will be decoded into dicts on the fly. Default ``False`` 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 (:py:class:`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: A generator for the build output. Raises: :py:class:`docker.errors.APIError` If the server returns an error. ``TypeError`` If neither ``path`` nor ``fileobj`` is specified. """ remote = context = None headers = {} container_limits = container_limits or {} buildargs = buildargs or {} if path is None and fileobj is None: raise TypeError("Either path or fileobj needs to be provided.") if gzip and encoding is not None: raise errors.DockerException( 'Can not use custom encoding if gzip is enabled' ) if tag is not None: if not utils.match_tag(tag): raise errors.DockerException( f"invalid tag '{tag}': invalid reference format" ) for key in container_limits.keys(): if key not in constants.CONTAINER_LIMITS_KEYS: raise errors.DockerException( f"invalid tag '{tag}': invalid reference format" ) if custom_context: if not fileobj: raise TypeError("You must specify fileobj with custom_context") context = fileobj elif fileobj is not None: context = utils.mkbuildcontext(fileobj) elif path.startswith(('http://', 'https://', 'git://', 'github.com/', 'git@')): remote = path elif not os.path.isdir(path): raise TypeError("You must specify a directory to build in path") else: dockerignore = os.path.join(path, '.dockerignore') exclude = None if os.path.exists(dockerignore): with open(dockerignore) as f: exclude = list(filter( lambda x: x != '' and x[0] != '#', [line.strip() for line in f.read().splitlines()] )) dockerfile = process_dockerfile(dockerfile, path) context = utils.tar( path, exclude=exclude, dockerfile=dockerfile, gzip=gzip ) encoding = 'gzip' if gzip else encoding u = self._url('/build') params = { 't': tag, 'remote': remote, 'q': quiet, 'nocache': nocache, 'rm': rm, 'forcerm': forcerm, 'pull': pull, 'dockerfile': dockerfile, } params.update(container_limits) if use_config_proxy: proxy_args = self._proxy_configs.get_environment() for k, v in proxy_args.items(): buildargs.setdefault(k, v) if buildargs: params.update({'buildargs': json.dumps(buildargs)}) if shmsize: if utils.version_gte(self._version, '1.22'): params.update({'shmsize': shmsize}) else: raise errors.InvalidVersion( 'shmsize was only introduced in API version 1.22' ) if labels: if utils.version_gte(self._version, '1.23'): params.update({'labels': json.dumps(labels)}) else: raise errors.InvalidVersion( 'labels was only introduced in API version 1.23' ) if cache_from: if utils.version_gte(self._version, '1.25'): params.update({'cachefrom': json.dumps(cache_from)}) else: raise errors.InvalidVersion( 'cache_from was only introduced in API version 1.25' ) if target: if utils.version_gte(self._version, '1.29'): params.update({'target': target}) else: raise errors.InvalidVersion( 'target was only introduced in API version 1.29' ) if network_mode: if utils.version_gte(self._version, '1.25'): params.update({'networkmode': network_mode}) else: raise errors.InvalidVersion( 'network_mode was only introduced in API version 1.25' ) if squash: if utils.version_gte(self._version, '1.25'): params.update({'squash': squash}) else: raise errors.InvalidVersion( 'squash was only introduced in API version 1.25' ) if extra_hosts is not None: if utils.version_lt(self._version, '1.27'): raise errors.InvalidVersion( 'extra_hosts was only introduced in API version 1.27' ) if isinstance(extra_hosts, dict): extra_hosts = utils.format_extra_hosts(extra_hosts) params.update({'extrahosts': extra_hosts}) if platform is not None: if utils.version_lt(self._version, '1.32'): raise errors.InvalidVersion( 'platform was only introduced in API version 1.32' ) params['platform'] = platform if isolation is not None: if utils.version_lt(self._version, '1.24'): raise errors.InvalidVersion( 'isolation was only introduced in API version 1.24' ) params['isolation'] = isolation if context is not None: headers = {'Content-Type': 'application/tar'} if encoding: headers['Content-Encoding'] = encoding self._set_auth_headers(headers) response = self._post( u, data=context, params=params, headers=headers, stream=True, timeout=timeout, ) if context is not None and not custom_context: context.close() return self._stream_helper(response, decode=decode) @utils.minimum_version('1.31') def prune_builds(self, filters=None, keep_storage=None, all=None): """ Delete the builder cache Args: filters (dict): Filters to process on the prune list. Needs Docker API v1.39+ Available filters: - dangling (bool): When set to true (or 1), prune only unused and untagged images. - until (str): Can be Unix timestamps, date formatted timestamps, or Go duration strings (e.g. 10m, 1h30m) computed relative to the daemon's local time. keep_storage (int): Amount of disk space in bytes to keep for cache. Needs Docker API v1.39+ all (bool): Remove all types of build cache. Needs Docker API v1.39+ Returns: (dict): A dictionary containing information about the operation's result. The ``SpaceReclaimed`` key indicates the amount of bytes of disk space reclaimed. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url("/build/prune") if (filters, keep_storage, all) != (None, None, None) \ and utils.version_lt(self._version, '1.39'): raise errors.InvalidVersion( '`filters`, `keep_storage`, and `all` args are only available ' 'for API version > 1.38' ) params = {} if filters is not None: params['filters'] = utils.convert_filters(filters) if keep_storage is not None: params['keep-storage'] = keep_storage if all is not None: params['all'] = all return self._result(self._post(url, params=params), True) def _set_auth_headers(self, headers): log.debug('Looking for auth config') # If we don't have any auth data so far, try reloading the config # file one more time in case anything showed up in there. if not self._auth_configs or self._auth_configs.is_empty: log.debug("No auth config in memory - loading from filesystem") self._auth_configs = auth.load_config( credstore_env=self.credstore_env ) # Send the full auth configuration (if any exists), since the build # could use any (or all) of the registries. if self._auth_configs: auth_data = self._auth_configs.get_all_credentials() # See https://github.com/docker/docker-py/issues/1683 if (auth.INDEX_URL not in auth_data and auth.INDEX_NAME in auth_data): auth_data[auth.INDEX_URL] = auth_data.get(auth.INDEX_NAME, {}) log.debug( "Sending auth config (%s)", ', '.join(repr(k) for k in auth_data), ) if auth_data: headers['X-Registry-Config'] = auth.encode_header( auth_data ) else: log.debug('No auth config found') def process_dockerfile(dockerfile, path): if not dockerfile: return (None, None) abs_dockerfile = dockerfile if not os.path.isabs(dockerfile): abs_dockerfile = os.path.join(path, dockerfile) if constants.IS_WINDOWS_PLATFORM and path.startswith( constants.WINDOWS_LONGPATH_PREFIX): normpath = os.path.normpath( abs_dockerfile[len(constants.WINDOWS_LONGPATH_PREFIX):]) abs_dockerfile = f'{constants.WINDOWS_LONGPATH_PREFIX}{normpath}' if (os.path.splitdrive(path)[0] != os.path.splitdrive(abs_dockerfile)[0] or os.path.relpath(abs_dockerfile, path).startswith('..')): # Dockerfile not in context - read data to insert into tar later with open(abs_dockerfile) as df: return ( f'.dockerfile.{random.getrandbits(160):x}', df.read() ) # Dockerfile is inside the context - return path relative to context root if dockerfile == abs_dockerfile: # Only calculate relpath if necessary to avoid errors # on Windows client -> Linux Docker # see https://github.com/docker/compose/issues/5969 dockerfile = os.path.relpath(abs_dockerfile, path) return (dockerfile, None) plugin.py 0000644 00000021426 15027743616 0006434 0 ustar 00 from .. import auth, utils class PluginApiMixin: @utils.minimum_version('1.25') @utils.check_resource('name') def configure_plugin(self, name, options): """ Configure a plugin. Args: name (string): The name of the plugin. The ``:latest`` tag is optional, and is the default if omitted. options (dict): A key-value mapping of options Returns: ``True`` if successful """ url = self._url('/plugins/{0}/set', name) data = options if isinstance(data, dict): data = [f'{k}={v}' for k, v in data.items()] res = self._post_json(url, data=data) self._raise_for_status(res) return True @utils.minimum_version('1.25') def create_plugin(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: ``True`` if successful """ url = self._url('/plugins/create') with utils.create_archive( root=plugin_data_dir, gzip=gzip, files=set(utils.build.walk(plugin_data_dir, [])) ) as archv: res = self._post(url, params={'name': name}, data=archv) self._raise_for_status(res) return True @utils.minimum_version('1.25') def disable_plugin(self, name, force=False): """ Disable an installed plugin. Args: name (string): The name of the plugin. The ``:latest`` tag is optional, and is the default if omitted. force (bool): To enable the force query parameter. Returns: ``True`` if successful """ url = self._url('/plugins/{0}/disable', name) res = self._post(url, params={'force': force}) self._raise_for_status(res) return True @utils.minimum_version('1.25') def enable_plugin(self, name, timeout=0): """ Enable an installed plugin. Args: name (string): The name of the plugin. The ``:latest`` tag is optional, and is the default if omitted. timeout (int): Operation timeout (in seconds). Default: 0 Returns: ``True`` if successful """ url = self._url('/plugins/{0}/enable', name) params = {'timeout': timeout} res = self._post(url, params=params) self._raise_for_status(res) return True @utils.minimum_version('1.25') def inspect_plugin(self, name): """ Retrieve plugin metadata. Args: name (string): The name of the plugin. The ``:latest`` tag is optional, and is the default if omitted. Returns: A dict containing plugin info """ url = self._url('/plugins/{0}/json', name) return self._result(self._get(url), True) @utils.minimum_version('1.25') def pull_plugin(self, remote, privileges, name=None): """ Pull and install a plugin. After the plugin is installed, it can be enabled using :py:meth:`~enable_plugin`. Args: remote (string): Remote reference for the plugin to install. The ``:latest`` tag is optional, and is the default if omitted. privileges (:py:class:`list`): A list of privileges the user consents to grant to the plugin. Can be retrieved using :py:meth:`~plugin_privileges`. name (string): Local name for the pulled plugin. The ``:latest`` tag is optional, and is the default if omitted. Returns: An iterable object streaming the decoded API logs """ url = self._url('/plugins/pull') params = { 'remote': remote, } if name: params['name'] = name headers = {} registry, repo_name = auth.resolve_repository_name(remote) header = auth.get_config_header(self, registry) if header: headers['X-Registry-Auth'] = header response = self._post_json( url, params=params, headers=headers, data=privileges, stream=True ) self._raise_for_status(response) return self._stream_helper(response, decode=True) @utils.minimum_version('1.25') def plugins(self): """ Retrieve a list of installed plugins. Returns: A list of dicts, one per plugin """ url = self._url('/plugins') return self._result(self._get(url), True) @utils.minimum_version('1.25') def plugin_privileges(self, name): """ Retrieve list of privileges to be granted to a plugin. Args: name (string): Name of the remote plugin to examine. The ``:latest`` tag is optional, and is the default if omitted. Returns: A list of dictionaries representing the plugin's permissions """ params = { 'remote': name, } headers = {} registry, repo_name = auth.resolve_repository_name(name) header = auth.get_config_header(self, registry) if header: headers['X-Registry-Auth'] = header url = self._url('/plugins/privileges') return self._result( self._get(url, params=params, headers=headers), True ) @utils.minimum_version('1.25') @utils.check_resource('name') def push_plugin(self, name): """ Push a plugin to the registry. Args: name (string): Name of the plugin to upload. The ``:latest`` tag is optional, and is the default if omitted. Returns: ``True`` if successful """ url = self._url('/plugins/{0}/pull', name) headers = {} registry, repo_name = auth.resolve_repository_name(name) header = auth.get_config_header(self, registry) if header: headers['X-Registry-Auth'] = header res = self._post(url, headers=headers) self._raise_for_status(res) return self._stream_helper(res, decode=True) @utils.minimum_version('1.25') @utils.check_resource('name') def remove_plugin(self, name, force=False): """ Remove an installed plugin. Args: name (string): Name of the plugin to remove. The ``:latest`` tag is optional, and is the default if omitted. force (bool): Disable the plugin before removing. This may result in issues if the plugin is in use by a container. Returns: ``True`` if successful """ url = self._url('/plugins/{0}', name) res = self._delete(url, params={'force': force}) self._raise_for_status(res) return True @utils.minimum_version('1.26') @utils.check_resource('name') def upgrade_plugin(self, name, remote, privileges): """ Upgrade an installed plugin. Args: name (string): Name of the plugin to upgrade. The ``:latest`` tag is optional and is the default if omitted. remote (string): Remote reference to upgrade to. The ``:latest`` tag is optional and is the default if omitted. privileges (:py:class:`list`): A list of privileges the user consents to grant to the plugin. Can be retrieved using :py:meth:`~plugin_privileges`. Returns: An iterable object streaming the decoded API logs """ url = self._url('/plugins/{0}/upgrade', name) params = { 'remote': remote, } headers = {} registry, repo_name = auth.resolve_repository_name(remote) header = auth.get_config_header(self, registry) if header: headers['X-Registry-Auth'] = header response = self._post_json( url, params=params, headers=headers, data=privileges, stream=True ) self._raise_for_status(response) return self._stream_helper(response, decode=True) daemon.py 0000644 00000013570 15027743616 0006402 0 ustar 00 import os from datetime import datetime from .. import auth, types, utils class DaemonApiMixin: @utils.minimum_version('1.25') def df(self): """ Get data usage information. Returns: (dict): A dictionary representing different resource categories and their respective data usage. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/system/df') return self._result(self._get(url), True) def events(self, since=None, until=None, filters=None, decode=None): """ Get real-time events from the server. Similar to the ``docker events`` command. Args: since (UTC datetime or int): Get events from this point until (UTC datetime or int): Get events until this point filters (dict): Filter the events by event time, container or image decode (bool): If set to true, stream will be decoded into dicts on the fly. False by default. Returns: A :py:class:`docker.types.daemon.CancellableStream` generator Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> for event in client.events(decode=True) ... print(event) {u'from': u'image/with:tag', u'id': u'container-id', u'status': u'start', u'time': 1423339459} ... or >>> events = client.events() >>> for event in events: ... print(event) >>> # and cancel from another thread >>> events.close() """ if isinstance(since, datetime): since = utils.datetime_to_timestamp(since) if isinstance(until, datetime): until = utils.datetime_to_timestamp(until) if filters: filters = utils.convert_filters(filters) params = { 'since': since, 'until': until, 'filters': filters } url = self._url('/events') response = self._get(url, params=params, stream=True, timeout=None) stream = self._stream_helper(response, decode=decode) return types.CancellableStream(stream, response) def info(self): """ Display system-wide information. Identical to the ``docker info`` command. Returns: (dict): The info as a dict Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self._result(self._get(self._url("/info")), True) def login(self, username, password=None, email=None, registry=None, reauth=False, dockercfg_path=None): """ Authenticate with a registry. Similar to the ``docker login`` command. Args: username (str): The registry username password (str): The plaintext password email (str): The email for the registry account registry (str): URL to the registry. E.g. ``https://index.docker.io/v1/`` reauth (bool): Whether or not to refresh existing authentication on the Docker server. dockercfg_path (str): Use a custom path for the Docker config file (default ``$HOME/.docker/config.json`` if present, otherwise ``$HOME/.dockercfg``) Returns: (dict): The response from the login request Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ # If we don't have any auth data so far, try reloading the config file # one more time in case anything showed up in there. # If dockercfg_path is passed check to see if the config file exists, # if so load that config. if dockercfg_path and os.path.exists(dockercfg_path): self._auth_configs = auth.load_config( dockercfg_path, credstore_env=self.credstore_env ) elif not self._auth_configs or self._auth_configs.is_empty: self._auth_configs = auth.load_config( credstore_env=self.credstore_env ) authcfg = self._auth_configs.resolve_authconfig(registry) # If we found an existing auth config for this registry and username # combination, we can return it immediately unless reauth is requested. if authcfg and authcfg.get('username', None) == username \ and not reauth: return authcfg req_data = { 'username': username, 'password': password, 'email': email, 'serveraddress': registry, } response = self._post_json(self._url('/auth'), data=req_data) if response.status_code == 200: self._auth_configs.add_auth(registry or auth.INDEX_NAME, req_data) return self._result(response, json=True) def ping(self): """ Checks the server is responsive. An exception will be raised if it isn't responding. Returns: (bool) The response from the server. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self._result(self._get(self._url('/_ping'))) == 'OK' def version(self, api_version=True): """ Returns version information from the server. Similar to the ``docker version`` command. Returns: (dict): The server version information Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url("/version", versioned_api=api_version) return self._result(self._get(url), json=True) exec_api.py 0000644 00000014102 15027743616 0006704 0 ustar 00 from .. import errors, utils from ..types import CancellableStream class ExecApiMixin: @utils.check_resource('container') def exec_create(self, container, cmd, stdout=True, stderr=True, stdin=False, tty=False, privileged=False, user='', environment=None, workdir=None, detach_keys=None): """ Sets up an exec instance in a running container. Args: container (str): Target container where exec instance will be created 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 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 detach_keys (str): Override the key sequence for detaching a container. Format is a single character `[a-Z]` or `ctrl-<value>` where `<value>` is one of: `a-z`, `@`, `^`, `[`, `,` or `_`. ~/.docker/config.json is used by default. Returns: (dict): A dictionary with an exec ``Id`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ if environment is not None and utils.version_lt(self._version, '1.25'): raise errors.InvalidVersion( 'Setting environment for exec is not supported in API < 1.25' ) if isinstance(cmd, str): cmd = utils.split_command(cmd) if isinstance(environment, dict): environment = utils.utils.format_environment(environment) data = { 'Container': container, 'User': user, 'Privileged': privileged, 'Tty': tty, 'AttachStdin': stdin, 'AttachStdout': stdout, 'AttachStderr': stderr, 'Cmd': cmd, 'Env': environment, } if workdir is not None: if utils.version_lt(self._version, '1.35'): raise errors.InvalidVersion( 'workdir is not supported for API version < 1.35' ) data['WorkingDir'] = workdir if detach_keys: data['detachKeys'] = detach_keys elif 'detachKeys' in self._general_configs: data['detachKeys'] = self._general_configs['detachKeys'] url = self._url('/containers/{0}/exec', container) res = self._post_json(url, data=data) return self._result(res, True) def exec_inspect(self, exec_id): """ Return low-level information about an exec command. Args: exec_id (str): ID of the exec instance Returns: (dict): Dictionary of values returned by the endpoint. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ if isinstance(exec_id, dict): exec_id = exec_id.get('Id') res = self._get(self._url("/exec/{0}/json", exec_id)) return self._result(res, True) def exec_resize(self, exec_id, height=None, width=None): """ Resize the tty session used by the specified exec command. Args: exec_id (str): ID of the exec instance height (int): Height of tty session width (int): Width of tty session """ if isinstance(exec_id, dict): exec_id = exec_id.get('Id') params = {'h': height, 'w': width} url = self._url("/exec/{0}/resize", exec_id) res = self._post(url, params=params) self._raise_for_status(res) @utils.check_resource('exec_id') def exec_start(self, exec_id, detach=False, tty=False, stream=False, socket=False, demux=False): """ Start a previously set up exec instance. Args: exec_id (str): ID of the exec instance detach (bool): If true, detach from the exec command. Default: False tty (bool): Allocate a pseudo-TTY. Default: False stream (bool): Return response data progressively as an iterator of strings, rather than a single string. socket (bool): Return the connection socket to allow custom read/write operations. Must be closed by the caller when done. demux (bool): Return stdout and stderr separately Returns: (generator or str or tuple): If ``stream=True``, a generator yielding response chunks. If ``socket=True``, a socket object for the connection. A string containing response data otherwise. If ``demux=True``, a tuple with two elements of type byte: stdout and stderr. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ # we want opened socket if socket == True data = { 'Tty': tty, 'Detach': detach } headers = {} if detach else { 'Connection': 'Upgrade', 'Upgrade': 'tcp' } res = self._post_json( self._url('/exec/{0}/start', exec_id), headers=headers, data=data, stream=True ) if detach: try: return self._result(res) finally: res.close() if socket: return self._get_raw_response_socket(res) output = self._read_from_socket(res, stream, tty=tty, demux=demux) if stream: return CancellableStream(output, res) else: return output volume.py 0000644 00000011777 15027743616 0006455 0 ustar 00 from .. import errors, utils class VolumeApiMixin: def volumes(self, filters=None): """ List volumes currently registered by the docker daemon. Similar to the ``docker volume ls`` command. Args: filters (dict): Server-side list filtering options. Returns: (dict): Dictionary with list of volume objects as value of the ``Volumes`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> client.api.volumes() {u'Volumes': [{u'Driver': u'local', u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data', u'Name': u'foobar'}, {u'Driver': u'local', u'Mountpoint': u'/var/lib/docker/volumes/baz/_data', u'Name': u'baz'}]} """ params = { 'filters': utils.convert_filters(filters) if filters else None } url = self._url('/volumes') return self._result(self._get(url, params=params), True) def create_volume(self, name=None, driver=None, driver_opts=None, labels=None): """ Create and register a named volume Args: name (str): Name of the volume 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: (dict): The created volume reference object Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> volume = client.api.create_volume( ... name='foobar', ... driver='local', ... driver_opts={'foo': 'bar', 'baz': 'false'}, ... labels={"key": "value"}, ... ) ... print(volume) {u'Driver': u'local', u'Labels': {u'key': u'value'}, u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data', u'Name': u'foobar', u'Scope': u'local'} """ url = self._url('/volumes/create') if driver_opts is not None and not isinstance(driver_opts, dict): raise TypeError('driver_opts must be a dictionary') data = { 'Name': name, 'Driver': driver, 'DriverOpts': driver_opts, } if labels is not None: if utils.compare_version('1.23', self._version) < 0: raise errors.InvalidVersion( 'volume labels were introduced in API 1.23' ) if not isinstance(labels, dict): raise TypeError('labels must be a dictionary') data["Labels"] = labels return self._result(self._post_json(url, data=data), True) def inspect_volume(self, name): """ Retrieve volume info by name. Args: name (str): volume name Returns: (dict): Volume information dictionary Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> client.api.inspect_volume('foobar') {u'Driver': u'local', u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data', u'Name': u'foobar'} """ url = self._url('/volumes/{0}', name) return self._result(self._get(url), True) @utils.minimum_version('1.25') def prune_volumes(self, filters=None): """ Delete unused volumes Args: filters (dict): Filters to process on the prune list. Returns: (dict): A dict containing a list of deleted volume names and the amount of disk space reclaimed in bytes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = {} if filters: params['filters'] = utils.convert_filters(filters) url = self._url('/volumes/prune') return self._result(self._post(url, params=params), True) def remove_volume(self, name, force=False): """ Remove a volume. Similar to the ``docker volume rm`` command. Args: name (str): The volume's name 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. """ params = {} if force: if utils.version_lt(self._version, '1.25'): raise errors.InvalidVersion( 'force removal was introduced in API 1.25' ) params = {'force': force} url = self._url('/volumes/{0}', name, params=params) resp = self._delete(url) self._raise_for_status(resp) image.py 0000644 00000047440 15027743616 0006224 0 ustar 00 import logging import os from .. import auth, errors, utils from ..constants import DEFAULT_DATA_CHUNK_SIZE log = logging.getLogger(__name__) class ImageApiMixin: @utils.check_resource('image') def get_image(self, image, chunk_size=DEFAULT_DATA_CHUNK_SIZE): """ Get a tarball of an image. Similar to the ``docker save`` command. Args: image (str): Image name to get chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB Returns: (generator): A stream of raw archive data. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> image = client.api.get_image("busybox:latest") >>> f = open('/tmp/busybox-latest.tar', 'wb') >>> for chunk in image: >>> f.write(chunk) >>> f.close() """ res = self._get(self._url("/images/{0}/get", image), stream=True) return self._stream_raw_result(res, chunk_size, False) @utils.check_resource('image') def history(self, image): """ Show the history of an image. Args: image (str): The image to show history for Returns: (list): The history of the image Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ res = self._get(self._url("/images/{0}/history", image)) return self._result(res, True) def images(self, name=None, quiet=False, all=False, filters=None): """ List images. Similar to the ``docker images`` command. Args: name (str): Only show images belonging to the repository ``name`` quiet (bool): Only return numeric IDs as a list. 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: (dict or list): A list if ``quiet=True``, otherwise a dict. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = { 'only_ids': 1 if quiet else 0, 'all': 1 if all else 0, } if name: if utils.version_lt(self._version, '1.25'): # only use "filter" on API 1.24 and under, as it is deprecated params['filter'] = name else: if filters: filters['reference'] = name else: filters = {'reference': name} if filters: params['filters'] = utils.convert_filters(filters) res = self._result(self._get(self._url("/images/json"), params=params), True) if quiet: return [x['Id'] for x in res] return res def import_image(self, src=None, repository=None, tag=None, image=None, changes=None, stream_src=False): """ Import an image. Similar to the ``docker import`` command. If ``src`` is a string or unicode string, it will first be treated as a path to a tarball on the local system. If there is an error reading from that file, ``src`` will be treated as a URL instead to fetch the image from. You can also pass an open file handle as ``src``, in which case the data will be read from that file. If ``src`` is unset but ``image`` is set, the ``image`` parameter will be taken as the name of an existing image to import from. Args: src (str or file): Path to tarfile, URL, or file-like object repository (str): The repository to create tag (str): The tag to apply image (str): Use another image like the ``FROM`` Dockerfile parameter """ if not (src or image): raise errors.DockerException( 'Must specify src or image to import from' ) u = self._url('/images/create') params = _import_image_params( repository, tag, image, src=(src if isinstance(src, str) else None), changes=changes ) headers = {'Content-Type': 'application/tar'} if image or params.get('fromSrc') != '-': # from image or URL return self._result( self._post(u, data=None, params=params) ) elif isinstance(src, str): # from file path with open(src, 'rb') as f: return self._result( self._post( u, data=f, params=params, headers=headers, timeout=None ) ) else: # from raw data if stream_src: headers['Transfer-Encoding'] = 'chunked' return self._result( self._post(u, data=src, params=params, headers=headers) ) def import_image_from_data(self, data, repository=None, tag=None, changes=None): """ Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but allows importing in-memory bytes data. Args: data (bytes collection): Bytes collection containing valid tar data repository (str): The repository to create tag (str): The tag to apply """ u = self._url('/images/create') params = _import_image_params( repository, tag, src='-', changes=changes ) headers = {'Content-Type': 'application/tar'} return self._result( self._post( u, data=data, params=params, headers=headers, timeout=None ) ) def import_image_from_file(self, filename, repository=None, tag=None, changes=None): """ Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only supports importing from a tar file on disk. Args: filename (str): Full path to a tar file. repository (str): The repository to create tag (str): The tag to apply Raises: IOError: File does not exist. """ return self.import_image( src=filename, repository=repository, tag=tag, changes=changes ) def import_image_from_stream(self, stream, repository=None, tag=None, changes=None): return self.import_image( src=stream, stream_src=True, repository=repository, tag=tag, changes=changes ) def import_image_from_url(self, url, repository=None, tag=None, changes=None): """ Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only supports importing from a URL. Args: url (str): A URL pointing to a tar file. repository (str): The repository to create tag (str): The tag to apply """ return self.import_image( src=url, repository=repository, tag=tag, changes=changes ) def import_image_from_image(self, image, repository=None, tag=None, changes=None): """ Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only supports importing from another image, like the ``FROM`` Dockerfile parameter. Args: image (str): Image name to import from repository (str): The repository to create tag (str): The tag to apply """ return self.import_image( image=image, repository=repository, tag=tag, changes=changes ) @utils.check_resource('image') def inspect_image(self, image): """ Get detailed information about an image. Similar to the ``docker inspect`` command, but only for images. Args: image (str): The image to inspect Returns: (dict): Similar to the output of ``docker inspect``, but as a single dict Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self._result( self._get(self._url("/images/{0}/json", image)), True ) @utils.minimum_version('1.30') @utils.check_resource('image') def inspect_distribution(self, image, auth_config=None): """ Get image digest and platform information by contacting the registry. Args: image (str): The image name to inspect 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: (dict): A dict containing distribution data Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ registry, _ = auth.resolve_repository_name(image) headers = {} if auth_config is None: header = auth.get_config_header(self, registry) if header: headers['X-Registry-Auth'] = header else: log.debug('Sending supplied auth config') headers['X-Registry-Auth'] = auth.encode_header(auth_config) url = self._url("/distribution/{0}/json", image) return self._result( self._get(url, headers=headers), True ) def load_image(self, data, quiet=None): """ Load an image that was previously saved using :py:meth:`~docker.api.image.ImageApiMixin.get_image` (or ``docker save``). Similar to ``docker load``. Args: data (binary): Image data to be loaded. quiet (boolean): Suppress progress details in response. Returns: (generator): Progress output as JSON objects. Only available for API version >= 1.23 Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = {} if quiet is not None: if utils.version_lt(self._version, '1.23'): raise errors.InvalidVersion( 'quiet is not supported in API version < 1.23' ) params['quiet'] = quiet res = self._post( self._url("/images/load"), data=data, params=params, stream=True ) if utils.version_gte(self._version, '1.23'): return self._stream_helper(res, decode=True) self._raise_for_status(res) @utils.minimum_version('1.25') def prune_images(self, filters=None): """ Delete unused images Args: filters (dict): Filters to process on the prune list. Available filters: - dangling (bool): When set to true (or 1), prune only unused and untagged images. Returns: (dict): A dict containing a list of deleted image IDs and the amount of disk space reclaimed in bytes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url("/images/prune") params = {} if filters is not None: params['filters'] = utils.convert_filters(filters) return self._result(self._post(url, params=params), True) def pull(self, repository, tag=None, stream=False, auth_config=None, decode=False, platform=None, all_tags=False): """ Pulls an image. Similar to the ``docker pull`` command. Args: repository (str): The repository to pull tag (str): The tag to pull. If ``tag`` is ``None`` or empty, it is set to ``latest``. stream (bool): Stream the output as a generator. Make sure to consume the generator, otherwise pull might get cancelled. 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. decode (bool): Decode the JSON data from the server into dicts. Only applies with ``stream=True`` platform (str): Platform in the format ``os[/arch[/variant]]`` all_tags (bool): Pull all image tags, the ``tag`` parameter is ignored. Returns: (generator or str): The output Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> resp = client.api.pull('busybox', stream=True, decode=True) ... for line in resp: ... print(json.dumps(line, indent=4)) { "status": "Pulling image (latest) from busybox", "progressDetail": {}, "id": "e72ac664f4f0" } { "status": "Pulling image (latest) from busybox, endpoint: ...", "progressDetail": {}, "id": "e72ac664f4f0" } """ repository, image_tag = utils.parse_repository_tag(repository) tag = tag or image_tag or 'latest' if all_tags: tag = None registry, repo_name = auth.resolve_repository_name(repository) params = { 'tag': tag, 'fromImage': repository } headers = {} if auth_config is None: header = auth.get_config_header(self, registry) if header: headers['X-Registry-Auth'] = header else: log.debug('Sending supplied auth config') headers['X-Registry-Auth'] = auth.encode_header(auth_config) if platform is not None: if utils.version_lt(self._version, '1.32'): raise errors.InvalidVersion( 'platform was only introduced in API version 1.32' ) params['platform'] = platform response = self._post( self._url('/images/create'), params=params, headers=headers, stream=stream, timeout=None ) self._raise_for_status(response) if stream: return self._stream_helper(response, decode=decode) return self._result(response) def push(self, repository, tag=None, stream=False, auth_config=None, decode=False): """ Push an image or a repository to the registry. Similar to the ``docker push`` command. Args: repository (str): The repository to push to tag (str): An optional tag to push stream (bool): Stream the output as a blocking generator 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. decode (bool): Decode the JSON data from the server into dicts. Only applies with ``stream=True`` Returns: (generator or str): The output from the server. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> resp = client.api.push( ... 'yourname/app', ... stream=True, ... decode=True, ... ) ... for line in resp: ... print(line) {'status': 'Pushing repository yourname/app (1 tags)'} {'status': 'Pushing','progressDetail': {}, 'id': '511136ea3c5a'} {'status': 'Image already pushed, skipping', 'progressDetail':{}, 'id': '511136ea3c5a'} ... """ if not tag: repository, tag = utils.parse_repository_tag(repository) registry, repo_name = auth.resolve_repository_name(repository) u = self._url("/images/{0}/push", repository) params = { 'tag': tag } headers = {} if auth_config is None: header = auth.get_config_header(self, registry) if header: headers['X-Registry-Auth'] = header else: log.debug('Sending supplied auth config') headers['X-Registry-Auth'] = auth.encode_header(auth_config) response = self._post_json( u, None, headers=headers, stream=stream, params=params ) self._raise_for_status(response) if stream: return self._stream_helper(response, decode=decode) return self._result(response) @utils.check_resource('image') def remove_image(self, image, force=False, noprune=False): """ Remove an image. Similar to the ``docker rmi`` command. Args: image (str): The image to remove force (bool): Force removal of the image noprune (bool): Do not delete untagged parents """ params = {'force': force, 'noprune': noprune} res = self._delete(self._url("/images/{0}", image), params=params) return self._result(res, True) def search(self, term, limit=None): """ Search for images on Docker Hub. Similar to the ``docker search`` command. Args: term (str): A term to search for. limit (int): The maximum number of results to return. Returns: (list of dicts): The response of the search. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = {'term': term} if limit is not None: params['limit'] = limit return self._result( self._get(self._url("/images/search"), params=params), True ) @utils.check_resource('image') def tag(self, image, repository, tag=None, force=False): """ Tag an image into a repository. Similar to the ``docker tag`` command. Args: image (str): The image to tag repository (str): The repository to set for the tag tag (str): The tag name force (bool): Force Returns: (bool): ``True`` if successful Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> client.api.tag('ubuntu', 'localhost:5000/ubuntu', 'latest', force=True) """ params = { 'tag': tag, 'repo': repository, 'force': 1 if force else 0 } url = self._url("/images/{0}/tag", image) res = self._post(url, params=params) self._raise_for_status(res) return res.status_code == 201 def is_file(src): try: return ( isinstance(src, str) and os.path.isfile(src) ) except TypeError: # a data string will make isfile() raise a TypeError return False def _import_image_params(repo, tag, image=None, src=None, changes=None): params = { 'repo': repo, 'tag': tag, } if image: params['fromImage'] = image elif src and not is_file(src): params['fromSrc'] = src else: params['fromSrc'] = '-' if changes: params['changes'] = changes return params config.py 0000644 00000005222 15027743616 0006377 0 ustar 00 import base64 from .. import utils class ConfigApiMixin: @utils.minimum_version('1.30') def create_config(self, name, data, labels=None, templating=None): """ Create a config Args: name (string): Name of the config data (bytes): Config data to be stored labels (dict): A mapping of labels to assign to the config templating (dict): dictionary containing the name of the templating driver to be used expressed as { name: <templating_driver_name>} Returns (dict): ID of the newly created config """ if not isinstance(data, bytes): data = data.encode('utf-8') data = base64.b64encode(data) data = data.decode('ascii') body = { 'Data': data, 'Name': name, 'Labels': labels, 'Templating': templating } url = self._url('/configs/create') return self._result( self._post_json(url, data=body), True ) @utils.minimum_version('1.30') @utils.check_resource('id') def inspect_config(self, id): """ Retrieve config metadata Args: id (string): Full ID of the config to inspect Returns (dict): A dictionary of metadata Raises: :py:class:`docker.errors.NotFound` if no config with that ID exists """ url = self._url('/configs/{0}', id) return self._result(self._get(url), True) @utils.minimum_version('1.30') @utils.check_resource('id') def remove_config(self, id): """ Remove a config Args: id (string): Full ID of the config to remove Returns (boolean): True if successful Raises: :py:class:`docker.errors.NotFound` if no config with that ID exists """ url = self._url('/configs/{0}', id) res = self._delete(url) self._raise_for_status(res) return True @utils.minimum_version('1.30') def configs(self, filters=None): """ List configs Args: filters (dict): A map of filters to process on the configs list. Available filters: ``names`` Returns (list): A list of configs """ url = self._url('/configs') params = {} if filters: params['filters'] = utils.convert_filters(filters) return self._result(self._get(url, params=params), True) container.py 0000644 00000147152 15027743616 0007125 0 ustar 00 from datetime import datetime from .. import errors, utils from ..constants import DEFAULT_DATA_CHUNK_SIZE from ..types import ( CancellableStream, ContainerConfig, EndpointConfig, HostConfig, NetworkingConfig, ) class ContainerApiMixin: @utils.check_resource('container') def attach(self, container, stdout=True, stderr=True, stream=False, logs=False, demux=False): """ Attach to a container. The ``.logs()`` function is a wrapper around this method, which you can use instead if you want to fetch/stream container output without first retrieving the entire backlog. Args: container (str): The container to attach to. stdout (bool): Include stdout. stderr (bool): Include stderr. stream (bool): Return container output progressively as an iterator of strings, rather than a single string. logs (bool): Include the container's previous output. demux (bool): Keep stdout and stderr separate. Returns: By default, the container's output as a single string (two if ``demux=True``: one for stdout and one for stderr). If ``stream=True``, an iterator of output strings. If ``demux=True``, two iterators are returned: one for stdout and one for stderr. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = { 'logs': logs and 1 or 0, 'stdout': stdout and 1 or 0, 'stderr': stderr and 1 or 0, 'stream': stream and 1 or 0 } headers = { 'Connection': 'Upgrade', 'Upgrade': 'tcp' } u = self._url("/containers/{0}/attach", container) response = self._post(u, headers=headers, params=params, stream=True) output = self._read_from_socket( response, stream, self._check_is_tty(container), demux=demux) if stream: return CancellableStream(output, response) else: return output @utils.check_resource('container') def attach_socket(self, container, params=None, ws=False): """ Like ``attach``, but returns the underlying socket-like object for the HTTP request. Args: container (str): The container to attach to. params (dict): Dictionary of request parameters (e.g. ``stdout``, ``stderr``, ``stream``). For ``detachKeys``, ~/.docker/config.json is used by default. ws (bool): Use websockets instead of raw HTTP. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ if params is None: params = { 'stdout': 1, 'stderr': 1, 'stream': 1 } if 'detachKeys' not in params \ and 'detachKeys' in self._general_configs: params['detachKeys'] = self._general_configs['detachKeys'] if ws: return self._attach_websocket(container, params) headers = { 'Connection': 'Upgrade', 'Upgrade': 'tcp' } u = self._url("/containers/{0}/attach", container) return self._get_raw_response_socket( self.post( u, None, params=self._attach_params(params), stream=True, headers=headers ) ) @utils.check_resource('container') def commit(self, container, repository=None, tag=None, message=None, author=None, pause=True, changes=None, conf=None): """ Commit a container to an image. Similar to the ``docker commit`` command. Args: container (str): The image hash of the container repository (str): The repository to push the image to tag (str): The tag to push message (str): A commit message author (str): The name of the author 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. """ params = { 'container': container, 'repo': repository, 'tag': tag, 'comment': message, 'author': author, 'pause': pause, 'changes': changes } u = self._url("/commit") return self._result( self._post_json(u, data=conf, params=params), json=True ) def containers(self, quiet=False, all=False, trunc=False, latest=False, since=None, before=None, limit=-1, size=False, filters=None): """ List containers. Similar to the ``docker ps`` command. Args: quiet (bool): Only display numeric Ids all (bool): Show all containers. Only running containers are shown by default trunc (bool): Truncate output latest (bool): Show only the latest created container, include non-running ones. since (str): Show only containers created since Id or Name, include non-running ones before (str): Show only container created before Id or Name, include non-running ones limit (int): Show `limit` last created containers, include non-running ones size (bool): Display sizes filters (dict): Filters to be processed on the image list. Available filters: - `exited` (int): Only containers with specified exit code - `status` (str): One of ``restarting``, ``running``, ``paused``, ``exited`` - `label` (str|list): format either ``"key"``, ``"key=value"`` or a list of such. - `id` (str): The id of the container. - `name` (str): The name of the container. - `ancestor` (str): Filter by container ancestor. Format of ``<image-name>[:tag]``, ``<image-id>``, or ``<image@digest>``. - `before` (str): Only containers created before a particular container. Give the container name or id. - `since` (str): Only containers created after a particular container. Give container name or id. A comprehensive list can be found in the documentation for `docker ps <https://docs.docker.com/engine/reference/commandline/ps>`_. Returns: A list of dicts, one per container Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = { 'limit': 1 if latest else limit, 'all': 1 if all else 0, 'size': 1 if size else 0, 'trunc_cmd': 1 if trunc else 0, 'since': since, 'before': before } if filters: params['filters'] = utils.convert_filters(filters) u = self._url("/containers/json") res = self._result(self._get(u, params=params), True) if quiet: return [{'Id': x['Id']} for x in res] if trunc: for x in res: x['Id'] = x['Id'][:12] return res def create_container(self, image, command=None, hostname=None, user=None, detach=False, stdin_open=False, tty=False, ports=None, environment=None, volumes=None, network_disabled=False, name=None, entrypoint=None, working_dir=None, domainname=None, host_config=None, mac_address=None, labels=None, stop_signal=None, networking_config=None, healthcheck=None, stop_timeout=None, runtime=None, use_config_proxy=True, platform=None): """ Creates a container. Parameters are similar to those for the ``docker run`` command except it doesn't support the attach options (``-a``). The arguments that are passed directly to this function are host-independent configuration options. Host-specific configuration is passed with the `host_config` argument. You'll normally want to use this method in combination with the :py:meth:`create_host_config` method to generate ``host_config``. **Port bindings** Port binding is done in two parts: first, provide a list of ports to open inside the container with the ``ports`` parameter, then declare bindings with the ``host_config`` parameter. For example: .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', ports=[1111, 2222], host_config=client.api.create_host_config(port_bindings={ 1111: 4567, 2222: None }) ) You can limit the host address on which the port will be exposed like such: .. code-block:: python client.api.create_host_config( port_bindings={1111: ('127.0.0.1', 4567)} ) Or without host port assignment: .. code-block:: python client.api.create_host_config(port_bindings={1111: ('127.0.0.1',)}) If you wish to use UDP instead of TCP (default), you need to declare ports as such in both the config and host config: .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', ports=[(1111, 'udp'), 2222], host_config=client.api.create_host_config(port_bindings={ '1111/udp': 4567, 2222: None }) ) To bind multiple host ports to a single container port, use the following syntax: .. code-block:: python client.api.create_host_config(port_bindings={ 1111: [1234, 4567] }) You can also bind multiple IPs to a single container port: .. code-block:: python client.api.create_host_config(port_bindings={ 1111: [ ('192.168.0.100', 1234), ('192.168.0.101', 1234) ] }) **Using volumes** Volume declaration is done in two parts. Provide a list of paths to use as mountpoints inside the container with the ``volumes`` parameter, and declare mappings from paths on the host in the ``host_config`` section. .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', volumes=['/mnt/vol1', '/mnt/vol2'], host_config=client.api.create_host_config(binds={ '/home/user1/': { 'bind': '/mnt/vol2', 'mode': 'rw', }, '/var/www': { 'bind': '/mnt/vol1', 'mode': 'ro', }, '/autofs/user1': { 'bind': '/mnt/vol3', 'mode': 'rw', 'propagation': 'shared' } }) ) You can alternatively specify binds as a list. This code is equivalent to the example above: .. code-block:: python container_id = client.api.create_container( 'busybox', 'ls', volumes=['/mnt/vol1', '/mnt/vol2', '/mnt/vol3'], host_config=client.api.create_host_config(binds=[ '/home/user1/:/mnt/vol2', '/var/www:/mnt/vol1:ro', '/autofs/user1:/mnt/vol3:rw,shared', ]) ) **Networking** You can specify networks to connect the container to by using the ``networking_config`` parameter. At the time of creation, you can only connect a container to a single networking, but you can create more connections by using :py:meth:`~connect_container_to_network`. For example: .. code-block:: python networking_config = client.api.create_networking_config({ 'network1': client.api.create_endpoint_config( ipv4_address='172.28.0.124', aliases=['foo', 'bar'], links=['container2'] ) }) ctnr = client.api.create_container( img, command, networking_config=networking_config ) Args: image (str): The image to run command (str or list): The command to be run in the container hostname (str): Optional hostname for the container user (str or int): Username or UID detach (bool): Detached mode: run container in the background and return container ID stdin_open (bool): Keep STDIN open even if not attached tty (bool): Allocate a pseudo-TTY ports (list of ints): A list of port numbers environment (dict or list): A dictionary or a list of strings in the following format ``["PASSWORD=xxx"]`` or ``{"PASSWORD": "xxx"}``. volumes (str or list): List of paths inside the container to use as volumes. network_disabled (bool): Disable networking name (str): A name for the container entrypoint (str or list): An entrypoint working_dir (str): Path to the working directory domainname (str): The domain name to use for the container host_config (dict): A dictionary created with :py:meth:`create_host_config`. mac_address (str): The Mac Address to assign the container labels (dict or list): A dictionary of name-value labels (e.g. ``{"label1": "value1", "label2": "value2"}``) or a list of names of labels to set with empty values (e.g. ``["label1", "label2"]``) stop_signal (str): The stop signal to use to stop the container (e.g. ``SIGINT``). stop_timeout (int): Timeout to stop the container, in seconds. Default: 10 networking_config (dict): A networking configuration generated by :py:meth:`create_networking_config`. runtime (str): Runtime to use with this container. healthcheck (dict): Specify a test to perform to check that the container is healthy. use_config_proxy (bool): If ``True``, and if the docker client configuration file (``~/.docker/config.json`` by default) contains a proxy configuration, the corresponding environment variables will be set in the container being created. platform (str): Platform in the format ``os[/arch[/variant]]``. Returns: A dictionary with an image 'Id' key and a 'Warnings' key. Raises: :py:class:`docker.errors.ImageNotFound` If the specified image does not exist. :py:class:`docker.errors.APIError` If the server returns an error. """ if isinstance(volumes, str): volumes = [volumes, ] if isinstance(environment, dict): environment = utils.utils.format_environment(environment) if use_config_proxy: environment = self._proxy_configs.inject_proxy_environment( environment ) or None config = self.create_container_config( image, command, hostname, user, detach, stdin_open, tty, ports, environment, volumes, network_disabled, entrypoint, working_dir, domainname, host_config, mac_address, labels, stop_signal, networking_config, healthcheck, stop_timeout, runtime ) return self.create_container_from_config(config, name, platform) def create_container_config(self, *args, **kwargs): return ContainerConfig(self._version, *args, **kwargs) def create_container_from_config(self, config, name=None, platform=None): u = self._url("/containers/create") params = { 'name': name } if platform: if utils.version_lt(self._version, '1.41'): raise errors.InvalidVersion( 'platform is not supported for API version < 1.41' ) params['platform'] = platform res = self._post_json(u, data=config, params=params) return self._result(res, True) def create_host_config(self, *args, **kwargs): """ Create a dictionary for the ``host_config`` argument to :py:meth:`create_container`. Args: auto_remove (bool): enable auto-removal of the container on daemon side when the container's process exits. binds (dict): Volumes to bind. See :py:meth:`create_container` for more information. blkio_weight_device: Block IO weight (relative device weight) in the form of: ``[{"Path": "device_path", "Weight": weight}]``. blkio_weight: Block IO weight (relative weight), accepts a weight value between 10 and 1000. cap_add (list of str): Add kernel capabilities. For example, ``["SYS_ADMIN", "MKNOD"]``. cap_drop (list of str): Drop kernel capabilities. cpu_period (int): The length of a CPU period in microseconds. cpu_quota (int): Microseconds of CPU time that the container can get in a CPU period. cpu_shares (int): CPU shares (relative weight). cpuset_cpus (str): CPUs in which to allow execution (``0-3``, ``0,1``). cpuset_mems (str): Memory nodes (MEMs) in which to allow execution (``0-3``, ``0,1``). Only effective on NUMA systems. device_cgroup_rules (:py:class:`list`): A list of cgroup rules to apply to the container. device_read_bps: Limit read rate (bytes per second) from a device in the form of: `[{"Path": "device_path", "Rate": rate}]` device_read_iops: Limit read rate (IO per second) from a device. device_write_bps: Limit write rate (bytes per second) from a device. device_write_iops: Limit write rate (IO per second) from a device. devices (:py:class:`list`): Expose host devices to the container, as a list of strings in the form ``<path_on_host>:<path_in_container>:<cgroup_permissions>``. For example, ``/dev/sda:/dev/xvda:rwm`` allows the container to have read-write access to the host's ``/dev/sda`` via a node named ``/dev/xvda`` inside the container. device_requests (:py:class:`list`): Expose host resources such as GPUs to the container, as a list of :py:class:`docker.types.DeviceRequest` instances. dns (:py:class:`list`): Set custom DNS servers. dns_opt (:py:class:`list`): Additional options to be added to the container's ``resolv.conf`` file dns_search (:py:class:`list`): DNS search domains. extra_hosts (dict): Additional hostnames to resolve inside the container, as a mapping of hostname to IP address. group_add (:py:class:`list`): List of additional group names and/or IDs that the container process will run as. init (bool): Run an init inside the container that forwards signals and reaps processes ipc_mode (str): Set the IPC mode for the container. isolation (str): Isolation technology to use. Default: ``None``. links (dict): Mapping of links using the ``{'container': 'alias'}`` format. The alias is optional. Containers declared in this dict will be linked to the new container using the provided alias. Default: ``None``. log_config (LogConfig): Logging configuration lxc_conf (dict): LXC config. mem_limit (float or str): Memory limit. Accepts float values (which represent the memory limit of the created container in bytes) or a string with a units identification char (``100000b``, ``1000k``, ``128m``, ``1g``). If a string is specified without a units character, bytes are assumed as an mem_reservation (float or str): Memory soft limit. mem_swappiness (int): Tune a container's memory swappiness behavior. Accepts number between 0 and 100. memswap_limit (str or int): Maximum amount of memory + swap a container is allowed to consume. mounts (:py:class:`list`): Specification for mounts to be added to the container. More powerful alternative to ``binds``. Each item in the list is expected to be a :py:class:`docker.types.Mount` object. network_mode (str): One of: - ``bridge`` Create a new network stack for the container on the bridge network. - ``none`` No networking for this container. - ``container:<name|id>`` Reuse another container's network stack. - ``host`` Use the host network stack. This mode is incompatible with ``port_bindings``. oom_kill_disable (bool): Whether to disable OOM killer. oom_score_adj (int): An integer value containing the score given to the container in order to tune OOM killer preferences. pid_mode (str): If set to ``host``, use the host PID namespace inside the container. pids_limit (int): Tune a container's pids limit. Set ``-1`` for unlimited. port_bindings (dict): See :py:meth:`create_container` for more information. Imcompatible with ``host`` in ``network_mode``. privileged (bool): Give extended privileges to this container. publish_all_ports (bool): Publish all ports to the host. read_only (bool): Mount the container's root filesystem as read only. restart_policy (dict): Restart the container when it exits. Configured as a dictionary with keys: - ``Name`` One of ``on-failure``, or ``always``. - ``MaximumRetryCount`` Number of times to restart the container on failure. security_opt (:py:class:`list`): A list of string values to customize labels for MLS systems, such as SELinux. shm_size (str or int): Size of /dev/shm (e.g. ``1G``). storage_opt (dict): Storage driver options per container as a key-value mapping. sysctls (dict): Kernel parameters to set in the container. tmpfs (dict): Temporary filesystems to mount, as a dictionary mapping a path inside the container to options for that path. For example: .. code-block:: python { '/mnt/vol2': '', '/mnt/vol1': 'size=3G,uid=1000' } ulimits (:py:class:`list`): Ulimits to set inside the container, as a list of :py:class:`docker.types.Ulimit` instances. userns_mode (str): Sets the user namespace mode for the container when user namespace remapping option is enabled. Supported values are: ``host`` uts_mode (str): Sets the UTS namespace mode for the container. Supported values are: ``host`` volumes_from (:py:class:`list`): List of container names or IDs to get volumes from. runtime (str): Runtime to use with this container. Returns: (dict) A dictionary which can be passed to the ``host_config`` argument to :py:meth:`create_container`. Example: >>> client.api.create_host_config( ... privileged=True, ... cap_drop=['MKNOD'], ... volumes_from=['nostalgic_newton'], ... ) {'CapDrop': ['MKNOD'], 'LxcConf': None, 'Privileged': True, 'VolumesFrom': ['nostalgic_newton'], 'PublishAllPorts': False} """ if not kwargs: kwargs = {} if 'version' in kwargs: raise TypeError( "create_host_config() got an unexpected " "keyword argument 'version'" ) kwargs['version'] = self._version return HostConfig(*args, **kwargs) def create_networking_config(self, *args, **kwargs): """ Create a networking config dictionary to be used as the ``networking_config`` parameter in :py:meth:`create_container`. Args: endpoints_config (dict): A dictionary mapping network names to endpoint configurations generated by :py:meth:`create_endpoint_config`. Returns: (dict) A networking config. Example: >>> client.api.create_network('network1') >>> networking_config = client.api.create_networking_config({ 'network1': client.api.create_endpoint_config() }) >>> container = client.api.create_container( img, command, networking_config=networking_config ) """ return NetworkingConfig(*args, **kwargs) def create_endpoint_config(self, *args, **kwargs): """ Create an endpoint config dictionary to be used with :py:meth:`create_networking_config`. Args: aliases (:py:class:`list`): A list of aliases for this endpoint. Names in that list can be used within the network to reach the container. Defaults to ``None``. links (dict): Mapping of links for this endpoint using the ``{'container': 'alias'}`` format. The alias is optional. Containers declared in this dict will be linked to this container using the provided alias. Defaults to ``None``. ipv4_address (str): The IP address of this container on the network, using the IPv4 protocol. Defaults to ``None``. ipv6_address (str): The IP address of this container on the network, using the IPv6 protocol. Defaults to ``None``. link_local_ips (:py:class:`list`): A list of link-local (IPv4/IPv6) addresses. driver_opt (dict): A dictionary of options to provide to the network driver. Defaults to ``None``. Returns: (dict) An endpoint config. Example: >>> endpoint_config = client.api.create_endpoint_config( aliases=['web', 'app'], links={'app_db': 'db', 'another': None}, ipv4_address='132.65.0.123' ) """ return EndpointConfig(self._version, *args, **kwargs) @utils.check_resource('container') def diff(self, container): """ Inspect changes on a container's filesystem. Args: container (str): The container to diff 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._result( self._get(self._url("/containers/{0}/changes", container)), True ) @utils.check_resource('container') def export(self, container, chunk_size=DEFAULT_DATA_CHUNK_SIZE): """ Export the contents of a filesystem as a tar archive. Args: container (str): The container to export chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB Returns: (generator): The archived filesystem data stream Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ res = self._get( self._url("/containers/{0}/export", container), stream=True ) return self._stream_raw_result(res, chunk_size, False) @utils.check_resource('container') def get_archive(self, container, path, chunk_size=DEFAULT_DATA_CHUNK_SIZE, encode_stream=False): """ Retrieve a file or folder from a container in the form of a tar archive. Args: container (str): The container where the file is located path (str): Path to the file or folder to retrieve chunk_size (int): The number of bytes returned by each iteration of the generator. If ``None``, data will be streamed as it is received. Default: 2 MB encode_stream (bool): Determines if data should be encoded (gzip-compressed) during transmission. Default: False Returns: (tuple): First element is a raw tar data stream. Second element is a dict containing ``stat`` information on the specified ``path``. Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: >>> c = docker.APIClient() >>> f = open('./sh_bin.tar', 'wb') >>> bits, stat = c.api.get_archive(container, '/bin/sh') >>> print(stat) {'name': 'sh', 'size': 1075464, 'mode': 493, 'mtime': '2018-10-01T15:37:48-07:00', 'linkTarget': ''} >>> for chunk in bits: ... f.write(chunk) >>> f.close() """ params = { 'path': path } headers = { "Accept-Encoding": "gzip, deflate" } if encode_stream else { "Accept-Encoding": "identity" } url = self._url('/containers/{0}/archive', container) res = self._get(url, params=params, stream=True, headers=headers) self._raise_for_status(res) encoded_stat = res.headers.get('x-docker-container-path-stat') return ( self._stream_raw_result(res, chunk_size, False), utils.decode_json_header(encoded_stat) if encoded_stat else None ) @utils.check_resource('container') def inspect_container(self, container): """ Identical to the `docker inspect` command, but only for containers. Args: container (str): The container to inspect Returns: (dict): Similar to the output of `docker inspect`, but as a single dict Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ return self._result( self._get(self._url("/containers/{0}/json", container)), True ) @utils.check_resource('container') def kill(self, container, signal=None): """ Kill a container or send a signal to a container. Args: container (str): The container to kill signal (str or int): The signal to send. Defaults to ``SIGKILL`` Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url("/containers/{0}/kill", container) params = {} if signal is not None: if not isinstance(signal, str): signal = int(signal) params['signal'] = signal res = self._post(url, params=params) self._raise_for_status(res) @utils.check_resource('container') def logs(self, container, stdout=True, stderr=True, stream=False, timestamps=False, tail='all', since=None, follow=None, until=None): """ Get logs from a container. Similar to the ``docker logs`` command. The ``stream`` parameter makes the ``logs`` function return a blocking generator you can iterate over to retrieve log output as it happens. Args: container (str): The container to get logs from stdout (bool): Get ``STDOUT``. Default ``True`` stderr (bool): Get ``STDERR``. Default ``True`` stream (bool): Stream the response. Default ``False`` timestamps (bool): Show timestamps. Default ``False`` tail (str or int): Output specified number of lines at the end of logs. Either an integer of number of lines or the string ``all``. Default ``all`` since (datetime, int, or float): Show logs since a given datetime, integer epoch (in seconds) or float (in fractional seconds) 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 fractional seconds) Returns: (generator of bytes or bytes) Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ if follow is None: follow = stream params = {'stderr': stderr and 1 or 0, 'stdout': stdout and 1 or 0, 'timestamps': timestamps and 1 or 0, 'follow': follow and 1 or 0, } if tail != 'all' and (not isinstance(tail, int) or tail < 0): tail = 'all' params['tail'] = tail if since is not None: if isinstance(since, datetime): params['since'] = utils.datetime_to_timestamp(since) elif (isinstance(since, int) and since > 0): params['since'] = since elif (isinstance(since, float) and since > 0.0): params['since'] = since else: raise errors.InvalidArgument( 'since value should be datetime or positive int/float,' f' not {type(since)}' ) if until is not None: if utils.version_lt(self._version, '1.35'): raise errors.InvalidVersion( 'until is not supported for API version < 1.35' ) if isinstance(until, datetime): params['until'] = utils.datetime_to_timestamp(until) elif (isinstance(until, int) and until > 0): params['until'] = until elif (isinstance(until, float) and until > 0.0): params['until'] = until else: raise errors.InvalidArgument( f'until value should be datetime or positive int/float, ' f'not {type(until)}' ) url = self._url("/containers/{0}/logs", container) res = self._get(url, params=params, stream=stream) output = self._get_result(container, stream, res) if stream: return CancellableStream(output, res) else: return output @utils.check_resource('container') def pause(self, container): """ Pauses all processes within a container. Args: container (str): The container to pause Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/containers/{0}/pause', container) res = self._post(url) self._raise_for_status(res) @utils.check_resource('container') def port(self, container, private_port): """ Lookup the public-facing port that is NAT-ed to ``private_port``. Identical to the ``docker port`` command. Args: container (str): The container to look up private_port (int): The private port to inspect Returns: (list of dict): The mapping for the host ports Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: .. code-block:: bash $ docker run -d -p 80:80 ubuntu:14.04 /bin/sleep 30 7174d6347063a83f412fad6124c99cffd25ffe1a0807eb4b7f9cec76ac8cb43b .. code-block:: python >>> client.api.port('7174d6347063', 80) [{'HostIp': '0.0.0.0', 'HostPort': '80'}] """ res = self._get(self._url("/containers/{0}/json", container)) self._raise_for_status(res) json_ = res.json() private_port = str(private_port) h_ports = None # Port settings is None when the container is running with # network_mode=host. port_settings = json_.get('NetworkSettings', {}).get('Ports') if port_settings is None: return None if '/' in private_port: return port_settings.get(private_port) for protocol in ['tcp', 'udp', 'sctp']: h_ports = port_settings.get(f"{private_port}/{protocol}") if h_ports: break return h_ports @utils.check_resource('container') def put_archive(self, container, path, data): """ Insert a file or folder in an existing container using a tar archive as source. Args: container (str): The container where the file(s) will be extracted path (str): Path inside the container where the file(s) will be extracted. Must exist. data (bytes or stream): tar data to be extracted Returns: (bool): True if the call succeeds. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = {'path': path} url = self._url('/containers/{0}/archive', container) res = self._put(url, params=params, data=data) self._raise_for_status(res) return res.status_code == 200 @utils.minimum_version('1.25') def prune_containers(self, filters=None): """ Delete stopped containers Args: filters (dict): Filters to process on the prune list. Returns: (dict): A dict containing a list of deleted container IDs and the amount of disk space reclaimed in bytes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = {} if filters: params['filters'] = utils.convert_filters(filters) url = self._url('/containers/prune') return self._result(self._post(url, params=params), True) @utils.check_resource('container') def remove_container(self, container, v=False, link=False, force=False): """ Remove a container. Similar to the ``docker rm`` command. Args: container (str): The container to remove v (bool): Remove the volumes associated with the container link (bool): Remove the specified link and not the underlying container force (bool): Force the removal of a running container (uses ``SIGKILL``) Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = {'v': v, 'link': link, 'force': force} res = self._delete( self._url("/containers/{0}", container), params=params ) self._raise_for_status(res) @utils.check_resource('container') def rename(self, container, name): """ Rename a container. Similar to the ``docker rename`` command. Args: container (str): ID of the container to rename name (str): New name for the container Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url("/containers/{0}/rename", container) params = {'name': name} res = self._post(url, params=params) self._raise_for_status(res) @utils.check_resource('container') def resize(self, container, height, width): """ Resize the tty session. Args: container (str or dict): The container to resize height (int): Height of tty session width (int): Width of tty session Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = {'h': height, 'w': width} url = self._url("/containers/{0}/resize", container) res = self._post(url, params=params) self._raise_for_status(res) @utils.check_resource('container') def restart(self, container, timeout=10): """ Restart a container. Similar to the ``docker restart`` command. Args: container (str or dict): The container to restart. If a dict, the ``Id`` key is used. timeout (int): Number of seconds to try to stop for before killing the container. Once killed it will then be restarted. Default is 10 seconds. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = {'t': timeout} url = self._url("/containers/{0}/restart", container) conn_timeout = self.timeout if conn_timeout is not None: conn_timeout += timeout res = self._post(url, params=params, timeout=conn_timeout) self._raise_for_status(res) @utils.check_resource('container') def start(self, container, *args, **kwargs): """ Start a container. Similar to the ``docker start`` command, but doesn't support attach options. **Deprecation warning:** Passing configuration options in ``start`` is no longer supported. Users are expected to provide host config options in the ``host_config`` parameter of :py:meth:`~ContainerApiMixin.create_container`. Args: container (str): The container to start Raises: :py:class:`docker.errors.APIError` If the server returns an error. :py:class:`docker.errors.DeprecatedMethod` If any argument besides ``container`` are provided. Example: >>> container = client.api.create_container( ... image='busybox:latest', ... command='/bin/sleep 30') >>> client.api.start(container=container.get('Id')) """ if args or kwargs: raise errors.DeprecatedMethod( 'Providing configuration in the start() method is no longer ' 'supported. Use the host_config param in create_container ' 'instead.' ) url = self._url("/containers/{0}/start", container) res = self._post(url) self._raise_for_status(res) @utils.check_resource('container') def stats(self, container, decode=None, stream=True, one_shot=None): """ Stream statistics for a specific container. Similar to the ``docker stats`` command. Args: container (str): The container to stream statistics from decode (bool): If set to true, stream will be decoded into dicts on the fly. Only applicable if ``stream`` is True. False by default. stream (bool): If set to false, only the current stats will be returned instead of a stream. True by default. one_shot (bool): If set to true, Only get a single stat instead of waiting for 2 cycles. Must be used with stream=false. False by default. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url("/containers/{0}/stats", container) params = { 'stream': stream } if one_shot is not None: if utils.version_lt(self._version, '1.41'): raise errors.InvalidVersion( 'one_shot is not supported for API version < 1.41' ) params['one-shot'] = one_shot if stream: if one_shot: raise errors.InvalidArgument( 'one_shot is only available in conjunction with ' 'stream=False' ) return self._stream_helper( self._get(url, stream=True, params=params), decode=decode ) else: if decode: raise errors.InvalidArgument( "decode is only available in conjunction with stream=True" ) return self._result(self._get(url, params=params), json=True) @utils.check_resource('container') def stop(self, container, timeout=None): """ Stops a container. Similar to the ``docker stop`` command. Args: container (str): The container to stop timeout (int): Timeout in seconds to wait for the container to stop before sending a ``SIGKILL``. If None, then the StopTimeout value of the container will be used. Default: None Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ if timeout is None: params = {} timeout = 10 else: params = {'t': timeout} url = self._url("/containers/{0}/stop", container) conn_timeout = self.timeout if conn_timeout is not None: conn_timeout += timeout res = self._post(url, params=params, timeout=conn_timeout) self._raise_for_status(res) @utils.check_resource('container') def top(self, container, ps_args=None): """ Display the running processes of a container. Args: container (str): The container to inspect ps_args (str): An optional arguments passed to ps (e.g. ``aux``) Returns: (str): The output of the top Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ u = self._url("/containers/{0}/top", container) params = {} if ps_args is not None: params['ps_args'] = ps_args return self._result(self._get(u, params=params), True) @utils.check_resource('container') def unpause(self, container): """ Unpause all processes within a container. Args: container (str): The container to unpause """ url = self._url('/containers/{0}/unpause', container) res = self._post(url) self._raise_for_status(res) @utils.minimum_version('1.22') @utils.check_resource('container') def update_container( self, container, blkio_weight=None, cpu_period=None, cpu_quota=None, cpu_shares=None, cpuset_cpus=None, cpuset_mems=None, mem_limit=None, mem_reservation=None, memswap_limit=None, kernel_memory=None, restart_policy=None ): """ Update resource configs of one or more containers. Args: container (str): The container to inspect blkio_weight (int): Block IO (relative weight), between 10 and 1000 cpu_period (int): Limit CPU CFS (Completely Fair Scheduler) period cpu_quota (int): Limit CPU CFS (Completely Fair Scheduler) quota cpu_shares (int): CPU shares (relative weight) cpuset_cpus (str): CPUs in which to allow execution cpuset_mems (str): MEMs in which to allow execution mem_limit (float or str): Memory limit mem_reservation (float or str): Memory soft limit memswap_limit (int or str): Total memory (memory + swap), -1 to disable swap kernel_memory (int or str): Kernel memory limit restart_policy (dict): Restart policy dictionary Returns: (dict): Dictionary containing a ``Warnings`` key. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url('/containers/{0}/update', container) data = {} if blkio_weight: data['BlkioWeight'] = blkio_weight if cpu_period: data['CpuPeriod'] = cpu_period if cpu_shares: data['CpuShares'] = cpu_shares if cpu_quota: data['CpuQuota'] = cpu_quota if cpuset_cpus: data['CpusetCpus'] = cpuset_cpus if cpuset_mems: data['CpusetMems'] = cpuset_mems if mem_limit: data['Memory'] = utils.parse_bytes(mem_limit) if mem_reservation: data['MemoryReservation'] = utils.parse_bytes(mem_reservation) if memswap_limit: data['MemorySwap'] = utils.parse_bytes(memswap_limit) if kernel_memory: data['KernelMemory'] = utils.parse_bytes(kernel_memory) if restart_policy: if utils.version_lt(self._version, '1.23'): raise errors.InvalidVersion( 'restart policy update is not supported ' 'for API version < 1.23' ) data['RestartPolicy'] = restart_policy res = self._post_json(url, data=data) return self._result(res, True) @utils.check_resource('container') def wait(self, container, timeout=None, condition=None): """ Block until a container stops, then return its exit code. Similar to the ``docker wait`` command. Args: container (str or dict): The container to wait on. If a dict, the ``Id`` key is used. timeout (int): Request timeout condition (str): Wait until a container state reaches the given condition, either ``not-running`` (default), ``next-exit``, or ``removed`` Returns: (dict): The API's response as a Python dictionary, including the container's exit code under the ``StatusCode`` attribute. Raises: :py:class:`requests.exceptions.ReadTimeout` If the timeout is exceeded. :py:class:`docker.errors.APIError` If the server returns an error. """ url = self._url("/containers/{0}/wait", container) params = {} if condition is not None: if utils.version_lt(self._version, '1.30'): raise errors.InvalidVersion( 'wait condition is not supported for API version < 1.30' ) params['condition'] = condition res = self._post(url, timeout=timeout, params=params) return self._result(res, True) network.py 0000644 00000024660 15027743616 0006632 0 ustar 00 from .. import utils from ..errors import InvalidVersion from ..utils import check_resource, minimum_version, version_lt class NetworkApiMixin: def networks(self, names=None, ids=None, filters=None): """ 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=[<key>]``, ``label=[<key>=<value>]`` or a list of such. - ``type=["custom"|"builtin"]`` Filters networks by type. Returns: (dict): List of network objects. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ if filters is None: filters = {} if names: filters['name'] = names if ids: filters['id'] = ids params = {'filters': utils.convert_filters(filters)} url = self._url("/networks") res = self._get(url, params=params) return self._result(res, json=True) def create_network(self, name, driver=None, options=None, ipam=None, check_duplicate=None, internal=False, labels=None, enable_ipv6=False, attachable=None, scope=None, ingress=None): """ 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: (dict): The created network reference object Raises: :py:class:`docker.errors.APIError` If the server returns an error. Example: A network using the bridge driver: >>> client.api.create_network("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.api.create_network("network1", driver="bridge", ipam=ipam_config) """ if options is not None and not isinstance(options, dict): raise TypeError('options must be a dictionary') data = { 'Name': name, 'Driver': driver, 'Options': options, 'IPAM': ipam, 'CheckDuplicate': check_duplicate, } if labels is not None: if version_lt(self._version, '1.23'): raise InvalidVersion( 'network labels were introduced in API 1.23' ) if not isinstance(labels, dict): raise TypeError('labels must be a dictionary') data["Labels"] = labels if enable_ipv6: if version_lt(self._version, '1.23'): raise InvalidVersion( 'enable_ipv6 was introduced in API 1.23' ) data['EnableIPv6'] = True if internal: if version_lt(self._version, '1.22'): raise InvalidVersion('Internal networks are not ' 'supported in API version < 1.22') data['Internal'] = True if attachable is not None: if version_lt(self._version, '1.24'): raise InvalidVersion( 'attachable is not supported in API version < 1.24' ) data['Attachable'] = attachable if ingress is not None: if version_lt(self._version, '1.29'): raise InvalidVersion( 'ingress is not supported in API version < 1.29' ) data['Ingress'] = ingress if scope is not None: if version_lt(self._version, '1.30'): raise InvalidVersion( 'scope is not supported in API version < 1.30' ) data['Scope'] = scope url = self._url("/networks/create") res = self._post_json(url, data=data) return self._result(res, json=True) @minimum_version('1.25') def prune_networks(self, filters=None): """ Delete unused networks Args: filters (dict): Filters to process on the prune list. Returns: (dict): A dict containing a list of deleted network names and the amount of disk space reclaimed in bytes. Raises: :py:class:`docker.errors.APIError` If the server returns an error. """ params = {} if filters: params['filters'] = utils.convert_filters(filters) url = self._url('/networks/prune') return self._result(self._post(url, params=params), True) @check_resource('net_id') def remove_network(self, net_id): """ Remove a network. Similar to the ``docker network rm`` command. Args: net_id (str): The network's id """ url = self._url("/networks/{0}", net_id) res = self._delete(url) self._raise_for_status(res) @check_resource('net_id') def inspect_network(self, net_id, verbose=None, scope=None): """ Get detailed information about a network. Args: net_id (str): ID of network verbose (bool): Show the service details across the cluster in swarm mode. scope (str): Filter the network by scope (``swarm``, ``global`` or ``local``). """ params = {} if verbose is not None: if version_lt(self._version, '1.28'): raise InvalidVersion('verbose was introduced in API 1.28') params['verbose'] = verbose if scope is not None: if version_lt(self._version, '1.31'): raise InvalidVersion('scope was introduced in API 1.31') params['scope'] = scope url = self._url("/networks/{0}", net_id) res = self._get(url, params=params) return self._result(res, json=True) @check_resource('container') def connect_container_to_network(self, container, net_id, ipv4_address=None, ipv6_address=None, aliases=None, links=None, link_local_ips=None, driver_opt=None, mac_address=None): """ Connect a container to a network. Args: container (str): container-id/name to be connected to the network net_id (str): network id 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 linked to 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. mac_address (str): The MAC address of this container on the network. Defaults to ``None``. """ data = { "Container": container, "EndpointConfig": self.create_endpoint_config( aliases=aliases, links=links, ipv4_address=ipv4_address, ipv6_address=ipv6_address, link_local_ips=link_local_ips, driver_opt=driver_opt, mac_address=mac_address ), } url = self._url("/networks/{0}/connect", net_id) res = self._post_json(url, data=data) self._raise_for_status(res) @check_resource('container') def disconnect_container_from_network(self, container, net_id, force=False): """ Disconnect a container from a network. Args: container (str): container ID or name to be disconnected from the network net_id (str): network ID force (bool): Force the container to disconnect from a network. Default: ``False`` """ data = {"Container": container} if force: if version_lt(self._version, '1.22'): raise InvalidVersion( 'Forced disconnect was introduced in API 1.22' ) data['Force'] = force url = self._url("/networks/{0}/disconnect", net_id) res = self._post_json(url, data=data) self._raise_for_status(res) client.py 0000644 00000045745 15027743616 0006426 0 ustar 00 import json import struct import urllib from functools import partial import requests import requests.adapters import requests.exceptions from .. import auth from ..constants import ( DEFAULT_MAX_POOL_SIZE, DEFAULT_NUM_POOLS, DEFAULT_NUM_POOLS_SSH, DEFAULT_TIMEOUT_SECONDS, DEFAULT_USER_AGENT, IS_WINDOWS_PLATFORM, MINIMUM_DOCKER_API_VERSION, STREAM_HEADER_SIZE_BYTES, ) from ..errors import ( DockerException, InvalidVersion, TLSParameterError, create_api_error_from_http_exception, ) from ..tls import TLSConfig from ..transport import UnixHTTPAdapter from ..utils import check_resource, config, update_headers, utils from ..utils.json_stream import json_stream from ..utils.proxy import ProxyConfig from ..utils.socket import consume_socket_output, demux_adaptor, frames_iter from .build import BuildApiMixin from .config import ConfigApiMixin from .container import ContainerApiMixin from .daemon import DaemonApiMixin from .exec_api import ExecApiMixin from .image import ImageApiMixin from .network import NetworkApiMixin from .plugin import PluginApiMixin from .secret import SecretApiMixin from .service import ServiceApiMixin from .swarm import SwarmApiMixin from .volume import VolumeApiMixin try: from ..transport import NpipeHTTPAdapter except ImportError: pass try: from ..transport import SSHHTTPAdapter except ImportError: pass class APIClient( requests.Session, BuildApiMixin, ConfigApiMixin, ContainerApiMixin, DaemonApiMixin, ExecApiMixin, ImageApiMixin, NetworkApiMixin, PluginApiMixin, SecretApiMixin, ServiceApiMixin, SwarmApiMixin, VolumeApiMixin): """ A low-level client for the Docker Engine API. Example: >>> import docker >>> client = docker.APIClient(base_url='unix://var/run/docker.sock') >>> client.version() {u'ApiVersion': u'1.33', u'Arch': u'amd64', u'BuildTime': u'2017-11-19T18:46:37.000000000+00:00', u'GitCommit': u'f4ffd2511c', u'GoVersion': u'go1.9.2', u'KernelVersion': u'4.14.3-1-ARCH', u'MinAPIVersion': u'1.12', u'Os': u'linux', u'Version': u'17.10.0-ce'} Args: base_url (str): URL to the Docker server. For example, ``unix:///var/run/docker.sock`` or ``tcp://127.0.0.1:1234``. version (str): The version of the API to use. Set to ``auto`` to automatically detect the server's version. Default: ``1.35`` timeout (int): Default timeout for API calls, in seconds. tls (bool or :py:class:`~docker.tls.TLSConfig`): Enable TLS. Pass ``True`` to enable it with default options, or pass a :py:class:`~docker.tls.TLSConfig` object to use custom configuration. user_agent (str): Set a custom user agent for requests to the server. credstore_env (dict): Override environment variables when calling the credential store process. use_ssh_client (bool): If set to `True`, an ssh connection is made via shelling out to the ssh client. Ensure the ssh client is installed and configured on the host. max_pool_size (int): The maximum number of connections to save in the pool. """ __attrs__ = requests.Session.__attrs__ + ['_auth_configs', '_general_configs', '_version', 'base_url', 'timeout'] def __init__(self, base_url=None, version=None, timeout=DEFAULT_TIMEOUT_SECONDS, tls=False, user_agent=DEFAULT_USER_AGENT, num_pools=None, credstore_env=None, use_ssh_client=False, max_pool_size=DEFAULT_MAX_POOL_SIZE): super().__init__() if tls and not base_url: raise TLSParameterError( 'If using TLS, the base_url argument must be provided.' ) self.base_url = base_url self.timeout = timeout self.headers['User-Agent'] = user_agent self._general_configs = config.load_general_config() proxy_config = self._general_configs.get('proxies', {}) try: proxies = proxy_config[base_url] except KeyError: proxies = proxy_config.get('default', {}) self._proxy_configs = ProxyConfig.from_dict(proxies) self._auth_configs = auth.load_config( config_dict=self._general_configs, credstore_env=credstore_env, ) self.credstore_env = credstore_env base_url = utils.parse_host( base_url, IS_WINDOWS_PLATFORM, tls=bool(tls) ) # SSH has a different default for num_pools to all other adapters num_pools = num_pools or DEFAULT_NUM_POOLS_SSH if \ base_url.startswith('ssh://') else DEFAULT_NUM_POOLS if base_url.startswith('http+unix://'): self._custom_adapter = UnixHTTPAdapter( base_url, timeout, pool_connections=num_pools, max_pool_size=max_pool_size ) self.mount('http+docker://', self._custom_adapter) self._unmount('http://', 'https://') # host part of URL should be unused, but is resolved by requests # module in proxy_bypass_macosx_sysconf() self.base_url = 'http+docker://localhost' elif base_url.startswith('npipe://'): if not IS_WINDOWS_PLATFORM: raise DockerException( 'The npipe:// protocol is only supported on Windows' ) try: self._custom_adapter = NpipeHTTPAdapter( base_url, timeout, pool_connections=num_pools, max_pool_size=max_pool_size ) except NameError as err: raise DockerException( 'Install pypiwin32 package to enable npipe:// support' ) from err self.mount('http+docker://', self._custom_adapter) self.base_url = 'http+docker://localnpipe' elif base_url.startswith('ssh://'): try: self._custom_adapter = SSHHTTPAdapter( base_url, timeout, pool_connections=num_pools, max_pool_size=max_pool_size, shell_out=use_ssh_client ) except NameError as err: raise DockerException( 'Install paramiko package to enable ssh:// support' ) from err self.mount('http+docker://ssh', self._custom_adapter) self._unmount('http://', 'https://') self.base_url = 'http+docker://ssh' else: # Use SSLAdapter for the ability to specify SSL version if isinstance(tls, TLSConfig): tls.configure_client(self) elif tls: self._custom_adapter = requests.adapters.HTTPAdapter( pool_connections=num_pools) self.mount('https://', self._custom_adapter) self.base_url = base_url # version detection needs to be after unix adapter mounting if version is None or (isinstance( version, str ) and version.lower() == 'auto'): self._version = self._retrieve_server_version() else: self._version = version if not isinstance(self._version, str): raise DockerException( 'Version parameter must be a string or None. ' f'Found {type(version).__name__}' ) if utils.version_lt(self._version, MINIMUM_DOCKER_API_VERSION): raise InvalidVersion( f'API versions below {MINIMUM_DOCKER_API_VERSION} are ' f'no longer supported by this library.' ) def _retrieve_server_version(self): try: return self.version(api_version=False)["ApiVersion"] except KeyError as ke: raise DockerException( 'Invalid response from docker daemon: key "ApiVersion"' ' is missing.' ) from ke except Exception as e: raise DockerException( f'Error while fetching server API version: {e}' ) from e def _set_request_timeout(self, kwargs): """Prepare the kwargs for an HTTP request by inserting the timeout parameter, if not already present.""" kwargs.setdefault('timeout', self.timeout) return kwargs @update_headers def _post(self, url, **kwargs): return self.post(url, **self._set_request_timeout(kwargs)) @update_headers def _get(self, url, **kwargs): return self.get(url, **self._set_request_timeout(kwargs)) @update_headers def _put(self, url, **kwargs): return self.put(url, **self._set_request_timeout(kwargs)) @update_headers def _delete(self, url, **kwargs): return self.delete(url, **self._set_request_timeout(kwargs)) def _url(self, pathfmt, *args, **kwargs): for arg in args: if not isinstance(arg, str): raise ValueError( f'Expected a string but found {arg} ({type(arg)}) instead' ) quote_f = partial(urllib.parse.quote, safe="/:") args = map(quote_f, args) formatted_path = pathfmt.format(*args) if kwargs.get('versioned_api', True): return f'{self.base_url}/v{self._version}{formatted_path}' else: return f'{self.base_url}{formatted_path}' def _raise_for_status(self, response): """Raises stored :class:`APIError`, if one occurred.""" try: response.raise_for_status() except requests.exceptions.HTTPError as e: raise create_api_error_from_http_exception(e) from e def _result(self, response, json=False, binary=False): assert not (json and binary) self._raise_for_status(response) if json: return response.json() if binary: return response.content return response.text def _post_json(self, url, data, **kwargs): # Go <1.1 can't unserialize null to a string # so we do this disgusting thing here. data2 = {} if data is not None and isinstance(data, dict): for k, v in iter(data.items()): if v is not None: data2[k] = v elif data is not None: data2 = data if 'headers' not in kwargs: kwargs['headers'] = {} kwargs['headers']['Content-Type'] = 'application/json' return self._post(url, data=json.dumps(data2), **kwargs) def _attach_params(self, override=None): return override or { 'stdout': 1, 'stderr': 1, 'stream': 1 } @check_resource('container') def _attach_websocket(self, container, params=None): url = self._url("/containers/{0}/attach/ws", container) req = requests.Request("POST", url, params=self._attach_params(params)) full_url = req.prepare().url full_url = full_url.replace("http://", "ws://", 1) full_url = full_url.replace("https://", "wss://", 1) return self._create_websocket_connection(full_url) def _create_websocket_connection(self, url): try: import websocket return websocket.create_connection(url) except ImportError as ie: raise DockerException( 'The `websocket-client` library is required ' 'for using websocket connections. ' 'You can install the `docker` library ' 'with the [websocket] extra to install it.' ) from ie def _get_raw_response_socket(self, response): self._raise_for_status(response) if self.base_url == "http+docker://localnpipe": sock = response.raw._fp.fp.raw.sock elif self.base_url.startswith('http+docker://ssh'): sock = response.raw._fp.fp.channel else: sock = response.raw._fp.fp.raw if self.base_url.startswith("https://"): sock = sock._sock try: # Keep a reference to the response to stop it being garbage # collected. If the response is garbage collected, it will # close TLS sockets. sock._response = response except AttributeError: # UNIX sockets can't have attributes set on them, but that's # fine because we won't be doing TLS over them pass return sock def _stream_helper(self, response, decode=False): """Generator for data coming from a chunked-encoded HTTP response.""" if response.raw._fp.chunked: if decode: yield from json_stream(self._stream_helper(response, False)) else: reader = response.raw while not reader.closed: # this read call will block until we get a chunk data = reader.read(1) if not data: break if reader._fp.chunk_left: data += reader.read(reader._fp.chunk_left) yield data else: # Response isn't chunked, meaning we probably # encountered an error immediately yield self._result(response, json=decode) def _multiplexed_buffer_helper(self, response): """A generator of multiplexed data blocks read from a buffered response.""" buf = self._result(response, binary=True) buf_length = len(buf) walker = 0 while True: if buf_length - walker < STREAM_HEADER_SIZE_BYTES: break header = buf[walker:walker + STREAM_HEADER_SIZE_BYTES] _, length = struct.unpack_from('>BxxxL', header) start = walker + STREAM_HEADER_SIZE_BYTES end = start + length walker = end yield buf[start:end] def _multiplexed_response_stream_helper(self, response): """A generator of multiplexed data blocks coming from a response stream.""" # Disable timeout on the underlying socket to prevent # Read timed out(s) for long running processes socket = self._get_raw_response_socket(response) self._disable_socket_timeout(socket) while True: header = response.raw.read(STREAM_HEADER_SIZE_BYTES) if not header: break _, length = struct.unpack('>BxxxL', header) if not length: continue data = response.raw.read(length) if not data: break yield data def _stream_raw_result(self, response, chunk_size=1, decode=True): ''' Stream result for TTY-enabled container and raw binary data''' self._raise_for_status(response) # Disable timeout on the underlying socket to prevent # Read timed out(s) for long running processes socket = self._get_raw_response_socket(response) self._disable_socket_timeout(socket) yield from response.iter_content(chunk_size, decode) def _read_from_socket(self, response, stream, tty=True, demux=False): """Consume all data from the socket, close the response and return the data. If stream=True, then a generator is returned instead and the caller is responsible for closing the response. """ socket = self._get_raw_response_socket(response) gen = frames_iter(socket, tty) if demux: # The generator will output tuples (stdout, stderr) gen = (demux_adaptor(*frame) for frame in gen) else: # The generator will output strings gen = (data for (_, data) in gen) if stream: return gen else: try: # Wait for all frames, concatenate them, and return the result return consume_socket_output(gen, demux=demux) finally: response.close() def _disable_socket_timeout(self, socket): """ Depending on the combination of python version and whether we're connecting over http or https, we might need to access _sock, which may or may not exist; or we may need to just settimeout on socket itself, which also may or may not have settimeout on it. To avoid missing the correct one, we try both. We also do not want to set the timeout if it is already disabled, as you run the risk of changing a socket that was non-blocking to blocking, for example when using gevent. """ sockets = [socket, getattr(socket, '_sock', None)] for s in sockets: if not hasattr(s, 'settimeout'): continue timeout = -1 if hasattr(s, 'gettimeout'): timeout = s.gettimeout() # Don't change the timeout if it is already disabled. if timeout is None or timeout == 0.0: continue s.settimeout(None) @check_resource('container') def _check_is_tty(self, container): cont = self.inspect_container(container) return cont['Config']['Tty'] def _get_result(self, container, stream, res): return self._get_result_tty(stream, res, self._check_is_tty(container)) def _get_result_tty(self, stream, res, is_tty): # We should also use raw streaming (without keep-alives) # if we're dealing with a tty-enabled container. if is_tty: return self._stream_raw_result(res) if stream else \ self._result(res, binary=True) self._raise_for_status(res) sep = b'' if stream: return self._multiplexed_response_stream_helper(res) else: return sep.join( list(self._multiplexed_buffer_helper(res)) ) def _unmount(self, *args): for proto in args: self.adapters.pop(proto) def get_adapter(self, url): try: return super().get_adapter(url) except requests.exceptions.InvalidSchema as e: if self._custom_adapter: return self._custom_adapter else: raise e @property def api_version(self): return self._version def reload_config(self, dockercfg_path=None): """ Force a reload of the auth configuration Args: dockercfg_path (str): Use a custom path for the Docker config file (default ``$HOME/.docker/config.json`` if present, otherwise ``$HOME/.dockercfg``) Returns: None """ self._auth_configs = auth.load_config( dockercfg_path, credstore_env=self.credstore_env ) __init__.py 0000644 00000000036 15027743616 0006667 0 ustar 00 from .client import APIClient
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings