open-source-mirrors
/
jellyfin
mirror of https://github.com/jellyfin/jellyfin
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Clean up server discovery code

Browse Source
pull/2264/head
Bond-009 5 years ago
parent d217f1614e
commit ded9857f45
6 changed files with 74 additions and 298 deletions
Show Stats Download Patch File Download Diff File

58
Emby.Server.Implementations/EntryPoints/UdpServerEntryPoint.cs
Unescape View File

@ -1,4 +1,5 @@
using System; using System;
using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using Emby.Server.Implementations.Udp; using Emby.Server.Implementations.Udp;
using MediaBrowser.Controller; using MediaBrowser.Controller;
@ -12,7 +13,7 @@ namespace Emby.Server.Implementations.EntryPoints
/// <summary> /// <summary>
/// Class UdpServerEntryPoint. /// Class UdpServerEntryPoint.
/// </summary> /// </summary>
public class UdpServerEntryPoint : IServerEntryPoint public sealed class UdpServerEntryPoint : IServerEntryPoint
{ {
/// <summary> /// <summary>
/// The port of the UDP server. /// The port of the UDP server.
@ -31,61 +32,44 @@ namespace Emby.Server.Implementations.EntryPoints
/// The UDP server. /// The UDP server.
/// </summary> /// </summary>
private UdpServer _udpServer; private UdpServer _udpServer;
private CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
private bool _disposed = false;
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="UdpServerEntryPoint" /> class. /// Initializes a new instance of the <see cref="UdpServerEntryPoint" /> class.
/// </summary> /// </summary>
public UdpServerEntryPoint( public UdpServerEntryPoint(
ILogger logger, ILogger<UdpServerEntryPoint> logger,
IServerApplicationHost appHost, IServerApplicationHost appHost)
IJsonSerializer json,
ISocketFactory socketFactory)
{ {
_logger = logger; _logger = logger;
_appHost = appHost; _appHost = appHost;
_json = json;
_socketFactory = socketFactory;
}
/// <inheritdoc />
public Task RunAsync()
{
var udpServer = new UdpServer(_logger, _appHost, _json, _socketFactory);
try
{
udpServer.Start(PortNumber);
_udpServer = udpServer;
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to start UDP Server");
}
return Task.CompletedTask;
} }
/// <inheritdoc /> /// <inheritdoc />
public void Dispose() public async Task RunAsync()
{ {
Dispose(true); _udpServer = new UdpServer(_logger, _appHost);
GC.SuppressFinalize(this); _udpServer.Start(PortNumber, _cancellationTokenSource.Token);
} }
/// <summary> /// <inheritdoc />
/// Releases unmanaged and - optionally - managed resources. public void Dispose()
/// </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) if (_disposed)
{ {
if (_udpServer != null) return;
{
_udpServer.Dispose();
}
} }
_cancellationTokenSource.Cancel();
_udpServer.Dispose();
_cancellationTokenSource = null;
_udpServer = null;
_disposed = true;
} }
} }
} }

29
Emby.Server.Implementations/Net/SocketFactory.cs
Unescape View File

@ -8,32 +8,6 @@ namespace Emby.Server.Implementations.Net
{ {
public class SocketFactory : ISocketFactory public class SocketFactory : ISocketFactory
{ {
/// <summary>
/// Creates a new UDP acceptSocket and binds it to the specified local port.
/// </summary>
/// <param name="localPort">An integer specifying the local port to bind the acceptSocket to.</param>
public ISocket CreateUdpSocket(int localPort)
{
if (localPort < 0)
{
throw new ArgumentException("localPort cannot be less than zero.", nameof(localPort));
}
var retVal = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
try
{
retVal.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
return new UdpSocket(retVal, localPort, IPAddress.Any);
}
catch
{
retVal?.Dispose();
throw;
}
}
public ISocket CreateUdpBroadcastSocket(int localPort) public ISocket CreateUdpBroadcastSocket(int localPort)
{ {
if (localPort < 0) if (localPort < 0)
@ -156,8 +130,5 @@ namespace Emby.Server.Implementations.Net
throw; throw;
} }
} }
public Stream CreateNetworkStream(ISocket socket, bool ownsSocket)
=> new NetworkStream(((UdpSocket)socket).Socket, ownsSocket);
} }
} }

9
Emby.Server.Implementations/Net/UdpSocket.cs
Unescape View File

@ -181,15 +181,6 @@ namespace Emby.Server.Implementations.Net
return taskCompletion.Task; return taskCompletion.Task;
} }
public Task<SocketReceiveResult> ReceiveAsync(CancellationToken cancellationToken)
{
ThrowIfDisposed();
var buffer = new byte[8192];
return ReceiveAsync(buffer, 0, buffer.Length, cancellationToken);
}
public Task SendToAsync(byte[] buffer, int offset, int size, IPEndPoint endPoint, CancellationToken cancellationToken) public Task SendToAsync(byte[] buffer, int offset, int size, IPEndPoint endPoint, CancellationToken cancellationToken)
{ {
ThrowIfDisposed(); ThrowIfDisposed();

265
Emby.Server.Implementations/Udp/UdpServer.cs
Unescape View File

@ -1,112 +1,47 @@
using System; using System;
using System.Collections.Generic;
using System.Linq;
using System.Net; using System.Net;
using System.Net.Sockets;
using System.Text; using System.Text;
using System.Text.Json;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using MediaBrowser.Controller; using MediaBrowser.Controller;
using MediaBrowser.Model.ApiClient; using MediaBrowser.Model.ApiClient;
using MediaBrowser.Model.Events;
using MediaBrowser.Model.Net;
using MediaBrowser.Model.Serialization;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
namespace Emby.Server.Implementations.Udp namespace Emby.Server.Implementations.Udp
{ {
/// <summary> /// <summary>
/// Provides a Udp Server /// Provides a Udp Server.
/// </summary> /// </summary>
public class UdpServer : IDisposable public sealed class UdpServer : IDisposable
{ {
/// <summary> /// <summary>
/// The _logger /// The _logger
/// </summary> /// </summary>
private readonly ILogger _logger; private readonly ILogger _logger;
private bool _isDisposed;
private readonly List<Tuple<string, bool, Func<string, IPEndPoint, Encoding, CancellationToken, Task>>> _responders = new List<Tuple<string, bool, Func<string, IPEndPoint, Encoding, CancellationToken, Task>>>();
private readonly IServerApplicationHost _appHost; private readonly IServerApplicationHost _appHost;
private readonly IJsonSerializer _json;
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="UdpServer" /> class. /// The _udp client.
/// </summary> /// </summary>
public UdpServer(ILogger logger, IServerApplicationHost appHost, IJsonSerializer json, ISocketFactory socketFactory) private Socket _udpSocket;
{ private IPEndPoint _endpoint;
_logger = logger; private readonly byte[] _receiveBuffer = new byte[8192];
_appHost = appHost;
_json = json;
_socketFactory = socketFactory;
AddMessageResponder("who is JellyfinServer?", true, RespondToV2Message);
}
private void AddMessageResponder(string message, bool isSubstring, Func<string, IPEndPoint, Encoding, CancellationToken, Task> responder) private bool _disposed = false;
{
_responders.Add(new Tuple<string, bool, Func<string, IPEndPoint, Encoding, CancellationToken, Task>>(message, isSubstring, responder));
}
/// <summary> /// <summary>
/// Raises the <see cref="E:MessageReceived" /> event. /// Initializes a new instance of the <see cref="UdpServer" /> class.
/// </summary> /// </summary>
private async void OnMessageReceived(GenericEventArgs<SocketReceiveResult> e) public UdpServer(ILogger logger, IServerApplicationHost appHost)
{
var message = e.Argument;
var encoding = Encoding.UTF8;
var responder = GetResponder(message.Buffer, message.ReceivedBytes, encoding);
if (responder == null)
{
encoding = Encoding.Unicode;
responder = GetResponder(message.Buffer, message.ReceivedBytes, encoding);
}
if (responder != null)
{
var cancellationToken = CancellationToken.None;
try
{
await responder.Item2.Item3(responder.Item1, message.RemoteEndPoint, encoding, cancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
}
catch (Exception ex)
{
_logger.LogError(ex, "Error in OnMessageReceived");
}
}
}
private Tuple<string, Tuple<string, bool, Func<string, IPEndPoint, Encoding, CancellationToken, Task>>> GetResponder(byte[] buffer, int bytesReceived, Encoding encoding)
{ {
var text = encoding.GetString(buffer, 0, bytesReceived); _logger = logger;
var responder = _responders.FirstOrDefault(i => _appHost = appHost;
{
if (i.Item2)
{
return text.IndexOf(i.Item1, StringComparison.OrdinalIgnoreCase) != -1;
}
return string.Equals(i.Item1, text, StringComparison.OrdinalIgnoreCase);
});
if (responder == null)
{
return null;
}
return new Tuple<string, Tuple<string, bool, Func<string, IPEndPoint, Encoding, CancellationToken, Task>>>(text, responder);
} }
private async Task RespondToV2Message(string messageText, IPEndPoint endpoint, Encoding encoding, CancellationToken cancellationToken) private async Task RespondToV2Message(string messageText, EndPoint endpoint, CancellationToken cancellationToken)
{ {
var parts = messageText.Split('|');
var localUrl = await _appHost.GetLocalApiUrl(cancellationToken).ConfigureAwait(false); var localUrl = await _appHost.GetLocalApiUrl(cancellationToken).ConfigureAwait(false);
if (!string.IsNullOrEmpty(localUrl)) if (!string.IsNullOrEmpty(localUrl))
@ -118,8 +53,16 @@ namespace Emby.Server.Implementations.Udp
Name = _appHost.FriendlyName Name = _appHost.FriendlyName
}; };
await SendAsync(encoding.GetBytes(_json.SerializeToString(response)), endpoint, cancellationToken).ConfigureAwait(false); try
{
await _udpSocket.SendToAsync(JsonSerializer.SerializeToUtf8Bytes(response), SocketFlags.None, endpoint).ConfigureAwait(false);
}
catch (SocketException ex)
{
_logger.LogError(ex, "Error sending response message");
}
var parts = messageText.Split('|');
if (parts.Length > 1) if (parts.Length > 1)
{ {
_appHost.EnableLoopback(parts[1]); _appHost.EnableLoopback(parts[1]);
@ -131,162 +74,60 @@ namespace Emby.Server.Implementations.Udp
} }
} }
/// <summary>
/// The _udp client
/// </summary>
private ISocket _udpClient;
private readonly ISocketFactory _socketFactory;
/// <summary> /// <summary>
/// Starts the specified port. /// Starts the specified port.
/// </summary> /// </summary>
/// <param name="port">The port.</param> /// <param name="port">The port.</param>
public void Start(int port) /// <param name="cancellationToken"></param>
{ public void Start(int port, CancellationToken cancellationToken)
_udpClient = _socketFactory.CreateUdpSocket(port);
Task.Run(() => BeginReceive());
}
private readonly byte[] _receiveBuffer = new byte[8192];
private void BeginReceive()
{ {
if (_isDisposed) _endpoint = new IPEndPoint(IPAddress.Any, port);
{
return;
}
try _udpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
{ _udpSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
var result = _udpClient.BeginReceive(_receiveBuffer, 0, _receiveBuffer.Length, OnReceiveResult); _udpSocket.Bind(_endpoint);
if (result.CompletedSynchronously) _ = Task.Run(async () => await BeginReceiveAsync(cancellationToken).ConfigureAwait(false), cancellationToken).ConfigureAwait(false);
{
OnReceiveResult(result);
}
}
catch (ObjectDisposedException)
{
//TODO Investigate and properly fix.
}
catch (Exception ex)
{
_logger.LogError(ex, "Error receiving udp message");
}
}
private void OnReceiveResult(IAsyncResult result)
{
if (_isDisposed)
{
return;
}
try
{
var socketResult = _udpClient.EndReceive(result);
OnMessageReceived(socketResult);
}
catch (ObjectDisposedException)
{
//TODO Investigate and properly fix.
}
catch (Exception ex)
{
_logger.LogError(ex, "Error receiving udp message");
}
BeginReceive();
} }
/// <summary> private async Task BeginReceiveAsync(CancellationToken cancellationToken)
/// Called when [message received].
/// </summary>
/// <param name="message">The message.</param>
private void OnMessageReceived(SocketReceiveResult message)
{ {
if (_isDisposed) while (!cancellationToken.IsCancellationRequested)
{
return;
}
if (message.RemoteEndPoint.Port == 0)
{ {
return; try
}
try
{
OnMessageReceived(new GenericEventArgs<SocketReceiveResult>
{ {
Argument = message var result = await _udpSocket.ReceiveFromAsync(_receiveBuffer, SocketFlags.None, _endpoint).ConfigureAwait(false);
});
}
catch (Exception ex)
{
_logger.LogError(ex, "Error handling UDP message");
}
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
Dispose(true);
}
/// <summary> cancellationToken.ThrowIfCancellationRequested();
/// 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)
{
_isDisposed = true;
if (_udpClient != null) var text = Encoding.UTF8.GetString(_receiveBuffer, 0, result.ReceivedBytes);
if (text.Contains("who is JellyfinServer?", StringComparison.OrdinalIgnoreCase))
{
await RespondToV2Message(text, result.RemoteEndPoint, cancellationToken).ConfigureAwait(false);
}
}
catch (SocketException ex)
{ {
_udpClient.Dispose(); _logger.LogError(ex, "Failed to receive data drom socket");
}
catch (OperationCanceledException)
{
// Don't throw
} }
} }
} }
public async Task SendAsync(byte[] bytes, IPEndPoint remoteEndPoint, CancellationToken cancellationToken) /// <inheritdoc />
public void Dispose()
{ {
if (_isDisposed) if (_disposed)
{ {
throw new ObjectDisposedException(GetType().Name); return;
}
if (bytes == null)
{
throw new ArgumentNullException(nameof(bytes));
}
if (remoteEndPoint == null)
{
throw new ArgumentNullException(nameof(remoteEndPoint));
} }
try _udpSocket?.Dispose();
{
await _udpClient.SendToAsync(bytes, 0, bytes.Length, remoteEndPoint, cancellationToken).ConfigureAwait(false);
_logger.LogInformation("Udp message sent to {remoteEndPoint}", remoteEndPoint); GC.SuppressFinalize(this);
}
catch (OperationCanceledException)
{
}
catch (Exception ex)
{
_logger.LogError(ex, "Error sending message to {remoteEndPoint}", remoteEndPoint);
}
} }
} }
} }

2
MediaBrowser.Model/Net/ISocket.cs
Unescape View File

@ -14,8 +14,6 @@ namespace MediaBrowser.Model.Net
Task<SocketReceiveResult> ReceiveAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken); Task<SocketReceiveResult> ReceiveAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
int Receive(byte[] buffer, int offset, int count);
IAsyncResult BeginReceive(byte[] buffer, int offset, int count, AsyncCallback callback); IAsyncResult BeginReceive(byte[] buffer, int offset, int count, AsyncCallback callback);
SocketReceiveResult EndReceive(IAsyncResult result); SocketReceiveResult EndReceive(IAsyncResult result);

9
MediaBrowser.Model/Net/ISocketFactory.cs
Unescape View File

@ -8,13 +8,6 @@ namespace MediaBrowser.Model.Net
/// </summary> /// </summary>
public interface ISocketFactory public interface ISocketFactory
{ {
/// <summary>
/// Creates a new unicast socket using the specified local port number.
/// </summary>
/// <param name="localPort">The local port to bind to.</param>
/// <returns>A <see cref="ISocket"/> implementation.</returns>
ISocket CreateUdpSocket(int localPort);
ISocket CreateUdpBroadcastSocket(int localPort); ISocket CreateUdpBroadcastSocket(int localPort);
/// <summary> /// <summary>
@ -30,7 +23,5 @@ namespace MediaBrowser.Model.Net
/// <param name="localPort">The local port to bind to.</param> /// <param name="localPort">The local port to bind to.</param>
/// <returns>A <see cref="ISocket"/> implementation.</returns> /// <returns>A <see cref="ISocket"/> implementation.</returns>
ISocket CreateUdpMulticastSocket(string ipAddress, int multicastTimeToLive, int localPort); ISocket CreateUdpMulticastSocket(string ipAddress, int multicastTimeToLive, int localPort);
Stream CreateNetworkStream(ISocket socket, bool ownsSocket);
} }
} }

Write Preview
Loading…
Cancel
Save