/src/Plac/Server.vala at 8ca06f40bdae87c6dffb332311286319f0f1c980

// Copyright 2025 Shota FUJI
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

namespace Plac {
	public errordomain ResolveServerError {
		SERVER_NOT_FOUND,
		SERVER_MISMATCH,
		NETWORK_ERROR,
	}

	public errordomain ConnectError {
		SERVER_NOT_FOUND,
		INVALID_REQUEST,
		INVALID_RESPONSE,
		SERVER_MISMATCH,
		NETWORK_ERROR,
	}

	public class Server : Object {
		/**
		 * IP address of the server.
		 */
		public GLib.InetSocketAddress address { get; construct; }

		/**
		 * TCP port for WebSocket and HTTP connection.
		 */
		public uint16 http_port { get; construct; }

		/**
		 * String uniquely identifies a server among servers in a network.
		 */
		public string id { get; construct; }

		public string version { get; construct; }

		/**
		 * User-facing display name.
		 */
		public string name { get; construct; }

		public Server(GLib.InetSocketAddress address, string id, string version, string name, uint16 http_port) {
			Object(address: address, id: id, version: version, name: name, http_port: http_port);
		}

		public static async Server from_address(
			GLib.InetSocketAddress address, uint16 http_port, string id, GLib.Cancellable? cancellable = null
		) throws ResolveServerError {
			Soup.WebsocketConnection conn;
			try {
				conn = yield ws_connect(address, http_port, cancellable);
			} catch (GLib.Error error) {
				GLib.log("Plac", LEVEL_DEBUG, "Handshake error");
				throw new ResolveServerError.NETWORK_ERROR(error.message);
			}

			Roon.Registry.Info.Response info;
			try {
				info = yield get_registry_info(conn);
			} catch (ConnectError error) {
				throw new ResolveServerError.SERVER_NOT_FOUND(error.message);
			}

			if (info.core_id != id) {
				throw new ResolveServerError.SERVER_MISMATCH("Server at the location has different server ID.");
			}

			return new Server(address, id, info.display_version, info.display_name, http_port);
		}

		/**
		 * TODO: Move connection-related code to `Connection` class
		 */
		private static async Soup.WebsocketConnection ws_connect(
			GLib.InetSocketAddress address,
			uint16 port,
			GLib.Cancellable? cancellable = null
		) throws GLib.Error {
			var session_singleton = new Session();
			var session = session_singleton.session;

			var url = GLib.Uri.build(
				NONE, "ws:", null, address.address.to_string(), port,
				"/api", null, null
			);
			var msg = new Soup.Message.from_uri("GET", url);

			// Roon API does not specify WebSocket subprotocols.
			Soup.WebsocketConnection conn = yield session.websocket_connect_async(
				msg, null, null, GLib.Priority.DEFAULT, cancellable
			);

			conn.message.connect(handle_ping);

			return conn;
		}

		private static async Response send_request(
			Soup.WebsocketConnection conn,
			string service,
			uint64 request_id,
			string? json_body = null
		) throws ConnectError {
			SourceFunc callback = send_request.callback;
			Response? resp = null;

			var message_handler_id = conn.message.connect((c, type, bytes) => {
				var message = (string) bytes.get_data();

				Moo.Metadata res_meta;
				Moo.Headers res_headers;
				try {
					res_meta = new Moo.Metadata.from_string(message);
					res_headers = new Moo.Headers.from_string(message, res_meta);
				} catch (GLib.Error error) {
					GLib.log("Plac", LEVEL_WARNING, "Got invalid MOO message: %s", error.message);
					return;
				}

				if (res_meta.verb == "REQUEST") {
					// Application ping message, skip.
					return;
				}

				if (res_headers.request_id != request_id) {
					GLib.log("Plac", LEVEL_DEBUG, "Ignoring response with unexpected Request-Id");
					return;
				}

				resp = new Response(res_meta, res_headers, message);
				callback();
			});

			var error_handler_id = conn.error.connect((c, error) => {
				GLib.log("Plac", LEVEL_ERROR, "Failed to receive MOO message: %s", error.message);
				callback();
			});

			var req_meta = new Moo.Metadata("REQUEST", service);
			var req_headers = new Moo.Headers();
			req_headers.write("Request-Id", @"$request_id");

			if (json_body != null) {
				req_headers.write("Content-Type", "application/json");
				req_headers.write("Content-Length", @"$(json_body.length)");

				conn.send_binary(@"$req_meta$req_headers$json_body".data);
			} else {
				conn.send_binary(@"$req_meta$req_headers".data);
			}

			yield;

			conn.disconnect(message_handler_id);
			conn.disconnect(error_handler_id);

			if (resp == null) {
				throw new ConnectError.SERVER_NOT_FOUND("Server not found.");
			}

			return resp;
		}

		private static async Roon.Registry.Info.Response get_registry_info(
			Soup.WebsocketConnection conn, uint64 request_id = 1
		) throws ConnectError {
			var resp = yield send_request(conn, "com.roonlabs.registry:1/info", request_id);

			if (resp.meta.service != "Success") {
				throw new ConnectError.INVALID_RESPONSE("Server error.");
			}

			if (resp.headers.content_type != "application/json") {
				throw new ConnectError.INVALID_RESPONSE("Not a JSON body.");
			}

			Roon.Registry.Info.Response info;
			try {
				var body = new Moo.JsonBody.from_string(resp.message, resp.headers);

				info = new Roon.Registry.Info.Response.from_json(body.data);
			} catch (GLib.Error error) {
				throw new ConnectError.INVALID_RESPONSE(error.message);
			}

			return info;
		}

		public async Connection connect_async(Roon.Registry.Register.Request req) throws ConnectError {
			GLib.log("Plac", LEVEL_DEBUG, @"Connecting to $(this.address.address):$(this.http_port)");

			Soup.WebsocketConnection conn;
			try {
				conn = yield ws_connect(address, http_port);
			} catch (GLib.Error error) {
				GLib.log("Plac", LEVEL_DEBUG, "Handshake error");
				throw new ConnectError.NETWORK_ERROR(error.message);
			}

			var info = yield get_registry_info(conn, 1);

			if (info.core_id != id) {
				throw new ConnectError.SERVER_MISMATCH("Got unexpected server ID.");
			}

			GLib.log("Plac", LEVEL_DEBUG, "Confirmed the Roon server is running. Registering extension.");

			var register_resp = yield send_request(conn, "com.roonlabs.registry:1/register", 2, req.to_json());
			if (register_resp.meta.service != "Registered") {
				throw new ConnectError.INVALID_RESPONSE(@"$(register_resp.meta.service)");
			}

			Roon.Registry.Register.Response result;
			try {
				var body = new Moo.JsonBody.from_string(register_resp.message, register_resp.headers);

				result = new Roon.Registry.Register.Response.from_json(body.data);
			} catch (GLib.Error error) {
				throw new ConnectError.INVALID_RESPONSE(error.message);
			}

			GLib.log("Plac", LEVEL_DEBUG, @"Registered Roon extension at $(this.address.address):$(this.http_port)");

			return new Connection(conn, this, result.token);
		}
	}
}