private static void DeviceWatcher_DeviceQueryRemove(object sender, DeviceNotificationEventArgs e)
{
if (DirectoryWatchers.ContainsKey(e.Name))
{
DirectoryWatchers[e.Name].Stop();
}
}
private void RegisterDirectoryWatcher(string path)
{
DirectoryWatcher directoryWatcher = new DirectoryWatcher(path, OnFileEvent, OnError);
directoryWatcher.Start();
DirectoryWatchers.Add(path, directoryWatcher);
}
/// <summary>
/// Runs the startup tasks.
/// </summary>
/// <returns>Task.</returns>
protected override async Task RunStartupTasks()
{
// Do these before allowing the base method to run, which will invoke startup scheduled tasks
await ServerKernel.LoadRepositories(ServerConfigurationManager).ConfigureAwait(false);
await base.RunStartupTasks().ConfigureAwait(false);
DirectoryWatchers.Start();
Parallel.ForEach(GetExports <IServerEntryPoint>(), entryPoint => entryPoint.Run());
}
/// <summary>
/// Called when a DirectoryWatcher has completed collecting
/// </summary>
/// <param name="watcher">The watcher that has completed collecting</param>
/// <param name="count">The number of items found</param>
void musicDirectoryWatcher_CollectingCompleted(DirectoryWatcher watcher, int count)
{
watcher.CollectingCompleted -= musicDirectoryWatcher_CollectingCompleted;
var done = DirectoryWatchers.Where(dw => dw.Medium == watcher.Medium).All(dw => dw.CollectionState == CollectionState.Collected);
if (done)
{
var masterPlaylist = watcher.Medium.MasterContainer;
masterPlaylist.Loaded = true;
masterPlaylist.Save();
}
}
public static void Stop()
{
foreach (DirectoryWatcher directoryWatcher in DirectoryWatchers.Values)
{
directoryWatcher.Stop();
}
DirectoryWatchers.Clear();
DeviceWatcher.DeviceArrived -= DeviceWatcher_DeviceArrived;
DeviceWatcher.DeviceQueryRemove -= DeviceWatcher_DeviceQueryRemove;
DeviceWatcher.DeviceRemoveComplete -= DeviceWatcher_DeviceRemoveComplete;
}
private static void DeviceWatcher_DeviceArrived(object sender, DeviceNotificationEventArgs e)
{
if (DirectoryWatchers.ContainsKey(e.Name))
{
DirectoryWatchers[e.Name].Start();
}
else
{
RegisterDirectoryWatcher(e.Name);
}
SendNotificationMessage(NotificationType.Add, e.Name);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_files.Clear();
if (_directoryWatchers != null)
{
_directoryWatchers.Changed -= OnChanged;
_directoryWatchers.Dispose();
_directoryWatchers = null;
}
}
}
public static void RegisterDirectoryWatcher(string path)
{
DirectoryWatcher directoryWatcher = new DirectoryWatcher(path, OnFileEvent, OnError);
directoryWatcher.Start();
if (DirectoryWatchers.ContainsKey(path))
{
DirectoryWatchers[path].Stop();
DirectoryWatchers.Remove(path);
}
DirectoryWatchers.Add(path, directoryWatcher);
}
/// <summary>
/// Registers resources that classes will depend on
/// </summary>
/// <returns>Task.</returns>
protected override async Task RegisterResources()
{
ServerKernel = new Kernel(ServerConfigurationManager);
await base.RegisterResources().ConfigureAwait(false);
RegisterSingleInstance <IHttpResultFactory>(new HttpResultFactory(LogManager));
RegisterSingleInstance <IServerApplicationHost>(this);
RegisterSingleInstance <IServerApplicationPaths>(ApplicationPaths);
RegisterSingleInstance(ServerKernel);
RegisterSingleInstance(ServerConfigurationManager);
RegisterSingleInstance <IWebSocketServer>(() => new AlchemyServer(Logger));
RegisterSingleInstance <IIsoManager>(new PismoIsoManager(Logger));
RegisterSingleInstance <IBlurayExaminer>(new BdInfoExaminer());
ZipClient = new DotNetZipClient();
RegisterSingleInstance(ZipClient);
HttpServer = ServerFactory.CreateServer(this, ProtobufSerializer, Logger, "Media Browser", "index.html");
RegisterSingleInstance(HttpServer, false);
ServerManager = new ServerManager(this, JsonSerializer, Logger, ServerConfigurationManager, ServerKernel);
RegisterSingleInstance(ServerManager);
UserManager = new UserManager(ServerKernel, Logger, ServerConfigurationManager);
RegisterSingleInstance(UserManager);
LibraryManager = new LibraryManager(ServerKernel, Logger, TaskManager, UserManager, ServerConfigurationManager);
RegisterSingleInstance(LibraryManager);
InstallationManager = new InstallationManager(HttpClient, PackageManager, JsonSerializer, Logger, this);
RegisterSingleInstance(InstallationManager);
DirectoryWatchers = new DirectoryWatchers(LogManager, TaskManager, LibraryManager, ServerConfigurationManager);
RegisterSingleInstance(DirectoryWatchers);
ProviderManager = new ProviderManager(HttpClient, ServerConfigurationManager, DirectoryWatchers, LogManager);
RegisterSingleInstance(ProviderManager);
RegisterSingleInstance <ILibrarySearchEngine>(() => new LuceneSearchEngine());
SetKernelProperties();
SetStaticProperties();
}
/// <summary>
/// Runs the startup tasks.
/// </summary>
/// <returns>Task.</returns>
public override async Task RunStartupTasks()
{
await base.RunStartupTasks().ConfigureAwait(false);
DirectoryWatchers.Start();
Logger.Info("Core startup complete");
Parallel.ForEach(GetExports <IServerEntryPoint>(), entryPoint =>
{
try
{
entryPoint.Run();
}
catch (Exception ex)
{
Logger.ErrorException("Error in {0}", ex, entryPoint.GetType().Name);
}
});
}
/// <summary>
/// Registers resources that classes will depend on
/// </summary>
/// <returns>Task.</returns>
protected override async Task RegisterResources()
{
ServerKernel = new Kernel();
await base.RegisterResources().ConfigureAwait(false);
RegisterSingleInstance <IHttpResultFactory>(new HttpResultFactory(LogManager));
RegisterSingleInstance <IServerApplicationHost>(this);
RegisterSingleInstance <IServerApplicationPaths>(ApplicationPaths);
RegisterSingleInstance(ServerKernel);
RegisterSingleInstance(ServerConfigurationManager);
RegisterSingleInstance <IWebSocketServer>(() => new AlchemyServer(Logger));
IsoManager = new IsoManager();
RegisterSingleInstance(IsoManager);
RegisterSingleInstance <IBlurayExaminer>(() => new BdInfoExaminer());
ZipClient = new DotNetZipClient();
RegisterSingleInstance(ZipClient);
UserDataRepository = new SqliteUserDataRepository(ApplicationPaths, JsonSerializer, LogManager);
RegisterSingleInstance(UserDataRepository);
UserRepository = await GetUserRepository().ConfigureAwait(false);
RegisterSingleInstance(UserRepository);
DisplayPreferencesRepository = new SqliteDisplayPreferencesRepository(ApplicationPaths, JsonSerializer, LogManager);
RegisterSingleInstance(DisplayPreferencesRepository);
ItemRepository = new SqliteItemRepository(ApplicationPaths, JsonSerializer, LogManager);
RegisterSingleInstance(ItemRepository);
UserManager = new UserManager(Logger, ServerConfigurationManager, UserRepository);
RegisterSingleInstance(UserManager);
LibraryManager = new LibraryManager(Logger, TaskManager, UserManager, ServerConfigurationManager, UserDataRepository, () => DirectoryWatchers);
RegisterSingleInstance(LibraryManager);
DirectoryWatchers = new DirectoryWatchers(LogManager, TaskManager, LibraryManager, ServerConfigurationManager);
RegisterSingleInstance(DirectoryWatchers);
ProviderManager = new ProviderManager(HttpClient, ServerConfigurationManager, DirectoryWatchers, LogManager, LibraryManager);
RegisterSingleInstance(ProviderManager);
RegisterSingleInstance <ILibrarySearchEngine>(() => new LuceneSearchEngine(ApplicationPaths, LogManager, LibraryManager));
MediaEncoder = new MediaEncoder(LogManager.GetLogger("MediaEncoder"), ZipClient, ApplicationPaths, JsonSerializer, HttpClient);
RegisterSingleInstance(MediaEncoder);
var clientConnectionManager = new SessionManager(UserDataRepository, ServerConfigurationManager, Logger, UserRepository);
RegisterSingleInstance <ISessionManager>(clientConnectionManager);
HttpServer = await _httpServerCreationTask.ConfigureAwait(false);
RegisterSingleInstance(HttpServer, false);
ServerManager = new ServerManager(this, JsonSerializer, Logger, ServerConfigurationManager);
RegisterSingleInstance(ServerManager);
LocalizationManager = new LocalizationManager(ServerConfigurationManager);
RegisterSingleInstance(LocalizationManager);
DtoService = new DtoService(Logger, LibraryManager, UserManager, UserDataRepository, ItemRepository);
RegisterSingleInstance(DtoService);
var displayPreferencesTask = Task.Run(async() => await ConfigureDisplayPreferencesRepositories().ConfigureAwait(false));
var itemsTask = Task.Run(async() => await ConfigureItemRepositories().ConfigureAwait(false));
var userdataTask = Task.Run(async() => await ConfigureUserDataRepositories().ConfigureAwait(false));
await ConfigureNotificationsRepository().ConfigureAwait(false);
await Task.WhenAll(itemsTask, displayPreferencesTask, userdataTask).ConfigureAwait(false);
SetKernelProperties();
}
