Merge branch 'main' into preview-rc-security-reorg

Author: cmilesb

assets/css/index.css

@@ -0,0 +1,261 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import logging
+import os
+import sys
+
+from components.syntax import Command
+from components.markdown import Markdown
+
+
+def command_filename(name: str) -> str:
+    """Convert command name to filename format."""
+    return name.lower().replace(' ', '-')
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description='Creates new Redis command pages from JSON input')
+    parser.add_argument('json_file', type=str,
+                        help='Path to JSON file containing command definitions')
+    parser.add_argument('--loglevel', type=str,
+                        default='INFO',
+                        help='Python logging level (overwrites LOGLEVEL env var)')
+    return parser.parse_args()
+
+
+def validate_json_structure(data: dict, filename: str) -> None:
+    """Validate that the JSON has the expected structure for Redis commands."""
+    if not isinstance(data, dict):
+        raise ValueError(f"JSON file {filename} must contain a dictionary at root level")
+    
+    for command_name, command_data in data.items():
+        if not isinstance(command_data, dict):
+            raise ValueError(f"Command '{command_name}' must be a dictionary")
+        
+        # Check for required fields
+        required_fields = ['summary', 'since', 'group']
+        for field in required_fields:
+            if field not in command_data:
+                logging.warning(f"Command '{command_name}' missing recommended field: {field}")
+        
+        # Validate arguments structure if present
+        if 'arguments' in command_data:
+            if not isinstance(command_data['arguments'], list):
+                raise ValueError(f"Command '{command_name}' arguments must be a list")
+
+
+def load_and_validate_json(filepath: str) -> dict:
+    """Load and validate the JSON file containing command definitions."""
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(f"JSON file not found: {filepath}")
+
+    try:
+        with open(filepath, 'r') as f:
+            data = json.load(f)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Invalid JSON in file {filepath}: {e}")
+
+    validate_json_structure(data, filepath)
+    return data
+
+
+def add_standard_categories(fm_data: dict) -> None:
+    """Add the standard categories from create.sh script."""
+    standard_categories = [
+        'docs', 'develop', 'stack', 'oss', 'rs', 'rc', 'oss', 'kubernetes', 'clients'
+    ]
+    fm_data['categories'] = standard_categories
+
+
+def get_full_command_name(command_name: str, command_data: dict) -> str:
+    """Get the full command name, handling container commands."""
+    container = command_data.get('container')
+    if container:
+        return f"{container} {command_name}"
+    return command_name
+
+
+def generate_command_frontmatter(command_name: str, command_data: dict, all_commands: dict) -> dict:
+    """Generate complete Hugo frontmatter for a command using existing build infrastructure."""
+    # Get the full command name (handles container commands)
+    full_command_name = get_full_command_name(command_name, command_data)
+
+    # Create Command object to generate syntax using the full command name
+    c = Command(full_command_name, command_data)
+
+    # Start with the command data
+    fm_data = command_data.copy()
+
+    # Add required Hugo frontmatter fields
+    fm_data.update({
+        'title': full_command_name,
+        'linkTitle': full_command_name,
+        'description': command_data.get('summary'),
+        'syntax_str': str(c),
+        'syntax_fmt': c.syntax(),
+        'hidden': False  # Default to not hidden
+    })
+
+    # Add the standard categories from create.sh
+    add_standard_categories(fm_data)
+
+    return fm_data
+
+
+def generate_argument_sections(command_data: dict) -> str:
+    """Generate placeholder sections for Required arguments and Optional arguments."""
+    content = ""
+
+    arguments = command_data.get('arguments', [])
+    if not arguments:
+        return content
+
+    required_args = []
+    optional_args = []
+
+    # Categorize arguments
+    for arg in arguments:
+        if arg.get('optional', False):
+            optional_args.append(arg)
+        else:
+            required_args.append(arg)
+
+    # Generate Required arguments section
+    if required_args:
+        content += "## Required arguments\n\n"
+        for arg in required_args:
+            arg_name = arg.get('name', 'unknown')
+            arg_type = arg.get('type', 'unknown')
+            display_text = arg.get('display_text', arg_name)
+
+            content += f"<details open><summary><code>{display_text}</code></summary>\n\n"
+            content += f"TODO: Add description for {arg_name} ({arg_type})\n\n"
+            content += "</details>\n\n"
+
+    # Generate Optional arguments section
+    if optional_args:
+        content += "## Optional arguments\n\n"
+        for arg in optional_args:
+            arg_name = arg.get('name', 'unknown')
+            arg_type = arg.get('type', 'unknown')
+            display_text = arg.get('display_text', arg_name)
+            token = arg.get('token', '')
+
+            content += f"<details open><summary><code>{token if token else display_text}</code></summary>\n\n"
+            content += f"TODO: Add description for {arg_name} ({arg_type})\n\n"
+            content += "</details>\n\n"
+
+    return content
+
+
+def generate_return_section() -> str:
+    """Generate placeholder Return information section."""
+    return '''## Return information
+
+{{< multitabs id="return-info"
+    tab1="RESP2"
+    tab2="RESP3" >}}
+
+TODO: Add RESP2 return information
+
+-tab-sep-
+
+TODO: Add RESP3 return information
+
+{{< /multitabs >}}
+
+'''
+
+
+def generate_complete_markdown_content(command_name: str, command_data: dict) -> str:
+    """Generate the complete markdown content for a command page."""
+    content = ""
+
+    # Add command summary as the main description
+    summary = command_data.get('summary', f'TODO: Add summary for {command_name}')
+    content += f"{summary}\n\n"
+
+    # Add argument sections
+    content += generate_argument_sections(command_data)
+
+    # Add return information section
+    content += generate_return_section()
+
+    return content
+
+
+def create_command_file(command_name: str, command_data: dict, all_commands: dict) -> str:
+    """Create a complete command markdown file with frontmatter and content."""
+    # Get the full command name (handles container commands)
+    full_command_name = get_full_command_name(command_name, command_data)
+
+    # Generate the file path using the full command name
+    filename = command_filename(full_command_name)
+    filepath = f'content/commands/{filename}.md'
+
+    # Ensure the directory exists
+    os.makedirs(os.path.dirname(filepath), exist_ok=True)
+
+    # Check if file already exists
+    if os.path.exists(filepath):
+        logging.warning(f"File {filepath} already exists, skipping...")
+        return filepath
+
+    # Generate frontmatter
+    frontmatter_data = generate_command_frontmatter(command_name, command_data, all_commands)
+
+    # Generate content
+    content = generate_complete_markdown_content(command_name, command_data)
+
+    # Create markdown object and set data
+    md = Markdown(filepath)
+    md.fm_data = frontmatter_data
+    md.payload = content
+
+    # Write the file
+    md.persist()
+
+    logging.info(f"Created command file: {filepath}")
+    return filepath
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    
+    # Configure logging BEFORE creating objects
+    log_level = getattr(logging, args.loglevel.upper())
+    logging.basicConfig(
+        level=log_level,
+        format='%(message)s %(filename)s:%(lineno)d - %(funcName)s',
+        force=True  # Force reconfiguration in case logging was already configured
+    )
+    
+    try:
+        # Load and validate JSON data
+        commands_data = load_and_validate_json(args.json_file)
+        logging.info(f"Loaded {len(commands_data)} commands from {args.json_file}")
+        
+        # Process each command and generate markdown files
+        created_files = []
+        for command_name in commands_data:
+            try:
+                logging.info(f"Processing command: {command_name}")
+                filepath = create_command_file(command_name, commands_data[command_name], commands_data)
+                created_files.append(filepath)
+            except Exception as e:
+                logging.error(f"Failed to create file for command '{command_name}': {e}")
+                # Continue processing other commands
+                continue
+
+        # Summary
+        logging.info(f"Successfully created {len(created_files)} command files:")
+        for filepath in created_files:
+            logging.info(f"  - {filepath}")
+            
+    except (FileNotFoundError, ValueError) as e:
+        logging.error(f"Error: {e}")
+        sys.exit(1)
+    except Exception as e:
+        logging.error(f"Unexpected error: {e}")
+        sys.exit(1)

build/add_cmds.py

@@ -14,7 +14,10 @@
     'java-sync': '@Test',
     'java-async': '@Test',
     'java-reactive': '@Test',
-    'c#': r'\[Fact]|\[SkipIfRedis\(.*\)]'
+    'c#': r'\[Fact]|\[SkipIfRedis\(.*\)]',
+    'c#-sync': r'\[Fact]|\[SkipIfRedis\(.*\)]',
+    'c#-async': r'\[Fact]|\[SkipIfRedis\(.*\)]',
+    'rust': r'#\[test]|#\[cfg\(test\)]|#\[tokio::test]'
 }
 PREFIXES = {
     'python': '#',
@@ -25,8 +28,13 @@
     'java-reactive': '//',
     'go': '//',
     'c#': '//',
+    'c#-sync': '//',
+    'c#-async': '//',
     'redisvl': '#',
-    'php': '//'
+    'php': '//',
+    'rust': '//',
+    'rust-sync': '//',
+    'rust-async': '//'
 }
 
 

build/components/example.py

@@ -25,18 +25,20 @@
     '.go': 'go',
     '.cs': 'c#',
     '.java': 'java',
-    '.php': 'php'
+    '.php': 'php',
+    '.rs': 'rust'
 }
 
 # Language to client name mapping (from config.toml clientsExamples)
 LANGUAGE_TO_CLIENT = {
     'python': 'Python',
     'node.js': 'Node.js',
     'go': 'Go',
-    'c#': 'C#',
+    'c#': 'C#-Sync',
     'java': 'Java-Sync',  # Default to sync, could be overridden
     'php': 'PHP',
-    'redisvl': 'RedisVL'
+    'redisvl': 'RedisVL',
+    'rust': 'Rust-Sync'
 }
 
 
@@ -65,6 +67,16 @@ def get_client_name_from_language_and_path(language: str, path: str) -> str:
             return 'Java-Async'
         if 'lettuce-reactive' in path:
             return 'Java-Reactive'
+    if language == 'rust':
+        if 'rust-async' in path:
+            return 'Rust-Async'
+        if 'rust-sync' in path:
+            return 'Rust-Sync'
+    if language == 'c#':
+        if 'async' in path:
+            return 'C#-Async'
+        if 'sync' in path:
+            return 'C#-Sync'
     # Default behavior for all languages (and Java fallback)
     return get_client_name_from_language(language)
 

build/local_examples.py

@@ -45,17 +45,17 @@ tagManagerId = "GTM-TKZ6J9R"
 gitHubRepo = "https://github.com/redis/docs"
 
 # Display and sort order for client examples
-clientsExamples = ["Python", "Node.js", "Java-Sync", "Java-Async", "Java-Reactive", "Go", "C#", "RedisVL", "PHP"]
+clientsExamples = ["Python", "Node.js", "Java-Sync", "Java-Async", "Java-Reactive", "Go", "C#-Sync", "C#-Async", "RedisVL", "PHP", "Rust-Sync", "Rust-Async"]
 searchService = "/convai/api/search-service"
-ratingsService = "/docusight/api/rate"
+ratingsService = "/docusight/api/rate/docs"
 
 # RDI params
 rdi_rlec_min_version = "6.2.18"
 rdi_redis_gears_version = "1.2.6"
 rdi_debezium_server_version = "2.3.0.Final"
 rdi_db_types = "cassandra|mysql|oracle|postgresql|sqlserver"
 rdi_cli_latest = "latest"
-rdi_current_version = "1.14.0"
+rdi_current_version = "1.14.1"
 
 [params.clientsConfig]
 "Python"={quickstartSlug="redis-py"}
@@ -64,9 +64,12 @@ rdi_current_version = "1.14.0"
 "Java-async"={quickstartSlug="lettuce"}
 "Java-reactive"={quickstartSlug="lettuce"}
 "Go"={quickstartSlug="go"}
-"C#"={quickstartSlug="dotnet"}
+"C#-Sync"={quickstartSlug="dotnet"}
+"C#-Async"={quickstartSlug="dotnet"}
 "RedisVL"={quickstartSlug="redis-vl"}
 "PHP"={quickstartSlug="php"}
+"Rust-sync"={quickstartSlug="rust"}
+"Rust-async"={quickstartSlug="rust"}
 
 # Markup
 [markup]

config.toml

@@ -47,9 +47,11 @@ title: ACL LOG
 ---
 The command shows a list of recent ACL security events:
 
-1. Failures to authenticate their connections with [`AUTH`]({{< relref "/commands/auth" >}}) or [`HELLO`]({{< relref "/commands/hello" >}}).
-2. Commands denied because against the current ACL rules.
-3. Commands denied because accessing keys not allowed in the current ACL rules.
+1. Failed authentications with [`AUTH`]({{< relref "/commands/auth" >}}) or [`HELLO`]({{< relref "/commands/hello" >}}) (reason = auth)
+2. Commands violating the current ACL rules
+   - Disallowed commands (reason = command).
+   - Disallowed keys (reason = key).
+   - Disallowed pub/sub channel (reason = channel).
 
 The optional argument specifies how many entries to show. By default
 up to ten failures are returned. The special [`RESET`]({{< relref "/commands/reset" >}}) argument clears the log.

content/commands/acl-log.md

@@ -58,6 +58,16 @@ The user should be aware that if the same existing key is mentioned in the argum
 
 ## Examples
 
+{{< clients-example set="cmds_generic" step="exists" >}}
+SET key1 "Hello"
+EXISTS key1
+EXISTS nosuchkey
+SET key2 "World"
+EXISTS key1 key2 nosuchkey
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
 {{% redis-cli %}}
 SET key1 "Hello"
 EXISTS key1