Temp file handling (#397)

* Added temp files sources

* Methods for easier reading and writing of the contents of the temp files.

* Moved bits to `FileStreamUtility`

* Moved path utility to validation job common. Added tests.

* TempFile with subdirectories

* Documentation fixups

Author: agr

src/Validation.Common.Job/FileStreamUtility.cs

@@ -19,5 +19,14 @@ public static FileStream GetTemporaryFile()
                 BufferSize,
                 FileOptions.DeleteOnClose | FileOptions.Asynchronous);
         }
+
+        public static FileStream OpenTemporaryFile(string fileName)
+            => new FileStream(
+                fileName,
+                FileMode.Open,
+                FileAccess.Read,
+                FileShare.None,
+                BufferSize,
+                FileOptions.DeleteOnClose | FileOptions.Asynchronous);
     }
 }

src/Validation.Common.Job/PathUtility.cs

@@ -0,0 +1,26 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.IO;
+
+namespace NuGet.Jobs.Validation
+{
+    public static class PathUtility
+    {
+        /// <summary>
+        /// Checks if given file path is an absolute path
+        /// </summary>
+        public static bool IsFilePathAbsolute(string path)
+        { 
+            if (path == null)
+            {
+                throw new ArgumentNullException(nameof(path));
+            }
+
+            return Path.IsPathRooted(path)
+                    && Path.GetPathRoot(path).Length == 3
+                    && Path.GetPathRoot(path).Substring(1) == ":" + Path.DirectorySeparatorChar;
+        }
+    }
+}

src/Validation.Common.Job/TempFiles/DeleteOnCloseReadOnlyTempFile.cs

@@ -0,0 +1,40 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NuGet.Jobs.Validation
+{
+    /// <summary>
+    /// Opens existing file for exclusive read and deletes it on close.
+    /// </summary>
+    public class DeleteOnCloseReadOnlyTempFile : ITempReadOnlyFile
+    {
+        private const int BufferSize = 8192;
+        private readonly FileStream _fileStream;
+
+        public DeleteOnCloseReadOnlyTempFile(string fileName)
+        {
+            _fileStream = FileStreamUtility.OpenTemporaryFile(fileName);
+        }
+
+        public async Task<string> ReadToEndAsync()
+        {
+            using (var streamReader = new StreamReader(ReadStream, Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: BufferSize, leaveOpen: true))
+            {
+                return await streamReader.ReadToEndAsync();
+            }
+        }
+
+        public Stream ReadStream => _fileStream;
+
+        public string FullName => _fileStream.Name;
+
+        public void Dispose()
+        {
+            _fileStream.Dispose();
+        }
+    }
+}

src/Validation.Common.Job/TempFiles/ITempFile.cs

@@ -0,0 +1,18 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace NuGet.Jobs.Validation
+{
+    /// <summary>
+    /// A wrapper for a temp file that tries to delete it on dispose
+    /// </summary>
+    public interface ITempFile : IDisposable
+    {
+        /// <summary>
+        /// Full path to a temporary file
+        /// </summary>
+        string FullName { get; }
+    }
+}

src/Validation.Common.Job/TempFiles/ITempFileFactory.cs

@@ -0,0 +1,29 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace NuGet.Jobs.Validation
+{
+    /// <summary>
+    /// Provides temp files for use 
+    /// </summary>
+    public interface ITempFileFactory
+    {
+        /// <summary>
+        /// Creates empty temp file under specified subdirectory of the temp directry,
+        /// returns object that contains path to it and controls its lifetime.
+        /// </summary>
+        ITempFile CreateTempFile(string directoryName);
+
+        /// <summary>
+        /// Creates temp file with specified text in the specified subdirectory of the temp directory,
+        /// returns object that contains path to it and controls its lifetime.
+        /// </summary>
+        /// <param name="contents">The contents of the file to be created.</param>
+        ITempFile CreateTempFile(string directoryName, string contents);
+
+        /// <summary>
+        /// Opens existing file for reading and makes sure it is deleted on closing.
+        /// </summary>
+        ITempReadOnlyFile OpenFileForReadAndDelete(string fileName);
+    }
+}

src/Validation.Common.Job/TempFiles/ITempReadOnlyFile.cs

@@ -0,0 +1,21 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.IO;
+using System.Threading.Tasks;
+
+namespace NuGet.Jobs.Validation
+{
+    /// <summary>
+    /// A temp file interface that provides stream for reading its content.
+    /// </summary>
+    public interface ITempReadOnlyFile : ITempFile
+    {
+        Stream ReadStream { get; }
+
+        /// <summary>
+        /// Reads the remaining content of the <see cref="ReadStream"/> as string and returns it.
+        /// </summary>
+        Task<string> ReadToEndAsync();
+    }
+}

src/Validation.Common.Job/TempFiles/TempFile.cs

@@ -0,0 +1,72 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.IO;
+
+namespace NuGet.Jobs.Validation
+{
+    public class TempFile : ITempFile
+    {
+        public TempFile()
+        {
+            FullName = Path.GetTempFileName();
+        }
+
+        private TempFile(string fullName)
+        {
+            FullName = fullName;
+        }
+
+        /// <summary>
+        /// Creates temp file under specified subdirectory in the temp directory.
+        /// Creates missing directories as needed.
+        /// </summary>
+        /// <param name="directoryName">Subdirectory name under temp directory to create file in.</param>
+        public static TempFile Create(string directoryName)
+        {
+            if (directoryName == null)
+            {
+                throw new ArgumentNullException(nameof(directoryName));
+            }
+
+            if (PathUtility.IsFilePathAbsolute(directoryName))
+            {
+                throw new ArgumentException($"Directory name must be a relative path, passed value: {directoryName}", nameof(directoryName));
+            }
+
+            var directory = new DirectoryInfo(Path.Combine(Path.GetTempPath(), directoryName));
+            if (!directory.Exists)
+            {
+                directory.Create();
+            }
+
+            string fileName;
+            do
+            {
+                fileName = Path.Combine(directory.FullName, $"{Guid.NewGuid()}.tmp");
+            } while (File.Exists(fileName));
+            File.Create(fileName).Dispose();
+
+            return new TempFile(fileName);
+        }
+
+        public string FullName { get; }
+
+        public void Dispose()
+        {
+            try
+            {
+                // we'll try to delete file if it exists...
+                if (File.Exists(FullName))
+                {
+                    File.Delete(FullName);
+                }
+            }
+            catch
+            {
+                // ... but won't throw if anything goes wrong
+            }
+        }
+    }
+}

src/Validation.Common.Job/TempFiles/TempFileFactory.cs

@@ -0,0 +1,26 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.IO;
+using System.Text;
+
+namespace NuGet.Jobs.Validation
+{
+    public class TempFileFactory : ITempFileFactory
+    {
+        public ITempFile CreateTempFile(string directoryName)
+            => TempFile.Create(directoryName);
+
+        public ITempFile CreateTempFile(string directoryName, string contents)
+        {
+            var file = CreateTempFile(directoryName);
+
+            File.WriteAllText(file.FullName, contents, Encoding.UTF8);
+
+            return file;
+        }
+
+        public ITempReadOnlyFile OpenFileForReadAndDelete(string fileName)
+            => new DeleteOnCloseReadOnlyTempFile(fileName);
+    }
+}

src/Validation.Common.Job/Validation.Common.Job.csproj

@@ -45,6 +45,7 @@
     <Compile Include="LoggerDiagnosticsService.cs" />
     <Compile Include="LoggerDiagnosticsSource.cs" />
     <Compile Include="PackageDownloader.cs" />
+    <Compile Include="PathUtility.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\AssemblyInfo.*.cs" />
     <Compile Include="Storage\AddStatusResult.cs" />
@@ -63,6 +64,12 @@
     <Compile Include="Validation\ValidatorName.cs" />
     <Compile Include="Validation\ValidatorNameAttribute.cs" />
     <Compile Include="Validation\ValidatorUtility.cs" />
+    <Compile Include="TempFiles\DeleteOnCloseReadOnlyTempFile.cs" />
+    <Compile Include="TempFiles\ITempFile.cs" />
+    <Compile Include="TempFiles\ITempFileFactory.cs" />
+    <Compile Include="TempFiles\ITempReadOnlyFile.cs" />
+    <Compile Include="TempFiles\TempFile.cs" />
+    <Compile Include="TempFiles\TempFileFactory.cs" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Autofac">

tests/Validation.Common.Job.Tests/PathUtilityFacts.cs

@@ -0,0 +1,34 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using NuGet.Jobs.Validation;
+using Xunit;
+
+namespace Validation.Common.Job.Tests
+{
+    public class PathUtilityFacts
+    {
+        [Fact]
+        public void IsFilePathAbsoluteThrowsWhenPathIsNull()
+        {
+            Assert.Throws<ArgumentNullException>(() => PathUtility.IsFilePathAbsolute(null));
+        }
+
+        [Theory]
+        [InlineData(@"", false)]
+        [InlineData(@"c:", false)]
+        [InlineData(@"aaa.txt", false)]
+        [InlineData(@"bbb\aaa.txt", false)]
+        [InlineData(@"c:aaa.txt", false)]
+        [InlineData(@"c:bbb\aaa.txt", false)]
+        [InlineData(@"c:\", true)]
+        [InlineData(@"c:\aaa.txt", true)]
+        [InlineData(@"c:\bbb\aaa.txt", true)]
+        public void IsFilePathAbsoluteSmokeTest(string path, bool expectedResult)
+        {
+            var result = PathUtility.IsFilePathAbsolute(path);
+            Assert.Equal(expectedResult, result);
+        }
+    }
+}