salla-gitpuller 0.1.2__tar.gz → 1.0.0__tar.gz

{salla_gitpuller-0.1.2 → salla_gitpuller-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salla_gitpuller
-Version: 0.1.2
+Version: 1.0.0
 Summary: A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables
 Author-email: Muhammad Zahid <zahidmuhammad127@gmail.com>
 License: MIT

salla_gitpuller-1.0.0/gitpuller/__init__.py

@@ -0,0 +1,19 @@
+from .gitpull import GitPullExecutor
+from .alert_manager import AlertManager
+from .state_manager import StateManager, InMemoryStateManager, MageAIStateManager
+from .slack_notifier import SlackNotifier
+from .utils import transform_custom, get_repo_path, get_env_base_path
+
+
+__version__ = "1.0.0"
+__all__ = [
+    "GitPullExecutor",
+    "AlertManager",
+    "StateManager",
+    "InMemoryStateManager",
+    "MageAIStateManager",
+    "SlackNotifier",
+    "transform_custom", 
+    "get_repo_path", 
+    "get_env_base_path"
+]

salla_gitpuller-1.0.0/gitpuller/alert_manager.py

@@ -0,0 +1,63 @@
+from datetime import datetime, timedelta
+from typing import Any, Dict, Optional, Tuple
+from .state_manager import StateManager, InMemoryStateManager, MageAIStateManager
+
+class AlertManager:    
+    def __init__(self, state_manager: Optional[StateManager] = None, use_mage_ai: bool = False):
+        if state_manager is not None:
+            self.state_manager = state_manager
+        elif use_mage_ai:
+            try:
+                self.state_manager = MageAIStateManager()
+            except ImportError:
+                print("⚠️ Mage AI not available, falling back to in-memory state manager")
+                self.state_manager = InMemoryStateManager()
+        else:
+            self.state_manager = InMemoryStateManager()
+    
+    def should_send_alert(
+        self, 
+        pipeline_uuid: str, 
+        current_error: str, 
+        suppression_hours: int = 1
+    ) -> Tuple[bool, Dict[str, Any]]:
+        
+        state = self.state_manager.load_alert_state(pipeline_uuid)
+        last_error = state.get("last_error_message")
+        last_alert_time_str = state.get("last_alert_time")
+        
+        # If no previous alert, always send
+        if not last_error or not last_alert_time_str:
+            return True, {"last_error_message": None, "last_alert_time": None}
+        
+        # If error is different, always send
+        if last_error != current_error:
+            return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
+        
+        # Same error - check if enough time has passed
+        try:
+            last_alert_time = datetime.fromisoformat(last_alert_time_str)
+            time_since_last_alert = datetime.now() - last_alert_time
+            
+            if time_since_last_alert >= timedelta(hours=suppression_hours):
+                return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
+            else:
+                return False, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
+        except (ValueError, TypeError):
+            # If we can't parse the time, send the alert to be safe
+            return True, {"last_error_message": last_error, "last_alert_time": last_alert_time_str}
+    
+    def save_alert_state(
+        self, 
+        pipeline_uuid: str, 
+        error_message: str, 
+        alert_time: datetime, 
+        pipeline_status: str
+    ) -> None:
+        """Save alert state."""
+        self.state_manager.save_alert_state(pipeline_uuid, error_message, alert_time, pipeline_status)
+    
+    def clear_alert_state(self, pipeline_uuid: str) -> None:
+        """Clear alert state on success."""
+        self.state_manager.clear_alert_state(pipeline_uuid)
+

salla_gitpuller-1.0.0/gitpuller/gitpull.py

@@ -0,0 +1,202 @@
+import os
+import subprocess
+from typing import Dict, Any, Optional
+from datetime import datetime
+from .alert_manager import AlertManager
+from .slack_notifier import SlackNotifier
+
+class GitPullExecutor:    
+    def __init__(
+        self,
+        slack_webhook_url: Optional[str] = None,
+        use_mage_ai: bool = False,
+        state_manager: Optional[Any] = None
+    ):
+        self.slack_notifier = SlackNotifier(webhook_url=slack_webhook_url)
+        self.alert_manager = AlertManager(state_manager=state_manager, use_mage_ai=use_mage_ai)
+    
+    def normalize_ssh_key(self, key_material: str) -> str:
+        if not key_material:
+            return key_material
+        
+        # Remove any quotes that might be wrapping the key
+        key_material = key_material.strip().strip('"').strip("'")
+        
+        # Handle literal \n sequences
+        if "\\n" in key_material:
+            key_material = key_material.replace("\\n", "\n")
+        
+        # Ensure proper line endings
+        if not key_material.endswith("\n"):
+            key_material += "\n"
+        
+        return key_material
+    
+    def prepare_ssh_key(
+        self, 
+        key_material: str, 
+        key_filename: str = "deploy_key",
+        ssh_dir: str = "/home/src/.ssh"
+    ) -> str:
+        os.makedirs(ssh_dir, exist_ok=True)
+        os.chmod(ssh_dir, 0o700)
+        
+        key_path = os.path.join(ssh_dir, key_filename)
+        
+        # Write key with restricted permissions
+        with open(key_path, "w") as f:
+            f.write(key_material)
+        os.chmod(key_path, 0o600)
+        
+        return key_path
+    
+    def execute_git_pull(
+        self,
+        repo_path: str,
+        git_url: str,
+        branch: str = "master",
+        ssh_key: Optional[str] = None,
+        workspace_name: Optional[str] = None,
+        key_filename: Optional[str] = None,
+        ssh_dir: str = "/home/src/.ssh"
+    ) -> Dict[str, Any]:
+        if not os.path.exists(repo_path):
+            raise ValueError(f"Repo path does not exist: {repo_path}")
+        
+        # Get SSH key
+        if not ssh_key and workspace_name:
+            key_env_name = f"{workspace_name}_SSHKEY"
+            ssh_key = os.environ.get(key_env_name)
+            if not ssh_key:
+                raise ValueError(f"Missing env var {key_env_name} with the PRIVATE deploy key")
+        elif not ssh_key:
+            raise ValueError("SSH key is required. Provide it directly or set workspace_name.")
+        
+        # Normalize key
+        ssh_key = self.normalize_ssh_key(ssh_key)
+        
+        # Prepare key file
+        if not key_filename:
+            key_filename = f"{workspace_name}_deploy" if workspace_name else "deploy_key"
+        
+        key_path = self.prepare_ssh_key(ssh_key, key_filename, ssh_dir)
+        
+        # Execute git pull
+        cmd = [
+            "git",
+            "-c",
+            f"core.sshCommand=ssh -i {key_path} -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new",
+            "pull",
+            git_url,
+            branch,
+        ]
+        
+        git_output = ""
+        git_status = "success"
+        key_env_var_used = f"{workspace_name}_SSHKEY" if workspace_name else "N/A"
+        
+        original_dir = None
+        try:
+            original_dir = os.getcwd()
+            os.chdir(repo_path)
+            
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            git_output = result.stdout
+            git_status = "success"
+        except subprocess.CalledProcessError as e:
+            git_output = (e.stdout or "") + (e.stderr or "")
+            git_status = "error"
+            raise
+        finally:
+            if original_dir:
+                try:
+                    os.chdir(original_dir)
+                except Exception:
+                    pass
+            # Clean up the key file
+            try:
+                os.remove(key_path)
+            except Exception:
+                pass
+        
+        return {
+            "workspace": workspace_name or "N/A",
+            "repo_path": repo_path,
+            "git_pull_status": git_status,
+            "git_pull_output": git_output.strip(),
+            "key_env_var_used": key_env_var_used,
+        }
+    
+    def execute_with_alerting(
+        self,
+        repo_path: str,
+        git_url: str,
+        branch: str = "master",
+        ssh_key: Optional[str] = None,
+        workspace_name: Optional[str] = None,
+        pipeline_uuid: str = "auto_git_pull",
+        suppression_hours: int = 1,
+        key_filename: Optional[str] = None,
+        ssh_dir: str = "/home/src/.ssh"
+    ) -> Dict[str, Any]:
+        repo_name = git_url.split('/')[-1].replace('.git', '')
+        
+        try:
+            result = self.execute_git_pull(
+                repo_path=repo_path,
+                git_url=git_url,
+                branch=branch,
+                ssh_key=ssh_key,
+                workspace_name=workspace_name,
+                key_filename=key_filename,
+                ssh_dir=ssh_dir
+            )
+            
+            # Clear alert state on success
+            self.alert_manager.clear_alert_state(pipeline_uuid)
+            
+            return result
+            
+        except Exception as e:
+            git_output = str(e)
+            error_signature = git_output.strip()[:500]
+            
+            # Check if we should send alert
+            should_alert, _ = self.alert_manager.should_send_alert(
+                pipeline_uuid,
+                error_signature,
+                suppression_hours=suppression_hours
+            )
+            
+            if should_alert:
+                # Send alert
+                self.slack_notifier.send_alert(repo_name, git_output[:1500])
+                
+                # Save alert state
+                self.alert_manager.save_alert_state(
+                    pipeline_uuid,
+                    error_signature,
+                    datetime.now(),
+                    pipeline_status="failed"
+                )
+            else:
+                # Alert suppressed
+                state = self.alert_manager.state_manager.load_alert_state(pipeline_uuid)
+                last_alert_time = state.get("last_alert_time")
+                if last_alert_time:
+                    try:
+                        from datetime import datetime, timedelta
+                        last_alert_dt = datetime.fromisoformat(last_alert_time)
+                        time_since = datetime.now() - last_alert_dt
+                        print(f"🔇 Alert suppressed - same error occurred {time_since} ago (suppression window: {suppression_hours} hour(s))")
+                    except:
+                        print(f"🔇 Alert suppressed - same error within suppression window ({suppression_hours} hour(s))")
+            
+            # Re-raise the exception
+            raise
+

salla_gitpuller-1.0.0/gitpuller/slack_notifier.py

@@ -0,0 +1,60 @@
+import os
+import requests
+from typing import Optional, Dict, Any
+
+
+class SlackNotifier:
+    
+    def __init__(self, webhook_url: Optional[str] = None):
+        self.webhook_url = webhook_url or os.environ.get("CDM_SLACK_WEBHOOK_URL")
+        if not self.webhook_url:
+            raise ValueError(
+                "Slack webhook URL is required. "
+                "Provide it as parameter or set CDM_SLACK_WEBHOOK_URL environment variable."
+            )
+    
+    def create_failure_payload(self, repo_name: str, error_output: str) -> Dict[str, Any]:
+        payload = {
+            "text": f"Automate Git Pull Pipeline Failed",
+            "blocks": [
+                {
+                    "type": "header",
+                    "text": {
+                        "type": "plain_text",
+                        "text": f":alert: Automate Git Pull Pipeline Failed :alert:"
+                    }
+                },
+                {
+                    "type": "divider"
+                },
+                {
+                    "type": "section",
+                    "text": {
+                        "type": "mrkdwn",
+                        "text": f"*Repository:* `{repo_name}`"
+                    }
+                }
+            ]
+        }
+        
+        if error_output:
+            payload["blocks"].append({
+                "type": "section",
+                "text": {
+                    "type": "mrkdwn",
+                    "text": f"*Error Output:*\n```{error_output[:1500]}```"
+                }
+            })
+        
+        return payload
+    
+    def send_alert(self, repo_name: str, error_output: str = "") -> bool:
+        try:
+            payload = self.create_failure_payload(repo_name, error_output)
+            response = requests.post(self.webhook_url, json=payload, timeout=10)
+            response.raise_for_status()
+            print("✅ Alert sent to Slack")
+            return True
+        except Exception as e:
+            print(f"⚠️ Failed to send Slack alert: {e}")
+            return False

salla_gitpuller-1.0.0/gitpuller/state_manager.py

@@ -0,0 +1,113 @@
+from typing import Any, Dict, Optional
+from datetime import datetime
+
+class StateManager:    
+    def load_alert_state(self, pipeline_uuid: str) -> Dict[str, Any]:
+        """Load alert state for a pipeline."""
+        raise NotImplementedError
+    
+    def save_alert_state(
+        self, 
+        pipeline_uuid: str, 
+        error_message: str, 
+        alert_time: datetime, 
+        pipeline_status: str
+    ) -> None:
+        """Save alert state for a pipeline."""
+        raise NotImplementedError
+    
+    def clear_alert_state(self, pipeline_uuid: str) -> None:
+        """Clear alert state for a pipeline."""
+        raise NotImplementedError
+
+class InMemoryStateManager(StateManager):    
+    def __init__(self):
+        self._state: Dict[str, Dict[str, Any]] = {}
+    
+    def load_alert_state(self, pipeline_uuid: str) -> Dict[str, Any]:
+        """Load alert state from memory."""
+        return self._state.get(pipeline_uuid, {
+            "last_alert_time": None,
+            "last_error_message": None
+        })
+    
+    def save_alert_state(
+        self, 
+        pipeline_uuid: str, 
+        error_message: str, 
+        alert_time: datetime, 
+        pipeline_status: str
+    ) -> None:
+        """Save alert state to memory."""
+        self._state[pipeline_uuid] = {
+            "last_alert_time": alert_time.isoformat(),
+            "last_error_message": error_message,
+            "pipeline_status": pipeline_status,
+            "last_alert_timestamp": alert_time.isoformat()
+        }
+    
+    def clear_alert_state(self, pipeline_uuid: str) -> None:
+        """Clear alert state from memory."""
+        if pipeline_uuid in self._state:
+            self._state[pipeline_uuid] = {
+                "last_alert_time": None,
+                "last_error_message": None,
+                "pipeline_status": "success"
+            }
+
+class MageAIStateManager(StateManager):    
+    def __init__(self):
+        try:
+            from mage_ai.data_preparation.variable_manager import (
+                set_global_variable, 
+                get_global_variable
+            )
+            self._set_global_variable = set_global_variable
+            self._get_global_variable = get_global_variable
+        except ImportError:
+            raise ImportError(
+                "Mage AI is not installed. Install it with: pip install mage-ai"
+            )
+    
+    def load_alert_state(self, pipeline_uuid: str) -> Dict[str, Any]:
+        try:
+            last_error_message = self._get_global_variable(pipeline_uuid, 'last_error_message')
+            last_alert_time = self._get_global_variable(pipeline_uuid, 'last_alert_time')
+            
+            if last_error_message and last_alert_time:
+                return {
+                    "last_alert_time": last_alert_time,
+                    "last_error_message": last_error_message
+                }
+        except Exception as e:
+            print(f"⚠️ Warning: Could not load alert state from global variables: {e}")
+        
+        return {
+            "last_alert_time": None,
+            "last_error_message": None
+        }
+    
+    def save_alert_state(
+        self, 
+        pipeline_uuid: str, 
+        error_message: str, 
+        alert_time: datetime, 
+        pipeline_status: str
+    ) -> None:
+        try:
+            self._set_global_variable(pipeline_uuid, 'last_error_message', error_message)
+            self._set_global_variable(pipeline_uuid, 'last_alert_time', alert_time.isoformat())
+            self._set_global_variable(pipeline_uuid, 'pipeline_status', pipeline_status)
+            self._set_global_variable(pipeline_uuid, 'last_alert_timestamp', alert_time.isoformat())
+            print(f"✅ Saved alert state to global variables: error_message, pipeline_status={pipeline_status}")
+        except Exception as e:
+            print(f"⚠️ Warning: Could not save alert state to global variables: {e}")
+    
+    def clear_alert_state(self, pipeline_uuid: str) -> None:
+        try:
+            self._set_global_variable(pipeline_uuid, 'last_error_message', None)
+            self._set_global_variable(pipeline_uuid, 'last_alert_time', None)
+            self._set_global_variable(pipeline_uuid, 'pipeline_status', 'success')
+            print("✅ Cleared alert state from global variables")
+        except Exception as e:
+            print(f"⚠️ Warning: Could not clear alert state: {e}")

{salla_gitpuller-0.1.2 → salla_gitpuller-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "salla_gitpuller"
-version = "0.1.2"
+version = "1.0.0"
 description = "A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables"
 readme = "README.md"
 authors = [

{salla_gitpuller-0.1.2 → salla_gitpuller-1.0.0}/salla_gitpuller.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salla_gitpuller
-Version: 0.1.2
+Version: 1.0.0
 Summary: A lightweight utility to git pull a repository using SSH deploy keys stored in environment variables
 Author-email: Muhammad Zahid <zahidmuhammad127@gmail.com>
 License: MIT

{salla_gitpuller-0.1.2 → salla_gitpuller-1.0.0}/salla_gitpuller.egg-info/SOURCES.txt

@@ -2,7 +2,10 @@ LICENSE
 README.md
 pyproject.toml
 gitpuller/__init__.py
+gitpuller/alert_manager.py
 gitpuller/gitpull.py
+gitpuller/slack_notifier.py
+gitpuller/state_manager.py
 gitpuller/utils.py
 salla_gitpuller.egg-info/PKG-INFO
 salla_gitpuller.egg-info/SOURCES.txt

salla_gitpuller-0.1.2/gitpuller/__init__.py

@@ -1,4 +0,0 @@
-from .gitpull import git_pull
-from .utils import transform_custom, get_repo_path, get_env_base_path
-
-__all__ = ["git_pull", "transform_custom", "get_repo_path", "get_env_base_path"]

salla_gitpuller-0.1.2/gitpuller/gitpull.py

@@ -1,115 +0,0 @@
-import os
-import requests
-import subprocess
-from typing import Any, Dict
-
-
-def git_pull(repo_path: str, workspace_name: str, git_url: str, key_material: str, webhook_url: str) -> Dict[str, Any]:
-    """
-    Executes 'git pull' in the specified repository path using a deploy key
-    provided via the env var WP_AUTOPULL_SSHKEY.
-
-    Args:
-        repo_path: Path to the local git repository
-        workspace_name: Logical workspace identifier
-        git_url: Git remote URL (SSH-based)
-    Returns:
-        Dict with status and command output.
-    """
-    print(f"Running git pull for workspace: {workspace_name}")
-    print(f"Repo path: {repo_path}")
-
-    repo_name = git_url.split('/')[-1].replace('.git', '')
-
-    if not all([webhook_url]):
-        raise EnvironmentError(
-            "One or more Slack environment variables are missing:\n"
-            "CDM_SLACK_WEBHOOK_URL"
-        )
-
-    payload = {
-        "text": f"Automate Git Pull Pipeline Failed",
-        "blocks": [
-            {
-                "type": "header",
-                "text": {
-                    "type": "plain_text",
-                    "text": f":alert: Automate Git Pull Pipeline Failed :alert:"
-                }
-            },
-            {
-                "type": "divider"
-            },
-            {
-                "type": "section",
-                "text": {
-                    "type": "mrkdwn",
-                    "text": f"*Repository:* `{repo_name}`"
-                }
-            }
-        ]
-    }
-
-
-    if not os.path.exists(repo_path):
-        raise FileNotFoundError(f"Repo path does not exist: {repo_path}")
-
-
-    if not key_material:
-        raise EnvironmentError(f"Missing SSH key material for workspace: {workspace_name}")
-
-    if key_material:
-        # Remove any quotes that might be wrapping the key
-        key_material = key_material.strip().strip('"').strip("'")
-        
-        # Handle literal \n sequences
-        if "\\n" in key_material:
-            key_material = key_material.replace("\\n", "\n")
-        
-        # Ensure proper line endings
-        if not key_material.endswith("\n"):
-            key_material += "\n"
-
-    ssh_dir = os.path.expanduser("~/.ssh")
-    key_path = os.path.join(ssh_dir, "SallaApp_mageai_CI_CD_deploy")
-    os.makedirs(ssh_dir, exist_ok=True)
-    os.chmod(ssh_dir, 0o700)
-
-    with open(key_path, "w") as f:
-        f.write(key_material)
-    os.chmod(key_path, 0o600)
-
-    cmd = [
-        "git",
-        "-c",
-        f"core.sshCommand=ssh -i {key_path} -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new",
-        "pull",
-        git_url,
-        "master",
-    ]
-
-    try:
-        os.chdir(repo_path)
-        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-        git_output = result.stdout
-        git_status = "success"
-    except subprocess.CalledProcessError as e:
-        git_output = (e.stdout or "") + (e.stderr or "")
-        git_status = "error"
-        payload["blocks"].append({
-        "type": "section",
-        "text": {"type": "mrkdwn", "text": f"*Error Output:*\n```{git_output[:1500]}```"}  # truncate for Slack limit
-        })
-        requests.post(webhook_url, json=payload)
-    finally:
-        try:
-            os.remove(key_path)
-        except Exception:
-            pass
-
-    return {
-        "workspace": workspace_name,
-        "repo_path": repo_path,
-        "git_pull_status": git_status,
-        "git_pull_output": git_output.strip(),
-    }