def upload(self, params):
path = params.get('path')
osname = params.pop('filename')
name = params.get('name')
dvd = '/'.join([path, osname])
log_info("check iso {0}".format(dvd))
self._check_iso(dvd)
mnt_sub = "/data/cobbler/{0}".format(name)
params['path'] = mnt_sub
mnt_sub_cmd = ['mkdir', '-p', mnt_sub]
mount_cmd = ['mount', '-o', 'loop', dvd, mnt_sub]
log_info('create temp dir %s' % str(mnt_sub))
ret, out_info, error_msg = self.execute_cmd(mnt_sub_cmd)
if not ret:
log_error('execute {0} error{1}'.format(mnt_sub_cmd, error_msg))
raise RuntimeError('execute {0} error{1}'.format(
mnt_sub_cmd, error_msg))
log_info("mount iso {0}".format(dvd))
ret, out_info, error_msg = self.execute_cmd(mount_cmd)
if not ret:
log_error('execute {0} error{1}'.format(mount_cmd, error_msg))
raise RuntimeError('execute {0} error{1}'.format(
mount_cmd, error_msg))
remote = self.get_remote()
token = self.get_token()
log_info("async import iso")
task_name = remote.background_import(params, token)
return task_name, mnt_sub
def del_record(self, req, resp):
record_id = req.get_param(name='ri')
domain = req.get_param(name='d')
t = req.get_param(name='t')
if t is None or t not in support:
return '%s type is not support' % t
if record_id is None or record_id == '':
return '-rt is empty'
if domain is None or domain == '':
return '-d is empty'
if t == 'cloudflare':
try:
cloudflare = CloudFlare()
return cloudflare.delete_record(domain=domain,
record_id=record_id)
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'dnspod':
try:
dp = Dnspod()
return dp.delete_record(domain=domain, record_id=record_id)
except Exception as e:
log_error(e)
raise Exception(e)
def upload(self, params):
path = params.get('path')
osname = params.pop('filename')
name = params.get('name')
dvd = '/'.join([path, osname])
log_info("check iso {0}".format(dvd))
self._check_iso(dvd)
mnt_sub = "/data/cobbler/{0}".format(name)
params['path'] = mnt_sub
mnt_sub_cmd = ['mkdir', '-p', mnt_sub]
mount_cmd = ['mount', '-o', 'loop', dvd, mnt_sub]
log_info('create temp dir %s' % str(mnt_sub))
ret, out_info, error_msg = self.execute_cmd(mnt_sub_cmd)
if not ret:
log_error('execute {0} error{1}'.format(mnt_sub_cmd, error_msg))
raise RuntimeError('execute {0} error{1}'.format(mnt_sub_cmd,
error_msg))
log_info("mount iso {0}".format(dvd))
ret, out_info, error_msg = self.execute_cmd(mount_cmd)
if not ret:
log_error('execute {0} error{1}'.format(mount_cmd, error_msg))
raise RuntimeError('execute {0} error{1}'.format(mount_cmd,
error_msg))
remote = self.get_remote()
token = self.get_token()
log_info("async import iso")
task_name = remote.background_import(params, token)
return task_name, mnt_sub
def get_item(self, system_name):
remote = self.get_remote()
token = self.get_token()
result = remote.get_system(system_name, token)
if not isinstance(result, dict):
log_error('system not found')
return result
def get_item(self, distros_name):
remote = self.get_remote()
token = self.get_token()
result = remote.get_distro(distros_name, token)
if not isinstance(result, dict):
log_error('distro not found')
return result
def modify(self, system_name, params):
remote = self.get_remote()
token = self.get_token()
log_debug('modify system params:{0}'.format(params))
interfaces = {}
if params.has_key('interfaces'):
interfaces = params.pop('interfaces')
if not remote.has_item(self.TYPE, system_name):
log_error('System {0} not found'.format(system_name))
system_id = remote.get_system_handle(system_name, token)
for key, val in params.items():
log_info("set params {0} = {1}".format(key, val))
remote.modify_system(system_id, key, val, token)
for interface_name, params in interfaces.items():
temp_dict = {}
log_info("struct interface params {0}".format(interface_name))
for key, val in params.items():
temp_dict['%s-%s' % (key, interface_name)] = val
log_info("update interface {0}".format(temp_dict))
remote.modify_system(system_id, 'modify_interface', temp_dict,
token)
del temp_dict
log_info("save system {0}".format(system_id))
remote.save_system(system_id, token)
log_info("sync system info")
sync_task = remote.sync(token)
return sync_task
def get_sensor_list(self, host, sensor=None):
sensor_list = []
output = self.execute_sensor_ipmi_command(host)
for line in output.split('\n'):
if line:
if sensor is None:
sensor_list.append({
"name":
line.split('|')[0].strip(),
"value":
float(line.split('|')[1].strip()),
"status":
line.split('|')[3].strip()
})
elif line.split('|')[2].strip() == sensor:
sensor_list.append({
"name":
line.split('|')[0].strip(),
"value":
float(line.split('|')[1].strip()),
"status":
line.split('|')[3].strip()
})
if not sensor_list:
log_error("No %s sensor", sensor)
else:
return sensor_list
def get_item(self, system_name):
remote = self.get_remote()
token = self.get_token()
result = remote.get_system(system_name, token)
if not isinstance(result, dict):
log_error('system not found')
return result
def modify(self, system_name, params):
remote = self.get_remote()
token = self.get_token()
log_debug('modify system params:{0}'.format(params))
interfaces = {}
if params.has_key('interfaces'):
interfaces = params.pop('interfaces')
if not remote.has_item(self.TYPE, system_name):
log_error('System {0} not found'.format(system_name))
system_id = remote.get_system_handle(system_name, token)
for key, val in params.items():
log_info("set params {0} = {1}".format(key, val))
remote.modify_system(system_id, key, val, token)
for interface_name, params in interfaces.items():
temp_dict = {}
log_info("struct interface params {0}".format(interface_name))
for key, val in params.items():
temp_dict['%s-%s' % (key, interface_name)] = val
log_info("update interface {0}".format(temp_dict))
remote.modify_system(system_id, 'modify_interface', temp_dict,
token)
del temp_dict
log_info("save system {0}".format(system_id))
remote.save_system(system_id, token)
log_info("sync system info")
sync_task = remote.sync(token)
return sync_task
def sink(req, resp):
do_log_history(req, resp)
paths = filter(lambda x: x != '', req.path.split('/'))
ctrl_name = func_name = 'index'
if len(paths) >= 2:
ctrl_name = paths[0]
func_name = paths[1]
elif len(paths) == 1:
func_name = paths[0]
ctrl = loader.ctrl(ctrl_name)
if ctrl == None or not hasattr(ctrl, func_name):
resp.status = falcon.HTTP_404
resp.body = "Not Found"
else:
try:
content = getattr(ctrl, func_name)(req, resp)
if resp.body == None:
if isinstance(content, unicode):
resp.body = unicode.encode(content, 'utf-8', 'ignore')
elif isinstance(content, str):
resp.body = content
else:
resp.body = json.dumps(content)
except Exception as ex:
log_error(ex)
resp.status = falcon.HTTP_500
resp.body = str(ex)
#resp.body = 'A server error occurred. Please contact the administrator'
do_log_result(req, resp)
def del_record(self, req, resp):
record_id = req.get_param(name='ri')
domain = req.get_param(name='d')
t = req.get_param(name='t')
if t is None or t not in support:
return '%s type is not support' % t
if record_id is None or record_id == '':
return '-rt is empty'
if domain is None or domain == '':
return '-d is empty'
if t == 'cloudflare':
try:
cloudflare = CloudFlare()
return cloudflare.delete_record(
domain=domain, record_id=record_id)
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'dnspod':
try:
dp = Dnspod()
return dp.delete_record(domain=domain, record_id=record_id)
except Exception as e:
log_error(e)
raise Exception(e)
def get_item(self, distros_name):
remote = self.get_remote()
token = self.get_token()
result = remote.get_distro(distros_name, token)
if not isinstance(result, dict):
log_error('distro not found')
return result
def __init__(self):
self.jenkins_url = jenkins_config.get('url')
self.user = jenkins_config.get('user')
self.password = jenkins_config.get('password')
if self.jenkins_url is not None:
try:
self.jenkins = Jenkins(
self.jenkins_url, auth=(self.user, self.password))
except Exception as e:
log_error(e)
def __init__(self):
self.jenkins_url = jenkins_config.get('url')
self.user = jenkins_config.get('user')
self.password = jenkins_config.get('password')
if self.jenkins_url is not None:
try:
self.jenkins = Jenkins(self.jenkins_url,
auth=(self.user, self.password))
except Exception as e:
log_error(e)
def get_event(self, event_id):
result = {}
try:
remote = self.get_remote()
status = remote.get_task_status(event_id)
loginfo = remote.get_event_log(event_id)
result['status'] = status[2]
result['event_log'] = loginfo
except xmlrpclib.Fault, msg:
re_no_event = re.compile('.*?no event with that id.*?', re.S)
if re.findall(re_no_event, msg.faultString):
log_error('no event with that id')
def get_event(self, event_id):
result = {}
try:
remote = self.get_remote()
status = remote.get_task_status(event_id)
loginfo = remote.get_event_log(event_id)
result['status'] = status[2]
result['event_log'] = loginfo
except xmlrpclib.Fault, msg:
re_no_event = re.compile('.*?no event with that id.*?', re.S)
if re.findall(re_no_event, msg.faultString):
log_error('no event with that id')
def _refresh_qcloud(self, domain, files):
service = Cdn()
for f in files:
try:
params = {
'entityFileName': os.path.basename(f),
'entityFile': domain + '/' + f
}
service.UploadCdnEntity(params)
except Exception as e:
log_error(e)
raise Exception(e)
return True
def _refresh_qcloud(self, domain, files):
service = Cdn()
for f in files:
try:
params = {
'entityFileName': os.path.basename(f),
'entityFile': domain + '/' + f
}
service.UploadCdnEntity(params)
except Exception as e:
log_error(e)
raise Exception(e)
return True
def _check_fileds(self, fileds, params):
mandatory_fileds = filter(lambda x: fileds[x][0], fileds.keys())
for k in mandatory_fileds:
if not params.get(k, None):
log_error('Variable "{0}" is mandatory, check your params.'.
format(k))
scode_fileds = filter(lambda x: fileds[x][1], fileds.keys())
for k in scode_fileds:
val = params.get(k)
if val:
if val not in fileds[k][2]:
log_error('Variable {0} value is Error, must in {1}'.
format(k, fileds[k][2]))
def refresh(self, req, resp):
file = req.get_param(name='file')
domain = req.get_param(name='domain')
t = req._params['t']
if t is None or t not in support:
return '%s type is not support' % t
if file is None or file == '':
return '--file is empty'
if domain is None or domain == '':
return '--domain is empty'
files = file.split(',')
if t == 'alicdn':
try:
return self._refresh_alicdn(domain=domain, files=files)
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'qcloud':
try:
return self._refresh_qcloud(domain=domain, files=files)
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'upyun':
try:
up = self._get_upyun()
up.up.purge(files=files, domain=domain)
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'chinacache':
try:
self._refresh_chinacache(domain=domain, files=files)
except Exception as e:
log_error(e)
raise Exception(e)
else:
try:
self._refresh_alicdn(domain=domain, files=files)
self._refresh_qcloud(domain=domain, files=files)
up = self._get_upyun()
up.up.purge(files=files, domain=domain)
self._refresh_chinacache(domain=domain, files=files)
return 'ok'
except Exception as e:
log_error(e)
raise Exception(e)
def refresh(self, req, resp):
file = req.get_param(name='file')
domain = req.get_param(name='domain')
t = req._params['t']
if t is None or t not in support:
return '%s type is not support' % t
if file is None or file == '':
return '--file is empty'
if domain is None or domain == '':
return '--domain is empty'
files = file.split(',')
if t == 'alicdn':
try:
return self._refresh_alicdn(domain=domain, files=files)
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'qcloud':
try:
return self._refresh_qcloud(domain=domain, files=files)
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'upyun':
try:
up = self._get_upyun()
up.up.purge(files=files, domain=domain)
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'chinacache':
try:
self._refresh_chinacache(domain=domain, files=files)
except Exception as e:
log_error(e)
raise Exception(e)
else:
try:
self._refresh_alicdn(domain=domain, files=files)
self._refresh_qcloud(domain=domain, files=files)
up = self._get_upyun()
up.up.purge(files=files, domain=domain)
self._refresh_chinacache(domain=domain, files=files)
return 'ok'
except Exception as e:
log_error(e)
raise Exception(e)
def callback(self, req, resp):
accept_key = '<M(^BJB<*&RGKJKLSO'
m1 = hashlib.md5()
m1.update(accept_key + req.get_param(name='host', default=''))
if req.get_param(name='access_token') != m1.hexdigest():
msg = 'invalid access_token,ansible calback fail'
log_error(msg)
raise Exception(msg)
else:
ansible_log = AnsibleLog()
ansible_log.category = req.get_param(name='classify')
ansible_log.result = req.get_param(name='result')
ansible_log.result_status = req.get_param(name='result_status')
ansible_log.server_ip = req.get_param(name='host')
return ansible_log.save()
def _refresh_alicdn(self, domain, files):
args = {}
args['Action'] = 'RefreshObjectCaches'
args['ObjectType'] = 'File'
for f in files:
args['ObjectPath'] = domain + '/' + f
log_debug('flush http://%s' % args['ObjectPath'])
try:
log_debug(json.dumps(args))
aliyun = Connection(region_id='cn-hangzhou', service='cdn')
aliyun.get(args)
except Exception as e:
log_error(e)
raise Exception(e)
return True
def _get_upyun(self):
up = None
try:
up = upyun.UpYun(upyun_config.get('bucket'),
username=upyun_config.get('username'),
password=upyun_config.get('password'))
except Exception as e:
log_error(e)
try:
up = upyun.UpYun(upyun_config.get('bucket'),
secret=upyun_config.get('secret'))
except Exception as e:
log_error(e)
raise Exception(e)
return up
def delete(self, system_names):
if not isinstance(system_names, (list, tuple)):
log_error('params must be list or tuple')
remote = self.get_remote()
token = self.get_token()
error_list = []
for obj_name in system_names:
try:
remote.xapi_object_edit('system', obj_name, "remove", {
'name': obj_name,
'recursive': False
}, token)
except xmlrpclib.Fault, msg:
error_list.append('{0} delete failed，error info {1}'.format(
obj_name, msg.faultString))
def _refresh_alicdn(self, domain, files):
args = {}
args['Action'] = 'RefreshObjectCaches'
args['ObjectType'] = 'File'
for f in files:
args['ObjectPath'] = domain + '/' + f
log_debug('flush http://%s' % args['ObjectPath'])
try:
log_debug(json.dumps(args))
aliyun = Connection(region_id='cn-hangzhou', service='cdn')
aliyun.get(args)
except Exception as e:
log_error(e)
raise Exception(e)
return True
def delete(self, system_names):
if not isinstance(system_names, (list, tuple)):
log_error('params must be list or tuple')
remote = self.get_remote()
token = self.get_token()
error_list = []
for obj_name in system_names:
try:
remote.xapi_object_edit('system', obj_name, "remove", {
'name': obj_name,
'recursive': False
}, token)
except xmlrpclib.Fault, msg:
error_list.append('{0} delete failed，error info {1}'.format(
obj_name, msg.faultString))
def callback(self, req, resp):
accept_key = '<M(^BJB<*&RGKJKLSO'
m1 = hashlib.md5()
m1.update(accept_key + req.get_param(name='host', default=''))
if req.get_param(name='access_token') != m1.hexdigest():
msg = 'invalid access_token,ansible calback fail'
log_error(msg)
raise Exception(msg)
else:
ansible_log = AnsibleLog()
ansible_log.category = req.get_param(name='classify')
ansible_log.result = req.get_param(name='result')
ansible_log.result_status = req.get_param(name='result_status')
ansible_log.server_ip = req.get_param(name='host')
return ansible_log.save()
def _check_fileds(self, fileds, params):
mandatory_fileds = filter(lambda x: fileds[x][0], fileds.keys())
for k in mandatory_fileds:
if not params.get(k, None):
log_error(
'Variable "{0}" is mandatory, check your params.'.format(
k))
scode_fileds = filter(lambda x: fileds[x][1], fileds.keys())
for k in scode_fileds:
val = params.get(k)
if val:
if val not in fileds[k][2]:
log_error(
'Variable {0} value is Error, must in {1}'.format(
k, fileds[k][2]))
def _get_upyun(self):
up = None
try:
up = upyun.UpYun(
upyun_config.get('bucket'),
username=upyun_config.get('username'),
password=upyun_config.get('password'))
except Exception as e:
log_error(e)
try:
up = upyun.UpYun(
upyun_config.get('bucket'),
secret=upyun_config.get('secret'))
except Exception as e:
log_error(e)
raise Exception(e)
return up
def list_domains(self, req, resp):
t = req.get_param(name='t')
if t is None or t not in support:
return '%s type is not support' % t
if t == 'cloudflare':
try:
cloudflare = CloudFlare()
return cloudflare.get_domains_list()
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'dnspod':
try:
dp = Dnspod()
return dp.get_domains_list()
except Exception as e:
log_error(e)
raise Exception(e)
def list_domains(self, req, resp):
t = req.get_param(name='t')
if t is None or t not in support:
return '%s type is not support' % t
if t == 'cloudflare':
try:
cloudflare = CloudFlare()
return cloudflare.get_domains_list()
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'dnspod':
try:
dp = Dnspod()
return dp.get_domains_list()
except Exception as e:
log_error(e)
raise Exception(e)
def execute_cmd(self, params):
"""
@params: list or tuple
return (bool, stdout, error_msg)
"""
if not isinstance(params, (list, tuple)):
log_error('params must be list or tuple')
return (False, '', 'params must be list or tuple')
pop = subprocess.Popen(params,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
code = pop.wait()
if code == 0:
return (True, pop.stdout.read(), '')
else:
return (False, pop.stdout.read(), pop.stderr.read())
def edit_record(self, req, resp):
record_type = req.get_param(name='rt')
record_id = req.get_param(name='ri')
name = req.get_param(name='n')
content = req.get_param(name='c')
domain = req.get_param(name='d')
t = req.get_param(name='t')
if t is None or t not in support:
return '%s type is not support' % t
if record_type is None or record_type not in allowed_types:
return '%s type is not support' % t
if record_id is None or record_id == '':
return '-rt is empty'
if name is None or name == '':
return '-n is empty'
if content is None or content == '':
return '-c is empty'
if domain is None or domain == '':
return '-d is empty'
if t == 'cloudflare':
try:
cloudflare = CloudFlare()
return cloudflare.add_record(
domain=domain,
record_type=record_type,
name=name,
content=content)
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'dnspod':
try:
dp = Dnspod()
return dp.add_record(
domain=domain,
record_type=record_type,
name=name,
content=content)
except Exception as e:
log_error(e)
raise Exception(e)
def execute_cmd(self, params):
"""
@params: list or tuple
return (bool, stdout, error_msg)
"""
if not isinstance(params, (list, tuple)):
log_error('params must be list or tuple')
return (False, '', 'params must be list or tuple')
pop = subprocess.Popen(
params,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
code = pop.wait()
if code == 0:
return (True, pop.stdout.read(), '')
else:
return (False, pop.stdout.read(), pop.stderr.read())
def execute_ipmi_command(self, host, command):
hostname = host.hostname
password = host.netloc.split(":")[1].split("@")[0]
user = host.netloc.split(":")[0]
all_command = "ipmitool "
all_command += command
all_command += " -H " + hostname
all_command += " -U " + user
all_command += " -P " + password
child = subprocess.Popen(all_command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
output, error = child.communicate()
if child.returncode == 0:
return output
else:
log_error(error)
raise IPMIException
def after_upload(self, task_name, mnt_sub):
remote = self.get_remote()
token = self.get_token()
umount_cmd = ["umount", mnt_sub]
del_mnt_sub_cmd = ['rm', '-rf', mnt_sub]
log_info("check task {0} result".format(task_name))
status = remote.get_task_status(task_name)
while status[2] not in ('complete', 'failed'):
status = remote.get_task_status(task_name)
log_info("task execute complete - result[{0}]".format(status[2]))
log_info("sync info")
remote.sync(token)
log_info("umount iso {0}".format(mnt_sub))
ret, out_info, error_msg = self.execute_cmd(umount_cmd)
if not ret:
log_error('execute {0} error{1}'.format(umount_cmd, error_msg))
log_info("delete temp dir{0}".format(mnt_sub))
ret, out_info, error_msg = self.execute_cmd(del_mnt_sub_cmd)
if not ret:
log_error('execute {0} error{1}'.format(del_mnt_sub_cmd,
error_msg))
def execute_ipmi_command(self, host, command):
hostname = host.hostname
password = host.netloc.split(":")[1].split("@")[0]
user = host.netloc.split(":")[0]
all_command = "ipmitool "
all_command += command
all_command += " -H " + hostname
all_command += " -U " + user
all_command += " -P " + password
child = subprocess.Popen(
all_command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
output, error = child.communicate()
if child.returncode == 0:
return output
else:
log_error(error)
raise IPMIException
def get_sensor_list(self, host, sensor=None):
sensor_list = []
output = self.execute_sensor_ipmi_command(host)
for line in output.split('\n'):
if line:
if sensor is None:
sensor_list.append({
"name": line.split('|')[0].strip(),
"value": float(line.split('|')[1].strip()),
"status": line.split('|')[3].strip()
})
elif line.split('|')[2].strip() == sensor:
sensor_list.append({
"name": line.split('|')[0].strip(),
"value": float(line.split('|')[1].strip()),
"status": line.split('|')[3].strip()
})
if not sensor_list:
log_error("No %s sensor", sensor)
else:
return sensor_list
def after_upload(self, task_name, mnt_sub):
remote = self.get_remote()
token = self.get_token()
umount_cmd = ["umount", mnt_sub]
del_mnt_sub_cmd = ['rm', '-rf', mnt_sub]
log_info("check task {0} result".format(task_name))
status = remote.get_task_status(task_name)
while status[2] not in ('complete', 'failed'):
status = remote.get_task_status(task_name)
log_info("task execute complete - result[{0}]".format(status[2]))
log_info("sync info")
remote.sync(token)
log_info("umount iso {0}".format(mnt_sub))
ret, out_info, error_msg = self.execute_cmd(umount_cmd)
if not ret:
log_error('execute {0} error{1}'.format(umount_cmd, error_msg))
log_info("delete temp dir{0}".format(mnt_sub))
ret, out_info, error_msg = self.execute_cmd(del_mnt_sub_cmd)
if not ret:
log_error('execute {0} error{1}'.format(del_mnt_sub_cmd,
error_msg))
def edit_record(self, req, resp):
record_type = req.get_param(name='rt')
record_id = req.get_param(name='ri')
name = req.get_param(name='n')
content = req.get_param(name='c')
domain = req.get_param(name='d')
t = req.get_param(name='t')
if t is None or t not in support:
return '%s type is not support' % t
if record_type is None or record_type not in allowed_types:
return '%s type is not support' % t
if record_id is None or record_id == '':
return '-rt is empty'
if name is None or name == '':
return '-n is empty'
if content is None or content == '':
return '-c is empty'
if domain is None or domain == '':
return '-d is empty'
if t == 'cloudflare':
try:
cloudflare = CloudFlare()
return cloudflare.add_record(domain=domain,
record_type=record_type,
name=name,
content=content)
except Exception as e:
log_error(e)
raise Exception(e)
elif t == 'dnspod':
try:
dp = Dnspod()
return dp.add_record(domain=domain,
record_type=record_type,
name=name,
content=content)
except Exception as e:
log_error(e)
raise Exception(e)
def add(self, req, resp):
try:
cmd = req.get_param(name='c')
ip = req.get_param(name='i')
timeout = req.get_param(name='5') or 3
if 'c' is None:
return '-c(cmd) require'
if 'i' is None:
return '-i(ip) require'
data = {'value': cmd.encode('utf-8')}
req = requests.post(
url="http://%s/v2/keys%s/servers/%s/" %
(self.etcd_config['server'], self.etcd_config['prefix'], ip),
data=data)
ret = req.json()
index = str(ret['node']['createdIndex'])
self.cmdkeys[index] = ''
start = time.time()
if ret['node']['value'] == cmd:
while True:
if (time.time() - start > timeout
) or self.cmdkeys[index] != '':
log_debug('%s timeout' % data)
break
else:
time.sleep(0.1)
if self.cmdkeys[index] != '':
ret = self.cmdkeys[index]
del self.cmdkeys[index]
return ret
return '(success) submit command success'
else:
return '(unsafe) submit command success '
except Exception as er:
log_error(er)
return 'fail'
def _check_iso(self, path):
if not os.path.exists(path):
log_error('{0} does not exist'.format(path))
def _check_iso(self, path):
if not os.path.exists(path):
log_error('{0} does not exist'.format(path))
