v1.3.4067.0

Author: ITHitBuild

VirtualFileSystem/Framework/CustomData.cs

@@ -108,7 +108,7 @@ public static bool IsMoved(this PlaceholderItem placeholder)
             }
 
             // Otherwise verify that current file path and original file path are equal.
-            return !originalPath.Equals(placeholder.Path, StringComparison.InvariantCultureIgnoreCase);
+            return !originalPath.TrimEnd(Path.DirectorySeparatorChar).Equals(placeholder.Path.TrimEnd(Path.DirectorySeparatorChar), StringComparison.InvariantCultureIgnoreCase);
         }
 
         /// <summary>

VirtualFileSystem/Framework/ETag.cs

@@ -76,14 +76,12 @@ public static string GetETagFilePath(string userFileSystemPath)
         internal static async Task<bool> ETagEqualsAsync(string userFileSystemPath, FileSystemItemBasicInfo remoteStorageItem)
         {
             string remoteStorageETag = remoteStorageItem.ETag;
-
-            // Intstead of the real ETag we store remote storage LastWriteTime when 
-            // creating and updating files/folders.
             string userFileSystemETag = await ETag.GetETagAsync(userFileSystemPath);
-            if (string.IsNullOrEmpty(userFileSystemETag))
+
+            if (string.IsNullOrEmpty(remoteStorageETag) && string.IsNullOrEmpty(userFileSystemETag))
             {
-                // No ETag associated with the file. This is a new file created in user file system.
-                return false;
+                // We assume the remote storage is not using ETags or no ETag is ssociated with this file/folder.
+                return true;
             }
 
             return remoteStorageETag == userFileSystemETag;

VirtualFileSystem/Framework/Syncronyzation/RemoteStorageRawItem.cs

@@ -59,7 +59,7 @@ public static async Task CreateAsync(string userFileSystemNewItemPath, ILogger l
                 logger.LogMessage("Creating item in the remote storage", userFileSystemNewItemPath);
                 await new RemoteStorageRawItem(userFileSystemNewItemPath, logger).CreateOrUpdateAsync(FileMode.CreateNew);
                 await new UserFileSystemRawItem(userFileSystemNewItemPath).ClearStateAsync();
-                logger.LogMessage("Created item in the remote storage succesefully", userFileSystemNewItemPath);
+                logger.LogMessage("Created in the remote storage succesefully", userFileSystemNewItemPath);
             }
             catch (Exception ex)
             {

README.md VirtualFileSystem/README.mdREADME.md renamed to VirtualFileSystem/README.md

@@ -45,7 +45,7 @@ public UserFileSystemItem(string userFileSystemPath, LockInfo lockInfo = null)
         /// <summary>
         /// Renames or moves file or folder to a new location in the remote storage.
         /// </summary>
-        /// <param name="userFileSystemNewPath">Target path of this file of folder in the user file system.</param>
+        /// <param name="userFileSystemNewPath">Target path of this file or folder in the user file system.</param>
         public async Task MoveToAsync(string userFileSystemNewPath)
         {
             string remoteStorageOldPath = RemoteStoragePath;

VirtualFileSystem/UserFileSystemItem.cs

@@ -29,7 +29,7 @@
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="3.1.7" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ITHit.FileSystem.Windows" Version="1.2.3984.0" />
+    <PackageReference Include="ITHit.FileSystem.Windows" Version="1.3.4067.0" />
   </ItemGroup>
   <ItemGroup>
     <None Update="appsettings.json">

VirtualFileSystem/VirtualFileSystem.csproj

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace VirtualFileSystem
+{
+    /// <summary>
+    /// Thrown when a file can not be locked. For example when a lock-token file is blocked 
+    /// from another thread, during update, lock and unlock operations.  
+    /// </summary>
+    public class ClientLockFailedException : IOException
+    {
+        /// <summary>
+        /// Creates instance of this class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        public ClientLockFailedException(string message) : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Creates instance of this class with a specified
+        /// error message and a reference to the inner exception that is the cause of this
+        /// exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">
+        /// The exception that is the cause of the current exception. If the innerException
+        /// parameter is not null, the current exception is raised in a catch block that
+        /// handles the inner exception.
+        /// </param>
+        public ClientLockFailedException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Creates instance of this class with a message and HRESULT code.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="hresult">An integer identifying the error that has occurred.</param>
+        public ClientLockFailedException(string message, int hresult) : base(message, hresult)
+        {
+        }
+    }
+}

WebDAVDrive/Framework/ClientLockFailedException.cs

@@ -0,0 +1,137 @@
+using ITHit.FileSystem;
+using ITHit.FileSystem.Windows;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace VirtualFileSystem
+{
+    /// <summary>
+    /// Custom data stored with a file or folder placeholder, such original file/folder path. Max 4KB.
+    /// </summary>
+    /// <remarks>To avoid storing metatadata and keep footprit small, this class is is using custom serialization.</remarks>
+    internal class CustomData
+    {
+        /// <summary>
+        /// Keeps the original file/folder path. Used to sync file/folder from user file system to remote storage 
+        /// if this app was not running when the file/folder was moved or renamed. This field allows to avoid 
+        /// delete-create sequence during client to server synchronization after app failure.
+        /// </summary>
+        internal string OriginalPath = "";
+
+        /// <summary>
+        /// Serializes all custom data fields into the byte array.
+        /// </summary>
+        /// <returns>Byte array representing custom data.</returns>
+        internal byte[] Serialize()
+        {
+            using (MemoryStream m = new MemoryStream())
+            {
+                using (BinaryWriter writer = new BinaryWriter(m))
+                {
+                    writer.Write(OriginalPath);
+                }
+                return m.ToArray();
+            }
+        }
+
+        /// <summary>
+        /// Deserializes custom data from byte array into object.
+        /// </summary>
+        /// <param name="data">Byte array representing custom data.</param>
+        /// <returns></returns>
+        internal static CustomData Desserialize(byte[] data)
+        {
+            if(data == null)
+            {
+                throw new ArgumentNullException("data");
+            }
+
+            CustomData obj = new CustomData();
+            using (MemoryStream m = new MemoryStream(data))
+            {
+                using (BinaryReader reader = new BinaryReader(m))
+                {
+                    obj.OriginalPath = reader.ReadString();
+                }
+            }
+            return obj;
+        }
+    }
+
+    /// <summary>
+    /// Placeholder methods to get and set custom data associated with a placeholder, such as OriginalPath.
+    /// </summary>
+    internal static class PlaceholderItemExtensions
+    {
+        public static void SetCustomData(this PlaceholderItem placeholder, string originalPath)
+        {
+            CustomData customData = new CustomData { OriginalPath = originalPath };
+            placeholder.SetCustomData(customData.Serialize());
+        }
+
+        public static void SetCustomData(Microsoft.Win32.SafeHandles.SafeFileHandle safeHandle, string originalPath)
+        {
+            CustomData customData = new CustomData { OriginalPath = originalPath };
+            PlaceholderItem.SetCustomData(safeHandle, customData.Serialize());
+        }
+
+        public static void SetOriginalPath(this PlaceholderItem placeholder, string originalPath)
+        {
+            byte[] customDataRaw = placeholder.GetCustomData();
+            CustomData customData = (customDataRaw.Length > 0) ? CustomData.Desserialize(customDataRaw) : new CustomData();
+
+            customData.OriginalPath = originalPath;
+            placeholder.SetCustomData(customData.Serialize());
+        }
+
+        public static string GetOriginalPath(this PlaceholderItem placeholder)
+        {
+            byte[] customDataRaw = placeholder.GetCustomData();
+            CustomData customData = (customDataRaw.Length > 0) ? CustomData.Desserialize(customDataRaw) : new CustomData();
+            return customData.OriginalPath;
+        }
+
+        /// <summary>
+        /// Returns true if the file was moved in the user file system and 
+        /// changes not yet synched to the remote storage.
+        /// </summary>
+        public static bool IsMoved(this PlaceholderItem placeholder)
+        {
+            // If original path was never set, the file was just created, not moved.
+            string originalPath = placeholder.GetOriginalPath();
+            if (string.IsNullOrEmpty(originalPath))
+            {
+                return false;
+            }
+
+            // Otherwise verify that current file path and original file path are equal.
+            return !originalPath.TrimEnd(Path.DirectorySeparatorChar).Equals(placeholder.Path.TrimEnd(Path.DirectorySeparatorChar), StringComparison.InvariantCultureIgnoreCase);
+        }
+
+        /// <summary>
+        /// Returns true if the item was created and must be synched to remote storage.
+        /// </summary>
+        /// <returns>
+        /// True if the item was created in the user file system and does not exists 
+        /// in the remote storage. False otherwise.
+        /// </returns>
+        public static bool IsNew(this PlaceholderItem placeholder)
+        {
+            // ETag absence signals that the item is new.
+            // However, ETag file may not exists during move operation, 
+            // additionally checking OriginalPath presence.
+            // Can not rely on OriginalPath only, 
+            // because MS Office files are being deleted and re-created during transactional save.
+
+            string originalPath = placeholder.GetOriginalPath();
+
+            bool eTagFileExists = File.Exists(ETag.GetETagFilePath(placeholder.Path));
+
+            return !eTagFileExists && string.IsNullOrEmpty(originalPath);
+        }
+
+    }
+}

WebDAVDrive/Framework/CustomData.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace VirtualFileSystem
+{
+    /// <summary>
+    /// Provides method for reading and writing ETags.
+    /// </summary>
+    internal static class ETag
+    {
+        /// <summary>
+        /// Creates or updates ETag associated with the file.
+        /// </summary>
+        /// <param name="userFileSystemPath">Path in the user file system.</param>
+        /// <param name="eTag">ETag.</param>
+        /// <returns></returns>
+        public static async Task SetETagAsync(string userFileSystemPath, string eTag)
+        {
+            string eTagFilePath = GetETagFilePath(userFileSystemPath);
+            Directory.CreateDirectory(Path.GetDirectoryName(eTagFilePath));
+            await File.WriteAllTextAsync(eTagFilePath, eTag);
+        }
+
+        /// <summary>
+        /// Gets ETag associated with a file.
+        /// </summary>
+        /// <param name="userFileSystemPath">Path in the user file system.</param>
+        /// <returns>ETag.</returns>
+        public static async Task<string> GetETagAsync(string userFileSystemPath)
+        {
+            string eTagFilePath = GetETagFilePath(userFileSystemPath);
+            if (!File.Exists(eTagFilePath))
+            {
+                return null;
+            }
+            return await File.ReadAllTextAsync(eTagFilePath);
+        }
+
+        /// <summary>
+        /// Deletes ETag associated with a file.
+        /// </summary>
+        /// <param name="userFileSystemPath">Path in the user file system.</param>
+        public static void DeleteETag(string userFileSystemPath)
+        {
+            File.Delete(GetETagFilePath(userFileSystemPath));
+        }
+
+        /// <summary>
+        /// Gets path to the file in which ETag is stored based on the provided user file system path.
+        /// </summary>
+        /// <param name="userFileSystemPath">Path to the file or folder to get the ETag file path.</param>
+        /// <returns>Path to the file that contains ETag.</returns>
+        public static string GetETagFilePath(string userFileSystemPath)
+        {
+            // Get path relative to the virtual root.
+            string relativePath = Path.TrimEndingDirectorySeparator(userFileSystemPath).Substring(
+                Path.TrimEndingDirectorySeparator(Program.Settings.UserFileSystemRootPath).Length);
+
+            string path = $"{Path.TrimEndingDirectorySeparator(Program.Settings.ServerDataFolderPath)}{relativePath}.etag";
+            return path;
+        }
+
+        /// <summary>
+        /// Returns true if the remote storage ETag and user file system ETags are equal. False - otherwise.
+        /// </summary>
+        /// <param name="userFileSystemPath">User file system item.</param>
+        /// <param name="remoteStorageItem">Remote storage item info.</param>
+        /// <remarks>
+        /// ETag is updated on the server during every document update and is sent to client with a file. 
+        /// During client->server update it is sent back to the remote storage together with a modified content. 
+        /// This ensures the changes on the server are not overwritten if the document on the server is modified.
+        /// </remarks>
+        internal static async Task<bool> ETagEqualsAsync(string userFileSystemPath, FileSystemItemBasicInfo remoteStorageItem)
+        {
+            string remoteStorageETag = remoteStorageItem.ETag;
+            string userFileSystemETag = await ETag.GetETagAsync(userFileSystemPath);
+
+            if (string.IsNullOrEmpty(remoteStorageETag) && string.IsNullOrEmpty(userFileSystemETag))
+            {
+                // We assume the remote storage is not using ETags or no ETag is ssociated with this file/folder.
+                return true;
+            }
+
+            return remoteStorageETag == userFileSystemETag;
+        }
+    }
+}

WebDAVDrive/Framework/ETag.cs

@@ -0,0 +1,14 @@
+using ITHit.FileSystem;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace VirtualFileSystem
+{
+    ///<inheritdoc cref="IFileBasicInfo"/>
+    internal class FileBasicInfo : FileSystemItemBasicInfo, IFileBasicInfo
+    {
+        ///<inheritdoc/>
+        public long Length { get; set; }
+    }
+}