clear-skies-aws 1.10.1__py3-none-any.whl → 2.0.1__py3-none-any.whl

clearskies_aws/contexts/cli.py

@@ -1,19 +0,0 @@
-from ..di import StandardDependencies
-from clearskies.contexts.cli import CLI, build_context
-def cli(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        CLI,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/contexts/cli_websocket_mock.py

@@ -1,33 +0,0 @@
-import clearskies
-import clearskies_aws
-from ..input_outputs import CLIWebsocketMock as CLIWebsocketMockInputOutput
-from clearskies_aws.contexts.cli import CLI
-class CLIWebsocketMock(CLI):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def __call__(self):
-        if self.handler is None:
-            raise ValueError("Cannot execute CLIWebsocketMock context without first configuring it")
-
-        try:
-            return self.handler(self.di.build(CLIWebsocketMockInputOutput))
-        except clearskies.input_outputs.exceptions.CLINotFound:
-            print("help (aka 404 not found)!")
-def cli_websocket_mock(
-    application,
-    di_class=clearskies_aws.di.StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return clearskies.contexts.build_context(
-        CLIWebsocketMock,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/contexts/lambda_api_gateway.py

@@ -1,30 +0,0 @@
-from ..input_outputs import LambdaAPIGateway as LambdaAPIGatewayInputOutput
-from ..di import StandardDependencies
-from clearskies.contexts.build_context import build_context
-from clearskies.contexts.context import Context
-class LambdaAPIGateway(Context):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def __call__(self, event, context):
-        if self.handler is None:
-            raise ValueError("Cannot execute LambdaAPIGateway context without first configuring it")
-
-        return self.handler(LambdaAPIGatewayInputOutput(event, context))
-def lambda_api_gateway(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        LambdaAPIGateway,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/contexts/lambda_api_gateway_web_socket.py

@@ -1,30 +0,0 @@
-from ..input_outputs import LambdaAPIGatewayWebSocket as LambdaAPIGatewayWebSocketInputOutput
-from ..di import StandardDependencies
-from clearskies.contexts.build_context import build_context
-from clearskies.contexts.context import Context
-class LambdaAPIGatewayWebSocket(Context):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def __call__(self, event, context):
-        if self.handler is None:
-            raise ValueError("Cannot execute LambdaAPIGatewayWebSocket context without first configuring it")
-
-        return self.handler(LambdaAPIGatewayWebSocketInputOutput(event, context))
-def lambda_api_gateway_web_socket(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        LambdaAPIGatewayWebSocket,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/contexts/lambda_elb.py

@@ -1,30 +0,0 @@
-from ..input_outputs import LambdaELB as LambdaELBInputOutput
-from ..di import StandardDependencies
-from clearskies.contexts.build_context import build_context
-from clearskies.contexts.context import Context
-class LambdaELB(Context):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def __call__(self, event, context):
-        if self.handler is None:
-            raise ValueError("Cannot execute LambdaELB context without first configuring it")
-
-        return self.handler(LambdaELBInputOutput(event, context))
-def lambda_elb(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        LambdaELB,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/contexts/lambda_http_gateway.py

@@ -1,30 +0,0 @@
-from ..input_outputs import LambdaHTTPGateway as LambdaHTTPGatewayInputOutput
-from ..di import StandardDependencies
-from clearskies.contexts.build_context import build_context
-from clearskies.contexts.context import Context
-class LambdaHTTPGateway(Context):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def __call__(self, event, context):
-        if self.handler is None:
-            raise ValueError("Cannot execute LambdaHTTPGateway context without first configuring it")
-
-        return self.handler(LambdaHTTPGatewayInputOutput(event, context))
-def lambda_http_gateway(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        LambdaHTTPGateway,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/contexts/lambda_invocation.py

@@ -1,48 +0,0 @@
-from clearskies.authentication import public
-from ..input_outputs import LambdaInvocation as LambdaInvocationInputOutput
-from ..di import StandardDependencies
-from clearskies.contexts.build_context import build_context
-from clearskies.contexts.context import Context
-class LambdaInvocation(Context):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def finalize_handler_config(self, config):
-        return {
-            'authentication': public(),
-            **config,
-        }
-
-    def __call__(
-        self,
-        event,
-        context,
-        method=None,
-        url=None,
-    ):
-        if self.handler is None:
-            raise ValueError("Cannot execute LambdaInvocation context without first configuring it")
-
-        return self.handler(LambdaInvocationInputOutput(
-            event,
-            context,
-            method=method,
-            url=url,
-        ))
-def lambda_invocation(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        LambdaInvocation,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/contexts/lambda_sns.py

@@ -1,43 +0,0 @@
-from ..input_outputs import LambdaSns as LambdaSnsInputOutput
-from ..di import StandardDependencies
-from clearskies.contexts.build_context import build_context
-from clearskies.contexts.context import Context
-from clearskies.authentication import public
-
-class LambdaSns(Context):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def finalize_handler_config(self, config):
-        return {
-            'authentication': public(),
-            **config,
-        }
-
-    def __call__(self, event, context, method=None, url=None):
-        if self.handler is None:
-            raise ValueError("Cannot execute LambdaSnsEvent context without first configuring it")
-
-        try:
-            return self.handler(LambdaSnsInputOutput(event, context, method=method, url=url))
-        except Exception as e:
-            print('Failed message ' + event['Records'][0]['Sns']['MessageId'] + '. Error error: ' + str(e))
-            raise e
-
-def lambda_sns(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        LambdaSns,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/contexts/lambda_sqs_standard_partial_batch.py

@@ -1,51 +0,0 @@
-import traceback
-from ..input_outputs import LambdaSqsStandard as LambdaSqsStandardInputOutput
-from ..di import StandardDependencies
-from clearskies.contexts.build_context import build_context
-from clearskies.contexts.context import Context
-from clearskies.authentication import public
-class LambdaSqsStandardPartialBatch(Context):
-    def __init__(self, di):
-        super().__init__(di)
-
-    def finalize_handler_config(self, config):
-        return {
-            'authentication': public(),
-            **config,
-        }
-
-    def __call__(self, event, context, url=None, method=None):
-        if self.handler is None:
-            raise ValueError("Cannot execute LambdaELB context without first configuring it")
-
-        item_failures = []
-        for record in event['Records']:
-            try:
-                self.handler(LambdaSqsStandardInputOutput(record['body'], event, context, url=url, method=method))
-            except Exception as e:
-                print('Failed message ' + record['messageId'] + ' being returned for retry.  Error error: ' + str(e))
-                traceback.print_tb(e.__traceback__)
-                item_failures.append({'itemIdentifier': record['messageId']})
-
-        if item_failures:
-            return {
-                "batchItemFailures": item_failures,
-            }
-        return {}
-def lambda_sqs_standard_partial_batch(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        LambdaSqsStandardPartialBatch,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/contexts/lambda_sqs_standard_partial_batch_test.py

@@ -1,66 +0,0 @@
-import json
-import unittest
-from types import SimpleNamespace
-from unittest.mock import MagicMock, call
-
-from .lambda_sqs_standard_partial_batch import lambda_sqs_standard_partial_batch
-
-
-class LambdaSqsStandardPartialBatchTest(unittest.TestCase):
-    def setUp(self):
-        self.calls = []
-
-    def my_callable(self, request_data):
-        if 'boom' in request_data:
-            raise ValueError('oops')
-        self.calls.append(request_data)
-
-    def test_simple_execution(self):
-        sqs_handler = lambda_sqs_standard_partial_batch(self.my_callable)
-        sqs_handler(
-            {
-                'Records': [
-                    {
-                        'messageId': '1-2-3-4',
-                        'body': json.dumps({'hey': 'sup'}),
-                    },
-                    {
-                        'messageId': '2-3-4-5',
-                        'body': json.dumps({'cool': 'yo'}),
-                    },
-                ]
-            },
-            {},
-        )
-        self.assertEqual(
-            [
-                {"hey": "sup"},
-                {"cool": "yo"},
-            ],
-            self.calls,
-        )
-
-    def test_with_failure(self):
-        sqs_handler = lambda_sqs_standard_partial_batch(self.my_callable)
-        results = sqs_handler({
-            'Records': [
-                {
-                    'messageId': '1-2-3-4',
-                    'body': json.dumps({'hey': 'sup'}),
-                },
-                {
-                    'messageId': '2-3-4-5',
-                    'body': json.dumps({'boom': 'yo'}),
-                },
-            ]
-        }, {})
-        self.assertEqual(
-            [
-                {"hey": "sup"},
-            ],
-            self.calls,
-        )
-        self.assertEqual(
-            {"batchItemFailures": [{"itemIdentifier": "2-3-4-5"}]},
-            results,
-        )

clearskies_aws/contexts/wsgi.py

@@ -1,19 +0,0 @@
-from ..di import StandardDependencies
-from clearskies.contexts.wsgi import WSGI, build_context
-def wsgi(
-    application,
-    di_class=StandardDependencies,
-    bindings=None,
-    binding_classes=None,
-    binding_modules=None,
-    additional_configs=None,
-):
-    return build_context(
-        WSGI,
-        application,
-        di_class=di_class,
-        bindings=bindings,
-        binding_classes=binding_classes,
-        binding_modules=binding_modules,
-        additional_configs=additional_configs,
-    )

clearskies_aws/di/__init__.py

@@ -1 +0,0 @@
-from .standard_dependencies import StandardDependencies

clearskies_aws/di/standard_dependencies.py

@@ -1,60 +0,0 @@
-from types import ModuleType
-
-import boto3 as boto3_module
-from boto3.session import Session as Boto3Session
-from clearskies import Environment
-from clearskies.di import StandardDependencies as DefaultStandardDependencies
-
-from ..backends import (
-    DynamoDBBackend,
-    DynamoDBPartiQLBackend,
-    DynamoDBPartiQLCursor,
-    SqsBackend,
-)
-from ..secrets import ParameterStore
-
-
-class StandardDependencies(DefaultStandardDependencies):
-
-    def provide_dynamo_db_parti_ql_cursor(
-        self, boto3_session: Boto3Session
-    ) -> DynamoDBPartiQLCursor:
-        return DynamoDBPartiQLCursor(boto3_session)
-
-    def provide_dynamo_db_backend(
-        self, boto3: ModuleType, environment: Environment
-    ) -> DynamoDBBackend:
-        return DynamoDBBackend(boto3, environment)
-
-    def provide_dynamo_db_parti_ql_backend(
-        self, dynamo_db_parti_ql_cursor: DynamoDBPartiQLCursor, environment: Environment
-    ) -> DynamoDBPartiQLBackend:
-        return DynamoDBPartiQLBackend(dynamo_db_parti_ql_cursor)
-
-    def provide_sqs_backend(
-        self, boto3: ModuleType, environment: Environment
-    ) -> SqsBackend:
-        return SqsBackend(boto3, environment)
-
-    def provide_boto3(self) -> ModuleType:
-        import boto3
-        return boto3
-
-    def provide_secrets(
-        self, boto3: ModuleType, environment: Environment
-    ) -> ParameterStore:
-        # This is just here so that we can auto-inject the secrets into the environment without having
-        # to force the developer to define a secrets manager
-        return ParameterStore(boto3, environment)
-
-    def provide_boto3_session(
-        self, boto3: ModuleType, environment: Environment
-    ) -> boto3_module.session.Session:
-
-        if not environment.get("AWS_REGION", True):
-            raise ValueError(
-                "To use AWS Session you must use set AWS_REGION in the .env file or an environment variable"
-            )
-
-        session = boto3.session.Session(region_name=environment.get("AWS_REGION", True))
-        return session

clearskies_aws/handlers/__init__.py

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

clearskies_aws/handlers/secrets_manager_rotation.py

@@ -1,174 +0,0 @@
-import json
-
-import clearskies
-from clearskies.handlers.exceptions import ClientError
-from clearskies.handlers.base import Base
-import botocore
-
-class SecretsManagerRotation(Base, clearskies.handlers.SchemaHelper):
-    _steps = ["createSecret", "setSecret", "testSecret", "finishSecret"]
-
-    current = "AWSCURRENT"
-    pending = "AWSPENDING"
-
-    _configuration_defaults = {
-        "createSecret": None,
-        "setSecret": None,
-        "testSecret": None,
-        "finishSecret": None,
-        "schema": [],
-    }
-
-    def __init__(self, boto3, di):
-        super().__init__(di)
-        self.boto3 = boto3
-
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
-        class_name = self.__class__.__name__
-        if not configuration.get("createSecret"):
-            raise KeyError(f"Missing required configuration 'createSecret' for handler {class_name}")
-
-        for config_name in self._steps:
-            config = configuration.get(config_name)
-            if config is None:
-                continue
-            if not callable(config):
-                raise ValueError(f"Misconfiguration for handler {class_name}: configuration '{config_name}' is not callable")
-
-        if configuration.get("schema") is not None:
-            self._check_schema(configuration["schema"], None, f"Misconfiguration for handler {class_name}")
-
-    def _finalize_configuration(self, configuration):
-        if configuration.get('schema'):
-            configuration['schema'] = self._schema_to_columns(configuration['schema'])
-        return super()._finalize_configuration(configuration)
-
-    def handle(self, input_output):
-        request_data = input_output.json_body()
-
-        arn = request_data.get('SecretId')
-        request_token = request_data.get('ClientRequestToken')
-        step = request_data.get('Step')
-        secretsmanager = self.boto3.client('secretsmanager')
-        metadata = secretsmanager.describe_secret(SecretId=arn)
-
-        self._validate_secret_and_request(step, arn, metadata, request_token)
-
-        current_secret_data = {}
-        pending_secret_data = {}
-
-        current_secret = secretsmanager.get_secret_value(SecretId=arn, VersionStage=self.current)
-        current_secret_data = json.loads(current_secret['SecretString'])
-
-        # validate the current secret
-        secret_errors = {
-            **self._extra_column_errors(current_secret_data),
-            **self._find_input_errors(current_secret_data),
-        }
-        if secret_errors:
-            raise ValueError(f"The current secret did not match the configured schema: {secret_errors}")
-
-        # check for a pending secret.  Note that this is not always available.  In the event that we are retrying a failed
-        # rotation it will already be set, in which case we need to skip the createSecret step.
-        try:
-            pending_secret = secretsmanager.get_secret_value(SecretId=arn, VersionId=request_token, VersionStage=self.pending)
-            pending_secret_data = json.loads(pending_secret['SecretString'])
-        except botocore.exceptions.ClientError as error:
-            if error.response['Error']['Code'] == 'ResourceNotFoundException':
-                pending_secret_data = None
-            else:
-                raise error
-
-        # we can't call the createSecret step if we already have a pending secret or this will generate an error from AWS.
-        if step == "createSecret" and pending_secret_data is not None:
-            return
-
-        # call the appropriate step and pass along *everything*.
-        getattr(self, step)(
-            current_secret_data=current_secret_data,
-            pending_secret_data=pending_secret_data,
-            secretsmanager=secretsmanager,
-            metadata=metadata,
-            request_token=request_token,
-            arn=arn,
-        )
-
-    def _validate_secret_and_request(self, step, arn, metadata, request_token):
-        """ This function does some basic checks suggested by AWS of both the request and the secret to make sure everything is on the up-and-up. """
-        if step not in self._steps:
-            raise ClientError(f"Invalid step: {step}")
-
-        if not metadata.get('RotationEnabled'):
-            raise ValueError("Secret %s is not enabled for rotation" % arn)
-
-        versions = metadata["VersionIdsToStages"]
-        prefix = f"Rotation config error for version '{request_token}' of secret '{arn}': "
-        if request_token not in versions:
-            raise ValueError(f"{prefix} we don't have a stage for rotation")
-        if self.current in versions[request_token]:
-            raise ValueError(f"{prefix} it's already the current version, which shouldn't happen.  I'm quitting with prejudice.")
-        elif self.pending not in versions[request_token]:
-            raise ValueError(f"{prefix} it hasn't been set to pending yet, which makes no sense!")
-
-    def createSecret(self, **kwargs):
-        new_secret_data = self._di.call_function(self._configuration["createSecret"], **kwargs)
-        if new_secret_data is None:
-            raise ValueError(f"I called the configured createSecret function but it didn't return anything.  It has to return the new secret data.")
-        if not isinstance(new_secret_data, dict):
-            raise ValueError(f"I called the configured createSecret function but it didn't return a dictionary.  The createSecret function must return a dictionary.")
-
-        secret_errors = {
-            **self._extra_column_errors(new_secret_data),
-            **self._find_input_errors(new_secret_data),
-        }
-        if secret_errors:
-            raise ValueError(f"The secret data returned by the call to createSecret did not match the configured schema: {secret_errors}")
-
-        # if we get this far we can store the new data
-        secretsmanager = kwargs["secretsmanager"]
-        request_token = kwargs["request_token"]
-        arn = kwargs["arn"]
-        secretsmanager.put_secret_value(
-            SecretId=arn,
-            SecretString=json.dumps(new_secret_data),
-            ClientRequestToken=request_token,
-            VersionStages=[self.pending],
-        )
-
-    def setSecret(self, **kwargs):
-        if not self._configuration.get("setSecret"):
-            return
-        self._di.call_function(self._configuration["setSecret"], **kwargs)
-
-    def testSecret(self, **kwargs):
-        if not self._configuration.get("testSecret"):
-            return
-        self._di.call_function(self._configuration["testSecret"], **kwargs)
-
-    def finishSecret(self, **kwargs):
-        if self._configuration.get("finishSecret"):
-            self._di.call_function(self._configuration["finishSecret"], **kwargs)
-
-        secretsmanager = kwargs["secretsmanager"]
-        request_token = kwargs["request_token"]
-        arn = kwargs["arn"]
-        metadata = kwargs["metadata"]
-        current_version = None
-        for version in metadata["VersionIdsToStages"]:
-            if self.current not in metadata["VersionIdsToStages"][version]:
-                continue
-
-            if version == request_token:
-                return
-
-            current_version = version
-            break
-
-        # finish the rotation by taking the new version and making it current.
-        secretsmanager.update_secret_version_stage(
-            SecretId=arn,
-            VersionStage=self.current,
-            MoveToVersionId=request_token,
-            RemoveFromVersionId=current_version
-        )