pt
/
jellyfin
mirror of https://github.com/jellyfin/jellyfin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

EditorConfig reformat: Emby.XmlTv, Jellyfin.Server. MediaBrowser.Api, MediaBrowser.Common

This commit is contained in:
Erwin de Haan 2019-01-13 20:30:41 +01:00
parent 5b3d8a6d76
commit 51ed47f4c4
12 changed files with 303 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Emby.XmlTv/Emby.XmlTv.Console/Program.cs
View File

@ -100,4 +100,4 @@ namespace Emby.XmlTv.Console
return count; return count;
} }
} }
} }

2
Emby.XmlTv/Emby.XmlTv/Entities/XmlTvChannel.cs
View File

@ -47,4 +47,4 @@ namespace Emby.XmlTv.Entities
return builder.ToString(); return builder.ToString();
} }
} }
} }

2
Emby.XmlTv/Emby.XmlTv/Entities/XmlTvCreditType.cs
View File

@ -14,4 +14,4 @@
Commentator, Commentator,
Guest Guest
} }
} }

584
Jellyfin.Server/Program.cs
View File

@ -1,242 +1,242 @@
using System; using System;
using System.Diagnostics; using System.Diagnostics;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Net; using System.Net;
using System.Net.Security; using System.Net.Security;
using System.Reflection; using System.Reflection;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Threading.Tasks; using System.Threading.Tasks;
using Emby.Drawing; using Emby.Drawing;
using Emby.Drawing.Skia; using Emby.Drawing.Skia;
using Emby.Server.Implementations; using Emby.Server.Implementations;
using Emby.Server.Implementations.EnvironmentInfo; using Emby.Server.Implementations.EnvironmentInfo;
using Emby.Server.Implementations.IO; using Emby.Server.Implementations.IO;
using Emby.Server.Implementations.Networking; using Emby.Server.Implementations.Networking;
using MediaBrowser.Common.Configuration; using MediaBrowser.Common.Configuration;
using MediaBrowser.Common.Net; using MediaBrowser.Common.Net;
using MediaBrowser.Controller.Drawing; using MediaBrowser.Controller.Drawing;
using MediaBrowser.Model.Globalization; using MediaBrowser.Model.Globalization;
using MediaBrowser.Model.IO; using MediaBrowser.Model.IO;
using MediaBrowser.Model.System; using MediaBrowser.Model.System;
using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Serilog; using Serilog;
using Serilog.AspNetCore; using Serilog.AspNetCore;
using ILogger = Microsoft.Extensions.Logging.ILogger; using ILogger = Microsoft.Extensions.Logging.ILogger;
namespace Jellyfin.Server namespace Jellyfin.Server
{ {
public static class Program public static class Program
{ {
private static readonly TaskCompletionSource<bool> ApplicationTaskCompletionSource = new TaskCompletionSource<bool>(); private static readonly TaskCompletionSource<bool> ApplicationTaskCompletionSource = new TaskCompletionSource<bool>();
private static ILoggerFactory _loggerFactory; private static ILoggerFactory _loggerFactory;
private static ILogger _logger; private static ILogger _logger;
private static bool _restartOnShutdown; private static bool _restartOnShutdown;
public static async Task<int> Main(string[] args) public static async Task<int> Main(string[] args)
{ {
StartupOptions options = new StartupOptions(args); StartupOptions options = new StartupOptions(args);
Version version = Assembly.GetEntryAssembly().GetName().Version; Version version = Assembly.GetEntryAssembly().GetName().Version;
if (options.ContainsOption("-v") || options.ContainsOption("--version")) if (options.ContainsOption("-v") || options.ContainsOption("--version"))
{ {
Console.WriteLine(version.ToString()); Console.WriteLine(version.ToString());
return 0; return 0;
} }
ServerApplicationPaths appPaths = createApplicationPaths(options); ServerApplicationPaths appPaths = createApplicationPaths(options);
// $JELLYFIN_LOG_DIR needs to be set for the logger configuration manager // $JELLYFIN_LOG_DIR needs to be set for the logger configuration manager
Environment.SetEnvironmentVariable("JELLYFIN_LOG_DIR", appPaths.LogDirectoryPath); Environment.SetEnvironmentVariable("JELLYFIN_LOG_DIR", appPaths.LogDirectoryPath);
await createLogger(appPaths); await createLogger(appPaths);
_loggerFactory = new SerilogLoggerFactory(); _loggerFactory = new SerilogLoggerFactory();
_logger = _loggerFactory.CreateLogger("Main"); _logger = _loggerFactory.CreateLogger("Main");
AppDomain.CurrentDomain.UnhandledException += (sender, e) AppDomain.CurrentDomain.UnhandledException += (sender, e)
=> _logger.LogCritical((Exception)e.ExceptionObject, "Unhandled Exception"); => _logger.LogCritical((Exception)e.ExceptionObject, "Unhandled Exception");
_logger.LogInformation("Jellyfin version: {Version}", version); _logger.LogInformation("Jellyfin version: {Version}", version);
EnvironmentInfo environmentInfo = new EnvironmentInfo(getOperatingSystem()); EnvironmentInfo environmentInfo = new EnvironmentInfo(getOperatingSystem());
ApplicationHost.LogEnvironmentInfo(_logger, appPaths, environmentInfo); ApplicationHost.LogEnvironmentInfo(_logger, appPaths, environmentInfo);
SQLitePCL.Batteries_V2.Init(); SQLitePCL.Batteries_V2.Init();
// Allow all https requests // Allow all https requests
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(delegate { return true; }); ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(delegate { return true; });
var fileSystem = new ManagedFileSystem(_loggerFactory.CreateLogger("FileSystem"), environmentInfo, null, appPaths.TempDirectory, true); var fileSystem = new ManagedFileSystem(_loggerFactory.CreateLogger("FileSystem"), environmentInfo, null, appPaths.TempDirectory, true);
using (var appHost = new CoreAppHost( using (var appHost = new CoreAppHost(
appPaths, appPaths,
_loggerFactory, _loggerFactory,
options, options,
fileSystem, fileSystem,
environmentInfo, environmentInfo,
new NullImageEncoder(), new NullImageEncoder(),
new SystemEvents(_loggerFactory.CreateLogger("SystemEvents")), new SystemEvents(_loggerFactory.CreateLogger("SystemEvents")),
new NetworkManager(_loggerFactory.CreateLogger("NetworkManager"), environmentInfo))) new NetworkManager(_loggerFactory.CreateLogger("NetworkManager"), environmentInfo)))
{ {
appHost.Init(); appHost.Init();
appHost.ImageProcessor.ImageEncoder = getImageEncoder(_logger, fileSystem, options, () => appHost.HttpClient, appPaths, environmentInfo, appHost.LocalizationManager); appHost.ImageProcessor.ImageEncoder = getImageEncoder(_logger, fileSystem, options, () => appHost.HttpClient, appPaths, environmentInfo, appHost.LocalizationManager);
_logger.LogInformation("Running startup tasks"); _logger.LogInformation("Running startup tasks");
await appHost.RunStartupTasks(); await appHost.RunStartupTasks();
// TODO: read input for a stop command // TODO: read input for a stop command
// Block main thread until shutdown // Block main thread until shutdown
await ApplicationTaskCompletionSource.Task; await ApplicationTaskCompletionSource.Task;
_logger.LogInformation("Disposing app host"); _logger.LogInformation("Disposing app host");
} }
if (_restartOnShutdown) if (_restartOnShutdown)
{ {
StartNewInstance(options); StartNewInstance(options);
} }
return 0; return 0;
} }
private static ServerApplicationPaths createApplicationPaths(StartupOptions options) private static ServerApplicationPaths createApplicationPaths(StartupOptions options)
{ {
string programDataPath = Environment.GetEnvironmentVariable("JELLYFIN_DATA_PATH"); string programDataPath = Environment.GetEnvironmentVariable("JELLYFIN_DATA_PATH");
if (string.IsNullOrEmpty(programDataPath)) if (string.IsNullOrEmpty(programDataPath))
{ {
if (options.ContainsOption("-programdata")) if (options.ContainsOption("-programdata"))
{ {
programDataPath = options.GetOption("-programdata"); programDataPath = options.GetOption("-programdata");
} }
else else
{ {
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{ {
programDataPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); programDataPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
} }
else else
{ {
// $XDG_DATA_HOME defines the base directory relative to which user specific data files should be stored. // $XDG_DATA_HOME defines the base directory relative to which user specific data files should be stored.
programDataPath = Environment.GetEnvironmentVariable("XDG_DATA_HOME"); programDataPath = Environment.GetEnvironmentVariable("XDG_DATA_HOME");
// If $XDG_DATA_HOME is either not set or empty, $HOME/.local/share should be used. // If $XDG_DATA_HOME is either not set or empty, $HOME/.local/share should be used.
if (string.IsNullOrEmpty(programDataPath)) if (string.IsNullOrEmpty(programDataPath))
{ {
programDataPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".local", "share"); programDataPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".local", "share");
} }
} }
programDataPath = Path.Combine(programDataPath, "jellyfin"); programDataPath = Path.Combine(programDataPath, "jellyfin");
// Ensure the dir exists // Ensure the dir exists
Directory.CreateDirectory(programDataPath); Directory.CreateDirectory(programDataPath);
} }
} }
string configDir = Environment.GetEnvironmentVariable("JELLYFIN_CONFIG_DIR"); string configDir = Environment.GetEnvironmentVariable("JELLYFIN_CONFIG_DIR");
if (string.IsNullOrEmpty(configDir)) if (string.IsNullOrEmpty(configDir))
{ {
if (options.ContainsOption("-configdir")) if (options.ContainsOption("-configdir"))
{ {
configDir = options.GetOption("-configdir"); configDir = options.GetOption("-configdir");
} }
else else
{ {
// Let BaseApplicationPaths set up the default value // Let BaseApplicationPaths set up the default value
configDir = null; configDir = null;
} }
} }
string logDir = Environment.GetEnvironmentVariable("JELLYFIN_LOG_DIR"); string logDir = Environment.GetEnvironmentVariable("JELLYFIN_LOG_DIR");
if (string.IsNullOrEmpty(logDir)) if (string.IsNullOrEmpty(logDir))
{ {
if (options.ContainsOption("-logdir")) if (options.ContainsOption("-logdir"))
{ {
logDir = options.GetOption("-logdir"); logDir = options.GetOption("-logdir");
} }
else else
{ {
// Let BaseApplicationPaths set up the default value // Let BaseApplicationPaths set up the default value
logDir = null; logDir = null;
} }
} }
string appPath = AppContext.BaseDirectory; string appPath = AppContext.BaseDirectory;
return new ServerApplicationPaths(programDataPath, appPath, appPath, logDir, configDir); return new ServerApplicationPaths(programDataPath, appPath, appPath, logDir, configDir);
} }
private static async Task createLogger(IApplicationPaths appPaths) private static async Task createLogger(IApplicationPaths appPaths)
{ {
try try
{ {
string configPath = Path.Combine(appPaths.ConfigurationDirectoryPath, "logging.json"); string configPath = Path.Combine(appPaths.ConfigurationDirectoryPath, "logging.json");
if (!File.Exists(configPath)) if (!File.Exists(configPath))
{ {
// For some reason the csproj name is used instead of the assembly name // For some reason the csproj name is used instead of the assembly name
using (Stream rscstr = typeof(Program).Assembly using (Stream rscstr = typeof(Program).Assembly
.GetManifestResourceStream("Jellyfin.Server.Resources.Configuration.logging.json")) .GetManifestResourceStream("Jellyfin.Server.Resources.Configuration.logging.json"))
using (Stream fstr = File.Open(configPath, FileMode.CreateNew)) using (Stream fstr = File.Open(configPath, FileMode.CreateNew))
{ {
await rscstr.CopyToAsync(fstr); await rscstr.CopyToAsync(fstr);
} }
} }
var configuration = new ConfigurationBuilder() var configuration = new ConfigurationBuilder()
.SetBasePath(appPaths.ConfigurationDirectoryPath) .SetBasePath(appPaths.ConfigurationDirectoryPath)
.AddJsonFile("logging.json") .AddJsonFile("logging.json")
.AddEnvironmentVariables("JELLYFIN_") .AddEnvironmentVariables("JELLYFIN_")
.Build(); .Build();
// Serilog.Log is used by SerilogLoggerFactory when no logger is specified // Serilog.Log is used by SerilogLoggerFactory when no logger is specified
Serilog.Log.Logger = new LoggerConfiguration() Serilog.Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(configuration) .ReadFrom.Configuration(configuration)
.Enrich.FromLogContext() .Enrich.FromLogContext()
.CreateLogger(); .CreateLogger();
} }
catch (Exception ex) catch (Exception ex)
{ {
Serilog.Log.Logger = new LoggerConfiguration() Serilog.Log.Logger = new LoggerConfiguration()
.WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss}] [{Level:u3}] {Message:lj}{NewLine}{Exception}") .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss}] [{Level:u3}] {Message:lj}{NewLine}{Exception}")
.WriteTo.Async(x => x.File( .WriteTo.Async(x => x.File(
Path.Combine(appPaths.LogDirectoryPath, "log_.log"), Path.Combine(appPaths.LogDirectoryPath, "log_.log"),
rollingInterval: RollingInterval.Day, rollingInterval: RollingInterval.Day,
outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz}] [{Level:u3}] {Message}{NewLine}{Exception}")) outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz}] [{Level:u3}] {Message}{NewLine}{Exception}"))
.Enrich.FromLogContext() .Enrich.FromLogContext()
.CreateLogger(); .CreateLogger();
Serilog.Log.Logger.Fatal(ex, "Failed to create/read logger configuration"); Serilog.Log.Logger.Fatal(ex, "Failed to create/read logger configuration");
} }
} }
public static IImageEncoder getImageEncoder( public static IImageEncoder getImageEncoder(
ILogger logger, ILogger logger,
IFileSystem fileSystem, IFileSystem fileSystem,
StartupOptions startupOptions, StartupOptions startupOptions,
Func<IHttpClient> httpClient, Func<IHttpClient> httpClient,
IApplicationPaths appPaths, IApplicationPaths appPaths,
IEnvironmentInfo environment, IEnvironmentInfo environment,
ILocalizationManager localizationManager) ILocalizationManager localizationManager)
{ {
try try
{ {
return new SkiaEncoder(logger, appPaths, httpClient, fileSystem, localizationManager); return new SkiaEncoder(logger, appPaths, httpClient, fileSystem, localizationManager);
} }
catch (Exception ex) catch (Exception ex)
{ {
logger.LogInformation(ex, "Skia not available. Will fallback to NullIMageEncoder. {0}"); logger.LogInformation(ex, "Skia not available. Will fallback to NullIMageEncoder. {0}");
} }
return new NullImageEncoder(); return new NullImageEncoder();
} }
private static MediaBrowser.Model.System.OperatingSystem getOperatingSystem() private static MediaBrowser.Model.System.OperatingSystem getOperatingSystem()
{ {
switch (Environment.OSVersion.Platform) switch (Environment.OSVersion.Platform)
{ {
case PlatformID.MacOSX: case PlatformID.MacOSX:
return MediaBrowser.Model.System.OperatingSystem.OSX; return MediaBrowser.Model.System.OperatingSystem.OSX;
case PlatformID.Win32NT: case PlatformID.Win32NT:
return MediaBrowser.Model.System.OperatingSystem.Windows; return MediaBrowser.Model.System.OperatingSystem.Windows;
case PlatformID.Unix: case PlatformID.Unix:
default: default:
{ {
string osDescription = RuntimeInformation.OSDescription; string osDescription = RuntimeInformation.OSDescription;
@ -253,62 +253,62 @@ namespace Jellyfin.Server
return MediaBrowser.Model.System.OperatingSystem.BSD; return MediaBrowser.Model.System.OperatingSystem.BSD;
} }
throw new Exception($"Can't resolve OS with description: '{osDescription}'"); throw new Exception($"Can't resolve OS with description: '{osDescription}'");
} }
} }
} }
public static void Shutdown() public static void Shutdown()
{ {
ApplicationTaskCompletionSource.SetResult(true); ApplicationTaskCompletionSource.SetResult(true);
} }
public static void Restart() public static void Restart()
{ {
_restartOnShutdown = true; _restartOnShutdown = true;
Shutdown(); Shutdown();
} }
private static void StartNewInstance(StartupOptions startupOptions) private static void StartNewInstance(StartupOptions startupOptions)
{ {
_logger.LogInformation("Starting new instance"); _logger.LogInformation("Starting new instance");
string module = startupOptions.GetOption("-restartpath"); string module = startupOptions.GetOption("-restartpath");
if (string.IsNullOrWhiteSpace(module)) if (string.IsNullOrWhiteSpace(module))
{ {
module = Environment.GetCommandLineArgs().First(); module = Environment.GetCommandLineArgs().First();
} }
string commandLineArgsString; string commandLineArgsString;
if (startupOptions.ContainsOption("-restartargs")) if (startupOptions.ContainsOption("-restartargs"))
{ {
commandLineArgsString = startupOptions.GetOption("-restartargs") ?? string.Empty; commandLineArgsString = startupOptions.GetOption("-restartargs") ?? string.Empty;
} }
else else
{ {
commandLineArgsString = string.Join(" ", commandLineArgsString = string.Join(" ",
Environment.GetCommandLineArgs() Environment.GetCommandLineArgs()
.Skip(1) .Skip(1)
.Select(NormalizeCommandLineArgument) .Select(NormalizeCommandLineArgument)
); );
} }
_logger.LogInformation("Executable: {0}", module); _logger.LogInformation("Executable: {0}", module);
_logger.LogInformation("Arguments: {0}", commandLineArgsString); _logger.LogInformation("Arguments: {0}", commandLineArgsString);
Process.Start(module, commandLineArgsString); Process.Start(module, commandLineArgsString);
} }
private static string NormalizeCommandLineArgument(string arg) private static string NormalizeCommandLineArgument(string arg)
{ {
if (!arg.Contains(" ", StringComparison.OrdinalIgnoreCase)) if (!arg.Contains(" ", StringComparison.OrdinalIgnoreCase))
{ {
return arg; return arg;
} }
return "\"" + arg + "\""; return "\"" + arg + "\"";
} }
} }
} }

2
Jellyfin.Server/Properties/AssemblyInfo.cs
View File

@ -2,7 +2,7 @@ using System.Reflection;
using System.Resources; using System.Resources;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following // General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information // set of attributes. Change these attribute values to modify the information
// associated with an assembly. // associated with an assembly.
[assembly: AssemblyTitle("Jellyfin.Server")] [assembly: AssemblyTitle("Jellyfin.Server")]

2
MediaBrowser.Api/Playback/Progressive/VideoService.cs
View File

@ -97,4 +97,4 @@ namespace MediaBrowser.Api.Playback.Progressive
return EncodingHelper.GetProgressiveVideoFullCommandLine(state, encodingOptions, outputPath, GetDefaultH264Preset()); return EncodingHelper.GetProgressiveVideoFullCommandLine(state, encodingOptions, outputPath, GetDefaultH264Preset());
} }
} }
} }

2
MediaBrowser.Api/Session/SessionsService.cs
View File

@ -518,4 +518,4 @@ namespace MediaBrowser.Api.Session
_sessionManager.ReportCapabilities(request.Id, request); _sessionManager.ReportCapabilities(request.Id, request);
} }
} }
} }

2
MediaBrowser.Common/Net/INetworkManager.cs
View File

@ -63,4 +63,4 @@ namespace MediaBrowser.Common.Net
bool IsAddressInSubnets(string addressString, string[] subnets); bool IsAddressInSubnets(string addressString, string[] subnets);
} }
} }

2
MediaBrowser.Common/Plugins/IPlugin.cs
View File

@ -80,4 +80,4 @@ namespace MediaBrowser.Common.Plugins
void SetStartupInfo(Action<string> directoryCreateFn); void SetStartupInfo(Action<string> directoryCreateFn);
} }
} }

2
MediaBrowser.Common/Security/ISecurityManager.cs
View File

@ -29,4 +29,4 @@ namespace MediaBrowser.Common.Security
Task RegisterAppStoreSale(string parameters); Task RegisterAppStoreSale(string parameters);
Task UpdateSupporterKey(string newValue); Task UpdateSupporterKey(string newValue);
} }
} }

2
MediaBrowser.Common/Updates/IInstallationManager.cs
View File

@ -118,4 +118,4 @@ namespace MediaBrowser.Common.Updates
/// <exception cref="System.ArgumentException"></exception> /// <exception cref="System.ArgumentException"></exception>
void UninstallPlugin(IPlugin plugin); void UninstallPlugin(IPlugin plugin);
} }
} }

2
MediaBrowser.Common/Updates/InstallationFailedEventArgs.cs
View File

@ -6,4 +6,4 @@ namespace MediaBrowser.Common.Updates
{ {
public Exception Exception { get; set; } public Exception Exception { get; set; }
} }
} }