class_name KeetIdentityManager
extends Node
## Multi-identity manager for keet-daemon via UDS.
## Create, switch, import, export, and delete identities.
signal identities_loaded(identities: Array, active_id: String)
signal identity_created(entry: Dictionary)
signal identity_switched(entry: Dictionary)
signal identity_deleted(id: String)
signal identity_updated(entry: Dictionary)
signal identity_exported(phrase: String)
signal identity_imported(entry: Dictionary)
signal identity_repaired(log: Array)
signal gc_completed(log: Array)
signal error_occurred(message: String)
var client: KeetUdsClient
func list_identities(callback: Callable = Callable()) -> void:
_require_client()
client.call_rpc("identity-manager.list", {}, func(result, err):
if err != null:
error_occurred.emit("list: %s" % str(err))
return
var data: Dictionary = result if result is Dictionary else {}
var identities: Array = data.get("identities", [])
var active_id: String = data.get("activeId", "")
identities_loaded.emit(identities, active_id)
if callback.is_valid():
callback.call(data)
)
func get_active(callback: Callable = Callable()) -> void:
_require_client()
client.call_rpc("identity-manager.active", {}, func(result, err):
if err != null:
error_occurred.emit("active: %s" % str(err))
return
if callback.is_valid():
callback.call(result if result is Dictionary else {})
)
func create_identity(identity_name: String, callback: Callable = Callable()) -> void:
_require_client()
client.call_rpc("identity-manager.create", {"name": identity_name}, func(result, err):
if err != null:
error_occurred.emit("create: %s" % str(err))
return
var entry: Dictionary = result if result is Dictionary else {}
identity_created.emit(entry)
if callback.is_valid():
callback.call(entry)
)
func switch_identity(id: String, callback: Callable = Callable()) -> void:
_require_client()
client.call_rpc("identity-manager.switch", {"id": id}, func(result, err):
if err != null:
error_occurred.emit("switch: %s" % str(err))
return
var data: Dictionary = result if result is Dictionary else {}
var entry: Dictionary = data.get("active", {})
identity_switched.emit(entry)
if callback.is_valid():
callback.call(data)
)
func delete_identity(id: String, delete_files: bool = true, callback: Callable = Callable()) -> void:
_require_client()
client.call_rpc("identity-manager.delete", {"id": id, "deleteFiles": delete_files}, func(result, err):
if err != null:
error_occurred.emit("delete: %s" % str(err))
return
identity_deleted.emit(id)
if callback.is_valid():
callback.call(result)
)
func update_identity(id: String, fields: Dictionary, callback: Callable = Callable()) -> void:
_require_client()
var params: Dictionary = {"id": id}
if fields.has("name"):
params["name"] = fields["name"]
if fields.has("username"):
params["username"] = fields["username"]
client.call_rpc("identity-manager.update", params, func(result, err):
if err != null:
error_occurred.emit("update: %s" % str(err))
return
var entry: Dictionary = result if result is Dictionary else {}
identity_updated.emit(entry)
if callback.is_valid():
callback.call(entry)
)
func export_identity(id: String, password: String, callback: Callable = Callable()) -> void:
_require_client()
client.call_rpc("identity-manager.export", {"id": id, "password": password}, func(result, err):
if err != null:
error_occurred.emit("export: %s" % str(err))
return
var data: Dictionary = result if result is Dictionary else {}
var phrase: String = data.get("phrase", "")
identity_exported.emit(phrase)
if callback.is_valid():
callback.call(data)
)
func import_identity(phrase: String, password: String, identity_name: String, callback: Callable = Callable()) -> void:
_require_client()
client.call_rpc("identity-manager.import", {
"phrase": phrase, "password": password, "name": identity_name
}, func(result, err):
if err != null:
error_occurred.emit("import: %s" % str(err))
return
var data: Dictionary = result if result is Dictionary else {}
var entry: Dictionary = data.get("identity", {})
identity_imported.emit(entry)
if callback.is_valid():
callback.call(data)
)
func gc_identity(callback: Callable = Callable()) -> void:
_require_client()
client.call_rpc("identity-manager.gc", {}, func(result, err):
if err != null:
error_occurred.emit("gc: %s" % str(err))
return
var data: Dictionary = result if result is Dictionary else {}
var log: Array = data.get("log", [])
gc_completed.emit(log)
if callback.is_valid():
callback.call(data)
)
func diagnose(callback: Callable = Callable()) -> void:
_require_client()
client.call_rpc("identity-manager.diagnose", {}, func(result, err):
if err != null:
error_occurred.emit("diagnose: %s" % str(err))
return
if callback.is_valid():
callback.call(result if result is Dictionary else {})
)
func repair_identity(callback: Callable = Callable()) -> void:
_require_client()
client.call_rpc("identity-manager.repair", {}, func(result, err):
if err != null:
error_occurred.emit("repair: %s" % str(err))
return
var data: Dictionary = result if result is Dictionary else {}
var log: Array = data.get("log", [])
identity_repaired.emit(log)
if callback.is_valid():
callback.call(data)
)
func _require_client() -> void:
if client == null:
push_error("KeetIdentityManager: client not set")