awslabs.elasticache-mcp-server 0.1.1__py3-none-any.whl

awslabs/elasticache_mcp_server/tools/rg/parsers.py

@@ -0,0 +1,268 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Parser functions for ElastiCache replication group tools."""
+
+import json
+from typing import Any, Dict
+
+
+def parse_shorthand_resharding(config: str) -> Dict[str, Any]:
+    """Parse a single resharding configuration from shorthand syntax.
+
+    Args:
+        config: Shorthand syntax string for resharding configuration
+               Format: NodeGroupId=string,NewShardConfiguration={NewReplicaCount=integer,PreferredAvailabilityZones=string1,string2}
+
+    Returns:
+        Dictionary containing the parsed resharding configuration
+
+    Raises:
+        ValueError: If the syntax is invalid
+    """
+    if not config:
+        raise ValueError('Empty resharding configuration')
+
+    result = {}
+    pairs = config.split(',')
+
+    # Define valid keys and their processors
+    key_processors = {
+        'NodeGroupId': str,
+        'NewShardConfiguration': lambda x: parse_new_shard_config(x),
+    }
+
+    for pair in pairs:
+        if '=' not in pair:
+            raise ValueError(f'Invalid format. Each parameter must be in key=value format: {pair}')
+
+        key, value = pair.split('=', 1)
+        if not key or not value:
+            raise ValueError(f'Empty key or value: {pair}')
+
+        if key not in key_processors:
+            raise ValueError(f'Invalid parameter: {key}')
+
+        try:
+            result[key] = key_processors[key](value)
+        except ValueError as e:
+            raise ValueError(f'Invalid value for {key}: {value}') from e
+
+    # Validate required fields
+    if 'NodeGroupId' not in result:
+        raise ValueError('Missing required field: NodeGroupId')
+    if 'NewShardConfiguration' not in result:
+        raise ValueError('Missing required field: NewShardConfiguration')
+
+    return result
+
+
+def parse_new_shard_config(config: str) -> Dict[str, Any]:
+    """Parse the NewShardConfiguration portion of resharding configuration.
+
+    Args:
+        config: String containing new shard configuration
+               Format: {NewReplicaCount=integer,PreferredAvailabilityZones=string1,string2}
+
+    Returns:
+        Dictionary containing the parsed new shard configuration
+
+    Raises:
+        ValueError: If the syntax is invalid
+    """
+    if not config.startswith('{') or not config.endswith('}'):
+        raise ValueError('NewShardConfiguration must be enclosed in curly braces')
+
+    # Remove curly braces
+    config = config[1:-1]
+
+    result = {}
+    pairs = config.split(',')
+
+    # Define valid keys and their processors
+    key_processors = {
+        'NewReplicaCount': int,
+        'PreferredAvailabilityZones': lambda x: x.split(','),
+    }
+
+    for pair in pairs:
+        if '=' not in pair:
+            raise ValueError(f'Invalid format. Each parameter must be in key=value format: {pair}')
+
+        key, value = pair.split('=', 1)
+        if not key or not value:
+            raise ValueError(f'Empty key or value: {pair}')
+
+        if key not in key_processors:
+            raise ValueError(f'Invalid parameter: {key}')
+
+        try:
+            result[key] = key_processors[key](value)
+        except ValueError as e:
+            raise ValueError(f'Invalid value for {key}: {value}') from e
+
+    # Validate required fields
+    if 'NewReplicaCount' not in result:
+        raise ValueError('Missing required field: NewReplicaCount')
+
+    return result
+
+
+def parse_shorthand_nodegroup(group: str) -> Dict[str, Any]:
+    """Parse a single nodegroup from shorthand syntax.
+
+    Args:
+        group: Shorthand syntax string for a nodegroup
+
+    Returns:
+        Dictionary containing the parsed nodegroup configuration
+
+    Raises:
+        ValueError: If the syntax is invalid
+    """
+    if not group:
+        raise ValueError('Empty nodegroup configuration')
+
+    config = {}
+
+    # Define valid keys
+    valid_keys = {
+        'NodeGroupId',
+        'Slots',
+        'ReplicaCount',
+        'PrimaryAvailabilityZone',
+        'ReplicaAvailabilityZones',
+        'PrimaryOutpostArn',
+        'ReplicaOutpostArns',
+    }
+
+    # Define keys that should be treated as arrays
+    array_keys = {'ReplicaAvailabilityZones', 'ReplicaOutpostArns'}
+
+    # Split into key-value pairs
+    pairs = group.split(',')
+    current_key = None
+    current_values = []
+
+    for pair in pairs:
+        pair = pair.strip()
+
+        # If this part contains an equals sign, it's a new key-value pair
+        if '=' in pair:
+            # Save any previous array values
+            if current_key in array_keys and current_values:
+                config[current_key] = current_values
+                current_values = []
+
+            key, value = pair.split('=', 1)
+            key = key.strip()
+            value = value.strip()
+
+            if not key or not value:
+                raise ValueError(f'Empty key or value: {pair}')
+
+            if key not in valid_keys:
+                raise ValueError(f'Invalid parameter: {key}')
+
+            current_key = key
+
+            try:
+                if key == 'ReplicaCount':
+                    config[key] = int(value)
+                elif key in array_keys:
+                    current_values = [value]
+                else:
+                    config[key] = value
+            except ValueError as e:
+                raise ValueError(f'Invalid value for {key}: {value}') from e
+
+        # If no equals sign and we're in an array key context, treat as array value
+        elif current_key in array_keys:
+            current_values.append(pair)
+        else:
+            raise ValueError(f'Invalid format. Each parameter must be in key=value format: {pair}')
+
+    # Handle any remaining array values
+    if current_key in array_keys and current_values:
+        config[current_key] = current_values
+
+    # Validate required fields
+    if 'NodeGroupId' not in config:
+        raise ValueError('Missing required field: NodeGroupId')
+
+    return config
+
+
+def parse_shorthand_log_delivery(config: str) -> Dict[str, Any]:
+    """Parse a single log delivery configuration from shorthand syntax.
+
+    Args:
+        config: Shorthand syntax string for log delivery configuration
+
+    Returns:
+        Dictionary containing the parsed log delivery configuration
+
+    Raises:
+        ValueError: If the syntax is invalid
+    """
+    if not config:
+        raise ValueError('Empty log delivery configuration')
+
+    result = {}
+    pairs = config.split(',')
+
+    # Define valid keys and their processors
+    key_processors = {
+        'LogType': str,
+        'DestinationType': str,
+        'DestinationDetails': lambda x: json.loads(x.replace("'", '"')),
+        'LogFormat': str,
+        'Enabled': lambda x: x.lower() == 'true',
+    }
+
+    for pair in pairs:
+        if '=' not in pair:
+            raise ValueError(f'Invalid format. Each parameter must be in key=value format: {pair}')
+
+        key, value = pair.split('=', 1)
+        if not key or not value:
+            raise ValueError(f'Empty key or value: {pair}')
+
+        if key not in key_processors:
+            raise ValueError(f'Invalid parameter: {key}')
+
+        try:
+            result[key] = key_processors[key](value)
+        except ValueError as e:
+            raise ValueError(f'Invalid value for {key}: {value}') from e
+
+    # Validate required fields
+    required_fields = ['LogType', 'DestinationType', 'DestinationDetails', 'LogFormat', 'Enabled']
+    missing_fields = [field for field in required_fields if field not in result]
+    if missing_fields:
+        raise ValueError(f'Missing required fields: {", ".join(missing_fields)}')
+
+    # Validate LogType
+    if result['LogType'] not in ['slow-log', 'engine-log']:
+        raise ValueError("LogType must be either 'slow-log' or 'engine-log'")
+
+    # Validate DestinationType
+    if result['DestinationType'] not in ['cloudwatch-logs', 'kinesis-firehose']:
+        raise ValueError("DestinationType must be either 'cloudwatch-logs' or 'kinesis-firehose'")
+
+    # Validate LogFormat
+    if result['LogFormat'] not in ['text', 'json']:
+        raise ValueError("LogFormat must be either 'text' or 'json'")
+
+    return result

awslabs/elasticache_mcp_server/tools/rg/processors.py

@@ -0,0 +1,227 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Processor functions for ElastiCache replication group tools."""
+
+from .parsers import (
+    parse_shorthand_log_delivery,
+    parse_shorthand_nodegroup,
+    parse_shorthand_resharding,
+)
+from typing import Dict, List, Union
+
+
+def process_resharding_configuration(
+    resharding_configuration: Union[str, List[Dict]],
+) -> List[Dict]:
+    """Process resharding configuration in either shorthand or JSON format.
+
+    Args:
+        resharding_configuration: Resharding configuration in either format
+            Shorthand format: "NodeGroupId=string,NewShardConfiguration={NewReplicaCount=integer,PreferredAvailabilityZones=string1,string2}"
+            Multiple configurations can be separated by spaces.
+            JSON format: List of dictionaries with required fields:
+            - NodeGroupId: string
+            - NewShardConfiguration:
+                - NewReplicaCount: integer
+                - PreferredAvailabilityZones: list of strings (optional)
+
+    Returns:
+        List of processed resharding configurations
+
+    Raises:
+        ValueError: If the configuration is invalid
+    """
+    processed_configs = []
+
+    if isinstance(resharding_configuration, str):
+        # Parse shorthand syntax
+        configs = resharding_configuration.split(' ')
+        for config in configs:
+            if not config:
+                continue
+            try:
+                parsed_config = parse_shorthand_resharding(config)
+                processed_configs.append(parsed_config)
+            except ValueError as e:
+                raise ValueError(f'Invalid resharding shorthand syntax: {str(e)}')
+    else:
+        # Handle JSON format
+        if not isinstance(resharding_configuration, list):
+            raise ValueError(
+                'Resharding configuration must be a list of dictionaries or a shorthand string'
+            )
+
+        for config in resharding_configuration:
+            if not isinstance(config, dict):
+                raise ValueError('Each resharding configuration must be a dictionary')
+
+            # Validate required fields
+            if 'NodeGroupId' not in config:
+                raise ValueError('Missing required field: NodeGroupId')
+            if 'NewShardConfiguration' not in config:
+                raise ValueError('Missing required field: NewShardConfiguration')
+
+            # Validate NewShardConfiguration
+            new_shard = config['NewShardConfiguration']
+            if not isinstance(new_shard, dict):
+                raise ValueError('NewShardConfiguration must be a dictionary')
+            if 'NewReplicaCount' not in new_shard:
+                raise ValueError(
+                    'Missing required field: NewReplicaCount in NewShardConfiguration'
+                )
+            if not isinstance(new_shard['NewReplicaCount'], int):
+                raise ValueError('NewReplicaCount must be an integer')
+
+            # Validate PreferredAvailabilityZones if present
+            if 'PreferredAvailabilityZones' in new_shard:
+                if not isinstance(new_shard['PreferredAvailabilityZones'], list):
+                    raise ValueError('PreferredAvailabilityZones must be a list of strings')
+                for zone in new_shard['PreferredAvailabilityZones']:
+                    if not isinstance(zone, str):
+                        raise ValueError('Each availability zone must be a string')
+
+            processed_configs.append(config)
+
+    return processed_configs
+
+
+def process_log_delivery_configurations(
+    log_delivery_configurations: Union[str, List[Dict]],
+) -> List[Dict]:
+    """Process log delivery configurations in either shorthand or JSON format.
+
+    Args:
+        log_delivery_configurations: Log delivery configurations in either format
+
+    Returns:
+        List of processed log delivery configurations
+
+    Raises:
+        ValueError: If the configuration is invalid
+    """
+    processed_configs = []
+
+    if isinstance(log_delivery_configurations, str):
+        # Parse shorthand syntax
+        configs = log_delivery_configurations.split(' ')
+        for config in configs:
+            if not config:
+                continue
+            try:
+                parsed_config = parse_shorthand_log_delivery(config)
+                processed_configs.append(parsed_config)
+            except ValueError as e:
+                raise ValueError(f'Invalid log delivery shorthand syntax: {str(e)}')
+    else:
+        # Handle JSON format
+        if not isinstance(log_delivery_configurations, list):
+            raise ValueError(
+                'Log delivery configurations must be a list of dictionaries or a shorthand string'
+            )
+
+        for config in log_delivery_configurations:
+            if not isinstance(config, dict):
+                raise ValueError('Each log delivery configuration must be a dictionary')
+
+            # Validate required fields and types
+            required_fields = {
+                'LogType': ['slow-log', 'engine-log'],
+                'DestinationType': ['cloudwatch-logs', 'kinesis-firehose'],
+                'DestinationDetails': dict,
+                'LogFormat': ['text', 'json'],
+                'Enabled': bool,
+            }
+
+            for field, valid_values in required_fields.items():
+                if field not in config:
+                    raise ValueError(f'Missing required field: {field}')
+
+                if field in ['LogType', 'DestinationType', 'LogFormat']:
+                    if config[field] not in valid_values:
+                        raise ValueError(f'{field} must be one of {valid_values}')
+                elif field == 'DestinationDetails':
+                    if not isinstance(config[field], valid_values):
+                        raise ValueError(f'{field} must be a dictionary')
+                elif field == 'Enabled':
+                    if not isinstance(config[field], valid_values):
+                        raise ValueError(f'{field} must be a boolean')
+
+            processed_configs.append(config)
+
+    return processed_configs
+
+
+def process_nodegroup_configuration(
+    node_group_configuration: Union[str, List[Dict]],
+) -> List[Dict]:
+    """Process nodegroup configuration in either shorthand or JSON format.
+
+    Args:
+        node_group_configuration: Nodegroup configuration in either format
+
+    Returns:
+        List of processed nodegroup configurations
+
+    Raises:
+        ValueError: If the configuration is invalid
+    """
+    processed_config = []
+
+    if isinstance(node_group_configuration, str):
+        # Parse shorthand syntax
+        groups = node_group_configuration.split(' ')
+        for group in groups:
+            if not group:
+                continue
+            try:
+                config = parse_shorthand_nodegroup(group)
+                processed_config.append(config)
+            except ValueError as e:
+                raise ValueError(f'Invalid nodegroup shorthand syntax: {str(e)}')
+    else:
+        # Handle JSON format
+        if not isinstance(node_group_configuration, list):
+            raise ValueError(
+                'Node group configuration must be a list of dictionaries or a shorthand string'
+            )
+
+        for config in node_group_configuration:
+            if not isinstance(config, dict):
+                raise ValueError('Each node group configuration must be a dictionary')
+
+            # Validate required fields
+            if 'NodeGroupId' not in config:
+                raise ValueError('Missing required field: NodeGroupId')
+
+            # Process the configuration
+            processed_item = {}
+            for k, v in config.items():
+                if k == 'ReplicaCount':
+                    try:
+                        processed_item[k] = int(v)
+                    except (ValueError, TypeError):
+                        raise ValueError(f'ReplicaCount must be an integer: {v}')
+                elif k in ['ReplicaAvailabilityZones', 'ReplicaOutpostArns']:
+                    if isinstance(v, str):
+                        processed_item[k] = v.split(',')
+                    elif isinstance(v, list):
+                        processed_item[k] = v
+                    else:
+                        raise ValueError(f'{k} must be a string or list of strings')
+                else:
+                    processed_item[k] = v
+            processed_config.append(processed_item)
+
+    return processed_config

awslabs/elasticache_mcp_server/tools/rg/start_migration.py

@@ -0,0 +1,151 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Start migration tool for ElastiCache MCP server."""
+
+from ...common.connection import ElastiCacheConnectionManager
+from ...common.decorators import handle_exceptions
+from ...common.server import mcp
+from ...context import Context
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, Dict, List, Union
+
+
+class CustomerNodeEndpoint(BaseModel):
+    """Customer node endpoint model."""
+
+    Address: str = Field(..., description='The address of the node endpoint')
+    Port: int = Field(..., description='The port of the node endpoint')
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+
+class StartMigrationRequest(BaseModel):
+    """Request model for starting migration to an ElastiCache replication group."""
+
+    model_config = ConfigDict(validate_by_name=True, arbitrary_types_allowed=True)
+
+    replication_group_id: str = Field(
+        ..., description='The ID of the replication group to which data should be migrated'
+    )
+    customer_node_endpoint_list: Union[str, List[CustomerNodeEndpoint]] = Field(
+        ...,
+        description='List of endpoints from which data should be migrated. For Valkey or Redis OSS (cluster mode disabled), the list should have only one element.',
+    )
+
+
+def prepare_request_dict(request: StartMigrationRequest) -> Dict[str, Any]:
+    """Prepare the request dictionary for the AWS API.
+
+    Args:
+        request: The StartMigrationRequest object
+
+    Returns:
+        Dict containing the properly formatted request parameters
+    """
+    # Start with required parameters
+    start_migration_request: Dict[str, Any] = {
+        'ReplicationGroupId': request.replication_group_id,
+    }
+
+    # Process customer node endpoint list
+    if isinstance(request.customer_node_endpoint_list, str):
+        # Parse shorthand syntax: Address=string,Port=integer
+        try:
+            pairs = [
+                p.strip() for p in request.customer_node_endpoint_list.split(',') if p.strip()
+            ]
+            endpoint = {}
+            for pair in pairs:
+                if '=' not in pair:
+                    raise ValueError(
+                        'Invalid endpoint format. Each parameter must be in key=value format'
+                    )
+                key, value = pair.split('=', 1)
+                key = key.strip()
+                value = value.strip()
+                if not key or not value:
+                    raise ValueError('Key or value cannot be empty')
+
+                if key == 'Address':
+                    endpoint['Address'] = value
+                elif key == 'Port':
+                    try:
+                        endpoint['Port'] = int(value)
+                    except ValueError:
+                        raise ValueError(f'Port must be an integer: {value}')
+                else:
+                    raise ValueError(f'Invalid parameter: {key}')
+
+            # Validate required fields
+            if 'Address' not in endpoint:
+                raise ValueError('Missing required field: Address')
+            if 'Port' not in endpoint:
+                raise ValueError('Missing required field: Port')
+
+            start_migration_request['CustomerNodeEndpointList'] = [endpoint]
+        except Exception as e:
+            raise ValueError(
+                f'Invalid endpoint shorthand syntax. Expected format: Address=string,Port=integer. Error: {str(e)}'
+            )
+    elif isinstance(request.customer_node_endpoint_list, list):
+        # Handle list format
+        if len(request.customer_node_endpoint_list) < 1:
+            raise ValueError('CustomerNodeEndpointList should have at least one element')
+
+        endpoints = [
+            endpoint.model_dump(exclude_none=True)
+            for endpoint in request.customer_node_endpoint_list
+        ]
+        start_migration_request['CustomerNodeEndpointList'] = endpoints
+    else:
+        raise ValueError(
+            'CustomerNodeEndpointList must be a string or a list with at least one element'
+        )
+
+    return start_migration_request
+
+
+@mcp.tool(name='start-migration')
+@handle_exceptions
+async def start_migration(request: StartMigrationRequest) -> Dict:
+    """Start migration to an Amazon ElastiCache replication group.
+
+    This tool starts migration from a Redis instance to an ElastiCache replication group.
+    It initiates the data migration process from the specified endpoint(s) to
+    the target replication group.
+
+    Args:
+        request: The StartMigrationRequest object containing:
+            - replication_group_id: The ID of the replication group to which data should be migrated
+            - customer_node_endpoint_list: List of endpoints from which data should be migrated.
+              For Valkey or Redis OSS (cluster mode disabled), the list should have only one element.
+
+    Returns:
+        Dict containing information about the migration start result.
+    """
+    # Check if readonly mode is enabled
+    if Context.readonly_mode():
+        raise ValueError(
+            'You have configured this tool in readonly mode. To make this change you will have to update your configuration.'
+        )
+
+    # Get ElastiCache client
+    elasticache_client = ElastiCacheConnectionManager.get_connection()
+
+    # Prepare request dictionary
+    start_request = prepare_request_dict(request)
+
+    # Start the migration
+    response = elasticache_client.start_migration(**start_request)
+    return response