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")
