Implemented logging errors to file.

Author: levitation

AsyncToSyncConverter.cs

@@ -1,5 +1,5 @@
 //
-// Copyright (c) Roland Pihlakas 2019 - 2020
+// Copyright (c) Roland Pihlakas 2019 - 2022
 // [email protected]
 //
 // Roland Pihlakas licenses this file to you under the GNU Lesser General Public License, ver 2.1.
@@ -125,7 +125,17 @@ public static async Task AsyncFileUpdated(Context context)
         {
             //using (await Global.FileOperationAsyncLock.LockAsync())
             {
-                var fileData = await FileExtensions.ReadAllTextAsync(Extensions.GetLongPath(context.Event.FullName), context.Token);
+                string fileData;
+                try
+                { 
+                    fileData = await FileExtensions.ReadAllTextAsync(Extensions.GetLongPath(context.Event.FullName), context.Token);
+                }
+                catch (FileNotFoundException)   //file was removed by the time queue processing got to it
+                {
+                    return;     
+                }
+
+
                 var originalData = fileData;
 
 

BinaryFileExtensions.cs

@@ -1,5 +1,5 @@
 //
-// Copyright (c) Roland Pihlakas 2019 - 2020
+// Copyright (c) Roland Pihlakas 2019 - 2022
 // [email protected]
 //
 // Roland Pihlakas licenses this file to you under the GNU Lesser General Public License, ver 2.1.
@@ -27,6 +27,11 @@ public static bool BinaryEqual(Binary a, Binary b)
 
         public static async Task<Tuple<byte[], long>> ReadAllBytesAsync(string path, CancellationToken cancellationToken = default(CancellationToken), long maxFileSize = 0)
         {
+            if (path == null)
+                throw new ArgumentNullException(nameof(path));
+            if (path.Length == 0)
+                throw new ArgumentException("Argument_EmptyPath: {0}", nameof(path));
+
             while (true)
             {
                 if (cancellationToken.IsCancellationRequested)
@@ -76,16 +81,25 @@ public static bool BinaryEqual(Binary a, Binary b)
             }
         }
 
-        public static async Task WriteAllBytesAsync(string path, byte[] contents, CancellationToken cancellationToken = default(CancellationToken), int writeBufferKB = 0, int bufferWriteDelayMs = 0)
+        public static async Task WriteAllBytesAsync(string path, byte[] contents, bool createTempFileFirst, CancellationToken cancellationToken = default(CancellationToken), int writeBufferKB = 0, int bufferWriteDelayMs = 0)
         {
+            if (path == null)
+                throw new ArgumentNullException(nameof(path));
+            if (path.Length == 0)
+                throw new ArgumentException("Argument_EmptyPath: {0}", nameof(path));
+
+            var tempPath = path;
+            if (createTempFileFirst)
+                tempPath += ".tmp";
+
             while (true)
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
                 try
                 {
                     using (var stream = new FileStream(
-                        path,
+                        tempPath,
                         FileMode.OpenOrCreate,
                         FileAccess.Write,
                         FileShare.Read,
@@ -110,9 +124,22 @@ public static bool BinaryEqual(Binary a, Binary b)
 
                             await stream.WriteAsync(contents, i, writeBufferLength, cancellationToken);
                         }
+                    }
 
-                        return;
+                    if (createTempFileFirst)
+                    {
+                        if (await Extensions.FSOperation(() => File.Exists(path), cancellationToken))
+                        {
+#pragma warning disable SEC0116 //Warning	SEC0116	Unvalidated file paths are passed to a file delete API, which can allow unauthorized file system operations (e.g. read, write, delete) to be performed on unintended server files.
+                            await Extensions.FSOperation(() => File.Delete(path), cancellationToken);
+#pragma warning restore SEC0116
+                        }
+
+                        await Extensions.FSOperation(() => File.Move(tempPath, path), cancellationToken);
                     }
+
+
+                    return;     //exit while loop
                 }
                 catch (IOException)
                 {

Extensions.cs

@@ -1,5 +1,5 @@
 //
-// Copyright (c) Roland Pihlakas 2019 - 2020
+// Copyright (c) Roland Pihlakas 2019 - 2022
 // [email protected]
 //
 // Roland Pihlakas licenses this file to you under the GNU Lesser General Public License, ver 2.1.
@@ -75,6 +75,10 @@ public static Dictionary<TValue, TKey> Inverse<TKey, TValue>(this IDictionary<TK
 
         public static string GetLongPath(string path)
         {
+            if (!ConfigParser.IsWindows)
+                return Path.GetFullPath(path);    //GetFullPath: convert relative path to full path
+
+
             //@"\\?\" prefix is needed for reading from long paths: https://stackoverflow.com/questions/44888844/directorynotfoundexception-when-using-long-paths-in-net-4-7 and https://superuser.com/questions/1617012/support-of-the-unc-server-share-syntax-in-windows
 
             if (path.Substring(0, 2) == @"\\")   //network path or path already starting with \\?\
@@ -83,10 +87,20 @@ public static string GetLongPath(string path)
             }
             else
             {
-                return @"\\?\" + path;
+                return @"\\?\" + Path.GetFullPath(path);    //GetFullPath: convert relative path to full path
             }
         }
 
+        public static string GetDirPathWithTrailingSlash(string dirPath)
+        {
+            if (string.IsNullOrWhiteSpace(dirPath))
+                return dirPath;
+
+            dirPath = Path.Combine(dirPath, ".");    //NB! add "." in order to ensure that slash is appended to the end of the path
+            dirPath = dirPath.Substring(0, dirPath.Length - 1);     //drop the "." again
+            return dirPath;
+        }
+
         public static async Task FSOperation(Action func, CancellationToken token)
         {
             //await Task.Run(func).WaitAsync(token);

FileExtensions.cs

@@ -51,7 +51,7 @@ private static StreamReader AsyncStreamReader(string path, Encoding encoding)
             if (encoding == null)
                 throw new ArgumentNullException(nameof(encoding));
             if (path.Length == 0)
-                throw new ArgumentException("SR.Argument_EmptyPath: {0}", nameof(path));
+                throw new ArgumentException("Argument_EmptyPath: {0}", nameof(path));
 
             while (true)    //roland
             {
@@ -133,17 +133,21 @@ private static StreamWriter AsyncStreamWriter(string path, Encoding encoding, bo
             return new StreamWriter(stream, encoding);
         }
 
-        public static Task WriteAllTextAsync(string path, string contents, CancellationToken cancellationToken = default(CancellationToken))
-            => WriteAllTextAsync(path, contents, UTF8NoBOM, cancellationToken);
+        public static Task WriteAllTextAsync(string path, string contents, bool createTempFileFirst, CancellationToken cancellationToken = default(CancellationToken))
+            => WriteAllTextAsync(path, contents, UTF8NoBOM, createTempFileFirst, cancellationToken);
 
-        public static async Task WriteAllTextAsync(string path, string contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
+        public static async Task WriteAllTextAsync(string path, string contents, Encoding encoding, bool createTempFileFirst, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (path == null)
                 throw new ArgumentNullException(nameof(path));
             if (encoding == null)
                 throw new ArgumentNullException(nameof(encoding));
             if (path.Length == 0)
-                throw new ArgumentException("SR.Argument_EmptyPath: {0}", nameof(path));
+                throw new ArgumentException("Argument_EmptyPath: {0}", nameof(path));
+
+            var tempPath = path;
+            if (createTempFileFirst)
+                tempPath += ".tmp";
 
             while (true)    //roland
             {
@@ -157,12 +161,28 @@ private static StreamWriter AsyncStreamWriter(string path, Encoding encoding, bo
 
                     if (string.IsNullOrEmpty(contents))
                     {
-                        new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read).Dispose();
-                        return; // await Task.CompletedTask;
+                        new FileStream(tempPath, FileMode.Create, FileAccess.Write, FileShare.Read).Dispose();
+                    }
+                    else
+                    { 
+                        await InternalWriteAllTextAsync(AsyncStreamWriter(tempPath, encoding, append: false), contents, cancellationToken);
                     }
 
-                    await InternalWriteAllTextAsync(AsyncStreamWriter(path, encoding, append: false), contents, cancellationToken);
-                    return;
+
+                    if (createTempFileFirst)
+                    {
+                        if (await Extensions.FSOperation(() => File.Exists(path), cancellationToken))
+                        {
+#pragma warning disable SEC0116 //Warning	SEC0116	Unvalidated file paths are passed to a file delete API, which can allow unauthorized file system operations (e.g. read, write, delete) to be performed on unintended server files.
+                            await Extensions.FSOperation(() => File.Delete(path), cancellationToken);
+#pragma warning restore SEC0116
+                        }
+
+                        await Extensions.FSOperation(() => File.Move(tempPath, path), cancellationToken);
+                    }
+
+
+                    return;     //exit while loop
                 }
                 catch (IOException)    //roland
                 {
@@ -214,5 +234,52 @@ private static async Task InternalWriteAllTextAsync(StreamWriter sw, string cont
 #endif
             }
         }
+
+        public static Task AppendAllTextAsync(string path, string contents, CancellationToken cancellationToken = default(CancellationToken))
+            => AppendAllTextAsync(path, contents, UTF8NoBOM, cancellationToken);
+
+        public static async Task AppendAllTextAsync(string path, string contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (path == null)
+                throw new ArgumentNullException(nameof(path));
+            if (encoding == null)
+                throw new ArgumentNullException(nameof(encoding));
+            if (path.Length == 0)
+                throw new ArgumentException("Argument_EmptyPath", nameof(path));
+
+
+
+            while (true)    //roland
+            {
+                try    //roland
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    //if (cancellationToken.IsCancellationRequested)
+                    //{
+                    //    return Task.FromCanceled(cancellationToken);
+                    //}
+
+                    if (string.IsNullOrEmpty(contents))
+                    {
+                        // Just to throw exception if there is a problem opening the file.
+                        new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.Read).Dispose();
+                        return; // Task.CompletedTask;
+                    }
+
+                    await InternalWriteAllTextAsync(AsyncStreamWriter(path, encoding, append: true), contents, cancellationToken);
+
+                    return;
+                }
+                catch (IOException)    //roland
+                {
+                    //retry after delay
+#if !NOASYNC
+                    await Task.Delay(1000, cancellationToken);     //TODO: config file?
+#else
+                    cancellationToken.WaitHandle.WaitOne(1000);
+#endif
+                }
+            }
+        }
     }
 }