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)