path: root/docker/utils/utils.py

import base64
import io
import os
import os.path
import json
import shlex
import sys
import tarfile
import tempfile
import warnings
from distutils.version import StrictVersion
from datetime import datetime
from fnmatch import fnmatch

import requests
import six

from .. import constants
from .. import errors
from .. import tls
from ..types import Ulimit, LogConfig, Healthcheck

if six.PY2:
    from urllib import splitnport
else:
    from urllib.parse import splitnport

DEFAULT_HTTP_HOST = "127.0.0.1"
DEFAULT_UNIX_SOCKET = "http+unix://var/run/docker.sock"
DEFAULT_NPIPE = 'npipe:////./pipe/docker_engine'

BYTE_UNITS = {
    'b': 1,
    'k': 1024,
    'm': 1024 * 1024,
    'g': 1024 * 1024 * 1024
}


def create_ipam_pool(subnet=None, iprange=None, gateway=None,
                     aux_addresses=None):
    """
    Create an IPAM pool config dictionary to be added to the
    ``pool_configs`` parameter of
    :py:meth:`~docker.utils.create_ipam_config`.

    Args:

        subnet (str): Custom subnet for this IPAM pool using the CIDR
            notation. Defaults to ``None``.
        iprange (str): Custom IP range for endpoints in this IPAM pool using
            the CIDR notation. Defaults to ``None``.
        gateway (str): Custom IP address for the pool's gateway.
        aux_addresses (dict): A dictionary of ``key -> ip_address``
            relationships specifying auxiliary addresses that need to be
            allocated by the IPAM driver.

    Returns:
        (dict) An IPAM pool config

    Example:

        >>> ipam_pool = docker.utils.create_ipam_pool(
            subnet='124.42.0.0/16',
            iprange='124.42.0.0/24',
            gateway='124.42.0.254',
            aux_addresses={
                'reserved1': '124.42.1.1'
            }
        )
        >>> ipam_config = docker.utils.create_ipam_config(
                pool_configs=[ipam_pool])
    """
    return {
        'Subnet': subnet,
        'IPRange': iprange,
        'Gateway': gateway,
        'AuxiliaryAddresses': aux_addresses
    }


def create_ipam_config(driver='default', pool_configs=None):
    """
    Create an IPAM (IP Address Management) config dictionary to be used with
    :py:meth:`~docker.api.network.NetworkApiMixin.create_network`.

    Args:
        driver (str): The IPAM driver to use. Defaults to ``default``.
        pool_configs (list): A list of pool configuration dictionaries as
            created by :py:meth:`~docker.utils.create_ipam_pool`. Defaults to
            empty list.

    Returns:
        (dict) An IPAM config.

    Example:

        >>> ipam_config = docker.utils.create_ipam_config(driver='default')
        >>> network = client.create_network('network1', ipam=ipam_config)

    """
    return {
        'Driver': driver,
        'Config': pool_configs or []
    }


def mkbuildcontext(dockerfile):
    f = tempfile.NamedTemporaryFile()
    t = tarfile.open(mode='w', fileobj=f)
    if isinstance(dockerfile, io.StringIO):
        dfinfo = tarfile.TarInfo('Dockerfile')
        if six.PY3:
            raise TypeError('Please use io.BytesIO to create in-memory '
                            'Dockerfiles with Python 3')
        else:
            dfinfo.size = len(dockerfile.getvalue())
            dockerfile.seek(0)
    elif isinstance(dockerfile, io.BytesIO):
        dfinfo = tarfile.TarInfo('Dockerfile')
        dfinfo.size = len(dockerfile.getvalue())
        dockerfile.seek(0)
    else:
        dfinfo = t.gettarinfo(fileobj=dockerfile, arcname='Dockerfile')
    t.addfile(dfinfo, dockerfile)
    t.close()
    f.seek(0)
    return f


def decode_json_header(header):
    data = base64.b64decode(header)
    if six.PY3:
        data = data.decode('utf-8')
    return json.loads(data)


def tar(path, exclude=None, dockerfile=None, fileobj=None, gzip=False):
    if not fileobj:
        fileobj = tempfile.NamedTemporaryFile()
    t = tarfile.open(mode='w:gz' if gzip else 'w', fileobj=fileobj)

    root = os.path.abspath(path)
    exclude = exclude or []

    for path in sorted(exclude_paths(root, exclude, dockerfile=dockerfile)):
        i = t.gettarinfo(os.path.join(root, path), arcname=path)

        if sys.platform == 'win32':
            # Windows doesn't keep track of the execute bit, so we make files
            # and directories executable by default.
            i.mode = i.mode & 0o755 | 0o111

        try:
            # We open the file object in binary mode for Windows support.
            f = open(os.path.join(root, path), 'rb')
        except IOError:
            # When we encounter a directory the file object is set to None.
            f = None

        t.addfile(i, f)

    t.close()
    fileobj.seek(0)
    return fileobj


def exclude_paths(root, patterns, dockerfile=None):
    """
    Given a root directory path and a list of .dockerignore patterns, return
    an iterator of all paths (both regular files and directories) in the root
    directory that do *not* match any of the patterns.

    All paths returned are relative to the root.
    """
    if dockerfile is None:
        dockerfile = 'Dockerfile'

    exceptions = [p for p in patterns if p.startswith('!')]

    include_patterns = [p[1:] for p in exceptions]
    include_patterns += [dockerfile, '.dockerignore']

    exclude_patterns = list(set(patterns) - set(exceptions))

    paths = get_paths(root, exclude_patterns, include_patterns,
                      has_exceptions=len(exceptions) > 0)

    return set(paths).union(
        # If the Dockerfile is in a subdirectory that is excluded, get_paths
        # will not descend into it and the file will be skipped. This ensures
        # it doesn't happen.
        set([dockerfile])
        if os.path.exists(os.path.join(root, dockerfile)) else set()
    )


def should_include(path, exclude_patterns, include_patterns):
    """
    Given a path, a list of exclude patterns, and a list of inclusion patterns:

    1. Returns True if the path doesn't match any exclusion pattern
    2. Returns False if the path matches an exclusion pattern and doesn't match
       an inclusion pattern
    3. Returns true if the path matches an exclusion pattern and matches an
       inclusion pattern
    """
    for pattern in exclude_patterns:
        if match_path(path, pattern):
            for pattern in include_patterns:
                if match_path(path, pattern):
                    return True
            return False
    return True


def get_paths(root, exclude_patterns, include_patterns, has_exceptions=False):
    paths = []

    for parent, dirs, files in os.walk(root, topdown=True, followlinks=False):
        parent = os.path.relpath(parent, root)
        if parent == '.':
            parent = ''

        # If exception rules exist, we can't skip recursing into ignored
        # directories, as we need to look for exceptions in them.
        #
        # It may be possible to optimize this further for exception patterns
        # that *couldn't* match within ignored directores.
        #
        # This matches the current docker logic (as of 2015-11-24):
        # https://github.com/docker/docker/blob/37ba67bf636b34dc5c0c0265d62a089d0492088f/pkg/archive/archive.go#L555-L557

        if not has_exceptions:

            # Remove excluded patterns from the list of directories to traverse
            # by mutating the dirs we're iterating over.
            # This looks strange, but is considered the correct way to skip
            # traversal. See https://docs.python.org/2/library/os.html#os.walk

            dirs[:] = [d for d in dirs if
                       should_include(os.path.join(parent, d),
                                      exclude_patterns, include_patterns)]

        for path in dirs:
            if should_include(os.path.join(parent, path),
                              exclude_patterns, include_patterns):
                paths.append(os.path.join(parent, path))

        for path in files:
            if should_include(os.path.join(parent, path),
                              exclude_patterns, include_patterns):
                paths.append(os.path.join(parent, path))

    return paths


def match_path(path, pattern):
    pattern = pattern.rstrip('/')
    if pattern:
        pattern = os.path.relpath(pattern)

    pattern_components = pattern.split(os.path.sep)
    path_components = path.split(os.path.sep)[:len(pattern_components)]
    return fnmatch('/'.join(path_components), pattern)


def compare_version(v1, v2):
    """Compare docker versions

    >>> v1 = '1.9'
    >>> v2 = '1.10'
    >>> compare_version(v1, v2)
    1
    >>> compare_version(v2, v1)
    -1
    >>> compare_version(v2, v2)
    0
    """
    s1 = StrictVersion(v1)
    s2 = StrictVersion(v2)
    if s1 == s2:
        return 0
    elif s1 > s2:
        return -1
    else:
        return 1


def version_lt(v1, v2):
    return compare_version(v1, v2) > 0


def version_gte(v1, v2):
    return not version_lt(v1, v2)


def ping_registry(url):
    warnings.warn(
        'The `ping_registry` method is deprecated and will be removed.',
        DeprecationWarning
    )

    return ping(url + '/v2/', [401]) or ping(url + '/v1/_ping')


def ping(url, valid_4xx_statuses=None):
    try:
        res = requests.get(url, timeout=3)
    except Exception:
        return False
    else:
        # We don't send yet auth headers
        # and a v2 registry will respond with status 401
        return (
            res.status_code < 400 or
            (valid_4xx_statuses and res.status_code in valid_4xx_statuses)
        )


def _convert_port_binding(binding):
    result = {'HostIp': '', 'HostPort': ''}
    if isinstance(binding, tuple):
        if len(binding) == 2:
            result['HostPort'] = binding[1]
            result['HostIp'] = binding[0]
        elif isinstance(binding[0], six.string_types):
            result['HostIp'] = binding[0]
        else:
            result['HostPort'] = binding[0]
    elif isinstance(binding, dict):
        if 'HostPort' in binding:
            result['HostPort'] = binding['HostPort']
            if 'HostIp' in binding:
                result['HostIp'] = binding['HostIp']
        else:
            raise ValueError(binding)
    else:
        result['HostPort'] = binding

    if result['HostPort'] is None:
        result['HostPort'] = ''
    else:
        result['HostPort'] = str(result['HostPort'])

    return result


def convert_port_bindings(port_bindings):
    result = {}
    for k, v in six.iteritems(port_bindings):
        key = str(k)
        if '/' not in key:
            key += '/tcp'
        if isinstance(v, list):
            result[key] = [_convert_port_binding(binding) for binding in v]
        else:
            result[key] = [_convert_port_binding(v)]
    return result


def convert_volume_binds(binds):
    if isinstance(binds, list):
        return binds

    result = []
    for k, v in binds.items():
        if isinstance(k, six.binary_type):
            k = k.decode('utf-8')

        if isinstance(v, dict):
            if 'ro' in v and 'mode' in v:
                raise ValueError(
                    'Binding cannot contain both "ro" and "mode": {}'
                    .format(repr(v))
                )

            bind = v['bind']
            if isinstance(bind, six.binary_type):
                bind = bind.decode('utf-8')

            if 'ro' in v:
                mode = 'ro' if v['ro'] else 'rw'
            elif 'mode' in v:
                mode = v['mode']
            else:
                mode = 'rw'

            result.append(
                six.text_type('{0}:{1}:{2}').format(k, bind, mode)
            )
        else:
            if isinstance(v, six.binary_type):
                v = v.decode('utf-8')
            result.append(
                six.text_type('{0}:{1}:rw').format(k, v)
            )
    return result


def convert_tmpfs_mounts(tmpfs):
    if isinstance(tmpfs, dict):
        return tmpfs

    if not isinstance(tmpfs, list):
        raise ValueError(
            'Expected tmpfs value to be either a list or a dict, found: {}'
            .format(type(tmpfs).__name__)
        )

    result = {}
    for mount in tmpfs:
        if isinstance(mount, six.string_types):
            if ":" in mount:
                name, options = mount.split(":", 1)
            else:
                name = mount
                options = ""

        else:
            raise ValueError(
                "Expected item in tmpfs list to be a string, found: {}"
                .format(type(mount).__name__)
            )

        result[name] = options
    return result


def convert_service_networks(networks):
    if not networks:
        return networks
    if not isinstance(networks, list):
        raise TypeError('networks parameter must be a list.')

    result = []
    for n in networks:
        if isinstance(n, six.string_types):
            n = {'Target': n}
        result.append(n)
    return result


def parse_repository_tag(repo_name):
    parts = repo_name.rsplit('@', 1)
    if len(parts) == 2:
        return tuple(parts)
    parts = repo_name.rsplit(':', 1)
    if len(parts) == 2 and '/' not in parts[1]:
        return tuple(parts)
    return repo_name, None


# Based on utils.go:ParseHost http://tinyurl.com/nkahcfh
# fd:// protocol unsupported (for obvious reasons)
# Added support for http and https
# Protocol translation: tcp -> http, unix -> http+unix
def parse_host(addr, is_win32=False, tls=False):
    proto = "http+unix"
    port = None
    path = ''

    if not addr and is_win32:
        addr = DEFAULT_NPIPE

    if not addr or addr.strip() == 'unix://':
        return DEFAULT_UNIX_SOCKET

    addr = addr.strip()
    if addr.startswith('http://'):
        addr = addr.replace('http://', 'tcp://')
    if addr.startswith('http+unix://'):
        addr = addr.replace('http+unix://', 'unix://')

    if addr == 'tcp://':
        raise errors.DockerException(
            "Invalid bind address format: {0}".format(addr)
        )
    elif addr.startswith('unix://'):
        addr = addr[7:]
    elif addr.startswith('tcp://'):
        proto = 'http{0}'.format('s' if tls else '')
        addr = addr[6:]
    elif addr.startswith('https://'):
        proto = "https"
        addr = addr[8:]
    elif addr.startswith('npipe://'):
        proto = 'npipe'
        addr = addr[8:]
    elif addr.startswith('fd://'):
        raise errors.DockerException("fd protocol is not implemented")
    else:
        if "://" in addr:
            raise errors.DockerException(
                "Invalid bind address protocol: {0}".format(addr)
            )
        proto = "https" if tls else "http"

    if proto in ("http", "https"):
        address_parts = addr.split('/', 1)
        host = address_parts[0]
        if len(address_parts) == 2:
            path = '/' + address_parts[1]
        host, port = splitnport(host)

        if port is None:
            raise errors.DockerException(
                "Invalid port: {0}".format(addr)
            )

        if not host:
            host = DEFAULT_HTTP_HOST
    else:
        host = addr

    if proto in ("http", "https") and port == -1:
        raise errors.DockerException(
            "Bind address needs a port: {0}".format(addr))

    if proto == "http+unix" or proto == 'npipe':
        return "{0}://{1}".format(proto, host).rstrip('/')
    return "{0}://{1}:{2}{3}".format(proto, host, port, path).rstrip('/')


def parse_devices(devices):
    device_list = []
    for device in devices:
        if isinstance(device, dict):
            device_list.append(device)
            continue
        if not isinstance(device, six.string_types):
            raise errors.DockerException(
                'Invalid device type {0}'.format(type(device))
            )
        device_mapping = device.split(':')
        if device_mapping:
            path_on_host = device_mapping[0]
            if len(device_mapping) > 1:
                path_in_container = device_mapping[1]
            else:
                path_in_container = path_on_host
            if len(device_mapping) > 2:
                permissions = device_mapping[2]
            else:
                permissions = 'rwm'
            device_list.append({
                'PathOnHost': path_on_host,
                'PathInContainer': path_in_container,
                'CgroupPermissions': permissions
            })
    return device_list


def kwargs_from_env(ssl_version=None, assert_hostname=None, environment=None):
    if not environment:
        environment = os.environ
    host = environment.get('DOCKER_HOST')

    # empty string for cert path is the same as unset.
    cert_path = environment.get('DOCKER_CERT_PATH') or None

    # empty string for tls verify counts as "false".
    # Any value or 'unset' counts as true.
    tls_verify = environment.get('DOCKER_TLS_VERIFY')
    if tls_verify == '':
        tls_verify = False
    else:
        tls_verify = tls_verify is not None
    enable_tls = cert_path or tls_verify

    params = {}

    if host:
        params['base_url'] = (
            host.replace('tcp://', 'https://') if enable_tls else host
        )

    if not enable_tls:
        return params

    if not cert_path:
        cert_path = os.path.join(os.path.expanduser('~'), '.docker')

    if not tls_verify and assert_hostname is None:
        # assert_hostname is a subset of TLS verification,
        # so if it's not set already then set it to false.
        assert_hostname = False

    params['tls'] = tls.TLSConfig(
        client_cert=(os.path.join(cert_path, 'cert.pem'),
                     os.path.join(cert_path, 'key.pem')),
        ca_cert=os.path.join(cert_path, 'ca.pem'),
        verify=tls_verify,
        ssl_version=ssl_version,
        assert_hostname=assert_hostname,
    )

    return params


def convert_filters(filters):
    result = {}
    for k, v in six.iteritems(filters):
        if isinstance(v, bool):
            v = 'true' if v else 'false'
        if not isinstance(v, list):
            v = [v, ]
        result[k] = v
    return json.dumps(result)


def datetime_to_timestamp(dt):
    """Convert a UTC datetime to a Unix timestamp"""
    delta = dt - datetime.utcfromtimestamp(0)
    return delta.seconds + delta.days * 24 * 3600


def parse_bytes(s):
    if isinstance(s, six.integer_types + (float,)):
        return s
    if len(s) == 0:
        return 0

    if s[-2:-1].isalpha() and s[-1].isalpha():
        if s[-1] == "b" or s[-1] == "B":
            s = s[:-1]
    units = BYTE_UNITS
    suffix = s[-1].lower()

    # Check if the variable is a string representation of an int
    # without a units part. Assuming that the units are bytes.
    if suffix.isdigit():
        digits_part = s
        suffix = 'b'
    else:
        digits_part = s[:-1]

    if suffix in units.keys() or suffix.isdigit():
        try:
            digits = int(digits_part)
        except ValueError:
            raise errors.DockerException(
                'Failed converting the string value for memory ({0}) to'
                ' an integer.'.format(digits_part)
            )

        # Reconvert to long for the final result
        s = int(digits * units[suffix])
    else:
        raise errors.DockerException(
            'The specified value for memory ({0}) should specify the'
            ' units. The postfix should be one of the `b` `k` `m` `g`'
            ' characters'.format(s)
        )

    return s


def host_config_type_error(param, param_value, expected):
    error_msg = 'Invalid type for {0} param: expected {1} but found {2}'
    return TypeError(error_msg.format(param, expected, type(param_value)))


def host_config_version_error(param, version, less_than=True):
    operator = '<' if less_than else '>'
    error_msg = '{0} param is not supported in API versions {1} {2}'
    return errors.InvalidVersion(error_msg.format(param, operator, version))


def host_config_value_error(param, param_value):
    error_msg = 'Invalid value for {0} param: {1}'
    return ValueError(error_msg.format(param, param_value))


def create_host_config(binds=None, port_bindings=None, lxc_conf=None,
                       publish_all_ports=False, links=None, privileged=False,
                       dns=None, dns_search=None, volumes_from=None,
                       network_mode=None, restart_policy=None, cap_add=None,
                       cap_drop=None, devices=None, extra_hosts=None,
                       read_only=None, pid_mode=None, ipc_mode=None,
                       security_opt=None, ulimits=None, log_config=None,
                       mem_limit=None, memswap_limit=None,
                       mem_reservation=None, kernel_memory=None,
                       mem_swappiness=None, cgroup_parent=None,
                       group_add=None, cpu_quota=None,
                       cpu_period=None, blkio_weight=None,
                       blkio_weight_device=None, device_read_bps=None,
                       device_write_bps=None, device_read_iops=None,
                       device_write_iops=None, oom_kill_disable=False,
                       shm_size=None, sysctls=None, version=None, tmpfs=None,
                       oom_score_adj=None, dns_opt=None, cpu_shares=None,
                       cpuset_cpus=None, userns_mode=None, pids_limit=None,
                       isolation=None):

    host_config = {}

    if not version:
        warnings.warn(
            'docker.utils.create_host_config() is deprecated. Please use '
            'Client.create_host_config() instead.'
        )
        version = constants.DEFAULT_DOCKER_API_VERSION

    if mem_limit is not None:
        host_config['Memory'] = parse_bytes(mem_limit)

    if memswap_limit is not None:
        host_config['MemorySwap'] = parse_bytes(memswap_limit)

    if mem_reservation:
        if version_lt(version, '1.21'):
            raise host_config_version_error('mem_reservation', '1.21')

        host_config['MemoryReservation'] = parse_bytes(mem_reservation)

    if kernel_memory:
        if version_lt(version, '1.21'):
            raise host_config_version_error('kernel_memory', '1.21')

        host_config['KernelMemory'] = parse_bytes(kernel_memory)

    if mem_swappiness is not None:
        if version_lt(version, '1.20'):
            raise host_config_version_error('mem_swappiness', '1.20')
        if not isinstance(mem_swappiness, int):
            raise host_config_type_error(
                'mem_swappiness', mem_swappiness, 'int'
            )

        host_config['MemorySwappiness'] = mem_swappiness

    if shm_size is not None:
        if isinstance(shm_size, six.string_types):
            shm_size = parse_bytes(shm_size)

        host_config['ShmSize'] = shm_size

    if pid_mode not in (None, 'host'):
        raise host_config_value_error('pid_mode', pid_mode)
    elif pid_mode:
        host_config['PidMode'] = pid_mode

    if ipc_mode:
        host_config['IpcMode'] = ipc_mode

    if privileged:
        host_config['Privileged'] = privileged

    if oom_kill_disable:
        if version_lt(version, '1.20'):
            raise host_config_version_error('oom_kill_disable', '1.19')

        host_config['OomKillDisable'] = oom_kill_disable

    if oom_score_adj:
        if version_lt(version, '1.22'):
            raise host_config_version_error('oom_score_adj', '1.22')
        if not isinstance(oom_score_adj, int):
            raise host_config_type_error(
                'oom_score_adj', oom_score_adj, 'int'
            )
        host_config['OomScoreAdj'] = oom_score_adj

    if publish_all_ports:
        host_config['PublishAllPorts'] = publish_all_ports

    if read_only is not None:
        host_config['ReadonlyRootfs'] = read_only

    if dns_search:
        host_config['DnsSearch'] = dns_search

    if network_mode:
        host_config['NetworkMode'] = network_mode
    elif network_mode is None and compare_version('1.19', version) > 0:
        host_config['NetworkMode'] = 'default'

    if restart_policy:
        if not isinstance(restart_policy, dict):
            raise host_config_type_error(
                'restart_policy', restart_policy, 'dict'
            )

        host_config['RestartPolicy'] = restart_policy

    if cap_add:
        host_config['CapAdd'] = cap_add

    if cap_drop:
        host_config['CapDrop'] = cap_drop

    if devices:
        host_config['Devices'] = parse_devices(devices)

    if group_add:
        if version_lt(version, '1.20'):
            raise host_config_version_error('group_add', '1.20')

        host_config['GroupAdd'] = [six.text_type(grp) for grp in group_add]

    if dns is not None:
        host_config['Dns'] = dns

    if dns_opt is not None:
        if version_lt(version, '1.21'):
            raise host_config_version_error('dns_opt', '1.21')

        host_config['DnsOptions'] = dns_opt

    if security_opt is not None:
        if not isinstance(security_opt, list):
            raise host_config_type_error('security_opt', security_opt, 'list')

        host_config['SecurityOpt'] = security_opt

    if sysctls:
        if not isinstance(sysctls, dict):
            raise host_config_type_error('sysctls', sysctls, 'dict')
        host_config['Sysctls'] = {}
        for k, v in six.iteritems(sysctls):
            host_config['Sysctls'][k] = six.text_type(v)

    if volumes_from is not None:
        if isinstance(volumes_from, six.string_types):
            volumes_from = volumes_from.split(',')

        host_config['VolumesFrom'] = volumes_from

    if binds is not None:
        host_config['Binds'] = convert_volume_binds(binds)

    if port_bindings is not None:
        host_config['PortBindings'] = convert_port_bindings(port_bindings)

    if extra_hosts is not None:
        if isinstance(extra_hosts, dict):
            extra_hosts = [
                '{0}:{1}'.format(k, v)
                for k, v in sorted(six.iteritems(extra_hosts))
            ]

        host_config['ExtraHosts'] = extra_hosts

    if links is not None:
        host_config['Links'] = normalize_links(links)

    if isinstance(lxc_conf, dict):
        formatted = []
        for k, v in six.iteritems(lxc_conf):
            formatted.append({'Key': k, 'Value': str(v)})
        lxc_conf = formatted

    if lxc_conf is not None:
        host_config['LxcConf'] = lxc_conf

    if cgroup_parent is not None:
        host_config['CgroupParent'] = cgroup_parent

    if ulimits is not None:
        if not isinstance(ulimits, list):
            raise host_config_type_error('ulimits', ulimits, 'list')
        host_config['Ulimits'] = []
        for l in ulimits:
            if not isinstance(l, Ulimit):
                l = Ulimit(**l)
            host_config['Ulimits'].append(l)

    if log_config is not None:
        if not isinstance(log_config, LogConfig):
            if not isinstance(log_config, dict):
                raise host_config_type_error(
                    'log_config', log_config, 'LogConfig'
                )
            log_config = LogConfig(**log_config)

        host_config['LogConfig'] = log_config

    if cpu_quota:
        if not isinstance(cpu_quota, int):
            raise host_config_type_error('cpu_quota', cpu_quota, 'int')
        if version_lt(version, '1.19'):
            raise host_config_version_error('cpu_quota', '1.19')

        host_config['CpuQuota'] = cpu_quota

    if cpu_period:
        if not isinstance(cpu_period, int):
            raise host_config_type_error('cpu_period', cpu_period, 'int')
        if version_lt(version, '1.19'):
            raise host_config_version_error('cpu_period', '1.19')

        host_config['CpuPeriod'] = cpu_period

    if cpu_shares:
        if version_lt(version, '1.18'):
            raise host_config_version_error('cpu_shares', '1.18')

        if not isinstance(cpu_shares, int):
            raise host_config_type_error('cpu_shares', cpu_shares, 'int')

        host_config['CpuShares'] = cpu_shares

    if cpuset_cpus:
        if version_lt(version, '1.18'):
            raise host_config_version_error('cpuset_cpus', '1.18')

        host_config['CpuSetCpus'] = cpuset_cpus

    if blkio_weight:
        if not isinstance(blkio_weight, int):
            raise host_config_type_error('blkio_weight', blkio_weight, 'int')
        if version_lt(version, '1.22'):
            raise host_config_version_error('blkio_weight', '1.22')
        host_config["BlkioWeight"] = blkio_weight

    if blkio_weight_device:
        if not isinstance(blkio_weight_device, list):
            raise host_config_type_error(
                'blkio_weight_device', blkio_weight_device, 'list'
            )
        if version_lt(version, '1.22'):
            raise host_config_version_error('blkio_weight_device', '1.22')
        host_config["BlkioWeightDevice"] = blkio_weight_device

    if device_read_bps:
        if not isinstance(device_read_bps, list):
            raise host_config_type_error(
                'device_read_bps', device_read_bps, 'list'
            )
        if version_lt(version, '1.22'):
            raise host_config_version_error('device_read_bps', '1.22')
        host_config["BlkioDeviceReadBps"] = device_read_bps

    if device_write_bps:
        if not isinstance(device_write_bps, list):
            raise host_config_type_error(
                'device_write_bps', device_write_bps, 'list'
            )
        if version_lt(version, '1.22'):
            raise host_config_version_error('device_write_bps', '1.22')
        host_config["BlkioDeviceWriteBps"] = device_write_bps

    if device_read_iops:
        if not isinstance(device_read_iops, list):
            raise host_config_type_error(
                'device_read_iops', device_read_iops, 'list'
            )
        if version_lt(version, '1.22'):
            raise host_config_version_error('device_read_iops', '1.22')
        host_config["BlkioDeviceReadIOps"] = device_read_iops

    if device_write_iops:
        if not isinstance(device_write_iops, list):
            raise host_config_type_error(
                'device_write_iops', device_write_iops, 'list'
            )
        if version_lt(version, '1.22'):
            raise host_config_version_error('device_write_iops', '1.22')
        host_config["BlkioDeviceWriteIOps"] = device_write_iops

    if tmpfs:
        if version_lt(version, '1.22'):
            raise host_config_version_error('tmpfs', '1.22')
        host_config["Tmpfs"] = convert_tmpfs_mounts(tmpfs)

    if userns_mode:
        if version_lt(version, '1.23'):
            raise host_config_version_error('userns_mode', '1.23')

        if userns_mode != "host":
            raise host_config_value_error("userns_mode", userns_mode)
        host_config['UsernsMode'] = userns_mode

    if pids_limit:
        if not isinstance(pids_limit, int):
            raise host_config_type_error('pids_limit', pids_limit, 'int')
        if version_lt(version, '1.23'):
            raise host_config_version_error('pids_limit', '1.23')
        host_config["PidsLimit"] = pids_limit

    if isolation:
        if not isinstance(isolation, six.string_types):
            raise host_config_type_error('isolation', isolation, 'string')
        if version_lt(version, '1.24'):
            raise host_config_version_error('isolation', '1.24')
        host_config['Isolation'] = isolation

    return host_config


def normalize_links(links):
    if isinstance(links, dict):
        links = six.iteritems(links)

    return ['{0}:{1}'.format(k, v) for k, v in sorted(links)]


def create_networking_config(endpoints_config=None):
    networking_config = {}

    if endpoints_config:
        networking_config["EndpointsConfig"] = endpoints_config

    return networking_config


def create_endpoint_config(version, aliases=None, links=None,
                           ipv4_address=None, ipv6_address=None,
                           link_local_ips=None):
    if version_lt(version, '1.22'):
        raise errors.InvalidVersion(
            'Endpoint config is not supported for API version < 1.22'
        )
    endpoint_config = {}

    if aliases:
        endpoint_config["Aliases"] = aliases

    if links:
        endpoint_config["Links"] = normalize_links(links)

    ipam_config = {}
    if ipv4_address:
        ipam_config['IPv4Address'] = ipv4_address

    if ipv6_address:
        ipam_config['IPv6Address'] = ipv6_address

    if link_local_ips is not None:
        if version_lt(version, '1.24'):
            raise errors.InvalidVersion(
                'link_local_ips is not supported for API version < 1.24'
            )
        ipam_config['LinkLocalIPs'] = link_local_ips

    if ipam_config:
        endpoint_config['IPAMConfig'] = ipam_config

    return endpoint_config


def parse_env_file(env_file):
    """
    Reads a line-separated environment file.
    The format of each line should be "key=value".
    """
    environment = {}

    with open(env_file, 'r') as f:
        for line in f:

            if line[0] == '#':
                continue

            parse_line = line.strip().split('=', 1)
            if len(parse_line) == 2:
                k, v = parse_line
                environment[k] = v
            else:
                raise errors.DockerException(
                    'Invalid line in environment file {0}:\n{1}'.format(
                        env_file, line))

    return environment


def split_command(command):
    if six.PY2 and not isinstance(command, six.binary_type):
        command = command.encode('utf-8')
    return shlex.split(command)


def format_environment(environment):
    def format_env(key, value):
        if value is None:
            return key
        if isinstance(value, six.binary_type):
            value = value.decode('utf-8')

        return u'{key}={value}'.format(key=key, value=value)
    return [format_env(*var) for var in six.iteritems(environment)]


def create_container_config(
    version, image, command, hostname=None, user=None, detach=False,
    stdin_open=False, tty=False, mem_limit=None, ports=None, environment=None,
    dns=None, volumes=None, volumes_from=None, network_disabled=False,
    entrypoint=None, cpu_shares=None, working_dir=None, domainname=None,
    memswap_limit=None, cpuset=None, host_config=None, mac_address=None,
    labels=None, volume_driver=None, stop_signal=None, networking_config=None,
    healthcheck=None,
):
    if isinstance(command, six.string_types):
        command = split_command(command)

    if isinstance(entrypoint, six.string_types):
        entrypoint = split_command(entrypoint)

    if isinstance(environment, dict):
        environment = format_environment(environment)

    if labels is not None and compare_version('1.18', version) < 0:
        raise errors.InvalidVersion(
            'labels were only introduced in API version 1.18'
        )

    if cpuset is not None or cpu_shares is not None:
        if version_gte(version, '1.18'):
            warnings.warn(
                'The cpuset_cpus and cpu_shares options have been moved to '
                'host_config in API version 1.18, and will be removed',
                DeprecationWarning
            )

    if stop_signal is not None and compare_version('1.21', version) < 0:
        raise errors.InvalidVersion(
            'stop_signal was only introduced in API version 1.21'
        )

    if healthcheck is not None and version_lt(version, '1.24'):
        raise errors.InvalidVersion(
            'Health options were only introduced in API version 1.24'
        )

    if compare_version('1.19', version) < 0:
        if volume_driver is not None:
            raise errors.InvalidVersion(
                'Volume drivers were only introduced in API version 1.19'
            )
        mem_limit = mem_limit if mem_limit is not None else 0
        memswap_limit = memswap_limit if memswap_limit is not None else 0
    else:
        if mem_limit is not None:
            raise errors.InvalidVersion(
                'mem_limit has been moved to host_config in API version 1.19'
            )

        if memswap_limit is not None:
            raise errors.InvalidVersion(
                'memswap_limit has been moved to host_config in API '
                'version 1.19'
            )

    if isinstance(labels, list):
        labels = dict((lbl, six.text_type('')) for lbl in labels)

    if mem_limit is not None:
        mem_limit = parse_bytes(mem_limit)

    if memswap_limit is not None:
        memswap_limit = parse_bytes(memswap_limit)

    if isinstance(ports, list):
        exposed_ports = {}
        for port_definition in ports:
            port = port_definition
            proto = 'tcp'
            if isinstance(port_definition, tuple):
                if len(port_definition) == 2:
                    proto = port_definition[1]
                port = port_definition[0]
            exposed_ports['{0}/{1}'.format(port, proto)] = {}
        ports = exposed_ports

    if isinstance(volumes, six.string_types):
        volumes = [volumes, ]

    if isinstance(volumes, list):
        volumes_dict = {}
        for vol in volumes:
            volumes_dict[vol] = {}
        volumes = volumes_dict

    if volumes_from:
        if not isinstance(volumes_from, six.string_types):
            volumes_from = ','.join(volumes_from)
    else:
        # Force None, an empty list or dict causes client.start to fail
        volumes_from = None

    if healthcheck and isinstance(healthcheck, dict):
        healthcheck = Healthcheck(**healthcheck)

    attach_stdin = False
    attach_stdout = False
    attach_stderr = False
    stdin_once = False

    if not detach:
        attach_stdout = True
        attach_stderr = True

        if stdin_open:
            attach_stdin = True
            stdin_once = True

    if compare_version('1.10', version) >= 0:
        message = ('{0!r} parameter has no effect on create_container().'
                   ' It has been moved to host_config')
        if dns is not None:
            raise errors.InvalidVersion(message.format('dns'))
        if volumes_from is not None:
            raise errors.InvalidVersion(message.format('volumes_from'))

    return {
        'Hostname': hostname,
        'Domainname': domainname,
        'ExposedPorts': ports,
        'User': six.text_type(user) if user else None,
        'Tty': tty,
        'OpenStdin': stdin_open,
        'StdinOnce': stdin_once,
        'Memory': mem_limit,
        'AttachStdin': attach_stdin,
        'AttachStdout': attach_stdout,
        'AttachStderr': attach_stderr,
        'Env': environment,
        'Cmd': command,
        'Dns': dns,
        'Image': image,
        'Volumes': volumes,
        'VolumesFrom': volumes_from,
        'NetworkDisabled': network_disabled,
        'Entrypoint': entrypoint,
        'CpuShares': cpu_shares,
        'Cpuset': cpuset,
        'CpusetCpus': cpuset,
        'WorkingDir': working_dir,
        'MemorySwap': memswap_limit,
        'HostConfig': host_config,
        'NetworkingConfig': networking_config,
        'MacAddress': mac_address,
        'Labels': labels,
        'VolumeDriver': volume_driver,
        'StopSignal': stop_signal,
        'Healthcheck': healthcheck,
    }