diff options
Diffstat (limited to 'Emby.Server.Implementations/HttpServer/WebSocketConnection.cs')
| -rw-r--r-- | Emby.Server.Implementations/HttpServer/WebSocketConnection.cs | 290 |
1 files changed, 290 insertions, 0 deletions
diff --git a/Emby.Server.Implementations/HttpServer/WebSocketConnection.cs b/Emby.Server.Implementations/HttpServer/WebSocketConnection.cs new file mode 100644 index 000000000..d449e4424 --- /dev/null +++ b/Emby.Server.Implementations/HttpServer/WebSocketConnection.cs @@ -0,0 +1,290 @@ +using System.Text; +using MediaBrowser.Common.Events; +using MediaBrowser.Controller.Net; +using MediaBrowser.Model.Logging; +using MediaBrowser.Model.Net; +using MediaBrowser.Model.Serialization; +using System; +using System.Threading; +using System.Threading.Tasks; +using MediaBrowser.Model.Services; +using MediaBrowser.Model.Text; +using System.Net.WebSockets; +using Emby.Server.Implementations.Net; + +namespace Emby.Server.Implementations.HttpServer +{ + /// <summary> + /// Class WebSocketConnection + /// </summary> + public class WebSocketConnection : IWebSocketConnection + { + public event EventHandler<EventArgs> Closed; + + /// <summary> + /// The _socket + /// </summary> + private readonly IWebSocket _socket; + + /// <summary> + /// The _remote end point + /// </summary> + public string RemoteEndPoint { get; private set; } + + /// <summary> + /// The logger + /// </summary> + private readonly ILogger _logger; + + /// <summary> + /// The _json serializer + /// </summary> + private readonly IJsonSerializer _jsonSerializer; + + /// <summary> + /// Gets or sets the receive action. + /// </summary> + /// <value>The receive action.</value> + public Func<WebSocketMessageInfo, Task> OnReceive { get; set; } + + /// <summary> + /// Gets the last activity date. + /// </summary> + /// <value>The last activity date.</value> + public DateTime LastActivityDate { get; private set; } + + /// <summary> + /// Gets the id. + /// </summary> + /// <value>The id.</value> + public Guid Id { get; private set; } + + /// <summary> + /// Gets or sets the URL. + /// </summary> + /// <value>The URL.</value> + public string Url { get; set; } + /// <summary> + /// Gets or sets the query string. + /// </summary> + /// <value>The query string.</value> + public QueryParamCollection QueryString { get; set; } + private readonly ITextEncoding _textEncoding; + + /// <summary> + /// Initializes a new instance of the <see cref="WebSocketConnection" /> class. + /// </summary> + /// <param name="socket">The socket.</param> + /// <param name="remoteEndPoint">The remote end point.</param> + /// <param name="jsonSerializer">The json serializer.</param> + /// <param name="logger">The logger.</param> + /// <exception cref="System.ArgumentNullException">socket</exception> + public WebSocketConnection(IWebSocket socket, string remoteEndPoint, IJsonSerializer jsonSerializer, ILogger logger, ITextEncoding textEncoding) + { + if (socket == null) + { + throw new ArgumentNullException("socket"); + } + if (string.IsNullOrEmpty(remoteEndPoint)) + { + throw new ArgumentNullException("remoteEndPoint"); + } + if (jsonSerializer == null) + { + throw new ArgumentNullException("jsonSerializer"); + } + if (logger == null) + { + throw new ArgumentNullException("logger"); + } + + Id = Guid.NewGuid(); + _jsonSerializer = jsonSerializer; + _socket = socket; + _socket.OnReceiveBytes = OnReceiveInternal; + + var memorySocket = socket as IMemoryWebSocket; + if (memorySocket != null) + { + memorySocket.OnReceiveMemoryBytes = OnReceiveInternal; + } + + RemoteEndPoint = remoteEndPoint; + _logger = logger; + _textEncoding = textEncoding; + + socket.Closed += socket_Closed; + } + + void socket_Closed(object sender, EventArgs e) + { + EventHelper.FireEventIfNotNull(Closed, this, EventArgs.Empty, _logger); + } + + /// <summary> + /// Called when [receive]. + /// </summary> + /// <param name="bytes">The bytes.</param> + private void OnReceiveInternal(byte[] bytes) + { + LastActivityDate = DateTime.UtcNow; + + if (OnReceive == null) + { + return; + } + + var charset = _textEncoding.GetDetectedEncodingName(bytes, bytes.Length, null, false); + + if (string.Equals(charset, "utf-8", StringComparison.OrdinalIgnoreCase)) + { + OnReceiveInternal(Encoding.UTF8.GetString(bytes, 0, bytes.Length)); + } + else + { + OnReceiveInternal(_textEncoding.GetASCIIEncoding().GetString(bytes, 0, bytes.Length)); + } + } + + /// <summary> + /// Called when [receive]. + /// </summary> + /// <param name="bytes">The bytes.</param> + private void OnReceiveInternal(Memory<byte> memory, int length) + { + LastActivityDate = DateTime.UtcNow; + + if (OnReceive == null) + { + return; + } + + var bytes = memory.Slice(0, length).ToArray(); + + var charset = _textEncoding.GetDetectedEncodingName(bytes, bytes.Length, null, false); + + if (string.Equals(charset, "utf-8", StringComparison.OrdinalIgnoreCase)) + { + OnReceiveInternal(Encoding.UTF8.GetString(bytes, 0, bytes.Length)); + } + else + { + OnReceiveInternal(_textEncoding.GetASCIIEncoding().GetString(bytes, 0, bytes.Length)); + } + } + + private void OnReceiveInternal(string message) + { + LastActivityDate = DateTime.UtcNow; + + if (!message.StartsWith("{", StringComparison.OrdinalIgnoreCase)) + { + // This info is useful sometimes but also clogs up the log + //_logger.Error("Received web socket message that is not a json structure: " + message); + return; + } + + if (OnReceive == null) + { + return; + } + + try + { + var stub = (WebSocketMessage<object>)_jsonSerializer.DeserializeFromString(message, typeof(WebSocketMessage<object>)); + + var info = new WebSocketMessageInfo + { + MessageType = stub.MessageType, + Data = stub.Data == null ? null : stub.Data.ToString(), + Connection = this + }; + + OnReceive(info); + } + catch (Exception ex) + { + _logger.ErrorException("Error processing web socket message", ex); + } + } + + /// <summary> + /// Sends a message asynchronously. + /// </summary> + /// <typeparam name="T"></typeparam> + /// <param name="message">The message.</param> + /// <param name="cancellationToken">The cancellation token.</param> + /// <returns>Task.</returns> + /// <exception cref="System.ArgumentNullException">message</exception> + public Task SendAsync<T>(WebSocketMessage<T> message, CancellationToken cancellationToken) + { + if (message == null) + { + throw new ArgumentNullException("message"); + } + + var json = _jsonSerializer.SerializeToString(message); + + return SendAsync(json, cancellationToken); + } + + /// <summary> + /// Sends a message asynchronously. + /// </summary> + /// <param name="buffer">The buffer.</param> + /// <param name="cancellationToken">The cancellation token.</param> + /// <returns>Task.</returns> + public Task SendAsync(byte[] buffer, CancellationToken cancellationToken) + { + if (buffer == null) + { + throw new ArgumentNullException("buffer"); + } + + cancellationToken.ThrowIfCancellationRequested(); + + return _socket.SendAsync(buffer, true, cancellationToken); + } + + public Task SendAsync(string text, CancellationToken cancellationToken) + { + if (string.IsNullOrEmpty(text)) + { + throw new ArgumentNullException("text"); + } + + cancellationToken.ThrowIfCancellationRequested(); + + return _socket.SendAsync(text, true, cancellationToken); + } + + /// <summary> + /// Gets the state. + /// </summary> + /// <value>The state.</value> + public WebSocketState State + { + get { return _socket.State; } + } + + /// <summary> + /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + /// </summary> + public void Dispose() + { + Dispose(true); + } + + /// <summary> + /// Releases unmanaged and - optionally - managed resources. + /// </summary> + /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> + protected virtual void Dispose(bool dispose) + { + if (dispose) + { + _socket.Dispose(); + } + } + } +} |