247 lines
No EOL
8 KiB
GDScript
247 lines
No EOL
8 KiB
GDScript
# ServerManager.gd
|
|
extends Node
|
|
|
|
var server_path: String = ""
|
|
var log_dir: String = ""
|
|
var log_string: String = ""
|
|
var running := false
|
|
var server_process_id: int = -50
|
|
var request_timer: Timer
|
|
var server_pinger: Timer
|
|
var ping_http: HTTPRequest
|
|
|
|
var server_url = "http://localhost:27531"
|
|
|
|
func write_log(message: String):
|
|
# First check if path is valid
|
|
# print("Attempting to write to: ", log_dir)
|
|
|
|
var file = FileAccess.open(log_dir, FileAccess.WRITE_READ)
|
|
var error = FileAccess.get_open_error()
|
|
|
|
if error != OK:
|
|
# print("Failed to open log file. Error code: ", error)
|
|
return
|
|
|
|
if file == null:
|
|
# print("File handle is null")
|
|
return
|
|
|
|
var timestamp = Time.get_datetime_string_from_system()
|
|
var log_message = "[" + timestamp + "] " + message + "\n"
|
|
log_string += log_message
|
|
print("Writing message: ", log_message)
|
|
file.store_string(log_string)
|
|
|
|
var write_error = FileAccess.get_open_error()
|
|
if write_error != OK:
|
|
print("Failed to write to log file. Error code: ", write_error)
|
|
|
|
file.close()
|
|
func _ready():
|
|
server_path = extract_server_files() + "/ChessEngines/fairy-chess-server"
|
|
setup_logging()
|
|
check_server_files(server_path)
|
|
start_server()
|
|
get_tree().set_auto_accept_quit(false)
|
|
setup_server_pinger()
|
|
|
|
func setup_server_pinger():
|
|
server_pinger = Timer.new()
|
|
add_child(server_pinger)
|
|
server_pinger.wait_time = 60.0
|
|
server_pinger.one_shot = false
|
|
server_pinger.timeout.connect(self._on_ping_timer_timeout)
|
|
ping_http = HTTPRequest.new()
|
|
add_child(ping_http)
|
|
ping_http.request_completed.connect(self._on_ping_completed)
|
|
|
|
server_pinger.start()
|
|
|
|
|
|
func _on_ping_timer_timeout():
|
|
write_log("Pinging server health endpoint...")
|
|
var error = ping_http.request(server_url + "/health")
|
|
if error != OK:
|
|
write_log("Error sending ping request: " + str(error))
|
|
|
|
|
|
func _on_ping_completed(result: int, response_code: int, headers: PackedStringArray, body: PackedByteArray):
|
|
if result == HTTPRequest.RESULT_SUCCESS:
|
|
write_log("Server ping successful")
|
|
else:
|
|
write_log("Server ping failed - may need to restart server")
|
|
|
|
|
|
func write_log_dir_contents(path: String):
|
|
var dir = DirAccess.open(path)
|
|
if dir:
|
|
write_log("Directory contents of: " + path)
|
|
dir.list_dir_begin()
|
|
var file_name = dir.get_next()
|
|
while file_name != "":
|
|
write_log(" - " + file_name)
|
|
file_name = dir.get_next()
|
|
else:
|
|
write_log("ERROR: Could not open directory: " + path)
|
|
func check_server_files(path: String):
|
|
write_log("Checking server files...")
|
|
write_log(path)
|
|
|
|
var index_path = path.path_join("index.js")
|
|
if FileAccess.file_exists(index_path):
|
|
write_log("index.js exists")
|
|
var file = FileAccess.open(index_path, FileAccess.READ)
|
|
if file:
|
|
write_log("index.js contents:")
|
|
# write_log(file.get_as_text())
|
|
else:
|
|
write_log("ERROR: Could not read index.js")
|
|
else:
|
|
write_log("ERROR: index.js does not exist at path: " + index_path)
|
|
|
|
func get_globalDir() -> String:
|
|
|
|
if OS.get_name() == "Linux":
|
|
return OS.get_environment("HOME").path_join(".local/share/ChessBuilder")
|
|
elif OS.get_name() == "Windows":
|
|
return OS.get_environment("APPDATA").path_join("Roaming/ChessBuilder")
|
|
else: # macOS
|
|
return OS.get_environment("HOME").path_join("Library/ChessBuilder")
|
|
|
|
func setup_logging():
|
|
var l_dir = get_globalDir() + "/logs"
|
|
|
|
# Create directory if it doesn't exist
|
|
DirAccess.make_dir_recursive_absolute(l_dir)
|
|
|
|
log_dir = l_dir.path_join("godot-chess.log")
|
|
write_log("ServerManager initialized")
|
|
|
|
func _exit_tree():
|
|
stop_server()
|
|
get_tree().quit()
|
|
|
|
func _notification(what):
|
|
if what == NOTIFICATION_WM_CLOSE_REQUEST:
|
|
stop_server()
|
|
get_tree().quit()
|
|
|
|
|
|
func start_server() -> bool:
|
|
if running:
|
|
return true
|
|
|
|
write_log("Starting chess server... " + server_path)
|
|
var http_request = HTTPRequest.new()
|
|
add_child(http_request)
|
|
http_request.request_completed.connect(self._on_init_request_completed)
|
|
|
|
request_timer = Timer.new()
|
|
add_child(request_timer)
|
|
request_timer.wait_time = 2.0 # 2 seconds
|
|
request_timer.one_shot = true
|
|
request_timer.timeout.connect(self._on_request_timeout)
|
|
request_timer.start()
|
|
http_request.request(server_url + "/health")
|
|
|
|
|
|
return true
|
|
|
|
|
|
func _on_request_timeout():
|
|
write_log("Request timed out, starting server manually")
|
|
# Clean up timer
|
|
request_timer.queue_free()
|
|
request_timer = null
|
|
# Call your secondary processing function here
|
|
write_log("HTTP Request failed, starting server process")
|
|
write_log(server_path + "/index.js")
|
|
server_process_id = OS.create_process("node", [server_path + "/index.js"])
|
|
write_log("SERVER PATH " + server_path)
|
|
if server_process_id <= 0:
|
|
printerr("Failed to start server")
|
|
write_log("ERROR: Failed to start server, process ID: " + str(server_process_id))
|
|
|
|
return false
|
|
|
|
running = true
|
|
write_log("Chess server started with PID: " + str(server_process_id))
|
|
return
|
|
|
|
func _on_init_request_completed(result: int, response_code: int, headers: PackedStringArray, body: PackedByteArray):
|
|
write_log("*****************_on_init_request_completed************")
|
|
if request_timer:
|
|
request_timer.stop()
|
|
request_timer.queue_free()
|
|
request_timer = null
|
|
var json = JSON.new()
|
|
json.parse(body.get_string_from_utf8())
|
|
var response = json.get_data()
|
|
write_log("Init request completed")
|
|
write_log("Result: " + str(response))
|
|
if response == null:
|
|
write_log("HTTP Request failed, starting server process")
|
|
write_log(server_path + "/index.js")
|
|
server_process_id = OS.create_process("node", [server_path + "/index.js"])
|
|
write_log("SERVER PATH " + server_path)
|
|
if server_process_id <= 0:
|
|
printerr("Failed to start server")
|
|
write_log("ERROR: Failed to start server, process ID: " + str(server_process_id))
|
|
|
|
return false
|
|
|
|
running = true
|
|
write_log("Chess server started with PID: " + str(server_process_id))
|
|
return
|
|
running = true
|
|
if response and response.status != "ok":
|
|
print("Server error : ", response_code, json.parse(body.get_string_from_utf8()),)
|
|
return
|
|
|
|
static func copy_directory_recursively(p_from: String, p_to: String) -> void:
|
|
# Create target directory if it doesn't exist
|
|
if not DirAccess.dir_exists_absolute(p_to):
|
|
DirAccess.make_dir_recursive_absolute(p_to)
|
|
|
|
# Open source directory
|
|
var dir = DirAccess.open(p_from)
|
|
if dir:
|
|
# Begin listing directory contents
|
|
dir.list_dir_begin()
|
|
var file_name = dir.get_next()
|
|
|
|
# Iterate through directory contents
|
|
while file_name != "":
|
|
# write_log(file_name + " isDIr? " + str(dir.current_is_dir()))
|
|
if dir.current_is_dir():
|
|
# Recursively copy subdirectories
|
|
copy_directory_recursively(p_from.path_join(file_name), p_to.path_join(file_name))
|
|
else:
|
|
# Copy files
|
|
dir.copy(p_from.path_join(file_name), p_to.path_join(file_name))
|
|
file_name = dir.get_next()
|
|
|
|
func extract_server_files() -> String:
|
|
write_log("Extracting server files from PCK...")
|
|
var dir = get_globalDir() + "/Assets";
|
|
copy_directory_recursively("res://Assets/", dir)
|
|
return dir
|
|
|
|
|
|
func stop_server():
|
|
if not running:
|
|
return
|
|
|
|
write_log("Stopping chess server...")
|
|
# Send a stop request to the server
|
|
var headers = ["Content-Type: application/json"]
|
|
var http = HTTPClient.new()
|
|
var data = JSON.stringify({"command": "shutdown"})
|
|
http.request(HTTPClient.METHOD_POST, "/shutdown", headers, data)
|
|
|
|
running = false
|
|
write_log("Chess server stopped")
|
|
|
|
func is_server_running() -> bool:
|
|
return running |