Releases/1.0.0 (#4)

* Release 1.0.0
* Add linting
* Refactor tests and improve logging messages

.editorconfig

@@ -8,3 +8,5 @@ csharp_hide_private_members = true:suggestion
 dotnet_diagnostic.CS0127.severity = none
 dotnet_diagnostic.CA1416.severity = none
 dotnet_diagnostic.IDE0005.severity = error
+dotnet_diagnostic.IDE0044.severity = error
+dotnet_sort_system_directives_first = true

.github/workflows/ci.yaml

@@ -36,5 +36,8 @@ jobs:
       - name: Build
         run: dotnet build
 
+      - name: Lint
+        run: dotnet format --verify-no-changes
+
       - name: Test
         run: dotnet test --no-build --verbosity normal

Directory.Build.props

@@ -0,0 +1,17 @@
+<Project>
+    <PropertyGroup>
+        <Description>By hook or by crook, perform operations on files and directories. If they are
+            in use by a process, kill the process.</Description>
+        <Version>1.0.0</Version>
+        <PackageProjectUrl>https://github.com/domsleee/forceops</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/domsleee/forceops</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+        <Authors>Dom Slee</Authors>
+        <PackageTags>lock file directory force delete</PackageTags>
+        <PackageReleaseNotes>https://github.com/domsleee/forceops/blob/main/CHANGELOG.md</PackageReleaseNotes>
+
+        <PackageReadmeFile>README.md</PackageReadmeFile>
+        <PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
+        <PackageOutputPath>./nupkg</PackageOutputPath>
+    </PropertyGroup>
+</Project>

ForceOps.Lib/ForceOps.Lib.csproj

@@ -4,8 +4,12 @@
 		<TargetFramework>net7.0</TargetFramework>
 		<ImplicitUsings>enable</ImplicitUsings>
 		<Nullable>enable</Nullable>
-		<RootNamespace>ForceOps</RootNamespace>
 	</PropertyGroup>
+	<ItemGroup>
+        <!-- Include README here so it shows up in the nuget.org page -->
+        <None Include="..\README.md" Link="README.md" Pack="true" PackagePath="\" />
+        <None Include="..\LICENSE.txt" Pack="true" PackagePath=""/>
+    </ItemGroup>
 	<ItemGroup>
 		<PackageReference Include="LockCheck" Version="0.9.25-g8ea8d862e5" />
 		<PackageReference Include="Serilog" Version="3.0.1" />

ForceOps.Lib/src/DirectoryUtils.cs

@@ -1,4 +1,4 @@
-namespace ForceOps;
+namespace ForceOps.Lib;
 
 public static class DirectoryUtils
 {

ForceOps.Lib/src/FileAndDirectoryDeleter.cs

@@ -0,0 +1,129 @@
+using System.Runtime.Versioning;
+using Serilog;
+using static ForceOps.Lib.DirectoryUtils;
+using static LockCheck.LockManager;
+
+namespace ForceOps.Lib;
+
+[SupportedOSPlatform("windows")]
+public class FileAndDirectoryDeleter
+{
+	readonly ILogger logger;
+	readonly ForceOpsContext forceOpsContext;
+
+	public FileAndDirectoryDeleter(ForceOpsContext forceOpsContext, ILogger? logger = null)
+	{
+		this.forceOpsContext = forceOpsContext;
+		this.logger = logger ?? forceOpsContext.loggerFactory.CreateLogger<FileAndDirectoryDeleter>();
+	}
+
+	/// <summary>
+	/// Delete a file or a folder, not following symlinks.
+	/// If the delete fails, it will attempt to find processes using the file or directory
+	/// </summary>
+	/// <param name="fileOrDirectory">File or directory to delete.</param>
+	public void DeleteFileOrDirectory(string fileOrDirectory)
+	{
+		fileOrDirectory = CombineWithCWDAndGetAbsolutePath(fileOrDirectory);
+		if (File.Exists(fileOrDirectory))
+		{
+			DeleteFile(new FileInfo(fileOrDirectory));
+			return;
+		}
+		if (Directory.Exists(fileOrDirectory))
+		{
+			DeleteDirectory(new DirectoryInfo(fileOrDirectory));
+			return;
+		}
+		// if the file/folder doesn't exist, it has already been deleted
+		logger.Debug($"{fileOrDirectory} already deleted.");
+		return;
+	}
+
+	internal void DeleteFile(FileInfo file)
+	{
+		for (var attempt = 1; attempt <= forceOpsContext.maxAttempts; attempt++)
+		{
+			try
+			{
+				file.IsReadOnly = false;
+				file.Delete();
+				break;
+			}
+			catch when (!file.Exists) { }
+			catch (Exception ex) when (ex is IOException || ex is System.UnauthorizedAccessException)
+			{
+				var getProcessesLockingFileFunc = () => GetLockingProcessInfos(new[] { file.FullName });
+				var shouldThrow = KillProcessesAndLogInfo("DeleteFile", attempt, file.FullName, getProcessesLockingFileFunc);
+				if (shouldThrow) throw;
+			}
+		}
+	}
+
+	bool KillProcessesAndLogInfo(string actionName, int attemptNumber, string fileOrDirectoryPath, Func<IEnumerable<LockCheck.ProcessInfo>> getProcessesLockingFileFunc)
+	{
+		var isProcessElevated = forceOpsContext.elevateUtils.IsProcessElevated();
+		var processElevatedMessage = isProcessElevated
+			? "ForceOps process is elevated"
+			: "ForceOps process is not elevated";
+		var messagePrefix = $"{actionName} failed attempt {attemptNumber}/{forceOpsContext.maxAttempts} for [{fileOrDirectoryPath}]. {processElevatedMessage}.";
+
+		if (attemptNumber == forceOpsContext.maxAttempts)
+		{
+			logger.Information($"{messagePrefix} No attempts remain, so the exception will be thrown.");
+			return true;
+		}
+
+		var processes = getProcessesLockingFileFunc().ToList();
+		var processPlural = processes.Count == 1 ? "process" : "processes";
+		var processLogString = string.Join(", ", processes.Select(process => ProcessInfoToString(process)));
+		logger.Information($"{messagePrefix} Found {processes.Count} {processPlural} to try to kill: [{processLogString}]");
+		forceOpsContext.processKiller.KillProcesses(processes);
+		return false;
+	}
+
+	static string ProcessInfoToString(LockCheck.ProcessInfo? process)
+	{
+		if (process == null)
+		{
+			return "<null>";
+		}
+		return $"{process?.ProcessId} - {process?.ExecutableName}";
+	}
+
+	internal void DeleteDirectory(DirectoryInfo directory)
+	{
+		if (!IsSymLink(directory))
+		{
+			DeleteFilesInFolder(directory);
+		}
+
+		for (var attempt = 1; attempt <= forceOpsContext.maxAttempts; attempt++)
+		{
+			try
+			{
+				directory.Delete();
+				break;
+			}
+			catch when (!directory.Exists) { }
+			catch (Exception ex) when (ex is IOException)
+			{
+				var getProcessesLockingFileFunc = () => GetLockingProcessInfos(new[] { directory.FullName }, LockCheck.LockManagerFeatures.UseLowLevelApi);
+				var shouldThrow = KillProcessesAndLogInfo("DeleteDirectory", attempt, directory.FullName, getProcessesLockingFileFunc);
+				if (shouldThrow) throw;
+			}
+		}
+	}
+
+	void DeleteFilesInFolder(DirectoryInfo directory)
+	{
+		foreach (var file in directory.GetFiles())
+		{
+			DeleteFile(file);
+		}
+		foreach (var subDirectory in directory.GetDirectories())
+		{
+			DeleteDirectory(subDirectory);
+		}
+	}
+}

ForceOps.Lib/src/ElevateUtils.cs → ForceOps.Lib/src/ForceOpsContext/ElevateUtils.cs

@@ -1,6 +1,6 @@
 using System.Security.Principal;
 
-namespace ForceOpsLib;
+namespace ForceOps.Lib;
 
 public class ElevateUtils : IElevateUtils
 {
@@ -10,9 +10,4 @@ public bool IsProcessElevated()
 		var principal = new WindowsPrincipal(identity);
 		return principal.IsInRole(WindowsBuiltInRole.Administrator);
 	}
-}
-
-public interface IElevateUtils
-{
-	public bool IsProcessElevated();
 }

ForceOps.Lib/src/ForceOpsContext/ForceOpsContext.cs

@@ -0,0 +1,23 @@
+namespace ForceOps.Lib;
+
+public class ForceOpsContext
+{
+	public int maxAttempts = 5;
+	public IProcessKiller processKiller;
+	public IElevateUtils elevateUtils;
+	public IRelaunchAsElevated relaunchAsElevated;
+	public ILoggerFactory loggerFactory;
+
+	public ForceOpsContext(
+		IProcessKiller? processKiller = null,
+		IElevateUtils? elevateUtils = null,
+		IRelaunchAsElevated? relaunchAsElevated = null,
+		ILoggerFactory? loggerFactory = null
+	)
+	{
+		this.processKiller = processKiller ?? new ProcessKiller();
+		this.elevateUtils = elevateUtils ?? new ElevateUtils();
+		this.relaunchAsElevated = relaunchAsElevated ?? new RelaunchAsElevated();
+		this.loggerFactory = loggerFactory ?? new LoggerFactory();
+	}
+}

ForceOps.Lib/src/ForceOpsContext/IElevateUtils.cs

@@ -0,0 +1,7 @@
+namespace ForceOps.Lib;
+
+
+public interface IElevateUtils
+{
+	public bool IsProcessElevated();
+}

ForceOps.Lib/src/ForceOpsContext/ILoggerFactory.cs

@@ -0,0 +1,8 @@
+using Serilog;
+
+namespace ForceOps.Lib;
+
+public interface ILoggerFactory
+{
+	public ILogger CreateLogger<T>();
+}

ForceOps.Lib/src/ForceOpsContext/IProcessKiller.cs

@@ -0,0 +1,6 @@
+namespace ForceOps;
+
+public interface IProcessKiller
+{
+	void KillProcesses(IEnumerable<LockCheck.ProcessInfo?> processes);
+}