- Many changes to async code (File Swapper, Logging) and greatly sped up the file swapping process

sharpjd · sharpjd · commit 68b7b09dc9bc · 2024-03-16T18:14:43.000-04:00
- Task Scheduler entries no longer only run while plugged in
diff --git a/GPUPrefSwitcher/AppLogger.cs b/GPUPrefSwitcher/AppLogger.cs
@@ -212,14 +212,14 @@ public int GlobalLogLevel
         /// <param name="str"></param>
         /// <param name="logLevel"></param>
         /// <returns></returns>
-        public Task Log(string str, int logLevel = 1000)
+        public void Log(string str, int logLevel = 1000)
         {
 
             if(logLevel < 0) { throw new ArgumentOutOfRangeException("logLevel must be positive"); }
             if(logLevel > GlobalLogLevel)
             {
                 skippedLogs++;
-                return Task.CompletedTask; 
+                return;
             }
 
             standardLogCount += 1;
@@ -228,12 +228,12 @@ public Task Log(string str, int logLevel = 1000)
 
             if (EnableRealtimeStandardLogWrites)
             {
-                semaphoreSlim_Standard.AvailableWaitHandle.WaitOne();//block if unavailable
-                return WriteAsyncInternal_Standard(toWrite);
+                semaphoreSlim_Standard.AvailableWaitHandle.WaitOne();//block if there's still a write in progress
+                _ = WriteAsyncInternal_Standard(toWrite);
             }
             
             StandardLogBuffer.Add(toWrite);
-            return Task.CompletedTask;
+            return;
              
         }
 
@@ -261,7 +261,6 @@ public string FormatMessageForStandardLog(string str, int logLevel)
         /// <returns></returns>
         private async Task WriteAsyncInternal_Standard(string str)
         {
-
             await semaphoreSlim_Standard.WaitAsync();
 
             try
@@ -274,6 +273,7 @@ private async Task WriteAsyncInternal_Standard(string str)
             {
                 semaphoreSlim_Standard.Release();
             }
+
         }
 
         /// <summary>
diff --git a/GPUPrefSwitcher/FileSwapper.cs b/GPUPrefSwitcher/FileSwapper.cs
@@ -70,7 +70,7 @@ public FileSwapper(AppEntry appEntry, PreferencesXML preferencesXML)
         
         public async Task InitiateFileSwaps(PowerLineStatus forPowerLineStatus, PreferencesXML preferencesXML)
         {
-            Logger.inst.Log($"Initiating FileSwap for AppEntry with target path {AppEntry.AppPath}");
+            Logger.inst.Log($"Initiating File Swaps for AppEntry with target path {AppEntry.AppPath}");
 
             //if the AppEntry doesn't yet have its own FileSwap folder, create it
             bool appEntryFolderExists = Directory.Exists(SettingsBankFolderPath);
@@ -80,6 +80,7 @@ public async Task InitiateFileSwaps(PowerLineStatus forPowerLineStatus, Preferen
                 File.Create(Path.Combine(SettingsBankFolderPath, $"{AppEntry.AppName} settings are in {SettingsBankFolderPath}"));
             }
 
+            List<Task> fileSwapTasks = new();
             //commence the swap for each FileSwapPath
             for (int i = 0; i < AppEntry.FileSwapperPaths.Length; i++)
             {
@@ -99,7 +100,7 @@ public async Task InitiateFileSwaps(PowerLineStatus forPowerLineStatus, Preferen
                 
                 try
                 {
-                    Task singleFileSwap = InitiateSingleFileSwap(current, i);
+                    fileSwapTasks.Add(InitiateSingleFileSwap(current, i));
                 }
                 catch (AggregateException)
                 {
@@ -108,7 +109,11 @@ public async Task InitiateFileSwaps(PowerLineStatus forPowerLineStatus, Preferen
 
             } //...repeat for every SwapPath
 
-            Logger.inst.Log($"Finished firing FileSwap logic for AppEntry with target path {AppEntry.AppPath}");
+            Logger.inst.Log($"Finished firing single FileSwap tasks for AppEntry with target path {AppEntry.AppPath}");
+
+            await Task.WhenAll(fileSwapTasks);
+
+            Logger.inst.Log($"Completed all FileSwap tasks for AppEntry with target path {AppEntry.AppPath}");
 
         }
 
@@ -154,15 +159,15 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int
         WaitForOlderFileSwaps:
             if (OngoingFileSwapTasks.Any(x => x.FileSwapPath == fileSwapPathTask.FileSwapPath && x.ID < fileSwapPathTask.ID))
             {
-                Task log = Logger.inst.Log($"An older FileSwap task for {swapPath} already exists, delaying");
+                Logger.inst.Log($"An older FileSwap task for {swapPath} already exists, delaying");
                 await Task.Delay(10000);
                 goto WaitForOlderFileSwaps;
             }
 
         WaitForAppToClose:
-            if (IsProcessRunning(AppEntry.AppPath))
+            if (await IsProcessRunning(AppEntry.AppPath)) //IsProcessRunning is apparently VERY expensive
             {
-                Task log = Logger.inst.Log($"Target app {AppEntry.AppPath} is still running, delaying File Swap for {swapPath}");
+                Logger.inst.Log($"Target app {AppEntry.AppPath} is still running, delaying File Swap for {swapPath}");
                 await Task.Delay(5000);
                 goto WaitForAppToClose;
             }
@@ -184,7 +189,7 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int
             StoreFile_OnBattery:
                 try
                 {
-                    FileCopyConsiderAccessRules(swapPath, onBatteryStoredFilePath, true, false);
+                    await FileCopyConsiderAccessRules(swapPath, onBatteryStoredFilePath, true, false);
                     File.Create(Path.Combine(SettingsBankFolderPath, $"{Path.GetFileName(swapPath)} is in {swapPathHash}"));
                 } 
                 catch (IOException)
@@ -203,7 +208,7 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int
             StoreFile_PluggedIn:
                 try
                 {
-                    FileCopyConsiderAccessRules(swapPath, pluggedInStoredFilePath, true, false);
+                    await FileCopyConsiderAccessRules(swapPath, pluggedInStoredFilePath, true, false);
                     File.Create(Path.Combine(SettingsBankFolderPath, $"{Path.GetFileName(swapPath)} is in {swapPathHash}"));
                 }
                 catch (IOException)
@@ -224,13 +229,13 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int
                     try
                     {
                         //no need to cancel the save if the substitution fails
-                        FileCopyConsiderAccessRules(swapPath, pluggedInStoredFilePath, true, false); //save current config to PluggedIn store
+                        await FileCopyConsiderAccessRules(swapPath, pluggedInStoredFilePath, true, false); //save current config to PluggedIn store
                         string s1 = $"Saved SwapPath {swapPath} for app {AppEntry.AppPath} as PluggedIn";
                         Logger.inst.Log(s1);
 
                         errorFlag = 1;
 
-                        FileCopyConsiderAccessRules(onBatteryStoredFilePath, swapPath, true, true); //then substitute with OnBattery config
+                        await FileCopyConsiderAccessRules(onBatteryStoredFilePath, swapPath, true, true); //then substitute with OnBattery config
                         string s2 = $"Substituted OnBattery config into SwapPath {swapPath} for app {AppEntry.AppPath}";
                         Logger.inst.Log(s2);
 
@@ -256,6 +261,9 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int
                     preferencesXML.ModifyAppEntryAndSave(AppEntry.AppPath, modified);
                     string s3 = $"Saved SwapPath state for SwapPath {swapPath} for app {AppEntry.AppPath}";
                     Logger.inst.Log(s3);
+                } else
+                {
+                    Logger.inst.Log($"Skipped operations for File Swap path {swapPath} because it's already in its correct state.");
                 }
             }
             else if (forPowerLineStatus == PowerLineStatus.Online)
@@ -268,13 +276,13 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int
                     {
 
                         //no need to cancel the save if the substitution fails 
-                        FileCopyConsiderAccessRules(swapPath, onBatteryStoredFilePath, true, false); //save current config to OnBattery store
+                        await FileCopyConsiderAccessRules(swapPath, onBatteryStoredFilePath, true, false); //save current config to OnBattery store
                         string s1 = $"Saved SwapPath {swapPath} for app {AppEntry.AppPath} as OnBattery";
                         Logger.inst.Log(s1);
 
                         errorFlag = 1;
 
-                        FileCopyConsiderAccessRules(pluggedInStoredFilePath, swapPath, true, true); //then substitute with PluggedIn config
+                        await FileCopyConsiderAccessRules(pluggedInStoredFilePath, swapPath, true, true); //then substitute with PluggedIn config
                         string s2 = $"Substituted PluggedIn config into SwapPath {swapPath} for app {AppEntry.AppPath}";
                         Logger.inst.Log(s2);
                     }
@@ -298,20 +306,23 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int
                     preferencesXML.ModifyAppEntryAndSave(AppEntry.AppPath, modified);
                     string s3 = $"Saved SwapPath state for SwapPath {swapPath} for app {AppEntry.AppPath}";
                     Logger.inst.Log(s3);
+                } else
+                {
+                    Logger.inst.Log($"Skipped operations for File Swap path {swapPath} because it's already in its correct state.");
                 }
             }
             else
             {
                 Debug.WriteLine($"Unknown power state: " + forPowerLineStatus.ToString());
             }
 
-            await Logger.inst.Log($"FileSwaps Task finished for {AppEntry.AppPath}");
+            Logger.inst.Log($"FileSwap Task {fileSwapPathTask.FileSwapPath} finished for {AppEntry.AppPath}");
 
             OngoingFileSwapTasks.Remove(fileSwapPathTask);
 
         }
 
-        static bool IsProcessRunning(string processPath)
+        static async Task<bool> IsProcessRunning(string processPath) //this function is apparently VERY expensive to run (many mores times than this app itself) so await it!
         {
             Process[] processes = Process.GetProcesses();
 
@@ -320,7 +331,7 @@ static bool IsProcessRunning(string processPath)
                 try
                 {
                     // Compare the process's main module file name with the specified process path
-                    if (string.Equals(process.MainModule.FileName, processPath, StringComparison.OrdinalIgnoreCase))
+                    if (await Task.Run(() => string.Equals(process.MainModule.FileName, processPath, StringComparison.OrdinalIgnoreCase))) //the expensive line in question
                     {
                         return true;
                     }
@@ -379,7 +390,7 @@ static byte[] GetHash(string str)
         /// </summary>
         /// 
         /// And yes, I think it's clearer to throw exceptions instead of returning false, unless there is a better way (in which I have tried TWICE; this is perfectly functional)
-        public static void FileCopyConsiderAccessRules(string sourceFileName, string destinationFileName, bool overwrite, bool ensureDestinationExists = true)
+        public static Task FileCopyConsiderAccessRules(string sourceFileName, string destinationFileName, bool overwrite, bool ensureDestinationExists = true)
         {
 
             FileInfo sourceInfo = new FileInfo(sourceFileName);
@@ -437,6 +448,8 @@ public static void FileCopyConsiderAccessRules(string sourceFileName, string des
             sourceFileSecurity.SetAccessRuleProtection(true, true); //supposedly this doesn't change the existing file's security settings?
             File.Copy(sourceFileName, destinationFileName, true);
             destinationInfo.SetAccessControl(sourceFileSecurity); //requires the file to exist, duh
+
+            return Task.CompletedTask;
         }
 
         /*
diff --git a/GPUPrefSwitcher/Switcher.cs b/GPUPrefSwitcher/Switcher.cs
@@ -251,29 +251,30 @@ private static void UpdateSeenInRegistryStatuses()
             }
         }
 
-        private static Task BeginFileSwapLogic(PowerLineStatus forPowerLineStatus, IEnumerable<AppEntry> forAppEntries)
+        private static async Task BeginFileSwapLogic(PowerLineStatus forPowerLineStatus, IEnumerable<AppEntry> forAppEntries)
         {
             Logger.inst.Log("Commence file swap logic.");
-            //shorten these long names
 
             //create the SettingsBank directory if it doesn't exist
             bool fileSwapperFolderExists = Directory.Exists(FileSwapper.SwapPathFolder);
             if (!fileSwapperFolderExists) { Directory.CreateDirectory(FileSwapper.SwapPathFolder); }
 
+            List<Task> fileSwapTasks = new();
             foreach (AppEntry appEntry in forAppEntries)
             {
                 var fileSwap = new FileSwapper(appEntry, preferencesXML);
 
                 if (!appEntry.EnableFileSwapper) continue;
                 if (appEntry.FileSwapperPaths.Length == 0) continue;
 
-                fileSwap.InitiateFileSwaps(forPowerLineStatus, preferencesXML);
+                Task fileSwapTask = fileSwap.InitiateFileSwaps(forPowerLineStatus, preferencesXML);
+                fileSwapTasks.Add(fileSwapTask);
 
-            } //...repeat for every AppEntry
+            }
 
-            Logger.inst.Log("File swap logic finished.");
+            await Task.WhenAll(fileSwapTasks);
 
-            return Task.CompletedTask;
+            Logger.inst.Log("File swap logic finished.");
         }
 
         static string[] ignoreList = RegistryHelper.ignoreValues;
diff --git a/GPUPrefSwitcher/SwitcherService.cs b/GPUPrefSwitcher/SwitcherService.cs
@@ -30,7 +30,7 @@ public Task StartAsync(CancellationToken cancellationToken)
         private void OnSessionEnd(object sender, SessionEndingEventArgs e)
         {
             e.Cancel = true;
-            Logger.inst.Log($"OnSessionEnd received (reason: {e.Reason})").Wait();
+            Logger.inst.Log($"OnSessionEnd received (reason: {e.Reason})");
             if (e.Reason == SessionEndReasons.SystemShutdown)
             {
                 CleanUpService();
@@ -41,7 +41,7 @@ private void OnSessionEnd(object sender, SessionEndingEventArgs e)
         public Task StopAsync(CancellationToken cancellationToken)
         {
 
-            Logger.inst.Log("Service StopAsync called").Wait();
+            Logger.inst.Log("Service StopAsync called");
 
             CleanUpService();
 
@@ -55,7 +55,7 @@ public void Dispose()
 
         private void CleanUpService()
         {
-            Logger.inst.Log("Service ending cleanup called.").Wait();
+            Logger.inst.Log("Service ending cleanup called.");
 
             Logger.inst.DumpStandardLogBufferToStandardLog().Wait();
 
diff --git a/GPUPrefSwitcher/TaskSchedulerUtils.cs b/GPUPrefSwitcher/TaskSchedulerUtils.cs
@@ -17,6 +17,7 @@ public static void RunOnBatteryTask()
                 string description = "The GPUPrefSwitcher service runs this task once when the system is considered on battery." +
                     "\n It is up to you to add actions (e.g. start a script).";
                 CreateTask(TASK_NAME_ON_BATTERY, description, FOLDER_NAME);
+                Logger.inst.Log("Created On Battery Task Scheduler entry because it doesn't exist yet");
             }
 
             RunTask(TASK_NAME_ON_BATTERY);
@@ -29,6 +30,7 @@ public static void RunPluggedInTask()
                 string description = "The GPUPrefSwitcher service runs this task once when the system is considered plugged in." +
                     "\n It is up to you to add actions (e.g. start a script).";
                 CreateTask(TASK_NAME_PLUGGED_IN, description, FOLDER_NAME);
+                Logger.inst.Log("Created Plugged In Task Scheduler entry because it doesn't exist yet");
             }
 
             RunTask(TASK_NAME_PLUGGED_IN);
@@ -52,6 +54,8 @@ public static void CreateTask(string taskName, string description, string folder
                 //we need to create at least one action otherwise it complains
                 taskDefinition.Actions.Add(new ExecAction("cmd.exe", "/c echo Dummy task executed", null));
 
+                taskDefinition.Settings.DisallowStartIfOnBatteries = false;
+                taskDefinition.Settings.StopIfGoingOnBatteries = false;
 
                 TaskFolder folder = taskService.GetFolder(folderPath);
                 if (folder == null)

Original file line number	Diff line number	Diff line change
`@@ -212,14 +212,14 @@ public int GlobalLogLevel`
`212`	`212`	`/// <param name="str"></param>`
`213`	`213`	`/// <param name="logLevel"></param>`
`214`	`214`	`/// <returns></returns>`
`215`		`- public Task Log(string str, int logLevel = 1000)`
	`215`	`+ public void Log(string str, int logLevel = 1000)`
`216`	`216`	`{`
`217`	`217`
`218`	`218`	`if(logLevel < 0) { throw new ArgumentOutOfRangeException("logLevel must be positive"); }`
`219`	`219`	`if(logLevel > GlobalLogLevel)`
`220`	`220`	`{`
`221`	`221`	`skippedLogs++;`
`222`		`- return Task.CompletedTask;`
	`222`	`+ return;`
`223`	`223`	`}`
`224`	`224`
`225`	`225`	`standardLogCount += 1;`
`@@ -228,12 +228,12 @@ public Task Log(string str, int logLevel = 1000)`
`228`	`228`
`229`	`229`	`if (EnableRealtimeStandardLogWrites)`
`230`	`230`	`{`
`231`		`- semaphoreSlim_Standard.AvailableWaitHandle.WaitOne();//block if unavailable`
`232`		`- return WriteAsyncInternal_Standard(toWrite);`
	`231`	`+ semaphoreSlim_Standard.AvailableWaitHandle.WaitOne();//block if there's still a write in progress`
	`232`	`+ _ = WriteAsyncInternal_Standard(toWrite);`
`233`	`233`	`}`
`234`	`234`
`235`	`235`	`StandardLogBuffer.Add(toWrite);`
`236`		`- return Task.CompletedTask;`
	`236`	`+ return;`
`237`	`237`
`238`	`238`	`}`
`239`	`239`
`@@ -261,7 +261,6 @@ public string FormatMessageForStandardLog(string str, int logLevel)`
`261`	`261`	`/// <returns></returns>`
`262`	`262`	`private async Task WriteAsyncInternal_Standard(string str)`
`263`	`263`	`{`
`264`		`-`
`265`	`264`	`await semaphoreSlim_Standard.WaitAsync();`
`266`	`265`
`267`	`266`	`try`
`@@ -274,6 +273,7 @@ private async Task WriteAsyncInternal_Standard(string str)`
`274`	`273`	`{`
`275`	`274`	`semaphoreSlim_Standard.Release();`
`276`	`275`	`}`
	`276`	`+`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ public FileSwapper(AppEntry appEntry, PreferencesXML preferencesXML)`
`70`	`70`
`71`	`71`	`public async Task InitiateFileSwaps(PowerLineStatus forPowerLineStatus, PreferencesXML preferencesXML)`
`72`	`72`	`{`
`73`		`- Logger.inst.Log($"Initiating FileSwap for AppEntry with target path {AppEntry.AppPath}");`
	`73`	`+ Logger.inst.Log($"Initiating File Swaps for AppEntry with target path {AppEntry.AppPath}");`
`74`	`74`
`75`	`75`	`//if the AppEntry doesn't yet have its own FileSwap folder, create it`
`76`	`76`	`bool appEntryFolderExists = Directory.Exists(SettingsBankFolderPath);`
`@@ -80,6 +80,7 @@ public async Task InitiateFileSwaps(PowerLineStatus forPowerLineStatus, Preferen`
`80`	`80`	`File.Create(Path.Combine(SettingsBankFolderPath, $"{AppEntry.AppName} settings are in {SettingsBankFolderPath}"));`
`81`	`81`	`}`
`82`	`82`
	`83`	`+ List<Task> fileSwapTasks = new();`
`83`	`84`	`//commence the swap for each FileSwapPath`
`84`	`85`	`for (int i = 0; i < AppEntry.FileSwapperPaths.Length; i++)`
`85`	`86`	`{`
`@@ -99,7 +100,7 @@ public async Task InitiateFileSwaps(PowerLineStatus forPowerLineStatus, Preferen`
`99`	`100`
`100`	`101`	`try`
`101`	`102`	`{`
`102`		`- Task singleFileSwap = InitiateSingleFileSwap(current, i);`
	`103`	`+ fileSwapTasks.Add(InitiateSingleFileSwap(current, i));`
`103`	`104`	`}`
`104`	`105`	`catch (AggregateException)`
`105`	`106`	`{`
`@@ -108,7 +109,11 @@ public async Task InitiateFileSwaps(PowerLineStatus forPowerLineStatus, Preferen`
`108`	`109`
`109`	`110`	`} //...repeat for every SwapPath`
`110`	`111`
`111`		`- Logger.inst.Log($"Finished firing FileSwap logic for AppEntry with target path {AppEntry.AppPath}");`
	`112`	`+ Logger.inst.Log($"Finished firing single FileSwap tasks for AppEntry with target path {AppEntry.AppPath}");`
	`113`	`+`
	`114`	`+ await Task.WhenAll(fileSwapTasks);`
	`115`	`+`
	`116`	`+ Logger.inst.Log($"Completed all FileSwap tasks for AppEntry with target path {AppEntry.AppPath}");`
`112`	`117`
`113`	`118`	`}`
`114`	`119`
`@@ -154,15 +159,15 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int`
`154`	`159`	`WaitForOlderFileSwaps:`
`155`	`160`	`if (OngoingFileSwapTasks.Any(x => x.FileSwapPath == fileSwapPathTask.FileSwapPath && x.ID < fileSwapPathTask.ID))`
`156`	`161`	`{`
`157`		`- Task log = Logger.inst.Log($"An older FileSwap task for {swapPath} already exists, delaying");`
	`162`	`+ Logger.inst.Log($"An older FileSwap task for {swapPath} already exists, delaying");`
`158`	`163`	`await Task.Delay(10000);`
`159`	`164`	`goto WaitForOlderFileSwaps;`
`160`	`165`	`}`
`161`	`166`
`162`	`167`	`WaitForAppToClose:`
`163`		`- if (IsProcessRunning(AppEntry.AppPath))`
	`168`	`+ if (await IsProcessRunning(AppEntry.AppPath)) //IsProcessRunning is apparently VERY expensive`
`164`	`169`	`{`
`165`		`- Task log = Logger.inst.Log($"Target app {AppEntry.AppPath} is still running, delaying File Swap for {swapPath}");`
	`170`	`+ Logger.inst.Log($"Target app {AppEntry.AppPath} is still running, delaying File Swap for {swapPath}");`
`166`	`171`	`await Task.Delay(5000);`
`167`	`172`	`goto WaitForAppToClose;`
`168`	`173`	`}`
`@@ -184,7 +189,7 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int`
`184`	`189`	`StoreFile_OnBattery:`
`185`	`190`	`try`
`186`	`191`	`{`
`187`		`- FileCopyConsiderAccessRules(swapPath, onBatteryStoredFilePath, true, false);`
	`192`	`+ await FileCopyConsiderAccessRules(swapPath, onBatteryStoredFilePath, true, false);`
`188`	`193`	`File.Create(Path.Combine(SettingsBankFolderPath, $"{Path.GetFileName(swapPath)} is in {swapPathHash}"));`
`189`	`194`	`}`
`190`	`195`	`catch (IOException)`
`@@ -203,7 +208,7 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int`
`203`	`208`	`StoreFile_PluggedIn:`
`204`	`209`	`try`
`205`	`210`	`{`
`206`		`- FileCopyConsiderAccessRules(swapPath, pluggedInStoredFilePath, true, false);`
	`211`	`+ await FileCopyConsiderAccessRules(swapPath, pluggedInStoredFilePath, true, false);`
`207`	`212`	`File.Create(Path.Combine(SettingsBankFolderPath, $"{Path.GetFileName(swapPath)} is in {swapPathHash}"));`
`208`	`213`	`}`
`209`	`214`	`catch (IOException)`
`@@ -224,13 +229,13 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int`
`224`	`229`	`try`
`225`	`230`	`{`
`226`	`231`	`//no need to cancel the save if the substitution fails`
`227`		`- FileCopyConsiderAccessRules(swapPath, pluggedInStoredFilePath, true, false); //save current config to PluggedIn store`
	`232`	`+ await FileCopyConsiderAccessRules(swapPath, pluggedInStoredFilePath, true, false); //save current config to PluggedIn store`
`228`	`233`	`string s1 = $"Saved SwapPath {swapPath} for app {AppEntry.AppPath} as PluggedIn";`
`229`	`234`	`Logger.inst.Log(s1);`
`230`	`235`
`231`	`236`	`errorFlag = 1;`
`232`	`237`
`233`		`- FileCopyConsiderAccessRules(onBatteryStoredFilePath, swapPath, true, true); //then substitute with OnBattery config`
	`238`	`+ await FileCopyConsiderAccessRules(onBatteryStoredFilePath, swapPath, true, true); //then substitute with OnBattery config`
`234`	`239`	`string s2 = $"Substituted OnBattery config into SwapPath {swapPath} for app {AppEntry.AppPath}";`
`235`	`240`	`Logger.inst.Log(s2);`
`236`	`241`
`@@ -256,6 +261,9 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int`
`256`	`261`	`preferencesXML.ModifyAppEntryAndSave(AppEntry.AppPath, modified);`
`257`	`262`	`string s3 = $"Saved SwapPath state for SwapPath {swapPath} for app {AppEntry.AppPath}";`
`258`	`263`	`Logger.inst.Log(s3);`
	`264`	`+ } else`
	`265`	`+ {`
	`266`	`+ Logger.inst.Log($"Skipped operations for File Swap path {swapPath} because it's already in its correct state.");`
`259`	`267`	`}`
`260`	`268`	`}`
`261`	`269`	`else if (forPowerLineStatus == PowerLineStatus.Online)`
`@@ -268,13 +276,13 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int`
`268`	`276`	`{`
`269`	`277`
`270`	`278`	`//no need to cancel the save if the substitution fails`
`271`		`- FileCopyConsiderAccessRules(swapPath, onBatteryStoredFilePath, true, false); //save current config to OnBattery store`
	`279`	`+ await FileCopyConsiderAccessRules(swapPath, onBatteryStoredFilePath, true, false); //save current config to OnBattery store`
`272`	`280`	`string s1 = $"Saved SwapPath {swapPath} for app {AppEntry.AppPath} as OnBattery";`
`273`	`281`	`Logger.inst.Log(s1);`
`274`	`282`
`275`	`283`	`errorFlag = 1;`
`276`	`284`
`277`		`- FileCopyConsiderAccessRules(pluggedInStoredFilePath, swapPath, true, true); //then substitute with PluggedIn config`
	`285`	`+ await FileCopyConsiderAccessRules(pluggedInStoredFilePath, swapPath, true, true); //then substitute with PluggedIn config`
`278`	`286`	`string s2 = $"Substituted PluggedIn config into SwapPath {swapPath} for app {AppEntry.AppPath}";`
`279`	`287`	`Logger.inst.Log(s2);`
`280`	`288`	`}`
`@@ -298,20 +306,23 @@ private async Task InitiateSingleFileSwap(FileSwapPathTask fileSwapPathTask, int`
`298`	`306`	`preferencesXML.ModifyAppEntryAndSave(AppEntry.AppPath, modified);`
`299`	`307`	`string s3 = $"Saved SwapPath state for SwapPath {swapPath} for app {AppEntry.AppPath}";`
`300`	`308`	`Logger.inst.Log(s3);`
	`309`	`+ } else`
	`310`	`+ {`
	`311`	`+ Logger.inst.Log($"Skipped operations for File Swap path {swapPath} because it's already in its correct state.");`
`301`	`312`	`}`
`302`	`313`	`}`
`303`	`314`	`else`
`304`	`315`	`{`
`305`	`316`	`Debug.WriteLine($"Unknown power state: " + forPowerLineStatus.ToString());`
`306`	`317`	`}`
`307`	`318`
`308`		`- await Logger.inst.Log($"FileSwaps Task finished for {AppEntry.AppPath}");`
	`319`	`+ Logger.inst.Log($"FileSwap Task {fileSwapPathTask.FileSwapPath} finished for {AppEntry.AppPath}");`
`309`	`320`
`310`	`321`	`OngoingFileSwapTasks.Remove(fileSwapPathTask);`
`311`	`322`
`312`	`323`	`}`
`313`	`324`
`314`		`- static bool IsProcessRunning(string processPath)`
	`325`	`+ static async Task<bool> IsProcessRunning(string processPath) //this function is apparently VERY expensive to run (many mores times than this app itself) so await it!`
`315`	`326`	`{`
`316`	`327`	`Process[] processes = Process.GetProcesses();`
`317`	`328`
`@@ -320,7 +331,7 @@ static bool IsProcessRunning(string processPath)`
`320`	`331`	`try`
`321`	`332`	`{`
`322`	`333`	`// Compare the process's main module file name with the specified process path`
`323`		`- if (string.Equals(process.MainModule.FileName, processPath, StringComparison.OrdinalIgnoreCase))`
	`334`	`+ if (await Task.Run(() => string.Equals(process.MainModule.FileName, processPath, StringComparison.OrdinalIgnoreCase))) //the expensive line in question`
`324`	`335`	`{`
`325`	`336`	`return true;`
`326`	`337`	`}`
`@@ -379,7 +390,7 @@ static byte[] GetHash(string str)`
`379`	`390`	`/// </summary>`
`380`	`391`	`///`
`381`	`392`	`/// And yes, I think it's clearer to throw exceptions instead of returning false, unless there is a better way (in which I have tried TWICE; this is perfectly functional)`
`382`		`- public static void FileCopyConsiderAccessRules(string sourceFileName, string destinationFileName, bool overwrite, bool ensureDestinationExists = true)`
	`393`	`+ public static Task FileCopyConsiderAccessRules(string sourceFileName, string destinationFileName, bool overwrite, bool ensureDestinationExists = true)`
`383`	`394`	`{`
`384`	`395`
`385`	`396`	`FileInfo sourceInfo = new FileInfo(sourceFileName);`
`@@ -437,6 +448,8 @@ public static void FileCopyConsiderAccessRules(string sourceFileName, string des`
`437`	`448`	`sourceFileSecurity.SetAccessRuleProtection(true, true); //supposedly this doesn't change the existing file's security settings?`
`438`	`449`	`File.Copy(sourceFileName, destinationFileName, true);`
`439`	`450`	`destinationInfo.SetAccessControl(sourceFileSecurity); //requires the file to exist, duh`
	`451`	`+`
	`452`	`+ return Task.CompletedTask;`
`440`	`453`	`}`
`441`	`454`
`442`	`455`	`/*`
Original file line number	Diff line number	Diff line change
`@@ -251,29 +251,30 @@ private static void UpdateSeenInRegistryStatuses()`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`
`254`		`- private static Task BeginFileSwapLogic(PowerLineStatus forPowerLineStatus, IEnumerable<AppEntry> forAppEntries)`
	`254`	`+ private static async Task BeginFileSwapLogic(PowerLineStatus forPowerLineStatus, IEnumerable<AppEntry> forAppEntries)`
`255`	`255`	`{`
`256`	`256`	`Logger.inst.Log("Commence file swap logic.");`
`257`		`- //shorten these long names`
`258`	`257`
`259`	`258`	`//create the SettingsBank directory if it doesn't exist`
`260`	`259`	`bool fileSwapperFolderExists = Directory.Exists(FileSwapper.SwapPathFolder);`
`261`	`260`	`if (!fileSwapperFolderExists) { Directory.CreateDirectory(FileSwapper.SwapPathFolder); }`
`262`	`261`
	`262`	`+ List<Task> fileSwapTasks = new();`
`263`	`263`	`foreach (AppEntry appEntry in forAppEntries)`
`264`	`264`	`{`
`265`	`265`	`var fileSwap = new FileSwapper(appEntry, preferencesXML);`
`266`	`266`
`267`	`267`	`if (!appEntry.EnableFileSwapper) continue;`
`268`	`268`	`if (appEntry.FileSwapperPaths.Length == 0) continue;`
`269`	`269`
`270`		`- fileSwap.InitiateFileSwaps(forPowerLineStatus, preferencesXML);`
	`270`	`+ Task fileSwapTask = fileSwap.InitiateFileSwaps(forPowerLineStatus, preferencesXML);`
	`271`	`+ fileSwapTasks.Add(fileSwapTask);`
`271`	`272`
`272`		`- } //...repeat for every AppEntry`
	`273`	`+ }`
`273`	`274`
`274`		`- Logger.inst.Log("File swap logic finished.");`
	`275`	`+ await Task.WhenAll(fileSwapTasks);`
`275`	`276`
`276`		`- return Task.CompletedTask;`
	`277`	`+ Logger.inst.Log("File swap logic finished.");`
`277`	`278`	`}`
`278`	`279`
`279`	`280`	`static string[] ignoreList = RegistryHelper.ignoreValues;`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public Task StartAsync(CancellationToken cancellationToken)`
`30`	`30`	`private void OnSessionEnd(object sender, SessionEndingEventArgs e)`
`31`	`31`	`{`
`32`	`32`	`e.Cancel = true;`
`33`		`- Logger.inst.Log($"OnSessionEnd received (reason: {e.Reason})").Wait();`
	`33`	`+ Logger.inst.Log($"OnSessionEnd received (reason: {e.Reason})");`
`34`	`34`	`if (e.Reason == SessionEndReasons.SystemShutdown)`
`35`	`35`	`{`
`36`	`36`	`CleanUpService();`
`@@ -41,7 +41,7 @@ private void OnSessionEnd(object sender, SessionEndingEventArgs e)`
`41`	`41`	`public Task StopAsync(CancellationToken cancellationToken)`
`42`	`42`	`{`
`43`	`43`
`44`		`- Logger.inst.Log("Service StopAsync called").Wait();`
	`44`	`+ Logger.inst.Log("Service StopAsync called");`
`45`	`45`
`46`	`46`	`CleanUpService();`
`47`	`47`
`@@ -55,7 +55,7 @@ public void Dispose()`
`55`	`55`
`56`	`56`	`private void CleanUpService()`
`57`	`57`	`{`
`58`		`- Logger.inst.Log("Service ending cleanup called.").Wait();`
	`58`	`+ Logger.inst.Log("Service ending cleanup called.");`
`59`	`59`
`60`	`60`	`Logger.inst.DumpStandardLogBufferToStandardLog().Wait();`
`61`	`61`