/// <summary> /// Launches a system URI asynchronously and returns an empty Warden process set to Alive /// This spawns an asynchronous loop that will execute a callback if the target process is found /// However the function returns right away to ensure it does not block. /// </summary> /// <param name="uri">The URI that will be launched</param> /// <param name="path">The full path of the executable that should spawn after the URI launch.</param> /// <param name="arguments">Any additional arguments.</param> /// <param name="filters">A list of filters so certain processes are not added to the tree.</param> /// <param name="callback">A callback executed on if the process launched or not.</param> /// <param name="cancelToken"></param> /// <returns></returns> public static async Task <WardenProcess> StartUriAsync(string uri, string path, string arguments, List <ProcessFilter> filters, Action <bool> callback, CancellationToken cancelToken, bool asUser = false, string workingDir = null) { if (!Initialized) { throw new WardenManageException(Resources.Exception_Not_Initialized); } if (CheckForWardenProcess(path, out var existingProcess)) { return(existingProcess); } if (string.IsNullOrWhiteSpace(arguments)) { arguments = string.Empty; } //lets add it to the dictionary ahead of time in case our program launches faster than we can return var key = Guid.NewGuid(); var warden = new WardenProcess(System.IO.Path.GetFileNameWithoutExtension(path), new Random().Next(1000000, 2000000), path, ProcessState.Alive, arguments?.SplitSpace(), ProcessTypes.Uri, filters) { FoundCallback = callback }; ManagedProcesses[key] = warden; if (await new UriLauncher().PrepareUri(uri, path, arguments, cancelToken, key, asUser, workingDir) != null) { return(ManagedProcesses[key]); } ManagedProcesses.TryRemove(key, out var t); return(null); }
/// <summary> /// Starts a process or URI via the Windows shell. /// </summary> /// <param name="startInfo"></param> /// <param name="callback"></param> /// <returns></returns> public static WardenProcess StartByShell(WardenStartInfo startInfo, Action <bool> callback = null) { if (!Initialized) { throw new WardenManageException(Resources.Exception_Not_Initialized); } if (string.IsNullOrWhiteSpace(startInfo.FileName)) { throw new ArgumentException("fileName cannot be empty."); } if (startInfo.Track && string.IsNullOrWhiteSpace(startInfo.TargetFileName)) { throw new ArgumentException("targetFileName cannot be empty."); } if (CheckForWardenProcess(startInfo.TargetFileName, out var existingProcess)) { return(existingProcess); } if (string.IsNullOrWhiteSpace(startInfo.Arguments)) { startInfo.Arguments = string.Empty; } var shellStartInfo = new ShellStartInfo(startInfo.FileName, startInfo.Arguments, startInfo.WorkingDirectory) { Verb = startInfo.RaisePrivileges ? "runas" : "open" }; if (startInfo.Track) { var key = Guid.NewGuid(); var proc = new WardenProcess(System.IO.Path.GetFileNameWithoutExtension(startInfo.TargetFileName), GenerateProcessId(), startInfo.TargetFileName, ProcessState.Alive, startInfo.Arguments.SplitSpace(), startInfo.Filters) { FoundCallback = callback }; if (ManagedProcesses.TryAdd(key, proc)) { Api.StartByShell(shellStartInfo); if (ManagedProcesses.TryGetValue(key, out var process)) { return(process); } } } Api.StartByShell(shellStartInfo); return(null); }
/// <summary> /// Launches a system URI and returns an empty Warden process set to Alive /// This spawns an asynchronous loop that will execute a callback if the target process is found /// However the function returns right away to ensure it does not block. /// </summary> /// <param name="startInfo"></param> /// <param name="callback"></param> /// <returns></returns> public static WardenProcess StartUriDeferred(WardenStartInfo startInfo, Action <bool> callback) { if (!Initialized) { throw new WardenManageException(Resources.Exception_Not_Initialized); } if (string.IsNullOrWhiteSpace(startInfo.FileName)) { throw new ArgumentException("fileName cannot be empty."); } if (string.IsNullOrWhiteSpace(startInfo.TargetFileName)) { throw new ArgumentException("targetFileName cannot be empty."); } if (CheckForWardenProcess(startInfo.TargetFileName, out var existingProcess)) { return(existingProcess); } if (string.IsNullOrWhiteSpace(startInfo.Arguments)) { startInfo.Arguments = string.Empty; } //lets add it to the dictionary ahead of time in case our program launches faster than we can return var key = Guid.NewGuid(); var warden = new WardenProcess(System.IO.Path.GetFileNameWithoutExtension(startInfo.TargetFileName), GenerateProcessId(), startInfo.TargetFileName, ProcessState.Alive, startInfo.Arguments.SplitSpace(), startInfo.Filters) { FoundCallback = callback }; if (ManagedProcesses.TryAdd(key, warden)) { if (UriShell.LaunchUriDeferred(startInfo)) { if (ManagedProcesses.TryGetValue(key, out var process)) { return(process); } } } ManagedProcesses.TryRemove(key, out var failedProcess); return(null); }
/// <summary> /// Attempts to create a Warden process tree from an existing system process. /// </summary> /// <param name="pId"></param> /// <param name="filters">A list of filters so certain processes are not added to the tree.</param> /// <param name="processPath"></param> /// <param name="commandLine"></param> /// <param name="track"></param> /// <returns></returns> public static WardenProcess GetProcessFromId(int pId, List <ProcessFilter> filters = null, string processPath = null, List <string> commandLine = null, bool track = true) { var process = BuildTreeById(pId, filters, processPath, commandLine); if (process == null) { return(null); } if (!track) { return(process); } var key = Guid.NewGuid(); if (ManagedProcesses.TryAdd(key, process)) { return(process); } ManagedProcesses.TryRemove(key, out var _); return(null); }
/// <summary> /// Checks if a process is currently running, if so we build the WardenProcess right away or fetch a monitored one. /// </summary> /// <param name="path"></param> /// <param name="process"></param> /// <returns></returns> private static bool CheckForWardenProcess(string path, out WardenProcess process) { using (var runningProcess = GetProcess(path)) { if (runningProcess == null) { process = null; return(false); } foreach (var key in ManagedProcesses.Keys) { if (ManagedProcesses.TryGetValue(key, out process)) { if (process.Id == runningProcess.Id) { return(true); } } } process = null; return(false); } }