CommandInfoUpdater fix - Ignore Garnet-internal sub-commands (#972)

* Ignore garnet-internal subcommands when fetching docs

* format

playground/CommandInfoUpdater/CommandDocsUpdater.cs

@@ -39,8 +39,19 @@ public static bool TryUpdateCommandDocs(string outputDir, int respServerPort, IP
                 return false;
             }
 
+            var internalSubCommands = new Dictionary<string, HashSet<string>>();
+            foreach (var ci in updatedCommandsInfo)
+            {
+                if (ci.Value.SubCommands == null) continue;
+                var internalSubCmds =
+                    ci.Value.SubCommands.Where(sc => sc.IsInternal).Select(sc => sc.Name).ToHashSet();
+
+                if (internalSubCmds.Count > 0)
+                    internalSubCommands.Add(ci.Key, internalSubCmds);
+            }
+
             var (commandsToAdd, commandsToRemove) =
-                CommonUtils.GetCommandsToAddAndRemove(existingCommandsDocs, ignoreCommands);
+                CommonUtils.GetCommandsToAddAndRemove(existingCommandsDocs, ignoreCommands, internalSubCommands);
 
             if (!CommonUtils.GetUserConfirmation(commandsToAdd, commandsToRemove, logger))
             {

playground/CommandInfoUpdater/CommandInfoUpdater.cs

@@ -45,7 +45,7 @@ public static bool TryUpdateCommandInfo(string outputDir, int respServerPort, IP
             }
 
             var (commandsToAdd, commandsToRemove) =
-                CommonUtils.GetCommandsToAddAndRemove(existingCommandsInfo, ignoreCommands);
+                CommonUtils.GetCommandsToAddAndRemove(existingCommandsInfo, ignoreCommands, null);
 
             if (!CommonUtils.GetUserConfirmation(commandsToAdd, commandsToRemove, logger))
             {

playground/CommandInfoUpdater/CommonUtils.cs

@@ -65,14 +65,16 @@ internal static bool TryWriteRespCommandsData<TData>(string outputPath,
         /// </summary>
         /// <param name="existingCommandsInfo">Existing command names mapped to current command info</param>
         /// <param name="ignoreCommands">Commands to ignore</param>
+        /// <param name="ignoreSubCommands">Sub-commands to ignore</param>
         /// <returns>Commands to add and commands to remove mapped to a boolean determining if parent command should be added / removed</returns>
         internal static (IDictionary<SupportedCommand, bool>, IDictionary<SupportedCommand, bool>)
             GetCommandsToAddAndRemove<TData>(IReadOnlyDictionary<string, TData> existingCommandsInfo,
-                IEnumerable<string> ignoreCommands) where TData : class, IRespCommandData<TData>
+                IEnumerable<string> ignoreCommands, IDictionary<string, HashSet<string>> ignoreSubCommands) where TData : class, IRespCommandData<TData>
         {
             var commandsToAdd = new Dictionary<SupportedCommand, bool>();
             var commandsToRemove = new Dictionary<SupportedCommand, bool>();
             var commandsToIgnore = ignoreCommands != null ? new HashSet<string>(ignoreCommands) : null;
+            var subCommandsToIgnore = ignoreSubCommands ?? new Dictionary<string, HashSet<string>>();
 
             // Supported commands
             var supportedCommands = SupportedCommand.SupportedCommandsMap;
@@ -97,16 +99,30 @@ internal static (IDictionary<SupportedCommand, bool>, IDictionary<SupportedComma
                 // If existing commands contain parent command and have no sub-commands, set sub-commands to add as supported command's sub-commands
                 if (existingCommandsInfo[supportedCommand.Command].SubCommands == null)
                 {
-                    subCommandsToAdd = [.. supportedCommand.SubCommands.Values];
+                    subCommandsToAdd =
+                    [
+                        .. supportedCommand.SubCommands.Where(subCommand =>
+                                !subCommandsToIgnore.ContainsKey(supportedCommand.Command) ||
+                                !subCommandsToIgnore[supportedCommand.Command].Contains(subCommand.Key))
+                            .Select(sc => sc.Value)
+                    ];
                 }
                 // Set sub-commands to add as the difference between existing sub-commands and supported command's sub-commands
                 else
                 {
                     var existingSubCommands = new HashSet<string>(existingCommandsInfo[supportedCommand.Command]
                         .SubCommands
                         .Select(sc => sc.Name));
-                    subCommandsToAdd = [.. supportedCommand.SubCommands
-                        .Where(subCommand => !existingSubCommands.Contains(subCommand.Key)).Select(sc => sc.Value)];
+
+                    subCommandsToAdd =
+                    [
+                        .. supportedCommand.SubCommands
+                            .Where(subCommand =>
+                                !existingSubCommands.Contains(subCommand.Key) &&
+                                (!subCommandsToIgnore.ContainsKey(supportedCommand.Command) ||
+                                 !subCommandsToIgnore[supportedCommand.Command].Contains(subCommand.Key)))
+                            .Select(sc => sc.Value)
+                    ];
                 }
 
                 // If there are sub-commands to add, add a new supported command with the sub-commands to add