def handle_async(self, *args, **options): # noqa C901 ( baseurl, facility_id, chunk_size, username, password, no_push, no_pull, noninteractive, no_provision, ) = ( options["baseurl"], options["facility"], options["chunk_size"], options["username"], options["password"], options["no_push"], options["no_pull"], options["noninteractive"], options["no_provision"], ) PORTAL_SYNC = baseurl == DATA_PORTAL_SYNCING_BASE_URL # validate url that is passed in if not PORTAL_SYNC: baseurl = get_baseurl(baseurl) # call this in case user directly syncs without migrating database if not ScopeDefinition.objects.filter(): call_command("loaddata", "scopedefinitions") dataset_cache.clear() # try to connect to server controller = MorangoProfileController(PROFILE_FACILITY_DATA) network_connection = controller.create_network_connection(baseurl) # if instance_ids are equal, this means device is trying to sync with itself, which we don't allow if (InstanceIDModel.get_or_create_current_instance()[0].id == network_connection.server_info["instance_id"]): raise CommandError( "Device can not sync with itself. Please recheck base URL and try again." ) if PORTAL_SYNC: # do portal sync setup facility = get_facility(facility_id=facility_id, noninteractive=noninteractive) # check for the certs we own for the specific facility client_cert = (facility.dataset.get_owned_certificates().filter( scope_definition_id=ScopeDefinitions.FULL_FACILITY).first()) if not client_cert: raise CommandError( "This device does not own a certificate for Facility: {}". format(facility.name)) # get primary partition scope_params = json.loads(client_cert.scope_params) dataset_id = scope_params["dataset_id"] # check if the server already has a cert for this facility server_certs = network_connection.get_remote_certificates( dataset_id, scope_def_id=ScopeDefinitions.FULL_FACILITY) # if necessary, push a cert up to the server server_cert = ( server_certs[0] if server_certs else network_connection.push_signed_client_certificate_chain( local_parent_cert=client_cert, scope_definition_id=ScopeDefinitions.FULL_FACILITY, scope_params=scope_params, )) else: # do P2P setup dataset_id = get_dataset_id(baseurl, identifier=facility_id, noninteractive=noninteractive) client_cert, server_cert, username = get_client_and_server_certs( username, password, dataset_id, network_connection, noninteractive=noninteractive, ) logger.info("Syncing has been initiated (this may take a while)...") sync_session_client = network_connection.create_sync_session( client_cert, server_cert, chunk_size=chunk_size) try: # pull from server if not no_pull: self._handle_pull(sync_session_client, noninteractive, dataset_id) # and push our own data to server if not no_push: self._handle_push(sync_session_client, noninteractive, dataset_id) if not no_provision: with self._lock(): create_superuser_and_provision_device( username, dataset_id, noninteractive=noninteractive) except UserCancelledError: if self.job: self.job.extra_metadata.update(sync_state=State.CANCELLED) self.job.save_meta() logger.info("Syncing has been cancelled.") return network_connection.close() if self.job: self.job.extra_metadata.update(sync_state=State.COMPLETED) self.job.save_meta() logger.info("Syncing has been completed.")
def handle_async(self, *args, **options): noninteractive = options["noninteractive"] strict = options["strict"] facility = get_facility(facility_id=options["facility"], noninteractive=noninteractive) dataset_id = facility.dataset_id logger.info("Found facility {} <{}> for deletion".format( facility.id, dataset_id)) if not noninteractive: # ensure the user REALLY wants to do this! confirm_or_exit( "Are you sure you wish to permanently delete this facility? This will DELETE ALL DATA FOR THE FACILITY." ) confirm_or_exit( "ARE YOU SURE? If you do this, there is no way to recover the facility data on this device." ) # everything should get cascade deleted from the facility, but we'll check anyway delete_group = GroupDeletion( "Main", groups=[ self._get_morango_models(dataset_id), self._get_log_models(dataset_id), self._get_class_models(dataset_id), self._get_users(dataset_id), self._get_facility_dataset(dataset_id), ], ) logger.info( "Proceeding with facility deletion. Deleting all data for facility <{}>" .format(dataset_id)) with self._delete_context(): total_deleted = 0 # run the counting step with self.start_progress( total=delete_group.group_count()) as update_progress: update_progress(increment=0, message="Counting database objects") total_count = delete_group.count(update_progress) # no the deleting step with self.start_progress(total=total_count) as update_progress: update_progress(increment=0, message="Deleting database objects") count, stats = delete_group.delete(update_progress) total_deleted += count # clear related cache dataset_cache.clear() # if count doesn't match, something doesn't seem right if total_count != total_deleted: msg = "Deleted count does not match total ({} != {})".format( total_count, total_deleted) if strict: raise CommandError("{}, aborting!".format(msg)) else: logger.warning(msg) logger.info("Deletion complete.")
def started(transfer_session): dataset_cache.clear() if noninteractive or tracker.progressbar is None: logger.info(message)