clear-skies-aws 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

clearskies_aws/contexts/lambda_sqs_standard.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import traceback
+from typing import Any
+
+from clearskies.authentication import Public
+from clearskies.contexts.context import Context
+
+from clearskies_aws.input_outputs import LambdaSqsStandard as LambdaSqsStandardInputOutput
+
+
+class LambdaSqsStandard(Context):
+    """
+    Process messages from an SQS Standard Queue with Lambda.
+
+    Use this context when your application lives in a Lambda and is attached to an SQS standard
+    queue.  Lambda always uses batch processing in this case, and will invoke your clearskies application
+    with a batch of messags.  This clearskies context will then in turn invoke your application once
+    for every batched message.  As a result, `request_data` will contain the contents of an individual message
+    from the queue, rather than the original group of batched events from Lambda.  If any exception is thrown,
+    every other message in the queue will still be sent to your application, and clearskies will inform
+    AWS that the message and question failed to process.
+
+    ### Usage
+
+    Here's a very simple example:
+
+    ```
+    import clearskies
+
+
+    def some_function(request_data):
+        return print(request_data)
+
+
+    lambda_sqs = clearskies_aws.contexts.LambdaSqsStandard(
+        clearskies.endpoints.Callable(
+            some_function,
+        ),
+    )
+
+
+    def lambda_handler(event, context):
+        return lambda_sqs(event, context)
+    ```
+
+    `lambda_handler` would then be attached to your lambda function, which is attached to some standard SQS.
+
+    Like the other lambda contexts which don't exist in an HTTP world, you can also attach a clearskies application
+    with routing and hard-code the path to invoke inside the lambda handler itself.  This is handy if you have
+    a few related lambdas with similar configuration (since you only have to build a single application) or if
+    you have an application that already exists and you want to invoke some specific endpoint with an SQS:
+
+    ```
+    import clearskies
+
+
+    def some_function(request_data):
+        return request_data
+
+
+    def some_other_function(request_data):
+        return request_data
+
+
+    def something_else(request_data):
+        return request_data
+
+
+    lambda_invoke = clearskies_aws.contexts.LambdaSqsStandard(
+        clearskies.endpoints.EndpointGroup(
+            [
+                clearskies.endpoints.Callable(
+                    some_function,
+                    url="some_function",
+                ),
+                clearskies.endpoints.Callable(
+                    some_other_function,
+                    url="some_other_function",
+                ),
+                clearskies.endpoints.Callable(
+                    something_else,
+                    url="something_else",
+                ),
+            ]
+        )
+    )
+
+
+    def some_function_handler(event, context):
+        return lambda_invoke(event, context, url="some_function")
+
+
+    def some_other_function_handler(event, context):
+        return lambda_invoke(event, context, url="some_other_function")
+
+
+    def something_else_handler(event, context):
+        return lambda_invoke(event, context, url="something_else")
+    ```
+
+    ### Context Specifics
+
+    When using this context, the following named parameters become available to inject into any callable
+    invoked by clearskies:
+
+    ```
+    |             Name            |       Type       | Description                                            |
+    |:---------------------------:|:----------------:|--------------------------------------------------------|
+    |           `event`           | `dict[str, Any]` | The lambda `event` object                              |
+    |          `context`          | `dict[str, Any]` | The lambda `context` object                            |
+    |         `message_id`        |       `str`      | The AWS message id                                     |
+    |       `receipt_handle`      |       `str`      | The receipt handle                                     |
+    |         `source_arn`        |       `str`      | The ARN of the SQS the lambda is receiving events from |
+    |       `sent_timestamp`      |       `str`      | The timestamp when the message was sent                |
+    | `approximate_receive_count` |       `str`      | The approximate receive count                          |
+    |     `message_attributes`    | `dict[str, Any]` | The message attributes                                 |
+    |           `record`          | `dict[str, Any]` | The full record of the message being processed         |
+    ```
+
+    """
+
+    def __call__(  # type: ignore[override]
+        self, event: dict[str, Any], context: dict[str, Any], url: str = "", request_method: str = ""
+    ) -> dict[str, Any]:
+        item_failures = []
+        for record in event["Records"]:
+            try:
+                self.execute_application(
+                    LambdaSqsStandardInputOutput(record, event, context, url=url, request_method=request_method)
+                )
+            except Exception as e:
+                item_failures.append({"itemIdentifier": record["messageId"]})
+
+        if item_failures:
+            return {
+                "batchItemFailures": item_failures,
+            }
+        return {}

clearskies_aws/cursors/__init__.py

@@ -0,0 +1,3 @@
+from clearskies_aws.cursors import iam, port_forwarding
+
+__all__ = ["iam", "port_forwarding"]

clearskies_aws/cursors/iam/__init__.py

@@ -0,0 +1,7 @@
+import logging
+
+from clearskies_aws.cursors.iam.rds_mysql import RdsMySql
+
+logging.getLogger(__name__)
+
+__all__ = ["RdsMySql", "MysqlWithSSM"]

clearskies_aws/cursors/iam/rds_mysql.py

@@ -0,0 +1,125 @@
+"""
+RdsMySql: MySQL cursor with AWS RDS IAM authentication.
+
+This class provides a MySQL cursor that uses AWS RDS IAM DB authentication.
+It loads connection parameters from environment variables and generates a temporary
+IAM authentication token for secure database access.
+
+Configuration fields:
+    - boto3: Injected boto3 provider for AWS API access.
+    - environment: Injected environment variable provider.
+    - hostname_environment_key: Environment variable for DB host (default: "DATABASE_HOST").
+    - username_environment_key: Environment variable for DB user (default: "DATABASE_USERNAME").
+    - database_environment_key: Environment variable for DB name (default: "DATABASE_NAME").
+    - port_environment_key: Environment variable for DB port (default: "DATABASE_PORT").
+    - cert_path_environment_key: Environment variable for SSL CA cert (default: "DATABASE_CERT_PATH").
+    - autocommit_environment_key: Environment variable for autocommit (default: "DATABASE_AUTOCOMMIT").
+    - connect_timeout_environment_key: Environment variable for connect timeout (default: "DATABASE_CONNECT_TIMEOUT").
+    - database_region_key: Environment variable for AWS region (default: "DATABASE_REGION").
+
+Example:
+    import clearskies_aws.cursors.iam.rds_mysql
+
+    cursor = clearskies_aws.cursors.iam.rds_mysql.RdsMySql()
+    cursor.execute("SELECT 1")
+"""
+
+import os
+from typing import Any
+
+import clearskies
+from clearskies import decorators
+from clearskies.cursors import Mysql as MysqlBase
+
+from clearskies_aws.di import inject
+
+
+class RdsMySql(MysqlBase):
+    """MySQL cursor with AWS RDS IAM DB authentication."""
+
+    """Injected boto3 provider for AWS API access."""
+    boto3 = inject.Boto3()
+
+    """Injected environment variable provider."""
+    environment = clearskies.di.inject.Environment()
+
+    """Environment variable for DB host (default: "DATABASE_HOST")."""
+    hostname_environment_key = clearskies.configs.String(default="DATABASE_HOST")
+
+    """Environment variable for DB user (default: "DATABASE_USERNAME")."""
+    username_environment_key = clearskies.configs.String(default="DATABASE_USERNAME")
+
+    """Environment variable for DB name (default: "DATABASE_NAME")."""
+    database_environment_key = clearskies.configs.String(default="DATABASE_NAME")
+
+    """Environment variable for DB port (default: "DATABASE_PORT")."""
+    port_environment_key = clearskies.configs.String(default="DATABASE_PORT")
+
+    """Environment variable for SSL CA cert (default: "DATABASE_CERT_PATH")."""
+    cert_path_environment_key = clearskies.configs.String(default="DATABASE_CERT_PATH")
+
+    """Environment variable for autocommit (default: "DATABASE_AUTOCOMMIT")."""
+    autocommit_environment_key = clearskies.configs.String(default="DATABASE_AUTOCOMMIT")
+
+    """Environment variable for connect timeout (default: "DATABASE_CONNECT_TIMEOUT")."""
+    connect_timeout_environment_key = clearskies.configs.String(default="DATABASE_CONNECT_TIMEOUT")
+
+    """Environment variable for AWS region (default: "DATABASE_REGION")."""
+    database_region_key = clearskies.configs.String(default="DATABASE_REGION")
+
+    @decorators.parameters_to_properties
+    def __init__(
+        self,
+        hostname_environment_key: str | None = None,
+        username_environment_key: str | None = None,
+        database_environment_key: str | None = None,
+        port_environment_key: str | None = None,
+        cert_path_environment_key: str | None = None,
+        autocommit_environment_key: str | None = None,
+        database_region_key: str | None = None,
+        connect_timeout_environment_key: str | None = None,
+        port_forwarding: Any | None = None,
+    ):
+        self.finalize_and_validate_configuration()
+
+    def build_connection_kwargs(self) -> dict:
+        """
+        Build the connection kwargs for the MySQL client, using IAM DB authentication.
+
+        Returns
+        -------
+        dict
+            Connection parameters for the MySQL client.
+        """
+        connection_kwargs = {
+            "user": self.environment.get(self.username_environment_key),
+            "host": self.environment.get(self.hostname_environment_key),
+            "database": self.environment.get(self.database_environment_key),
+            "port": int(self.environment.get(self.port_environment_key, silent=True) or self.port),
+            "ssl_ca": self.environment.get(self.cert_path_environment_key, silent=True),
+            "autocommit": self.environment.get(self.autocommit_environment_key, silent=True),
+            "connect_timeout": int(
+                self.environment.get(self.connect_timeout_environment_key, silent=True) or self.connect_timeout
+            ),
+        }
+        region: str = self.environment.get(self.database_region_key, True) or self.environment.get("AWS_REGION", True)
+        if not region:
+            raise ValueError(
+                "To use RDS IAM DB auth you must set DATABASE_REGION or AWS_REGION in the .env file or an environment variable"
+            )
+        os.environ["LIBMYSQL_ENABLE_CLEARTEXT_PLUGIN"] = "1"
+
+        rds_api = self.boto3.Session().client("rds")
+        rds_token = rds_api.generate_db_auth_token(
+            DBHostname=connection_kwargs.get("host"),
+            Port=connection_kwargs.get("port", 3306),
+            DBUsername=connection_kwargs.get("user"),
+            Region=region,
+        )
+        connection_kwargs["password"] = rds_token
+
+        for kwarg in ["autocommit", "connect_timeout", "port", "ssl_ca"]:
+            if not connection_kwargs[kwarg]:
+                del connection_kwargs[kwarg]
+
+        return {**super().build_connection_kwargs(), **connection_kwargs}

clearskies_aws/cursors/port_forwarding/__init__.py

@@ -0,0 +1,3 @@
+from clearskies_aws.cursors.port_forwarding.ssm import Ssm
+
+__all__ = ["Ssm"]

clearskies_aws/di/aws_additional_config_auto_import.py

@@ -17,7 +17,7 @@ class AwsAdditionalConfigAutoImport(AdditionalConfigAutoImport):
     This DI auto injects boto3, boto3 Session and the parameter store.
     """
 
-    def provide_boto3(self) -> ModuleType:
+    def provide_boto3_sdk(self) -> ModuleType:
         import boto3
 
         return boto3

clearskies_aws/di/inject/boto3.py

@@ -12,4 +12,4 @@ class Boto3(Injectable):
     def __get__(self, instance, parent) -> ModuleType:
         if instance is None:
             return self  # type: ignore
-        return self._di.build_from_name("boto3", cache=self.cache)
+        return self._di.build_from_name("boto3_sdk", cache=self.cache)

clearskies_aws/endpoints/__init__.py

@@ -1,2 +1 @@
 from .secrets_manager_rotation import SecretsManagerRotation
-from .simple_body_routing import SimpleBodyRouting

clearskies_aws/endpoints/secrets_manager_rotation.py

@@ -19,7 +19,6 @@ from clearskies_aws.di import inject
 
 
 class SecretsManagerRotation(Endpoint):
-
     di = Di()
     boto3 = inject.Boto3()
 
@@ -92,7 +91,7 @@ class SecretsManagerRotation(Endpoint):
             pending_secret_data = json.loads(pending_secret["SecretString"])
         except botocore.exceptions.ClientError as error:
             if error.response["Error"]["Code"] == "ResourceNotFoundException":
-                pending_secret_data = None
+                pending_secret_data = {}
             else:
                 raise error
 

clearskies_aws/input_outputs/__init__.py

@@ -6,7 +6,7 @@ from clearskies_aws.input_outputs.lambda_api_gateway import LambdaApiGateway
 from clearskies_aws.input_outputs.lambda_api_gateway_web_socket import (
     LambdaApiGatewayWebSocket,
 )
-from clearskies_aws.input_outputs.lambda_invocation import LambdaInvocation
+from clearskies_aws.input_outputs.lambda_invoke import LambdaInvoke
 from clearskies_aws.input_outputs.lambda_sns import LambdaSns
 from clearskies_aws.input_outputs.lambda_sqs_standard import LambdaSqsStandard
 
@@ -15,7 +15,7 @@ __all__ = [
     "LambdaApiGateway",
     "LambdaApiGatewayWebSocket",
     "LambdaAlb",
-    "LambdaInvocation",
+    "LambdaInvoke",
     "LambdaSns",
     "LambdaSqsStandard",
 ]

clearskies_aws/input_outputs/cli_web_socket_mock.py

@@ -15,4 +15,6 @@ class CliWebSocketMock(clearskies.input_outputs.Cli):
             "event": {},
             "context": {},
             "connection_id": connection_id,
+            "domain": "",
+            "stage": "",
         }

clearskies_aws/input_outputs/lambda_api_gateway_web_socket.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from typing import Any
 
 from clearskies.configs import String
@@ -24,7 +25,7 @@ class LambdaApiGatewayWebSocket(lambda_input_output.LambdaInputOutput):
         request_context = event.get("requestContext", {})
 
         # WebSocket uses route_key, but doesn't have either a route or a method
-        self.route_key = request_context.get("routeKey", "")
+        self.route_key = request_context.get("routeKey", "GET")
         self.request_method = self.route_key.upper()  # For compatibility
 
         # WebSocket connection ID
@@ -47,12 +48,13 @@ class LambdaApiGatewayWebSocket(lambda_input_output.LambdaInputOutput):
 
         raise ValueError("Unable to find the client ip inside the API Gateway")
 
-    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any]:
-        """Create WebSocket specific response format."""
-        # WebSocket responses are simpler than HTTP responses
-        return {
-            "statusCode": status_code,
-        }
+    def respond(self, body: Any, status_code: int = 200) -> None:
+        # since there is no response to the client, we want to raise an exception for any non-200 status code so
+        # the lambda execution itself will be marked as a failure.
+        if status_code > 299:
+            if not isinstance(body, str):
+                body = json.dumps(body)
+            raise Exception(f"Non-200 Status code returned by application: {status_code}.  Response: '{body}'")
 
     def context_specifics(self) -> dict[str, Any]:
         """Provide WebSocket specific context data."""

clearskies_aws/input_outputs/lambda_input_output.py

@@ -20,7 +20,9 @@ class LambdaInputOutput(InputOutput):
     _cached_body = None
     _body_was_cached = False
 
-    def __init__(self, event: dict[str, Any], context: dict[str, Any]):
+    def __init__(
+        self, event: dict[str, Any], context: dict[str, Any], url: str | None = "", request_method: str | None = ""
+    ):
         # Store event and context
         self.event = event
         self.context = context
@@ -28,7 +30,7 @@ class LambdaInputOutput(InputOutput):
         # Initialize the base class
         super().__init__()
 
-    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any]:
+    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any] | None:
         """Create standard Lambda HTTP response format."""
         if "content-type" not in self.response_headers:
             self.response_headers.content_type = "application/json; charset=UTF-8"

clearskies_aws/input_outputs/{lambda_invocation.py → lambda_invoke.py}

@@ -9,25 +9,28 @@ from clearskies.input_outputs import Headers
 from clearskies_aws.input_outputs import lambda_input_output
 
 
-class LambdaInvocation(lambda_input_output.LambdaInputOutput):
+class LambdaInvoke(lambda_input_output.LambdaInputOutput):
     """Direct Lambda invocation specific input/output handler."""
 
     def __init__(
         self,
         event: dict[str, Any],
         context: dict[str, Any],
-        method: str = "POST",
+        request_method: str = "",
         url: str = "",
     ):
         # Call parent constructor
         super().__init__(event, context)
 
         # Direct invocation specific initialization
-        self.path = url
-        self.request_method = method.upper()
-
-        # Direct invocations don't have query parameters or path parameters
-        self.query_parameters = {}
+        if url:
+            self.path = url
+        else:
+            self.supports_url = True
+        if request_method:
+            self.request_method = request_method.upper()
+        else:
+            self.supports_request_method = False
 
         # Direct invocations don't have headers
         self.request_headers = Headers({})

clearskies_aws/input_outputs/lambda_sns.py

@@ -12,16 +12,21 @@ from clearskies_aws.input_outputs import lambda_input_output
 class LambdaSns(lambda_input_output.LambdaInputOutput):
     """SNS specific Lambda input/output handler."""
 
-    def __init__(self, event: dict, context: dict[str, Any], url: str = "", method: str = "POST"):
+    record: dict[str, Any]
+
+    def __init__(self, event: dict, context: dict[str, Any], url: str = "", request_method: str = ""):
         # Call parent constructor
         super().__init__(event, context)
 
         # SNS specific initialization
-        self.path = url
-        self.request_method = method.upper()
-
-        # SNS events don't have query parameters or path parameters
-        self.query_parameters = {}
+        if url:
+            self.path = url
+        else:
+            self.supports_url = False
+        if request_method:
+            self.request_method = request_method.upper()
+        else:
+            self.supports_request_method = False
 
         # SNS events don't have headers
         self.request_headers = Headers({})
@@ -29,24 +34,29 @@ class LambdaSns(lambda_input_output.LambdaInputOutput):
         # Extract SNS message from event
         try:
             record = event["Records"][0]["Sns"]["Message"]
-            self._record = json.loads(record)
+            self.record = json.loads(record)
         except (KeyError, IndexError, json.JSONDecodeError) as e:
             raise ClientError(
                 "The message from AWS was not a valid SNS event with serialized JSON. "
                 "The lambda_sns context for clearskies only accepts serialized JSON."
             )
 
-    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any]:
-        """SNS events don't return responses."""
-        return {}
+    def respond(self, body: Any, status_code: int = 200) -> None:
+        """Respond to the client, but SNS has no client."""
+        # since there is no response to the client, we want to raise an exception for any non-200 status code so
+        # the lambda execution itself will be marked as a failure.
+        if status_code > 299:
+            if not isinstance(body, str):
+                body = json.dumps(body)
+            raise Exception(f"Non-200 Status code returned by application: {status_code}.  Response: '{body}'")
 
     def get_body(self) -> str:
         """Get the SNS message as a JSON string."""
-        return json.dumps(self._record) if self._record else ""
+        return json.dumps(self.record) if self.record else ""
 
     def has_body(self) -> bool:
         """Check if SNS message exists."""
-        return bool(self._record)
+        return bool(self.record)
 
     def get_client_ip(self) -> str:
         """SNS events don't have client IP information."""
@@ -66,14 +76,13 @@ class LambdaSns(lambda_input_output.LambdaInputOutput):
 
         return {
             **super().context_specifics(),
-            "sns_message_id": sns_record.get("MessageId"),
-            "sns_topic_arn": sns_record.get("TopicArn"),
-            "sns_subject": sns_record.get("Subject"),
-            "sns_timestamp": sns_record.get("Timestamp"),
-            "sns_message": self._record,
+            "message_id": sns_record.get("MessageId"),
+            "topic_arn": sns_record.get("TopicArn"),
+            "subject": sns_record.get("Subject"),
+            "timestamp": sns_record.get("Timestamp"),
         }
 
     @property
     def request_data(self) -> dict[str, Any] | list[Any] | None:
         """Return the SNS message data directly."""
-        return self._record
+        return self.record

clearskies_aws/input_outputs/lambda_sqs_standard.py

@@ -17,31 +17,44 @@ class LambdaSqsStandard(lambda_input_output.LambdaInputOutput):
     path = String(default="/")
 
     def __init__(
-        self, record: str, event: dict[str, Any], context: dict[str, Any], url: str = "", method: str = "POST"
+        self,
+        record: dict[str, Any],
+        event: dict[str, Any],
+        context: dict[str, Any],
+        url: str = "",
+        request_method: str = "",
     ):
         # Call parent constructor with the full event
         super().__init__(event, context)
 
         # Store the individual SQS record
-        self.record = json.loads(record)
-        print("SQS record:", self.record)
+        self.record = record
         # SQS specific initialization
-        self.path = url if url else "/"
-        self.request_method = method.upper() if method else "POST"
+        if url:
+            self.path = url
+        else:
+            self.supports_url = False
 
-        # SQS events don't have query parameters or path parameters
-        self.query_parameters = {}
+        if request_method:
+            self.request_method = request_method.upper()
+        else:
+            self.supports_request_method = False
 
         # SQS events don't have headers
         self.request_headers = Headers({})
 
-    def respond(self, body: Any, status_code: int = 200) -> dict[str, Any]:
-        """SQS events don't return responses."""
-        return {}
+    def respond(self, body: Any, status_code: int = 200) -> None:
+        """Respond to the client, but SQS has no client."""
+        # since there is no response to the client, we want to raise an exception for any non-200 status code so
+        # the lambda execution itself will be marked as a failure.
+        if status_code > 299:
+            if not isinstance(body, str):
+                body = json.dumps(body)
+            raise Exception(f"Non-200 Status code returned by application: {status_code}.  Response: '{body}'")
 
     def get_body(self) -> str:
-        """Get the SQS message body."""
-        return json.dumps(self.record)
+        """Get request body with base64 decoding if needed."""
+        return self.record["body"]
 
     def has_body(self) -> bool:
         """Check if SQS message has a body."""
@@ -63,22 +76,11 @@ class LambdaSqsStandard(lambda_input_output.LambdaInputOutput):
         """Provide SQS specific context data."""
         return {
             **super().context_specifics(),
-            "sqs_message_id": self.record.get("messageId"),
-            "sqs_receipt_handle": self.record.get("receiptHandle"),
-            "sqs_source_arn": self.record.get("eventSourceARN"),
-            "sqs_sent_timestamp": self.record.get("attributes", {}).get("SentTimestamp"),
-            "sqs_approximate_receive_count": self.record.get("attributes", {}).get("ApproximateReceiveCount"),
-            "sqs_message_attributes": self.record.get("messageAttributes", {}),
-            "sqs_record": self.record,
+            "message_id": self.record.get("messageId"),
+            "receipt_handle": self.record.get("receiptHandle"),
+            "source_arn": self.record.get("eventSourceARN"),
+            "sent_timestamp": self.record.get("attributes", {}).get("SentTimestamp"),
+            "approximate_receive_count": self.record.get("attributes", {}).get("ApproximateReceiveCount"),
+            "message_attributes": self.record.get("messageAttributes", {}),
+            "record": self.record,
         }
-
-    @property
-    def request_data(self) -> dict[str, Any]:
-        """Return the SQS message body as parsed JSON."""
-        body = self.get_body()
-        if not body:
-            return {}
-        try:
-            return json.loads(body)
-        except json.JSONDecodeError:
-            raise ClientError("SQS message body was not valid JSON")

clearskies_aws/models/__init__.py

@@ -0,0 +1 @@
+from clearskies_aws.models.web_socket_connection_model import WebSocketConnectionModel

clearskies_aws/contexts/lambda_invocation.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from clearskies.authentication import Public
-from clearskies.contexts.context import Context
-
-from clearskies_aws.input_outputs import LambdaInvocation as LambdaInvocationInputOutput
-
-
-class LambdaInvocation(Context):
-
-    def __call__(self, event: dict[str, Any], context: dict[str, Any]) -> Any:  # type: ignore[override]
-        return self.execute_application(
-            LambdaInvocationInputOutput(
-                event,
-                context,
-            )
-        )