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 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 __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 _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 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 _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 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 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))