def __init__(self,
cmd_prefix=None,
default_bin=None,
base_url=None,
tls=None,
use_sudo=None,
debug=None):
super(DockerCliClient, self).__init__()
base_url = base_url or env.get('docker_base_url')
if base_url:
cmd_args = ['-H {0}'.format(base_url)]
else:
cmd_args = []
if tls or (tls is None and env.get('docker_tls')):
cmd_args.append('--tls')
self._out = DockerCommandLineOutput(
cmd_prefix or env.get('docker_cli_prefix'), default_bin
or env.get('docker_cli_bin', 'docker'), cmd_args or None)
if use_sudo or (use_sudo is None and env.get('docker_cli_sudo')):
self._call_method = sudo
else:
self._call_method = run
self._quiet = not (debug or
(debug is None and env.get('docker_cli_debug')))
self.api_version = None
self._update_api_version()
def __init__(self, cmd_prefix=None, default_bin='docker', base_url=None, tls=None, use_sudo=False):
super(DockerCliClient, self).__init__()
if base_url:
cmd_args = ['-H {0}'.format(base_url)]
else:
cmd_args = []
if tls:
cmd_args.append('--tls')
self._out = DockerCommandLineOutput(cmd_prefix, default_bin, cmd_args or None)
if use_sudo:
self._call_method = sudo
else:
self._call_method = run
def __init__(self, cmd_prefix=None, default_bin=None, base_url=None, tls=None, use_sudo=None, debug=None):
super(DockerCliClient, self).__init__()
base_url = base_url or env.get('docker_base_url')
if base_url:
cmd_args = ['-H {0}'.format(base_url)]
else:
cmd_args = []
if tls or (tls is None and env.get('docker_tls')):
cmd_args.append('--tls')
self._out = DockerCommandLineOutput(cmd_prefix or env.get('docker_cli_prefix'),
default_bin or env.get('docker_cli_bin', 'docker'), cmd_args or None)
if use_sudo or (use_sudo is None and env.get('docker_cli_sudo')):
self._call_method = sudo
else:
self._call_method = run
self._quiet = not (debug or (debug is None and env.get('docker_cli_debug')))
self.api_version = None
self._update_api_version()
class DockerCliClient(DockerUtilityMixin):
"""
Docker client for Fabric using the command line interface on a remote host.
:param cmd_prefix: Custom prefix to prepend to the Docker command line.
:type cmd_prefix: unicode
:param default_bin: Docker binary to use. If not set, uses ``docker``.
:type default_bin: unicode
:param base_url: URL to connect to; if not set, will refer to ``env.docker_base_url`` or use ``None``, which by
default attempts a connection on a Unix socket at ``/var/run/docker.sock``.
:type base_url: unicode
:param tls: Whether to use TLS on the connection to the Docker service.
:type tls: bool
:param use_sudo: Whether to use ``sudo`` when performing Docker commands.
:type use_sudo: bool
:param debug: If set to ``True``, echoes each command and its console output. Some commands are echoed either way
for some feedback.
:type debug: bool
"""
def __init__(self,
cmd_prefix=None,
default_bin=None,
base_url=None,
tls=None,
use_sudo=None,
debug=None):
super(DockerCliClient, self).__init__()
base_url = base_url or env.get('docker_base_url')
if base_url:
cmd_args = ['-H {0}'.format(base_url)]
else:
cmd_args = []
if tls or (tls is None and env.get('docker_tls')):
cmd_args.append('--tls')
self._out = DockerCommandLineOutput(
cmd_prefix or env.get('docker_cli_prefix'), default_bin
or env.get('docker_cli_bin', 'docker'), cmd_args or None)
if use_sudo or (use_sudo is None and env.get('docker_cli_sudo')):
self._call_method = sudo
else:
self._call_method = run
self._quiet = not (debug or
(debug is None and env.get('docker_cli_debug')))
self.api_version = None
self._update_api_version()
def _call(self, cmd, quiet=False):
if cmd:
return self._call_method(cmd,
shell=False,
quiet=quiet and self._quiet)
return None
def create_container(self, *args, **kwargs):
cmd_str = self._out.get_cmd('create_container', *args, **kwargs)
return {'Id': self._call(cmd_str)}
def start(self, *args, **kwargs):
cmd_str = self._out.get_cmd('start', *args, **kwargs)
self._call(cmd_str)
def restart(self, *args, **kwargs):
cmd_str = self._out.get_cmd('restart', *args, **kwargs)
self._call(cmd_str)
def stop(self, *args, **kwargs):
cmd_str = self._out.get_cmd('stop', *args, **kwargs)
self._call(cmd_str)
def remove_container(self, *args, **kwargs):
cmd_str = self._out.get_cmd('remove_container', *args, **kwargs)
self._call(cmd_str)
def remove_image(self, *args, **kwargs):
cmd_str = self._out.get_cmd('remove_image', *args, **kwargs)
self._call(cmd_str)
def kill(self, *args, **kwargs):
cmd_str = self._out.get_cmd('kill', *args, **kwargs)
self._call(cmd_str)
def wait(self, *args, **kwargs):
cmd_str = self._out.get_cmd('wait', *args, **kwargs)
self._call(cmd_str)
def containers(self, *args, **kwargs):
cmd_str = self._out.get_cmd('containers', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_containers_output(res)
def inspect_container(self, *args, **kwargs):
cmd_str = self._out.get_cmd('inspect_container', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_inspect_output(res, 'container')
def images(self, *args, **kwargs):
cmd_str = self._out.get_cmd('images', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_images_output(res)
def pull(self, repository, tag=None, **kwargs):
repo_tag = '{0}:{1}'.format(repository, tag) if tag else repository
cmd_str = self._out.get_cmd('pull', repo_tag, **kwargs)
self._call(cmd_str)
def push(self, repository, tag=None, **kwargs):
repo_tag = '{0}:{1}'.format(repository, tag) if tag else repository
cmd_str = self._out.get_cmd('push', repo_tag, **kwargs)
self._call(cmd_str)
def create_network(self, *args, **kwargs):
cmd_str = self._out.get_cmd('create_network', *args, **kwargs)
return {'Id': self._call(cmd_str)}
def remove_network(self, *args, **kwargs):
cmd_str = self._out.get_cmd('remove_network', *args, **kwargs)
self._call(cmd_str)
def connect_container_to_network(self, *args, **kwargs):
cmd_str = self._out.get_cmd('connect_container_to_network', *args,
**kwargs)
self._call(cmd_str)
def disconnect_container_from_network(self, *args, **kwargs):
cmd_str = self._out.get_cmd('disconnect_container_from_network', *args,
**kwargs)
self._call(cmd_str)
def networks(self, *args, **kwargs):
cmd_str = self._out.get_cmd('networks', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_networks_output(res)
def inspect_network(self, *args, **kwargs):
cmd_str = self._out.get_cmd('inspect_network', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_inspect_output(res, 'network')
def create_volume(self, *args, **kwargs):
cmd_str = self._out.get_cmd('create_volume', *args, **kwargs)
return {'Name': self._call(cmd_str)}
def remove_volume(self, *args, **kwargs):
cmd_str = self._out.get_cmd('remove_volume', *args, **kwargs)
self._call(cmd_str)
def volumes(self, *args, **kwargs):
cmd_str = self._out.get_cmd('volumes', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return {'Volumes': parse_volumes_output(res), 'Warnings': None}
def inspect_volume(self, *args, **kwargs):
cmd_str = self._out.get_cmd('inspect_volume', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_inspect_output(res, 'volume')
def exec_create(self, *args, **kwargs):
cmd_str = self._out.get_cmd('exec_create', *args, **kwargs)
self._call(cmd_str)
def exec_start(self, *args, **kwargs):
cmd_str = self._out.get_cmd('exec_start', *args, **kwargs)
self._call(cmd_str)
def top(self, container, ps_args):
if ps_args:
cmd_str = self._out.get_cmd('top', container, ps_args)
else:
cmd_str = self._out.get_cmd('top', container)
res = self._call(cmd_str, quiet=True)
return parse_top_output(res)
def tag(self, image, repository, tag=None, **kwargs):
if tag:
repo_tag = '{0}:{1}'.format(repository, tag)
else:
repo_tag = repository
cmd_str = self._out.get_cmd('tag', image, repo_tag, **kwargs)
return self._call(cmd_str)
def logs(self, *args, **kwargs):
kwargs.pop('stream', None)
cmd_str = self._out.get_cmd('logs', *args, **kwargs)
return self._call(cmd_str, quiet=True)
def login(self, **kwargs):
for key, variable in [('username', 'user'), ('password', 'password'),
('email', 'mail'), ('registry', 'repository'),
('insecure_registry', 'insecure')]:
if key not in kwargs:
env_value = env.get('docker_registry_{0}'.format(variable))
if env_value:
kwargs[key] = env_value
registry = kwargs.pop('registry',
env.get('docker_registry_repository'))
if registry:
cmd_str = self._out.get_cmd('login', registry, **kwargs)
else:
cmd_str = self._out.get_cmd('login', **kwargs)
res = self._call(cmd_str, quiet=True)
lines = res.splitlines()
fastprint(lines)
return 'Login Succeeded' in lines
def build(self,
tag,
add_latest_tag=False,
add_tags=None,
raise_on_error=True,
**kwargs):
try:
context = kwargs.pop('fileobj')
except KeyError:
raise ValueError(
"'fileobj' needs to be provided. Using 'path' is currently not implemented."
)
for a in ['custom_context', 'encoding']:
kwargs.pop(a, None)
with temp_dir() as remote_tmp:
remote_fn = posixpath.join(remote_tmp, 'context')
put(context, remote_fn)
cmd_str = self._out.get_cmd('build',
'- <',
remote_fn,
tag=tag,
**kwargs)
with settings(warn_only=not raise_on_error):
res = self._call(cmd_str)
if res:
image_id = _find_image_id(res)
if image_id:
self.add_extra_tags(image_id, tag, add_tags, add_latest_tag)
return image_id
return None
def version(self, **kwargs):
kwargs.pop('api_version', None)
cmd_str = self._out.get_cmd('version')
res = self._call(cmd_str, quiet=True)
version_dict = parse_version_output(res)
return version_dict
def push_log(self, info, level, *args, **kwargs):
pass
def _update_api_version(self):
if self.api_version and self.api_version != 'auto':
return
version_dict = self.version()
if 'APIVersion' in version_dict:
self.api_version = version_dict['APIVersion']
elif 'ApiVersion' in version_dict:
self.api_version = version_dict['ApiVersion']
def run_cmd(self, command):
sudo(command)
class DockerCliClient(DockerUtilityMixin):
"""
Docker client for Fabric using the command line interface on a remote host.
:param cmd_prefix: Custom prefix to prepend to the Docker command line.
:type cmd_prefix: unicode
:param default_bin: Docker binary to use. If not set, uses ``docker``.
:type default_bin: unicode
:param base_url: URL to connect to; if not set, will refer to ``env.docker_base_url`` or use ``None``, which by
default attempts a connection on a Unix socket at ``/var/run/docker.sock``.
:type base_url: unicode
:param tls: Whether to use TLS on the connection to the Docker service.
:type tls: bool
:param use_sudo: Whether to use ``sudo`` when performing Docker commands.
:type use_sudo: bool
:param debug: If set to ``True``, echoes each command and its console output. Some commands are echoed either way
for some feedback.
:type debug: bool
"""
def __init__(self, cmd_prefix=None, default_bin=None, base_url=None, tls=None, use_sudo=None, debug=None):
super(DockerCliClient, self).__init__()
base_url = base_url or env.get('docker_base_url')
if base_url:
cmd_args = ['-H {0}'.format(base_url)]
else:
cmd_args = []
if tls or (tls is None and env.get('docker_tls')):
cmd_args.append('--tls')
self._out = DockerCommandLineOutput(cmd_prefix or env.get('docker_cli_prefix'),
default_bin or env.get('docker_cli_bin', 'docker'), cmd_args or None)
if use_sudo or (use_sudo is None and env.get('docker_cli_sudo')):
self._call_method = sudo
else:
self._call_method = run
self._quiet = not (debug or (debug is None and env.get('docker_cli_debug')))
self.api_version = None
self._update_api_version()
def _call(self, cmd, quiet=False):
if cmd:
return self._call_method(cmd, shell=False, quiet=quiet and self._quiet)
return None
def create_container(self, *args, **kwargs):
cmd_str = self._out.get_cmd('create_container', *args, **kwargs)
return {'Id': self._call(cmd_str)}
def start(self, *args, **kwargs):
cmd_str = self._out.get_cmd('start', *args, **kwargs)
self._call(cmd_str)
def restart(self, *args, **kwargs):
cmd_str = self._out.get_cmd('restart', *args, **kwargs)
self._call(cmd_str)
def stop(self, *args, **kwargs):
cmd_str = self._out.get_cmd('stop', *args, **kwargs)
self._call(cmd_str)
def remove_container(self, *args, **kwargs):
cmd_str = self._out.get_cmd('remove_container', *args, **kwargs)
self._call(cmd_str)
def remove_image(self, *args, **kwargs):
cmd_str = self._out.get_cmd('remove_image', *args, **kwargs)
self._call(cmd_str)
def kill(self, *args, **kwargs):
cmd_str = self._out.get_cmd('kill', *args, **kwargs)
self._call(cmd_str)
def wait(self, *args, **kwargs):
cmd_str = self._out.get_cmd('wait', *args, **kwargs)
self._call(cmd_str)
def containers(self, *args, **kwargs):
cmd_str = self._out.get_cmd('containers', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_containers_output(res)
def inspect_container(self, *args, **kwargs):
cmd_str = self._out.get_cmd('inspect_container', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_inspect_output(res, 'container')
def images(self, *args, **kwargs):
cmd_str = self._out.get_cmd('images', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_images_output(res)
def pull(self, repository, tag=None, **kwargs):
repo_tag = '{0}:{1}'.format(repository, tag) if tag else repository
cmd_str = self._out.get_cmd('pull', repo_tag, **kwargs)
self._call(cmd_str)
def push(self, repository, tag=None, **kwargs):
repo_tag = '{0}:{1}'.format(repository, tag) if tag else repository
cmd_str = self._out.get_cmd('push', repo_tag, **kwargs)
self._call(cmd_str)
def create_network(self, *args, **kwargs):
cmd_str = self._out.get_cmd('create_network', *args, **kwargs)
return {'Id': self._call(cmd_str)}
def remove_network(self, *args, **kwargs):
cmd_str = self._out.get_cmd('remove_network', *args, **kwargs)
self._call(cmd_str)
def connect_container_to_network(self, *args, **kwargs):
cmd_str = self._out.get_cmd('connect_container_to_network', *args, **kwargs)
self._call(cmd_str)
def disconnect_container_from_network(self, *args, **kwargs):
cmd_str = self._out.get_cmd('disconnect_container_from_network', *args, **kwargs)
self._call(cmd_str)
def networks(self, *args, **kwargs):
cmd_str = self._out.get_cmd('networks', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_networks_output(res)
def inspect_network(self, *args, **kwargs):
cmd_str = self._out.get_cmd('inspect_network', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_inspect_output(res, 'network')
def create_volume(self, *args, **kwargs):
cmd_str = self._out.get_cmd('create_volume', *args, **kwargs)
return {'Name': self._call(cmd_str)}
def remove_volume(self, *args, **kwargs):
cmd_str = self._out.get_cmd('remove_volume', *args, **kwargs)
self._call(cmd_str)
def volumes(self, *args, **kwargs):
cmd_str = self._out.get_cmd('volumes', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return {'Volumes': parse_volumes_output(res), 'Warnings': None}
def inspect_volume(self, *args, **kwargs):
cmd_str = self._out.get_cmd('inspect_volume', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_inspect_output(res, 'volume')
def exec_create(self, *args, **kwargs):
cmd_str = self._out.get_cmd('exec_create', *args, **kwargs)
self._call(cmd_str)
def exec_start(self, *args, **kwargs):
cmd_str = self._out.get_cmd('exec_start', *args, **kwargs)
self._call(cmd_str)
def top(self, container, ps_args):
if ps_args:
cmd_str = self._out.get_cmd('top', container, ps_args)
else:
cmd_str = self._out.get_cmd('top', container)
res = self._call(cmd_str, quiet=True)
return parse_top_output(res)
def tag(self, image, repository, tag=None, **kwargs):
if tag:
repo_tag = '{0}:{1}'.format(repository, tag)
else:
repo_tag = repository
cmd_str = self._out.get_cmd('tag', image, repo_tag, **kwargs)
return self._call(cmd_str)
def logs(self, *args, **kwargs):
kwargs.pop('stream', None)
cmd_str = self._out.get_cmd('logs', *args, **kwargs)
return self._call(cmd_str, quiet=True)
def login(self, **kwargs):
for key, variable in [
('username', 'user'),
('password', 'password'),
('email', 'mail'),
('registry', 'repository'),
('insecure_registry', 'insecure')
]:
if key not in kwargs:
env_value = env.get('docker_registry_{0}'.format(variable))
if env_value:
kwargs[key] = env_value
registry = kwargs.pop('registry', env.get('docker_registry_repository'))
if registry:
cmd_str = self._out.get_cmd('login', registry, **kwargs)
else:
cmd_str = self._out.get_cmd('login', **kwargs)
res = self._call(cmd_str, quiet=True)
lines = res.splitlines()
fastprint(lines)
return 'Login Succeeded' in lines
def build(self, tag, add_latest_tag=False, add_tags=None, raise_on_error=True, **kwargs):
try:
context = kwargs.pop('fileobj')
except KeyError:
raise ValueError("'fileobj' needs to be provided. Using 'path' is currently not implemented.")
for a in ['custom_context', 'encoding']:
kwargs.pop(a, None)
with temp_dir() as remote_tmp:
remote_fn = posixpath.join(remote_tmp, 'context')
put(context, remote_fn)
cmd_str = self._out.get_cmd('build', '- <', remote_fn, tag=tag, **kwargs)
with settings(warn_only=not raise_on_error):
res = self._call(cmd_str)
if res:
image_id = _find_image_id(res)
if image_id:
self.add_extra_tags(image_id, tag, add_tags, add_latest_tag)
return image_id
return None
def version(self, **kwargs):
kwargs.pop('api_version', None)
cmd_str = self._out.get_cmd('version')
res = self._call(cmd_str, quiet=True)
version_dict = parse_version_output(res)
return version_dict
def push_log(self, info, level, *args, **kwargs):
pass
def _update_api_version(self):
if self.api_version and self.api_version != 'auto':
return
version_dict = self.version()
if 'APIVersion' in version_dict:
self.api_version = version_dict['APIVersion']
elif 'ApiVersion' in version_dict:
self.api_version = version_dict['ApiVersion']
def run_cmd(self, command):
sudo(command)
class DockerCliClient(DockerUtilityMixin):
def __init__(self, cmd_prefix=None, default_bin='docker', base_url=None, tls=None, use_sudo=False):
super(DockerCliClient, self).__init__()
if base_url:
cmd_args = ['-H {0}'.format(base_url)]
else:
cmd_args = []
if tls:
cmd_args.append('--tls')
self._out = DockerCommandLineOutput(cmd_prefix, default_bin, cmd_args or None)
if use_sudo:
self._call_method = sudo
else:
self._call_method = run
def _call(self, cmd, quiet=False):
if cmd:
return self._call_method(cmd, shell=False, quiet=quiet)
return None
def create_container(self, *args, **kwargs):
cmd_str = self._out.get_cmd('create_container', *args, **kwargs)
return {'Id': self._call(cmd_str)}
def start(self, *args, **kwargs):
cmd_str = self._out.get_cmd('start', *args, **kwargs)
self._call(cmd_str)
def restart(self, *args, **kwargs):
cmd_str = self._out.get_cmd('restart', *args, **kwargs)
self._call(cmd_str)
def stop(self, *args, **kwargs):
cmd_str = self._out.get_cmd('stop', *args, **kwargs)
self._call(cmd_str)
def remove_container(self, *args, **kwargs):
cmd_str = self._out.get_cmd('remove_container', *args, **kwargs)
self._call(cmd_str)
def remove_image(self, *args, **kwargs):
cmd_str = self._out.get_cmd('remove_image', *args, **kwargs)
self._call(cmd_str)
def kill(self, *args, **kwargs):
cmd_str = self._out.get_cmd('kill', *args, **kwargs)
self._call(cmd_str)
def wait(self, *args, **kwargs):
cmd_str = self._out.get_cmd('wait', *args, **kwargs)
self._call(cmd_str)
def containers(self, *args, **kwargs):
cmd_str = self._out.get_cmd('containers', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_containers_output(res)
def inspect_container(self, *args, **kwargs):
cmd_str = self._out.get_cmd('inspect_container', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_inspect_output(res)
def images(self, *args, **kwargs):
cmd_str = self._out.get_cmd('images', *args, **kwargs)
res = self._call(cmd_str, quiet=True)
return parse_images_output(res)
def pull(self, repository, tag=None, **kwargs):
repo_tag = '{0}:{1}'.format(repository, tag) if tag else repository
cmd_str = self._out.get_cmd('pull', repo_tag, **kwargs)
self._call(cmd_str)
def push(self, repository, tag=None, **kwargs):
repo_tag = '{0}:{1}'.format(repository, tag) if tag else repository
cmd_str = self._out.get_cmd('push', repo_tag, **kwargs)
self._call(cmd_str)
def exec_create(self, *args, **kwargs):
cmd_str = self._out.get_cmd('exec_create', *args, **kwargs)
self._call(cmd_str)
def exec_start(self, *args, **kwargs):
cmd_str = self._out.get_cmd('exec_start', *args, **kwargs)
self._call(cmd_str)
def tag(self, image, repository, tag=None, **kwargs):
if tag:
repo_tag = '{0}:{1}'.format(repository, tag)
else:
repo_tag = repository
cmd_str = self._out.get_cmd('tag', image, repo_tag, **kwargs)
return self._call(cmd_str)
def logs(self, *args, **kwargs):
kwargs.pop('stream', None)
cmd_str = self._out.get_cmd('logs', *args, **kwargs)
return self._call(cmd_str, quiet=True)
def login(self, **kwargs):
for key, variable in [
('username', 'user'),
('password', 'password'),
('email', 'mail'),
('registry', 'repository'),
('insecure_registry', 'insecure')
]:
if key not in kwargs:
env_value = env.get('docker_registry_{0}'.format(variable))
if env_value:
kwargs[key] = env_value
registry = kwargs.pop('registry', env.get('docker_registry_repository'))
if registry:
cmd_str = self._out.get_cmd('login', registry, **kwargs)
else:
cmd_str = self._out.get_cmd('login', **kwargs)
res = self._call(cmd_str, quiet=True)
lines = res.splitlines()
fastprint(lines)
return 'Login Succeeded' in lines
def build(self, tag, add_latest_tag=False, add_tags=None, raise_on_error=False, **kwargs):
try:
context = kwargs.pop('fileobj')
except KeyError:
raise ValueError("'fileobj' needs to be provided. Using 'path' is currently not implemented.")
for a in ['custom_context', 'encoding']:
kwargs.pop(a, None)
with temp_dir() as remote_tmp:
remote_fn = posixpath.join(remote_tmp, 'context')
put(context, remote_fn)
cmd_str = self._out.get_cmd('build', '- <', remote_fn, tag=tag, **kwargs)
with settings(warn_only=not raise_on_error):
res = self._call(cmd_str)
if res:
last_log = res.splitlines()[-1]
if last_log and last_log.startswith('Successfully built '):
image_id = last_log[19:] # Remove prefix
self.add_extra_tags(image_id, tag, add_tags, add_latest_tag)
return image_id
return None
def push_log(self, info, level, *args, **kwargs):
pass
