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

clearskies_aws/handlers/simple_body_routing.py

@@ -1,39 +0,0 @@
-import clearskies
-
-
-class SimpleBodyRouting(clearskies.handlers.Routing):
-    def __init__(self, di):
-        super().__init__(di)
-
-    _configuration_defaults = {
-        "routes": {},
-        "route_key": "route",
-    }
-
-    def handler_classes(self, configuration):
-        # not actually used but required by base
-        return []
-
-    def _check_configuration(self, configuration):
-        for config_name in ["route_key", "routes"]:
-            if not configuration.get(config_name):
-                raise KeyError(f"Missing required configuration for SimpleBodyRouting handler: '{config_name}'")
-        if not isinstance(configuration["routes"], dict):
-            raise ValueError(f"COnfiguration 'routes' for handler SimpleBodyRouting must be a dictionary, but instead I got something else.")
-
-    def handle(self, input_output):
-        body = input_output.json_body(required=True)
-        if not body or not body.get(self.configuration("route_key")):
-            return self.error(input_output, "Not Found", 404)
-
-        route = body[self.configuration("route_key")]
-        if route not in self.configuration("routes"):
-            return self.error(input_output, "Not Found", 404)
-        return input_output.respond(self._di.call_function(
-            self.configuration("routes")[route],
-            request_data=body,
-            **input_output.context_specifics(),
-        ), 200)
-
-    def documentation(self):
-        return []

clearskies_aws/input_outputs/__init__.py

@@ -1,8 +0,0 @@
-from .cli_websocket_mock import CLIWebsocketMock
-from .lambda_api_gateway import LambdaAPIGateway
-from .lambda_api_gateway_web_socket import LambdaAPIGatewayWebSocket
-from .lambda_elb import LambdaELB
-from .lambda_http_gateway import LambdaHTTPGateway
-from .lambda_invocation import LambdaInvocation
-from .lambda_sqs_standard import LambdaSqsStandard
-from .lambda_sns import LambdaSns

clearskies_aws/input_outputs/cli_websocket_mock.py

@@ -1,12 +0,0 @@
-import clearskies
-class CLIWebsocketMock(clearskies.input_outputs.CLI):
-    def context_specifics(self):
-        connection_id = self.json_body().get("connection_id")
-        if not connection_id:
-            raise KeyError("When using the CLIWebsocketMock you must provide connection_id in the request body")
-
-        return {
-            "event": {},
-            "context": {},
-            "connection_id": connection_id,
-        }

clearskies_aws/input_outputs/lambda_api_gateway.py

@@ -1,105 +0,0 @@
-from clearskies.input_outputs.input_output import InputOutput
-import json
-import base64
-import urllib
-class LambdaAPIGateway(InputOutput):
-    _event = None
-    _context = None
-    _request_headers = None
-    _request_method = None
-    _path = None
-    _resource = None
-    _query_parameters = None
-    _path_parameters = None
-    _cached_body = None
-    _body_was_cached = False
-
-    def __init__(self, event, context):
-        self._event = event
-        self._context = context
-        self._request_method = event.get('httpMethod', '').upper()
-        self._path = event.get('path')
-        self._resource = event.get('resource')
-        self._query_parameters = event.get('queryStringParameters', {})
-        self._path_parameters = event.get('pathParameters', {})
-        self._request_headers = {}
-        for (key, value) in event.get('headers', {}).items():
-            self._request_headers[key.lower()] = value
-
-    def respond(self, body, status_code=200):
-        if not self.has_header('content-type'):
-            self.set_header('content-type', 'application/json; charset=UTF-8')
-
-        is_base64 = False
-        if type(body) == bytes:
-            is_base64 = True
-            final_body = base64.encodebytes(body).decode('utf8')
-        elif type(body) == str:
-            final_body = body
-        else:
-            final_body = json.dumps(body)
-
-        return {
-            "isBase64Encoded": is_base64,
-            "statusCode": status_code,
-            "headers": self._response_headers,
-            "body": final_body,
-        }
-
-    def has_body(self):
-        return bool(self.get_body())
-
-    def get_body(self):
-        if not self._body_was_cached:
-            self._cached_body = self._event.get('body')
-            if self._cached_body is not None and self._event.get('isBase64Encoded'):
-                self._cached_body = base64.decodebytes(self._cached_body.encode('utf-8')).decode('utf-8')
-        return self._cached_body
-
-    def get_request_method(self):
-        return self._request_method
-
-    def get_script_name(self):
-        return ''
-
-    def get_path_info(self):
-        return self._path
-
-    def get_query_string(self):
-        return urllib.parse.urlencode(self._query_parameters)
-
-    def get_content_type(self):
-        return self.get_request_header('content-type', True)
-
-    def get_protocol(self):
-        return 'https'
-
-    def has_request_header(self, header_name):
-        return header_name.lower() in self._request_headers
-
-    def get_request_header(self, header_name, silent=False):
-        if not header_name.lower() in self._request_headers:
-            if not silent:
-                raise KeyError(f"HTTP header '{header_name}' was not found in request")
-            return ''
-        return self._request_headers[header_name.lower()]
-
-    def get_query_parameter(self, key):
-        return self._query_parameters[key] if key in self._query_parameters else []
-
-    def get_query_parameters(self):
-        return self._query_parameters
-
-    def context_specifics(self):
-        return {
-            "event": self._event,
-            "context": self._context,
-        }
-
-    def get_client_ip(self):
-        # I haven't actually tested with an API gateway yet to figure out which of these works...
-        sourceIp = self._event.get('requestContext', {}).get('identity', {}).get('sourceIp')
-        if sourceIp:
-            return sourceIp
-
-        return self.get_request_header('x-forwarded-for', silent=True)

clearskies_aws/input_outputs/lambda_api_gateway_test.py

@@ -1,87 +0,0 @@
-import unittest
-from collections import OrderedDict
-
-from .lambda_api_gateway import LambdaAPIGateway
-
-
-class LambdaAPIGatewayTest(unittest.TestCase):
-    dummy_event = {
-        'httpMethod': 'GET',
-        'path': '/test',
-        'resource': 'bob',
-        'queryStringParameters': {
-            'q': 'hey',
-            'bob': 'sup'
-        },
-        'pathParameters': None,
-        'headers': {
-            'Content-Type': 'application/json'
-        },
-    }
-
-    def test_respond(self):
-        aws_lambda = LambdaAPIGateway(self.dummy_event, {})
-        aws_lambda.set_headers({'bob': 'hey', 'jane': 'kay'})
-        aws_lambda.set_header('hey', 'sup')
-        aws_lambda.clear_header('bob')
-        response = aws_lambda.respond({'some': 'data'}, 200)
-        self.assertEqual(
-            {
-                "isBase64Encoded": False,
-                "statusCode": 200,
-                "headers": OrderedDict(
-                    [
-                        ("JANE", "kay"),
-                        ("HEY", "sup"),
-                        ("CONTENT-TYPE", "application/json; charset=UTF-8"),
-                    ]
-                ),
-                "body": '{"some": "data"}',
-            },
-            response,
-        )
-
-    def test_headers(self):
-        aws_lambda = LambdaAPIGateway({
-            **self.dummy_event,
-            **{
-                'headers': {
-                    'Content-Type': 'application/json',
-                    'AUTHORIZATION': 'hey',
-                    'X-Auth': 'asdf',
-                }
-            }
-        }, {})
-        self.assertEqual("hey", aws_lambda.get_request_header("authorizatiON"))
-        self.assertEqual("asdf", aws_lambda.get_request_header("x-auth"))
-        self.assertTrue(aws_lambda.has_request_header('authorization'))
-        self.assertTrue(aws_lambda.has_request_header('x-auth'))
-        self.assertFalse(aws_lambda.has_request_header('bearer'))
-
-    def test_body_plain(self):
-        aws_lambda = LambdaAPIGateway({**self.dummy_event, **{'body': '{"hey": "sup"}', 'isBase64Encoded': False}}, {})
-
-        self.assertEqual({"hey": "sup"}, aws_lambda.json_body())
-        self.assertEqual('{"hey": "sup"}', aws_lambda.get_body())
-        self.assertTrue(aws_lambda.has_body())
-
-    def test_body_base64(self):
-        aws_lambda = LambdaAPIGateway({
-            **self.dummy_event,
-            **{
-                'body': 'eyJoZXkiOiAic3VwIn0=',
-                'isBase64Encoded': True
-            }
-        }, {})
-
-        self.assertEqual({"hey": "sup"}, aws_lambda.json_body())
-        self.assertEqual('{"hey": "sup"}', aws_lambda.get_body())
-        self.assertTrue(aws_lambda.has_body())
-
-    def test_path(self):
-        aws_lambda = LambdaAPIGateway(self.dummy_event, {})
-        self.assertEqual("/test", aws_lambda.get_path_info())
-
-    def test_query_string(self):
-        aws_lambda = LambdaAPIGateway(self.dummy_event, {})
-        self.assertEqual("q=hey&bob=sup", aws_lambda.get_query_string())

clearskies_aws/input_outputs/lambda_api_gateway_web_socket.py

@@ -1,8 +0,0 @@
-from .lambda_api_gateway import LambdaAPIGateway
-class LambdaAPIGatewayWebSocket(LambdaAPIGateway):
-    def context_specifics(self):
-        return {
-            "event": self._event,
-            "context": self._context,
-            "connection_id": self._event["requestContext"]["connectionId"],
-        }

clearskies_aws/input_outputs/lambda_elb.py

@@ -1,21 +0,0 @@
-from .lambda_api_gateway import LambdaAPIGateway
-class LambdaELB(LambdaAPIGateway):
-    _event = None
-    _context = None
-    _request_headers = None
-    _request_method = None
-    _path = None
-    _query_parameters = None
-
-    def __init__(self, event, context):
-        self._event = event
-        self._context = context
-        self._request_method = event.get('httpMethod', 'GET').upper()
-        self._path = event.get('path', '/')
-        self._query_parameters = event.get('queryStringParameters', {})
-        self._request_headers = {}
-        for (key, value) in event.get('headers', {}).items():
-            self._request_headers[key.lower()] = value
-
-    def get_client_ip(self):
-        return self.get_request_header('x-forwarded-for')

clearskies_aws/input_outputs/lambda_http_gateway.py

@@ -1,12 +0,0 @@
-from .lambda_api_gateway import LambdaAPIGateway
-class LambdaHTTPGateway(LambdaAPIGateway):
-    def __init__(self, event, context):
-        self._event = event
-        self._context = context
-        self._path = event.get('requestContext', {}).get('http', {}).get('path')
-        self._request_method = event.get('requestContext', {}).get('http', {}).get('method').upper()
-        self._query_parameters = event['queryStringParameters'] if event['queryStringParameters'] is not None else {}
-        self._path_parameters = event['pathParameters']
-        self._request_headers = {}
-        for (key, value) in event['headers'].items():
-            self._request_headers[key.lower()] = value

clearskies_aws/input_outputs/lambda_invocation.py

@@ -1,34 +0,0 @@
-from .lambda_api_gateway import LambdaAPIGateway
-import json
-from clearskies.handlers.exceptions import ClientError
-class LambdaInvocation(LambdaAPIGateway):
-    def __init__(
-        self,
-        event,
-        context,
-        method=None,
-        url=None,
-    ):
-        self._event = event
-        self._context = context
-        self._path = url if url else ''
-        self._request_method = method.upper() if method else 'GET'
-        self._query_parameters = {}
-        self._path_parameters = []
-        self._request_headers = {}
-
-    def has_body(self):
-        return True
-
-    def get_body(self):
-        return self._event
-
-    def json_body(self, required=True, allow_non_json_bodies=False):
-        # we ignore the allow_non_json_bodies flag here because with the way invoking lambdas works,
-        # the event already is an object, so it's a moot point.
-        if required and not self._event:
-            raise ClientError("Request body was not valid JSON")
-        return self._event
-
-    def respond(self, body, status_code=200):
-        return body.decode('utf-8') if type(body) == bytes else body

clearskies_aws/input_outputs/lambda_sns.py

@@ -1,52 +0,0 @@
-from .lambda_api_gateway import LambdaAPIGateway
-from clearskies.handlers.exceptions import ClientError
-import json
-class LambdaSns(LambdaAPIGateway):
-    def __init__(self, event, context, url=None, method=None):
-        self._event = event
-        self._context = context
-        self._path = url if url else ''
-        self._request_method = method.upper() if method else 'GET'
-        record = event['Records'][0]['Sns']['Message']
-        try:
-            self._record = json.loads(record)
-        except json.JSONDecodeError as e:
-            raise ClientError("The message from AWS was not a serialized JSON string.  The lambda_sns context for clearskies only accepts serialized JSON")
-
-    def respond(self, body, status_code=200):
-        pass
-
-    def get_body(self):
-        return self._record
-
-    def request_data(self, required=True, allow_non_json_bodies=False):
-        return self.json_body(required=required, allow_non_json_bodies=allow_non_json_bodies)
-
-    def json_body(self, required=True, allow_non_json_bodies=False):
-        if not self._record:
-            if required:
-                raise ClientError("No SNS message found")
-            return {}
-
-        return self._record
-
-    def get_query_string(self):
-        raise NotImplementedError("The query string doesn't exist in an SNS context")
-
-    def get_content_type(self):
-        raise NotImplementedError("Content type doesn't exist in an SNS context")
-
-    def get_protocol(self):
-        raise NotImplementedError("A request protocol is not defined in an SNS context")
-
-    def has_request_header(self, header_name):
-        raise NotImplementedError("SNS contexts don't have request headers")
-
-    def get_request_header(self, header_name, silent=True):
-        raise NotImplementedError("SNS contexts don't have request headers")
-
-    def get_query_parameter(self, key):
-        raise NotImplementedError("SNS contexts don't have query parameters")
-
-    def get_query_parameters(self):
-        raise NotImplementedError("SNS contexts don't have query parameters")

clearskies_aws/input_outputs/lambda_sqs_standard.py

@@ -1,54 +0,0 @@
-from .lambda_api_gateway import LambdaAPIGateway
-from clearskies.handlers.exceptions import ClientError
-import json
-class LambdaSqsStandard(LambdaAPIGateway):
-    def __init__(self, record, event, context, url=None, method=None):
-        self._record = record
-        self._context = context
-        self._event = event
-        self._path = url if url else ''
-        self._request_method = method.upper() if method else 'GET'
-
-    def respond(self, body, status_code=200):
-        pass
-
-    def get_body(self):
-        return self._record
-
-    def has_body(self):
-        return True
-
-    def request_data(self, required=True, allow_non_json_bodies=False):
-        return self.json_body(required=required, allow_non_json_bodies=allow_non_json_bodies)
-
-    def json_body(self, required=True, allow_non_json_bodies=False):
-        if not self._record:
-            if required:
-                raise ClientError("SQS message was not valid JSON")
-            return {}
-
-        try:
-            return json.loads(self._record)
-        except json.JSONDecodeError:
-            raise ClientError("SQS message was not valid JSON")
-
-    def get_query_string(self):
-        raise NotImplementedError("The query string doesn't exist in an SQS context")
-
-    def get_content_type(self):
-        raise NotImplementedError("Content type doesn't exist in an SQS context")
-
-    def get_protocol(self):
-        raise NotImplementedError("A request protocol is not defined in an SQS context")
-
-    def has_request_header(self, header_name):
-        raise NotImplementedError("SQS contexts don't have request headers")
-
-    def get_request_header(self, header_name, silent=True):
-        raise NotImplementedError("SQS contexts don't have request headers")
-
-    def get_query_parameter(self, key):
-        raise NotImplementedError("SQS contexts don't have query parameters")
-
-    def get_query_parameters(self):
-        raise NotImplementedError("SQS contexts don't have query parameters")

clearskies_aws/mocks/__init__.py

@@ -1 +0,0 @@
-from . import actions

clearskies_aws/mocks/actions/__init__.py

@@ -1,6 +0,0 @@
-from .ses import SES
-from .sns import SNS
-from .sqs import SQS
-from .step_function import StepFunction
-
-__all__ = ["SES", "SNS", "SQS", "StepFunction"]

clearskies_aws/mocks/actions/ses.py

@@ -1,28 +0,0 @@
-from ...actions.ses import SES as BaseSES
-class SES(BaseSES):
-    calls = None
-
-    def __init__(self, environment, boto3, di):
-        super().__init__(environment, boto3, di)
-
-    @classmethod
-    def mock(cls, di):
-        cls.calls = []
-        di.mock_class(BaseSES, SES)
-
-    def __call__(self, model) -> None:
-        """Send a notification as configured."""
-        if SES.calls == None:
-            SES.calls = []
-        utcnow = self.di.build('utcnow')
-        if self.when and not self.di.call_function(self.when, model=model):
-            return
-
-        SES.calls.append({
-            "from": self.sender,
-            "to": self._resolve_destination("to", model),
-            "cc": self._resolve_destination("cc", model),
-            "bcc": self._resolve_destination("bcc", model),
-            "subject": self._resolve_subject(model, utcnow),
-            "message": self._resolve_message_as_html(model, utcnow),
-        })

clearskies_aws/mocks/actions/sns.py

@@ -1,23 +0,0 @@
-from types import ModuleType
-from clearskies import Model
-from ...actions.sns import SNS as BaseSNS
-class SNS(BaseSNS):
-    calls = None
-
-    def __init__(self, environment, boto3, di):
-        super().__init__(environment, boto3, di)
-
-    @classmethod
-    def mock(cls, di):
-        cls.calls = []
-        di.mock_class(BaseSNS, SNS)
-
-    def _execute_action(self, client: ModuleType, model: Model) -> None:
-        """Send a notification as configured."""
-        if SNS.calls == None:
-            SNS.calls = []
-
-        SNS.calls.append({
-            "TopicArn": self.get_topic_arn(model),
-            "Message": self.get_message_body(model),
-        })

clearskies_aws/mocks/actions/sqs.py

@@ -1,23 +0,0 @@
-from types import ModuleType
-from clearskies import Model
-from ...actions.sqs import SQS as BaseSQS
-class SQS(BaseSQS):
-    calls = None
-
-    def __init__(self, environment, boto3, di):
-        super().__init__(environment, boto3, di)
-
-    @classmethod
-    def mock(cls, di):
-        cls.calls = []
-        di.mock_class(BaseSQS, SQS)
-
-    def _execute_action(self, client: ModuleType, model: Model) -> None:
-        """Send a notification as configured."""
-        if SQS.calls == None:
-            SQS.calls = []
-
-        SQS.calls.append({
-            "QueueUrl": self.get_queue_url(model),
-            "MessageBody": self.get_message_body(model),
-        })

clearskies_aws/mocks/actions/step_function.py

@@ -1,26 +0,0 @@
-from types import ModuleType
-from clearskies import Model
-from ...actions.step_function import StepFunction as BaseStepFunction
-class StepFunction(BaseStepFunction):
-    calls = None
-
-    def __init__(self, environment, boto3, di):
-        super().__init__(environment, boto3, di)
-
-    @classmethod
-    def mock(cls, di):
-        StepFunction.calls = []
-        di.mock_class(BaseStepFunction, StepFunction)
-
-    def _execute_action(self, client: ModuleType, model: Model) -> None:
-        """Send a notification as configured."""
-        if StepFunction.calls == None:
-            StepFunction.calls = []
-
-        StepFunction.calls.append({
-            "stateMachineArn": self.get_arn(model),
-            "input": self.get_message_body(model),
-        })
-
-        if self.column_to_store_execution_arn:
-            model.save({self.column_to_store_execution_arn: "mock_execution_arn"})

clearskies_aws/secrets/__init__.py

@@ -1,7 +0,0 @@
-from clearskies import BindingConfig
-from .parameter_store import ParameterStore
-from .secrets_manager import SecretsManager
-from .akeyless_with_ssm_cache import AkeylessWithSsmCache
-from . import additional_configs
-def akeyless_with_ssm_cache(*args, **kwargs):
-    return BindingConfig(AkeylessWithSsmCache, *args, **kwargs)

clearskies_aws/secrets/additional_configs/__init__.py

@@ -1,54 +0,0 @@
-from .mysql_connection_dynamic_producer_via_ssh_cert_bastion import MySQLConnectionDynamicProducerViaSSHCertBastion
-from .mysql_connection_dynamic_producer_via_ssm_bastion import MySQLConnectionDynamicProducerViaSSMBastion
-from .iam_db_auth import IAMDBAuth
-from .iam_db_auth_with_ssm import IAMDBAuthWithSSM
-def mysql_connection_dynamic_producer_via_ssh_cert_bastion(
-    producer_name=None,
-    bastion_host=None,
-    bastion_name=None,
-    bastion_region=None,
-    bastion_username=None,
-    public_key_file_path=None,
-    cert_issuer_name=None,
-    database_host=None,
-    database_name=None,
-    local_proxy_port=None,
-):
-    return MySQLConnectionDynamicProducerViaSSHCertBastion(
-        producer_name=producer_name,
-        bastion_host=bastion_host,
-        bastion_name=bastion_name,
-        bastion_region=bastion_region,
-        bastion_username=bastion_username,
-        cert_issuer_name=cert_issuer_name,
-        public_key_file_path=public_key_file_path,
-        database_host=database_host,
-        database_name=database_name,
-        local_proxy_port=local_proxy_port,
-    )
-def mysql_connection_dynamic_producer_via_ssm_bastion(
-    producer_name=None,
-    bastion_instance_id=None,
-    bastion_name=None,
-    bastion_region=None,
-    bastion_username=None,
-    public_key_file_path=None,
-    database_host=None,
-    database_name=None,
-    local_proxy_port=None,
-):
-    return MySQLConnectionDynamicProducerViaSSMBastion(
-        producer_name=producer_name,
-        bastion_instance_id=bastion_instance_id,
-        bastion_name=bastion_name,
-        bastion_region=bastion_region,
-        bastion_username=bastion_username,
-        public_key_file_path=public_key_file_path,
-        database_host=database_host,
-        database_name=database_name,
-        local_proxy_port=local_proxy_port,
-    )
-def iam_db_auth():
-    return IAMDBAuth()
-def iam_db_auth_with_ssm():
-    return IAMDBAuthWithSSM()

clearskies_aws/secrets/additional_configs/iam_db_auth.py

@@ -1,29 +0,0 @@
-import clearskies
-import os
-class IAMDBAuth(clearskies.di.AdditionalConfig):
-    def provide_boto3(self):
-        import boto3
-        return boto3
-
-    def provide_connection_details(self, environment, boto3):
-        """
-        I really need to make these configurable - both the values themselves and the environment
-        variables that things get pulled from.
-        """
-        endpoint = environment.get('db_endpoint')
-        username = environment.get('db_username')
-        database = environment.get('db_database')
-        region = environment.get('AWS_REGION')
-        ssl_ca_bundle_name = environment.get('ssl_ca_bundle_filename')
-        os.environ['LIBMYSQL_ENABLE_CLEARTEXT_PLUGIN'] = '1'
-
-        rds_api = boto3.Session().client('rds')
-        rds_token = rds_api.generate_db_auth_token(DBHostname=endpoint, Port='3306', DBUsername=username, Region=region)
-
-        return {
-            'username': username,
-            'password': rds_token,
-            'host': endpoint,
-            'database': database,
-            'ssl_ca': ssl_ca_bundle_name,
-        }