/// <summary>
/// Runs the application.
/// </summary>
/// <param name="appPaths">The app paths.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="options">The options.</param>
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, StartupOptions options, EnvironmentInfo environmentInfo)
{
var fileSystem = new ManagedFileSystem(logManager.GetLogger("FileSystem"), true, true, true);
fileSystem.AddShortcutHandler(new MbLinkShortcutHandler(fileSystem));
var imageEncoder = new NullImageEncoder();
_appHost = new CoreAppHost(appPaths,
logManager,
options,
fileSystem,
new PowerManagement(),
"emby.windows.zip",
environmentInfo,
imageEncoder,
new CoreSystemEvents(),
new MemoryStreamFactory(),
new NetworkManager(logManager.GetLogger("NetworkManager")),
GenerateCertificate,
() => "EmbyUser");
var initProgress = new Progress <double>();
if (environmentInfo.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.Windows)
{
// Not crazy about this but it's the only way to suppress ffmpeg crash dialog boxes
SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS | ErrorModes.SEM_NOALIGNMENTFAULTEXCEPT |
ErrorModes.SEM_NOGPFAULTERRORBOX | ErrorModes.SEM_NOOPENFILEERRORBOX);
}
var task = _appHost.Init(initProgress);
Task.WaitAll(task);
task = task.ContinueWith(new Action <Task>(a => _appHost.RunStartupTasks()), TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.AttachedToParent);
Task.WaitAll(task);
task = ApplicationTaskCompletionSource.Task;
Task.WaitAll(task);
}
public async Task <FFMpegInfo> GetFFMpegInfo(NativeEnvironment environment, StartupOptions options, IProgress <double> progress)
{
var customffMpegPath = options.GetOption("-ffmpeg");
var customffProbePath = options.GetOption("-ffprobe");
if (!string.IsNullOrWhiteSpace(customffMpegPath) && !string.IsNullOrWhiteSpace(customffProbePath))
{
return(new FFMpegInfo
{
ProbePath = customffProbePath,
EncoderPath = customffMpegPath,
Version = "external"
});
}
var downloadInfo = _ffmpegInstallInfo;
var version = downloadInfo.Version;
if (string.Equals(version, "path", StringComparison.OrdinalIgnoreCase))
{
return(new FFMpegInfo
{
ProbePath = downloadInfo.FFProbeFilename,
EncoderPath = downloadInfo.FFMpegFilename,
Version = version
});
}
if (string.Equals(version, "0", StringComparison.OrdinalIgnoreCase))
{
return(new FFMpegInfo());
}
var rootEncoderPath = Path.Combine(_appPaths.ProgramDataPath, "ffmpeg");
var versionedDirectoryPath = Path.Combine(rootEncoderPath, version);
var info = new FFMpegInfo
{
ProbePath = Path.Combine(versionedDirectoryPath, downloadInfo.FFProbeFilename),
EncoderPath = Path.Combine(versionedDirectoryPath, downloadInfo.FFMpegFilename),
Version = version
};
_fileSystem.CreateDirectory(versionedDirectoryPath);
var excludeFromDeletions = new List <string> {
versionedDirectoryPath
};
if (!_fileSystem.FileExists(info.ProbePath) || !_fileSystem.FileExists(info.EncoderPath))
{
// ffmpeg not present. See if there's an older version we can start with
var existingVersion = GetExistingVersion(info, rootEncoderPath);
// No older version. Need to download and block until complete
if (existingVersion == null)
{
var success = await DownloadFFMpeg(downloadInfo, versionedDirectoryPath, progress).ConfigureAwait(false);
if (!success)
{
return(new FFMpegInfo());
}
}
else
{
info = existingVersion;
versionedDirectoryPath = Path.GetDirectoryName(info.EncoderPath);
excludeFromDeletions.Add(versionedDirectoryPath);
}
}
// Allow just one of these to be overridden, if desired.
if (!string.IsNullOrWhiteSpace(customffMpegPath))
{
info.EncoderPath = customffMpegPath;
}
if (!string.IsNullOrWhiteSpace(customffProbePath))
{
info.EncoderPath = customffProbePath;
}
return(info);
}
public MonoAppHost(ServerApplicationPaths applicationPaths, ILogManager logManager, StartupOptions options, IFileSystem fileSystem, IPowerManagement powerManagement, string releaseAssetFilename, IEnvironmentInfo environmentInfo, MediaBrowser.Controller.Drawing.IImageEncoder imageEncoder, ISystemEvents systemEvents, IMemoryStreamFactory memoryStreamFactory, MediaBrowser.Common.Net.INetworkManager networkManager, Action <string, string> certificateGenerator, Func <string> defaultUsernameFactory) : base(applicationPaths, logManager, options, fileSystem, powerManagement, releaseAssetFilename, environmentInfo, imageEncoder, systemEvents, memoryStreamFactory, networkManager, certificateGenerator, defaultUsernameFactory)
{
}
/// <summary>
/// Changes the startup option
/// </summary>
/// <param name="previousOption"></param>
/// <param name="newOption"></param>
/// <returns></returns>
public bool ChangeStartupOption(StartupOptions previousOption, string previousStartupItemName, StartupOptions newOption, string startupItemName, string startupItemValue)
{
// if there is no change then we don't need to do anything
// if (previousOption == newOption)
// return true;
// remove the previous option
switch(previousOption)
{
case StartupOptions.None:
break;
case StartupOptions.AllUsers:
this.RemoveLocalMachineStartupItem(previousStartupItemName);
break;
case StartupOptions.CurrentUser:
this.RemoveCurrentUserStartupItem(previousStartupItemName);
break;
// case StartupOptions.AllUsersStartup:
// break;
//
// case StartupOptions.CurrentUserStartup:
// break;
};
bool result = false;
// add the new option
switch(newOption)
{
case StartupOptions.None:
this.RemoveLocalMachineStartupItem(previousStartupItemName);
this.RemoveCurrentUserStartupItem(previousStartupItemName);
break;
case StartupOptions.AllUsers:
result = this.AddLocalMachineStartupItem(startupItemName, startupItemValue);
break;
case StartupOptions.CurrentUser:
result = this.AddCurrentUserStartupItem(startupItemName, startupItemValue);
break;
// case StartupOptions.AllUsersStartup:
// break;
//
// case StartupOptions.CurrentUserStartup:
// break;
};
return result;
}
public void Restart(StartupOptions startupOptions)
{
MainStartup.Restart();
}
/// <summary>
/// Defines the entry point of the application.
/// </summary>
public static void Main()
{
var options = new StartupOptions();
_isRunningAsService = options.ContainsOption("-service");
var currentProcess = Process.GetCurrentProcess();
var applicationPath = currentProcess.MainModule.FileName;
var architecturePath = Path.Combine(Path.GetDirectoryName(applicationPath), Environment.Is64BitProcess ? "x64" : "x86");
Wand.SetMagickCoderModulePath(architecturePath);
var success = SetDllDirectory(architecturePath);
var appPaths = CreateApplicationPaths(applicationPath, _isRunningAsService);
var logManager = new NlogManager(appPaths.LogDirectoryPath, "server");
logManager.ReloadLogger(LogSeverity.Debug);
logManager.AddConsoleOutput();
var logger = _logger = logManager.GetLogger("Main");
ApplicationHost.LogEnvironmentInfo(logger, appPaths, true);
// Install directly
if (options.ContainsOption("-installservice"))
{
logger.Info("Performing service installation");
InstallService(applicationPath, logger);
return;
}
// Restart with admin rights, then install
if (options.ContainsOption("-installserviceasadmin"))
{
logger.Info("Performing service installation");
RunServiceInstallation(applicationPath);
return;
}
// Uninstall directly
if (options.ContainsOption("-uninstallservice"))
{
logger.Info("Performing service uninstallation");
UninstallService(applicationPath, logger);
return;
}
// Restart with admin rights, then uninstall
if (options.ContainsOption("-uninstallserviceasadmin"))
{
logger.Info("Performing service uninstallation");
RunServiceUninstallation(applicationPath);
return;
}
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
RunServiceInstallationIfNeeded(applicationPath);
if (IsAlreadyRunning(applicationPath, currentProcess))
{
logger.Info("Shutting down because another instance of Emby Server is already running.");
return;
}
if (PerformUpdateIfNeeded(appPaths, logger))
{
logger.Info("Exiting to perform application update.");
return;
}
try
{
RunApplication(appPaths, logManager, _isRunningAsService, options);
}
finally
{
OnServiceShutdown();
}
}
/// <summary>
/// Runs the application.
/// </summary>
/// <param name="appPaths">The app paths.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="runService">if set to <c>true</c> [run service].</param>
/// <param name="options">The options.</param>
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, bool runService, StartupOptions options)
{
var fileSystem = new NativeFileSystem(logManager.GetLogger("FileSystem"), false);
var nativeApp = new WindowsApp
{
IsRunningAsService = runService
};
_appHost = new ApplicationHost(appPaths,
logManager,
options,
fileSystem,
"MBServer",
true,
nativeApp);
var initProgress = new Progress <double>();
if (!runService)
{
if (!options.ContainsOption("-nosplash"))
{
ShowSplashScreen(_appHost.ApplicationVersion, initProgress, logManager.GetLogger("Splash"));
}
// Not crazy about this but it's the only way to suppress ffmpeg crash dialog boxes
SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS | ErrorModes.SEM_NOALIGNMENTFAULTEXCEPT |
ErrorModes.SEM_NOGPFAULTERRORBOX | ErrorModes.SEM_NOOPENFILEERRORBOX);
}
var task = _appHost.Init(initProgress);
task = task.ContinueWith(new Action <Task>(a => _appHost.RunStartupTasks()));
if (runService)
{
StartService(logManager);
}
else
{
Task.WaitAll(task);
SystemEvents.SessionEnding += SystemEvents_SessionEnding;
SystemEvents.SessionSwitch += SystemEvents_SessionSwitch;
HideSplashScreen();
ShowTrayIcon();
task = ApplicationTaskCompletionSource.Task;
Task.WaitAll(task);
}
}
/// <summary>
/// Restarts this instance.
/// </summary>
public virtual void Restart(StartupOptions startupOptions)
{
throw new NotImplementedException();
}
protected BaseMonoApp(StartupOptions startupOptions)
{
StartupOptions = startupOptions;
}
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, StartupOptions options)
{
// Allow all https requests
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(delegate { return(true); });
var environmentInfo = GetEnvironmentInfo();
var fileSystem = new ManagedFileSystem(logManager.GetLogger("FileSystem"), environmentInfo, null, appPaths.TempDirectory, true);
FileSystem = fileSystem;
using (var appHost = new MonoAppHost(appPaths,
logManager,
options,
fileSystem,
new PowerManagement(),
"embyserver-mono_{version}.zip",
environmentInfo,
new NullImageEncoder(),
new SystemEvents(logManager.GetLogger("SystemEvents")),
new NetworkManager(logManager.GetLogger("NetworkManager"), environmentInfo)))
{
if (options.ContainsOption("-v"))
{
Console.WriteLine(appHost.ApplicationVersion.ToString());
return;
}
Console.WriteLine("appHost.Init");
appHost.Init();
appHost.ImageProcessor.ImageEncoder = ImageEncoderHelper.GetImageEncoder(_logger, logManager, fileSystem, options, () => appHost.HttpClient, appPaths, environmentInfo, appHost.LocalizationManager);
Console.WriteLine("Running startup tasks");
var task = appHost.RunStartupTasks();
Task.WaitAll(task);
task = ApplicationTaskCompletionSource.Task;
Task.WaitAll(task);
}
}
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, StartupOptions options)
{
SystemEvents.SessionEnding += SystemEvents_SessionEnding;
// Allow all https requests
ServicePointManager.ServerCertificateValidationCallback = _ignoreCertificates;
_appHost = new ApplicationHost(appPaths, logManager, false, false, options);
Console.WriteLine("appHost.Init");
var initProgress = new Progress <double>();
var task = _appHost.Init(initProgress);
Task.WaitAll(task);
Console.WriteLine("Running startup tasks");
task = _appHost.RunStartupTasks();
Task.WaitAll(task);
task = _applicationTaskCompletionSource.Task;
Task.WaitAll(task);
}
private static async Task StartFromStartupOptions(StartupOptions options)
{
var tests = LoadTestCasesFromFile(options.Test);
await Run(options.Command, options.Argument, tests);
}
/// <summary>
/// Restarts this instance.
/// </summary>
public override void Restart(StartupOptions options)
{
MainClass.Restart();
}
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, StartupOptions options)
{
// Allow all https requests
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(delegate { return(true); });
var fileSystem = new MonoFileSystem(logManager.GetLogger("FileSystem"), false, false);
fileSystem.AddShortcutHandler(new MbLinkShortcutHandler(fileSystem));
var environmentInfo = GetEnvironmentInfo();
var imageEncoder = ImageEncoderHelper.GetImageEncoder(_logger, logManager, fileSystem, options, () => _appHost.HttpClient, appPaths);
_appHost = new MonoAppHost(appPaths,
logManager,
options,
fileSystem,
new PowerManagement(),
"emby.mono.zip",
environmentInfo,
imageEncoder,
new Startup.Common.SystemEvents(logManager.GetLogger("SystemEvents")),
new MemoryStreamProvider(),
new NetworkManager(logManager.GetLogger("NetworkManager")),
GenerateCertificate,
() => Environment.UserName);
if (options.ContainsOption("-v"))
{
Console.WriteLine(_appHost.ApplicationVersion.ToString());
return;
}
Console.WriteLine("appHost.Init");
var initProgress = new Progress <double>();
var task = _appHost.Init(initProgress);
Task.WaitAll(task);
Console.WriteLine("Running startup tasks");
task = _appHost.RunStartupTasks();
Task.WaitAll(task);
task = ApplicationTaskCompletionSource.Task;
Task.WaitAll(task);
}
/// <summary>
/// Runs the application.
/// </summary>
/// <param name="appPaths">The app paths.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="runService">if set to <c>true</c> [run service].</param>
/// <param name="options">The options.</param>
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, bool runService, StartupOptions options)
{
var environmentInfo = new EnvironmentInfo();
var fileSystem = new ManagedFileSystem(logManager.GetLogger("FileSystem"), environmentInfo, null, appPaths.TempDirectory);
FileSystem = fileSystem;
using (var appHost = new WindowsAppHost(appPaths,
logManager,
options,
fileSystem,
new PowerManagement(),
UpdatePackageFileName,
environmentInfo,
new NullImageEncoder(),
new SystemEvents(logManager.GetLogger("SystemEvents")),
new Networking.NetworkManager(logManager.GetLogger("NetworkManager"), environmentInfo)))
{
if (!runService)
{
ShowSplashScreen(appHost.ApplicationVersion, new Progress <double>(), logManager.GetLogger("Splash"));
// Not crazy about this but it's the only way to suppress ffmpeg crash dialog boxes
SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS | ErrorModes.SEM_NOALIGNMENTFAULTEXCEPT |
ErrorModes.SEM_NOGPFAULTERRORBOX | ErrorModes.SEM_NOOPENFILEERRORBOX);
}
appHost.Init();
Task task = null;
if (!runService)
{
task = InstallVcredist2013IfNeeded(appHost.HttpClient, _logger);
Task.WaitAll(task);
// needed by skia
task = InstallVcredist2015IfNeeded(appHost.HttpClient, _logger);
Task.WaitAll(task);
}
// set image encoder here
appHost.ImageProcessor.ImageEncoder = ImageEncoderHelper.GetImageEncoder(_logger, logManager, fileSystem, options, () => appHost.HttpClient, appPaths, appHost.LocalizationManager);
task = task.ContinueWith(new Action <Task>(a => appHost.RunStartupTasks()), TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.AttachedToParent);
if (runService && IsServiceInstalled())
{
StartService(logManager);
}
else
{
Task.WaitAll(task);
HideSplashScreen();
ShowTrayIcon(appHost);
}
}
}
protected BaseMonoApp(StartupOptions startupOptions, ILogger logger)
{
StartupOptions = startupOptions;
Logger = logger;
}
public static void Main()
{
var options = new StartupOptions(Environment.GetCommandLineArgs());
IsRunningAsService = options.ContainsOption("-service");
var currentProcess = Process.GetCurrentProcess();
ApplicationPath = currentProcess.MainModule.FileName;
var architecturePath = Path.Combine(Path.GetDirectoryName(ApplicationPath), Environment.Is64BitProcess ? "x64" : "x86");
var success = SetDllDirectory(architecturePath);
SQLitePCL.raw.SetProvider(new SQLitePCL.SQLite3Provider_sqlite3());
var appPaths = CreateApplicationPaths(ApplicationPath, IsRunningAsService);
_appPaths = appPaths;
using (var logManager = new SimpleLogManager(appPaths.LogDirectoryPath, "server"))
{
_logManager = logManager;
var task = logManager.ReloadLogger(LogSeverity.Debug, CancellationToken.None);
Task.WaitAll(task);
logManager.AddConsoleOutput();
var logger = _logger = logManager.GetLogger("Main");
ApplicationHost.LogEnvironmentInfo(logger, appPaths, true);
// Uninstall directly
if (options.ContainsOption("-uninstallservice"))
{
logger.Info("Performing service uninstallation");
UninstallService(ApplicationPath, logger);
return;
}
// Restart with admin rights, then uninstall
if (options.ContainsOption("-uninstallserviceasadmin"))
{
logger.Info("Performing service uninstallation");
RunServiceUninstallation(ApplicationPath);
return;
}
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
if (IsAlreadyRunning(ApplicationPath, currentProcess))
{
logger.Info("Shutting down because another instance of Emby Server is already running.");
return;
}
if (PerformUpdateIfNeeded(appPaths, logger))
{
logger.Info("Exiting to perform application update.");
return;
}
RunApplication(appPaths, logManager, IsRunningAsService, options);
logger.Info("Shutdown complete");
if (_restartOnShutdown)
{
logger.Info("Starting new server process");
var restartCommandLine = GetRestartCommandLine();
Process.Start(restartCommandLine.Item1, restartCommandLine.Item2);
}
}
}
private static void TestPHRPReader(string synOrFhtFile, bool blnSkipDuplicates)
{
var inputFile = new FileInfo(synOrFhtFile);
Console.WriteLine("Instantiating reader");
var startupOptions = new StartupOptions
{
LoadModsAndSeqInfo = true,
LoadMSGFResults = true,
LoadScanStatsData = false,
MaxProteinsPerPSM = 100
};
var phrpReader =
new ReaderFactory(inputFile.FullName, PeptideHitResultTypes.Unknown, startupOptions)
{
EchoMessagesToConsole = false,
SkipDuplicatePSMs = blnSkipDuplicates
};
// Check for any load errors
if (phrpReader.ErrorMessages.Count > 0)
{
Console.WriteLine("Error(s) instantiating the reader:");
foreach (var errorMessage in phrpReader.ErrorMessages)
{
Console.WriteLine(" " + errorMessage);
}
}
phrpReader.ErrorEvent += ErrorEventHandler;
phrpReader.StatusEvent += MessageEventHandler;
phrpReader.WarningEvent += WarningEventHandler;
const bool fastReadEnabled = true;
phrpReader.FastReadMode = fastReadEnabled;
var massCalculator = new PeptideMassCalculator();
if (!phrpReader.CanRead)
{
Console.WriteLine("Aborting since PHRPReader is not ready: " + phrpReader.ErrorMessage);
return;
}
var lstValues = new List <string>();
var intPSMsRead = 0;
var intModifiedPSMsRead = 0;
// ReSharper disable once CollectionNeverQueried.Local
var dctCachedValues = new Dictionary <int, PSM>();
Console.WriteLine("Reading data");
while (phrpReader.MoveNext())
{
var psm = phrpReader.CurrentPSM;
intPSMsRead += 1;
lstValues.Clear();
phrpReader.FinalizeCurrentPSM();
PeptideCleavageStateCalculator.SplitPrefixAndSuffixFromSequence(psm.Peptide, out _, out _, out _);
var strMassErrorPPM = GetCorrectedMassErrorPPM(psm, out _);
lstValues.Add(phrpReader.DatasetName + "_dta.txt"); // #SpecFile
lstValues.Add("index=" + intPSMsRead); // SpecID
lstValues.Add(psm.ScanNumber.ToString()); // ScanNum
lstValues.Add(psm.CollisionMode); // FragMethod
lstValues.Add(massCalculator.ConvoluteMass(psm.PrecursorNeutralMass, 0, psm.Charge).ToString(CultureInfo.InvariantCulture)); // Precursor m/z
lstValues.Add(strMassErrorPPM); // PrecursorError(ppm)
lstValues.Add(psm.Charge.ToString()); // Charge
lstValues.Add(psm.NumTrypticTermini.ToString()); // Tryptic state (0, 1, or 2)
lstValues.Add(CleanupPeptide(psm.PeptideWithNumericMods)); // Peptide
if (psm.SeqID <= 0)
{
lstValues.Add("**" + psm.SeqID + "**"); // SeqID is undefined
}
else
{
lstValues.Add(psm.SeqID.ToString()); // SeqID
}
lstValues.Add(psm.ProteinFirst);
if (psm.ProteinDetails.Count > 0)
{
var firstProteinDetail = psm.ProteinDetails.First();
if (!string.Equals(psm.ProteinFirst, firstProteinDetail.Key))
{
lstValues.Add(firstProteinDetail.Key);
}
else
{
lstValues.Add("<Match>");
}
lstValues.Add(firstProteinDetail.Value.ResidueStart.ToString());
lstValues.Add(firstProteinDetail.Value.ResidueEnd.ToString());
}
var strXCorr = GetScore(psm, SequestSynFileReader.GetColumnNameByID(SequestSynopsisFileColumns.XCorr), "0");
lstValues.Add(strXCorr);
lstValues.Add(GetScore(psm, SequestSynFileReader.GetColumnNameByID(SequestSynopsisFileColumns.Sp), "0"));
lstValues.Add(psm.MSGFSpecEValue);
lstValues.Add(GetScore(psm, SequestSynFileReader.GetColumnNameByID(SequestSynopsisFileColumns.DeltaCn2), "0"));
lstValues.Add(GetScore(psm, MSGFPlusSynFileReader.GetMSGFDBColumnNameByID(MSGFDBSynFileColumns.PValue), "0"));
lstValues.Add(GetScore(psm, MSGFPlusSynFileReader.GetColumnNameByID(MSGFPlusSynFileColumns.EValue), "0"));
lstValues.Add(GetScore(psm, MSGFPlusSynFileReader.GetColumnNameByID(MSGFPlusSynFileColumns.RankSpecEValue), "0"));
lstValues.Add(GetScore(psm, MSGFPlusSynFileReader.GetMSGFDBColumnNameByID(MSGFDBSynFileColumns.FDR), "1"));
lstValues.Add(GetScore(psm, MSGFPlusSynFileReader.GetColumnNameByID(MSGFPlusSynFileColumns.QValue), "0"));
lstValues.Add(GetScore(psm, MSGFPlusSynFileReader.GetColumnNameByID(MSGFPlusSynFileColumns.PepQValue), "0"));
if (psm.PeptideCleanSequence == "QQIEESTSDYDKEK")
{
Console.WriteLine(psm.Peptide + " in scan " + psm.ScanNumber);
var parentIonMZ = massCalculator.ConvoluteMass(psm.PrecursorNeutralMass, 0, psm.Charge);
Console.WriteLine("ParentIonMZ = " + parentIonMZ);
Console.WriteLine("PeptideWithNumericMods = " + psm.PeptideWithNumericMods);
}
if (psm.ModifiedResidues.Count > 0)
{
intModifiedPSMsRead += 1;
if (intModifiedPSMsRead % 500 == 0)
{
Console.WriteLine("PeptideWithNumericMods = " + psm.PeptideWithNumericMods);
foreach (var modifiedResidue in psm.ModifiedResidues)
{
Console.WriteLine(" " + modifiedResidue.Residue + modifiedResidue.EndResidueLocInPeptide + ": " + modifiedResidue.ModDefinition.ModificationMassAsText);
}
}
var dblPeptideMassRecomputed = massCalculator.ComputeSequenceMassNumericMods(psm.PeptideWithNumericMods);
if (Math.Abs(psm.PeptideMonoisotopicMass - dblPeptideMassRecomputed) > 0.1)
{
Console.WriteLine(" Peptide mass disagreement: " + (psm.PeptideMonoisotopicMass - dblPeptideMassRecomputed).ToString("0.0000000"));
}
}
var strFlattened = FlattenList(lstValues);
if (intPSMsRead % 10000 == 0)
{
Console.WriteLine(strFlattened);
}
dctCachedValues.Add(intPSMsRead, psm);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="datasetName">Dataset name</param>
/// <param name="inputFilePath">Input file path</param>
/// <param name="startupOptions">Startup Options, in particular LoadModsAndSeqInfo and MaxProteinsPerPSM</param>
public MSGFDBSynFileReader(string datasetName, string inputFilePath, StartupOptions startupOptions)
: base(datasetName, inputFilePath, startupOptions)
{
}
/// <summary>
/// Runs the application.
/// </summary>
/// <param name="appPaths">The app paths.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="runService">if set to <c>true</c> [run service].</param>
/// <param name="options">The options.</param>
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, bool runService, StartupOptions options)
{
var fileSystem = new WindowsFileSystem(new PatternsLogger(logManager.GetLogger("FileSystem")));
fileSystem.AddShortcutHandler(new MbLinkShortcutHandler(fileSystem));
//fileSystem.AddShortcutHandler(new LnkShortcutHandler(fileSystem));
var nativeApp = new WindowsApp(fileSystem, _logger)
{
IsRunningAsService = runService
};
_appHost = new ApplicationHost(appPaths,
logManager,
options,
fileSystem,
"emby.windows.zip",
nativeApp);
var initProgress = new Progress <double>();
if (!runService)
{
if (!options.ContainsOption("-nosplash"))
{
ShowSplashScreen(_appHost.ApplicationVersion, initProgress, logManager.GetLogger("Splash"));
}
// Not crazy about this but it's the only way to suppress ffmpeg crash dialog boxes
SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS | ErrorModes.SEM_NOALIGNMENTFAULTEXCEPT |
ErrorModes.SEM_NOGPFAULTERRORBOX | ErrorModes.SEM_NOOPENFILEERRORBOX);
}
var task = _appHost.Init(initProgress);
Task.WaitAll(task);
task = task.ContinueWith(new Action <Task>(a => _appHost.RunStartupTasks()), TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.AttachedToParent);
if (runService)
{
StartService(logManager);
}
else
{
Task.WaitAll(task);
task = InstallVcredist2013IfNeeded(_appHost, _logger);
Task.WaitAll(task);
SystemEvents.SessionEnding += SystemEvents_SessionEnding;
SystemEvents.SessionSwitch += SystemEvents_SessionSwitch;
HideSplashScreen();
ShowTrayIcon();
task = ApplicationTaskCompletionSource.Task;
Task.WaitAll(task);
}
}
public static IServiceCollection AddPlatformService(this IServiceCollection services, StartupOptions options)
{
if (OperatingSystem2.IsAndroid)
{
services.AddSingleton <AndroidPlatformServiceImpl>();
services.AddSingleton <IPlatformService>(s => s.GetRequiredService <AndroidPlatformServiceImpl>());
services.AddPlatformNotificationService();
services.TryAddAndroidClientHttpPlatformHelperService();
PlatformToastImpl.TryAddToast(services);
services.AddSingleton <IBiometricService, PlatformBiometricServiceImpl>();
services.AddSingleton <IFilePickerPlatformService.ISaveFileDialogService, FilePickerPlatformServiceImpl>();
#if __XAMARIN_FORMS__
services.AddSingleton <IPlatformPageRouteService, AndroidPageRouteServiceImpl>();
#endif
services.AddSingleton <IDeviceInfoPlatformService, AndroidDeviceInfoPlatformServiceImpl>();
}
else
{
throw new PlatformNotSupportedException();
}
return(services);
}
public MonoAppHost(ServerApplicationPaths applicationPaths, ILogManager logManager, StartupOptions options, IFileSystem fileSystem, IPowerManagement powerManagement, string releaseAssetFilename, IEnvironmentInfo environmentInfo, MediaBrowser.Controller.Drawing.IImageEncoder imageEncoder, ISystemEvents systemEvents, MediaBrowser.Common.Net.INetworkManager networkManager) : base(applicationPaths, logManager, options, fileSystem, powerManagement, releaseAssetFilename, environmentInfo, imageEncoder, systemEvents, networkManager)
{
}
/// <summary>
/// Runs the application.
/// </summary>
/// <param name="appPaths">The app paths.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="runService">if set to <c>true</c> [run service].</param>
/// <param name="options">The options.</param>
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, bool runService, StartupOptions options)
{
var fileSystem = new ManagedFileSystem(logManager.GetLogger("FileSystem"), true, true, true, appPaths.TempDirectory);
fileSystem.AddShortcutHandler(new LnkShortcutHandler());
fileSystem.AddShortcutHandler(new MbLinkShortcutHandler(fileSystem));
var imageEncoder = ImageEncoderHelper.GetImageEncoder(_logger, logManager, fileSystem, options, () => _appHost.HttpClient, appPaths);
_appHost = new WindowsAppHost(appPaths,
logManager,
options,
fileSystem,
new PowerManagement(),
"emby.windows.zip",
new EnvironmentInfo(),
imageEncoder,
new Server.Startup.Common.SystemEvents(logManager.GetLogger("SystemEvents")),
new RecyclableMemoryStreamProvider(),
new Networking.NetworkManager(logManager.GetLogger("NetworkManager")),
GenerateCertificate,
() => Environment.UserDomainName);
var initProgress = new Progress<double>();
if (!runService)
{
if (!options.ContainsOption("-nosplash")) ShowSplashScreen(_appHost.ApplicationVersion, initProgress, logManager.GetLogger("Splash"));
// Not crazy about this but it's the only way to suppress ffmpeg crash dialog boxes
SetErrorMode(ErrorModes.SEM_FAILCRITICALERRORS | ErrorModes.SEM_NOALIGNMENTFAULTEXCEPT |
ErrorModes.SEM_NOGPFAULTERRORBOX | ErrorModes.SEM_NOOPENFILEERRORBOX);
}
var task = _appHost.Init(initProgress);
Task.WaitAll(task);
task = task.ContinueWith(new Action<Task>(a => _appHost.RunStartupTasks()), TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.AttachedToParent);
if (runService)
{
StartService(logManager);
}
else
{
Task.WaitAll(task);
task = InstallVcredist2013IfNeeded(_appHost, _logger);
Task.WaitAll(task);
Microsoft.Win32.SystemEvents.SessionSwitch += SystemEvents_SessionSwitch;
HideSplashScreen();
ShowTrayIcon();
task = ApplicationTaskCompletionSource.Task;
Task.WaitAll(task);
}
}
public async Task <FFMpegInfo> GetFFMpegInfo(StartupOptions options, IProgress <double> progress)
{
var customffMpegPath = options.GetOption("-ffmpeg");
var customffProbePath = options.GetOption("-ffprobe");
if (!string.IsNullOrWhiteSpace(customffMpegPath) && !string.IsNullOrWhiteSpace(customffProbePath))
{
return(new FFMpegInfo
{
ProbePath = customffProbePath,
EncoderPath = customffMpegPath,
Version = "custom"
});
}
var version = FFMpegDownloadInfo.Version;
if (string.Equals(version, "path", StringComparison.OrdinalIgnoreCase))
{
return(new FFMpegInfo
{
ProbePath = FFMpegDownloadInfo.FFProbeFilename,
EncoderPath = FFMpegDownloadInfo.FFMpegFilename,
Version = version
});
}
var rootEncoderPath = Path.Combine(_appPaths.ProgramDataPath, "ffmpeg");
var versionedDirectoryPath = Path.Combine(rootEncoderPath, version);
var info = new FFMpegInfo
{
ProbePath = Path.Combine(versionedDirectoryPath, FFMpegDownloadInfo.FFProbeFilename),
EncoderPath = Path.Combine(versionedDirectoryPath, FFMpegDownloadInfo.FFMpegFilename),
Version = version
};
Directory.CreateDirectory(versionedDirectoryPath);
var excludeFromDeletions = new List <string> {
versionedDirectoryPath
};
if (!File.Exists(info.ProbePath) || !File.Exists(info.EncoderPath))
{
// ffmpeg not present. See if there's an older version we can start with
var existingVersion = GetExistingVersion(info, rootEncoderPath);
// No older version. Need to download and block until complete
if (existingVersion == null)
{
await DownloadFFMpeg(versionedDirectoryPath, progress).ConfigureAwait(false);
}
else
{
// Older version found.
// Start with that. Download new version in the background.
var newPath = versionedDirectoryPath;
Task.Run(() => DownloadFFMpegInBackground(newPath));
info = existingVersion;
versionedDirectoryPath = Path.GetDirectoryName(info.EncoderPath);
excludeFromDeletions.Add(versionedDirectoryPath);
}
}
await DownloadFonts(versionedDirectoryPath).ConfigureAwait(false);
DeleteOlderFolders(Path.GetDirectoryName(versionedDirectoryPath), excludeFromDeletions);
return(info);
}
public FFMpegInfo GetFFMpegInfo(StartupOptions options)
{
var customffMpegPath = options.GetOption("-ffmpeg");
var customffProbePath = options.GetOption("-ffprobe");
if (!string.IsNullOrWhiteSpace(customffMpegPath) && !string.IsNullOrWhiteSpace(customffProbePath))
{
return(new FFMpegInfo
{
ProbePath = customffProbePath,
EncoderPath = customffMpegPath,
Version = "external"
});
}
var downloadInfo = _ffmpegInstallInfo;
var prebuiltFolder = _appPaths.ProgramSystemPath;
var prebuiltffmpeg = Path.Combine(prebuiltFolder, downloadInfo.FFMpegFilename);
var prebuiltffprobe = Path.Combine(prebuiltFolder, downloadInfo.FFProbeFilename);
if (_fileSystem.FileExists(prebuiltffmpeg) && _fileSystem.FileExists(prebuiltffprobe))
{
return(new FFMpegInfo
{
ProbePath = prebuiltffprobe,
EncoderPath = prebuiltffmpeg,
Version = "external"
});
}
var version = downloadInfo.Version;
if (string.Equals(version, "0", StringComparison.OrdinalIgnoreCase))
{
return(new FFMpegInfo());
}
var rootEncoderPath = Path.Combine(_appPaths.ProgramDataPath, "ffmpeg");
var versionedDirectoryPath = Path.Combine(rootEncoderPath, version);
var info = new FFMpegInfo
{
ProbePath = Path.Combine(versionedDirectoryPath, downloadInfo.FFProbeFilename),
EncoderPath = Path.Combine(versionedDirectoryPath, downloadInfo.FFMpegFilename),
Version = version
};
_fileSystem.CreateDirectory(versionedDirectoryPath);
var excludeFromDeletions = new List <string> {
versionedDirectoryPath
};
if (!_fileSystem.FileExists(info.ProbePath) || !_fileSystem.FileExists(info.EncoderPath))
{
// ffmpeg not present. See if there's an older version we can start with
var existingVersion = GetExistingVersion(info, rootEncoderPath);
// No older version. Need to download and block until complete
if (existingVersion == null)
{
return(new FFMpegInfo());
}
else
{
info = existingVersion;
versionedDirectoryPath = _fileSystem.GetDirectoryName(info.EncoderPath);
excludeFromDeletions.Add(versionedDirectoryPath);
}
}
// Allow just one of these to be overridden, if desired.
if (!string.IsNullOrWhiteSpace(customffMpegPath))
{
info.EncoderPath = customffMpegPath;
}
if (!string.IsNullOrWhiteSpace(customffProbePath))
{
info.ProbePath = customffProbePath;
}
return(info);
}
public async Task<FFMpegInfo> GetFFMpegInfo(NativeEnvironment environment, StartupOptions options, IProgress<double> progress)
{
var customffMpegPath = options.GetOption("-ffmpeg");
var customffProbePath = options.GetOption("-ffprobe");
if (!string.IsNullOrWhiteSpace(customffMpegPath) && !string.IsNullOrWhiteSpace(customffProbePath))
{
return new FFMpegInfo
{
ProbePath = customffProbePath,
EncoderPath = customffMpegPath,
Version = "custom"
};
}
var downloadInfo = FFMpegDownloadInfo.GetInfo(environment);
var version = downloadInfo.Version;
if (string.Equals(version, "path", StringComparison.OrdinalIgnoreCase))
{
return new FFMpegInfo
{
ProbePath = downloadInfo.FFProbeFilename,
EncoderPath = downloadInfo.FFMpegFilename,
Version = version
};
}
var rootEncoderPath = Path.Combine(_appPaths.ProgramDataPath, "ffmpeg");
var versionedDirectoryPath = Path.Combine(rootEncoderPath, version);
var info = new FFMpegInfo
{
ProbePath = Path.Combine(versionedDirectoryPath, downloadInfo.FFProbeFilename),
EncoderPath = Path.Combine(versionedDirectoryPath, downloadInfo.FFMpegFilename),
Version = version
};
_fileSystem.CreateDirectory(versionedDirectoryPath);
var excludeFromDeletions = new List<string> { versionedDirectoryPath };
if (!_fileSystem.FileExists(info.ProbePath) || !_fileSystem.FileExists(info.EncoderPath))
{
// ffmpeg not present. See if there's an older version we can start with
var existingVersion = GetExistingVersion(info, rootEncoderPath);
// No older version. Need to download and block until complete
if (existingVersion == null)
{
await DownloadFFMpeg(downloadInfo, versionedDirectoryPath, progress).ConfigureAwait(false);
}
else
{
// Older version found.
// Start with that. Download new version in the background.
var newPath = versionedDirectoryPath;
Task.Run(() => DownloadFFMpegInBackground(downloadInfo, newPath));
info = existingVersion;
versionedDirectoryPath = Path.GetDirectoryName(info.EncoderPath);
excludeFromDeletions.Add(versionedDirectoryPath);
}
}
await DownloadFonts(versionedDirectoryPath).ConfigureAwait(false);
DeleteOlderFolders(Path.GetDirectoryName(versionedDirectoryPath), excludeFromDeletions);
// Allow just one of these to be overridden, if desired.
if (!string.IsNullOrWhiteSpace(customffMpegPath))
{
info.EncoderPath = customffMpegPath;
}
if (!string.IsNullOrWhiteSpace(customffProbePath))
{
info.EncoderPath = customffProbePath;
}
return info;
}
private static void RunApplication(ServerApplicationPaths appPaths, ILogManager logManager, StartupOptions options)
{
SystemEvents.SessionEnding += SystemEvents_SessionEnding;
// Allow all https requests
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(delegate { return(true); });
var fileSystem = new CommonFileSystem(logManager.GetLogger("FileSystem"), false, true);
var nativeApp = new NativeApp();
_appHost = new ApplicationHost(appPaths, logManager, options, fileSystem, "MBServer.Mono", nativeApp);
if (options.ContainsOption("-v"))
{
Console.WriteLine(_appHost.ApplicationVersion.ToString());
return;
}
Console.WriteLine("appHost.Init");
var initProgress = new Progress <double>();
var task = _appHost.Init(initProgress);
Task.WaitAll(task);
Console.WriteLine("Running startup tasks");
task = _appHost.RunStartupTasks();
Task.WaitAll(task);
task = ApplicationTaskCompletionSource.Task;
Task.WaitAll(task);
}
