def begin_request_soud_sync(server, user): """ Enqueue a task to request this SoUD to be synced with a server """ info = get_device_info() if not info["subset_of_users_device"]: # this does not make sense unless this is a SoUD logger.warn("Only Subsets of Users Devices can do this") return queue.enqueue(request_soud_sync, server, user)
def startdiskexport(self, request): """ Export a channel to a local drive, and copy content to the drive. """ task = validate_local_export_task(request, request.data) task.update({"type": "DISKCONTENTEXPORT"}) task_id = queue.enqueue( _localexport, task["channel_id"], task["drive_id"], track_progress=True, cancellable=True, node_ids=task["node_ids"], exclude_node_ids=task["exclude_node_ids"], extra_metadata=task, ) # attempt to get the created Task, otherwise return pending status resp = _job_to_response(queue.fetch_job(task_id)) return Response(resp)
def startdiskbulkexport(self, request): if not isinstance(request.data, list): raise serializers.ValidationError( "POST data must be a list of task descriptions") tasks = map(partial(validate_local_export_task, request), request.data) job_ids = [] for task in tasks: task.update({"type": "DISKEXPORT"}) export_job_id = queue.enqueue( _localexport, task["channel_id"], task["drive_id"], track_progress=True, cancellable=True, extra_metadata=task, ) job_ids.append(export_job_id) resp = [ _job_to_response(queue.fetch_job(job_id)) for job_id in job_ids ] return Response(resp)
def startdeletechannel(self, request): """ Delete a channel and all its associated content from the server """ task = validate_deletion_task(request, request.data) task.update({"type": "DELETECONTENT"}) if task["node_ids"] or task["exclude_node_ids"]: task["file_size"] = None task["total_resources"] = None task_id = queue.enqueue( call_command, "deletecontent", task["channel_id"], node_ids=task["node_ids"], exclude_node_ids=task["exclude_node_ids"], force_delete=task["force_delete"], track_progress=True, extra_metadata=task, ) # attempt to get the created Task, otherwise return pending status resp = _job_to_response(queue.fetch_job(task_id)) return Response(resp)
def startbulkdelete(self, request): if not isinstance(request.data, list): raise serializers.ValidationError( "POST data must be a list of task descriptions") tasks = map(partial(validate_deletion_task, request), request.data) job_ids = [] for task in tasks: task.update({"type": "DELETECHANNEL"}) if task["node_ids"] or task["exclude_node_ids"]: task["file_size"] = None task["total_resources"] = None delete_job_id = queue.enqueue( call_command, "deletecontent", task["channel_id"], track_progress=True, extra_metadata=task, ) job_ids.append(delete_job_id) resp = [ _job_to_response(queue.fetch_job(job_id)) for job_id in job_ids ] return Response(resp)
def startremotebulkimport(self, request): if not isinstance(request.data, list): raise serializers.ValidationError( "POST data must be a list of task descriptions") tasks = map(partial(validate_remote_import_task, request), request.data) job_ids = [] for task in tasks: task.update({"type": "REMOTEIMPORT"}) import_job_id = queue.enqueue( _remoteimport, task["channel_id"], task["baseurl"], extra_metadata=task, cancellable=True, ) job_ids.append(import_job_id) resp = [ _job_to_response(queue.fetch_job(job_id)) for job_id in job_ids ] return Response(resp)
def startpeerfacilitysync(server, user_id): """ Initiate a SYNC (PULL + PUSH) of a specific facility from another device. """ user = FacilityUser.objects.get(pk=user_id) facility_id = user.facility.id device_info = get_device_info() extra_metadata = prepare_sync_task( facility_id, user_id, user.username, user.facility.name, device_info["device_name"], device_info["instance_id"], server, type="SYNCPEER/FULL", ) job_data = prepare_peer_sync_job(server, facility_id, user.username, user.password, extra_metadata=extra_metadata) job_id = queue.enqueue(call_command, "sync", **job_data) return job_id
def startchannelupdate(self, request): sourcetype = request.data.pop("sourcetype", None) new_version = request.data.pop("new_version", None) if sourcetype == "remote": task = validate_remote_import_task(request, request.data) task.update({"type": "UPDATECHANNEL", "new_version": new_version}) job_id = queue.enqueue( _remoteimport, task["channel_id"], task["baseurl"], peer_id=task["peer_id"], node_ids=task["node_ids"], is_updating=True, extra_metadata=task, track_progress=True, cancellable=True, ) elif sourcetype == "local": task = validate_local_import_task(request, request.data) task.update({"type": "UPDATECHANNEL", "new_version": new_version}) job_id = queue.enqueue( _diskimport, task["channel_id"], task["datafolder"], drive_id=task["drive_id"], node_ids=task["node_ids"], is_updating=True, extra_metadata=task, track_progress=True, cancellable=True, ) else: raise serializers.ValidationError( "sourcetype must be 'remote' or 'local'") resp = _job_to_response(queue.fetch_job(job_id)) return Response(resp)
def startdiskchannelimport(self, request): task = validate_local_import_task(request, request.data) task.update({"type": "DISKCHANNELIMPORT"}) job_id = queue.enqueue( call_command, "importchannel", "disk", task["channel_id"], task["datafolder"], extra_metadata=task, cancellable=True, ) resp = _job_to_response(queue.fetch_job(job_id)) return Response(resp)
def startremotechannelimport(self, request): task = validate_remote_import_task(request, request.data) task.update({"type": "REMOTECHANNELIMPORT"}) job_id = queue.enqueue( call_command, "importchannel", "network", task["channel_id"], baseurl=task["baseurl"], extra_metadata=task, cancellable=True, ) resp = _job_to_response(queue.fetch_job(job_id)) return Response(resp)
def startexportlogcsv(self, request): """ Dumps in csv format the required logs. By default it will be dump contentsummarylog. :param: logtype: Kind of log to dump, summary or session :returns: An object with the job information """ csv_export_filenames = { "session": "content_session_logs.csv", "summary": "content_summary_logs.csv", } log_type = request.data.get("logtype", "summary") if log_type in csv_export_filenames.keys(): logs_dir = os.path.join(conf.KOLIBRI_HOME, "log_export") filepath = os.path.join(logs_dir, csv_export_filenames[log_type]) else: raise Http404( "Impossible to create a csv export file for {}".format( log_type)) if not os.path.isdir(logs_dir): os.mkdir(logs_dir) job_type = ("EXPORTSUMMARYLOGCSV" if log_type == "summary" else "EXPORTSESSIONLOGCSV") job_metadata = {"type": job_type, "started_by": request.user.pk} job_id = queue.enqueue( call_command, "exportlogs", log_type=log_type, output_file=filepath, overwrite="true", extra_metadata=job_metadata, track_progress=True, ) resp = _job_to_response(queue.fetch_job(job_id)) return Response(resp)
def startdiskcontentimport(self, request): task = validate_local_import_task(request, request.data) task.update({"type": "DISKCONTENTIMPORT"}) job_id = queue.enqueue( call_command, "importcontent", "disk", task["channel_id"], task["datafolder"], node_ids=task["node_ids"], exclude_node_ids=task["exclude_node_ids"], extra_metadata=task, track_progress=True, cancellable=True, ) resp = _job_to_response(queue.fetch_job(job_id)) return Response(resp)
def startremotecontentimport(self, request): task = validate_remote_import_task(request, request.data) task.update({"type": "REMOTECONTENTIMPORT"}) job_id = queue.enqueue( call_command, "importcontent", "network", task["channel_id"], baseurl=task["baseurl"], node_ids=task["node_ids"], exclude_node_ids=task["exclude_node_ids"], extra_metadata=task, track_progress=True, cancellable=True, ) resp = _job_to_response(queue.fetch_job(job_id)) return Response(resp)
def startdataportalsync(self, request): """ Initiate a PUSH sync with Kolibri Data Portal. """ task = { "facility": request.data["facility"], "type": "SYNCDATAPORTAL", "started_by": request.user.pk, } job_id = queue.enqueue( call_command, "sync", facility=task["facility"], noninteractive=True, extra_metadata=task, track_progress=False, cancellable=False, ) # attempt to get the created Task, otherwise return pending status resp = _job_to_response(queue.fetch_job(job_id)) return Response(resp)