def register_public_key_client(request): if Device.get_own_device().get_zone(): set_as_registered() return {"already_registered": True} client = SyncClient() if client.test_connection() != "success": return {"no_internet": True} reg_response = client.register() reg_status = reg_response.get("code") if reg_status == "registered": set_as_registered() return {"newly_registered": True} if reg_status == "device_already_registered": set_as_registered() return {"already_registered": True} if reg_status == "public_key_unregistered": return { "unregistered": True, "registration_url": client.path_to_url( "/securesync/register/?" + urllib.quote(crypto.get_own_key().get_public_key_string())), } error_msg = reg_response.get("error", "") if error_msg: return {"error_msg": error_msg} return HttpResponse(_("Registration status: ") + reg_status)
def register_public_key_client(request): if Device.get_own_device().get_zone(): set_as_registered() return {"already_registered": True} client = SyncClient() if client.test_connection() != "success": return {"no_internet": True} reg_response = client.register() reg_status = reg_response.get("code") if reg_status == "registered": set_as_registered() return {"newly_registered": True} if reg_status == "device_already_registered": set_as_registered() return {"already_registered": True} if reg_status == "public_key_unregistered": return { "unregistered": True, "registration_url": client.path_to_url( reverse("register_public_key") + "?" + urllib.quote(crypto.get_own_key().get_public_key_string())), "central_login_url": "%s://%s/accounts/login" % (settings.SECURESYNC_PROTOCOL, settings.CENTRAL_SERVER_HOST), "callback_url": request.build_absolute_uri(reverse("register_public_key")), } error_msg = reg_response.get("error", "") if error_msg: return {"error_msg": error_msg} return HttpResponse(_("Registration status: ") + reg_status)
def wrapper_fn(request, *args, **kwargs): client = SyncClient() if not request.is_admin and Facility.objects.count() == 0: messages.warning(request, mark_safe( "Please <a href='%s?next=%s'>login</a> with the account you created while running the installation script, \ to complete the setup." % (reverse("login"), reverse("register_public_key")))) if request.is_admin: if not Settings.get("registered") and client.test_connection() == "success": messages.warning(request, mark_safe("Please <a href='%s'>follow the directions to register your device</a>, so that it can synchronize with the central server." % reverse("register_public_key"))) elif Facility.objects.count() == 0: messages.warning(request, mark_safe("Please <a href='%s'>create a facility</a> now. Users will not be able to sign up for accounts until you have made a facility." % reverse("add_facility"))) return handler(request, *args, **kwargs)
def crypto_login(request): if not request.user.is_superuser: return HttpResponseNotAllowed() ip = request.GET.get("ip", "") if not ip: return HttpResponseNotFound("Please specify an IP (as a GET param).") host = "http://%s/" % ip client = SyncClient(host=host, require_trusted=False) if client.test_connection() != "success": return HttpResponse("Unable to connect to a KA Lite server at %s" % host) client.start_session() if not client.session or not client.session.client_nonce: return HttpResponse("Unable to establish a session with KA Lite server at %s" % host) return HttpResponseRedirect("%ssecuresync/cryptologin/?client_nonce=%s" % (host, client.session.client_nonce))
def handle(self, *args, **options): self.stdout_writeln(("Checking purgatory for unsaved models")+"...") call_command("retrypurgatory") kwargs = {} if len(args) >= 1: kwargs["host"] = args[0] if len(args) >= 2: max_retries = args[1] else: max_retries = 5 try: client = SyncClient(**kwargs) except Exception as e: raise CommandError(e) if client.test_connection() != "success": self.stderr_writeln(("KA Lite host is currently unreachable")+": %s" % client.url) return self.stdout_writeln(("Initiating SyncSession")+"...") try: result = client.start_session() except Exception as e: raise CommandError(e) if result != "success": self.stderr_writeln(("Unable to initiate session")+": %s" % result.content) return self.stdout_writeln(("Syncing models")+"...") failure_tries = 0 while True: results = client.sync_models() upload_results = results["upload_results"] download_results = results["download_results"] # display counts for this block of models being transferred self.stdout_writeln("\t%-15s: %d (%d failed, %d error(s))" % ( ("Uploaded"), upload_results["saved_model_count"], upload_results["unsaved_model_count"], upload_results.has_key("error"))) self.stdout_writeln("\t%-15s: %d (%d failed, %d error(s))" % ( ("Downloaded"), download_results["saved_model_count"], download_results["unsaved_model_count"], download_results.has_key("error"))) # count the number of successes and failures success_count = upload_results["saved_model_count"] + download_results["saved_model_count"] fail_count = upload_results["unsaved_model_count"] + download_results["unsaved_model_count"] error_count = upload_results.has_key("error") + download_results.has_key("error") + upload_results.has_key("exceptions") # Report any errors if error_count > 0: if upload_results.has_key("error"): self.stderr_writeln("%s: %s"%(("Upload error"),upload_results["error"])) if download_results.has_key("error"): self.stderr_writeln("%s: %s"%(("Download error"),download_results["error"])) if upload_results.has_key("exceptions"): self.stderr_writeln("%s: %s"%(("Upload exceptions"),upload_results["exceptions"][:200])) # stop when nothing is being transferred anymore if success_count == 0 and (fail_count == 0 or failure_tries >= max_retries): break failure_tries += (fail_count > 0 and success_count == 0) # Report summaries self.stdout_writeln("%s... (%s: %d, %s: %d, %s: %d)" % (("Closing session"), ("Total uploaded"), client.session.models_uploaded, ("Total downloaded"), client.session.models_downloaded, ("Total errors"), client.session.errors)) # Report any exceptions if client.session.errors: self.stderr_writeln("Completed with %d errors."%client.session.errors) if failure_tries >= max_retries: self.stderr_writeln("%s (%d)."%("Failed to upload all models (stopped after failed attempts)",failure_tries)) self.stdout_writeln(("Checking purgatory once more, to try saving any unsaved models")+"...") call_command("retrypurgatory") client.close_session()
def handle(self, *args, **options): self.stdout.write("Checking purgatory for unsaved models...\n") call_command("retrypurgatory") kwargs = {} if len(args) >= 1: kwargs["host"] = args[0] client = SyncClient(**kwargs) if client.test_connection() != "success": self.stderr.write("KA Lite host is currently unreachable: %s\n" % client.url) return self.stdout.write("Initiating SyncSession...\n") result = client.start_session() if result != "success": self.stderr.write("Unable to initiate session: %s\n" % result.content) return self.stdout.write("Syncing models...\n") while True: results = client.sync_models() # display counts for this block of models being transferred self.stdout.write( "\tUploaded: %d (%d failed)\n" % (results["upload_results"]["saved_model_count"], results["upload_results"]["unsaved_model_count"])) self.stdout.write( "\tDownloaded: %d (%d failed)\n" % (results["download_results"]["saved_model_count"], results["download_results"]["unsaved_model_count"])) # count the number of successes and failures upload_results = results["upload_results"] download_results = results["download_results"] success_count = upload_results[ "saved_model_count"] + download_results["saved_model_count"] fail_count = upload_results[ "unsaved_model_count"] + download_results["unsaved_model_count"] # stop when nothing is being transferred anymore if success_count + fail_count == 0: break self.stdout.write( "Closing session... (Total uploaded: %d, Total downloaded: %d)\n" % (client.session.models_uploaded, client.session.models_downloaded)) self.stdout.write( "Checking purgatory once more, to try saving any unsaved models...\n" ) call_command("retrypurgatory") client.close_session()