diff --git a/src/client/spark_websocket/Core/WebsocketConnectNotification.cs b/src/client/spark_websocket/Core/WebsocketConnectNotification.cs new file mode 100644 index 000000000..d73c4c448 --- /dev/null +++ b/src/client/spark_websocket/Core/WebsocketConnectNotification.cs @@ -0,0 +1,14 @@ +namespace Bts.Websocket; + +using bts.websocket_core; + +public class WebsocketConnectNotification { + public WebsocketConnectNotification( + WebsocketClientID id, WebsocketIncomingMessage? message = null) { + Id = id; + Message = message; + } + + public WebsocketClientID Id { get; } + public WebsocketIncomingMessage? Message { get; } +} diff --git a/src/client/spark_websocket/Core/WebsocketConnectionUpdate.cs b/src/client/spark_websocket/Core/WebsocketConnectionUpdate.cs new file mode 100644 index 000000000..6951a6eda --- /dev/null +++ b/src/client/spark_websocket/Core/WebsocketConnectionUpdate.cs @@ -0,0 +1,73 @@ +namespace Bts.Websocket; + +using bts.websocket_core; + +public class WebsocketConnectionUpdate { + readonly WebsocketClientID? connection; + readonly WebsocketIncomingMessage? incomingMessage; + readonly WebsocketOutgoingMessage? outgoingMessage; + readonly WebsocketConnectNotification? connect; + readonly WebsocketDisconnectNotification? disconnect; + + WebsocketConnectionUpdate( + WebsocketClientID connection, + WebsocketIncomingMessage? incomingMessage = null, + WebsocketOutgoingMessage? outgoingMessage = null, + WebsocketConnectNotification? connect = null, + WebsocketDisconnectNotification? disconnect = null) { + this.connection = connection; + this.incomingMessage = incomingMessage; + this.outgoingMessage = outgoingMessage; + this.connect = connect; + this.disconnect = disconnect; + } + + public static WebsocketConnectionUpdate Create( + WebsocketClientID connection, WebsocketConnectNotification connect) => + new(connection, connect: connect); + + public static WebsocketConnectionUpdate Create( + WebsocketClientID connection, WebsocketDisconnectNotification disconnect) => + new(connection, disconnect: disconnect); + + public static WebsocketConnectionUpdate Create( + WebsocketClientID connection, WebsocketIncomingMessage incomingMessage) => + new(connection, incomingMessage: incomingMessage); + + public static WebsocketConnectionUpdate Create( + WebsocketClientID connection, WebsocketOutgoingMessage outgoingMessage) => + new(connection, outgoingMessage: outgoingMessage); + + public WebsocketClientID Connection => + connection ?? throw new InvalidOperationException(); + + public WebsocketConnectionUpdateType Type { + get { + if (incomingMessage is not null) { + return WebsocketConnectionUpdateType.IncomingMessage; + } + if (outgoingMessage is not null) { + return WebsocketConnectionUpdateType.OutgoingMessage; + } + if (connect is not null) { + return WebsocketConnectionUpdateType.Connect; + } + if (disconnect is not null) { + return WebsocketConnectionUpdateType.Disconnect; + } + return WebsocketConnectionUpdateType.Unspecified; + } + } + + public WebsocketIncomingMessage IncomingMessage => + incomingMessage ?? throw new InvalidOperationException(); + + public WebsocketOutgoingMessage OutgoingMessage => + outgoingMessage ?? throw new InvalidOperationException(); + + public WebsocketConnectNotification Connect => + connect ?? throw new InvalidOperationException(); + + public WebsocketDisconnectNotification Disconnect => + disconnect ?? throw new InvalidOperationException(); +} diff --git a/src/client/spark_websocket/Core/WebsocketConnectionUpdateType.cs b/src/client/spark_websocket/Core/WebsocketConnectionUpdateType.cs new file mode 100644 index 000000000..6de37b1b7 --- /dev/null +++ b/src/client/spark_websocket/Core/WebsocketConnectionUpdateType.cs @@ -0,0 +1,9 @@ +namespace Bts.Websocket; + +public enum WebsocketConnectionUpdateType { + Unspecified, + Connect, + IncomingMessage, + OutgoingMessage, + Disconnect +}; diff --git a/src/client/spark_websocket/Core/WebsocketDisconnectNotification.cs b/src/client/spark_websocket/Core/WebsocketDisconnectNotification.cs new file mode 100644 index 000000000..a6b93ae24 --- /dev/null +++ b/src/client/spark_websocket/Core/WebsocketDisconnectNotification.cs @@ -0,0 +1,10 @@ +namespace Bts.Websocket; + +using bts.websocket_core; + +public class WebsocketDisconnectNotification { + public WebsocketDisconnectNotification(WebsocketClientID id) => + Id = id; + + public WebsocketClientID Id { get; } +} diff --git a/src/client/spark_websocket/Core/WebsocketGatewayObservable.cs b/src/client/spark_websocket/Core/WebsocketGatewayObservable.cs new file mode 100644 index 000000000..464acd87a --- /dev/null +++ b/src/client/spark_websocket/Core/WebsocketGatewayObservable.cs @@ -0,0 +1,108 @@ +namespace Bts.Websocket; + +using bts; +using bts.websocket_core; + +using mbts; + +using System; +using System.Reactive.Subjects; + +/// +/// Represents an I/O model that provides websocket requests from clients as output, and accepts +/// data/notifications to send back to the clients as input. This class doesn't interpret clients' +/// requests; it doesn't subscribe to data on their behalf. It emits those requests as output so +/// someone else can. +/// +public class WebsocketGatewayObservable : IConnectableObservable, ISubject, WebsocketConnectionUpdate>, IDisposable { + readonly WebsocketServerConfig config; + readonly object lockObj = new(); + IWebsocketConnectionGateway? gatewayBacking; + + public WebsocketGatewayObservable(WebsocketServerConfig config) + : this(new WebsocketConnectionGateway(), config) { } + + public WebsocketGatewayObservable( + IWebsocketConnectionGateway gateway, WebsocketServerConfig config) { + gatewayBacking = gateway; + this.config = config; + } + + IWebsocketConnectionGateway gateway => + /// The gateway is (only) set to null in + gatewayBacking ?? throw new ObjectDisposedException($"{GetType()}"); + + public IDisposable Connect() { + IWebsocketConnectionGateway? gw; + lock (lockObj) { + gw = gateway; + ConnectAsync().ignore(); + return this; + } + } + + public async Task ConnectAsync() { + var gw = gateway; + try { + await gw.start_listening(config); + } catch (Exception ex) { + Log.Api.error($"Error running {typeof(IWebsocketConnectionGateway)}: {ex}"); + throw; + } + } + + public void OnCompleted() => + Log.Api.warn($"{GetType()} outgoing message stream completed."); + + public void OnError(Exception error) => + Log.Api.error($"{GetType()} detected error in outgoing message stream: {error}"); + + public void OnNext(IEnumerable outMessages) => + gateway.send_to_clients(outMessages); + + public IDisposable Subscribe(IObserver observer) { + lock (lockObj) { + return new Subscription(observer, gateway); + } + } + + public void Dispose() { + lock (lockObj) { + (gatewayBacking as IDisposable)?.Dispose(); + gatewayBacking = null; + } + } + + class Subscription : IDisposable { + readonly IObserver observer; + readonly IWebsocketConnectionGateway gateway; + + public Subscription( + IObserver observer, IWebsocketConnectionGateway gateway) { + this.observer = observer; + this.gateway = gateway; + gateway.Connected += onConnected; + gateway.Disconnected += onDisconnected; + gateway.MessageReceived += onMessageReceived; + } + + public void Dispose() { + gateway.Connected -= onConnected; + gateway.Disconnected -= onDisconnected; + gateway.MessageReceived -= onMessageReceived; + } + + void onConnected(WebsocketClientID id, WebsocketIncomingMessage? message) { + observer.OnNext(WebsocketConnectionUpdate.Create( + id, new WebsocketConnectNotification(id, message))); + } + + void onDisconnected(WebsocketClientID id) => + observer.OnNext(WebsocketConnectionUpdate.Create( + id, new WebsocketDisconnectNotification(id))); + + void onMessageReceived(WebsocketIncomingMessage message) => + observer.OnNext(WebsocketConnectionUpdate.Create( + message.sender_client_id, message)); + } +}