def get_list(cls, url, version):
cli = Client(base_url=url, version=version)
image_list = cli.images(all=True)
rel = []
for image in image_list:
item = {}
name_tag = image['RepoTags'][0]
name = name_tag.split(':')[0]
if name == '<none>':
continue
item['name'] = name
item['tag'] = name_tag.split(':')[1]
create_time = time.localtime(image['Created'])
format_time = time.strftime('%Y-%m-%d %H:%M:%S', create_time)
item['create_time'] = format_time
item['size'] = format_size(float(image['VirtualSize']))
rel.append(item)
def started(_):
docker = Client()
data = docker.inspect_container(self.namespacing_prefix + name)
self.assertEqual(
image_name,
data[u"Config"][u"Image"],
)
def test_pull_timeout_pull(self):
"""
Image pull timeout does not affect subsequent pulls.
"""
# Use an image that isn't likely to be in use by anything, since
# it's old, and isn't used by other tests. Note, this is the
# same image as test_pull_image_if_necessary, but they run at
# different times.
image = u"busybox:ubuntu-12.04"
# Make sure image is gone:
docker = Client()
try:
docker.remove_image(image, force=True)
except APIError as e:
if e.response.status_code != 404:
raise
name = random_name(self)
client = DockerClient(namespace=self.namespacing_prefix, long_timeout=1)
self.addCleanup(client.remove, name)
d = client.add(name, image)
def unexpected_success(_):
self.fail("Image unexpectedly pulled within timeout limit")
def expected_failure(failure):
self.assertIsNotNone(failure.check(IOError))
# We got our failure, now try to successfully pull
client = DockerClient(namespace=self.namespacing_prefix, long_timeout=600)
return client.add(name, image)
d.addCallbacks(unexpected_success, expected_failure)
return d
def barman_check(self):
"""Connect to the Barman Docker object and check configuration. Error out on failure."""
docker_client = Client(base_url=self.url)
try:
# TODO: verify that the barman container is running
docker_client.inspect_container(self.container)
except Exception:
print('stats err failed when inspecting the container.')
sys.exit(1)
try:
exec_id = docker_client.exec_create(self.container, self.command)
response = docker_client.exec_start(exec_id)
except Exception:
print('stats err failed to execute barman check command in the container.')
sys.exit(1)
failed = False
for line in response.splitlines()[1:]:
check, value = line.strip().split(': ', 1)
slug = check.lower().replace(' ', '_').replace('-', '_')
print('metric {} string {}'.format(slug, value))
if value.startswith('FAILED'):
failed = True
if failed:
print('status err failure in barman check')
sys.exit(1)
print('status ok all checks passed')
def find_container(needle):
cli = Client(base_url='unix://var/run/docker.sock')
for container in cli.containers():
for name in container['Names']:
if needle in name:
return container
return False
def cleanup_host(daemon_url, timeout=5):
"""
Cleanup a container host when use removes the host
Maybe we will remove the networks?
:param daemon_url: Docker daemon url
:param timeout: timeout to wait
:return:
"""
if not daemon_url or not daemon_url.startswith("tcp://"):
logger.error("Invalid daemon_url={}".format(daemon_url))
return False
try:
client = Client(base_url=daemon_url, version="auto", timeout=timeout)
net_names = [x["Name"] for x in client.networks()]
for cs_type in CONSENSUS_PLUGINS:
net_name = CLUSTER_NETWORK + "_{}".format(cs_type)
if net_name in net_names:
logger.debug("Remove network {}".format(net_name))
client.remove_network(net_name)
else:
logger.warning("Network {} not exists!".format(net_name))
except Exception as e:
logger.error("Exception happens!")
logger.error(e)
return False
return True
class DockerInfo(object):
def __init__(self):
cfg = config.get_instance()
self.cfg = cfg
self.log = aLogger.getLogger(self.__class__.__name__, self.cfg)
self.__url = self.cfg.get("docker.url", check_type=str)
self._conn = Client(self.__url)
def get_ip_info(self, name: str):
name = name.split(".")
try:
info = self._conn.inspect_container(name[0])
if info is not None and "NetworkSettings" in info and "IPAddress" in info["NetworkSettings"]:
return info["NetworkSettings"]["IPAddress"] if info["NetworkSettings"]["IPAddress"].strip() != "" else None
except Exception as e:
return None
return None
def container_name_by_ip(self, ip:str):
containerIDS = self._conn.containers()
for containerID in containerIDS:
container_obj = self._conn.inspect_container(containerID)
if container_obj is not None and "NetworkSettings" in container_obj and "IPAddress" in container_obj["NetworkSettings"]:
container_ip = container_obj["NetworkSettings"]["IPAddress"] if container_obj["NetworkSettings"]["IPAddress"].strip() else None
if container_ip == ip:
return "%s.%s" % (container_obj["Config"]["Hostname"], container_obj["Config"]["Domainname"])
def detect_daemon_type(daemon_url, timeout=5):
""" Try to detect the daemon type
Only wait for timeout seconds.
:param daemon_url: Docker daemon url
:param timeout: Time to wait for the response
:return: host type info
"""
if not daemon_url or not daemon_url.startswith("tcp://"):
return None
segs = daemon_url.split(":")
if len(segs) != 3:
logger.error("Invalid daemon url = ", daemon_url)
return None
try:
client = Client(base_url=daemon_url, version="auto", timeout=timeout)
server_version = client.info()['ServerVersion']
if server_version.startswith('swarm'):
return HOST_TYPES[1]
else:
return HOST_TYPES[0]
except Exception as e:
logger.error(e)
return None
def rm_container(docker_client: docker.Client, args, state: dict):
containers = args.container
error = 0
for container in containers:
if container == '-':
container = get_last_container(state)
try:
docker_client.remove_container(container, link=args.link, v=args.volumes, force=args.force)
print(container)
except docker.errors.NotFound:
pass
except docker.errors.APIError as e:
status_code = e.response.status_code
if status_code < 500:
print(e.response.content.decode('utf-8').strip(), file=sys.stderr)
error = errors.INVALID_INPUT
else:
print(e.response.content.decode('utf-8').strip(), file=sys.stderr)
if error == 0:
error = errors.DOCKER_ERROR
except docker.errors.DockerException as e:
print(e.explanation.decode('utf-8').strip(), file=sys.stderr)
if error == 0:
error = errors.DOCKER_ERROR
if error > 0:
raise errors.DkrException("There was an error", error)
if 'last_container' in state:
state.pop('last_container')
def stop_container(docker_client: docker.Client, args, state: dict):
containers = args.container
error = 0
for container in containers:
if container == '-':
container = get_last_container(state)
try:
docker_client.stop(container, timeout=args.timeout)
print(container)
except docker.errors.APIError as e:
status_code = e.response.status_code
if status_code < 500:
print(e.response.content.decode('utf-8').strip(), file=sys.stderr)
error = errors.INVALID_INPUT
else:
print(e.response.content.decode('utf-8').strip(), file=sys.stderr)
if error == 0:
error = errors.DOCKER_ERROR
except docker.errors.DockerException as e:
print(e.explanation.decode('utf-8').strip(), file=sys.stderr)
if error == 0:
error = errors.DOCKER_ERROR
state['last_container'] = containers[-1]
if error > 0:
raise errors.DkrException("There was an error", error)
def StopContainer():
if not os.geteuid() == 0:
print "Command must be run as root"
sys.exit(-1)
cli = Client()
cli.stop('suri-buildbot')
sys.exit(0)
def get_client(self, verbose=False):
url = docker_url()
tls = url.split(':')[-1] == '2376'
if tls:
url = 'https://' + url.split('://')[-1]
import requests.packages.urllib3 as urllib3
urllib3.__version__ = '1.9'
client = Client(base_url=url, tls=tls)
if tls:
client.verify = False
import os
cert_home = os.path.join(os.getenv('HOME'), '.docker')
client.cert = (
os.path.join(cert_home, 'cert.pem'),
os.path.join(cert_home, 'key.pem'),
)
if verbose:
version_info = six.iteritems(client.version())
log.info("Fig version %s", __version__)
log.info("Docker base_url: %s", client.base_url)
log.info("Docker version: %s",
", ".join("%s=%s" % item for item in version_info))
return verbose_proxy.VerboseProxy('docker', client)
return client
def getlogs(params):
c = Client(base_url = 'unix://var/run/docker.sock')
if 'stdout' in params:
params['stdout'] = bool(params['stdout'])
if 'stdin' in params:
params['stdin'] = bool(params['stdin'])
if 'stream' in params:
params['stream'] = bool(params['stream'])
if 'stderr' in params:
params['stderr'] = bool(params['stderr'])
if 'timestamps' in params:
params['timestamps'] = bool(params['timestamps'])
if 'tail' in params:
if isdigit(params['tail']):
params['tail'] = int(params['tail'])
container = c.logs(**params)
yield container
def _pull_image_to_docker_host(self, base_url, image_name, image_version):
"""
Pull image from private registry to docker host.
"""
client = Client(base_url=base_url)
response = [line for line in client.pull(repository=image_name,
tag=image_version, stream=True)]
def _push_image_to_registry(self, base_url, image_name, image_version,
image_token):
"""
Push image from docker host to private registry.
Returns the sha256 digest of the image.
"""
image_complete_name = '%s:%s' %(image_name, image_version)
client = Client(base_url=base_url)
try:
response = [res for res in client.push(image_complete_name,
stream=True)]
except Exception:
logger.error('Push image %s to registry failed.' %
image_complete_name)
return None
try:
digest = fetch_digest_from_response(response[-1])
except Exception:
logger.error('Parse the digest response error.')
return None
return digest
def _tag_image_with_new_name(self, base_url, old_image_name,
old_image_version, image_name, image_version):
"""
Docker tag old_image_name:old_image_version image_name:image_version.
"""
client = Client(base_url=base_url)
old_image = "{}:{}".format(old_image_name, old_image_version)
try:
response = client.tag(image=old_image, repository=image_name,
tag=image_version)
except Exception as e:
logger.debug(e)
response = False
if not response:
logger.info("Tag image {} to {}:{} failed.".format(old_image,
image_name, image_version))
return None
image_token = self._get_image_token_on_docker_host(base_url,
image_name, image_version)
self._delete_image_on_docker_host(base_url, old_image_name,
old_image_version)
return image_token
def _import_snapshot_on_docker_host(self, base_url, build_file, image_name,
image_version='latest'):
"""
Import container snapshot on the selected docker host.
'base_url': the url of docker host.
'build_file': the name of the build file in absolute path.
'image_name': the name of the image, containing registry address, user
name and image name.
'image_version': the version of the image.
Returns:
'token': the image token
"""
self._delete_image_on_docker_host(base_url, image_name, image_version)
client = Client(base_url=base_url)
try:
res_json = client.import_image_from_file(build_file, image_name,
image_version)
res = json.loads(res_json)
except Exception:
logger.error('import snapshot on docker host %s failed.' % base_url)
return None
return res.get('status', None)
def _push_image_to_registry(self, base_url, image_name, image_version,
image_token):
"""
Push image from docker host to private registry.
Returns the sha256 digest of the image.
"""
image_complete_name = '%s:%s' %(image_name, image_version)
if not self._is_image_on_docker_host(base_url, image_token):
logger.error('There is no image called %s on docker host %s' %
(image_complete_name, base_url))
return None
client = Client(base_url=base_url)
try:
response = [res for res in client.push(image_complete_name,
stream=True)]
except Exception:
logger.error('Communicate with %s failed.' % base_url)
return None
try:
digest = fetch_digest_from_response(response[-1])
except Exception:
logger.error('Parse the digest response error.')
return None
return digest
def CreateContainer():
cli = Client()
# FIXME check if existing
print "Pulling docking image, first run should take long"
cli.pull('regit/suri-buildbot')
cli.create_container(name='suri-buildbot', image='regit/suri-buildbot', ports=[8010, 22], volumes=['/data/oisf', '/data/buildbot/master/master.cfg'])
sys.exit(0)
def _load_image_on_docker_host(self, base_url, build_file, image_name,
image_version='latest'):
"""
Import container snapshot on the selected docker host.
'base_url': the url of docker host.
'build_file': the name of the build file in absolute path.
'image_name': the name of the image, containing registry address, user
name and image name.
'image_version': the version of the image.
Returns:
'token': the image token
"""
self._delete_image_on_docker_host(base_url, self.old_image_name,
self.old_image_version)
self._delete_image_on_docker_host(base_url, image_name, image_version)
client = Client(base_url=base_url)
try:
with open(build_file, 'rb') as fileobj:
client.load_image(fileobj)
except Exception:
logger.error('load image file on docker host %s failed.' % base_url)
return None
return self._tag_image_with_new_name(base_url, self.old_image_name,
self.old_image_version, image_name, image_version)
class PrometheusHelper(object):
def __init__(self, template_dir):
self.clusters = []
self.template_dir = template_dir
self.template = self.get_template_path('prometheus/prometheus.conf.tmpl')
self.target_path = '/etc/gluu/prometheus/prometheus.conf' #TODO: must come from flask config
self.docker = Client("unix:///var/run/docker.sock")
self.prometheus_cid = "/var/run/prometheus.cid" #TODO: must come from flask config
def __load_clusters(self):
self.clusters = db.all("clusters")
def __render(self):
with open(self.template, 'r') as fp:
tmpl = fp.read()
template = Template(tmpl)
rtxt = template.render(clusters = self.clusters)
with open(self.target_path, 'w') as fp:
fp.write(rtxt)
def __restart(self):
with open(self.prometheus_cid, 'r') as fp:
cid = fp.read()
self.docker.restart(container=cid)
def update(self):
self.__load_clusters()
self.__render()
self.__restart()
def get_template_path(self, path):
template_path = os.path.join(self.template_dir, path)
return template_path
def __init__(self, *args, **kw):
"""
:param timedelta long_timeout: A timeout to use for any request that
doesn't have any other timeout specified.
"""
self._long_timeout = kw.pop('long_timeout', None)
Client.__init__(self, *args, **kw)
def _get_container_state(self, host, name):
docker_cli = Client("tcp://{}:2375".format(host), timeout=1200, version='1.17')
try:
if docker_cli.inspect_container(name)['State']['Running']:
return JobState.up
except:
return JobState.destroyed
def deploy_project(self, build_id, **kwargs):
build = Build.objects.get(id=build_id)
DOCKER_HOST = os.environ['DOCKER_HOST']
DOCKER_HOST = DOCKER_HOST.replace('tcp', 'https')
DOCKER_CERT_PATH = os.environ['DOCKER_CERT_PATH']
cert_dir = os.environ['DOCKER_CERT_PATH'] + '/'
tls_config = TLSConfig(
client_cert=(cert_dir + 'cert.pem', cert_dir + 'key.pem'), verify=False
)
docker_client = Client(base_url=DOCKER_HOST, tls = tls_config)
try:
Build.objects.get(project = build.project, is_active = True)
except ObjectDoesNotExist:
pass
else:
old_build = Build.objects.get(project = build.project, is_active = True)
old_build.is_active = False
old_build.save()
docker_client.stop(container = old_build.container)
response = docker_client.start(container = build.container, port_bindings = { 8080 : build.port })
build.is_active = True
build.save()
return response
def _get_image_token_on_docker_host(self, base_url, image_name,
image_version):
"""
Given the image name and version, return the token of the image on the
docker host.
"""
image_complete_name = '%s:%s' %(image_name, image_version)
logger.debug(image_complete_name)
client = Client(base_url=base_url)
try:
images = client.images()
except Exception as e:
logger.debug(e)
logger.debug("Communicate with docker host {} failed.".format(
base_url))
return None
tokens = [image['Id'] for image in images
if image_complete_name in image['RepoTags']]
if not tokens:
logger.info("The docker host {} has no image {}:{}".format(base_url,
image_name, image_version))
return None
return tokens[0]
def main():
cli = Client(base_url="unix://var/run/docker.sock")
hosts = {"static": OrderedDict(), "dynamic": OrderedDict()}
for container in cli.containers():
data = container["Image"].split("/")
if len(data) != 2:
continue
host, name = data
if host == "tellendil":
if name in ["static", "dynamic"]:
hosts[name][container["Id"]] = container["NetworkSettings"]["Networks"]["bridge"]["IPAddress"]
update_conf(safe_get(hosts, "static"), safe_get(hosts, "dynamic"))
for event in cli.events(decode=True):
data = event.get("from", "").split("/")
if len(data) != 2:
continue
host, name = data
if event["Action"] == "die" and host == "tellendil":
if name in ["static", "dynamic"]:
hosts[name].pop(event["id"])
update_conf(safe_get(hosts, "static"), safe_get(hosts, "dynamic"))
elif event["Action"] == "start" and host == "tellendil":
if name in ["static", "dynamic"]:
hosts[name][event["id"]] = cli.inspect_container(event["id"])["NetworkSettings"]["Networks"]["bridge"]["IPAddress"]
update_conf(safe_get(hosts, "static"), safe_get(hosts, "dynamic"))
def __connect_to_default_socket(self):
try:
c = Client(base_url='unix:///var/run/docker.sock')
c.info()
return c
except Exception:
return None
def main():
# register the exit signals
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
args = parse_args()
global hosts_path
hosts_path = args.file
docker = Client(base_url='unix://%s'%args.socket)
events = docker.events(decode=True)
#get running containers
for c in docker.containers(quiet=True,all=False):
container_id = c["Id"]
container = get_container_data(docker, container_id)
hosts[container_id] = container
update_hosts_file()
#listen for events to keep the hosts file updated
for e in events:
status = e["status"];
if status =="start":
container_id = e["id"]
container = get_container_data(docker, container_id)
hosts[container_id] = container
update_hosts_file()
if status=="stop" or status=="die" or status=="destroy":
container_id = e["id"]
if container_id in hosts:
hosts.pop(container_id)
update_hosts_file()
def _get_docker():
global _docker
if not _docker:
if sys.platform.startswith('darwin'):
_machine_check_connectivity()
# Create the Docker client
version_client = Client(version=MINIMUM_API_VERSION, **_docker_kwargs)
try:
api_version = version_client.version()['ApiVersion']
except ConnectionError:
try:
# workaround for connection issue when old version specified
# on some clients
version_client = Client(**_docker_kwargs)
api_version = version_client.version()['ApiVersion']
except:
raise DatacatsError(DOCKER_FAIL_STRING)
except:
raise DatacatsError(DOCKER_FAIL_STRING)
version = get_api_version(DEFAULT_DOCKER_API_VERSION, api_version)
_docker = Client(version=version, **_docker_kwargs)
return _docker
def _get_container(name):
client = Client()
for c in client.containers(all=True):
for container_name in c['Names']:
if name == container_name:
return c
return None
from flask import Flask, request
from docker import Client
import json
app = Flask(__name__)
docker_cli = Client(base_url='unix://var/run/docker.sock')
@app.route('/start', methods=['POST'])
def start():
for line in docker_cli.pull('itxtech/docker-env-genisys', stream=True):
print(json.dumps(json.loads(line), indent=4))
container = docker_cli.create_container(
image='itxtech/docker-env-genisys',
ports=['19133:19132/udp'],
host_config=docker_cli.create_host_config(binds=[
'/home/ubuntu/genisys.phar:/srv/genisys/genisys.phar',
'/home/ubuntu/server.properties:/srv/genisys/server.properties',
], ),
name='mcpe',
tty=True,
stdin_open=True,
)
response = docker_cli.start(container=container)
return 'ok'
if __name__ == '__main__':
app.run('0.0.0.0', debug=True)
def __init__(self):
self.cli = Client(base_url="tcp://192.168.205.125:2376", version="auto")
import subprocess
import os
from docker import Client
from utils import build_args
cli = Client(base_url='unix:///var/run/docker.sock', tls=False, version='1.18')
def create_subprocess(cmd):
"""
Create a new subprocess in the OS
:param cmd: command to execute in the subprocess
:return: the output and errors of the subprocess
"""
process = subprocess.Popen(cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=os.environ,
shell=True)
return process.communicate()
def docker_run(cmd):
"""
r = envoy.run(command)
if r.std_err:
return r.std_err
return r.std_out
def setUpClass(cls):
cls.client = Client(docker_url())
cls.client.pull('busybox', tag='latest')
class Docker(object):
def __init__(self,
socket,
remove_intermediate=False,
registry=None,
insecure_registry=False):
log.debug('DockerClient connecting to {}'.format(socket))
self._socket = socket
self._client = Client(base_url=socket)
self._remove_intermediate = remove_intermediate
self._registry = registry
self._insecure_registry = insecure_registry
@exception_safe(ConnectionError, False)
def build(self, dockerfile, image):
"""/
:param dockerfile: The dockerfile full path
:param image: the image name (eg: midolman:1.9)
"""
log.info('Now building {}'.format(image))
log.debug('Invoking docker build on {}'.format(dockerfile))
response = self._client.build(path=os.path.dirname(dockerfile),
tag=image,
pull=False,
rm=self._remove_intermediate,
dockerfile=os.path.basename(dockerfile))
last_line = None
for line in response:
eval_line = eval(line)
if 'stream' in eval_line:
print(eval_line['stream']),
last_line = eval_line['stream']
# Check for ensure success after building
if 'Successfully built' not in last_line:
log.error('Error building the image {}.'.format(image))
return False
return True
@exception_safe(ConnectionError, None)
def pull(self, image):
"""
:param image: The image name with its tag
:param repository: The repository where to pull the image
(dockerhub if none defined)
"""
name, tag = image.split(':')
repository = '{}/{}'.format(self._registry, name) \
if self._registry else name
log.info('Now Pulling {}:{}'.format(repository, tag))
response = self._client.pull(repository=repository,
tag=tag,
insecure_registry=self._insecure_registry,
stream=True)
for line in response:
eval_line = eval(line)
if 'error' in eval_line:
log.error('Error pulling image: {}'.format(eval_line['error']))
return False
if 'status' in eval_line:
log.info('[{}:{}] Status: {}'.format(repository, tag,
eval_line['status']))
if self._registry:
# If pulling from an external repo, we need to tag with the
# actual image name used in the flavours definition.
images = self.list_images(repository)
for image in images:
for repotag in image['RepoTags']:
if '{}:{}'.format(repository, tag) == repotag:
self._client.tag(image['Id'], name, tag, force=True)
return True
@exception_safe(ConnectionError, None)
def push(self, image):
"""
:param image: The image name with its tag
:param repository: The repository where to push the image
(dockerhub if none defined)
"""
name, tag = image.split(':')
if self._registry:
# First tag the local image to map to the new registry
repository = '{}/{}'.format(self._registry, name)
images = self.list_images(name)
for image in images:
for repotag in image['RepoTags']:
if '{}:{}'.format(name, tag) == repotag:
self._client.tag(image['Id'],
repository,
tag,
force=True)
else:
repository = name
log.info('Now pushing {}:{}'.format(repository, tag))
response = self._client.push(repository=repository,
tag=tag,
insecure_registry=self._insecure_registry,
stream=True)
for line in response:
eval_line = eval(line)
if 'error' in eval_line:
log.error('Error pushing image: {}'.format(eval_line['error']))
return False
if 'status' in eval_line:
if 'Pushing' not in eval_line['status'] \
and 'Buffering' not in eval_line['status']:
log.info('[{}:{}] Status: {}'.format(
repository, tag, eval_line['status']))
return True
@exception_safe(ConnectionError, [])
def list_images(self, prefix=None):
"""
List the available images
:param prefix: Filter the images by a prefix (eg: "sandbox/")
:return: the images list
"""
images = self._client.images()
if prefix:
filtered = list()
for image in images:
for tag in image['RepoTags']:
if tag.startswith(prefix):
filtered.append(image)
images = filtered
return images
def list_containers(self, prefix=None):
"""
List the running containers, prefixed with prefix
:param prefix: The container's name prefix
:return: The list of containers
"""
containers = self._client.containers()
filtered = list()
if prefix:
for container_ref in containers:
if prefix in container_ref['Names'][0]:
filtered.append(container_ref)
containers = filtered
return containers
def container_by_name(self, name):
containers = self.list_containers()
for container_ref in containers:
if name == self.principal_container_name(container_ref):
return container_ref
@staticmethod
def principal_container_name(container_ref):
for name in container_ref['Names']:
if '/' not in name[1:]:
return name[1:]
def container_ip(self, container_ref):
return self._client.inspect_container(
container_ref)['NetworkSettings']['IPAddress']
def stop_container(self, container_ref):
self._client.stop(container_ref)
def kill_container(self, container_ref):
self._client.kill(container_ref)
def remove_container(self, container_ref):
self._client.remove_container(container_ref)
@exception_safe(OSError, False)
def execute(self, container_ref, command):
"""
Execute a command inside the container.
NOTE: Needs the 'docker' binary installed in the host
"""
cmd = [
'docker', 'exec', '-it',
self.principal_container_name(container_ref), 'env', 'TERM=xterm',
command
]
log.debug('Running command: "{}"'.format(' '.join(cmd)))
p = subprocess.Popen(cmd, stderr=subprocess.STDOUT)
p.wait()
def ssh(self, container_ref):
self.execute(container_ref, 'bash')
class Docker_interface:
def __init__(self,
net_name='tosker_net',
tmp_dir='/tmp',
socket='unix://var/run/docker.sock'):
self._log = Logger.get(__name__)
self._net_name = net_name
self._cli = Client(base_url=os.environ.get('DOCKER_HOST') or socket)
self._tmp_dir = tmp_dir
# TODO: aggiungere un parametro per eliminare i container se esistono gia'!
def create(self, con, cmd=None, entrypoint=None, saved_image=False):
def create_container():
tmp_dir = path.join(self._tmp_dir, con.name)
try:
os.makedirs(tmp_dir)
except:
pass
saved_img_name = '{}/{}'.format(self._net_name, con.name)
img_name = con.image
if saved_image and self.inspect(saved_img_name):
img_name = saved_img_name
self._log.debug('container: {}'.format(con.get_str_obj()))
con.id = self._cli.create_container(
name=con.name,
image=img_name,
entrypoint=entrypoint if entrypoint else con.entrypoint,
command=cmd if cmd else con.cmd,
environment=con.env,
detach=True,
# stdin_open=True,
ports=[key for key in con.ports.keys()] if con.ports else None,
volumes=['/tmp/dt'] +
([k for k, v in con.volume.items()] if con.volume else []),
networking_config=self._cli.create_networking_config({
self._net_name:
self._cli.create_endpoint_config(links=con.link
# ,aliases=['db']
)
}),
host_config=self._cli.create_host_config(
port_bindings=con.ports,
# links=con.link,
binds=[tmp_dir + ':/tmp/dt'] +
([v + ':' + k
for k, v in con.volume.items()] if con.volume else []),
)).get('Id')
assert isinstance(con, Container)
if con.to_build:
self._log.debug('start building..')
# utility.print_json(
self._cli.build(path='/'.join(con.dockerfile.split('/')[0:-1]),
dockerfile='./' + con.dockerfile.split('/')[-1],
tag=con.image,
pull=True,
quiet=True)
# )
self._log.debug('stop building..')
elif not saved_image:
# TODO: da evitare se si deve utilizzare un'immagine custom
self._log.debug('start pulling.. {}'.format(con.image))
utility.print_json(self._cli.pull(con.image, stream=True),
self._log.debug)
self._log.debug('end pulling..')
try:
create_container()
except errors.APIError as e:
self._log.debug(e)
# self.stop(con)
self.delete(con)
create_container()
# raise e
def stop(self, container):
name = self._get_name(container)
try:
return self._cli.stop(name)
except errors.NotFound as e:
self._log.error(e)
def start(self, container, wait=False):
name = self._get_name(container)
self._cli.start(name)
if wait:
self._log.debug('wait container..')
self._cli.wait(name)
utility.print_byte(self._cli.logs(name, stream=True),
self._log.debug)
def delete(self, container):
name = self._get_name(container)
try:
self._cli.remove_container(name, v=True)
except (errors.NotFound, errors.APIError) as e:
self._log.error(e)
raise e
def exec_cmd(self, container, cmd):
name = self._get_name(container)
if not self.is_running(name):
return False
try:
exec_id = self._cli.exec_create(name, cmd)
status = self._cli.exec_start(exec_id)
# TODO: verificare attendibilita' di questo check!
check = 'rpc error:' != status[:10].decode("utf-8")
self._log.debug('check: {}'.format(check))
return check
except errors.APIError as e:
self._log.error(e)
return False
except requests.exceptions.ConnectionError as e:
# TODO: questo errore arriva dopo un timeout di 10 secodi
self._log.error(e)
return False
def create_volume(self, volume):
assert isinstance(volume, Volume)
self._log.debug('volume opt: {}'.format(volume.get_all_opt()))
return self._cli.create_volume(volume.name, volume.driver,
volume.get_all_opt())
def delete_volume(self, volume):
name = self._get_name(volume)
return self._cli.remove_volume(name)
def get_containers(self, all=False):
return self._cli.containers(all=all)
def get_volumes(self):
volumes = self._cli.volumes()
return volumes['Volumes'] or []
def inspect(self, item):
name = self._get_name(item)
try:
return self._cli.inspect_container(name)
except errors.NotFound:
pass
try:
return self._cli.inspect_image(name)
except errors.NotFound:
pass
try:
return self._cli.inspect_volume(name)
except errors.NotFound:
return None
def remove_all_containers(self):
for c in self.get_containers(all=True):
self.stop(c['Id'])
self.delete(c['Id'])
def remove_all_volumes(self):
for v in self.get_volumes():
self.delete_volume(v['Name'])
def create_network(self, name, subnet='172.25.0.0/16'):
# docker network create -d bridge --subnet 172.25.0.0/16 isolated_nw
# self.delete_network(name)
try:
self._cli.create_network(name=name,
driver='bridge',
ipam={'subnet': subnet},
check_duplicate=True)
except errors.APIError:
self._log.debug('network already exists!')
def delete_network(self, name):
assert isinstance(name, str)
try:
self._cli.remove_network(name)
except errors.APIError:
self._log.debug('network not exists!')
def delete_image(self, name):
assert isinstance(name, str)
try:
self._cli.remove_image(name)
except errors.NotFound:
pass
# TODO: splittare questo metodo in due, semantica non chiara!
def update_container(self, node, cmd, saved_image=True):
assert isinstance(node, Container)
# self._log.debug('container_conf: {}'.format(node.host_container))
stat = self.inspect(node.image)
old_cmd = stat['Config']['Cmd'] or None
old_entry = stat['Config']['Entrypoint'] or None
if self.inspect(node):
self.stop(node)
self.delete(node)
self.create(node, cmd=cmd, entrypoint='', saved_image=saved_image)
self.start(node.id, wait=True)
self.stop(node.id)
name = '{}/{}'.format(self._net_name, node.name)
self._cli.commit(node.id, name)
self.stop(node)
self.delete(node)
self.create(node,
cmd=node.cmd or old_cmd,
entrypoint=node.entrypoint or old_entry,
saved_image=True)
self._cli.commit(node.id, name)
def is_running(self, container):
name = self._get_name(container)
stat = self.inspect(name)
stat = stat is not None and stat['State']['Running'] is True
self._log.debug('State: {}'.format(stat))
return stat
def _get_name(self, name):
if isinstance(name, six.string_types):
return name
else:
assert isinstance(name, (Container, Volume))
return name.name
class Docker:
def __init__(self):
self.client = Client(base_url='tcp://192.168.0.2:2376')
def listar_containers(self):
containers = self.client.containers(all=True)
return containers
def criar_container(self,
nome='novo',
imagem='ubuntu',
comando='/bin/bash'):
container = self.client.create_container(
image=imagem,
command=comando,
name=nome,
stdin_open=True,
tty=True,
detach=True,
ports=[80],
host_config=self.client.create_host_config(port_bindings={80: 80}))
return container
def iniciar_container(self, id):
self.client.start(container=id)
print 'Container iniciado'
def parar_container(self, id):
self.client.stop(container=id)
print 'Container parado.'
def rem_container(self, id):
self.client.stop(container=id)
self.client.remove_container(container=id)
print 'Container removido.'
def exec_comando(self, id, comando):
exec_id = self.client.exec_create(container=id, cmd=comando)
resultado = self.client.exec_start(exec_id)
return resultado
def inspec_container(self, id):
container = self.client.inspect_container(container=id)
return container
def __init__(self, url):
self._cli = Client(base_url=url, version='auto')
#coding:utf-8
from django.test import TestCase
# Create your tests here.
try:
from docker import Client
except:
from docker import APIClient as Client
from registry_api import BASE_REGISTRY_API
c = Client(base_url='tcp://192.168.62.200:2375', version='1.14', timeout=10)
# c = Client(base_url='unix://var/run/docker.sock',version='1.14',timeout=10)
# print c.images()
# import docker
#sssss
url = 'http://192.168.62.200:5000/' ##私有仓库地址
b = BASE_REGISTRY_API()
print b.get_imageId_info(
ImageId=
"sha256:9087edac75d18fbcaffbf6ed3f0fa34e726bd5e6abefe2d4cd0fdf4a493eb43b",
url=url,
version=2,
tag="latest",
ImageName="shipyard")['data']['history']
# client = docker.from_env()
# print client.containers.run("alpine", ["echo", "hello", "world"])
def __init__(self, base_url, semaphore):
self._semaphore = semaphore
# FIXME we can reuse the client once we know for sure that it is Thread safe...
self._client = Client(base_url, version='1.19')
def attach_to_docker_client():
if os.getenv('DOCKER_HOST') == 'tcp://192.168.59.103:2376':
c = Client(**kwargs_from_env(assert_hostname=False))
else:
c = Client()
return c
def get_client(self, daemon_client):
return Client(**daemon_client)
def docker_monitor(host_ip, container_id, network_card):
try:
lists = []
network_alls = []
memory_alls = []
cpu_alls = []
io_alls = []
times = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))
datetimes = int(time.mktime(time.strptime(times, '%Y-%m-%d %H:%M:%S')))
# datetimes = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
# timeStamp = int(time.mktime(datatimes))
cli = Client(base_url='tcp://%s:5555' % (host_ip), version='1.20')
stats_obj = cli.stats('%s' % (container_id))
for i in stats_obj:
lists.append(i)
break
for i in lists:
i_json = json.loads(i)
for k, v in i_json.items():
# print k
if re.search('network', k):
network = {'network_stats': [v]}
network_alls.append(network)
if re.search('memory_stats', k):
memory = {'memory_stats': [v]}
# print memory
for memory_i in memory.get('memory_stats'):
memory_stats = {
'mem_usage':
str(round(memory_i.get('usage')) / 1000000),
'mem_limit':
str(memory_i.get('limit') / 1000000000 * 1000)
}
# memory_alls.append(memory)
if re.search('cpu_stats', k):
cpu = {'cpu_stats': [v]}
for cpu_i in cpu.get('cpu_stats'):
# print cpu
# for k,v in cpu_i.items():
# print v
# if re.search('throttling_data',cpu_i.get('cpu_usage').get('throttling_data')):
# print cpu_i
# print cpu_i.get('cpu_usage').get('total_usage')
# print cpu_i.get('cpu_usage').get('percpu_usage')
if int(cpu_i.get('cpu_usage').get(
'total_usage')) != 0 and cpu_i.get(
'cpu_usage').get('total_usage') != None:
#stats = cpu_i.get('cpu_usage').get('total_usage') / cpu_i.get('cpu_usage').get('percpu_usage')[0]
cpu_stats = str(
float(
cpu_i.get('cpu_usage').get('total_usage') /
cpu_i.get('cpu_usage').get(
'percpu_usage')[0]) / 100) + '%'
# print stats
# print cpu_i.get('cpu_usage').get('total_usage')
# print cpu_i.get('cpu_usage').get('percpu_usage')[0]
# print stats
else:
pass
# cpu_alls.append(cpu)
if re.search('blkio_stats', k):
io = {'io_stats': [v]}
io_alls.append(io)
linux = 'python /home/zeusadmin/monitor/monitor_flow.py %s' % network_card
cli = docker.Client(base_url='tcp://%s:5555' % (host_ip),
version='1.20',
timeout=10)
ex = cli.exec_create(container=container_id, cmd=linux, user='******')
ls = cli.exec_start(exec_id=ex["Id"], tty=True).strip('\r\n')
if len(ls) == 0:
flow = u"监控无数据"
else:
flow = eval(ls)
# print ls
# print memory_stats
# print cpu_stats
# print io_alls
# print flow
all_stats = {
'code':
200,
'monitor_time':
datetimes,
'message': [{
'memory_stats': memory_stats
}, {
'flow_stats': flow
}, {
'cpu_stats': {
'cpu_usage': cpu_stats
}
}]
}
return (json.dumps(all_stats, sort_keys=True, indent=4))
# print stats
# status = {'code':200,'message': [network_alls,memory_alls,cpu_alls,io_alls]}
# return (json.dumps(status,sort_keys=True,indent=4))
except docker.errors.NotFound, e:
return e
from docker import Client
from json import JSONEncoder
from platform import node
# Generates image inventory data in the same format as the provider (used in unit tests to validate OMI provider)
NUMBYTESPERMB = 1048576
c = Client(base_url="unix://var/run/docker.sock")
imageDict = c.images()
tempDict = dict()
for image in imageDict:
result = dict()
result["InstanceID"] = image["Id"]
name = image["RepoTags"][-1].replace("/", ":").split(":")
result["Image"] = name[-2]
result["ImageTag"] = name[-1]
result["Repository"] = name[0] if len(name) == 3 else ""
result["Computer"] = node()
result["Running"] = 0
result["Stopped"] = 0
result["Failed"] = 0
result["Paused"] = 0
result["Total"] = 0
result["ImageSize"] = str(image["Size"] / NUMBYTESPERMB) + " MB"
result["VirtualSize"] = str(image["VirtualSize"] / NUMBYTESPERMB) + " MB"
tempDict[image["Id"]] = result
from docker import Client
import json, os, time
# work against docker socket
cli = Client(base_url='unix://var/run/docker.sock', version="auto")
# list containers based on said image, if no app_name provided gets all
def list_containers(app_name=""):
if app_name == "":
try:
return cli.containers(filters="")
except:
print "failed getting list of all containers"
os._exit(2)
else:
try:
app_label = "app_name=" + app_name
return cli.containers(filters={"label": app_label}, all=True)
except:
print "failed getting list of containers where label is app_name=" + app_name
os._exit(2)
# pull image with optional version tag and registry auth
def pull_image(image_name,
version_tag="latest",
registry_user="",
registry_pass="",
registry_host=""):
print "logging in to registry"
_id, _id), # TODO: Detect format
])
}
container = self.client.create_container(**container)
work = Work(_id, container, self, fuente)
work.run()
return work
@property
def name(self):
return repo_origin(self.repo.name, self.schema["RepoTags"])
if __name__ == "__main__":
from docker import Client
c = Client("unix:///var/run/docker.sock")
esquema = {
'Created': 1441279808,
'Labels': {},
'VirtualSize': 795865269,
'ParentId':
'9cce8d0ab3ceadd880b97330a259d362e51e303089fc096db5094f2642585bee',
'RepoTags': ['iso8601:latest', 'src/iso8601:latest'],
'RepoDigests': [],
'Id':
'15ef989c576bdc0ae8ed721f9c58a850ee050620ed8e9d816dacaffdb050e497',
'Size': 0
}
from utils import make_id
class SwarmClient(object):
def __init__(self, target, auth, options, pkey):
self.target = settings.SWARM_HOST
# single global connection
self.registry = settings.REGISTRY_HOST + ':' + settings.REGISTRY_PORT
self.docker_cli = Client("tcp://{}:2395".format(self.target),
timeout=1200, version='1.17')
def create(self, name, image, command='', template=None, **kwargs):
"""Create a container"""
cimage = self.registry + '/' + image
affinity = "affinity:container!=~/{}*/".format(re.split(r'_v\d.', name)[0])
l = locals().copy()
l.update(re.match(MATCH, name).groupdict())
mem = kwargs.get('memory', {}).get(l['c_type'])
if mem:
mem = mem.lower()
if mem[-2:-1].isalpha() and mem[-1].isalpha():
mem = mem[:-1]
cpu = kwargs.get('cpu', {}).get(l['c_type'])
self.docker_cli.create_container(image=cimage, name=name,
command=command.encode('utf-8'), mem_limit=mem,
cpu_shares=cpu,
environment=[affinity],
host_config={'PublishAllPorts': True})
def start(self, name):
"""
Start a container
"""
self.docker_cli.start(name)
def stop(self, name):
"""
Stop a container
"""
self.docker_cli.stop(name)
def destroy(self, name):
"""
Destroy a container
"""
self.stop(name)
self.docker_cli.remove_container(name)
def run(self, name, image, entrypoint, command):
"""
Run a one-off command
"""
cimage = self.registry + '/' + image
# use affinity for nodes that already have the image
affinity = "affinity:image==~{}".format(cimage)
self.docker_cli.create_container(image=cimage, name=name,
command=command.encode('utf-8'),
environment=[affinity],
entrypoint=[entrypoint])
time.sleep(2)
self.start(name)
rc = 0
while (True):
if self._get_container_state(name) == JobState.created:
break
time.sleep(1)
try:
output = self.docker_cli.logs(name)
return rc, output
except:
rc = 1
return rc, output
def _get_container_state(self, name):
try:
if self.docker_cli.inspect_container(name)['State']['Running']:
return JobState.up
else:
return JobState.created
except:
return JobState.destroyed
def state(self, name):
try:
for _ in range(30):
return self._get_container_state(name)
time.sleep(1)
# FIXME (smothiki): should be able to send JobState.crashed
except KeyError:
return JobState.error
except RuntimeError:
return JobState.destroyed
def attach(self, name):
"""
Attach to a job's stdin, stdout and stderr
"""
raise NotImplementedError
def _get_hostname(self, application_name):
hostname = settings.UNIT_HOSTNAME
if hostname == 'default':
return ''
elif hostname == 'application':
# replace underscore with dots, since underscore is not valid in DNS hostnames
dns_name = application_name.replace('_', '.')
return dns_name
elif hostname == 'server':
raise NotImplementedError
else:
raise RuntimeError('Unsupported hostname: ' + hostname)
def _get_portbindings(self, image):
dictports = self.docker_cli.inspect_image(image)['ContainerConfig']['ExposedPorts']
for port, mapping in dictports.items():
dictports[port] = None
return dictports
def _get_ports(self, image):
dictports = self.docker_cli.inspect_image(image)['ContainerConfig']['ExposedPorts']
return [int(port.split('/')[0]) for port in dictports.iterkeys()]
def __init__(self, target, auth, options, pkey):
self.target = settings.SWARM_HOST
# single global connection
self.registry = settings.REGISTRY_HOST + ':' + settings.REGISTRY_PORT
self.docker_cli = Client("tcp://{}:2395".format(self.target),
timeout=1200, version='1.17')
def __init__(self):
try:
self.client = Client(base_url="tcp://192.168.0.2:2376",
version="auto")
except Exception as e:
print "Falhou ao conectar no Docker %s", e
#
# Copyright (C) 2016 Nippon Telegraph and Telephone Corporation.
#
# Licensed 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.
try:
from docker import Client
except ImportError:
from docker import APIClient as Client
dckr = Client(version='auto')
#coding=utf-8
from flask import render_template, redirect, request, url_for, flash
from . import ws
import time, json
from docker import Client
client = Client(base_url='unix://run/docker.sock')
@ws.route('/echo')
def echo_socket(socket):
while not socket.closed:
message = socket.receive()
if message != '':
for i in range(10):
socket.send(message + ':' + str(i))
time.sleep(1)
@ws.route('/pull')
def pull_images(socket):
while not socket.closed:
try:
image = socket.receive()
if image == '' or image == None:
socket.send('Please tell me which image you want to pull.')
else:
im = image.split(':')
if im[1] == '':
image += 'latest'
def get_docker_client():
if os.environ.get('DOCKER_HOST'):
kwargs = kwargs_from_env()
return Client(**kwargs)
return Client(base_url=get_docker_base_url())
def __init__(self, base_master_name, base_slave_name, base_tag,
tag_decoration):
super(TagBareImageProvider, self).__init__(tag_decoration)
self.base_master_name = base_master_name + ":" + base_tag
self.base_slave_name = base_slave_name + ":" + base_tag
self.client = Client()
def pg_server(unused_port_factory, docker: DockerClient, request):
pg_name = request.config.getoption('--pg-name')
pg_image = request.config.getoption('--pg-image')
pg_reuse = request.config.getoption('--pg-reuse')
container = None
port = None
if not pg_name:
pg_name = 'db-{}'.format(str(uuid.uuid4()))
if pg_name:
for item in docker.containers(all=True):
for name in item['Names']:
if pg_name in name:
container = item
break
if not container:
port = unused_port_factory()
docker.pull(pg_image)
container = docker.create_container(
image=pg_image,
name=pg_name,
ports=[5432],
host_config=docker.create_host_config(port_bindings={5432: port}),
detach=True)
docker.start(container=container['Id'])
inspection = docker.inspect_container(container['Id'])
host = inspection['NetworkSettings']['IPAddress']
if not port:
ports = inspection['NetworkSettings']['Ports']
if '5432/tcp' in ports:
port = ports['5432/tcp'][0]['HostPort']
pg_params = {
'database': 'postgres',
'user': '******',
'password': '******',
'host': 'localhost',
'port': port
}
delay = 0.001
for i in range(100):
try:
with psycopg2.connect(**pg_params) as conn:
with conn.cursor() as cursor:
cursor.execute('SELECT version();')
break
except psycopg2.Error:
time.sleep(delay)
delay *= 2
else:
pytest.fail('Cannot start postgres server')
container['host'] = host
container['port'] = port
container['pg_params'] = pg_params
yield container
if not pg_reuse:
docker.kill(container=container['Id'])
docker.remove_container(container['Id'])
class Haproxyctl:
def __init__(self):
self.__haproxyctl_config_file = '/root/.haproxyctl.cfg'
self.__haproxy_template_file = 'haproxy.jinja'
self.__haproxy_config_file = 'haproxy.cfg'
self.__haproxy_config_path = '/usr/local/etc/haproxy/'
self.__haproxy_container_id = None
self.__docker_client = Client(base_url='unix://var/run/docker.sock')
def get_haproxy_container(self):
containers = self.__docker_client.containers()
for container in containers:
for name in container['Names']:
if 'haproxy' in name.lower():
self.__haproxy_container_id = container['Id']
return self.__haproxy_container_id
return None
def get_container_ip(self, container_name):
try:
container = self.__docker_client.inspect_container(container_name)
return container['NetworkSettings']['IPAddress']
except errors.NotFound:
return None
def read_config_file(self):
with open(self.__haproxyctl_config_file, 'w+') as f_handle:
try:
json_data = json.load(f_handle)
return json_data
except ValueError:
return []
return []
def write_config_file(self, existing_config):
with open(self.__haproxyctl_config_file, 'w') as f_handle:
json.dump(existing_config,
f_handle,
sort_keys=True,
indent=4,
ensure_ascii=False)
def add_url(self, url, container_name, port, existing_config):
if port is None:
port = 80
for item in existing_config:
if type(item) is dict:
if 'url' in item:
if item['url'] == url:
item['container_name'] = container_name
item['port'] = port
return existing_config
existing_config.append({
'url': url,
'container_name': container_name,
'port': port
})
return existing_config
def remove_url(self, url, existing_config):
for item in existing_config:
if type(item) is dict:
if 'url' in item:
if item['url'] == url:
existing_config.remove(item)
return existing_config
def generate_haproxy_config(self, new_config):
env = Environment(loader=FileSystemLoader(
pkg_resources.resource_filename('haproxyctl', 'templates')),
trim_blocks=True)
template = env.get_template(self.__haproxy_template_file)
f = open(self.__haproxy_config_file, 'w')
items = []
counter = 1
for item in new_config:
ip = self.get_container_ip(item['container_name'])
if ip:
items.append({
'id': counter,
'url': item['url'],
'port': item['port'],
'ip': ip
})
counter += 1
print " => [ OK ] Url: '%s', Container: '%s', IP:%s, Port:%s" % (
item['url'], item['container_name'], ip, item['port'])
else:
print " => [SKIP] Url: '%s', Container: '%s'(not found), IP:N/A, Port:%s" % (
item['url'], item['container_name'], item['port'])
f.write(template.render(items=items))
f.close()
def update_haproxy_config(self):
si = StringIO()
tar = tarfile.open(mode='w', fileobj=si)
tar.add(self.__haproxy_config_file)
tar.close()
tar_content = si.getvalue()
self.__docker_client.put_archive(self.__haproxy_container_id,
self.__haproxy_config_path,
tar_content)
def test_haproxy_config(self):
cmd = "haproxy -c -f %s%s 2>&1" % (self.__haproxy_config_path,
self.__haproxy_config_file)
res = self.__docker_client.exec_create(
container=self.__haproxy_container_id, cmd=['bash', '-c', cmd])
output = self.__docker_client.exec_start(res)
output = output.strip()
if output == "Configuration file is valid":
print " => Haproxy config is OK"
return True
else:
print " => Haproxy config contains error!"
return False
def restart_haproxy_container(self):
print " => Restarting haproxy..."
self.__docker_client.restart(container=self.__haproxy_container_id,
timeout=0)
print " => Restarted."
from jinja2 import Environment, FileSystemLoader
from docker import Client
import os, shutil, tarfile, io
import xml.etree.ElementTree as ET
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-u",
"--update",
action='store_true',
help="force recreate the keys")
args = parser.parse_args()
client = Client()
HOSTS = {"rpi3": "hypriot", "win-dev": "alpine", "mac-dev": "alpine"}
# build/run the syncthing_cli image to get the configuration
key_pathname = os.path.join(os.getcwd(), "keys")
if args.update:
key_container = client.create_container(
"johncclayton/syncthing-cli",
"/generate-identities.sh",
environment={"KEY_HOSTS": " ".join(HOSTS.keys())})
print("Generating keys...")
key_response = client.start(container=key_container.get('Id'))
client.wait(container=key_container.get('Id'))
# now copy the files from within the container to the local disk
if os.path.exists(key_pathname):
def get_docker_port(container):
ports = docker.execute(["netstat", "-tulpn"])[0].split("\n")
for line in ports:
if "docker" in line:
port = line.split()[3].split(":::")[1]
return port
#Get the port the docker host is listening on
port = get_docker_port(docker)
######## Connect to the docker host ########
#Connect to the remote docker host in the LXC container
dockerclient = Dclient(base_url="tcp://{}:{}".format(host,port), version="auto")
print "Connected to Docker host on {}:{}".format(host,port)
######## Create an docker image ########
print "\nCreating image from Dockerfile\n"
#Create a docker container image from the Dockerfile in this directory
response = dockerclient.build(path=".", dockerfile="Dockerfile", tag="pyne/helloworld")
#Show the output from the build process
for line in response:
print line
#Show the images now avalible on the docker host
from docker import Client
cli = Client(base_url="tcp://192.168.205.125:2376",version="auto")
class Docker:
def __init__(self):
self.cli = Client(base_url="tcp://192.168.205.125:2376", version="auto")
def get_containers(self, all=True):
return [ c for c in self.cli.containers(all=all)]
def create_container(self, name, command, image):
return self.cli.create_container(
name=name,
command=command,
image=image
)
def start_container(self, name):
return self.cli.start(name)
def stop_container(self, name):
return self.cli.stop(name)
def remove_container(self, name):
return self.cli.remove_container(name)
def __init__(self):
self.client = Client(base_url='tcp://192.168.0.2:2376')
def setUpClass(cls):
cls.client = Client(docker_url())
