def get_image_list(request):
try:
res_list = []
data = ImageAction().list_image()
dont_show_list = api_settings.DONT_SHOW['image_list']
for da in data:
if da.name not in dont_show_list:
if da.size:
size = proc_size(da.size)
else:
size = ''
image_type = ''
if da.container_format == 'docker':
image_type = 'docker'
else:
image_type = da.container_format
res_dict = {
'id': da.id,
'status': da.status,
'name': da.name,
'size': da.size,
'created_at': da.created_at,
'image_format': da.disk_format,
'image_size': size,
'image_type': image_type,
}
res_list.append(res_dict)
except Exception as e:
raise e
return list_view(request, res_list, serializers.ImageListSerializer)
def http_get_task_event_by_type(request):
if request.method == 'GET':
if request.user.is_superuser:
auth_classes = None
else:
auth_classes = request.user.classes
typeId = request.query_params['type_id']
event_list = get_task_event_by_type(typeId, auth_classes=auth_classes)
return list_view(request, event_list, TaskEventSerializer)
def get_fwaas_group_detail_by_id(request):
try:
id = request.GET.get('id', None)
res_list = []
if not id or id == '|':
return Response(None)
id_list = id.split('|')
index = 1
for item in id_list:
if item != 'null' and item != None:
data = NetworkAction().get_firewall_policy(item)
rules_list = data.get('firewall_rules', None)
if rules_list:
for rule_id in rules_list:
rule_dict = NetworkAction().get_firewall_rule(rule_id)
if index == 1:
type = 'ingress'
else:
type = 'engress'
res_dict = {
'id':
rule_dict.get('id', None),
'description':
rule_dict.get('description', None),
'name':
rule_dict.get('name', None),
'protocol':
rule_dict.get('protocol', None),
'shared':
rule_dict.get('shared', None),
'enabled':
rule_dict.get('enabled', None),
'action':
rule_dict.get('action', None),
'type':
type,
'source_ip_address':
rule_dict.get('source_ip_address', 'All'),
'destination_ip_address':
rule_dict.get('destination_ip_address', 'All'),
'destination_port':
rule_dict.get('destination_port', 'All'),
'source_port':
rule_dict.get('source_port', 'All'),
}
res_list.append(res_dict)
index = index + 1
except Exception as e:
raise e
return list_view(request, res_list, serializers.FwaasRuleListSerializer)
def get_docker_server_list(request):
try:
data = ContainerAction().list_container()
res_list = []
_attrs = [
'uuid', 'name', 'command', 'image', 'status', 'ports', 'host'
]
for docker in data:
create_user = ''
# get docker instance networks
docker_net_list = docker.addresses.values()
address_list = []
if docker_net_list:
for net_list in docker_net_list:
# get one of network ips
address_str = ''
for net in net_list:
address_str = address_str + ' ' + net['addr']
address_list.append(address_str)
try:
env_docker = env_models.EnvTerminal.objects.filter(
vm_id=docker.uuid).first()
if env_docker is not None:
create_user = env_docker.env.user.first_name
else:
env_docker = env_models.StandardDeviceEditServer.objects.filter(
tmp_docker_id=docker.uuid).first()
if env_docker is not None:
create_user = env_docker.create_user.first_name
else:
create_user = ''
except Exception as e:
create_user = ''
res_dict = to_dict(docker, _attrs)
res_dict['id'] = res_dict['uuid']
res_dict['address_list'] = address_list
res_dict['create_user'] = create_user
res_list.append(res_dict)
except Exception as e:
raise e
local_dockers = get_local_dockers()
if local_dockers:
res_list.extend(local_dockers)
return list_view(request, res_list, serializers.DockerListSerializer)
def django_list_log(self, request):
if request.method == 'GET':
logs = logset.get_log_file_list()
return list_view(request, logs, RunLogSerializer)
elif request.method == 'POST':
log_level = self.shift_data.get('log_level', int)
log_size = self.shift_data.get('log_size', int)
log_count = self.shift_data.get('log_count', int)
logset.set_loging_param(log_level, log_size, log_count)
self.update_db(log_level, log_size, log_count)
# self.update_db()
return response.Response({'action': 'ok'})
def online_user_monitor(request):
online_list = []
for obj in User.objects.all():
if obj.report_time:
critical_time = timezone.now() - datetime.timedelta(seconds=auth_api_settings.OFFLINE_TIME)
if obj.report_time >= critical_time:
online_list.append(obj)
user_queryset = User.objects.filter(id__in=[user.id for user in online_list])
user_list = user_queryset.values('id', 'username', 'first_name', 'classes__name', 'faculty__name', 'major__name', 'total_online_time')
for user in user_list:
user['action'], user['learn_object'] = get_recent_action(user['id'])
user['monitor'], user['lesson_id'] = judge_monitor(user['id'])
# rows = [OnlineUserSerializer(row).data for row in user_list]
# return JsonResponse({"total": len(rows), "rows": rows})
return list_view(request, user_list, OnlineUserSerializer)
def get_router_list(request):
try:
res_list = []
data = NetworkAction().list_router()
for da in data:
res_dict = {
'id': da.get('id', None),
'status': da.get('status', None),
'name': da.get('name', None),
'created_at': da.get('created_at', None),
}
res_list.append(res_dict)
except Exception as e:
raise e
return list_view(request, res_list, serializers.RouterListSerializer)
def get_float_ip_list(request):
try:
res_list = []
data = NetworkAction().list_floating_ip()
# floating_list = data['floatingips']
for da in data:
res_dict = {
'id': da.get('id', None),
'status': da.get('status', None),
'created_at': da.get('created_at', None),
'fixed_ip_address': da.get('fixed_ip_address', None),
'floating_ip_address': da.get('floating_ip_address', None),
}
res_list.append(res_dict)
except Exception as e:
raise e
return list_view(request, res_list, serializers.FloatIpListSerializer)
def task_list(request):
if request.method == 'GET':
p_type = int(request.query_params.get('type_id', None))
if p_type is None:
return response.Response(constant.ILLEGAL_REQUEST_PARAMETERS,
status=status.HTTP_200_OK)
category = request.query_params.get('category', None)
event = int(request.query_params.get('event', None))
task_list = get_task_list(p_type=p_type,
event=event,
category=category)
taskSerializer = get_task_serializer(p_type)
if taskSerializer:
if task_list:
return list_view(request, task_list, taskSerializer)
else:
return response.Response(constant.ILLEGAL_REQUEST_PARAMETERS,
status=status.HTTP_200_OK)
else:
return response.Response(constant.ILLEGAL_REQUEST_PARAMETERS,
status=status.HTTP_200_OK)
def get_fwaas_group_list(request):
try:
res_list = []
data = NetworkAction().list_firewall()
for da in data:
ingress_policy_id = da.get('ingress_firewall_policy_id', '')
egress_policy_id = da.get('egress_firewall_policy_id', '')
res_ingress_policy_name = ''
res_egress_policy_name = ''
if ingress_policy_id:
res_ingress_policy = NetworkAction().get_firewall_policy(
ingress_policy_id)
res_ingress_policy_name = res_ingress_policy.get('name', '')
else:
res_ingress_policy_name = ''
if egress_policy_id:
res_egress_policy = NetworkAction().get_firewall_policy(
egress_policy_id)
res_egress_policy_name = res_egress_policy.get('name', '')
else:
res_egress_policy_name = ''
res_dict = {
'id': da.get('id', None),
'status': da.get('status', None),
'name': da.get('name', None),
'description': da.get('description', None),
'ingress_name': res_ingress_policy_name,
'engress_name': res_egress_policy_name,
'ingress_id': ingress_policy_id,
'engress_id': egress_policy_id,
}
res_list.append(res_dict)
except Exception as e:
raise e
return list_view(request, res_list, serializers.FwaasGroupListSerializer)
def get_network_list(request):
try:
res_list = []
# get all network
if settings.PLATFORM_TYPE == 'ALL':
data = NetworkAction().list_network_by_name('XOJ')
data.extend(NetworkAction().list_network_by_name('XAD'))
else:
data = NetworkAction().list_network_by_name('X' +
settings.PLATFORM_TYPE)
# get all subnet
subnet_all = NetworkAction().list_subnet()
for da in data:
res_sub_list = []
network_id = da.get('id', int)
# subnet_list = NetworkAction().get_subnet_by_network_id(network_id)
# get all subnet under this network
for subnet in subnet_all:
if subnet['network_id'] == network_id:
res_sub_list.append(subnet)
res_dict = {
'id': da.get('id', None),
'status': da.get('status', None),
'net_name': da.get('name', None),
'created_at': da.get('created_at', None),
'subnets': res_sub_list,
'router:external': da.get('router:external', None),
'provider:network_type': da.get('provider:network_type', None),
}
res_list.append(res_dict)
except Exception as e:
raise e
return list_view(request, res_list, serializers.NetListSerializer)
def get_fwaas_rules_list(request):
try:
res_list = []
data = NetworkAction().list_firewall_rule()
for da in data:
res_dict = {
'id': da.get('id', None),
'action': da.get('action', None),
'name': da.get('name', None),
'description': da.get('description', None),
'protocol': da.get('protocol', None),
'enabled': da.get('enabled', None),
'source_ip': da.get('source_ip_address', None),
'destination_ip': da.get('destination_ip_address', None),
'source_port': da.get('source_port', None),
'destination_port': da.get('destination_port', None),
}
res_list.append(res_dict)
except Exception as e:
raise e
return list_view(request, res_list, serializers.FwaasRuleListSerializer)
container_count += 1
if hyper.hypervisor_hostname.startswith("controller"):
from common_scene.cms.views import get_local_dockers
local_containers_count = len(get_local_dockers())
hyper_dict = Hypervisor(hyper).to_dict()
hyper_dict['container_count'] = container_count + local_containers_count
hyper_dict['vcpus_percent'] = round(hyper.vcpus_percent * 100)
hyper_dict['ram_percent'] = round(hyper.ram_percent * 100)
hyper_dict['disk_percent'] = round(hyper.disk_percent * 100)
hyperv_list.append(hyper_dict)
hyper_count = len(hypers)
except Exception, e:
raise e
return list_view(request, hyperv_list, hyperListSerializer)
def platform_stats(request):
now = datetime.datetime.now()
user_reg_statistic = []
team_reg_statistic = []
event_answered_statistic = []
course_learned_statistic = []
practise_studyed_statistic = []
x_axis = []
for i in range(30)[::-1]:
n_day = now - datetime.timedelta(days=i)
x_axis.append(n_day.strftime('%Y-%m-%d'))
n_day_start = datetime.datetime.strptime(n_day.strftime('%Y-%m-%d 00:00:00'), '%Y-%m-%d %H:%M:%S')
n_day_end = datetime.datetime.strptime(n_day.strftime('%Y-%m-%d 23:59:59'), '%Y-%m-%d %H:%M:%S')
def get_instance_list(request):
try:
if settings.PLATFORM_TYPE == 'ALL':
data = InstanceAction().get_instance_list_by_name('XOJ')
data.extend(InstanceAction().get_instance_list_by_name('XAD'))
else:
data = InstanceAction().get_instance_list_by_name(
'X' + settings.PLATFORM_TYPE)
res_list = []
if not len(data) == 0:
for instance in data:
try:
env_instance = env_models.EnvTerminal.objects.filter(
vm_id=instance.id).first()
if env_instance is not None:
create_user = env_instance.env.user.first_name
else:
env_instance = env_models.StandardDeviceEditServer.objects.filter(
tmp_vm_id=instance.id).first()
if env_instance is not None:
create_user = env_instance.create_user.first_name
else:
create_user = ''
except Exception as e:
create_user = ''
networks_contain = hasattr(instance, 'networks')
if networks_contain:
network_list = instance.networks
if network_list:
for key in network_list:
address = " ".join(
instance.networks.get(key, None))
else:
address = ''
else:
address = ''
node = instance._info.get('OS-EXT-SRV-ATTR:host', 'None')
res_dict = {
'id': instance.id,
'status': instance.status,
'name': instance.name,
'server_ip': address,
'create_time': instance.created,
'node': node,
'create_user': create_user,
}
image_id = instance.image.get('id', None)
if image_id:
# image = ImageAction().get_image(id=image_id)
# image_name = image.name
image_name = None
else:
image_name = None
res_dict['server_image'] = image_name
res_list.append(res_dict)
except Exception as e:
raise e
return list_view(request, res_list, serializers.InstanceListSerializer)
def get_ask(self, request):
queryset = self.queryset
states = self.request.query_params['states']
states = int(states)
user = request.user
queryset = queryset.filter(username=user)
queryset = queryset.filter(parent__isnull=states)
# total = len(queryset)
ask_list = []
for row in queryset:
resource = row.resource
category = resource.split(".")[1]
title = ''
# 页面跳转链接
resource_url = ''
if category == "course" and settings.PLATFORM_TYPE != 'AD':
from course.models import Course
result = Course.objects.filter(hash=resource)
for task in result:
title = task.name
resource_url = reverse('course:detail', args=(task.id, ))
elif category == "tool" and settings.PLATFORM_TYPE != 'OJ':
from x_tools.models import Tool
result = Tool.objects.filter(hash=resource)
for task in result:
title = task.name
resource_url = reverse('x_tools:detail', args=(task.id, ))
elif category == "lesson" and settings.PLATFORM_TYPE != "AD":
from course.models import Lesson
result = Lesson.objects.filter(hash=resource)
for task in result:
title = task.name
resource_url = reverse(
'course:markdown_new') + "?" + urllib.urlencode(
{
'course_screen': 'one_screen',
'lesson_id': task.id
})
else:
if settings.PLATFORM_TYPE != "AD":
if len(RealVulnTask.objects.filter(hash=resource)) != 0:
result = RealVulnTask.objects.filter(hash=resource)
for task in result:
title = task.title
if title == [] or title == None:
title = task.theme_name
resource_url = reverse('practice:defensetraintask',
args=(category, resource))
elif len(PracticeExerciseTask.objects.filter(
hash=resource)) != 0:
result = PracticeExerciseTask.objects.filter(
hash=resource)
for task in result:
title = task.title
if title == [] or title == None:
title = task.theme_name
resource_url = reverse('practice:defensetraintask',
args=(category, resource))
ask_dict = {
'id': row.id,
'title': title,
'comment': row.comment,
'last_update': row.update_time,
'resource_url': resource_url
}
ask_list.append(ask_dict)
return list_view(request, ask_list, CommentListViewSerializer)
