Mini Shell
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import base64
import datetime
import shlex
import re
import os
try:
import simplejson as json
except Exception:
import json
from libcloud.utils.py3 import httplib
from libcloud.utils.py3 import b
from libcloud.common.base import JsonResponse, ConnectionUserAndKey
from libcloud.common.base import KeyCertificateConnection
from libcloud.common.types import InvalidCredsError
from libcloud.container.base import (Container, ContainerDriver,
ContainerImage)
from libcloud.container.providers import Provider
from libcloud.container.types import ContainerState
VALID_RESPONSE_CODES = [httplib.OK, httplib.ACCEPTED, httplib.CREATED,
httplib.NO_CONTENT]
class DockerResponse(JsonResponse):
valid_response_codes = [httplib.OK, httplib.ACCEPTED, httplib.CREATED,
httplib.NO_CONTENT]
def parse_body(self):
if len(self.body) == 0 and not self.parse_zero_length_body:
return self.body
try:
# error responses are tricky in Docker. Eg response could be
# an error, but response status could still be 200
content_type = self.headers.get('content-type', 'application/json')
if content_type == 'application/json' or content_type == '':
if self.headers.get('transfer-encoding') == 'chunked' and \
'fromImage' in self.request.url:
body = [json.loads(chunk) for chunk in
self.body.strip().replace('\r', '').split('\n')]
else:
body = json.loads(self.body)
else:
body = self.body
except ValueError:
m = re.search('Error: (.+?)"', self.body)
if m:
error_msg = m.group(1)
raise Exception(error_msg)
else:
raise Exception(
'ConnectionError: Failed to parse JSON response')
return body
def parse_error(self):
if self.status == 401:
raise InvalidCredsError('Invalid credentials')
return self.body
def success(self):
return self.status in self.valid_response_codes
class DockerException(Exception):
def __init__(self, code, message):
self.code = code
self.message = message
self.args = (code, message)
def __str__(self):
return "%s %s" % (self.code, self.message)
def __repr__(self):
return "DockerException %s %s" % (self.code, self.message)
class DockerConnection(ConnectionUserAndKey):
responseCls = DockerResponse
timeout = 60
def add_default_headers(self, headers):
"""
Add parameters that are necessary for every request
If user and password are specified, include a base http auth
header
"""
headers['Content-Type'] = 'application/json'
if self.user_id and self.key:
user_b64 = base64.b64encode(b('%s:%s' % (self.user_id, self.key)))
headers['Authorization'] = 'Basic %s' % (user_b64.decode('utf-8'))
return headers
class DockertlsConnection(KeyCertificateConnection):
responseCls = DockerResponse
def __init__(self, key, secret, secure=True,
host='localhost',
port=4243, key_file='', cert_file='', **kwargs):
super(DockertlsConnection, self).__init__(key_file=key_file,
cert_file=cert_file,
secure=secure, host=host,
port=port, url=None,
proxy_url=None,
timeout=None, backoff=None,
retry_delay=None)
if key_file:
keypath = os.path.expanduser(key_file)
is_file_path = os.path.exists(keypath) and os.path.isfile(keypath)
if not is_file_path:
raise InvalidCredsError(
'You need an key PEM file to authenticate with '
'Docker tls. This can be found in the server.'
)
self.key_file = key_file
certpath = os.path.expanduser(cert_file)
is_file_path = os.path.exists(
certpath) and os.path.isfile(certpath)
if not is_file_path:
raise InvalidCredsError(
'You need an certificate PEM file to authenticate with '
'Docker tls. This can be found in the server.'
)
self.cert_file = cert_file
def add_default_headers(self, headers):
headers['Content-Type'] = 'application/json'
return headers
class DockerContainerDriver(ContainerDriver):
"""
Docker container driver class.
>>> from libcloud.container.providers import get_driver
>>> driver = get_driver('docker')
>>> conn = driver(host='198.61.239.128', port=4243)
>>> conn.list_containers()
or connecting to http basic auth protected https host:
>>> conn = driver('user', 'pass', host='https://198.61.239.128', port=443)
connect with tls authentication, by providing a hostname, port, a private
key file (.pem) and certificate (.pem) file
>>> conn = driver(host='https://198.61.239.128',
>>> port=4243, key_file='key.pem', cert_file='cert.pem')
"""
type = Provider.DOCKER
name = 'Docker'
website = 'http://docker.io'
connectionCls = DockerConnection
supports_clusters = False
version = '1.24'
def __init__(self, key='', secret='', secure=False, host='localhost',
port=4243, key_file=None, cert_file=None):
"""
:param key: API key or username to used (required)
:type key: ``str``
:param secret: Secret password to be used (required)
:type secret: ``str``
:param secure: Whether to use HTTPS or HTTP. Note: Some providers
only support HTTPS, and it is on by default.
:type secure: ``bool``
:param host: Override hostname used for connections.
:type host: ``str``
:param port: Override port used for connections.
:type port: ``int``
:param key_file: Path to private key for TLS connection (optional)
:type key_file: ``str``
:param cert_file: Path to public key for TLS connection (optional)
:type cert_file: ``str``
:return: ``None``
"""
if key_file:
self.connectionCls = DockertlsConnection
self.key_file = key_file
self.cert_file = cert_file
secure = True
if host.startswith('https://'):
secure = True
# strip the prefix
prefixes = ['http://', 'https://']
for prefix in prefixes:
if host.startswith(prefix):
host = host.strip(prefix)
super(DockerContainerDriver, self).__init__(key=key, secret=secret,
secure=secure, host=host,
port=port,
key_file=key_file,
cert_file=cert_file)
if key_file or cert_file:
# docker tls authentication-
# https://docs.docker.com/articles/https/
# We pass two files, a key_file with the
# private key and cert_file with the certificate
# libcloud will handle them through LibcloudHTTPSConnection
if not (key_file and cert_file):
raise Exception(
'Needs both private key file and '
'certificate file for tls authentication')
self.connection.secure = secure
self.connection.host = host
self.connection.port = port
# set API version
self.version = self._get_api_version()
def _ex_connection_class_kwargs(self):
kwargs = {}
if hasattr(self, 'key_file'):
kwargs['key_file'] = self.key_file
if hasattr(self, 'cert_file'):
kwargs['cert_file'] = self.cert_file
return kwargs
def install_image(self, path):
"""
Install a container image from a remote path.
:param path: Path to the container image
:type path: ``str``
:rtype: :class:`libcloud.container.base.ContainerImage`
"""
payload = {
}
data = json.dumps(payload)
result = self.connection.request('/v%s/images/create?fromImage=%s' %
(self.version, path), data=data,
method='POST')
if "errorDetail" in result.body:
raise DockerException(None, result.body)
image_id = None
# the response is slightly different if the image is already present
# and it's not downloaded. both messages below indicate that the image
# is available for use to the daemon
if re.search(r'Downloaded newer image', result.body) or \
re.search(r'"Status: Image is up to date', result.body):
if re.search(r'sha256:(?P<id>[a-z0-9]{64})', result.body):
image_id = re.findall(r'sha256:(?P<id>[a-z0-9]{64})',
result.body)[-1]
# if there is a failure message or if there is not an image id in the
# response then throw an exception.
if image_id is None:
raise DockerException(None, 'failed to install image')
image = ContainerImage(
id=image_id,
name=path,
path=path,
version=None,
driver=self.connection.driver,
extra={})
return image
def list_images(self):
"""
List the installed container images
:rtype: ``list`` of :class:`libcloud.container.base.ContainerImage`
"""
result = self.connection.request('/v%s/images/json' %
(self.version)).object
images = []
for image in result:
try:
name = image.get('RepoTags')[0]
except Exception:
name = image.get('Id')
images.append(ContainerImage(
id=image.get('Id'),
name=name,
path=name,
version=None,
driver=self.connection.driver,
extra={
"created": image.get('Created'),
"size": image.get('Size'),
"virtual_size": image.get('VirtualSize'),
},
))
return images
def list_containers(self, image=None, all=True):
"""
List the deployed container images
:param image: Filter to containers with a certain image
:type image: :class:`libcloud.container.base.ContainerImage`
:param all: Show all container (including stopped ones)
:type all: ``bool``
:rtype: ``list`` of :class:`libcloud.container.base.Container`
"""
if all:
ex = '?all=1'
else:
ex = ''
try:
result = self.connection.request(
"/v%s/containers/json%s" % (self.version, ex)).object
except Exception as exc:
errno = getattr(exc, 'errno', None)
if errno == 111:
raise DockerException(
errno,
'Make sure docker host is accessible'
'and the API port is correct')
raise
containers = [self._to_container(value) for value in result]
return containers
def deploy_container(self, name, image, parameters=None, start=True,
command=None, hostname=None, user='',
stdin_open=True, tty=True,
mem_limit=0, ports=None, environment=None, dns=None,
volumes=None, volumes_from=None,
network_disabled=False, entrypoint=None,
cpu_shares=None, working_dir='', domainname=None,
memswap_limit=0, port_bindings=None,
network_mode='bridge', labels=None):
"""
Deploy an installed container image
For details on the additional parameters see : http://bit.ly/1PjMVKV
:param name: The name of the new container
:type name: ``str``
:param image: The container image to deploy
:type image: :class:`libcloud.container.base.ContainerImage`
:param parameters: Container Image parameters
:type parameters: ``str``
:param start: Start the container on deployment
:type start: ``bool``
:rtype: :class:`Container`
"""
command = shlex.split(str(command))
if port_bindings is None:
port_bindings = {}
params = {
'name': name
}
payload = {
'Hostname': hostname,
'Domainname': domainname,
'ExposedPorts': ports,
'User': user,
'Tty': tty,
'OpenStdin': stdin_open,
'StdinOnce': False,
'Memory': mem_limit,
'AttachStdin': True,
'AttachStdout': True,
'AttachStderr': True,
'Env': environment,
'Cmd': command,
'Dns': dns,
'Image': image.name,
'Volumes': volumes,
'VolumesFrom': volumes_from,
'NetworkDisabled': network_disabled,
'Entrypoint': entrypoint,
'CpuShares': cpu_shares,
'WorkingDir': working_dir,
'MemorySwap': memswap_limit,
'PublishAllPorts': True,
'PortBindings': port_bindings,
'NetworkMode': network_mode,
'Labels': labels,
}
data = json.dumps(payload)
try:
result = self.connection.request('/v%s/containers/create'
% (self.version),
data=data,
params=params, method='POST')
except Exception as e:
message = e.message or str(e) # pylint: disable=no-member
if message.startswith('No such image:'):
raise DockerException(None, 'No such image: %s' % image.name)
else:
raise DockerException(None, e)
id_ = result.object['Id']
payload = {
'Binds': [],
'PublishAllPorts': True,
'PortBindings': port_bindings,
}
data = json.dumps(payload)
if start:
if float(self._get_api_version()) > 1.22:
result = self.connection.request(
'/v%s/containers/%s/start' %
(self.version, id_),
method='POST')
else:
result = self.connection.request(
'/v%s/containers/%s/start' %
(self.version, id_), data=data,
method='POST')
return self.get_container(id_)
def get_container(self, id):
"""
Get a container by ID
:param id: The ID of the container to get
:type id: ``str``
:rtype: :class:`libcloud.container.base.Container`
"""
result = self.connection.request("/v%s/containers/%s/json" %
(self.version, id)).object
return self._to_container(result)
def start_container(self, container):
"""
Start a container
:param container: The container to be started
:type container: :class:`libcloud.container.base.Container`
:return: The container refreshed with current data
:rtype: :class:`libcloud.container.base.Container`
"""
if float(self._get_api_version()) > 1.22:
result = self.connection.request(
'/v%s/containers/%s/start' %
(self.version, container.id),
method='POST')
else:
payload = {
'Binds': [],
'PublishAllPorts': True,
}
data = json.dumps(payload)
result = self.connection.request(
'/v%s/containers/%s/start' %
(self.version, container.id),
method='POST', data=data)
if result.status in VALID_RESPONSE_CODES:
return self.get_container(container.id)
else:
raise DockerException(result.status,
'failed to start container')
def stop_container(self, container):
"""
Stop a container
:param container: The container to be stopped
:type container: :class:`libcloud.container.base.Container`
:return: The container refreshed with current data
:rtype: :class:`libcloud.container.base.Container`
"""
result = self.connection.request('/v%s/containers/%s/stop' %
(self.version, container.id),
method='POST')
if result.status in VALID_RESPONSE_CODES:
return self.get_container(container.id)
else:
raise DockerException(result.status,
'failed to stop container')
def restart_container(self, container):
"""
Restart a container
:param container: The container to be stopped
:type container: :class:`libcloud.container.base.Container`
:return: The container refreshed with current data
:rtype: :class:`libcloud.container.base.Container`
"""
data = json.dumps({'t': 10})
# number of seconds to wait before killing the container
result = self.connection.request('/v%s/containers/%s/restart' %
(self.version, container.id),
data=data, method='POST')
if result.status in VALID_RESPONSE_CODES:
return self.get_container(container.id)
else:
raise DockerException(result.status,
'failed to restart container')
def destroy_container(self, container):
"""
Remove a container
:param container: The container to be destroyed
:type container: :class:`libcloud.container.base.Container`
:return: True if the destroy was successful, False otherwise.
:rtype: ``bool``
"""
result = self.connection.request('/v%s/containers/%s' % (self.version,
container.id),
method='DELETE')
return result.status in VALID_RESPONSE_CODES
def ex_list_processes(self, container):
"""
List processes running inside a container
:param container: The container to list processes for.
:type container: :class:`libcloud.container.base.Container`
:rtype: ``str``
"""
result = self.connection.request("/v%s/containers/%s/top" %
(self.version, container.id)).object
return result
def ex_rename_container(self, container, name):
"""
Rename a container
:param container: The container to be renamed
:type container: :class:`libcloud.container.base.Container`
:param name: The new name
:type name: ``str``
:rtype: :class:`libcloud.container.base.Container`
"""
result = self.connection.request('/v%s/containers/%s/rename?name=%s'
% (self.version, container.id, name),
method='POST')
if result.status in VALID_RESPONSE_CODES:
return self.get_container(container.id)
def ex_get_logs(self, container, stream=False):
"""
Get container logs
If stream == True, logs will be yielded as a stream
From Api Version 1.11 and above we need a GET request to get the logs
Logs are in different format of those of Version 1.10 and below
:param container: The container to list logs for
:type container: :class:`libcloud.container.base.Container`
:param stream: Stream the output
:type stream: ``bool``
:rtype: ``bool``
"""
payload = {}
data = json.dumps(payload)
if float(self._get_api_version()) > 1.10:
result = self.connection.request(
"/v%s/containers/%s/logs?follow=%s&stdout=1&stderr=1" %
(self.version, container.id, str(stream))).object
logs = result
else:
result = self.connection.request(
"/v%s/containers/%s/attach?logs=1&stream=%s&stdout=1&stderr=1"
% (self.version, container.id, str(stream)),
method='POST',
data=data)
logs = result.body
return logs
def ex_search_images(self, term):
"""Search for an image on Docker.io.
Returns a list of ContainerImage objects
>>> images = conn.ex_search_images(term='mistio')
>>> images
[<ContainerImage: id=rolikeusch/docker-mistio...>,
<ContainerImage: id=mist/mistio, name=mist/mistio,
driver=Docker ...>]
:param term: The search term
:type term: ``str``
:rtype: ``list`` of :class:`libcloud.container.base.ContainerImage`
"""
term = term.replace(' ', '+')
result = self.connection.request('/v%s/images/search?term=%s' %
(self.version, term)).object
images = []
for image in result:
name = image.get('name')
images.append(
ContainerImage(
id=name,
path=name,
version=None,
name=name,
driver=self.connection.driver,
extra={
"description": image.get('description'),
"is_official": image.get('is_official'),
"is_trusted": image.get('is_trusted'),
"star_count": image.get('star_count'),
},
))
return images
def ex_delete_image(self, image):
"""
Remove image from the filesystem
:param image: The image to remove
:type image: :class:`libcloud.container.base.ContainerImage`
:rtype: ``bool``
"""
result = self.connection.request('/v%s/images/%s' % (self.version,
image.name),
method='DELETE')
return result.status in VALID_RESPONSE_CODES
def _to_container(self, data):
"""
Convert container in Container instances
"""
try:
name = data.get('Name').strip('/')
except Exception:
try:
name = data.get('Names')[0].strip('/')
except Exception:
name = data.get('Id')
state = data.get('State')
if isinstance(state, dict):
status = data.get(
'Status',
state.get('Status')
if state is not None else None)
else:
status = data.get('Status')
if 'Exited' in status:
state = ContainerState.STOPPED
elif status.startswith('Up '):
state = ContainerState.RUNNING
elif 'running' in status:
state = ContainerState.RUNNING
else:
state = ContainerState.STOPPED
image = data.get('Image')
ports = data.get('Ports', [])
created = data.get('Created')
if isinstance(created, float):
created = ts_to_str(created)
extra = {
'id': data.get('Id'),
'status': data.get('Status'),
'created': created,
'image': image,
'ports': ports,
'command': data.get('Command'),
'sizerw': data.get('SizeRw'),
'sizerootfs': data.get('SizeRootFs'),
}
ips = []
if ports is not None:
for port in ports:
if port.get('IP') is not None:
ips.append(port.get('IP'))
return Container(
id=data['Id'],
name=name,
image=ContainerImage(
id=data.get('ImageID', None),
path=image,
name=image,
version=None,
driver=self.connection.driver
),
ip_addresses=ips,
state=state,
driver=self.connection.driver,
extra=extra)
def _get_api_version(self):
"""
Get the docker API version information
"""
result = self.connection.request('/version').object
result = result or {}
api_version = result.get('ApiVersion')
return api_version
def ts_to_str(timestamp):
"""
Return a timestamp as a nicely formated datetime string.
"""
date = datetime.datetime.fromtimestamp(timestamp)
date_string = date.strftime("%d/%m/%Y %H:%M %Z")
return date_string
Zerion Mini Shell 1.0