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(
"/securesync/register/?" + urllib.quote(crypto.serialize_public_key())),
}
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 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 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:
raise PermissionDenied()
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 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.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()
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()
