LocalPackages config to _generated_local (no CI needed for gen code) (#20504)

* LocalPackages config to _generated_local (no check-in needed for generated code))
Updates to BuildConfigGen to support unverified writes to _generated_local
Fixes for globalversion.txt updates

Author: merlynomsft

.gitignore

@@ -222,3 +222,4 @@ _dotnetsdk/
 # BuildConfigGen files
 FilesOverriddenForConfigGoHereREADME.txt
 
+_generated_local/

BuildConfigGen/EnsureUpdateModeVerifier.cs

@@ -1,5 +1,6 @@
 using System.ComponentModel.Design;
 using System.Diagnostics;
+using System.IO;
 using System.Security.AccessControl;
 
 namespace BuildConfigGen
@@ -10,15 +11,17 @@ internal class EnsureUpdateModeVerifier
         // if any changes would be made to output, verification should fail
         // check the contents of VerifyErrors for verification errors
 
-        private readonly bool verifyOnly;
+        private bool verifyState;
+        private readonly bool verifyFromConstructor;
         private List<string> VerifyErrors = new List<string>();
         internal Dictionary<string, string> CopiedFilesToCheck = new Dictionary<string, string>();
         internal Dictionary<string, string> RedirectedToTempl = new Dictionary<string, string>();
         private HashSet<string> tempsToKeep = new HashSet<string>();
 
         public EnsureUpdateModeVerifier(bool verifyOnly)
         {
-            this.verifyOnly = verifyOnly;
+            this.verifyState = verifyOnly;
+            this.verifyFromConstructor = verifyOnly;
         }
 
         public IEnumerable<string> GetVerifyErrors(bool skipContentCheck)
@@ -30,7 +33,6 @@ public IEnumerable<string> GetVerifyErrors(bool skipContentCheck)
 
             if (!skipContentCheck)
             {
-
                 foreach (var r in CopiedFilesToCheck)
                 {
                     string? sourceFile;
@@ -90,9 +92,9 @@ public void CleanupTempFiles()
                     }
                 }
 
-                if (count > 0 && !verifyOnly)
+                if (count > 0 && !verifyFromConstructor)
                 {
-                    throw new Exception("Expected RedirectedToTemp to be empty when !verifyOnly");
+                    throw new Exception("Expected RedirectedToTemp to be empty when !verifyFromConstructor");
                 }
             }
             finally
@@ -105,6 +107,8 @@ public void CleanupTempFiles()
 
         internal void Copy(string sourceFileName, string destFileName, bool overwrite)
         {
+            bool verifyOnly = UseVerifyOnlyForFile(destFileName);
+
             if (verifyOnly)
             {
                 if (File.Exists(destFileName))
@@ -138,6 +142,16 @@ internal void Copy(string sourceFileName, string destFileName, bool overwrite)
 
         internal void Move(string sourceFileName, string destFileName)
         {
+            bool verifyOnlySource = UseVerifyOnlyForFile(sourceFileName);
+            bool verifyOnlyDest = UseVerifyOnlyForFile(destFileName);
+
+            if (verifyOnlySource != verifyOnlyDest)
+            {
+                throw new Exception($"BUG: both source and dest must be unconditional path or not sourceFileName={sourceFileName} destFileName={destFileName}");
+            }
+
+            var verifyOnly = verifyOnlySource || verifyOnlyDest;
+
             if (verifyOnly)
             {
                 // verification won't pass if we encounter a move
@@ -160,6 +174,8 @@ internal void Move(string sourceFileName, string destFileName)
 
         internal void WriteAllText(string path, string contents, bool suppressValidationErrorIfTargetPathDoesntExist)
         {
+            bool verifyOnly = UseVerifyOnlyForFile(path);
+
             if (verifyOnly)
             {
                 if (File.Exists(path))
@@ -205,6 +221,8 @@ private string NormalizeFile(string file)
 
         internal void DirectoryCreateDirectory(string path, bool suppressValidationErrorIfTargetPathDoesntExist)
         {
+            bool verifyOnly = UseVerifyOnlyForPath(path);
+
             if (verifyOnly)
             {
                 if (!Directory.Exists(path))
@@ -228,6 +246,8 @@ internal void DirectoryCreateDirectory(string path, bool suppressValidationError
 
         internal string FileReadAllText(string filePath)
         {
+            bool verifyOnly = UseVerifyOnlyForFile(filePath);
+
             if (verifyOnly)
             {
                 string targetFile = ResolveFile(filePath);
@@ -240,8 +260,10 @@ internal string FileReadAllText(string filePath)
             }
         }
 
-        internal string [] FileReadAllLines(string filePath)
+        internal string[] FileReadAllLines(string filePath)
         {
+            bool verifyOnly = UseVerifyOnlyForFile(filePath);
+
             if (verifyOnly)
             {
                 string targetFile = ResolveFile(filePath);
@@ -263,7 +285,7 @@ internal bool FilesEqual(string sourcePath, string targetPath)
 
         private string ResolveFile(string filePath)
         {
-            if(!verifyOnly)
+            if (!UseVerifyOnlyForFile(filePath))
             {
                 return filePath;
             }
@@ -295,20 +317,138 @@ private string ResolveFile(string filePath)
 
         internal void DeleteDirectoryRecursive(string path)
         {
-            if(verifyOnly)
+            bool verify = UseVerifyOnlyForPath(path);
+
+            if (verify)
             {
-                if(Directory.Exists(path))
+                if (Directory.Exists(path))
                 {
                     VerifyErrors.Add($"Expected directory {path} to not exist");
                 }
             }
             else
             {
-                if(Directory.Exists(path))
+                if (Directory.Exists(path))
                 {
                     Directory.Delete(path, true);
                 }
             }
         }
+
+        private bool UseVerifyOnlyForFile(string file)
+        {
+            return UseVerifyOnlyInternal(file, true);
+        }
+
+        private bool UseVerifyOnlyForPath(string path)
+        {
+            return UseVerifyOnlyInternal(path, false);
+        }
+
+        private bool UseVerifyOnlyInternal(string path, bool trueForFile)
+        {
+            EnsureState();
+
+            /*
+            // if verifyOnly state
+            if (verifyState)
+            {
+                return true;
+            }*/
+
+            // if !verifyOnly was passed to constructor, unconditional writes everywhere
+            if (!verifyFromConstructor)
+            {
+                return false;
+            }
+
+            // if uncondo
+            if (allowedUnconditionalPath is null)
+            {
+                return verifyState;
+            }
+
+            if (trueForFile ? IsSubFile(allowedUnconditionalPath, path) : IsSubPath(allowedUnconditionalPath, path))
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        string? allowedUnconditionalPath;
+
+        internal void StartUnconditionalWrites(string allowedUnconditionalPath)
+        {
+            EnsureState();
+
+            if(verifyState != verifyFromConstructor)
+            { 
+                throw new Exception($"BUG: expected verifyState {verifyState} == verifyFromConstructor {verifyFromConstructor}");
+            }
+
+            if (!verifyFromConstructor)
+            {
+                return;
+            }
+
+            verifyState = false;
+            this.allowedUnconditionalPath = allowedUnconditionalPath;
+        }
+
+        internal void ResumeWriteBehavior()
+        {
+            EnsureState();
+
+            if (!verifyFromConstructor)
+            {
+                return;
+            }
+
+            verifyState = verifyFromConstructor;
+            this.allowedUnconditionalPath = null;
+        }
+
+        private void EnsureState()
+        {
+            if(!verifyFromConstructor && verifyState)
+            {
+                throw new Exception("BUG: verifyState cannot be true if verifyFromConstructor is false");
+            }
+
+            if (verifyFromConstructor)
+            {
+                if (this.allowedUnconditionalPath is null && !verifyState)
+                {
+                    throw new Exception($"BUG: expected allowedUnconditionalPath={allowedUnconditionalPath} to be not null when !verifyState=={!verifyState}");
+                }
+            }
+            else 
+            {
+                if (this.allowedUnconditionalPath is not null)
+                {
+                    throw new Exception($"BUG: expected allowedUnconditionalPath={allowedUnconditionalPath} to be null");
+                }
+            }
+        }
+
+        // generaetd by copilot 20240926
+        static bool IsSubPath(string mainPath, string subPath)
+        {
+            var mainDirectory = new DirectoryInfo(mainPath).FullName;
+            var subDirectory = new DirectoryInfo(subPath).FullName;
+
+            return subDirectory.StartsWith(mainDirectory, StringComparison.OrdinalIgnoreCase);
+        }
+
+        static bool IsSubFile(string mainPath, string subFile)
+        {
+            var mainDirectory = new DirectoryInfo(mainPath).FullName;
+            var subDirectory = new FileInfo(subFile).FullName;
+
+            return subDirectory.StartsWith(mainDirectory, StringComparison.OrdinalIgnoreCase);
+        }
     }
 }

BuildConfigGen/GitUtil.cs

@@ -120,9 +120,51 @@ internal static string GetGitRootPath(string currentDir)
             }
         }
 
-        internal static IEnumerable<string> GetNonIgnoredFileListFromPath(string taskTarget)
+        internal static IEnumerable<string> GetNonIgnoredFileListFromPath(string gitRoot, string taskTarget)
         {
-            if(!Directory.Exists(taskTarget))
+            string gitIgnorePathBak = Path.Combine(gitRoot, ".gitignore.bak");
+            string gitIgnore = Path.Combine(gitRoot, ".gitignore");
+
+            bool needsGitIgnoreUpdate = taskTarget.Contains("/_generated_local/") || taskTarget.Contains(@"\_generated_local\");
+
+            string? gitIgnoreContent = null;
+
+            if (needsGitIgnoreUpdate)
+            {
+                gitIgnoreContent = File.ReadAllText(gitIgnore);
+                const string genertedLocalPath = "_generated_local/";
+
+                if (!gitIgnoreContent.Contains(genertedLocalPath))
+                {
+                    throw new Exception("Expected " + genertedLocalPath + " in " + gitIgnore);
+                }
+
+                gitIgnoreContent = gitIgnoreContent.Replace(genertedLocalPath, "");
+
+                File.Copy(gitIgnore, gitIgnorePathBak, true);
+            }
+
+            try
+            {
+                if (needsGitIgnoreUpdate)
+                {
+                    File.WriteAllText(gitIgnore, gitIgnoreContent);
+                }
+
+                return GetNonIgnoredFileListFromPathInner(taskTarget);
+            }
+            finally
+            {
+                if (needsGitIgnoreUpdate)
+                {
+                    File.Move(gitIgnorePathBak, gitIgnore, true);
+                }
+            }
+        }
+
+        private static IEnumerable<string> GetNonIgnoredFileListFromPathInner(string taskTarget)
+        {
+            if (!Directory.Exists(taskTarget))
             {
                 throw new Exception($"{nameof(taskTarget)}=={taskTarget} doesn't exist");
             }
@@ -137,7 +179,6 @@ internal static IEnumerable<string> GetNonIgnoredFileListFromPath(string taskTar
             return paths;
         }
 
-
         private static IEnumerable<string> GitLsFiles(string taskTarget)
         {
             if (!Directory.Exists(taskTarget))