RepoRegistry: refactor format and access directly from verbs

Scalar.Build/GenerateVersionInfo.cs

@@ -27,9 +27,11 @@ public override bool Execute()
                 this.AssemblyVersion,
                 string.Format(
 @"using System.Reflection;
+using System.Runtime.CompilerServices;
 
 [assembly: AssemblyVersion(""{0}"")]
 [assembly: AssemblyFileVersion(""{0}"")]
+[assembly: InternalsVisibleTo(""Scalar.UnitTests"")]
 ",
                 this.Version));
 

Scalar.Common/FileSystem/PhysicalFileSystem.cs

@@ -196,6 +196,11 @@ public virtual IEnumerable<string> EnumerateDirectories(string path)
             return Directory.EnumerateDirectories(path);
         }
 
+        public virtual IEnumerable<string> EnumerateFiles(string path, string searchPattern)
+        {
+            return Directory.EnumerateFiles(path, searchPattern);
+        }
+
         public virtual FileProperties GetFileProperties(string path)
         {
             FileInfo entry = new FileInfo(path);

Scalar.Common/NamedPipes/NamedPipeMessages.cs

@@ -116,82 +116,6 @@ public override string ToString()
             }
         }
 
-        public class UnregisterRepoRequest
-        {
-            public const string Header = nameof(UnregisterRepoRequest);
-
-            public string EnlistmentRoot { get; set; }
-
-            public static UnregisterRepoRequest FromMessage(Message message)
-            {
-                return JsonConvert.DeserializeObject<UnregisterRepoRequest>(message.Body);
-            }
-
-            public Message ToMessage()
-            {
-                return new Message(Header, JsonConvert.SerializeObject(this));
-            }
-
-            public class Response : BaseResponse<UnregisterRepoRequest>
-            {
-                public static Response FromMessage(Message message)
-                {
-                    return JsonConvert.DeserializeObject<Response>(message.Body);
-                }
-            }
-        }
-
-        public class RegisterRepoRequest
-        {
-            public const string Header = nameof(RegisterRepoRequest);
-
-            public string EnlistmentRoot { get; set; }
-            public string OwnerSID { get; set; }
-
-            public static RegisterRepoRequest FromMessage(Message message)
-            {
-                return JsonConvert.DeserializeObject<RegisterRepoRequest>(message.Body);
-            }
-
-            public Message ToMessage()
-            {
-                return new Message(Header, JsonConvert.SerializeObject(this));
-            }
-
-            public class Response : BaseResponse<RegisterRepoRequest>
-            {
-                public static Response FromMessage(Message message)
-                {
-                    return JsonConvert.DeserializeObject<Response>(message.Body);
-                }
-            }
-        }
-
-        public class GetActiveRepoListRequest
-        {
-            public const string Header = nameof(GetActiveRepoListRequest);
-
-            public static GetActiveRepoListRequest FromMessage(Message message)
-            {
-                return JsonConvert.DeserializeObject<GetActiveRepoListRequest>(message.Body);
-            }
-
-            public Message ToMessage()
-            {
-                return new Message(Header, JsonConvert.SerializeObject(this));
-            }
-
-            public class Response : BaseResponse<GetActiveRepoListRequest>
-            {
-                public List<string> RepoList { get; set; }
-
-                public static Response FromMessage(Message message)
-                {
-                    return JsonConvert.DeserializeObject<Response>(message.Body);
-                }
-            }
-        }
-
         public class BaseResponse<TRequest>
         {
             public const string Header = nameof(TRequest) + ResponseSuffix;

Scalar.Common/RepoRegistry/IScalarRepoRegistry.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace Scalar.Common.RepoRegistry
+{
+    public interface IScalarRepoRegistry
+    {
+        bool TryRegisterRepo(string normalizedRepoRoot, string userId, out string errorMessage);
+        bool TryUnregisterRepo(string normalizedRepoRoot, out string errorMessage);
+        IEnumerable<ScalarRepoRegistration> GetRegisteredRepos();
+    }
+}

Scalar.Common/RepoRegistry/IScalarRepoRegistryExtensions.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Scalar.Common.RepoRegistry
+{
+    public static class IScalarRepoRegistryExtensions
+    {
+        public static IEnumerable<ScalarRepoRegistration> GetRegisteredReposForUser(this IScalarRepoRegistry registry, string userId)
+        {
+            return registry.GetRegisteredRepos().Where(x => x.UserId.Equals(userId, StringComparison.CurrentCultureIgnoreCase));
+        }
+    }
+}

Scalar.Common/RepoRegistry/ScalarRepoRegistration.cs

@@ -0,0 +1,40 @@
+using Newtonsoft.Json;
+
+namespace Scalar.Common.RepoRegistry
+{
+    public class ScalarRepoRegistration
+    {
+        public ScalarRepoRegistration()
+        {
+        }
+
+        public ScalarRepoRegistration(string normalizedRepoRoot, string userId)
+        {
+            this.NormalizedRepoRoot = normalizedRepoRoot;
+            this.UserId = userId;
+        }
+
+        public string NormalizedRepoRoot { get; set; }
+        public string UserId { get; set; }
+
+        public static ScalarRepoRegistration FromJson(string json)
+        {
+            return JsonConvert.DeserializeObject<ScalarRepoRegistration>(
+                json,
+                new JsonSerializerSettings
+                {
+                    MissingMemberHandling = MissingMemberHandling.Ignore
+                });
+        }
+
+        public override string ToString()
+        {
+            return $"({this.UserId}) {this.NormalizedRepoRoot}";
+        }
+
+        public string ToJson()
+        {
+            return JsonConvert.SerializeObject(this);
+        }
+    }
+}

Scalar.Common/RepoRegistry/ScalarRepoRegistry.cs

@@ -0,0 +1,207 @@
+using Scalar.Common.FileSystem;
+using Scalar.Common.Tracing;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+
+namespace Scalar.Common.RepoRegistry
+{
+    public class ScalarRepoRegistry : IScalarRepoRegistry
+    {
+        private const string EtwArea = nameof(ScalarRepoRegistry);
+        private const string RegistryFileExtension = ".repo";
+        private const string RegistryTempFileExtension = ".temp";
+
+        private string registryFolderPath;
+        private ITracer tracer;
+        private PhysicalFileSystem fileSystem;
+
+        public ScalarRepoRegistry(
+            ITracer tracer,
+            PhysicalFileSystem fileSystem,
+            string repoRegistryLocation)
+        {
+            this.tracer = tracer;
+            this.fileSystem = fileSystem;
+            this.registryFolderPath = repoRegistryLocation;
+        }
+
+        public bool TryRegisterRepo(string normalizedRepoRoot, string userId, out string errorMessage)
+        {
+            try
+            {
+                if (!this.fileSystem.DirectoryExists(this.registryFolderPath))
+                {
+                    EventMetadata metadata = CreateEventMetadata();
+                    metadata.Add(nameof(this.registryFolderPath), this.registryFolderPath);
+                    this.tracer.RelatedEvent(
+                        EventLevel.Informational,
+                        $"{nameof(this.TryRegisterRepo)}_CreatingRegistryDirectory",
+                        metadata);
+
+                    // TODO #136: Make sure this does the right thing with ACLs on Windows
+                    this.fileSystem.CreateDirectory(this.registryFolderPath);
+                }
+            }
+            catch (Exception e)
+            {
+                errorMessage = $"Error while ensuring registry directory '{this.registryFolderPath}' exists: {e.Message}";
+
+                EventMetadata metadata = CreateEventMetadata(e);
+                metadata.Add(nameof(normalizedRepoRoot), normalizedRepoRoot);
+                metadata.Add(nameof(this.registryFolderPath), this.registryFolderPath);
+                this.tracer.RelatedError(metadata, $"{nameof(this.TryRegisterRepo)}: Exception while ensuring registry directory exists");
+                return false;
+            }
+
+            string tempRegistryPath = this.GetRepoRegistryTempFilePath(normalizedRepoRoot);
+
+            try
+            {
+                ScalarRepoRegistration repoRegistration = new ScalarRepoRegistration(normalizedRepoRoot, userId);
+                string registryFileContents = repoRegistration.ToJson();
+
+                using (Stream tempFile = this.fileSystem.OpenFileStream(
+                    tempRegistryPath,
+                    FileMode.Create,
+                    FileAccess.Write,
+                    FileShare.None,
+                    callFlushFileBuffers: true))
+                using (StreamWriter writer = new StreamWriter(tempFile))
+                {
+                    writer.WriteLine(registryFileContents);
+                    tempFile.Flush();
+                }
+            }
+            catch (Exception e)
+            {
+                errorMessage = $"Error while registering repo {normalizedRepoRoot}: {e.Message}";
+
+                EventMetadata metadata = CreateEventMetadata(e);
+                metadata.Add(nameof(normalizedRepoRoot), normalizedRepoRoot);
+                metadata.Add(nameof(tempRegistryPath), tempRegistryPath);
+                this.tracer.RelatedError(metadata, $"{nameof(this.TryRegisterRepo)}: Exception while writing temp registry file");
+                return false;
+            }
+
+            string registryFilePath = this.GetRepoRegistryFilePath(normalizedRepoRoot);
+            try
+            {
+                this.fileSystem.MoveAndOverwriteFile(tempRegistryPath, registryFilePath);
+            }
+            catch (Win32Exception e)
+            {
+                errorMessage = $"Error while registering repo {normalizedRepoRoot}: {e.Message}";
+
+                EventMetadata metadata = CreateEventMetadata(e);
+                metadata.Add(nameof(normalizedRepoRoot), normalizedRepoRoot);
+                metadata.Add(nameof(tempRegistryPath), tempRegistryPath);
+                metadata.Add(nameof(registryFilePath), registryFilePath);
+                this.tracer.RelatedError(metadata, $"{nameof(this.TryRegisterRepo)}: Exception while renaming temp registry file");
+                return false;
+            }
+
+            errorMessage = null;
+            return true;
+        }
+
+        public bool TryUnregisterRepo(string normalizedRepoRoot, out string errorMessage)
+        {
+            string registryPath = this.GetRepoRegistryFilePath(normalizedRepoRoot);
+            if (!this.fileSystem.FileExists(registryPath))
+            {
+                errorMessage = $"Attempted to remove non-existent repo '{normalizedRepoRoot}'";
+
+                EventMetadata metadata = CreateEventMetadata();
+                metadata.Add(nameof(normalizedRepoRoot), normalizedRepoRoot);
+                metadata.Add(nameof(registryPath), registryPath);
+                this.tracer.RelatedWarning(
+                    metadata,
+                    $"{nameof(this.TryUnregisterRepo)}: Attempted to remove non-existent repo");
+
+                return false;
+            }
+
+            try
+            {
+                this.fileSystem.DeleteFile(registryPath);
+            }
+            catch (Exception e)
+            {
+                errorMessage = $"Error while removing repo {normalizedRepoRoot}: {e.Message}";
+
+                EventMetadata metadata = CreateEventMetadata(e);
+                metadata.Add(nameof(normalizedRepoRoot), normalizedRepoRoot);
+                metadata.Add(nameof(registryPath), registryPath);
+                this.tracer.RelatedWarning(
+                    metadata,
+                    $"{nameof(this.TryUnregisterRepo)}: Exception while removing repo");
+
+                return false;
+            }
+
+            errorMessage = null;
+            return true;
+        }
+
+        public IEnumerable<ScalarRepoRegistration> GetRegisteredRepos()
+        {
+            if (this.fileSystem.DirectoryExists(this.registryFolderPath))
+            {
+                IEnumerable<string> registryFilePaths = this.fileSystem.EnumerateFiles(this.registryFolderPath, $"*{RegistryFileExtension}");
+                foreach (string registryFilePath in registryFilePaths)
+                {
+                    ScalarRepoRegistration registration = null;
+                    try
+                    {
+                        string repoData = this.fileSystem.ReadAllText(registryFilePath);
+                        registration = ScalarRepoRegistration.FromJson(repoData);
+                    }
+                    catch (Exception e)
+                    {
+                        EventMetadata metadata = CreateEventMetadata(e);
+                        metadata.Add(nameof(registryFilePath), registryFilePath);
+                        this.tracer.RelatedWarning(
+                            metadata,
+                            $"{nameof(this.GetRegisteredRepos)}: Failed to read registry file");
+                    }
+
+                    if (registration != null)
+                    {
+                        yield return registration;
+                    }
+                }
+            }
+        }
+
+        internal static string GetRepoRootSha(string normalizedRepoRoot)
+        {
+            return SHA1Util.SHA1HashStringForUTF8String(normalizedRepoRoot.ToLowerInvariant());
+        }
+
+        private static EventMetadata CreateEventMetadata(Exception e = null)
+        {
+            EventMetadata metadata = new EventMetadata();
+            metadata.Add("Area", EtwArea);
+            if (e != null)
+            {
+                metadata.Add("Exception", e.ToString());
+            }
+
+            return metadata;
+        }
+
+        private string GetRepoRegistryTempFilePath(string normalizedRepoRoot)
+        {
+            string repoTempFilename = $"{GetRepoRootSha(normalizedRepoRoot)}{RegistryTempFileExtension}";
+            return Path.Combine(this.registryFolderPath, repoTempFilename);
+        }
+
+        private string GetRepoRegistryFilePath(string normalizedRepoRoot)
+        {
+            string repoFilename = $"{GetRepoRootSha(normalizedRepoRoot)}{RegistryFileExtension}";
+            return Path.Combine(this.registryFolderPath, repoFilename);
+        }
+    }
+}

Scalar.Common/ScalarConstants.cs

@@ -54,6 +54,11 @@ public static class Service
             public const string UIName = "Scalar.Service.UI";
         }
 
+        public static class RepoRegistry
+        {
+            public const string RegistryDirectoryName = "Scalar.RepoRegistry";
+        }
+
         public static class MediaTypes
         {
             public const string PrefetchPackFilesAndIndexesMediaType = "application/x-gvfs-timestamped-packfiles-indexes";