def sync_init(app_name):
app_module = import_module(app_name)
if hasattr(app_module, 'sync_init'):
app_module.sync_init()
if hasattr(app_module, 'async_init'):
async_exe(app_module.async_init)
if hasattr(app_module, 'async_global_init'):
async_exe_once(app_module.async_global_init)
def save_related_mission(mission, data, update=False):
if mission.type in [constant.Type.CTF, constant.Type.CHECK]:
save_ctf_or_check_mission(mission, data, update=update)
elif mission.type == constant.Type.EXAM:
create_update_tasks(mission, data)
if mission.type == constant.Type.CHECK:
async_exe(mission_copy_file, (mission, data,), delay=0)
def stop_mission_check(self):
logger.debug("[start_mission_check]: stop mission check")
if self.cr_scene:
missions = self.cr_scene.missions.filter(type=MissionType.CHECK)
async_exe(self._handle_scene_mission_check,
(self.ActionType.STOP, missions),
delay=2)
else:
logger.error("[stop_mission_check]cr_scene is None or Invalid.")
def sub_perform_update(self, serializer):
check_operate_permission(self.request.user, serializer.instance)
instance = serializer.instance
validated_data = serializer.validated_data
name = validated_data.get('name')
is_terminal_mode = self._terminal_mode(validated_data, instance)
is_real = (('is_real' in validated_data
and validated_data.get('is_real'))
or ('is_real' not in validated_data and instance.is_real))
if is_terminal_mode and not is_real and name and name != instance.name:
async_exe(cloud.image.update,
kwargs={
'image_name': instance.name,
'name': name
})
upload_mode = (is_terminal_mode
and not (validated_data.get('source_image_name')
or instance.source_image_name) and not is_real)
if upload_mode:
if StandardDeviceSnapshot.objects.filter(
standard_device=instance).exists():
raise exceptions.PermissionDenied(error.SNAPSHOT_BAN_UPLOAD)
self._check_upload_image(
validated_data.get('name') or instance.name,
validated_data.get('disk_format') or instance.disk_format,
)
# 待更新元数据
old_meta_data = serializer.instance.meta_data
new_meta_data = validated_data.get('meta_data')
else:
# 非上传模式无元数据
validated_data['meta_data'] = None
serializer.save(
modify_time=timezone.now(),
modify_user=self.request.user,
)
if upload_mode:
meta_data_str = new_meta_data or old_meta_data
meta_data = json.loads(meta_data_str) if meta_data_str else None
result = self._try_upload_image(
validated_data.get('name') or instance.name,
validated_data.get('image_type') or instance.image_type,
validated_data.get('disk_format') or instance.disk_format,
meta_data)
# 未上传则更新元数据
if not result and new_meta_data and new_meta_data != old_meta_data:
cloud.image.update(image_name=serializer.instance.name,
partial_update=False,
**json.loads(new_meta_data))
return True
def manual_stop_mission_check(self, mission_id):
logger.debug("[start_mission_check]: manual stop mission check")
if self.cr_scene:
missions = self.cr_scene.missions.filter(type=MissionType.CHECK,
id=mission_id)
else:
missions = mission_models.Mission.objects.filter(id=mission_id)
async_exe(self._handle_scene_mission_check,
(self.ActionType.STOP, missions),
delay=2)
def manual_start_mission_check(self, mission_id):
logger.debug("[start_mission_check]: manual start mission check")
if self.cr_scene:
missions = self.cr_scene.missions.filter(type=MissionType.CHECK,
id=mission_id)
async_exe(self._handle_scene_mission_check,
(self.ActionType.START, missions),
delay=2)
else:
logger.error(
"[manual_start_mission_check]cr_scene is None or Invalid.")
def delete(self):
device = self.device
if device.image_scene:
self.delete_image_scene(save=False)
async_exe(cloud.image.delete, kwargs={'image_name': device.name})
if device.image_type == StandardDevice.ImageType.VM:
async_exe(cloud.image.operator.scene_delete_img_with_disk,
kwargs={'image_name': device.name})
device.name = device.name + rk()
device.status = StandardDevice.Status.DELETE
device.save()
def sync_init(app_name):
app_module = import_module(app_name)
if hasattr(app_module, 'sync_init'):
app_module.sync_init()
if hasattr(app_module, 'async_init'):
async_exe(app_module.async_init)
if hasattr(app_module, 'async_global_init'):
async_exe_once(app_module.async_global_init)
resource_name = '{app_name}.resources'.format(
app_name=app_name,
)
resource_path = os.path.join(settings.BASE_DIR, resource_name.replace('.', '/') + '.py')
if os.path.exists(resource_path):
import_module(resource_name)
def recording_convert(request):
host_ip = request.shift_data.get('host_ip')
convert_key = request.shift_data.get('convert_key')
convert_params = json.loads(
request.shift_data.get('convert_params') or '{}')
recording_name = request.shift_data.get('recording_name')
screen_size = request.shift_data.get('screen_size') or '1366x768'
if not convert_key or not recording_name or not isinstance(
convert_params, dict):
raise PermissionDenied()
convert_func = app_settings.RECORDING_CONVERT_CALLBACK.get(convert_key)
if not convert_func:
raise PermissionDenied()
def tmp_task():
remote_manager = RemoteManager(host=host_ip)
callback_script = ''
if host_ip and host_ip != app_settings.OJ_SERVER['host_ip']:
executor = {
'func': delay_convert_callback,
'params': {
'recording_name': recording_name,
'screen_size': screen_size,
'convert_func': convert_func,
'convert_params': convert_params,
}
}
condition = Executor.dump_executor(executor)
task = Executor.objects.filter(**condition).first()
if not task:
task = Executor.objects.create(extra=executor.get('extra', ''),
**condition)
callback_url = settings.SERVER + reverse(
'api:public:base_remote:recording_convert_over', (task.id, ))
callback_script = 'curl {callback_url}'.format(
callback_url=callback_url)
video_names = remote_manager.convert_recording(
recording_name,
screen_size=screen_size,
callback_script=callback_script)
convert_func(video_names, screen_size, **convert_params)
async_exe(tmp_task)
return Response({})
def _cr_scene_instance_status_updated(user_id, cr_scene_id, *args, **kwargs):
CrSceneViewSet.clear_self_cache()
event = kwargs.get('event', SceneStatusUpdateEvent.SCENE_CREATE)
status = kwargs.get('status')
scene_id = kwargs.get('scene_id')
if scene_id:
if status == Scene.Status.RUNNING:
if event == SceneStatusUpdateEvent.SCENE_CREATE:
# 场景创建完成
logger.info('cr scene created')
# 流量发生开始
SceneTrafficManager(
scene_id, cr_scene_id=cr_scene_id).start_traffic_event()
# 检测任务开始
SceneMissionManager(scene_id, False).start_mission_check()
elif status == Scene.Status.DELETED:
# 删除流量
SceneTrafficManager(scene_id,
cr_scene_id=cr_scene_id).stop_traffic_event()
# 删除检测任务
SceneMissionManager(cr_scene_id, False).stop_mission_check()
scene_consumers.SceneWebsocket.scene_status_update(user_id, scene_id)
scene_net_id = kwargs.get('scene_net_id')
if scene_net_id:
scene_consumers.SceneWebsocket.scene_net_status_update(
user_id, scene_net_id)
scene_terminal_id = kwargs.get('scene_terminal_id')
if scene_terminal_id:
if status == SceneTerminal.Status.RUNNING:
if event == SceneStatusUpdateEvent.SCENE_CREATE:
# 机器创建完成
# report_sys_info(cr_scene_id, scene_terminal_id)
from base.utils.thread import async_exe
async_exe(report_sys_info, (cr_scene_id, scene_terminal_id),
delay=1)
scene_consumers.SceneWebsocket.scene_terminal_status_update(
user_id, scene_terminal_id)
def create(self, image_name, vm_id=None, container_id=None, image_file=None,
ftp_file_name=None, meta_data=None, created=None, failed=None):
check_type = 'Image'
if vm_id:
image_id = self.operator.create_snapshot(vm_id, image_name)
image = self.get(image_id=image_id)
bdm = getattr(image, 'block_device_mapping', None)
if bdm:
try:
block_snap_id = json.loads(bdm)[0].get("snapshot_id")
self.operator.check_volume_snapshot_status(block_snap_id)
except Exception:
pass
else:
image = self.operator.check_image_status(image_id)
check_type = 'Snapshot'
elif container_id:
image = self.operator.save_image(container_id, image_name)
elif image_file:
params = {
'name': image_name,
'image_file': image_file,
}
if meta_data:
params.update(meta_data)
image = self.operator.create_image(**params)
elif ftp_file_name:
params = {
'name': image_name,
'file_name': ftp_file_name,
}
if meta_data:
params.update(meta_data)
image = self.operator.create_image_by_ftp(**params)
else:
raise Exception('param error: no resource for creating image')
if created or failed:
async_exe(self.operator.check_image_status, (image.id, check_type, created, failed))
return image
def _run(self, script, script_client, **kwargs):
self.logger.info(
"Mission[%s]: The parameter check is completed， Agent check start",
self.content.get("title"))
if script.split(".")[-1] == "py":
is_run = script_client.agent_python_check(**kwargs)
else:
is_run = script_client.agent_shell_check(**kwargs)
if is_run:
self.mission_connect_cache.blank_cache(
) # cache set to 0 when the connection is successful
record_status_information(self.content.get("id"),
"Agent check is running",
constant.MissionStatus.ISPROCESS)
self.logger.info("Mission[%s]: Agent check is running",
self.content.get("title"))
else:
mission_connect_number = self.mission_connect_cache.set_frequency_cache(
) # Connect failed,set cache
if mission_connect_number <= MAX_BUMBER_ATTEMPTS:
self.logger.info("Mission[%s]: Agent check unable to connect",
self.content.get("title"))
mission = Mission.objects.filter(
id=self.content.get("id")).first()
mission_status = mission.mission_status
if mission_status != MissionStatus.STOP:
async_exe(start_checker, (self.content, self.logger),
delay=1)
else:
record_status_information(
self.content.get("id"), "Agent has stopped connecting,"
" because the number of attempts to connect has reached the maximum",
constant.MissionStatus.DOWN)
self.logger.info(
"Mission[%s]: Agent has stopped connecting,"
"because the number of attempts to connect has reached the maximum",
self.content.get("title"))
def image(self, request, pk=None):
device = self.get_object()
check_operate_permission(request.user, device)
if request.method == 'POST':
if not device.image_scene:
raise exceptions.ValidationError(error.DEVICE_NO_SCENE)
if device.image_status == StandardDevice.ImageStatus.CREATING:
raise exceptions.ValidationError(error.IMAGE_SAVING)
device.image_status = StandardDevice.ImageStatus.CREATING
device.save()
self.clear_cache()
mconsumers.StandardDeviceWebsocket.image_status_update(
request.user, device.pk)
name = self.shift_data.get('name')
desc = self.shift_data.get('desc')
name = '{}__$__{}'.format(name, rk())
def created(image):
StandardDeviceSnapshot.objects.create(standard_device=device,
name=name,
desc=desc)
self.clear_cache()
mconsumers.StandardDeviceWebsocket.image_status_update(
request.user, device.pk)
def failed(error):
self.clear_cache()
mconsumers.StandardDeviceWebsocket.image_status_update(
request.user, device.pk)
handler = DeviceHandler(request.user, device=device)
async_exe(handler.create_image, (name, created, failed))
return Response(status=status.HTTP_201_CREATED)
def exe_sync_attack(self, request):
async_exe(self.test_simulated_attack, args=(request, ), delay=10)
def _wrapper(*args, **kwargs):
if status_updated:
async_exe(status_updated, args=args, kwargs=kwargs)
