jellyfin/MediaBrowser.Controller/Kernel.cs

408 lines
13 KiB
C#
Raw Normal View History

2012-09-07 16:17:39 +00:00
using MediaBrowser.Common.Kernel;
2012-08-31 01:30:33 +00:00
using MediaBrowser.Common.Logging;
2012-07-12 06:55:27 +00:00
using MediaBrowser.Controller.IO;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Providers;
2012-07-12 06:55:27 +00:00
using MediaBrowser.Controller.Resolvers;
2012-09-02 05:30:25 +00:00
using MediaBrowser.Controller.Weather;
using MediaBrowser.Model.Configuration;
2012-07-12 06:55:27 +00:00
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Progress;
2012-09-07 16:17:39 +00:00
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
2012-07-12 06:55:27 +00:00
namespace MediaBrowser.Controller
{
public class Kernel : BaseKernel<ServerConfiguration, ServerApplicationPaths>
2012-07-12 06:55:27 +00:00
{
public static Kernel Instance { get; private set; }
public ItemController ItemController { get; private set; }
2012-09-02 05:30:25 +00:00
public WeatherClient WeatherClient { get; private set; }
2012-07-12 06:55:27 +00:00
public IEnumerable<User> Users { get; private set; }
public Folder RootFolder { get; private set; }
private DirectoryWatchers DirectoryWatchers { get; set; }
private string MediaRootFolderPath
{
get
{
2012-08-02 03:13:44 +00:00
return ApplicationPaths.RootFolderPath;
2012-07-12 06:55:27 +00:00
}
}
public override KernelContext KernelContext
{
get { return KernelContext.Server; }
}
/// <summary>
/// Gets the list of currently registered metadata prvoiders
/// </summary>
[ImportMany(typeof(BaseMetadataProvider))]
private IEnumerable<BaseMetadataProvider> MetadataProvidersEnumerable { get; set; }
/// <summary>
/// Once MEF has loaded the resolvers, sort them by priority and store them in this array
/// Given the sheer number of times they'll be iterated over it'll be faster to loop through an array
/// </summary>
private BaseMetadataProvider[] MetadataProviders { get; set; }
/// <summary>
/// Gets the list of currently registered entity resolvers
/// </summary>
[ImportMany(typeof(IBaseItemResolver))]
2012-08-21 01:21:03 +00:00
private IEnumerable<IBaseItemResolver> EntityResolversEnumerable { get; set; }
/// <summary>
/// Once MEF has loaded the resolvers, sort them by priority and store them in this array
/// Given the sheer number of times they'll be iterated over it'll be faster to loop through an array
/// </summary>
2012-08-21 01:21:03 +00:00
internal IBaseItemResolver[] EntityResolvers { get; private set; }
2012-07-12 06:55:27 +00:00
/// <summary>
/// Creates a kernel based on a Data path, which is akin to our current programdata path
2012-07-12 06:55:27 +00:00
/// </summary>
public Kernel()
: base()
2012-07-12 06:55:27 +00:00
{
Instance = this;
ItemController = new ItemController();
DirectoryWatchers = new DirectoryWatchers();
2012-09-02 05:30:25 +00:00
WeatherClient = new WeatherClient();
2012-07-12 06:55:27 +00:00
ItemController.PreBeginResolvePath += ItemController_PreBeginResolvePath;
ItemController.BeginResolvePath += ItemController_BeginResolvePath;
}
public async override Task Init(IProgress<TaskProgress> progress)
{
2012-08-22 02:50:59 +00:00
ExtractFFMpeg();
2012-08-22 02:50:59 +00:00
await base.Init(progress).ConfigureAwait(false);
2012-08-22 02:50:59 +00:00
progress.Report(new TaskProgress() { Description = "Loading Users", PercentComplete = 15 });
ReloadUsers();
2012-08-22 02:50:59 +00:00
progress.Report(new TaskProgress() { Description = "Loading Media Library", PercentComplete = 25 });
await ReloadRoot(allowInternetProviders: false).ConfigureAwait(false);
2012-08-20 13:36:18 +00:00
2012-08-22 02:50:59 +00:00
progress.Report(new TaskProgress() { Description = "Loading Complete", PercentComplete = 100 });
}
protected override void OnComposablePartsLoaded()
2012-07-12 06:55:27 +00:00
{
2012-07-26 13:51:26 +00:00
// The base class will start up all the plugins
base.OnComposablePartsLoaded();
2012-08-21 01:21:03 +00:00
// Sort the resolvers by priority
EntityResolvers = EntityResolversEnumerable.OrderBy(e => e.Priority).ToArray();
2012-08-21 01:21:03 +00:00
// Sort the providers by priority
MetadataProviders = MetadataProvidersEnumerable.OrderBy(e => e.Priority).ToArray();
// Initialize the metadata providers
Parallel.ForEach(MetadataProviders, provider =>
{
provider.Init();
});
}
2012-07-12 06:55:27 +00:00
/// <summary>
/// Fires when a path is about to be resolved, but before child folders and files
/// have been collected from the file system.
/// This gives us a chance to cancel it if needed, resulting in the path being ignored
/// </summary>
void ItemController_PreBeginResolvePath(object sender, PreBeginResolveEventArgs e)
{
if (e.IsHidden || e.IsSystemFile)
2012-07-12 06:55:27 +00:00
{
// Ignore hidden files and folders
e.Cancel = true;
}
else if (Path.GetFileName(e.Path).Equals("trailers", StringComparison.OrdinalIgnoreCase))
{
// Ignore any folders named "trailers"
e.Cancel = true;
}
}
/// <summary>
/// Fires when a path is about to be resolved, but after child folders and files
/// This gives us a chance to cancel it if needed, resulting in the path being ignored
/// </summary>
void ItemController_BeginResolvePath(object sender, ItemResolveEventArgs e)
{
2012-08-21 14:42:40 +00:00
if (e.ContainsFile(".ignore"))
2012-07-12 06:55:27 +00:00
{
2012-08-21 14:42:40 +00:00
// Ignore any folders containing a file called .ignore
e.Cancel = true;
2012-07-12 06:55:27 +00:00
}
}
private void ReloadUsers()
{
2012-07-31 13:28:12 +00:00
Users = GetAllUsers();
2012-07-12 06:55:27 +00:00
}
/// <summary>
/// Reloads the root media folder
/// </summary>
public async Task ReloadRoot(bool allowInternetProviders = true)
2012-07-12 06:55:27 +00:00
{
if (!Directory.Exists(MediaRootFolderPath))
{
Directory.CreateDirectory(MediaRootFolderPath);
}
DirectoryWatchers.Stop();
RootFolder = await ItemController.GetItem(MediaRootFolderPath, allowInternetProviders: allowInternetProviders).ConfigureAwait(false) as Folder;
2012-07-12 06:55:27 +00:00
DirectoryWatchers.Start();
}
public static Guid GetMD5(string str)
{
using (var provider = new MD5CryptoServiceProvider())
2012-07-12 06:55:27 +00:00
{
return new Guid(provider.ComputeHash(Encoding.Unicode.GetBytes(str)));
2012-07-12 06:55:27 +00:00
}
}
2012-09-07 16:17:39 +00:00
/// <summary>
/// Gets the default user to use when EnableUserProfiles is false
/// </summary>
public User GetDefaultUser()
{
User user = Users.FirstOrDefault();
return user;
}
/// <summary>
/// Persists a User
/// </summary>
public void SaveUser(User user)
{
}
/// <summary>
/// Authenticates a User and returns a result indicating whether or not it succeeded
/// </summary>
public AuthenticationResult AuthenticateUser(User user, string password)
{
AuthenticationResult result = new AuthenticationResult();
// When EnableUserProfiles is false, only the default User can login
if (!Configuration.EnableUserProfiles)
{
result.Success = user.Id == GetDefaultUser().Id;
}
else if (string.IsNullOrEmpty(user.Password))
{
result.Success = true;
}
else
{
result.Success = GetMD5((password ?? string.Empty)).ToString().Equals(user.Password);
}
2012-09-07 16:17:39 +00:00
// Update LastActivityDate and LastLoginDate, then save
if (result.Success)
{
user.LastActivityDate = user.LastLoginDate = DateTime.UtcNow;
SaveUser(user);
2012-09-07 16:17:39 +00:00
}
return result;
}
public async Task ReloadItem(BaseItem item)
2012-07-12 06:55:27 +00:00
{
Folder folder = item as Folder;
if (folder != null && folder.IsRoot)
{
2012-08-20 21:48:11 +00:00
await ReloadRoot().ConfigureAwait(false);
2012-07-12 06:55:27 +00:00
}
else
{
if (!Directory.Exists(item.Path) && !File.Exists(item.Path))
{
2012-08-20 21:48:11 +00:00
await ReloadItem(item.Parent).ConfigureAwait(false);
2012-07-12 06:55:27 +00:00
return;
}
2012-08-21 01:21:03 +00:00
BaseItem newItem = await ItemController.GetItem(item.Path, item.Parent).ConfigureAwait(false);
2012-07-12 06:55:27 +00:00
List<BaseItem> children = item.Parent.Children.ToList();
int index = children.IndexOf(item);
children.RemoveAt(index);
children.Insert(index, newItem);
item.Parent.Children = children.ToArray();
}
}
/// <summary>
/// Finds a library item by Id
/// </summary>
public BaseItem GetItemById(Guid id)
{
if (id == Guid.Empty)
{
return RootFolder;
}
return RootFolder.FindItemById(id);
}
2012-07-31 13:28:12 +00:00
/// <summary>
/// Gets all users within the system
/// </summary>
private IEnumerable<User> GetAllUsers()
{
List<User> list = new List<User>();
// Return a dummy user for now since all calls to get items requre a userId
User user = new User();
2012-07-31 13:28:12 +00:00
user.Name = "Default User";
user.Id = Guid.Parse("5d1cf7fce25943b790d140095457a42b");
list.Add(user);
2012-08-27 12:18:59 +00:00
user = new User();
2012-09-06 20:29:33 +00:00
user.Name = "Abobader";
2012-08-27 12:18:59 +00:00
user.Id = Guid.NewGuid();
2012-09-06 20:35:54 +00:00
user.LastLoginDate = DateTime.UtcNow.AddDays(-1);
user.LastActivityDate = DateTime.UtcNow.AddHours(-3);
2012-09-06 20:29:33 +00:00
user.Password = GetMD5("1234").ToString();
2012-08-27 12:18:59 +00:00
list.Add(user);
user = new User();
2012-09-06 20:29:33 +00:00
user.Name = "Scottisafool";
2012-08-27 12:18:59 +00:00
user.Id = Guid.NewGuid();
list.Add(user);
user = new User();
2012-09-06 20:29:33 +00:00
user.Name = "Redshirt";
2012-08-27 12:18:59 +00:00
user.Id = Guid.NewGuid();
list.Add(user);
2012-07-31 13:28:12 +00:00
/*user = new User();
2012-08-27 12:18:59 +00:00
user.Name = "Test User 4";
user.Id = Guid.NewGuid();
list.Add(user);
user = new User();
user.Name = "Test User 5";
user.Id = Guid.NewGuid();
list.Add(user);
user = new User();
user.Name = "Test User 6";
user.Id = Guid.NewGuid();
list.Add(user);*/
2012-07-31 13:28:12 +00:00
return list;
}
2012-08-20 13:36:18 +00:00
/// <summary>
/// Runs all metadata providers for an entity
/// </summary>
internal async Task ExecuteMetadataProviders(BaseEntity item, ItemResolveEventArgs args, bool allowInternetProviders = true)
{
2012-08-21 03:32:59 +00:00
// Run them sequentially in order of priority
for (int i = 0; i < MetadataProviders.Length; i++)
{
var provider = MetadataProviders[i];
2012-08-24 17:49:07 +00:00
// Skip if internet providers are currently disabled
if (provider.RequiresInternet && (!Configuration.EnableInternetProviders || !allowInternetProviders))
{
continue;
}
2012-08-24 17:49:07 +00:00
// Skip if the provider doesn't support the current item
if (!provider.Supports(item))
2012-08-21 03:32:59 +00:00
{
continue;
}
try
{
await provider.FetchAsync(item, args).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
}
2012-08-22 02:50:59 +00:00
private void ExtractFFMpeg()
{
ExtractFFMpeg(ApplicationPaths.FFMpegPath);
ExtractFFMpeg(ApplicationPaths.FFProbePath);
}
2012-08-20 13:36:18 +00:00
/// <summary>
/// Run these during Init.
/// Can't run do this on-demand because there will be multiple workers accessing them at once and we'd have to lock them
/// </summary>
2012-08-25 21:13:02 +00:00
private void ExtractFFMpeg(string exe)
2012-08-20 13:36:18 +00:00
{
if (File.Exists(exe))
{
File.Delete(exe);
}
// Extract exe
using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("MediaBrowser.Controller.FFMpeg." + Path.GetFileName(exe)))
{
using (FileStream fileStream = new FileStream(exe, FileMode.Create))
{
2012-08-25 21:13:02 +00:00
stream.CopyTo(fileStream);
2012-08-20 13:36:18 +00:00
}
}
}
protected override void DisposeComposableParts()
{
base.DisposeComposableParts();
DisposeProviders();
}
/// <summary>
/// Disposes all providers
/// </summary>
private void DisposeProviders()
{
if (MetadataProviders != null)
{
foreach (var provider in MetadataProviders)
{
provider.Dispose();
}
}
}
2012-07-12 06:55:27 +00:00
}
}