jellyfin-server/MediaBrowser.Server.Implementations/HttpServer/HttpListenerHost.cs

441 lines
14 KiB
C#
Raw Normal View History

2014-07-26 17:30:15 +00:00
using Funq;
2013-12-07 15:52:38 +00:00
using MediaBrowser.Common;
using MediaBrowser.Common.Extensions;
using MediaBrowser.Controller.Net;
using MediaBrowser.Model.Logging;
2014-07-19 01:28:40 +00:00
using MediaBrowser.Server.Implementations.HttpServer.SocketSharp;
2013-12-07 15:52:38 +00:00
using ServiceStack;
2013-12-10 16:44:07 +00:00
using ServiceStack.Api.Swagger;
2013-12-07 15:52:38 +00:00
using ServiceStack.Host;
using ServiceStack.Host.Handlers;
using ServiceStack.Host.HttpListener;
using ServiceStack.Logging;
using ServiceStack.Web;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
namespace MediaBrowser.Server.Implementations.HttpServer
{
public class HttpListenerHost : ServiceStackHost, IHttpServer
{
private string DefaultRedirectPath { get; set; }
private readonly ILogger _logger;
2014-01-09 04:44:51 +00:00
public IEnumerable<string> UrlPrefixes { get; private set; }
2013-12-07 15:52:38 +00:00
private readonly List<IRestfulService> _restServices = new List<IRestfulService>();
2014-07-18 22:14:59 +00:00
private IHttpListener _listener;
2013-12-07 15:52:38 +00:00
private readonly ContainerAdapter _containerAdapter;
public event EventHandler<WebSocketConnectEventArgs> WebSocketConnected;
2014-09-17 03:04:10 +00:00
private readonly List<string> _localEndpoints = new List<string>();
private readonly ReaderWriterLockSlim _localEndpointLock = new ReaderWriterLockSlim();
2015-01-19 04:29:57 +00:00
public string CertificatePath { get; private set; }
2013-12-07 15:52:38 +00:00
/// <summary>
/// Gets the local end points.
/// </summary>
/// <value>The local end points.</value>
public IEnumerable<string> LocalEndPoints
{
2014-09-17 03:04:10 +00:00
get
{
_localEndpointLock.EnterReadLock();
var list = _localEndpoints.ToList();
_localEndpointLock.ExitReadLock();
return list;
}
2013-12-07 15:52:38 +00:00
}
2015-01-17 19:30:23 +00:00
public HttpListenerHost(IApplicationHost applicationHost,
ILogManager logManager,
string serviceName,
string defaultRedirectPath,
2014-10-06 23:58:46 +00:00
params Assembly[] assembliesWithServices)
2013-12-07 15:52:38 +00:00
: base(serviceName, assembliesWithServices)
{
DefaultRedirectPath = defaultRedirectPath;
_logger = logManager.GetLogger("HttpServer");
_containerAdapter = new ContainerAdapter(applicationHost);
}
public override void Configure(Container container)
{
HostConfig.Instance.DefaultRedirectPath = DefaultRedirectPath;
HostConfig.Instance.MapExceptionToStatusCode = new Dictionary<Type, int>
{
{typeof (InvalidOperationException), 422},
{typeof (ResourceNotFoundException), 404},
{typeof (FileNotFoundException), 404},
2014-07-22 01:29:06 +00:00
{typeof (DirectoryNotFoundException), 404},
2014-11-15 02:31:03 +00:00
{typeof (SecurityException), 401},
2014-10-27 03:06:01 +00:00
{typeof (UnauthorizedAccessException), 401}
2013-12-07 15:52:38 +00:00
};
HostConfig.Instance.DebugMode = true;
HostConfig.Instance.LogFactory = LogManager.LogFactory;
// The Markdown feature causes slow startup times (5 mins+) on cold boots for some users
// Custom format allows images
HostConfig.Instance.EnableFeatures = Feature.Csv | Feature.Html | Feature.Json | Feature.Jsv | Feature.Metadata | Feature.Xml | Feature.CustomFormat;
container.Adapter = _containerAdapter;
2013-12-10 16:44:07 +00:00
Plugins.Add(new SwaggerFeature());
2014-08-18 14:20:02 +00:00
Plugins.Add(new CorsFeature(allowedHeaders: "Content-Type, Authorization, Range, X-MediaBrowser-Token"));
2014-07-09 00:46:11 +00:00
//Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] {
// new SessionAuthProvider(_containerAdapter.Resolve<ISessionContext>()),
//}));
2014-08-18 03:00:37 +00:00
PreRequestFilters.Add((httpReq, httpRes) =>
{
//Handles Request and closes Responses after emitting global HTTP Headers
if (string.Equals(httpReq.Verb, "OPTIONS", StringComparison.OrdinalIgnoreCase))
{
httpRes.EndRequest(); //add a 'using ServiceStack;'
}
});
2013-12-07 15:52:38 +00:00
HostContext.GlobalResponseFilters.Add(new ResponseFilter(_logger).FilterResponse);
}
public override void OnAfterInit()
{
SetAppDomainData();
base.OnAfterInit();
}
public override void OnConfigLoad()
{
base.OnConfigLoad();
2015-01-17 19:30:23 +00:00
Config.HandlerFactoryPath = null;
2013-12-07 15:52:38 +00:00
2015-01-17 19:30:23 +00:00
Config.MetadataRedirectPath = "metadata";
2013-12-07 15:52:38 +00:00
}
protected override ServiceController CreateServiceController(params Assembly[] assembliesWithServices)
{
var types = _restServices.Select(r => r.GetType()).ToArray();
return new ServiceController(this, () => types);
}
public virtual void SetAppDomainData()
{
//Required for Mono to resolve VirtualPathUtility and Url.Content urls
var domain = Thread.GetDomain(); // or AppDomain.Current
domain.SetData(".appDomain", "1");
domain.SetData(".appVPath", "/");
domain.SetData(".appPath", domain.BaseDirectory);
if (string.IsNullOrEmpty(domain.GetData(".appId") as string))
{
domain.SetData(".appId", "1");
}
if (string.IsNullOrEmpty(domain.GetData(".domainId") as string))
{
domain.SetData(".domainId", "1");
}
}
public override ServiceStackHost Start(string listeningAtUrlBase)
{
2014-07-18 22:14:59 +00:00
StartListener();
2013-12-07 15:52:38 +00:00
return this;
}
2014-08-31 19:15:33 +00:00
private void OnRequestReceived(string localEndPoint)
{
2014-09-24 01:44:05 +00:00
var ignore = localEndPoint.IndexOf("::", StringComparison.OrdinalIgnoreCase) != -1 ||
localEndPoint.StartsWith("127.", StringComparison.OrdinalIgnoreCase) ||
localEndPoint.StartsWith("localhost", StringComparison.OrdinalIgnoreCase) ||
localEndPoint.StartsWith("169.", StringComparison.OrdinalIgnoreCase);
if (ignore)
{
return;
}
2014-09-17 03:04:10 +00:00
if (_localEndpointLock.TryEnterWriteLock(100))
{
var list = _localEndpoints.ToList();
list.Remove(localEndPoint);
list.Insert(0, localEndPoint);
_localEndpointLock.ExitWriteLock();
}
2014-08-31 19:15:33 +00:00
}
2013-12-07 15:52:38 +00:00
/// <summary>
/// Starts the Web Service
/// </summary>
2014-07-18 22:14:59 +00:00
private void StartListener()
2013-12-07 15:52:38 +00:00
{
2014-07-09 00:46:11 +00:00
HostContext.Config.HandlerFactoryPath = ListenerRequest.GetHandlerPathIfAny(UrlPrefixes.First());
2014-12-27 22:52:41 +00:00
_listener = GetListener();
2014-07-19 01:28:40 +00:00
_listener.WebSocketHandler = WebSocketHandler;
_listener.ErrorHandler = ErrorHandler;
_listener.RequestHandler = RequestHandler;
2013-12-07 15:52:38 +00:00
2014-07-18 22:14:59 +00:00
_listener.Start(UrlPrefixes);
2014-07-09 00:46:11 +00:00
}
2013-12-07 15:52:38 +00:00
2014-12-27 22:52:41 +00:00
private IHttpListener GetListener()
{
2015-01-19 04:29:57 +00:00
return new WebSocketSharpListener(_logger, OnRequestReceived, CertificatePath);
2014-12-27 22:52:41 +00:00
}
2014-07-18 22:14:59 +00:00
private void WebSocketHandler(WebSocketConnectEventArgs args)
2014-07-09 00:46:11 +00:00
{
2014-07-18 22:14:59 +00:00
if (WebSocketConnected != null)
2014-07-09 00:46:11 +00:00
{
2014-07-18 22:14:59 +00:00
WebSocketConnected(this, args);
2014-07-09 00:46:11 +00:00
}
2013-12-07 15:52:38 +00:00
}
2014-07-18 22:14:59 +00:00
private void ErrorHandler(Exception ex, IRequest httpReq)
2013-12-07 15:52:38 +00:00
{
try
{
var httpRes = httpReq.Response;
if (httpRes.IsClosed)
{
return;
}
2015-01-17 19:30:23 +00:00
2014-07-09 00:46:11 +00:00
var errorResponse = new ErrorResponse
{
ResponseStatus = new ResponseStatus
{
ErrorCode = ex.GetType().GetOperationName(),
Message = ex.Message,
2014-10-28 23:17:55 +00:00
StackTrace = ex.StackTrace
2014-07-09 00:46:11 +00:00
}
};
2013-12-07 15:52:38 +00:00
var contentType = httpReq.ResponseContentType;
var serializer = HostContext.ContentTypes.GetResponseSerializer(contentType);
if (serializer == null)
{
contentType = HostContext.Config.DefaultContentType;
serializer = HostContext.ContentTypes.GetResponseSerializer(contentType);
}
var httpError = ex as IHttpError;
if (httpError != null)
{
httpRes.StatusCode = httpError.Status;
httpRes.StatusDescription = httpError.StatusDescription;
}
else
{
httpRes.StatusCode = 500;
}
httpRes.ContentType = contentType;
serializer(httpReq, errorResponse, httpRes);
httpRes.Close();
}
catch (Exception errorEx)
{
2014-07-09 00:46:11 +00:00
_logger.ErrorException("Error this.ProcessRequest(context)(Exception while writing error to the response)", errorEx);
2013-12-07 15:52:38 +00:00
}
}
/// <summary>
/// Shut down the Web Service
/// </summary>
public void Stop()
{
2014-07-18 22:14:59 +00:00
if (_listener != null)
2013-12-07 15:52:38 +00:00
{
2014-07-18 22:14:59 +00:00
_listener.Stop();
2013-12-07 15:52:38 +00:00
}
}
/// <summary>
/// Overridable method that can be used to implement a custom hnandler
/// </summary>
2014-07-18 22:14:59 +00:00
/// <param name="httpReq">The HTTP req.</param>
2014-07-19 01:28:40 +00:00
/// <param name="url">The URL.</param>
2014-07-18 22:14:59 +00:00
/// <returns>Task.</returns>
protected Task RequestHandler(IHttpRequest httpReq, Uri url)
2013-12-07 15:52:38 +00:00
{
2014-07-18 22:14:59 +00:00
var date = DateTime.Now;
2014-07-09 00:46:11 +00:00
2014-07-18 22:14:59 +00:00
var httpRes = httpReq.Response;
2014-07-09 00:46:11 +00:00
2014-07-18 22:14:59 +00:00
var operationName = httpReq.OperationName;
var localPath = url.LocalPath;
2014-07-09 00:46:11 +00:00
2015-01-17 19:30:23 +00:00
if (string.Equals(localPath, "/mediabrowser/", StringComparison.OrdinalIgnoreCase))
2014-07-09 00:46:11 +00:00
{
2015-01-17 19:30:23 +00:00
httpRes.RedirectToUrl("/../" + DefaultRedirectPath);
2014-07-09 00:46:11 +00:00
return Task.FromResult(true);
}
2015-01-17 19:30:23 +00:00
if (string.Equals(localPath, "/mediabrowser", StringComparison.OrdinalIgnoreCase))
2014-07-09 00:46:11 +00:00
{
2015-01-17 19:30:23 +00:00
httpRes.RedirectToUrl("../" + DefaultRedirectPath);
2014-07-09 00:46:11 +00:00
return Task.FromResult(true);
}
if (string.Equals(localPath, "/", StringComparison.OrdinalIgnoreCase))
{
2015-01-17 19:30:23 +00:00
httpRes.RedirectToUrl(DefaultRedirectPath);
2014-07-09 00:46:11 +00:00
return Task.FromResult(true);
}
if (string.IsNullOrEmpty(localPath))
{
2015-01-17 19:30:23 +00:00
httpRes.RedirectToUrl("/" + DefaultRedirectPath);
2014-07-09 00:46:11 +00:00
return Task.FromResult(true);
}
2013-12-07 15:52:38 +00:00
var handler = HttpHandlerFactory.GetHandler(httpReq);
2014-07-09 00:46:11 +00:00
var remoteIp = httpReq.RemoteIp;
2013-12-07 15:52:38 +00:00
var serviceStackHandler = handler as IServiceStackHandler;
if (serviceStackHandler != null)
{
var restHandler = serviceStackHandler as RestHandler;
if (restHandler != null)
{
httpReq.OperationName = operationName = restHandler.RestPath.RequestType.GetOperationName();
}
var task = serviceStackHandler.ProcessRequestAsync(httpReq, httpRes, operationName);
2014-07-09 00:46:11 +00:00
task.ContinueWith(x => httpRes.Close(), TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.AttachedToParent);
//Matches Exceptions handled in HttpListenerBase.InitTask()
2014-07-18 22:14:59 +00:00
var urlString = url.ToString();
2014-07-09 00:46:11 +00:00
task.ContinueWith(x =>
{
2014-07-19 01:28:40 +00:00
var statusCode = httpRes.StatusCode;
2014-07-09 00:46:11 +00:00
var duration = DateTime.Now - date;
2014-07-18 22:14:59 +00:00
LoggerUtils.LogResponse(_logger, statusCode, urlString, remoteIp, duration);
2014-07-09 00:46:11 +00:00
}, TaskContinuationOptions.None);
2013-12-07 15:52:38 +00:00
return task;
}
return new NotImplementedException("Cannot execute handler: " + handler + " at PathInfo: " + httpReq.PathInfo)
.AsTaskException();
}
/// <summary>
/// Adds the rest handlers.
/// </summary>
/// <param name="services">The services.</param>
public void Init(IEnumerable<IRestfulService> services)
{
_restServices.AddRange(services);
ServiceController = CreateServiceController();
_logger.Info("Calling ServiceStack AppHost.Init");
2013-12-09 02:24:48 +00:00
base.Init();
2013-12-07 15:52:38 +00:00
}
2015-01-17 19:30:23 +00:00
public override RouteAttribute[] GetRouteAttributes(Type requestType)
{
var routes = base.GetRouteAttributes(requestType).ToList();
var clone = routes.ToList();
foreach (var route in clone)
{
routes.Add(new RouteAttribute(NormalizeRoutePath(route.Path), route.Verbs)
{
Notes = route.Notes,
Priority = route.Priority,
Summary = route.Summary
});
}
return routes.ToArray();
}
private string NormalizeRoutePath(string path)
{
if (path.StartsWith("/", StringComparison.OrdinalIgnoreCase))
{
return "/mediabrowser" + path;
}
return "mediabrowser/" + path;
}
2014-07-09 00:46:11 +00:00
2013-12-07 15:52:38 +00:00
/// <summary>
/// Releases the specified instance.
/// </summary>
/// <param name="instance">The instance.</param>
public override void Release(object instance)
{
// Leave this empty so SS doesn't try to dispose our objects
}
private bool _disposed;
private readonly object _disposeLock = new object();
protected virtual void Dispose(bool disposing)
{
if (_disposed) return;
base.Dispose();
lock (_disposeLock)
{
if (_disposed) return;
if (disposing)
{
Stop();
}
//release unmanaged resources here...
_disposed = true;
}
}
public override void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
public void StartServer(IEnumerable<string> urlPrefixes, string certificatePath)
2013-12-07 15:52:38 +00:00
{
2015-01-19 04:29:57 +00:00
CertificatePath = certificatePath;
2014-01-09 04:44:51 +00:00
UrlPrefixes = urlPrefixes.ToList();
Start(UrlPrefixes.First());
2013-12-07 15:52:38 +00:00
}
}
}