def system_run_time(): current_app.logger.debug("get system running time") resp = errcode.get_error_result() resp['data'] = {} try: start_time = time.localtime(psutil.boot_time()) _time = time.strftime("%Y-%m-%d %H:%M:%S", start_time) date_time = dt.datetime.fromisoformat(_time) days = (dt.datetime.now() - date_time).days delta_seconds = (dt.datetime.now() - date_time).seconds hours = delta_seconds // (60 * 60) minutes = (delta_seconds - hours * (60 * 60)) // 60 run_time = "" if days: run_time += "%s天" % days if hours: run_time += "%s时" % hours run_time += "%s分" % minutes # run_time = "%s天%s时%s分" % (days, hours, minutes) resp['data']['run_time'] = run_time return resp except Exception as err: current_app.logger.error(err) current_app.logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="GetSystemRunningTimeError") return resp
def delete_voi_desktop(self, desktop_uuid): """ 删除桌面组 """ desktop = db_api.get_item_with_first(models.YzyVoiDesktop, {"uuid": desktop_uuid}) if not desktop: logger.error("desktop %s not exist", desktop_uuid) return get_error_result("DesktopNotExist", name="") try: # 清除桌面组与终端的绑定关系 terminal_desktop_binds = db_api.get_item_with_all(models.YzyVoiTerminalToDesktops, {"desktop_group_uuid": desktop_uuid}) for bind in terminal_desktop_binds: # type: 0-upload, 1-download bt_task = db_api.get_item_with_first(models.YzyVoiTorrentTask, {"terminal_mac": bind.terminal_mac, "type": 1}) # status == 1, task running if bt_task and bt_task.status == 1: return get_error_result("TerminalTorrentDownloading") bind.soft_delete() logger.info("delete voi desktop, clear terminal desktop bind success!!") desktop.soft_delete() logger.info("delete voi desktop, uuid:%s, name:%s", desktop.uuid, desktop.name) if desktop.default: default_one = db_api.get_item_with_first(models.YzyVoiDesktop, {}) if default_one: default_one.default = True default_one.soft_update() logger.info("the delete desktop is default, set %s as default", default_one.name) return get_error_result("Success") except Exception as e: logger.error("delete voi desktop failed:%s", e, exc_info=True) return get_error_result("DesktopDeleteFail")
def get_resource_info(): try: merge_resp = errcode.get_error_result() #ip_info = get_ip_info() #merge_resp['ip'] = ip_info[0] #merge_resp['hostname'] = ip_info[1] utc = int((dt.datetime.utcnow() - dt.datetime.utcfromtimestamp(0)).total_seconds()) merge_resp['utc'] = utc call_func_list = [ get_cpu_info, get_memory_info, get_disk_info, get_network_info, get_vm_running, get_diskio_info, get_networkio_info, get_cpuvt_info, get_service_info ] merge_resp['data'] = {} for func in call_func_list: resp = func() if resp['code'] != 0: return resp else: if 'data' in resp.keys(): if 'utc' in resp['data'].keys(): resp['data'].pop('utc') add_key_name = func.__name__.split('_')[1] merge_resp['data'][add_key_name] = resp['data'] return merge_resp except Exception as err: current_app.logger.error(err) current_app.logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="OtherError") return resp
def setup_shutdown(self): try: resp = errcode.get_error_result() cron = CronTab(user=True) cron_name = self.task.get("data").get("task_name") cron_time_minute = int(self.task.get("data").get("exec_minute")) cron_time_hour = int(self.task.get("data").get("exec_hour")) cron_weekly = str(self.task.get("data").get("exec_weekly")) cron_weekly = [ x for x in re.findall('\d', cron_weekly) if x in list("01234567") ] cron_weekly = ','.join(cron_weekly) jobs = cron.find_comment( 'front_end_controller:{}'.format(cron_name)) for job in jobs: job.delete() job = cron.new(command='shutdown now', comment='front_end_controller:{}'.format(cron_name)) job.setall(cron_time_minute, cron_time_hour, '*', '*', cron_weekly) cron.write() current_app.logger.debug( 'add crontab: {} success'.format(cron_name)) return resp except Exception as err: current_app.logger.error(err) current_app.logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="OtherError") return resp
def delete_ip_info(): """ { "name": "eth0:0", "ip": "172.16.1.31", "netmask": "255.255.255.0", "gateway": "172.16.1.254", "dns1": "8.8.8.8", "dns2": "114.114.114.114" } :return: """ try: data = request.get_json() name = data.get("name", "") if name.find(":") == -1: current_app.logger.error("delete dev ip: %s, is main device" % name) return errcode.get_error_result("MainNICIpDelError") try: os.system("ifdown %s" % name) except: pass nic_ifcfg = "/etc/sysconfig/network-scripts/ifcfg-%s" % name if os.path.exists(nic_ifcfg): os.remove(nic_ifcfg) current_app.logger.info("delete dev ip: %s success" % name) return errcode.get_error_result() except Exception as err: current_app.logger.error(err) current_app.logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="DeleteIpConfFileFailure") return resp
def get_diskio_info(self): try: resp = errcode.get_error_result() utc = int((dt.datetime.utcnow() - dt.datetime.utcfromtimestamp(0)).total_seconds()) resp['utc'] = utc diskio_parts = psutil.disk_io_counters(perdisk=True) virtual_block_device = os.listdir('/sys/devices/virtual/block/') physical_block_device = [ dev for dev in diskio_parts if dev not in virtual_block_device ] for diskio in physical_block_device: resp[diskio] = { 'read_bytes': diskio_parts[diskio].read_bytes, 'write_bytes': diskio_parts[diskio].write_bytes } # insert redis """ if self.rds.ping_server(): node_key = '{}:diskio_info:{}'.format(self.ip, self.now_date) insert_data = resp.copy() insert_data.pop('code') insert_data.pop('msg') if self.rds.exists(node_key): self.rds.zadd(node_key, {json.dumps(insert_data): utc}) else: self.rds.zadd(node_key, {json.dumps(insert_data): utc}) self.rds.expire(node_key, self.rds.live_seconds) # 86400 seconds of a day """ return resp except Exception as err: logger.error(err) logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="GetDiskIoInfoFailure") return resp
def get_cpu_info(self): try: resp = errcode.get_error_result() utc = int((dt.datetime.utcnow() - dt.datetime.utcfromtimestamp(0)).total_seconds()) resp['utc'] = utc cpu_numbers = psutil.cpu_count() resp['numbers'] = cpu_numbers cpu_utilization = psutil.cpu_percent() resp['utilization'] = cpu_utilization # insert redis """ if self.rds.ping_server(): node_key = '{}:cpu_info:{}'.format(self.ip, self.now_date) insert_data = resp.copy() insert_data.pop('code') insert_data.pop('msg') if self.rds.exists(node_key): self.rds.zadd(node_key, {json.dumps(insert_data): utc}) else: self.rds.zadd(node_key, {json.dumps(insert_data): utc}) self.rds.expire(node_key, self.rds.live_seconds) # 86400 seconds of a day """ return resp except Exception as err: logger.error(err) logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="GetCpuInfoFailure") return resp
def create_user(self, data): if not self._check_params(data): return get_error_result("ParamError") group = db_api.get_group_with_first({'uuid': data['group_uuid']}) if not group: logger.error("group: %s not exist", data['group_uuid']) return get_error_result("GroupNotExists", name='') # add user to group user_value = { "uuid": create_uuid(), "group_uuid": data['group_uuid'], "user_name": data['user_name'], "passwd": create_md5(data['passwd']), "name": data.get('name', ''), "phone": data.get('phone', ''), "email": data.get('email', ''), "enabled": data.get('enabled', True) } try: db_api.create_group_user(user_value) logger.info("create group user %s success", data['user_name']) except Exception as e: logging.info("insert group user info to db failed:%s", e) return get_error_result("GroupUserCreateError", user_name=data['user_name']) return get_error_result("Success", user_value)
def update(self): try: resp = errcode.get_error_result() addr = self.task.get("data").get('addr') node_uuid = self.task.get("data").get('node_uuid') current_app.logger.debug('Get addr: {}'.format(addr)) # work_dir = os.getcwd() work_dir = os.path.join(BASE_DIR, 'config') conf = configparser.ConfigParser() conf.read('{}/monitor_server.ini'.format(work_dir)) if conf.has_option('CONTROLLER', 'addr') and conf.has_option( 'CONTROLLER', 'node_uuid'): conf.set('CONTROLLER', 'addr', addr) conf.set('CONTROLLER', 'node_uuid', node_uuid) conf.write(open('{}/monitor_server.ini'.format(work_dir), 'w+')) else: current_app.logger.error( 'Config file monitor_server.ini error: no addr or node_uuid' ) resp = errcode.get_error_result(error="OtherError") # send command to ipc queue current_app.timer_msq.put(sys._getframe(0).f_code.co_name, block=False) return resp except Exception as err: current_app.logger.error(err) current_app.logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="OtherError") return resp
def get_log_file(self): try: resp = errcode.get_error_result() cmd_msg = CommandMsg() cmd_msg.cmdstr = 'upload_log' cmd_msg.BodyType = CommandBodyType.TEXT cmd_msg.Body = "Command:%s" % cmd_msg.cmdstr cmd_msg.ArgsDic = { 'start_time': self.task.get("data").get("start_date"), "end_time": self.task.get("data").get("end_date") } mac_list = self.task.get("data").get("mac_list") # if directory not exists, then create it if not os.path.exists(SERVER_CONF.terminal.log_dir): os.makedirs(SERVER_CONF.terminal.log_dir) for mac in mac_list.split(','): # delete log file and ok file if exists os.system("rm -f {}/{}*.zip".format( SERVER_CONF.terminal.log_dir, mac)) os.system("rm -f {}/{}*.ok".format( SERVER_CONF.terminal.log_dir, mac)) self.send_thrift_cmd(mac, cmd_msg) return resp except Exception as err: logging.error(err) logging.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="OtherError") return resp
def desktop_close_notice(self): try: resp = errcode.get_error_result() cmd_msg = CommandMsg() cmd_msg.cmdstr = 'vm_shutdown' cmd_msg.BodyType = CommandBodyType.TEXT data = self.task.get("data") data['desktop_name'] = data["instance_name"] data['dsk_uuid'] = data["instance_uuid"] data.pop("instance_name") data.pop("instance_uuid") data['dsk_type'] = "kvm" data['status'] = 0 terminal_mac = data['terminal_mac'] data.pop("terminal_mac") body = str(json.dumps(data).encode('utf-8'), encoding='utf-8') cmd_msg.Body = "Command:{}|{}".format(cmd_msg.cmdstr, body) if terminal_mac: table_terminal_api = db_api.YzyTerminalTableCtrl( current_app.db) qry_terminal = table_terminal_api.select_terminal_by_mac( terminal_mac) if qry_terminal and qry_terminal.status == '1': self.send_thrift_cmd(terminal_mac, cmd_msg) return resp except Exception as err: logging.error(err) logging.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="OtherError") return resp
def update_group(self, data): group_uuid = data.get('uuid', '') group = voi_api.get_item_with_first(models.YzyVoiGroup, {"uuid": group_uuid}) if not group: logger.error("group: %s not exist", group_uuid) return get_error_result("GroupNotExists", name='') try: # dhcp_conf = data["value"].get("dhcp") # if dhcp_conf: # start_ip = dhcp_conf.get("start_ip") # end_ip = dhcp_conf.get("end_ip") # netmask = dhcp_conf.get("netmask") # gateway = dhcp_conf.get("gateway") # if start_ip and end_ip and netmask and gateway: # # 更新DHCP配置 # try: # self.update_dhcp_server(dhcp_conf, group_uuid) # except Exception as e: # logger.error("", exc_info=True) # return get_error_result("DhcpConfigUpdateError") # data['value']["dhcp"] = json.dumps(dhcp_conf) group.update(data['value']) group.soft_update() except Exception as e: logger.error("update voi group:%s failed:%s", group_uuid, e, exc_info=True) return get_error_result("GroupUpdateError", name=group.name) logger.info("update voi group:%s success", group_uuid) return get_error_result("Success")
def modify_terminal_name(self): try: resp = errcode.get_error_result() cmd_msg = CommandMsg() cmd_msg.cmdstr = 'update_config' cmd_msg.BodyType = CommandBodyType.TEXT cmd_msg.Body = "Command:%s" % cmd_msg.cmdstr data = self.task.get("data") logging.debug(data) # yzy_terminal update for mac in data.keys(): table_api = db_api.YzyTerminalTableCtrl(current_app.db) qry_terminal = table_api.select_terminal_by_mac(mac) if qry_terminal: terminal_values = { 'mac': mac, 'conf_version': str(int(qry_terminal.conf_version) + 1), 'name': data[mac] } table_api.update_terminal_by_mac(**terminal_values) if qry_terminal.status == '1': self.send_thrift_cmd(mac, cmd_msg) else: logging.warning( 'mac not found in yzy_terminal {}'.format(mac)) return resp except Exception as err: logging.error(err) logging.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="OtherError") return resp
def delete_group(self, group_uuid): group = voi_api.get_item_with_first(models.YzyVoiGroup, {"uuid": group_uuid}) if not group: logger.error("group: %s not exist", group_uuid) return get_error_result("GroupNotExists", name='') if constants.EDUCATION_DESKTOP == group.group_type: desktop = voi_api.get_item_with_first(models.YzyVoiDesktop, {"group_uuid": group_uuid}) if desktop: logger.error("group already in use", group_uuid) return get_error_result("GroupInUse", name=group.name) binds = voi_api.get_item_with_all(models.YzyVoiTemplateGroups, {"group_uuid": group_uuid}) for bind in binds: bind.soft_delete() group.soft_delete() logger.info("delete voi group %s success", group_uuid) ret = voi_terminal_post( "/api/v1/voi/terminal/command", { "handler": "WebTerminalHandler", "command": "delete_group", "data": { "group_uuid": group_uuid } }) return ret
def select_shutdown(self): try: resp = errcode.get_error_result() cron = CronTab(user=True) cron_name = self.task.get("data").get("task_name") jobs = cron.find_comment( 'front_end_controller:{}'.format(cron_name)) jobs_cnt = len(list(jobs)) if jobs_cnt == 1: jobs = cron.find_comment( 'front_end_controller:{}'.format(cron_name)) resp['data'] = {} for job in jobs: job_cmd = str(job).split('#')[0].strip() resp['data']['exec_minute'] = job_cmd.split(' ')[0] resp['data']['exec_hour'] = job_cmd.split(' ')[1] resp['data']['exec_weekly'] = str(job_cmd.split(' ')[4]) elif jobs_cnt >= 1: resp = errcode.get_error_result( error="FoundMultipleCrontabRecord") return resp else: resp = errcode.get_error_result(error="NotFoundCrontabRecord") return resp current_app.logger.debug( 'select crontab: {} success'.format(cron_name)) return resp except Exception as err: current_app.logger.error(err) current_app.logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="OtherError") return resp
def delete_shutdown(self): try: resp = errcode.get_error_result() cron = CronTab(user=True) cron_name = self.task.get("data").get("task_name") jobs = cron.find_comment( 'front_end_controller:{}'.format(cron_name)) jobs_cnt = len(list(jobs)) if jobs_cnt >= 1: jobs = cron.find_comment( 'front_end_controller:{}'.format(cron_name)) for job in jobs: job.delete() cron.write() else: resp = errcode.get_error_result(error="NotFoundCrontabRecord") return resp current_app.logger.debug( 'del crontab: {} success'.format(cron_name)) return resp except Exception as err: current_app.logger.error(err) current_app.logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="OtherError") return resp
def get_port_status(): try: resp = errcode.get_error_result() resp['data'] = {} data = request.get_json() ports = data.get("ports", None) if not ports: resp = errcode.get_error_result(error="MessageError") return resp port_list = [int(port) for port in ports.split(',')] conn_list = psutil.net_connections() status_cnt_dict = {port: 0 for port in port_list} for conn in conn_list: if conn.laddr.port in port_list and conn.status == 'ESTABLISHED': status_cnt_dict[conn.laddr.port] += 1 for port in port_list: if status_cnt_dict[port] >= 4: resp['data'][port] = True else: resp['data'][port] = False return resp except Exception as err: current_app.logger.error(err) current_app.logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="SystemError") return resp
def compute_post(ipaddr, data, timeout=120): endpoint, url = get_compute_url(ipaddr) http_client = HTTPClient(endpoint, timeout=timeout) headers = {"Content-Type": "application/json"} try: resp, body = http_client.post(url, data=data, headers=headers) except requests.exceptions.Timeout as e: ret = get_error_result("ComputeServiceTimeout", ipaddr=ipaddr) ret['data'] = "节点'%s'请求超时" % ipaddr return ret except requests.exceptions.ConnectionError as e: ret = get_error_result("ComputeServiceUnavaiable", ipaddr=ipaddr) ret['data'] = "节点'%s'计算服务连接失败" % ipaddr return ret except socket.gaierror as e: ret = get_error_result("ComputeServiceUnavaiable", ipaddr=ipaddr) ret['data'] = "节点'%s'计算服务连接失败" % ipaddr return ret except (socket.error, socket.timeout, IOError) as e: ret = get_error_result("ComputeServiceUnavaiable", ipaddr=ipaddr) ret['data'] = "节点'%s'计算服务连接失败" % ipaddr return ret except Exception as e: return get_error_result("ComputeServiceUnavaiable", ipaddr=ipaddr) return body
def update_group(self, data): group_uuid = data.get('uuid', '') group = db_api.get_group_with_first({"uuid": group_uuid}) if not group: logger.error("group: %s not exist" % group_uuid) return get_error_result("GroupNotExists", name='') if group.group_type == 1: desktop = db_api.get_desktop_with_all({'group_uuid': group_uuid}) if desktop: if 'subnet_uuid' in data['value'] and data['value'][ 'subnet_uuid'] != group.subnet_uuid: return get_error_result("GroupSubnetError") start_ip = data.get('value').get('start_ip') end_ip = data.get('value').get('end_ip') if group.start_ip != start_ip or group.end_ip != end_ip: old_terminals = db_api.get_terminal_with_all( {'group_uuid': group_uuid}) for terminal in old_terminals: terminal.group_uuid = None terminal.updated_at = datetime.datetime.utcnow() terminal.soft_update() new_terminals = db_api.get_terminal_with_all( {'group_uuid': None}) self.change_group_uuid(new_terminals, start_ip, end_ip, group_uuid) try: group.update(data['value']) group.soft_update() except Exception as e: logger.error("update group:%s failed:%s", group_uuid, e) return get_error_result("GroupUpdateError", name=group.name) logger.info("update group:%s success", group_uuid) return get_error_result("Success")
def server_post(url, data, version=None, timeout=180): if not version: version = "v1" bind = SERVER_CONF.addresses.get_by_default('server_bind', '') if bind: port = bind.split(':')[-1] else: port = constants.SERVER_DEFAULT_PORT endpoint = 'http://127.0.0.1:%s' % port http_client = HTTPClient(endpoint, timeout=timeout) headers = {"Content-Type": "application/json"} if not url.startswith("/api/"): url = "/api/%s/%s" % (version, url.lstrip('/')) try: resp, body = http_client.post(url, data=data, headers=headers) except requests.exceptions.ConnectionError as e: ret = get_error_result("ServerServiceUnavaiable") ret['data'] = "节点server服务计算服务连接失败" return ret except requests.exceptions.Timeout as e: ret = get_error_result("ServerServiceTimeout") ret['data'] = "节点server服务请求超时" return ret except socket.gaierror as e: ret = get_error_result("ServerServiceUnavaiable") ret['data'] = "节点server服务计算服务连接失败" return ret except (socket.error, socket.timeout, IOError) as e: ret = get_error_result("ServerServiceUnavaiable") ret['data'] = "节点server服务计算服务连接失败" return ret except Exception as e: return get_error_result("ServerServiceUnavaiable") return body
def move_user(self, data): group = db_api.get_group_with_first({"uuid": data['group_uuid']}) if not group: logger.error("group: %s not exist" % data['group_uuid']) return get_error_result("GroupNotExists", name='') for user in data['users']: user = db_api.get_group_user_with_first({'uuid': user['uuid']}) if not user: logger.error("user %s not exist", user['user_name']) return get_error_result("GroupUserNotExists", name=user['user_name']) if user.group_uuid == group.uuid: logger.info("user %s already in group %s, skip", user.user_name, group.name) continue try: user.group_uuid = data['group_uuid'] # 移动后,原先的跟桌面绑定关系要删除 binds = db_api.get_instance_with_all({"user_uuid": user.uuid}) for bind in binds: bind.user_uuid = '' bind.soft_update() user.soft_update() except Exception as e: logger.error("move user %s to group %s failed:%s", user.user_name, group.name, e) return get_error_result("GroupUserMoveError", user_name=user.user_name, group=group.name) logger.info("move user %s to group %s success", user.user_name, group.name) return get_error_result("Success")
def upgrade_post(ipaddr, url, data, timeout=60): bind = SERVER_CONF.addresses.get_by_default('upgrade_bind', '') if bind: port = bind.split(':')[-1] else: port = constants.UPGRADE_DEFAULT_PORT endpoint = 'http://%s:%s' % (ipaddr, port) http_client = HTTPClient(endpoint, timeout=timeout) headers = {"Content-Type": "application/json"} try: logger.debug("endpoint:%s, url: %s, data: %s: headers: %s" % (endpoint, url, data, headers)) resp, body = http_client.post(url, data=data, headers=headers) if isinstance(body, dict): body['ipaddr'] = ipaddr except requests.exceptions.Timeout as e: ret = get_error_result("UpgradeServiceTimeout") ret['data'] = "节点升级服务请求超时" ret['ipaddr'] = ipaddr return ret except Exception as e: logger.error("UpgradeServiceUnavailable", exc_info=True) ret = get_error_result("UpgradeServiceUnavailable", ipaddr=ipaddr) ret['data'] = "节点升级服务连接失败" ret['ipaddr'] = ipaddr return ret return body
def get_memory_info(self): try: resp = errcode.get_error_result() utc = int((dt.datetime.utcnow() - dt.datetime.utcfromtimestamp(0)).total_seconds()) resp['utc'] = utc mem_info = psutil.virtual_memory() resp['total'] = mem_info.total resp['available'] = mem_info.available resp['utilization'] = mem_info.percent # insert redis """ if self.rds.ping_server(): node_key = '{}:memory_info:{}'.format(self.ip, self.now_date) insert_data = resp.copy() insert_data.pop('code') insert_data.pop('msg') if self.rds.exists(node_key): self.rds.zadd(node_key, {json.dumps(insert_data): utc}) else: self.rds.zadd(node_key, {json.dumps(insert_data): utc}) self.rds.expire(node_key, self.rds.live_seconds) # 86400 seconds of a day """ return resp except Exception as err: logger.error(err) logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="GetMemoryInfoFailure") return resp
def update_voi_desktop(self, data): """ :param data: { "uuid": "", "value": { "name": "", ... } } :return: """ desktop_uuid = data.get('uuid', '') desktop = db_api.get_item_with_first(models.YzyVoiDesktop, {"uuid": desktop_uuid}) if not desktop: logger.error("desktop %s not exist", desktop_uuid) return get_error_result("DesktopNotExist", name="") try: if data['value'].get('ip_detail'): data['value']['ip_detail'] = json.dumps(data['value']['ip_detail']) else: data['value']['ip_detail'] = '' desktop.update(data['value']) desktop.soft_update() terminal_desktop_binds = db_api.get_item_with_all(models.YzyVoiTerminalToDesktops, {"desktop_group_uuid": desktop_uuid}) for bind in terminal_desktop_binds: bind.soft_delete() logger.info("update voi desktop, clear terminal desktop bind success!!") except Exception as e: logger.error("update voi desktop %s failed:%s", desktop_uuid, e, exc_info=True) return get_error_result("DesktopUpdateFail", name=desktop.name) logger.info("update voi desktop %s success", desktop_uuid) return get_error_result("Success")
def get_networkio_info(self): try: resp = errcode.get_error_result() utc = int((dt.datetime.utcnow() - dt.datetime.utcfromtimestamp(0)).total_seconds()) resp['utc'] = utc nics_io = psutil.net_io_counters(pernic=True) virtual_net_device = os.listdir('/sys/devices/virtual/net/') physical_net_device = [ dev for dev in nics_io if dev not in virtual_net_device ] for nic in physical_net_device: resp[nic] = { 'bytes_send': nics_io[nic].bytes_sent, 'bytes_recv': nics_io[nic].bytes_recv } # insert redis """ if self.rds.ping_server(): node_key = '{}:networkio_info:{}'.format(self.ip, self.now_date) insert_data = resp.copy() insert_data.pop('code') insert_data.pop('msg') if self.rds.exists(node_key): self.rds.zadd(node_key, {json.dumps(insert_data): utc}) else: self.rds.zadd(node_key, {json.dumps(insert_data): utc}) self.rds.expire(node_key, self.rds.live_seconds) # 86400 seconds of a day """ return resp except Exception as err: logger.error(err) logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="GetNetworkIoInfoFailure") return resp
def _check_term_duplicate(self, start, end, exclued_uuid=""): """ 校验新学期期间是否与已有学期重叠 :param start: "2020/09/01" :param end: "2021/02/01" :param exclued_uuid: 排除学期的uuid :return: """ try: exsit_term_obj_list = db_api.get_term_with_all({}) if exsit_term_obj_list: new_start = datetime.strptime(start, '%Y/%m/%d').date() new_end = datetime.strptime(end, '%Y/%m/%d').date() for exsit_term_obj in exsit_term_obj_list: if exsit_term_obj.uuid != exclued_uuid: exist_start = datetime.strptime( exsit_term_obj.start, '%Y/%m/%d').date() exist_end = datetime.strptime(exsit_term_obj.end, '%Y/%m/%d').date() if exist_start <= new_end and new_start <= exist_end: return get_error_result("TermDuplicateError", name=exsit_term_obj.name) return None except Exception as e: logger.exception("_check_term_duplicate failed: %s" % str(e), exc_info=True) return get_error_result("OtherError")
def get_hardware_info(): try: resp = errcode.get_error_result() #ip_info = get_ip_info() resp['data'] = {} utc = int((dt.datetime.utcnow() - dt.datetime.utcfromtimestamp(0)).total_seconds()) resp['data']['utc'] = utc resp['data']['server_version'] = get_server_version() hardware_type_list = ['disk', 'gfxcard'] for hardware_type in hardware_type_list: cmd = 'hwinfo --{}|grep \"Model\"'.format(hardware_type) hardware_model = os.popen(cmd).readlines() if type(hardware_model) is list: hardware_model = [x.split('\"')[1] for x in hardware_model] resp['data'][hardware_type] = dict(Counter(hardware_model)) elif type(hardware_model) is str: hardware_model = hardware_model.split('\"')[1][:-1] resp['data'][hardware_type] = {hardware_model: 1} hardware_type_list = ['cpu', 'memory'] info = get_profile() resp['data']['cpu'] = dict(Counter(get_device_info(info, "cpu"))) # resp['data']['memory'] = dict(Counter(get_device_info(info, "memory"))) resp['data']['memory'] = get_device_info(info, "memory") return resp except Exception as err: current_app.logger.error(err) current_app.logger.error(''.join(traceback.format_exc())) resp = errcode.get_error_result(error="GetHardwareInfoFailure") return resp
def delete(self, data): """ 删除指定学期、教学分组下的所有课表 :param data: { "term_uuid": "062d6d14-97c1-448d-a9fb-67367fdf843b", "group_uuid": "41b212d6-3ef4-49f1-851d-424cb4559261" } :return: """ try: logger.info("data: %s" % data) term_uuid = data.get("term_uuid", None) group_uuid = data.get("group_uuid", None) if not term_uuid or not group_uuid: return get_error_result("ParamError") if not db_api.get_term_with_first({"uuid": term_uuid}): return get_error_result("TermNotExist") if not db_api.get_group_with_first({"uuid": group_uuid}): return get_error_result("EduGroupNotExist") template_uuids = db_api.get_distinct_course_template_uuids_by_course_schedule( { "term_uuid": term_uuid, "group_uuid": group_uuid }) template_uuids = [tuple_[0] for tuple_ in template_uuids] ds_ret = db_api.delete_course_schedule_many({ "term_uuid": term_uuid, "group_uuid": group_uuid }) logger.info( "delete many[%s] in yzy_course_schedule success where term_uuid[%s] group_uuid[%s] " % (ds_ret, term_uuid, group_uuid)) dt_ret = db_api.delete_course_template_many_by_uuids( template_uuids) logger.info( "delete many[%s] in yzy_course_template success where uuid in [%s]" % (dt_ret, template_uuids)) dc_ret = db_api.delete_course_many_by_course_template_uuids( template_uuids) logger.info( "delete many[%s] in yzy_course success where course_template_uuid in [%s]" % (dc_ret, template_uuids)) return get_error_result() except Exception as e: logger.exception("delete course_schedule failed: %s" % str(e), exc_info=True) return get_error_result("OtherError")
def inactive_voi_desktop(self, desktop_uuid): desktop = db_api.get_item_with_first(models.YzyVoiDesktop, {'uuid': desktop_uuid}) if not desktop: logger.error("desktop %s not exist", desktop_uuid) return get_error_result("DesktopNotExist", name="") desktop.active = False desktop.soft_update() logger.info("inactive voi desktop %s success", desktop.name) return get_error_result("Success")
def disable(self, data): """ 禁用指定学期、教学分组下的所有课表 :param data: { "term_uuid": "062d6d14-97c1-448d-a9fb-67367fdf843b", "group_uuid": "41b212d6-3ef4-49f1-851d-424cb4559261" } :return: """ try: logger.info("data: %s" % data) term_uuid = data.get("term_uuid", None) group_uuid = data.get("group_uuid", None) if not term_uuid or not group_uuid: return get_error_result( "ParamError", data={"keys": ["term_uuid", "group_uuid"]}) term_obj = db_api.get_term_with_first({"uuid": term_uuid}) if not term_obj: return get_error_result("TermNotExist") if not db_api.get_group_with_first({"uuid": group_uuid}): return get_error_result("EduGroupNotExist") # 更新该学期的group_status_map字段(保存了教学桌面组的课表启用状态) group_status_map = json.loads(term_obj.group_status_map) if group_status_map.get( group_uuid, None) != constants.COURSE_SCHEDULE_DISABLED: group_status_map[ group_uuid] = constants.COURSE_SCHEDULE_DISABLED term_obj.update( {"group_status_map": json.dumps(group_status_map)}) logger.info( "update uuid[%s] in yzy_term success : {'group_status_map': {'%s': %s}}" % (term_uuid, group_uuid, constants.COURSE_SCHEDULE_DISABLED)) # 找出该学期、该教学分组下的所有课表,标记为禁用 ret = db_api.update_course_schedule_many( value_dict={"status": constants.COURSE_SCHEDULE_DISABLED}, item={ "term_uuid": term_uuid, "group_uuid": group_uuid }) logger.info( "update many[%s] in yzy_course_schedule success where term_uuid[%s], group_uuid[%s]: {'status': %s}" % (ret, term_uuid, group_uuid, constants.COURSE_SCHEDULE_DISABLED)) return get_error_result() except Exception as e: logger.exception("disable course_schedule failed: %s" % str(e), exc_info=True) return get_error_result("OtherError")