462 lines
13 KiB
GDScript
462 lines
13 KiB
GDScript
class_name SavedServerStore
|
|
extends Node
|
|
|
|
const FORMAT_VERSION: int = 1
|
|
const MAX_SAVED_ENTRIES: int = 100
|
|
const MAX_RECENT_ENTRIES: int = 20
|
|
const MAX_DISPLAY_NAME_LENGTH: int = 80
|
|
|
|
signal data_changed
|
|
signal recovery_warning_changed(message: String)
|
|
|
|
var _saved_entries: Array[Dictionary] = []
|
|
var _recent_entries: Array[Dictionary] = []
|
|
var _loaded: bool = false
|
|
var _recovery_warning: String = ""
|
|
var _write_blocked: bool = false
|
|
var _store_path := ""
|
|
var _expected_hash := ""
|
|
var _data_root: PlayerDataRoot
|
|
|
|
|
|
func configure_storage(path: String, data_root: PlayerDataRoot) -> void:
|
|
_store_path = path
|
|
_data_root = data_root
|
|
|
|
|
|
func _temp_path() -> String:
|
|
return _store_path + ".tmp"
|
|
|
|
|
|
func _backup_path() -> String:
|
|
return _store_path + ".backup"
|
|
|
|
|
|
func get_saved_entries() -> Array[SavedServerEntry]:
|
|
_ensure_loaded()
|
|
var result: Array[SavedServerEntry] = []
|
|
for data: Dictionary in _saved_entries:
|
|
result.append(SavedServerEntry.from_dictionary(
|
|
data, SavedServerEntry.Kind.SAVED
|
|
))
|
|
result.sort_custom(_sort_saved_entries)
|
|
return result
|
|
|
|
|
|
func get_recent_entries() -> Array[SavedServerEntry]:
|
|
_ensure_loaded()
|
|
var result: Array[SavedServerEntry] = []
|
|
for data: Dictionary in _recent_entries:
|
|
result.append(SavedServerEntry.from_dictionary(
|
|
data, SavedServerEntry.Kind.RECENT
|
|
))
|
|
result.sort_custom(func(a: SavedServerEntry, b: SavedServerEntry) -> bool:
|
|
return a.last_success_at_unix > b.last_success_at_unix
|
|
)
|
|
return result
|
|
|
|
|
|
func list_entries() -> Array[Dictionary]:
|
|
_ensure_loaded()
|
|
return _saved_entries.duplicate(true)
|
|
|
|
|
|
func get_recovery_warning() -> String:
|
|
_ensure_loaded()
|
|
return _recovery_warning
|
|
|
|
|
|
func find_saved_by_endpoint(
|
|
endpoint: ConnectionEndpoint,
|
|
) -> SavedServerEntry:
|
|
_ensure_loaded()
|
|
if endpoint == null or not endpoint.is_valid():
|
|
return null
|
|
for data: Dictionary in _saved_entries:
|
|
if data.get("normalized_endpoint", "") == endpoint.normalized_display:
|
|
return SavedServerEntry.from_dictionary(
|
|
data, SavedServerEntry.Kind.SAVED
|
|
)
|
|
return null
|
|
|
|
|
|
func find_by_normalized_endpoint(value: String) -> Dictionary:
|
|
var endpoint := EndpointParser.parse(value)
|
|
var entry: SavedServerEntry = find_saved_by_endpoint(endpoint)
|
|
return entry.to_dictionary() if entry != null else {}
|
|
|
|
|
|
func save_or_update_entry(
|
|
display_name: String,
|
|
endpoint: ConnectionEndpoint,
|
|
entry_id: String = "",
|
|
) -> SavedServerEntry:
|
|
_ensure_loaded()
|
|
var clean_name: String = display_name.strip_edges()
|
|
if (
|
|
endpoint == null
|
|
or not endpoint.is_valid()
|
|
or clean_name.is_empty()
|
|
or clean_name.length() > MAX_DISPLAY_NAME_LENGTH
|
|
):
|
|
return null
|
|
var now: int = int(Time.get_unix_time_from_system())
|
|
var target: Dictionary = {}
|
|
for data: Dictionary in _saved_entries:
|
|
if not entry_id.is_empty() and data.get("entry_id", "") == entry_id:
|
|
target = data
|
|
break
|
|
for data: Dictionary in _saved_entries:
|
|
if (
|
|
data.get("normalized_endpoint", "") == endpoint.normalized_display
|
|
and data != target
|
|
):
|
|
return null
|
|
if target.is_empty():
|
|
if _saved_entries.size() >= MAX_SAVED_ENTRIES:
|
|
return null
|
|
target = _make_entry(endpoint, SavedServerEntry.Kind.SAVED)
|
|
_saved_entries.append(target)
|
|
target["display_name"] = clean_name
|
|
target["host"] = endpoint.host
|
|
target["normalized_host"] = endpoint.host
|
|
target["port"] = endpoint.port
|
|
target["normalized_endpoint"] = endpoint.normalized_display
|
|
target["updated_at_unix"] = now
|
|
if not _save_atomic():
|
|
return null
|
|
data_changed.emit()
|
|
return SavedServerEntry.from_dictionary(
|
|
target, SavedServerEntry.Kind.SAVED
|
|
)
|
|
|
|
|
|
func save_entry(display_name: String, endpoint: ConnectionEndpoint) -> bool:
|
|
return save_or_update_entry(display_name, endpoint) != null
|
|
|
|
|
|
func remove_saved_entry(entry_id: String) -> bool:
|
|
_ensure_loaded()
|
|
for index: int in range(_saved_entries.size()):
|
|
if _saved_entries[index].get("entry_id", "") == entry_id:
|
|
_saved_entries.remove_at(index)
|
|
if not _save_atomic():
|
|
return false
|
|
data_changed.emit()
|
|
return true
|
|
return false
|
|
|
|
|
|
func remove_entry(entry_id: String) -> bool:
|
|
return remove_saved_entry(entry_id)
|
|
|
|
|
|
func set_favorite(entry_id: String, favorite: bool) -> bool:
|
|
_ensure_loaded()
|
|
for data: Dictionary in _saved_entries:
|
|
if data.get("entry_id", "") == entry_id:
|
|
data["favorite"] = favorite
|
|
data["updated_at_unix"] = int(Time.get_unix_time_from_system())
|
|
if not _save_atomic():
|
|
return false
|
|
data_changed.emit()
|
|
return true
|
|
return false
|
|
|
|
|
|
func record_successful_connection(
|
|
endpoint: ConnectionEndpoint,
|
|
observed_max_players: int,
|
|
server_name: String = "",
|
|
protocol_version: int = 0,
|
|
player_count: int = 0,
|
|
) -> bool:
|
|
_ensure_loaded()
|
|
if endpoint == null or not endpoint.is_valid():
|
|
return false
|
|
var now: int = int(Time.get_unix_time_from_system())
|
|
for data: Dictionary in _saved_entries:
|
|
if data.get("normalized_endpoint", "") == endpoint.normalized_display:
|
|
_apply_result_metadata(
|
|
data, now, "SUCCESS", server_name, protocol_version,
|
|
player_count, observed_max_players
|
|
)
|
|
var recent: Dictionary = {}
|
|
for data: Dictionary in _recent_entries:
|
|
if data.get("normalized_endpoint", "") == endpoint.normalized_display:
|
|
recent = data
|
|
break
|
|
if recent.is_empty():
|
|
recent = _make_entry(endpoint, SavedServerEntry.Kind.RECENT)
|
|
_recent_entries.append(recent)
|
|
recent["display_name"] = (
|
|
server_name if not server_name.is_empty() else endpoint.normalized_display
|
|
)
|
|
_apply_result_metadata(
|
|
recent, now, "SUCCESS", server_name, protocol_version,
|
|
player_count, observed_max_players
|
|
)
|
|
_recent_entries.sort_custom(func(a: Dictionary, b: Dictionary) -> bool:
|
|
return int(a.get("last_success_at_unix", 0)) > int(
|
|
b.get("last_success_at_unix", 0)
|
|
)
|
|
)
|
|
if _recent_entries.size() > MAX_RECENT_ENTRIES:
|
|
_recent_entries.resize(MAX_RECENT_ENTRIES)
|
|
if not _save_atomic():
|
|
return false
|
|
data_changed.emit()
|
|
return true
|
|
|
|
|
|
func record_connection_failure(
|
|
endpoint: ConnectionEndpoint,
|
|
result_code: String,
|
|
) -> bool:
|
|
_ensure_loaded()
|
|
if endpoint == null or not endpoint.is_valid():
|
|
return false
|
|
for data: Dictionary in _saved_entries:
|
|
if data.get("normalized_endpoint", "") == endpoint.normalized_display:
|
|
data["last_result_code"] = result_code.left(48)
|
|
data["updated_at_unix"] = int(Time.get_unix_time_from_system())
|
|
if not _save_atomic():
|
|
return false
|
|
data_changed.emit()
|
|
break
|
|
return true
|
|
|
|
|
|
func remove_recent_entry(entry_id: String) -> bool:
|
|
_ensure_loaded()
|
|
for index: int in range(_recent_entries.size()):
|
|
if _recent_entries[index].get("entry_id", "") == entry_id:
|
|
_recent_entries.remove_at(index)
|
|
if not _save_atomic():
|
|
return false
|
|
data_changed.emit()
|
|
return true
|
|
return false
|
|
|
|
|
|
func clear_recent_entries() -> bool:
|
|
_ensure_loaded()
|
|
if _recent_entries.is_empty():
|
|
return true
|
|
_recent_entries.clear()
|
|
if not _save_atomic():
|
|
return false
|
|
data_changed.emit()
|
|
return true
|
|
|
|
|
|
func _ensure_loaded() -> void:
|
|
if _loaded:
|
|
return
|
|
_loaded = true
|
|
_recover_interrupted_write()
|
|
if _store_path.is_empty() or not FileAccess.file_exists(_store_path):
|
|
return
|
|
var data: Dictionary = _read_store(_store_path)
|
|
if data.is_empty() and FileAccess.file_exists(_backup_path()):
|
|
data = _read_store(_backup_path())
|
|
if not data.is_empty():
|
|
_set_warning("Recovered saved servers from the local backup.")
|
|
if data.is_empty():
|
|
if FileAccess.file_exists(_store_path):
|
|
_set_warning(
|
|
"Saved servers could not be read. Direct connection is still available."
|
|
)
|
|
return
|
|
if data.get("format_version") != FORMAT_VERSION:
|
|
_write_blocked = true
|
|
_set_warning(
|
|
"Saved servers use a newer format. Direct connection is still available."
|
|
)
|
|
return
|
|
_load_collection(data.get("saved_entries", data.get("entries", [])), true)
|
|
_load_collection(data.get("recent_entries", []), false)
|
|
_expected_hash = PortableFileGuard.hash_file(_store_path)
|
|
|
|
|
|
func _load_collection(raw: Variant, is_saved: bool) -> void:
|
|
if typeof(raw) != TYPE_ARRAY:
|
|
_set_warning("Some saved-server data was unavailable.")
|
|
return
|
|
var target: Array[Dictionary] = (
|
|
_saved_entries if is_saved else _recent_entries
|
|
)
|
|
var seen: Dictionary[String, bool] = {}
|
|
for value: Variant in raw:
|
|
if typeof(value) != TYPE_DICTIONARY:
|
|
_set_warning("Some malformed server entries were skipped.")
|
|
continue
|
|
var validated: Dictionary = _validate_entry(value, is_saved)
|
|
if validated.is_empty():
|
|
_set_warning("Some malformed server entries were skipped.")
|
|
continue
|
|
var identity: String = validated["normalized_endpoint"]
|
|
if seen.has(identity):
|
|
continue
|
|
seen[identity] = true
|
|
target.append(validated)
|
|
if target.size() >= (
|
|
MAX_SAVED_ENTRIES if is_saved else MAX_RECENT_ENTRIES
|
|
):
|
|
break
|
|
|
|
|
|
func _validate_entry(value: Dictionary, is_saved: bool) -> Dictionary:
|
|
if (
|
|
typeof(value.get("entry_id")) != TYPE_STRING
|
|
or str(value.get("entry_id", "")).is_empty()
|
|
or typeof(value.get("host")) != TYPE_STRING
|
|
):
|
|
return {}
|
|
var stored_host: String = str(value.get("host", ""))
|
|
var stored_port: int = int(value.get("port", 0))
|
|
var endpoint_text: String = (
|
|
"[%s]:%d" % [stored_host, stored_port]
|
|
if stored_host.contains(":")
|
|
else "%s:%d" % [stored_host, stored_port]
|
|
)
|
|
var endpoint := EndpointParser.parse(endpoint_text)
|
|
if not endpoint.is_valid():
|
|
return {}
|
|
var display_name: String = str(
|
|
value.get("display_name", "")
|
|
).strip_edges()
|
|
if is_saved and (
|
|
display_name.is_empty()
|
|
or display_name.length() > MAX_DISPLAY_NAME_LENGTH
|
|
):
|
|
return {}
|
|
var result: Dictionary = _make_entry(
|
|
endpoint,
|
|
SavedServerEntry.Kind.SAVED if is_saved else SavedServerEntry.Kind.RECENT
|
|
)
|
|
for key: String in result:
|
|
if value.has(key) and typeof(value[key]) == typeof(result[key]):
|
|
result[key] = value[key]
|
|
result["host"] = endpoint.host
|
|
result["normalized_host"] = endpoint.host
|
|
result["port"] = endpoint.port
|
|
result["normalized_endpoint"] = endpoint.normalized_display
|
|
return result
|
|
|
|
|
|
func _make_entry(
|
|
endpoint: ConnectionEndpoint,
|
|
kind: SavedServerEntry.Kind,
|
|
) -> Dictionary:
|
|
var now: int = int(Time.get_unix_time_from_system())
|
|
return {
|
|
"entry_id": Crypto.new().generate_random_bytes(16).hex_encode(),
|
|
"display_name": endpoint.host,
|
|
"route_kind": "DIRECT",
|
|
"host": endpoint.host,
|
|
"normalized_host": endpoint.host,
|
|
"port": endpoint.port,
|
|
"normalized_endpoint": endpoint.normalized_display,
|
|
"favorite": false,
|
|
"created_at_unix": now,
|
|
"updated_at_unix": now,
|
|
"last_success_at_unix": 0,
|
|
"last_result_code": "",
|
|
"last_observed_server_name": "",
|
|
"last_observed_protocol_version": 0,
|
|
"last_observed_player_count": 0,
|
|
"last_observed_max_players": 0,
|
|
"entry_kind": int(kind),
|
|
}
|
|
|
|
|
|
func _apply_result_metadata(
|
|
data: Dictionary,
|
|
now: int,
|
|
result_code: String,
|
|
server_name: String,
|
|
protocol_version: int,
|
|
player_count: int,
|
|
max_players: int,
|
|
) -> void:
|
|
data["last_success_at_unix"] = now
|
|
data["updated_at_unix"] = now
|
|
data["last_result_code"] = result_code
|
|
data["last_observed_server_name"] = server_name.left(80)
|
|
data["last_observed_protocol_version"] = maxi(protocol_version, 0)
|
|
data["last_observed_player_count"] = maxi(player_count, 0)
|
|
data["last_observed_max_players"] = maxi(max_players, 0)
|
|
|
|
|
|
func _sort_saved_entries(
|
|
a: SavedServerEntry,
|
|
b: SavedServerEntry,
|
|
) -> bool:
|
|
if a.favorite != b.favorite:
|
|
return a.favorite
|
|
if a.last_success_at_unix != b.last_success_at_unix:
|
|
return a.last_success_at_unix > b.last_success_at_unix
|
|
var name_compare: int = a.display_name.naturalnocasecmp_to(b.display_name)
|
|
if name_compare != 0:
|
|
return name_compare < 0
|
|
return a.entry_id < b.entry_id
|
|
|
|
|
|
func _save_atomic() -> bool:
|
|
if _write_blocked:
|
|
return false
|
|
var bytes := JSON.stringify({
|
|
"format_version": FORMAT_VERSION,
|
|
"saved_entries": _saved_entries,
|
|
"recent_entries": _recent_entries,
|
|
}, "\t").to_utf8_buffer()
|
|
var result := PortableFileGuard.write_guarded(
|
|
_store_path, bytes, _expected_hash, _data_root.conflict_directory(),
|
|
_data_root.device_id,
|
|
)
|
|
if bool(result.get("conflict", false)):
|
|
_data_root.report_conflict(str(result.get("message", "")), str(result.get("conflict_path", "")))
|
|
if bool(result.get("ok", false)):
|
|
_expected_hash = str(result["hash"])
|
|
return bool(result.get("ok", false))
|
|
|
|
|
|
func _read_store(path: String) -> Dictionary:
|
|
var file := FileAccess.open(path, FileAccess.READ)
|
|
if file == null:
|
|
return {}
|
|
var json := JSON.new()
|
|
var error: Error = json.parse(file.get_as_text())
|
|
file.close()
|
|
return json.data if error == OK and typeof(json.data) == TYPE_DICTIONARY else {}
|
|
|
|
|
|
func _recover_interrupted_write() -> void:
|
|
if FileAccess.file_exists(_store_path):
|
|
_remove_if_present(_temp_path())
|
|
return
|
|
if FileAccess.file_exists(_backup_path()):
|
|
_rename(_backup_path(), _store_path)
|
|
_set_warning("Recovered saved servers after an interrupted write.")
|
|
_remove_if_present(_temp_path())
|
|
|
|
|
|
func _set_warning(message: String) -> void:
|
|
if _recovery_warning.is_empty():
|
|
_recovery_warning = message
|
|
recovery_warning_changed.emit(_recovery_warning)
|
|
|
|
|
|
func _rename(from_path: String, to_path: String) -> bool:
|
|
return DirAccess.rename_absolute(
|
|
ProjectSettings.globalize_path(from_path),
|
|
ProjectSettings.globalize_path(to_path)
|
|
) == OK
|
|
|
|
|
|
func _remove_if_present(path: String) -> bool:
|
|
return (
|
|
not FileAccess.file_exists(path)
|
|
or DirAccess.remove_absolute(ProjectSettings.globalize_path(path)) == OK
|
|
)
|