##################
splunk_docker_utils.do_setup()
# We need to loop running containers, getting stats
hosts = open (splunk_docker_utils.RUN_DIR + '/docker_hosts.dat','r')
for host in hosts:
host=host.rstrip()
conn_string="tcp://" + host +":2375"
#cli = Client(base_url='tcp://192.168.160.166:2375', version='auto')
try:
cli = Client(base_url=conn_string, version='auto')
containers=cli.containers()
count=0
for container in containers:
#print "container is "+str(container)
name_attr=re.search( r'\[u\'\/(\w+)\'\]',str(containers[count]['Names']))
container_name=name_attr.group(1)
count +=1
inspect=cli.inspect_container(container_name)
# We need hostname, unfortunately we have to inspect container for it
hostname=inspect['Config']['Hostname']
stats=cli.stats(container_name,decode=None, stream=False)
# Network
#networks": {
def __init__(self,args=None):
## Init Thread
threading.Thread.__init__(self)
self.wait=threading.Event()
## Init Logs
self._logger = logging.getLogger("MAIN")
FORMAT = '%(asctime)s %(levelname)s %(threadName)s %(name)s %(message)s'
LOGFILE='logs/docker-zabbix-sender.log'
logFormatter = logging.Formatter(FORMAT)
console = logging.StreamHandler(sys.stdout)
console.setFormatter(logFormatter)
fileHandler = logging.handlers.TimedRotatingFileHandler(LOGFILE, when='D', interval=1, backupCount=7)
fileHandler.setFormatter(logFormatter)
self._logger.addHandler(fileHandler)
self._logger.setLevel(logging.INFO)
self._logger.addHandler(console)
## Parse the command line
parser = argparse.ArgumentParser(
description="""Provides Zabbix Docker containers statistics running on a Docker daemon."""
)
parser.add_argument('-V', '--version',
action='version',
version='%(prog)s ' + version
)
parser.add_argument('-v', '--verbose',
action='count',
help='Verbose mode, -vv for more details'
)
parser.add_argument("--tlsverify",
action='store',
choices=["true", "false"],
default='true',
help="Use TLS and verify the remote Docker daemon. Default is %(default)s"
)
parser.add_argument('-c', '--config',
metavar="<file>",
help="Absolute path to the zabbix agent configuration file"
)
parser.add_argument('-z', '--zabbix-server',
metavar='<server>',
help='Hostname or IP address of Zabbix server'
)
parser.add_argument('-p', '--port',
metavar='<server port>',
help='Specify port number of server trapper running on the server. Default is 10051'
)
parser.add_argument('-i', '--interval',
metavar='<sec>',
default=1800,
type=int,
help='Specify Zabbix update interval (in sec). Default is %(default)s'
)
parser.add_argument('-r', '--real-time',
action='store_true',
help="zabbix_sender push metrics to Zabbix one by one as soon as they are sent."
)
parser.add_argument('-s', '--host',
metavar='<hostname>',
help='Specify host name. Host IP address and DNS name will not work'
)
self.args = parser.parse_args(args)
kwargs = kwargs_from_env()
if not self.args.tlsverify.lower() in ("yes", "true", "t", "1"):
kwargs['tls'].assert_hostname = False
kwargs['version'] = '1.17'
if self.args.zabbix_server is None:
self.args.zabbix_server = os.environ['ZABBIX_SERVER']
if self.args.host is None:
self.args.host = os.environ['ZABBIX_HOST']
if "INTERVAL" in os.environ :
self.args.interval = os.environ['INTERVAL']
## Hostame in environment varaiable
if "HOSTNAME" in os.environ :
self.hostname=os.environ['HOSTNAME']
## The configuration file
self.configFilename = "Default.ini"
## Open the Config File
self.json = self.openConfigFile(self.configFilename)
if self.json.cp == None :
self._logger.info("PARSE ERROR : Please Check the Configuration File %s", self.configFilename )
## Init de l'API docker && Param to stop the thread && the zabbix_sender subProcess && Thread Array
self.docker_client = Client(**kwargs)
self.running = True
self.zabbixPipe = TrapSender(
config_file = self.args.config,
zabbix_server = self.args.zabbix_server,
host = self.args.host,
port = self.args.port,
real_time = self.args.real_time,
verbose = self.args.verbose if self.args.verbose is not None else 0
);
self.emitter={}
from docker import Client
#cli = Client(base_url="tcp://192.168.0.2:2376")
cli = Client(base_url='tcp://192.168.0.2:2376', version='auto')
class DockerManager:
def __init__(self):
try:
self.cli = Client(base_url='tcp://192.168.0.2:2376',
version='auto')
except Exception as e:
raise Exception(e)
def getContainers(self, todos=True):
try:
return [c for c in self.cli.containers(all=todos)]
except Exception as e:
raise Exception(e)
def createContainer(self, nome, hn):
try:
container = self.cli.create_container(name=nome,
hostname=hn,
image="debian",
detach=True,
stdin_open=True,
tty=True)
self.cli.start(container=container.get('Id'))
return container
# -*- coding: utf-8 -*-
from docker import Client
from docker import errors
import base64
import binascii
def sss(ddd):
ddd = [9,9,9,9]
cli = Client(version='auto', base_url='tcp://127.0.0.1:2375')
result = cli.containers()
print '\n\n'
print result
zzz = 'sh /home/run.sh /home/libg/Jx3Robot/Jx3Robot Li9KeDNSb2JvdEQgLVQgU3VwZXJSb2JvdDo1MCAtYSBsYWl0dWFuIC1yIMC0zcWwySAtbCAtZSAtayDL5rv6IC1qIMvmu/ogLWcgy+a7+iAtcyAxMC4yMC45Ni4xNTUgLXAgMTAw'
ppp = zzz.split(' ')
print ppp
print ppp[2]
print ppp[3]
#procmd.decode('utf8').encode('gb2312')
rrr = base64.b64decode(ppp[3])
# except NameError,error_msg:
# pass
# finally:
# old_result = eval(generator.next())
# new_result = eval(generator.next())
# c.close()
# cpu_total_usage=new_result['cpu_stats']['cpu_usage']['total_usage'] - old_result['cpu_stats']['cpu_usage']['total_usage']
# cpu_system_uasge=new_result['cpu_stats']['system_cpu_usage'] - old_result['cpu_stats']['system_cpu_usage']
# cpu_num=len(old_result['cpu_stats']['cpu_usage']['percpu_usage'])
# cpu_percent=round((float(cpu_total_usage)/float(cpu_system_uasge))*cpu_num*100.0,2)
# print cpu_percent
# else:
# print 0
if __name__ == '__main__':
c = Client(base_url='unix://var/run/docker.sock', version='1.22')
if len(sys.argv) < 3:
#print "error! please %s [container_name] [up|cpu_per_usage|memory_usage|rx_bytes|tx_bytes]" %sys.argv[0]
print "error! please %s [container_name] [up|cpu_per_usage|usage_mem|limit_max_mem|rx_bytes|tx_bytes]" % sys.argv[
0]
elif sys.argv[2] == "up":
container_status(sys.argv[1])
elif sys.argv[2] == "cpu_per_usage":
display_cpu(sys.argv[1])
elif sys.argv[2] == "limit_max_mem":
display_memory(sys.argv[1], "limit_max_mem")
elif sys.argv[2] == "usage_mem":
#!usr/bin/python
# -*- coding: utf-8 -*-
from docker import Client
cli = Client(base_url="http://192.168.0.2:2376", version="auto")
class DockerModulo:
def __init__(self):
try:
self.cli = Client(base_url="http://192.168.0.2:2376",
version="auto")
except Exception as e:
raise Exception(e)
def getContainers(self, todos=True):
try:
return [c for c in self.cli.containers(all=todos)]
except Exception as e:
raise Exception(e)
def startContainer(self, id):
return self.cli.start(container=id)
def stopContainer(self, id):
return self.cli.stop(container=id)
def removeContainer(self, id):
self.cli.stop(container=id)
return self.cli.remove_container(id)
from services import Services
from docker import Client
from flask import Flask
services = Services(Client(base_url='unix://var/run/docker.sock'),
"config.yml")
app = Flask(__name__, static_url_path='')
import overview.frontend
import overview.api
import overview.helpers
def get_client(self, daemon_client):
return Client(**daemon_client)
#!/usr/bin/env python
import requests
import time
from docker import Client
from docker import utils as dockerutils
c = Client(base_url="unix://var/run/docker.sock")
while True:
res = requests.get('http://192.168.33.10/nginx_status')
active_conn = int(res.text.split('\n')[0].split()[2])
num_backend = len(
filter(lambda c: c['Image'] == 'runseb/hostname', c.containers()))
print num_backend, active_conn
conn_threshold = 10
if (num_backend <= active_conn / conn_threshold):
new_backend = c.create_container(image='runseb/hostname', detach=True, ports=[5000], \
host_config=dockerutils.utils.create_host_config(port_bindings={5000: None }))
res = c.start(container=new_backend.get('Id'))
elif (num_backend > 1 and num_backend > active_conn / conn_threshold):
backends = filter(lambda c: c['Image'] == 'runseb/hostname',
c.containers())
c.kill(container=backends[0]['Id'])
c.remove_container(container=backends[0]['Id'])
time.sleep(6)
def cleanup():
client = Client(version='auto', **kwargs_from_env())
test_images = client.images(TEST_ORG + "/*")
for image in test_images:
client.remove_image(image)
def __init__(self, containerObject):
self.containerObject = containerObject
self.dockerCli = Client(base_url='unix://var/run/docker.sock')
def template_queue(path, base_dir="/var/lib/docker/data/"):
"""
Processes template files that have been added or changed or deleted from
the rq-worker. Then, removes exited containers, kills and removes disabled containers,
and starts/restarts enabled containers. Only restarts enabled containers which were
running at the time of the configuration change.
"""
import ast
import os
import sys
import time
import ConfigParser
config = ConfigParser.RawConfigParser()
# needed to preserve case sensitive options
config.optionxform = str
from docker import Client
from docker.utils.types import LogConfig
from subprocess import check_output
c = Client(base_url='unix://var/run/docker.sock')
try:
# keep track of running containers to restart
running_containers = c.containers()
# first some cleanup
containers = c.containers(quiet=True,
all=True,
filters={'status': "exited"})
for cont in containers:
try:
# will only remove containers that aren't running
c.remove_container(cont['Id'])
except Exception as e:
pass
try:
data_dir = "/scripts/"
if base_dir != "/var/lib/docker/data/":
data_dir = base_dir
enabled, disabled = ast.literal_eval(
check_output("python2.7 " + data_dir +
"info_tools/get_status.py enabled -b " + base_dir,
shell=True))
except Exception as e:
pass
# remove disabled running containers
for container in containers:
for name in container["Names"]:
if name in disabled:
try:
c.kill(container["Id"])
c.remove_container(container["Id"])
continue
except Exception as e:
pass
core_containers = c.containers(all=True, filters={'name': "core-"})
# remove core containers, so when restarted, behavior matches current configuration
for container in core_containers:
try:
if container["Status"] == "exited":
c.remove_container(container["Id"])
elif container["Id"].startswith(os.environ.get('HOSTNAME')):
# skip this container until the end
this_container = container["Id"]
else:
c.kill(container["Id"])
c.remove_container(container["Id"])
except Exception as e:
pass
# restart this container last
try:
c.kill(this_container)
c.remove_container(this_container)
except Exception as e:
pass
# start enabled containers
data_dir = "/vent/"
if base_dir != "/var/lib/docker/data/":
data_dir = base_dir
os.system('python2.7 ' + data_dir + 'template_parser.py core start')
active_started = False
passive_started = False
vis_started = False
for container in running_containers:
# usually containers have one name, but container["Names"] is a list, so we have to be sure
for name in container["Names"]:
if active_started and passive_started and vis_started:
break
elif "active-" in name and not active_started:
os.system('python2.7 ' + base_dir +
'template_parser.py active start')
active_started = True
elif "passive-" in name and not passive_started:
os.system('python2.7 ' + base_dir +
'template_parser.py passive start')
passive_started = True
elif "visualization-" in name and not vis_started:
os.system('python2.7 ' + base_dir +
'template_parser.py visualization start')
vis_started = True
else:
pass
except Exception as e:
pass
return
def file_queue(path, base_dir="/var/lib/docker/data/"):
"""
Processes files that have been added from the rq-worker, and tells
vent-management to start plugins that match the mime type for the new file.
"""
import ConfigParser
import magic
import os
import time
from docker import Client
from docker.utils.types import LogConfig
c = Client(base_url='unix://var/run/docker.sock')
# first some cleanup
containers = c.containers(quiet=True,
all=True,
filters={'status': "exited"})
for cont in containers:
try:
# will only remove containers that aren't running
c.remove_container(cont['Id'])
except Exception as e:
pass
template_dir = base_dir + "templates/"
plugins_dir = base_dir + "plugins/"
vent_dir = "/vent/"
if base_dir != "/var/lib/docker/data/":
vent_dir = base_dir
try:
config = ConfigParser.RawConfigParser()
# needed to preserve case sensitive options
config.optionxform = str
# Check file exists
if os.path.isfile(template_dir + 'modes.template'):
config.read(template_dir + 'modes.template')
plugin_array = []
# Check section exists and has options
if config.has_section("plugins") and config.options("plugins"):
plugin_array = config.options("plugins")
plugins = {}
for plug in plugin_array:
if plug not in ["core", "visualization", "collectors"]:
plugins[plug] = config.get("plugins", plug)
container_count = 0
container_max = 50
try:
config = ConfigParser.RawConfigParser()
# needed to preserve case sensitive options
config.optionxform = str
if os.path.isfile(template_dir + 'core.template'):
config.read(template_dir + 'core.template')
if config.has_section("active-containers") and config.has_option(
"active-containers", "count"):
container_max = int(config.get("active-containers", "count"))
except Exception as e:
print(str(e))
file_mime = None
try:
f_path = path.split("_", 1)[1]
file_mime = magic.from_file(f_path, mime=True)
except Exception as e:
print(str(e))
for plugin in plugins:
# check mime types
mime_types = []
try:
config = ConfigParser.RawConfigParser()
# needed to preserve case sensitive options
config.optionxform = str
if os.path.isfile(template_dir + plugin + '.template'):
config.read(template_dir + plugin + '.template')
if config.has_section("service") and config.has_option(
"service", "mime_types"):
mime_types = config.get("service", "mime_types").split(",")
except Exception as e:
print(str(e))
# check file extensions
ext_types = []
try:
config = ConfigParser.RawConfigParser()
# needed to preserve case sensitive options
config.optionxform = str
if os.path.isfile(template_dir + plugin + '.template'):
config.read(template_dir + plugin + '.template')
if config.has_section("service") and config.has_option(
"service", "ext_types"):
ext_types = config.get("service", "ext_types").split(",")
except Exception as e:
print(str(e))
if len(mime_types) == 0 or file_mime in mime_types or path.split(
".", -1)[-1] in ext_types:
# check resources before creating container
# wait until there are resources available
container_count = len(
c.containers(filters={'status': 'running'}))
while container_count >= container_max:
time.sleep(5)
container_count = len(
c.containers(filters={'status': 'running'}))
cmd = "python2.7 " + vent_dir + "template_parser.py " + plugin + " start " + path
os.system(cmd)
except Exception as e:
print(str(e))
return
def __init__(self):
self.client = Client(**kwargs_from_env(assert_hostname=False))
try:
self.client.info()
except Exception as e:
self.client = None
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 client(self):
return Client(**self.settings)
#!/usr/bin/python
from ansible.module_utils.basic import *
import docker
try:
import docker
from docker import Client
except ImportError:
from docker import APIClient as Client
if __name__ == '__main__':
module = AnsibleModule(argument_spec=dict(
id=dict(required=True),
type=dict(default='container', choises=['container', 'image'])),
supports_check_mode=True)
id = module.params['id']
type = module.params['type']
client = Client()
try:
if type == 'image':
attrs = client.inspect_image(id)
elif type == 'container':
attrs = client.inspect_container(id)
except docker.errors.APIError as e:
module.fail_json(attrs={}, msg=str(e))
else:
module.exit_json(failed=False, changed=False, attrs=attrs)
def _get_client(timeout=None):
client = Client(base_url='unix://var/run/docker.sock', version='1.19')
return client
def __init__(self):
try:
self.cli = Client(base_url="http://192.168.0.2:2376",
version="auto")
except Exception as e:
raise Exception(e)
def get_pid(ptf_name):
cli = Client(base_url='unix://var/run/docker.sock')
result = cli.inspect_container(ptf_name)
return result['State']['Pid']
def create_connection(self, url):
return Client(base_url=url)
def main():
global docker_api
docker_api = Client(base_url='unix://var/run/docker.sock', version='auto')
ui = Ui()
gevent.spawn(event_watcher, ui.update)
ui.run()
stdout=subprocess.PIPE)).stdout.readlines()[0]).strip('\n'))
time.sleep(1)
network_new_result = eval(((subprocess.Popen(
network_check_command, shell=True,
stdout=subprocess.PIPE)).stdout.readlines()[0]).strip('\n'))
result = int(network_new_result['rx']) - int(network_old_result['rx'])
elif collect_item == 'network_tx_bytes':
network_check_command = """docker exec %s awk '/eth0/ {print "{\\"rx\\":"$2",\\"tx\\":"$10"}"}' /proc/net/dev""" \
% container_name
network_old_result = eval(((subprocess.Popen(
network_check_command, shell=True,
stdout=subprocess.PIPE)).stdout.readlines()[0]).strip('\n'))
time.sleep(1)
network_new_result = eval(((subprocess.Popen(
network_check_command, shell=True,
stdout=subprocess.PIPE)).stdout.readlines()[0]).strip('\n'))
result = int(network_new_result['tx']) - int(network_old_result['tx'])
return result
if __name__ == "__main__":
client = Client(base_url='unix:///var/run/docker.sock')
container = None
item = None
if sys.argv[1] is not None and sys.argv[2] is not None:
container = sys.argv[1]
item = sys.argv[2]
else:
exit(1)
print check_container_stats(container, item)
def execute(self, context):
self.log.info('Starting docker container from image %s', self.image)
tls_config = None
if self.tls_ca_cert and self.tls_client_cert and self.tls_client_key:
tls_config = tls.TLSConfig(ca_cert=self.tls_ca_cert,
client_cert=(self.tls_client_cert,
self.tls_client_key),
verify=True,
ssl_version=self.tls_ssl_version,
assert_hostname=self.tls_hostname)
self.docker_url = self.docker_url.replace('tcp://', 'https://')
self.cli = Client(base_url=self.docker_url,
version=self.api_version,
tls=tls_config)
if ':' not in self.image:
image = self.image + ':latest'
else:
image = self.image
if self.force_pull or len(self.cli.images(name=image)) == 0:
self.log.info('Pulling docker image %s', image)
for l in self.cli.pull(image, stream=True):
output = json.loads(l.decode('utf-8'))
self.log.info("%s", output['status'])
cpu_shares = int(round(self.cpus * 1024))
with TemporaryDirectory(prefix='airflowtmp') as host_tmp_dir:
self.environment['AIRFLOW_TMP_DIR'] = self.tmp_dir
self.volumes.append('{0}:{1}'.format(host_tmp_dir, self.tmp_dir))
self.container = self.cli.create_container(
command=self.get_command(),
cpu_shares=cpu_shares,
environment=self.environment,
host_config=self.cli.create_host_config(
binds=self.volumes, network_mode=self.network_mode),
image=image,
mem_limit=self.mem_limit,
user=self.user,
working_dir=self.working_dir)
self.cli.start(self.container['Id'])
line = ''
for line in self.cli.logs(container=self.container['Id'],
stream=True):
line = line.strip()
if hasattr(line, 'decode'):
line = line.decode('utf-8')
self.log.info(line)
exit_code = self.cli.wait(self.container['Id'])
if exit_code != 0:
raise AirflowException('docker container failed')
if self.xcom_push_flag:
return self.cli.logs(container=self.container['Id']
) if self.xcom_all else str(line)
def __init__(self):
self.cli = Client(base_url="tcp://10.100.0.116:2376", version="auto")
def __init__(self):
self.client = Client(base_url="tcp://192.168.0.2:2376")
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')
#!/usr/local/miniconda/bin/python3
__author__ = 'matthieu'
import argparse
from io import StringIO
from docker import Client
dcl = Client()
parser = argparse.ArgumentParser(description='PGXL startpack')
parser.add_argument('--ip',
dest="ip",
action="store_true",
help="print container IP")
parser.add_argument('--ncontainers',
dest="ncontainers",
action="store",
type=int,
default=4,
help="N containers")
parser.add_argument('--conf',
dest='conf',
action="store",
type=str,
help="generate configuration file")
parser.add_argument('--static',
dest='static',
action="store",
type=str,
default=None,
help="generate configuration file")
def __init__(self):
try:
self.cli = Client(base_url='tcp://192.168.0.2:2376',
version='auto')
except Exception as e:
raise Exception(e)
def docker_is_available(context):
base_docker_url = get_docker_host()
docker_client = Client(base_url=base_docker_url)
assert docker_client.ping()
context.docker_client = docker_client