DYN-9707 : Show warning when a file is opened in another Dynamo instance (#17139)

Author: ivaylo-matov

src/DynamoCore/Graph/Workspaces/Locking/GraphLockFile.cs

@@ -0,0 +1,164 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Security;
+using System.Text;
+using System.Threading;
+using Newtonsoft.Json;
+
+namespace Dynamo.Graph.Workspaces.Locking
+{
+    /// <summary>
+    /// Provides file-system operations for graph lock sidecar files.
+    /// </summary>
+    internal static class GraphLockFile
+    {
+        private static readonly JsonSerializer Serializer = JsonSerializer.Create(new JsonSerializerSettings
+        {
+            Culture = System.Globalization.CultureInfo.InvariantCulture,
+            DateTimeZoneHandling = DateTimeZoneHandling.Utc,
+            Formatting = Formatting.Indented,
+            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
+            MissingMemberHandling = MissingMemberHandling.Ignore,
+            NullValueHandling = NullValueHandling.Ignore,
+            TypeNameHandling = TypeNameHandling.None
+        });
+
+        /// <summary>
+        /// Gets the sidecar lock path for a graph file.
+        /// </summary>
+        /// <param name="graphPath">The graph file path.</param>
+        /// <returns>The sidecar lock file path.</returns>
+        internal static string GetLockFilePath(string graphPath)
+        {
+            return Path.GetFullPath(graphPath) + ".dynlock";
+        }
+
+        /// <summary>
+        /// Attempts to create a lock file only if it does not already exist.
+        /// </summary>
+        /// <param name="sidecarPath">The sidecar lock file path.</param>
+        /// <param name="info">The lock metadata to write.</param>
+        /// <returns>True if the lock file was created, false if one already exists.</returns>
+        internal static bool TryCreateNewLockFile(string sidecarPath, GraphLockInfo info)
+        {
+            try
+            {
+                using (var stream = new FileStream(sidecarPath, FileMode.CreateNew, FileAccess.Write, FileShare.Read))
+                using (var writer = new StreamWriter(stream, new UTF8Encoding(false)))
+                {
+                    Serializer.Serialize(writer, info);
+                }
+
+                return true;
+            }
+            catch (IOException) when (File.Exists(sidecarPath))
+            {
+                return false;
+            }
+        }
+
+
+        /// <summary>
+        /// Attempts to read graph-lock metadata from a sidecar file.
+        /// </summary>
+        /// <param name="sidecarPath">The sidecar lock file path.</param>
+        /// <param name="info">The parsed lock metadata when reading succeeds.</param>
+        /// <returns>True if metadata was read; otherwise false.</returns>
+        internal static bool TryRead(string sidecarPath, out GraphLockInfo info)
+        {
+            info = null;
+
+            const int maxAttempts = 2;
+            for (var attempt = 0; attempt < maxAttempts; attempt++)
+            {
+                try
+                {
+                    using (var stream = File.Open(sidecarPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
+                    using (var reader = new StreamReader(stream, Encoding.UTF8))
+                    using (var jsonReader = new JsonTextReader(reader))
+                    {
+                        info = Serializer.Deserialize<GraphLockInfo>(jsonReader);
+                    }
+
+                    return info != null;
+                }
+                catch (Exception ex) when (ex is IOException || ex is JsonException)
+                {
+                    if (attempt == maxAttempts - 1)
+                    {
+                        return false;
+                    }
+
+                    // Wait for 50 milliseconds before retrying
+                    Thread.Sleep(50);
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    return false;
+                }
+                catch (SecurityException)
+                {
+                    return false;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Updates a lock file heartbeat using a temp file and replace operation.
+        /// </summary>
+        /// <param name="sidecarPath">The sidecar lock file path.</param>
+        /// <param name="info">The lock metadata to write.</param>
+        internal static void WriteHeartbeat(string sidecarPath, GraphLockInfo info)
+        {
+            var tempPath = sidecarPath + ".tmp";
+            var replaced = false;
+
+            try
+            {
+                using (var stream = new FileStream(tempPath, FileMode.Create, FileAccess.Write, FileShare.None))
+                using (var writer = new StreamWriter(stream, new UTF8Encoding(false)))
+                {
+                    Serializer.Serialize(writer, info);
+                }
+
+                try
+                {
+                    File.Replace(tempPath, sidecarPath, null, true);
+                }
+                catch (Exception ex) when (ex is IOException || ex is PlatformNotSupportedException || ex is UnauthorizedAccessException)
+                {
+                    File.Move(tempPath, sidecarPath, true);
+                }
+
+                replaced = true;
+            }
+            finally
+            {
+                // If the swap never completed (e.g. serialization threw), don't leave a stray scratch file.
+                if (!replaced && File.Exists(tempPath))
+                {
+                    TryDelete(tempPath);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Attempts to delete a sidecar lock file without throwing.
+        /// </summary>
+        /// <param name="sidecarPath">The sidecar lock file path.</param>
+        internal static void TryDelete(string sidecarPath)
+        {
+            try
+            {
+                File.Delete(sidecarPath);
+            }
+            catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException || ex is SecurityException)
+            {
+                Debug.WriteLine("GraphLock cleanup delete failed: " + ex.Message);
+            }
+        }
+    }
+}

src/DynamoCore/Graph/Workspaces/Locking/GraphLockInfo.cs

@@ -0,0 +1,29 @@
+using Newtonsoft.Json;
+using System;
+
+namespace Dynamo.Graph.Workspaces.Locking
+{
+    /// <summary>
+    /// Serializable metadata stored in a graph lock sidecar file.
+    /// </summary>
+    internal sealed class GraphLockInfo
+    {
+        [JsonProperty("sessionId")]
+        internal Guid SessionId { get; set; }
+
+        [JsonProperty("graphPath")]
+        internal string GraphPath { get; set; }
+
+        [JsonProperty("machineName")]
+        internal string MachineName { get; set; }
+
+        [JsonProperty("processId")]
+        internal int ProcessId { get; set; }
+
+        [JsonProperty("processStartUtc")]
+        internal DateTime ProcessStartUtc { get; set; }
+
+        [JsonProperty("lastHeartbeatUtc")]
+        internal DateTime LastHeartbeatUtc { get; set; }
+    }
+}