cloud-foundry 0.0.1__tar.gz → 0.0.2__tar.gz

cloud_foundry-0.0.2/.gitignore

@@ -0,0 +1,6 @@
+
+venv/
+__pycache__
+.pytest_cache
+.env
+temp/

{cloud_foundry-0.0.1 → cloud_foundry-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cloud-foundry
-Version: 0.0.1
+Version: 0.0.2
 Summary: cloud-foundry is a curated set of cloud components that can be used to assemble cloud based applications.
 Project-URL: Documentation, https://github.com/DanRepik/cloud-foundry
 Project-URL: Source, https://github.com/DanRepik/cloud-foundry

cloud_foundry-0.0.2/cloud_foundry/__init__.py

@@ -0,0 +1,2 @@
+from cloud_foundry.pulumi.python_function import python_function
+

cloud_foundry-0.0.2/cloud_foundry/archive_builder.py

@@ -0,0 +1,6 @@
+class ArchiveBuilder:
+    def hash(self) -> str:
+        raise NotImplementedError
+
+    def location(self) -> str:
+        raise NotImplementedError

cloud_foundry-0.0.2/cloud_foundry/cloud_foundry.py

@@ -0,0 +1,23 @@
+from cloud_foundry.pulumi.python_function import PythonFunction
+from cloud_foundry.python_archive_builder import PythonArchiveBuilder
+
+def python_function(
+    self,
+    name: str,
+    sources: dict[str, str] = None,
+    requirements: list[str] = None,
+    environment: dict[str, str] = None,
+):
+    self.archive_builder = PythonArchiveBuilder(
+        name=f"{name}-archive-builder",
+        sources=sources,
+        requirements=requirements,
+        working_dir="temp",
+    )
+    return PythonFunction(
+        name=f"{name}-api-maker",
+        hash=self.archive_builder.hash(),
+        handler="app.lambda_handler",
+        archive_location=self.archive_builder.location(),
+        environment=environment,
+    )

cloud_foundry-0.0.2/cloud_foundry/pulumi/log_group.pv

@@ -0,0 +1,18 @@
+def log_group(scope: Construct, name: str, retention_in_days: int = 3) -> CloudwatchLogGroup:
+    """
+    Creates a CloudWatch log group.
+
+    Args:
+        name (str): The name of the log group.
+        retention_in_days (int, optional): Default retention period in days. Defaults to 3 days.
+
+    Returns:
+        CloudwatchLogGroup: The created CloudWatch log group.
+    """
+    return CloudwatchLogGroup(
+        scope,
+        make_id(scope, name),
+        name=f"{scope.config.get('environment')}/{scope.config.get('product')}/{scope.config.get('domain')}/{name}",
+        retention_in_days=retention_in_days,
+        tags=make_tags(scope, name)
+    )

cloud_foundry-0.0.2/cloud_foundry/pulumi/python_function.py

@@ -0,0 +1,123 @@
+import pulumi
+import pulumi_aws as aws
+from cloud_foundry.utils.logger import logger
+
+from cloud_foundry.python_archive_builder import PythonArchiveBuilder
+
+log = logger(__name__)
+
+
+class PythonFunction(pulumi.ComponentResource):
+    name: str
+    handler: str
+    lambda_: aws.lambda_.Function
+
+    def __init__(
+        self,
+        name,
+        *,
+        hash: str,
+        archive_location: str,
+        handler: str,
+        environment: dict[str, str]=None,
+        actions: list[str]=None,
+        opts=None
+    ):
+        super().__init__("custom:cloud_forge:PythonFunction", name, {}, opts)
+        self.name = name
+        self.handler = handler
+        self.environment = environment or {}
+        self.actions = actions or []
+        self.create_lambda_function(hash, archive_location)
+        self.register_outputs({})
+
+    def create_execution_role(self) -> aws.iam.Role:
+        log.debug("creating execution role")
+        assume_role_policy = aws.iam.get_policy_document(
+            statements=[
+                aws.iam.GetPolicyDocumentStatementArgs(
+                    effect="Allow",
+                    principals=[
+                        aws.iam.GetPolicyDocumentStatementPrincipalArgs(
+                            type="Service",
+                            identifiers=["lambda.amazonaws.com"],
+                        )
+                    ],
+                    actions=["sts:AssumeRole"],
+                )
+            ]
+        )
+
+        role = aws.iam.Role(
+            f"{self.name}-lambda-execution",
+            assume_role_policy=assume_role_policy.json,
+            opts=pulumi.ResourceOptions(parent=self)
+        )
+
+        aws.iam.get_policy_document(
+            statements=[
+                aws.iam.GetPolicyDocumentStatementArgs(
+                    effect="Allow",
+                    actions=(self.actions + [
+                        "logs:CreateLogGroup",
+                        "logs:CreateLogStream",
+                        "logs:PutLogEvents",
+                    ]),
+                    resources=["*"],  
+                )
+            ]
+        )
+
+        return role
+
+    def create_log_group(self) -> aws.cloudwatch.LogGroup:
+        log_group = aws.cloudwatch.LogGroup(
+            f"{self.name}-log-group",
+            name=f"/aws/lambda/{pulumi.get_project()}-{self.name}",
+            retention_in_days=3,
+            opts=pulumi.ResourceOptions(parent=self)
+        )
+        return log_group
+
+    def invoke_arn(self) -> pulumi.Output[str]:
+        return self.lambda_.invoke_arn
+
+    def create_lambda_function(self, hash: str, archive_location: str):
+        log.debug("creating lambda function")
+
+        log_group = self.create_log_group()
+
+        execution_role = self.create_execution_role()
+
+        self.lambda_ = aws.lambda_.Function(
+            f"{self.name}-lambda",
+            code=pulumi.FileArchive(archive_location),
+            name=f"{pulumi.get_project()}-{self.name}",
+            role=execution_role.arn,
+            handler=self.handler,
+            source_code_hash=hash,
+            runtime=aws.lambda_.Runtime.PYTHON3D9,
+            environment=aws.lambda_.FunctionEnvironmentArgs(variables=self.environment),
+            opts=pulumi.ResourceOptions(depends_on=[execution_role, log_group], parent=self),
+        )
+
+def python_function(
+    name: str, *,
+    handler: str,
+    sources: dict[str, str] = None,
+    requirements: list[str] = None,
+    environment: dict[str, str] = None,
+):
+    archive_builder = PythonArchiveBuilder(
+        name=f"{name}-archive-builder",
+        sources=sources,
+        requirements=requirements,
+        working_dir="temp",
+    )
+    return PythonFunction(
+        name=name,
+        hash=archive_builder.hash(),
+        handler=handler,
+        archive_location=archive_builder.location(),
+        environment=environment,
+    )

cloud_foundry-0.0.2/cloud_foundry/pulumi/rest_api.py

@@ -0,0 +1,16 @@
+import pulumi
+import pulumi_aws as aws
+
+
+class GatewayAPI(pulumi.ComponentResource):
+    rest_api: aws.apigateway.RestApi
+
+    def __init__(self, name, body: str, opts=None):
+        super().__init__("cloud_forge:apigw:RestAPI", name, None, opts)
+
+        self.rest_api = aws.apigateway.RestApi(
+            f"{name}-http-api", name=f"{name}-http-api", body=body, opts=opts
+        )
+
+    def id(self) -> pulumi.Output[str]:
+        return self.rest_api.id

cloud_foundry-0.0.2/cloud_foundry/python_archive_builder.py

@@ -0,0 +1,198 @@
+import os
+import shutil
+import subprocess
+import sys
+
+from cloud_foundry.utils.logger import logger
+from cloud_foundry.utils.hash_comparator import HashComparator
+from cloud_foundry.archive_builder import ArchiveBuilder
+
+log = logger(__name__)
+
+
+class PythonArchiveBuilder(ArchiveBuilder):
+    _hash: str
+    _location: str
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        sources: dict[str, str],
+        requirements: list[str],
+        working_dir: str,
+    ):
+        self.name = name
+        self._sources = sources
+        self._requirements = requirements
+        self._working_dir = working_dir
+
+        self.prepare()
+
+        hash_comparator = HashComparator()
+        new_hash = hash_comparator.hash_folder(self._staging)
+        old_hash = hash_comparator.read(self._base_dir)
+        log.debug(f"old_hash: {old_hash}, new_hash: {new_hash}")
+        if old_hash == new_hash:
+            self._hash = old_hash or ""
+        else:
+            self.install_requirements()
+            self.build_archive()
+            self._hash = new_hash
+            hash_comparator.write(self._hash, self._base_dir)
+
+    def hash(self) -> str:
+        return self._hash
+
+    def location(self) -> str:
+        return self._location
+
+    def prepare(self):
+        self._base_dir = os.path.join(self._working_dir, f"{self.name}-lambda")
+        self._staging = os.path.join(self._base_dir, "staging")
+        self._libs = os.path.join(self._base_dir, "libs")
+        self._location = os.path.join(self._base_dir, f"{self.name}.zip")
+
+        self.create_clean_folder(self._staging)
+        self.create_clean_folder(self._libs)
+
+        self.install_sources()
+        self.write_requirements()
+
+    def build_archive(self):
+        log.info(f"building archive: {self.name}")
+        try:
+            shutil.make_archive(
+                base_name=self._location.replace('.zip', ''),
+                format='zip',
+                root_dir=self._base_dir
+            )
+            log.info("Archive built successfully")
+        except Exception as e:
+            log.error(f"Error building archive: {e}")
+            raise
+
+    def install_sources(self):
+        log.info(f"installing resources: {self.name}")
+        if not self._sources:
+            return
+        log.debug(f"sources: {self._sources}")
+        for destination, source in self._sources.items():
+            destination_path = os.path.join(self._staging, destination)
+
+            try:
+                if os.path.isdir(source):
+                    shutil.copytree(source, destination_path)
+                    log.info(f"Folder copied from {source} to {destination_path}")
+                elif os.path.isfile(source):
+                    os.makedirs(os.path.dirname(destination_path), exist_ok=True)
+                    shutil.copy2(source, destination_path)
+                    log.info(f"File copied from {source} to {destination_path}")
+                else:  # inline
+                    try:
+                        with open(destination_path, "w") as f:
+                            f.write(source + "\n")
+                    except Exception as e:
+                        log.error(
+                            "Error writing requirements to "
+                            + f"{destination_path}: {e}"
+                        )
+                        raise
+            except Exception as e:
+                log.error(f"Error copying {source} to {destination_path}: {e}")
+                raise
+
+    def write_requirements(self):
+        log.debug("writing requirements")
+        if not self._requirements:
+            return
+
+        requirements_path = os.path.join(self._staging, "requirements.txt")
+        try:
+            with open(requirements_path, "w") as f:
+                for requirement in self._requirements:
+                    f.write(requirement + "\n")
+        except Exception as e:
+            log.error(f"Error writing requirements to {requirements_path}: {e}")
+            raise
+
+    def install_requirements(self):
+        log.info(f"installing packages {self.name}")
+        requirements_file = os.path.join(self._staging, "requirements.txt")
+        if not os.path.exists(requirements_file):
+            log.warning(f"No requirements file found at {requirements_file}")
+            return
+
+        log.info(
+            f"Installing packages using: {sys.executable} -m pip3 "
+            + f"install --target {self._libs} --platform manylinux2010_x86_64 "
+            + "--implementation cp --only-binary=:all: --upgrade "
+            + f"--python-version 3.9 -r {requirements_file}"
+        )
+        self.clean_folder(self._libs)
+
+        try:
+            subprocess.check_call(
+                [
+                    sys.executable,
+                    "-m",
+                    "pip",
+                    "install",
+                    "-v",
+                    "--target",
+                    self._libs,
+                    "--platform",
+                    "manylinux2010_x86_64",
+                    "--implementation",
+                    "cp",
+                    "--only-binary=:all:",
+                    "--upgrade",
+                    "--python-version",
+                    "3.9",
+                    "-r",
+                    requirements_file,
+                ]
+            )
+        except subprocess.CalledProcessError as e:
+            log.error(f"Error installing requirements: {e}")
+            raise
+
+    def create_clean_folder(self, folder_path):
+        """
+        Create a clean folder by removing existing contents or creating
+        the folder if it doesn't exist.
+
+        Args:
+            folder_path (str): Path to the folder to clean or create.
+
+        Returns:
+            None
+        """
+        if os.path.exists(folder_path):
+            self.clean_folder(folder_path)
+        else:
+            os.makedirs(folder_path)
+
+    def clean_folder(self, folder_path):
+        """
+        Remove all files and folders from the specified folder.
+
+        Args:
+            folder_path (str): Path to the folder from which to remove
+            files and folders.
+
+        Returns:
+            None
+        """
+        log.info(f"Cleaning folder: {folder_path}")
+        try:
+            for item in os.listdir(folder_path):
+                item_path = os.path.join(folder_path, item)
+                if os.path.isfile(item_path):
+                    os.remove(item_path)
+                elif os.path.isdir(item_path):
+                    shutil.rmtree(item_path)
+            log.info(f"All files and folders removed from {folder_path}")
+        except Exception as e:
+            log.error(f"Error cleaning folder {folder_path}: {e}")
+            raise

cloud_foundry-0.0.2/cloud_foundry/utils/hash_comparator.py

@@ -0,0 +1,100 @@
+import hashlib
+import os
+import re
+from cloud_foundry.utils.logger import logger
+
+log = logger(__name__)
+
+class HashComparator:
+    def __init__(self, hash_algorithm="sha256"):
+        self.hash_algorithm = hash_algorithm
+
+    def check_folder(self, hash_file: str, hash_dir: str):
+        """Compares the stored hash with the current hash of the directory."""
+        old_hash = self.read(hash_file)
+        log.info(f"old_hash: {old_hash}")
+        if old_hash is None:
+            return False
+
+        new_hash = self.hash_folder(hash_dir)
+        log.info(f"new_hash: {new_hash}")
+        return self.compare(old_hash, new_hash)
+
+    def hash_file(self, file_path):
+        """Efficiently calculate the hash value of a file using streaming."""
+        hasher = hashlib.new(self.hash_algorithm)
+        with open(file_path, "rb") as f:
+            while chunk := f.read(4096):
+                hasher.update(chunk)
+        return hasher.hexdigest()
+
+    def hash_folder(self, folder_path, include_regex=None, exclude_regex=None, include_metadata=False):
+        """
+        Calculates a hash of the folder's contents (including its files and subfolders).
+
+        Args:
+            folder_path (str): Path to the folder to hash.
+            include_regex (str): Optional regex to include files.
+            exclude_regex (str): Optional regex to exclude files.
+            include_metadata (bool): If True, include file metadata (e.g., modification time) in the hash.
+        """
+        hasher = hashlib.new(self.hash_algorithm)
+        include_pattern = re.compile(include_regex) if include_regex else None
+        exclude_pattern = re.compile(exclude_regex) if exclude_regex else None
+
+        for root, dirs, files in os.walk(folder_path):
+            # Sort directories and files to ensure deterministic hash
+            dirs.sort()
+            files.sort()
+
+            for file in files:
+                file_path = os.path.join(root, file)
+
+                # Check if the file should be included or excluded
+                if include_pattern and not include_pattern.match(file):
+                    continue
+                if exclude_pattern and exclude_pattern.match(file):
+                    continue
+
+                # Update the folder hash with the file path and file content
+                relative_path = os.path.relpath(file_path, folder_path)
+                hasher.update(relative_path.encode())  # Update the hash with the file path
+                
+                if include_metadata:
+                    # Include metadata such as file modification time, size, and permissions
+                    stat = os.stat(file_path)
+                    hasher.update(str(stat.st_mtime).encode())  # Modification time
+                    hasher.update(str(stat.st_size).encode())   # File size
+                    hasher.update(str(stat.st_mode).encode())   # File permissions
+                
+                # Hash file content and update the folder hash
+                with open(file_path, "rb") as f:
+                    while chunk := f.read(4096):
+                        hasher.update(chunk)
+
+        return hasher.hexdigest()
+
+    def read(self, file_path):
+        """Read the hash value from a file (expected to be stored in a `.hash` file)."""
+        log.debug(f"reading hash: {file_path}")
+        hash_file = os.path.join(file_path, ".hash")
+
+        if not os.path.exists(hash_file):
+            return None
+
+        try:
+            with open(hash_file, "r") as f:
+                return f.read().strip()
+        except FileNotFoundError:
+            log.debug(f"hash file not found: {hash_file}")
+            return None
+
+    def write(self, hash_value, file_path):
+        """Write the hash value to a `.hash` file in the specified directory."""
+        log.debug(f"writing hash: {file_path}")
+        with open(os.path.join(file_path, ".hash"), "w") as f:
+            f.write(hash_value)
+
+    def compare(self, hash_value1, hash_value2):
+        """Compares two hash values."""
+        return hash_value1 == hash_value2

cloud_foundry-0.0.2/cloud_foundry/utils/logger.py

@@ -0,0 +1,60 @@
+import logging
+import os
+
+# Configuring the logging module with basic settings, including format and log level,
+# where the log level is obtained from the environment variable LOGGING_LEVEL
+# with a default of DEBUG, and force=True to ensure the configuration is applied immediately.
+logging.basicConfig(
+    format="%(name)s:%(lineno)s - %(levelname)s - %(message)s",
+    level=os.getenv("LOGGING_LEVEL", "DEBUG").upper(),
+    force=True,
+)
+
+WARN = logging.WARN
+INFO = logging.INFO
+DEBUG = logging.DEBUG
+
+
+def logger(name=None):
+    """
+    Function to create a logger with a specified name or default name.
+
+    Parameters:
+        name (str): Name of the logger. If not provided, the root logger is returned.
+
+    Returns:
+        logging.Logger: Logger object with the specified name or the root logger.
+
+    """
+    # Retrieving the logging level from the environment variable LOGGING_LEVEL
+    # with a default of DEBUG, and converting it to uppercase
+    loggingLevel = os.getenv("LOGGING_LEVEL", "DEBUG").upper()
+
+    # Setting the logging level for the root logger to the obtained logging level
+    logging.getLogger().setLevel(loggingLevel)
+
+    # Returning a logger object with the specified name or the root logger
+    return logging.getLogger(name)
+
+
+def write_logging_file(file_name, content):
+    """
+    Function to write a given string to a file in the temp/logging folder.
+
+    Parameters:
+        file_name (str): Name of the file to write the content to.
+        content (str): The string content to write to the file.
+
+    """
+    # Define the directory path
+    dir_path = os.path.join("temp", "logging")
+
+    # Ensure the directory exists
+    os.makedirs(dir_path, exist_ok=True)
+
+    # Define the file path
+    file_path = os.path.join(dir_path, file_name)
+
+    # Write the content to the file
+    with open(file_path, "w") as file:
+        file.write(content + "\n")

{cloud_foundry-0.0.1 → cloud_foundry-0.0.2}/pyproject.toml

@@ -1,10 +1,12 @@
+# src/pyproject.tomal
+
 [build-system]
 requires = ["hatchling>=1.0"]
 build-backend = "hatchling.build"
 
 [project]
 name = "cloud-foundry"
-version = "0.0.1"
+version = "0.0.2"
 authors = [
     { name="Daniel Repik", email="danrepik@icloud.com" },
 ]
@@ -24,10 +26,10 @@ dependencies = [
 "Source" = "https://github.com/DanRepik/cloud-foundry"
 
 [tool.hatch.build.targets.sdist]
-include = ["cloud-foundry"]
+include = ["cloud_foundry"]
 
 [tool.hatch.build.targets.wheel]
-include = ["cloud-foundry"]
+include = ["cloud_foundry"]
 
 [tool.pytest.ini_options]
 markers = [