velocity-python 0.0.109__py3-none-any.whl → 0.0.161__py3-none-any.whl

velocity/aws/handlers/base_handler.py

@@ -0,0 +1,248 @@
+"""
+Base Handler Module
+
+This module provides a base class for handling AWS Lambda events.
+It includes common functionality shared between LambdaHandler and SqsHandler.
+"""
+
+import os
+import sys
+import traceback
+from typing import Any, Dict, List, Optional
+
+from velocity.aws.handlers import context as VelocityContext
+
+
+class BaseHandler:
+    """
+    Base class for handling AWS Lambda events.
+
+    Provides common functionality including action routing, logging,
+    and error handling hooks that can be shared across different handler types.
+    """
+
+    def __init__(
+        self,
+        aws_event: Dict[str, Any],
+        aws_context: Any,
+        context_class=VelocityContext.Context,
+    ):
+        """
+        Initialize the base handler.
+
+        Args:
+            aws_event: The AWS Lambda event
+            aws_context: The AWS Lambda context object
+            context_class: The context class to use for processing
+        """
+        self.aws_event = aws_event
+        self.aws_context = aws_context
+        self.serve_action_default = True  # Set to False to disable OnActionDefault
+        self.skip_action = False  # Set to True to skip all actions
+        self.ContextClass = context_class
+
+        # Configure SSL certificates for HTTPS requests
+        self._update_lambda_ca_certificates()
+
+    def _update_lambda_ca_certificates(self):
+        """Configure SSL certificates for HTTPS requests in Lambda environments."""
+        # This is helpful for running HTTPS clients on lambda.
+        if os.path.exists("/opt/python/ca-certificates.crt"):
+            os.environ["REQUESTS_CA_BUNDLE"] = "/opt/python/ca-certificates.crt"
+        elif os.path.exists("/home/ubuntu/PyLibLayer/ca-certificates.crt"):
+            os.environ["REQUESTS_CA_BUNDLE"] = (
+                "/home/ubuntu/PyLibLayer/ca-certificates.crt"
+            )
+
+    def get_calling_function(self) -> str:
+        """
+        Get the name of the calling function by inspecting the call stack.
+
+        Returns:
+            The name of the calling function or "<Unknown>" if not found
+        """
+        skip_functions = {"x", "log", "_transaction", "get_calling_function"}
+
+        for idx in range(10):  # Limit search to prevent infinite loops
+            try:
+                frame = sys._getframe(idx)
+                function_name = frame.f_code.co_name
+
+                if function_name not in skip_functions:
+                    return function_name
+
+            except ValueError:
+                # No more frames in the stack
+                break
+
+        return "<Unknown>"
+
+    def format_action_name(self, action: str) -> str:
+        """
+        Format an action string into a method name.
+
+        Args:
+            action: The raw action string (e.g., "create-user", "delete_item")
+
+        Returns:
+            Formatted method name (e.g., "OnActionCreateUser", "OnActionDeleteItem")
+        """
+        if not action:
+            return ""
+
+        formatted = action.replace("-", " ").replace("_", " ")
+        return f"on action {formatted}".title().replace(" ", "")
+
+    def get_actions_to_execute(self, action: Optional[str]) -> List[str]:
+        """
+        Get the list of actions to execute.
+
+        Args:
+            action: The specific action to execute, if any
+
+        Returns:
+            List of action method names to try executing
+        """
+        actions = []
+
+        # Add specific action if available
+        if action:
+            action_method = self.format_action_name(action)
+            actions.append(action_method)
+
+        # Add default action if enabled
+        if self.serve_action_default:
+            actions.append("OnActionDefault")
+
+        return actions
+
+    def execute_actions(self, tx, local_context, actions: List[str]) -> bool:
+        """
+        Execute the appropriate actions for the given context.
+
+        Args:
+            tx: Database transaction object
+            local_context: The context object
+            actions: List of action method names to try
+
+        Returns:
+            True if an action was executed, False otherwise
+        """
+        # Execute beforeAction hook if available
+        if hasattr(self, "beforeAction"):
+            self.beforeAction(tx, local_context)
+
+        action_executed = False
+
+        # Execute the first matching action
+        for action in actions:
+            if self.skip_action:
+                break
+
+            if hasattr(self, action):
+                result = getattr(self, action)(tx, local_context)
+
+                # Check for deprecated return values (LambdaHandler specific)
+                if result is not None and hasattr(self, "_check_deprecated_return"):
+                    self._check_deprecated_return(action, result)
+
+                action_executed = True
+                break
+
+        # Execute afterAction hook if available
+        if hasattr(self, "afterAction"):
+            self.afterAction(tx, local_context)
+
+        return action_executed
+
+    def handle_error(self, tx, local_context, exception: Exception):
+        """
+        Handle errors that occur during action execution.
+
+        Args:
+            tx: Database transaction object
+            local_context: The context object
+            exception: The exception that occurred
+        """
+        if hasattr(self, "onError"):
+            self.onError(
+                tx,
+                local_context,
+                exc=exception.__class__.__name__,
+                tb=traceback.format_exc(),
+            )
+        else:
+            # Re-raise if no error handler is defined
+            raise exception
+
+    def log(self, tx, message: str, function: Optional[str] = None):
+        """
+        Log a message to the system log table.
+        This is a base implementation that should be overridden by subclasses
+        to provide handler-specific logging details.
+
+        Args:
+            tx: Database transaction object
+            message: The message to log
+            function: Optional function name, auto-detected if not provided
+        """
+        if not function:
+            function = self.get_calling_function()
+
+        # Base log data - subclasses should extend this
+        data = {
+            "app_name": os.environ.get("ProjectName", "Unknown"),
+            "function": function,
+            "message": message,
+        }
+
+        # Let subclasses add their specific fields
+        self._extend_log_data(data)
+
+        tx.table("sys_log").insert(data)
+
+    def _extend_log_data(self, data: Dict[str, Any]):
+        """
+        Extend log data with handler-specific fields.
+        To be overridden by subclasses.
+
+        Args:
+            data: The base log data dictionary to extend
+        """
+        # Default implementation adds basic Lambda info
+        data.update(
+            {
+                "user_agent": "AWS Lambda",
+                "device_type": "Lambda",
+                "sys_modified_by": "Lambda",
+            }
+        )
+
+    def OnActionDefault(self, local_context):
+        """
+        Default action handler when no specific action is found.
+
+        Args:
+            local_context: The context object
+        """
+        action = getattr(local_context, "action", lambda: "unknown")()
+        warning_message = (
+            f"[Warn] Action handler not found. Calling default action "
+            f"`{self.__class__.__name__}.OnActionDefault` with the following parameters:\n"
+            f"  - action: {action}\n"
+            f"  - handler: {self.__class__.__name__}"
+        )
+        print(warning_message)
+
+    def get_context_args(self) -> Dict[str, Any]:
+        """
+        Get the arguments to pass to the context constructor.
+        To be implemented by subclasses based on their specific needs.
+
+        Returns:
+            Dictionary of arguments for context initialization
+        """
+        return {
+            "aws_event": self.aws_event,
+            "aws_context": self.aws_context,
+        }

velocity/aws/handlers/context.py

@@ -1,6 +1,15 @@
+import json
+import os
+import boto3
+import uuid
 import support.app
+from velocity.misc.format import to_json
+from velocity.misc.merge import deep_merge
+from datetime import datetime
 
-engine = support.app.postgres()
+import velocity.db
+
+engine = velocity.db.postgres.initialize()
 
 
 @engine.transaction
@@ -12,10 +21,12 @@ class Context:
         self.__args = args
         self.__postdata = postdata
         self.__response = response
-        self.__session = session
+        self.__session = {} if session is None else session
         self.__aws_event = aws_event
         self.__aws_context = aws_context
         self.__log = log
+        self._job_record_cache = {}
+        self._job_cancelled_flag = False
 
     def postdata(self, keys=-1, default=None):
         if keys == -1:
@@ -68,3 +79,241 @@ class Context:
                 print(f"{function}: {message}")
             else:
                 print(f"{message}")
+
+    def update_job(self, tx, data=None):
+        """Update job status and message in aws_job_activity table.
+
+        This method only UPDATES existing jobs. For creating new jobs, use create_job.
+        """
+        if not data:
+            return
+        if self.postdata("job_id"):
+            # Sanitize data before storing in database
+            sanitized_data = self._sanitize_job_data(data)
+            job_id = self.postdata("job_id")
+            tx.table("aws_job_activity").update(sanitized_data, {"job_id": job_id})
+            self._job_record_cache.pop(job_id, None)
+            tx.commit()
+
+    def create_job(self, tx, job_data=None):
+        """Create a new job record in aws_job_activity table using independent transaction."""
+        if not job_data:
+            return
+        sanitized_data = self._sanitize_job_data(job_data)
+        tx.table("aws_job_activity").insert(sanitized_data)
+        job_id = sanitized_data.get("job_id")
+        if job_id:
+            self._job_record_cache.pop(job_id, None)
+        tx.commit()
+
+    def _sanitize_job_data(self, data):
+        """Sanitize sensitive data before storing in aws_job_activity table."""
+        if not isinstance(data, dict):
+            return data
+
+        sanitized = {}
+
+        # List of sensitive field patterns to sanitize
+        sensitive_patterns = [
+            "password",
+            "token",
+            "secret",
+            "key",
+            "credential",
+            "auth",
+            "cognito_user",
+            "session",
+            "cookie",
+            "authorization",
+        ]
+
+        for key, value in data.items():
+            # Check if key contains sensitive patterns
+            if any(pattern in key.lower() for pattern in sensitive_patterns):
+                sanitized[key] = "[REDACTED]" if value else value
+            elif key == "error" and value:
+                # Sanitize error messages - keep first 500 chars and remove potential sensitive info
+                error_str = str(value)[:500]
+                for pattern in sensitive_patterns:
+                    if pattern in error_str.lower():
+                        # Replace potential sensitive values with placeholder
+                        import re
+
+                        # Remove patterns like password=value, token=value, etc.
+                        error_str = re.sub(
+                            rf"{pattern}[=:]\s*[^\s,\]}}]+",
+                            f"{pattern}=[REDACTED]",
+                            error_str,
+                            flags=re.IGNORECASE,
+                        )
+                sanitized[key] = error_str
+            elif key == "traceback" and value:
+                # Sanitize traceback - keep structure but remove sensitive values
+                tb_str = str(value)
+                for pattern in sensitive_patterns:
+                    if pattern in tb_str.lower():
+                        import re
+
+                        # Remove patterns like password=value, token=value, etc.
+                        tb_str = re.sub(
+                            rf"{pattern}[=:]\s*[^\s,\]}}]+",
+                            f"{pattern}=[REDACTED]",
+                            tb_str,
+                            flags=re.IGNORECASE,
+                        )
+                # Limit traceback size to prevent DB bloat
+                sanitized[key] = tb_str[:2000]
+            elif key == "message" and value:
+                # Sanitize message field
+                message_str = str(value)
+                for pattern in sensitive_patterns:
+                    if pattern in message_str.lower():
+                        import re
+
+                        message_str = re.sub(
+                            rf"{pattern}[=:]\s*[^\s,\]}}]+",
+                            f"{pattern}=[REDACTED]",
+                            message_str,
+                            flags=re.IGNORECASE,
+                        )
+                sanitized[key] = message_str[:1000]  # Limit message size
+            else:
+                # For other fields, copy as-is but check for nested dicts
+                if isinstance(value, dict):
+                    sanitized[key] = self._sanitize_job_data(value)
+                elif isinstance(value, str) and len(value) > 5000:
+                    # Limit very large string fields
+                    sanitized[key] = value[:5000] + "...[TRUNCATED]"
+                else:
+                    sanitized[key] = value
+
+        return sanitized
+
+    def _get_job_record(self, tx, job_id=None, refresh=False):
+        job_id = job_id or self.postdata("job_id")
+        if not job_id:
+            return None
+
+        if refresh or job_id not in self._job_record_cache:
+            record = tx.table("aws_job_activity").find({"job_id": job_id})
+            if record is not None:
+                self._job_record_cache[job_id] = record
+            elif job_id in self._job_record_cache:
+                del self._job_record_cache[job_id]
+
+        return self._job_record_cache.get(job_id)
+
+    def is_job_cancel_requested(self, tx, force_refresh=False):
+        job = self._get_job_record(tx, refresh=force_refresh)
+        if not job:
+            return False
+
+        status = (job.get("status") or "").lower()
+        if status in {"cancelrequested", "cancelled"}:
+            return True
+
+        message_raw = job.get("message")
+        if not message_raw:
+            return False
+
+        if isinstance(message_raw, dict):
+            message = message_raw
+        else:
+            try:
+                message = json.loads(message_raw)
+            except (TypeError, ValueError, json.JSONDecodeError):
+                return False
+
+        return bool(message.get("cancel_requested") or message.get("cancelled"))
+
+    def mark_job_cancelled(self, tx, detail=None, requested_by=None):
+        job_id = self.postdata("job_id")
+        if not job_id:
+            return
+
+        job = self._get_job_record(tx, refresh=True) or {}
+        message_raw = job.get("message")
+        if isinstance(message_raw, dict):
+            message = dict(message_raw)
+        else:
+            try:
+                message = json.loads(message_raw) if message_raw else {}
+            except (TypeError, ValueError, json.JSONDecodeError):
+                message = {}
+
+        message.update(
+            {
+                "detail": detail or "Job cancelled",
+                "cancelled": True,
+            }
+        )
+
+        tx.table("aws_job_activity").update(
+            {
+                "status": "Cancelled",
+                "message": to_json(message),
+                "handler_complete_timestamp": datetime.now(),
+                "sys_modified": datetime.now(),
+                "sys_modified_by": requested_by
+                or self.session().get("email_address")
+                or "system",
+            },
+            {"job_id": job_id},
+        )
+        tx.commit()
+        self._job_record_cache.pop(job_id, None)
+        self._job_cancelled_flag = True
+
+    def was_job_cancelled(self):
+        return self._job_cancelled_flag
+
+    def enqueue(self, action, payload={}, user=None, suppress_job_activity=False):
+        """
+        Enqueue jobs to SQS with independent job activity tracking.
+
+        This method uses its own transaction for aws_job_activity updates to ensure
+        job tracking is never rolled back with other operations.
+        """
+        batch_id = str(uuid.uuid4())
+        results = {"batch_id": batch_id}
+        queue = boto3.resource("sqs").get_queue_by_name(
+            QueueName=os.environ["SqsWorkQueue"]
+        )
+        if isinstance(payload, dict):
+            payload = [payload]
+        messages = []
+        if user is None:
+            user = self.session().get("email_address") or "EnqueueTasks"
+        for item in payload:
+            message = {"action": action, "payload": item}
+            id = str(uuid.uuid4()).split("-")[0]
+            if suppress_job_activity:
+                messages.append({"Id": id, "MessageBody": to_json(message)})
+            else:
+                message["job_id"] = id
+                # Use separate transaction for job activity - this should never be rolled back
+                self.create_job(
+                    {
+                        "action": action,
+                        "initial_timestamp": datetime.now(),
+                        "created_by": user,
+                        "sys_modified_by": user,
+                        "payload": to_json(message),
+                        "batch_id": str(batch_id),
+                        "job_id": id,
+                        "status": "Initialized",
+                        "message": "Job Initialized",
+                    }
+                )
+                messages.append({"Id": id, "MessageBody": to_json(message)})
+
+            if len(messages) == 10:
+                result = queue.send_messages(Entries=messages)
+                results = deep_merge(results, result)
+                messages.clear()
+
+        if messages:
+            result = queue.send_messages(Entries=messages)
+            results = deep_merge(results, result)
+
+        return results

velocity/aws/handlers/exceptions.py

@@ -0,0 +1,16 @@
+class AppError(Exception):
+    pass
+
+
+class AccessError(AppError):
+    pass
+
+
+class AlertError(AppError):
+    def get_payload(self):
+        data = self.args[0]
+        if isinstance(data, str):
+            return {"message": data}
+        elif isinstance(data, dict):
+            return data
+        return {"message": "No message was supplied to AlertError"}

velocity/aws/handlers/lambda_handler.py

@@ -1,23 +1,17 @@
-from velocity.misc.format import to_json
 import json
-import sys
-import os
-import traceback
-from support.app import DEBUG
-from support.app import helpers, AlertError, enqueue
-
-from velocity.aws.handlers import Response
-
+from velocity.aws.handlers.base_handler import BaseHandler
+from velocity.aws.handlers.response import Response
 from . import context
 
+# TODO: helpers import needs to be resolved - may need to pass table name instead
+# from some_app import helpers
+
 
-class LambdaHandler:
+class LambdaHandler(BaseHandler):
     def __init__(self, aws_event, aws_context, context_class=context.Context):
-        self.aws_event = aws_event
-        self.aws_context = aws_context
-        self.serve_action_default = True  # Set to False to disable OnActionDefault
-        self.skip_action = False  # Set to True to skip all actions
+        super().__init__(aws_event, aws_context, context_class)
 
+        # LambdaHandler-specific initialization
         requestContext = aws_event.get("requestContext") or {}
         identity = requestContext.get("identity") or {}
         headers = aws_event.get("headers") or {}
@@ -48,36 +42,6 @@ class LambdaHandler:
         else:
             self.session["device_type"] = "unknown"
 
-        self.ContextClass = context_class
-
-    def log(self, tx, message, function=None):
-        if not function:
-            function = "<Unknown>"
-            idx = 0
-            while True:
-                try:
-                    temp = sys._getframe(idx).f_code.co_name
-                except ValueError as e:
-                    break
-                if temp in ["x", "log", "_transaction"]:
-                    idx += 1
-                    continue
-                function = temp
-                break
-
-        data = {
-            "app_name": os.environ["ProjectName"],
-            "source_ip": self.session["source_ip"],
-            "referer": self.session["referer"],
-            "user_agent": self.session["user_agent"],
-            "device_type": self.session["device_type"],
-            "function": function,
-            "message": message,
-        }
-        if "email_address" in self.session:
-            data["sys_modified_by"] = self.session["email_address"]
-        tx.table("sys_log").insert(data)
-
     def serve(self, tx):
         response = Response()
         body = self.aws_event.get("body")
@@ -85,7 +49,7 @@ class LambdaHandler:
         if isinstance(body, str) and len(body) > 0:
             try:
                 postdata = json.loads(body)
-            except:
+            except (json.JSONDecodeError, TypeError):
                 postdata = {"raw_body": body}
         elif isinstance(body, dict):
             postdata = body
@@ -93,7 +57,7 @@ class LambdaHandler:
             try:
                 new = "\n".join(body)
                 postdata = json.loads(new)
-            except:
+            except (json.JSONDecodeError, TypeError):
                 postdata = {"raw_body": body}
 
         req_params = self.aws_event.get("queryStringParameters") or {}
@@ -106,43 +70,20 @@ class LambdaHandler:
             session=self.session,
             log=lambda message, function=None: self.log(message, function),
         )
+
+        # Determine action from postdata or query parameters
+        action = postdata.get("action") or req_params.get("action")
+        
+        # Get the list of actions to execute
+        actions = self.get_actions_to_execute(action)
+        
+        # Use BaseHandler's execute_actions method
         try:
-            if hasattr(self, "beforeAction"):
-                self.beforeAction(local_context)
-            actions = []
-            action = postdata.get("action", req_params.get("action"))
-            if action:
-                actions.append(
-                    f"on action {action.replace('-', ' ').replace('_', ' ')}".title().replace(
-                        " ", ""
-                    )
-                )
-            if self.serve_action_default:
-                actions.append("OnActionDefault")
-            for action in actions:
-                if self.skip_action:
-                    break
-                if hasattr(self, action):
-                    result = getattr(self, action)(local_context)
-                    if result is not None:
-                        raise Exception(
-                            f"Deprecated Feature Error: Action {action} returned a response but this is not allowed. Use Repsonse object instead: {type(result)}"
-                        )
-                    break
-            if hasattr(self, "afterAction"):
-                self.afterAction(local_context)
-        except AlertError as e:
-            response.alert(e.get_payload())
+            self.execute_actions(tx, local_context, actions)
         except Exception as e:
-            response.exception()
-            if hasattr(self, "onError"):
-                self.onError(
-                    local_context,
-                    exc=e.__class__.__name__,
-                    tb=traceback.format_exc(),
-                )
-
-        return response.render()
+            self.handle_error(tx, local_context, e)
+            
+        return local_context.response().render()
 
     def track(self, tx, data={}, user=None):
         data = data.copy()
@@ -155,7 +96,8 @@ class LambdaHandler:
                 "sys_modified_by": self.session["email_address"],
             }
         )
-        tx.table(helpers.get_tracking_table(user or self.session)).insert(data)
+        # TODO: Fix undefined helpers reference
+        # tx.table(helpers.get_tracking_table(user or self.session)).insert(data)
 
     def OnActionDefault(self, tx, context):
         context.response().set_body(
@@ -164,6 +106,3 @@ class LambdaHandler:
 
     def OnActionTracking(self, tx, context):
         self.track(tx, context.payload().get("data", {}))
-
-    def enqueue(self, tx, action, payload={}):
-        enqueue(tx, action, payload, self.session["email_address"])