jellyfin-server/Emby.Server.Implementations/Session/SessionWebSocketListener.cs

347 lines
12 KiB
C#
Raw Normal View History

#nullable disable
using System;
2020-04-28 12:12:06 +00:00
using System.Collections.Generic;
2020-04-17 11:47:00 +00:00
using System.Linq;
using System.Net.WebSockets;
using System.Threading;
using System.Threading.Tasks;
using MediaBrowser.Controller.Net;
using MediaBrowser.Controller.Session;
2020-04-17 11:47:00 +00:00
using MediaBrowser.Model.Net;
using MediaBrowser.Model.Session;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
2016-11-03 23:35:19 +00:00
namespace Emby.Server.Implementations.Session
{
/// <summary>
/// Class SessionWebSocketListener.
/// </summary>
2020-11-28 08:50:16 +00:00
public sealed class SessionWebSocketListener : IWebSocketListener, IDisposable
{
2020-04-17 11:47:00 +00:00
/// <summary>
/// The timeout in seconds after which a WebSocket is considered to be lost.
/// </summary>
private const int WebSocketLostTimeout = 60;
2020-04-17 11:47:00 +00:00
/// <summary>
2020-04-28 12:12:06 +00:00
/// The keep-alive interval factor; controls how often the watcher will check on the status of the WebSockets.
2020-04-17 11:47:00 +00:00
/// </summary>
private const float IntervalFactor = 0.2f;
2020-04-17 11:47:00 +00:00
/// <summary>
/// The ForceKeepAlive factor; controls when a ForceKeepAlive is sent.
/// </summary>
private const float ForceKeepAliveFactor = 0.75f;
2020-04-17 11:47:00 +00:00
/// <summary>
/// Lock used for accesing the KeepAlive cancellation token.
/// </summary>
private readonly object _keepAliveLock = new object();
/// <summary>
/// The WebSocket watchlist.
2013-05-10 12:18:07 +00:00
/// </summary>
private readonly HashSet<IWebSocketConnection> _webSockets = new HashSet<IWebSocketConnection>();
2020-11-28 08:50:16 +00:00
2020-04-17 11:47:00 +00:00
/// <summary>
/// Lock used for accessing the WebSockets watchlist.
2020-04-28 12:12:06 +00:00
/// </summary>
private readonly object _webSocketsLock = new object();
2020-04-28 12:12:06 +00:00
/// <summary>
/// The _session manager.
2020-04-17 11:47:00 +00:00
/// </summary>
private readonly ISessionManager _sessionManager;
2020-04-17 11:47:00 +00:00
/// <summary>
/// The _logger.
2020-04-17 11:47:00 +00:00
/// </summary>
private readonly ILogger<SessionWebSocketListener> _logger;
private readonly ILoggerFactory _loggerFactory;
2020-04-28 12:12:06 +00:00
/// <summary>
/// The KeepAlive cancellation token.
2020-04-28 12:12:06 +00:00
/// </summary>
private CancellationTokenSource _keepAliveCancellationToken;
2015-03-08 19:48:30 +00:00
2013-05-10 12:18:07 +00:00
/// <summary>
/// Initializes a new instance of the <see cref="SessionWebSocketListener" /> class.
/// </summary>
2019-12-17 22:15:02 +00:00
/// <param name="logger">The logger.</param>
/// <param name="sessionManager">The session manager.</param>
/// <param name="loggerFactory">The logger factory.</param>
2019-12-17 22:15:02 +00:00
public SessionWebSocketListener(
ILogger<SessionWebSocketListener> logger,
ISessionManager sessionManager,
ILoggerFactory loggerFactory)
{
2019-12-17 22:15:02 +00:00
_logger = logger;
_sessionManager = sessionManager;
2019-12-17 22:15:02 +00:00
_loggerFactory = loggerFactory;
}
2020-11-28 08:50:16 +00:00
/// <inheritdoc />
public void Dispose()
{
StopKeepAlive();
2015-03-08 19:48:30 +00:00
}
/// <summary>
/// Processes the message.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>Task.</returns>
public Task ProcessMessageAsync(WebSocketMessageInfo message)
=> Task.CompletedTask;
/// <inheritdoc />
public async Task ProcessWebSocketConnectedAsync(IWebSocketConnection connection)
2015-03-08 19:48:30 +00:00
{
var session = GetSession(connection.QueryString, connection.RemoteEndPoint.ToString());
2015-03-08 19:48:30 +00:00
if (session != null)
{
EnsureController(session, connection);
await KeepAliveWebSocket(connection).ConfigureAwait(false);
2015-03-08 19:48:30 +00:00
}
else
{
_logger.LogWarning("Unable to determine session based on query string: {0}", connection.QueryString);
2015-03-08 19:48:30 +00:00
}
}
private SessionInfo GetSession(IQueryCollection queryString, string remoteEndpoint)
2015-03-08 19:48:30 +00:00
{
2015-03-16 16:47:14 +00:00
if (queryString == null)
{
return null;
2015-03-16 16:47:14 +00:00
}
2015-03-08 19:48:30 +00:00
var token = queryString["api_key"];
if (string.IsNullOrWhiteSpace(token))
{
2018-09-12 17:26:21 +00:00
return null;
}
2015-03-13 01:55:22 +00:00
var deviceId = queryString["deviceId"];
return _sessionManager.GetSessionByAuthenticationToken(token, deviceId, remoteEndpoint);
2015-03-08 19:48:30 +00:00
}
2018-09-12 17:26:21 +00:00
private void EnsureController(SessionInfo session, IWebSocketConnection connection)
2014-04-16 02:17:48 +00:00
{
2019-12-17 22:15:02 +00:00
var controllerInfo = session.EnsureController<WebSocketController>(
s => new WebSocketController(_loggerFactory.CreateLogger<WebSocketController>(), s, _sessionManager));
2014-04-16 02:17:48 +00:00
2018-09-12 17:26:21 +00:00
var controller = (WebSocketController)controllerInfo.Item1;
controller.AddWebSocket(connection);
2020-12-07 00:04:48 +00:00
_sessionManager.OnSessionControllerConnected(session);
2013-10-03 01:22:50 +00:00
}
2020-04-17 11:47:00 +00:00
/// <summary>
/// Called when a WebSocket is closed.
/// </summary>
/// <param name="sender">The WebSocket.</param>
/// <param name="e">The event arguments.</param>
2020-04-21 21:37:37 +00:00
private void OnWebSocketClosed(object sender, EventArgs e)
2020-04-17 11:47:00 +00:00
{
2020-05-26 09:37:52 +00:00
var webSocket = (IWebSocketConnection)sender;
2020-05-04 17:46:02 +00:00
_logger.LogDebug("WebSocket {0} is closed.", webSocket);
2020-04-21 21:37:37 +00:00
RemoveWebSocket(webSocket);
2020-04-17 11:47:00 +00:00
}
/// <summary>
/// Adds a WebSocket to the KeepAlive watchlist.
/// </summary>
/// <param name="webSocket">The WebSocket to monitor.</param>
2020-05-26 09:37:52 +00:00
private async Task KeepAliveWebSocket(IWebSocketConnection webSocket)
2020-04-17 11:47:00 +00:00
{
2020-04-28 12:12:06 +00:00
lock (_webSocketsLock)
2020-04-21 21:37:37 +00:00
{
2020-04-28 12:12:06 +00:00
if (!_webSockets.Add(webSocket))
{
_logger.LogWarning("Multiple attempts to keep alive single WebSocket {0}", webSocket);
return;
}
2020-06-15 21:43:52 +00:00
2020-04-28 12:12:06 +00:00
webSocket.Closed += OnWebSocketClosed;
webSocket.LastKeepAliveDate = DateTime.UtcNow;
StartKeepAlive();
2020-04-21 21:37:37 +00:00
}
2020-04-17 11:47:00 +00:00
// Notify WebSocket about timeout
try
{
2020-07-24 14:37:54 +00:00
await SendForceKeepAlive(webSocket).ConfigureAwait(false);
2020-04-17 11:47:00 +00:00
}
catch (WebSocketException exception)
{
2020-05-04 17:46:02 +00:00
_logger.LogWarning(exception, "Cannot send ForceKeepAlive message to WebSocket {0}.", webSocket);
2020-04-17 11:47:00 +00:00
}
}
2020-04-21 21:37:37 +00:00
/// <summary>
/// Removes a WebSocket from the KeepAlive watchlist.
/// </summary>
/// <param name="webSocket">The WebSocket to remove.</param>
private void RemoveWebSocket(IWebSocketConnection webSocket)
{
2020-04-28 12:12:06 +00:00
lock (_webSocketsLock)
{
if (!_webSockets.Remove(webSocket))
{
_logger.LogWarning("WebSocket {0} not on watchlist.", webSocket);
}
else
{
webSocket.Closed -= OnWebSocketClosed;
}
}
2020-04-21 21:37:37 +00:00
}
2020-04-17 11:47:00 +00:00
/// <summary>
2020-04-28 12:12:06 +00:00
/// Starts the KeepAlive watcher.
2020-04-17 11:47:00 +00:00
/// </summary>
2020-04-28 12:12:06 +00:00
private void StartKeepAlive()
2020-04-17 11:47:00 +00:00
{
2020-04-28 12:12:06 +00:00
lock (_keepAliveLock)
2020-04-17 11:47:00 +00:00
{
2020-04-28 12:12:06 +00:00
if (_keepAliveCancellationToken == null)
{
_keepAliveCancellationToken = new CancellationTokenSource();
// Start KeepAlive watcher
2020-05-09 12:34:07 +00:00
_ = RepeatAsyncCallbackEvery(
2020-05-04 17:46:02 +00:00
KeepAliveSockets,
2020-04-28 12:12:06 +00:00
TimeSpan.FromSeconds(WebSocketLostTimeout * IntervalFactor),
_keepAliveCancellationToken.Token);
}
2020-04-17 11:47:00 +00:00
}
}
/// <summary>
2020-04-28 12:12:06 +00:00
/// Stops the KeepAlive watcher.
2020-04-17 11:47:00 +00:00
/// </summary>
2020-04-28 12:12:06 +00:00
private void StopKeepAlive()
2020-04-17 11:47:00 +00:00
{
2020-04-28 12:12:06 +00:00
lock (_keepAliveLock)
2020-04-17 11:47:00 +00:00
{
2020-04-28 12:12:06 +00:00
if (_keepAliveCancellationToken != null)
{
_keepAliveCancellationToken.Cancel();
2020-07-24 14:37:54 +00:00
_keepAliveCancellationToken.Dispose();
2020-04-28 12:12:06 +00:00
_keepAliveCancellationToken = null;
}
2020-04-17 11:47:00 +00:00
}
2020-04-28 12:12:06 +00:00
lock (_webSocketsLock)
2020-04-17 11:47:00 +00:00
{
2020-04-28 12:12:06 +00:00
foreach (var webSocket in _webSockets)
{
webSocket.Closed -= OnWebSocketClosed;
}
2020-05-09 12:34:07 +00:00
2020-04-28 12:12:06 +00:00
_webSockets.Clear();
2020-04-17 11:47:00 +00:00
}
}
/// <summary>
2020-05-04 17:46:02 +00:00
/// Checks status of KeepAlive of WebSockets.
2020-04-17 11:47:00 +00:00
/// </summary>
2020-05-04 17:46:02 +00:00
private async Task KeepAliveSockets()
2020-04-17 11:47:00 +00:00
{
2020-05-09 12:34:07 +00:00
List<IWebSocketConnection> inactive;
List<IWebSocketConnection> lost;
2020-05-04 17:46:02 +00:00
lock (_webSocketsLock)
2020-04-17 11:47:00 +00:00
{
2020-05-04 17:46:02 +00:00
_logger.LogDebug("Watching {0} WebSockets.", _webSockets.Count);
2020-04-17 11:47:00 +00:00
2020-05-04 17:46:02 +00:00
inactive = _webSockets.Where(i =>
2020-04-28 12:12:06 +00:00
{
2020-05-04 17:46:02 +00:00
var elapsed = (DateTime.UtcNow - i.LastKeepAliveDate).TotalSeconds;
return (elapsed > WebSocketLostTimeout * ForceKeepAliveFactor) && (elapsed < WebSocketLostTimeout);
2020-05-09 12:34:07 +00:00
}).ToList();
lost = _webSockets.Where(i => (DateTime.UtcNow - i.LastKeepAliveDate).TotalSeconds >= WebSocketLostTimeout).ToList();
2020-05-04 17:46:02 +00:00
}
2020-04-17 11:47:00 +00:00
2020-07-24 14:37:54 +00:00
if (inactive.Count > 0)
2020-05-04 17:46:02 +00:00
{
2020-05-15 18:06:41 +00:00
_logger.LogInformation("Sending ForceKeepAlive message to {0} inactive WebSockets.", inactive.Count);
2020-05-04 17:46:02 +00:00
}
foreach (var webSocket in inactive)
{
try
2020-04-17 11:47:00 +00:00
{
2020-07-24 14:37:54 +00:00
await SendForceKeepAlive(webSocket).ConfigureAwait(false);
2020-04-17 11:47:00 +00:00
}
2020-05-04 17:46:02 +00:00
catch (WebSocketException exception)
2020-04-17 11:47:00 +00:00
{
2020-05-04 17:46:02 +00:00
_logger.LogInformation(exception, "Error sending ForceKeepAlive message to WebSocket.");
2020-05-09 12:34:07 +00:00
lost.Add(webSocket);
2020-04-17 11:47:00 +00:00
}
2020-05-04 17:46:02 +00:00
}
2020-04-17 11:47:00 +00:00
2020-05-04 17:46:02 +00:00
lock (_webSocketsLock)
{
2020-07-24 14:37:54 +00:00
if (lost.Count > 0)
2020-04-21 21:37:37 +00:00
{
2020-05-15 18:06:41 +00:00
_logger.LogInformation("Lost {0} WebSockets.", lost.Count);
2020-05-09 12:34:07 +00:00
foreach (var webSocket in lost)
2020-04-28 12:12:06 +00:00
{
2020-05-04 17:46:02 +00:00
// TODO: handle session relative to the lost webSocket
RemoveWebSocket(webSocket);
2020-04-28 12:12:06 +00:00
}
2020-04-21 21:37:37 +00:00
}
2020-04-17 11:47:00 +00:00
2020-07-24 14:37:54 +00:00
if (_webSockets.Count == 0)
2020-04-28 12:12:06 +00:00
{
2020-05-04 17:46:02 +00:00
StopKeepAlive();
2020-04-28 12:12:06 +00:00
}
2020-04-17 11:47:00 +00:00
}
}
/// <summary>
/// Sends a ForceKeepAlive message to a WebSocket.
/// </summary>
/// <param name="webSocket">The WebSocket.</param>
/// <returns>Task.</returns>
private Task SendForceKeepAlive(IWebSocketConnection webSocket)
{
2020-07-24 14:37:54 +00:00
return webSocket.SendAsync(
new WebSocketMessage<int>
{
MessageType = SessionMessageType.ForceKeepAlive,
2020-07-24 14:37:54 +00:00
Data = WebSocketLostTimeout
},
CancellationToken.None);
2020-04-17 11:47:00 +00:00
}
2020-05-04 17:46:02 +00:00
/// <summary>
/// Runs a given async callback once every specified interval time, until cancelled.
/// </summary>
/// <param name="callback">The async callback.</param>
/// <param name="interval">The interval time.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
private async Task RepeatAsyncCallbackEvery(Func<Task> callback, TimeSpan interval, CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
2020-07-24 14:37:54 +00:00
await callback().ConfigureAwait(false);
2020-05-04 17:46:02 +00:00
try
{
2020-07-24 14:37:54 +00:00
await Task.Delay(interval, cancellationToken).ConfigureAwait(false);
2020-05-04 17:46:02 +00:00
}
catch (TaskCanceledException)
{
return;
}
}
}
}
}