k8s-helper-cli 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

k8s_helper/__init__.py

@@ -20,7 +20,7 @@ from .utils import (
     create_service_manifest
 )
 
-__version__ = "0.5.0"
+__version__ = "0.5.2"
 __author__ = "Harshit Chatterjee"
 __email__ = "harshitchatterjee50@gmail.com"
 

k8s_helper/cli.py

@@ -1886,5 +1886,279 @@ def update_prometheus_target(
         console.print(f"❌ Error updating Prometheus target: {e}")
 
 
+# ======================
+# HELM-BASED MONITORING COMMANDS
+# ======================
+@app.command()
+def setup_monitoring_stack(
+    namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Namespace for monitoring stack"),
+    grafana_service_type: str = typer.Option("NodePort", "--service-type", "-t", help="Grafana service type: NodePort, LoadBalancer, ClusterIP"),
+    prometheus_storage_size: str = typer.Option("10Gi", "--prometheus-storage", help="Prometheus storage size"),
+    grafana_storage_size: str = typer.Option("5Gi", "--grafana-storage", help="Grafana storage size"),
+    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for deployments to be ready"),
+    install_ingress: bool = typer.Option(False, "--install-ingress", help="Install ingress for external access")
+):
+    """Deploy monitoring stack using official Helm charts (auto-installs Helm if needed)"""
+    
+    # Validate service type
+    valid_service_types = ["NodePort", "LoadBalancer", "ClusterIP"]
+    if grafana_service_type not in valid_service_types:
+        console.print(f"❌ Invalid service type: {grafana_service_type}")
+        console.print(f"💡 Valid options: {', '.join(valid_service_types)}")
+        return
+    
+    console.print(f"🚀 Setting up Helm-based monitoring stack in namespace: {namespace}")
+    console.print(f"🔧 Grafana service type: {grafana_service_type}")
+    console.print(f"💾 Prometheus storage: {prometheus_storage_size}")
+    console.print(f"💾 Grafana storage: {grafana_storage_size}")
+    console.print(f"⚙️  Note: Helm will be automatically installed if not present")
+    
+    # Show what will be deployed
+    console.print("\n📋 Components to deploy via Helm:")
+    console.print("   • Prometheus Operator (kube-prometheus-stack)")
+    console.print("   • Grafana with persistent storage")
+    console.print("   • AlertManager for alerts")
+    console.print("   • Node Exporter for node metrics")
+    console.print("   • kube-state-metrics for cluster state")
+    console.print("   • Prometheus rules and dashboards")
+    if install_ingress:
+        console.print("   • Ingress for external access")
+    
+    try:
+        client = K8sClient()
+        
+        with console.status("Deploying Helm monitoring stack..."):
+            result = client.setup_helm_monitoring(
+                namespace=namespace,
+                grafana_service_type=grafana_service_type,
+                prometheus_storage_size=prometheus_storage_size,
+                grafana_storage_size=grafana_storage_size,
+                wait_for_ready=wait,
+                install_ingress=install_ingress
+            )
+        
+        if result['success']:
+            console.print("✅ Helm monitoring stack deployed successfully!")
+            
+            # Show deployment summary
+            console.print(f"\n📋 Deployment Summary:")
+            console.print(f"📍 Namespace: {result['namespace']}")
+            console.print(f"🎯 Helm Release: {result['release_name']}")
+            
+            if result.get('prometheus', {}).get('deployed'):
+                console.print("✅ Prometheus Operator: Deployed")
+            else:
+                console.print("❌ Prometheus Operator: Failed to deploy")
+            
+            if result.get('grafana', {}).get('deployed'):
+                console.print("✅ Grafana: Deployed")
+                if result['grafana'].get('admin_password'):
+                    console.print(f"🔑 Grafana admin password: {result['grafana']['admin_password']}")
+                else:
+                    console.print("🔑 Grafana admin password: admin")
+            else:
+                console.print("❌ Grafana: Failed to deploy")
+            
+            # Show access information
+            console.print(f"\n🔗 Access Information:")
+            
+            if result.get('grafana_url'):
+                console.print(f"🔗 Grafana URL: [blue]{result['grafana_url']}[/blue]")
+            else:
+                console.print(f"💡 Grafana: kubectl port-forward -n {namespace} svc/kube-prometheus-stack-grafana 3000:80")
+            
+            if result.get('prometheus_url'):
+                console.print(f"🔗 Prometheus URL: [blue]{result['prometheus_url']}[/blue]")
+            else:
+                console.print(f"💡 Prometheus: kubectl port-forward -n {namespace} svc/kube-prometheus-stack-prometheus 9090:9090")
+            
+            if result.get('alertmanager_url'):
+                console.print(f"🔗 AlertManager URL: [blue]{result['alertmanager_url']}[/blue]")
+            else:
+                console.print(f"💡 AlertManager: kubectl port-forward -n {namespace} svc/kube-prometheus-stack-alertmanager 9093:9093")
+            
+            # Show next steps
+            console.print(f"\n🚀 Next Steps:")
+            console.print(f"   1. Access Grafana with admin/admin (or password shown above)")
+            console.print(f"   2. Explore pre-configured dashboards")
+            console.print(f"   3. Set up custom alerts in AlertManager")
+            console.print(f"   4. Add custom Prometheus targets if needed")
+            console.print(f"\n💡 Useful commands:")
+            console.print(f"   • Check status: k8s-helper monitoring-stack-status -n {namespace}")
+            console.print(f"   • List dashboards: kubectl get configmaps -n {namespace} | grep dashboard")
+            console.print(f"   • View Helm release: helm list -n {namespace}")
+            
+        else:
+            console.print(f"❌ Failed to deploy Helm monitoring stack: {result.get('error', 'Unknown error')}")
+            
+            # Show suggestion if provided
+            if result.get('suggestion'):
+                console.print(f"💡 {result['suggestion']}")
+            
+            console.print("\n🛠️  Troubleshooting:")
+            if 'Helm' in str(result.get('error', '')):
+                console.print("   • Helm installation failed - you may need to install manually")
+                console.print("   • Visit: https://helm.sh/docs/intro/install/")
+                console.print("   • Restart your terminal after installation")
+            else:
+                console.print("   • Check cluster connectivity: kubectl get nodes")
+                console.print("   • Verify namespace permissions")
+                console.print(f"   • View Helm status: helm status -n {namespace} kube-prometheus-stack")
+    
+    except Exception as e:
+        console.print(f"❌ Error setting up Helm monitoring: {e}")
+        console.print("\n🛠️  Troubleshooting:")
+        console.print("   • Ensure Helm is installed and configured")
+        console.print("   • Check if kubectl is configured correctly")
+        console.print("   • Verify you have cluster admin permissions")
+
+
+@app.command()
+def monitoring_stack_status(
+    namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Monitoring namespace"),
+    output: str = output_option
+):
+    """Show status of Helm-based monitoring stack"""
+    try:
+        client = K8sClient()
+        
+        with console.status("Checking Helm monitoring stack status..."):
+            info = client.get_helm_monitoring_info(namespace)
+        
+        if 'error' in info:
+            console.print(f"❌ Error getting monitoring status: {info['error']}")
+            return
+        
+        if output == "table":
+            # Helm release info
+            console.print(f"🎯 Helm Release: {info.get('release_name', 'kube-prometheus-stack')}")
+            console.print(f"📊 Release Status: {info.get('release_status', 'Unknown')}")
+            console.print(f"📅 Last Deployed: {info.get('last_deployed', 'Unknown')}")
+            
+            # Overview table
+            table = Table(title=f"Monitoring Stack Status - {namespace}")
+            table.add_column("Component", style="cyan")
+            table.add_column("Status", style="green")
+            table.add_column("URL", style="blue")
+            
+            # Components status
+            components = ['prometheus', 'grafana', 'alertmanager']
+            for component in components:
+                if component in info:
+                    comp_info = info[component]
+                    status = "🟢 Running" if comp_info.get('running') else "🔴 Not Running"
+                    url = comp_info.get('url', 'Port-forward required')
+                    table.add_row(component.capitalize(), status, url)
+            
+            console.print(table)
+            
+            # Show pod status
+            if info.get('pods'):
+                pod_table = Table(title="Pod Status")
+                pod_table.add_column("Pod", style="cyan")
+                pod_table.add_column("Status", style="green")
+                pod_table.add_column("Ready", style="blue")
+                
+                for pod in info['pods']:
+                    pod_table.add_row(
+                        pod['name'],
+                        pod['status'],
+                        f"{pod['ready']}/{pod['total']}"
+                    )
+                
+                console.print(pod_table)
+        
+        elif output == "json":
+            console.print(format_json_output(info))
+        elif output == "yaml":
+            console.print(format_yaml_output(info))
+    
+    except Exception as e:
+        console.print(f"❌ Error checking Helm monitoring status: {e}")
+
+
+@app.command()
+def delete_monitoring_stack(
+    namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Monitoring namespace"),
+    release_name: str = typer.Option("kube-prometheus-stack", "--release-name", help="Helm release name"),
+    force: bool = typer.Option(False, "--force", help="Skip confirmation prompt")
+):
+    """Delete Helm-based monitoring stack"""
+    if not force:
+        if not typer.confirm(f"Are you sure you want to delete the Helm monitoring stack '{release_name}' in namespace '{namespace}'?"):
+            console.print("❌ Operation cancelled")
+            return
+    
+    try:
+        client = K8sClient()
+        
+        console.print(f"🗑️  Deleting Helm monitoring stack: {release_name}")
+        
+        with console.status("Uninstalling Helm release..."):
+            result = client.delete_helm_monitoring(namespace, release_name)
+        
+        if result['success']:
+            console.print(f"✅ Helm monitoring stack '{release_name}' deleted successfully")
+            console.print(f"📋 Cleaned up {result.get('resources_deleted', 0)} resources")
+        else:
+            console.print(f"❌ Failed to delete Helm monitoring stack: {result.get('error', 'Unknown error')}")
+    
+    except Exception as e:
+        console.print(f"❌ Error deleting Helm monitoring: {e}")
+
+
+@app.command()
+def install_helm(
+    force: bool = typer.Option(False, "--force", help="Force reinstall even if Helm is already installed")
+):
+    """Install Helm automatically on your system"""
+    try:
+        client = K8sClient()
+        
+        # Check if Helm is already installed
+        if not force and client._check_helm_available():
+            console.print("✅ Helm is already installed on your system")
+            
+            import subprocess
+            try:
+                result = subprocess.run(['helm', 'version'], capture_output=True, text=True)
+                console.print(f"📋 Version: {result.stdout.strip()}")
+            except:
+                pass
+            
+            console.print("💡 Use --force to reinstall")
+            return
+        
+        console.print("🔧 Installing Helm automatically...")
+        
+        with console.status("Installing Helm..."):
+            result = client._install_helm_automatically()
+        
+        if result['success']:
+            console.print(f"✅ {result['message']}")
+            console.print(f"📦 Installation method: {result['method']}")
+            
+            # Test the installation
+            if client._check_helm_available():
+                console.print("✅ Helm installation verified successfully")
+                console.print("\n🚀 You can now use Helm-based monitoring commands:")
+                console.print("   • k8s-helper setup-monitoring-stack")
+                console.print("   • k8s-helper monitoring-stack-status")
+                console.print("   • k8s-helper delete-monitoring-stack")
+            else:
+                console.print("⚠️  Helm was installed but may not be in your PATH")
+                console.print("💡 You may need to restart your terminal")
+        else:
+            console.print(f"❌ Failed to install Helm: {result.get('error', 'Unknown error')}")
+            console.print("\n🛠️  Manual installation:")
+            console.print("   • Windows: choco install kubernetes-helm")
+            console.print("   • macOS: brew install helm")
+            console.print("   • Linux: curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash")
+            console.print("   • Visit: https://helm.sh/docs/intro/install/")
+    
+    except Exception as e:
+        console.print(f"❌ Error installing Helm: {e}")
+
+
 if __name__ == "__main__":
     app()

k8s_helper/core.py

@@ -1694,6 +1694,261 @@ class K8sClient:
         except (subprocess.TimeoutExpired, FileNotFoundError):
             return False
     
+    def _install_helm_automatically(self) -> Dict[str, Any]:
+        """Automatically install Helm based on the operating system"""
+        import subprocess
+        import platform
+        import os
+        import tempfile
+        import urllib.request
+        
+        result = {
+            'success': False,
+            'method': None,
+            'error': None,
+            'message': None
+        }
+        
+        system = platform.system().lower()
+        print(f"🔧 Attempting to install Helm on {system}...")
+        
+        try:
+            if system == 'windows':
+                # Try to install via Chocolatey first, then Scoop, then direct download
+                methods = [
+                    {
+                        'name': 'Chocolatey',
+                        'check_cmd': ['choco', '--version'],
+                        'install_cmd': ['choco', 'install', 'kubernetes-helm', '-y']
+                    },
+                    {
+                        'name': 'Scoop',
+                        'check_cmd': ['scoop', '--version'],
+                        'install_cmd': ['scoop', 'install', 'helm']
+                    }
+                ]
+                
+                for method in methods:
+                    try:
+                        # Check if package manager is available
+                        subprocess.run(method['check_cmd'], capture_output=True, check=True, timeout=10)
+                        print(f"📦 Installing Helm via {method['name']}...")
+                        
+                        # Install Helm
+                        install_result = subprocess.run(
+                            method['install_cmd'], 
+                            capture_output=True, 
+                            text=True, 
+                            timeout=300  # 5 minutes timeout
+                        )
+                        
+                        if install_result.returncode == 0:
+                            result['success'] = True
+                            result['method'] = method['name']
+                            result['message'] = f"Helm installed successfully via {method['name']}"
+                            print(f"✅ {result['message']}")
+                            return result
+                        else:
+                            print(f"⚠️  {method['name']} installation failed: {install_result.stderr}")
+                            
+                    except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError):
+                        print(f"⚠️  {method['name']} not available")
+                        continue
+                
+                # If package managers fail, try direct download
+                print("📦 Attempting direct download installation...")
+                result = self._install_helm_direct_download()
+                
+            elif system == 'linux':
+                # Try different Linux package managers and methods
+                methods = [
+                    {
+                        'name': 'Snap',
+                        'check_cmd': ['snap', '--version'],
+                        'install_cmd': ['sudo', 'snap', 'install', 'helm', '--classic']
+                    },
+                    {
+                        'name': 'Script',
+                        'script_url': 'https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3'
+                    }
+                ]
+                
+                # Try snap first
+                try:
+                    subprocess.run(['snap', '--version'], capture_output=True, check=True, timeout=10)
+                    print("📦 Installing Helm via Snap...")
+                    
+                    install_result = subprocess.run(
+                        ['sudo', 'snap', 'install', 'helm', '--classic'],
+                        capture_output=True,
+                        text=True,
+                        timeout=300
+                    )
+                    
+                    if install_result.returncode == 0:
+                        result['success'] = True
+                        result['method'] = 'Snap'
+                        result['message'] = "Helm installed successfully via Snap"
+                        print(f"✅ {result['message']}")
+                        return result
+                        
+                except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError):
+                    print("⚠️  Snap not available")
+                
+                # Try installation script
+                print("📦 Installing Helm via official installation script...")
+                try:
+                    script_result = subprocess.run([
+                        'bash', '-c', 
+                        'curl -fsSL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash'
+                    ], capture_output=True, text=True, timeout=300)
+                    
+                    if script_result.returncode == 0:
+                        result['success'] = True
+                        result['method'] = 'Installation Script'
+                        result['message'] = "Helm installed successfully via installation script"
+                        print(f"✅ {result['message']}")
+                        return result
+                    else:
+                        print(f"⚠️  Script installation failed: {script_result.stderr}")
+                        
+                except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+                    print("⚠️  Script installation failed")
+                
+            elif system == 'darwin':  # macOS
+                # Try Homebrew
+                try:
+                    subprocess.run(['brew', '--version'], capture_output=True, check=True, timeout=10)
+                    print("📦 Installing Helm via Homebrew...")
+                    
+                    install_result = subprocess.run(
+                        ['brew', 'install', 'helm'],
+                        capture_output=True,
+                        text=True,
+                        timeout=300
+                    )
+                    
+                    if install_result.returncode == 0:
+                        result['success'] = True
+                        result['method'] = 'Homebrew'
+                        result['message'] = "Helm installed successfully via Homebrew"
+                        print(f"✅ {result['message']}")
+                        return result
+                        
+                except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError):
+                    print("⚠️  Homebrew not available, trying installation script...")
+                    
+                    # Fallback to installation script
+                    try:
+                        script_result = subprocess.run([
+                            'bash', '-c',
+                            'curl -fsSL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash'
+                        ], capture_output=True, text=True, timeout=300)
+                        
+                        if script_result.returncode == 0:
+                            result['success'] = True
+                            result['method'] = 'Installation Script'
+                            result['message'] = "Helm installed successfully via installation script"
+                            print(f"✅ {result['message']}")
+                            return result
+                            
+                    except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+                        print("⚠️  Script installation failed")
+            
+            # If we reach here, all methods failed
+            result['error'] = f"Could not install Helm automatically on {system}"
+            print(f"❌ {result['error']}")
+            
+        except Exception as e:
+            result['error'] = f"Error during Helm installation: {str(e)}"
+            print(f"❌ {result['error']}")
+        
+        return result
+    
+    def _install_helm_direct_download(self) -> Dict[str, Any]:
+        """Install Helm via direct download (Windows fallback)"""
+        import subprocess
+        import tempfile
+        import zipfile
+        import urllib.request
+        import os
+        import platform
+        
+        result = {
+            'success': False,
+            'method': 'Direct Download',
+            'error': None,
+            'message': None
+        }
+        
+        try:
+            # Determine architecture
+            arch = platform.machine().lower()
+            if arch == 'amd64' or arch == 'x86_64':
+                arch = 'amd64'
+            elif arch == 'arm64':
+                arch = 'arm64'
+            else:
+                arch = 'amd64'  # Default fallback
+            
+            # Download URL for latest Helm
+            download_url = f"https://get.helm.sh/helm-v3.13.0-windows-{arch}.zip"
+            
+            with tempfile.TemporaryDirectory() as temp_dir:
+                zip_path = os.path.join(temp_dir, "helm.zip")
+                
+                print(f"📥 Downloading Helm from {download_url}...")
+                urllib.request.urlretrieve(download_url, zip_path)
+                
+                print("📦 Extracting Helm...")
+                with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                    zip_ref.extractall(temp_dir)
+                
+                # Find helm.exe
+                helm_exe = None
+                for root, dirs, files in os.walk(temp_dir):
+                    if 'helm.exe' in files:
+                        helm_exe = os.path.join(root, 'helm.exe')
+                        break
+                
+                if helm_exe:
+                    # Try to move to a directory in PATH
+                    target_locations = [
+                        os.path.expanduser("~/bin"),
+                        "C:\\Program Files\\Helm",
+                        os.path.join(os.environ.get('LOCALAPPDATA', ''), 'Microsoft', 'WindowsApps')
+                    ]
+                    
+                    for target_dir in target_locations:
+                        try:
+                            os.makedirs(target_dir, exist_ok=True)
+                            target_path = os.path.join(target_dir, 'helm.exe')
+                            
+                            import shutil
+                            shutil.copy2(helm_exe, target_path)
+                            
+                            # Test if it works
+                            test_result = subprocess.run([target_path, 'version'], 
+                                                       capture_output=True, timeout=10)
+                            if test_result.returncode == 0:
+                                result['success'] = True
+                                result['message'] = f"Helm installed to {target_path}"
+                                print(f"✅ {result['message']}")
+                                print(f"💡 Please add {target_dir} to your PATH if not already present")
+                                return result
+                                
+                        except (OSError, subprocess.TimeoutExpired):
+                            continue
+                    
+                    result['error'] = "Downloaded Helm but could not install to PATH"
+                else:
+                    result['error'] = "Could not find helm.exe in downloaded archive"
+                    
+        except Exception as e:
+            result['error'] = f"Direct download failed: {str(e)}"
+        
+        return result
+    
     def _install_kube_state_metrics(self, namespace: str) -> Dict[str, Any]:
         """Install kube-state-metrics using Helm if available, or manual YAML if not"""
         import subprocess
@@ -3083,3 +3338,413 @@ scrape_configs:
         except Exception as e:
             print(f"⚠️  Could not restart Prometheus deployment: {e}")
             return False
+
+    # ======================
+    # HELM-BASED MONITORING METHODS
+    # ======================
+    
+    def setup_helm_monitoring(self, namespace: str = "monitoring", 
+                            grafana_service_type: str = "NodePort",
+                            prometheus_storage_size: str = "10Gi",
+                            grafana_storage_size: str = "5Gi",
+                            wait_for_ready: bool = True,
+                            install_ingress: bool = False) -> Dict:
+        """Deploy monitoring stack using official Helm charts"""
+        import subprocess
+        import tempfile
+        import os
+        
+        try:
+            # Check if Helm is available, and install if not
+            if not self._check_helm_available():
+                print("🔧 Helm not found. Attempting automatic installation...")
+                install_result = self._install_helm_automatically()
+                
+                if not install_result['success']:
+                    return {
+                        'success': False,
+                        'error': f"Helm is required but could not be installed automatically. {install_result.get('error', '')}",
+                        'suggestion': 'Please install Helm manually: https://helm.sh/docs/intro/install/'
+                    }
+                else:
+                    print(f"✅ {install_result['message']}")
+                    
+                    # Verify installation worked
+                    if not self._check_helm_available():
+                        return {
+                            'success': False,
+                            'error': 'Helm was installed but is not accessible. You may need to restart your terminal or add Helm to your PATH.',
+                            'suggestion': 'Please restart your terminal and try again, or install Helm manually.'
+                        }
+            
+            print("✅ Helm is available")
+            
+            # Create namespace if it doesn't exist
+            try:
+                self.core_v1.create_namespace(
+                    body=client.V1Namespace(metadata=client.V1ObjectMeta(name=namespace))
+                )
+                print(f"✅ Created namespace: {namespace}")
+            except ApiException as e:
+                if e.status == 409:  # Already exists
+                    print(f"✅ Namespace {namespace} already exists")
+                else:
+                    print(f"⚠️  Could not create namespace: {e}")
+            
+            # Add Prometheus community Helm repository
+            print("📦 Adding Prometheus community Helm repository...")
+            try:
+                subprocess.run([
+                    'helm', 'repo', 'add', 'prometheus-community', 
+                    'https://prometheus-community.github.io/helm-charts'
+                ], check=True, capture_output=True)
+                
+                subprocess.run(['helm', 'repo', 'update'], check=True, capture_output=True)
+                print("✅ Helm repository added and updated")
+            except subprocess.CalledProcessError as e:
+                return {
+                    'success': False,
+                    'error': f'Failed to add Helm repository: {e.stderr.decode() if e.stderr else str(e)}'
+                }
+            
+            # Create Helm values file
+            helm_values = {
+                'grafana': {
+                    'enabled': True,
+                    'persistence': {
+                        'enabled': True,
+                        'size': grafana_storage_size
+                    },
+                    'service': {
+                        'type': grafana_service_type
+                    },
+                    'adminPassword': 'admin',
+                    'datasources': {
+                        'datasources.yaml': {
+                            'apiVersion': 1,
+                            'datasources': [{
+                                'name': 'Prometheus',
+                                'type': 'prometheus',
+                                'url': 'http://kube-prometheus-stack-prometheus:9090',
+                                'access': 'proxy',
+                                'isDefault': True
+                            }]
+                        }
+                    },
+                    'dashboardProviders': {
+                        'dashboardproviders.yaml': {
+                            'apiVersion': 1,
+                            'providers': [{
+                                'name': 'default',
+                                'orgId': 1,
+                                'folder': '',
+                                'type': 'file',
+                                'disableDeletion': False,
+                                'editable': True,
+                                'options': {
+                                    'path': '/var/lib/grafana/dashboards/default'
+                                }
+                            }]
+                        }
+                    },
+                    'dashboards': {
+                        'default': {
+                            'kubernetes-cluster-dashboard': {
+                                'gnetId': 7249,
+                                'revision': 1,
+                                'datasource': 'Prometheus'
+                            },
+                            'kubernetes-pod-dashboard': {
+                                'gnetId': 6417,
+                                'revision': 1,
+                                'datasource': 'Prometheus'
+                            },
+                            'node-exporter-dashboard': {
+                                'gnetId': 1860,
+                                'revision': 27,
+                                'datasource': 'Prometheus'
+                            }
+                        }
+                    }
+                },
+                'prometheus': {
+                    'enabled': True,
+                    'prometheusSpec': {
+                        'retention': '30d',
+                        'storageSpec': {
+                            'volumeClaimTemplate': {
+                                'spec': {
+                                    'accessModes': ['ReadWriteOnce'],
+                                    'resources': {
+                                        'requests': {
+                                            'storage': prometheus_storage_size
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        'serviceMonitorSelectorNilUsesHelmValues': False
+                    }
+                },
+                'alertmanager': {
+                    'enabled': True
+                },
+                'nodeExporter': {
+                    'enabled': True
+                },
+                'kubeStateMetrics': {
+                    'enabled': True
+                },
+                'defaultRules': {
+                    'create': True,
+                    'rules': {
+                        'alertmanager': True,
+                        'etcd': True,
+                        'general': True,
+                        'k8s': True,
+                        'kubeApiserver': True,
+                        'kubePrometheusNodeRecording': True,
+                        'kubernetesApps': True,
+                        'kubernetesResources': True,
+                        'kubernetesStorage': True,
+                        'kubernetesSystem': True,
+                        'network': True,
+                        'node': True,
+                        'prometheus': True,
+                        'prometheusOperator': True
+                    }
+                }
+            }
+            
+            # Add ingress if requested
+            if install_ingress:
+                helm_values['grafana']['ingress'] = {
+                    'enabled': True,
+                    'hosts': [f'grafana.{namespace}.local'],
+                    'paths': ['/']
+                }
+            
+            # Write values to temporary file
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+                yaml.dump(helm_values, f, default_flow_style=False)
+                values_file = f.name
+            
+            try:
+                # Install the Helm chart
+                print("🚀 Installing kube-prometheus-stack via Helm...")
+                helm_cmd = [
+                    'helm', 'install', 'kube-prometheus-stack',
+                    'prometheus-community/kube-prometheus-stack',
+                    '--namespace', namespace,
+                    '--values', values_file
+                ]
+                
+                if wait_for_ready:
+                    helm_cmd.append('--wait')
+                    helm_cmd.extend(['--timeout', '10m'])
+                
+                result = subprocess.run(helm_cmd, capture_output=True, text=True, check=True)
+                print("✅ Helm chart installed successfully")
+                
+                # Wait a bit for pods to start
+                if wait_for_ready:
+                    print("⏳ Waiting for pods to be ready...")
+                    time.sleep(30)
+                
+                # Get service information
+                services_info = self._get_helm_monitoring_services(namespace)
+                
+                return {
+                    'success': True,
+                    'namespace': namespace,
+                    'release_name': 'kube-prometheus-stack',
+                    'prometheus': {'deployed': True},
+                    'grafana': {
+                        'deployed': True,
+                        'admin_password': 'admin'
+                    },
+                    'grafana_url': services_info.get('grafana_url'),
+                    'prometheus_url': services_info.get('prometheus_url'),
+                    'alertmanager_url': services_info.get('alertmanager_url')
+                }
+                
+            finally:
+                # Clean up temporary file
+                os.unlink(values_file)
+                
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.decode() if e.stderr else str(e)
+            return {
+                'success': False,
+                'error': f'Helm installation failed: {error_msg}'
+            }
+        except Exception as e:
+            return {
+                'success': False,
+                'error': f'Failed to setup Helm monitoring: {str(e)}'
+            }
+    
+    def get_helm_monitoring_info(self, namespace: str = "monitoring") -> Dict:
+        """Get information about the Helm-based monitoring stack"""
+        import subprocess
+        
+        try:
+            # Check if Helm release exists
+            try:
+                result = subprocess.run([
+                    'helm', 'status', 'kube-prometheus-stack', 
+                    '--namespace', namespace
+                ], capture_output=True, text=True, check=True)
+                
+                # Parse Helm status
+                lines = result.stdout.split('\n')
+                release_info = {}
+                for line in lines:
+                    if 'STATUS:' in line:
+                        release_info['release_status'] = line.split('STATUS:')[1].strip()
+                    elif 'LAST DEPLOYED:' in line:
+                        release_info['last_deployed'] = line.split('LAST DEPLOYED:')[1].strip()
+                
+            except subprocess.CalledProcessError:
+                return {'error': 'Helm release not found. Use setup-helm-monitoring to deploy first.'}
+            
+            # Get services information
+            services_info = self._get_helm_monitoring_services(namespace)
+            
+            # Get pod status
+            pods_info = self._get_monitoring_pods_status(namespace)
+            
+            return {
+                'release_name': 'kube-prometheus-stack',
+                'release_status': release_info.get('release_status', 'Unknown'),
+                'last_deployed': release_info.get('last_deployed', 'Unknown'),
+                'prometheus': {
+                    'running': any(pod['name'].startswith('prometheus-kube-prometheus-stack-prometheus') 
+                                 for pod in pods_info if pod['status'] == 'Running'),
+                    'url': services_info.get('prometheus_url', 'Port-forward required')
+                },
+                'grafana': {
+                    'running': any(pod['name'].startswith('kube-prometheus-stack-grafana') 
+                                 for pod in pods_info if pod['status'] == 'Running'),
+                    'url': services_info.get('grafana_url', 'Port-forward required')
+                },
+                'alertmanager': {
+                    'running': any(pod['name'].startswith('alertmanager-kube-prometheus-stack-alertmanager') 
+                                 for pod in pods_info if pod['status'] == 'Running'),
+                    'url': services_info.get('alertmanager_url', 'Port-forward required')
+                },
+                'pods': pods_info
+            }
+            
+        except Exception as e:
+            return {'error': f'Failed to get monitoring info: {str(e)}'}
+    
+    def delete_helm_monitoring(self, namespace: str = "monitoring", 
+                             release_name: str = "kube-prometheus-stack") -> Dict:
+        """Delete Helm-based monitoring stack"""
+        import subprocess
+        
+        try:
+            # Uninstall Helm release
+            result = subprocess.run([
+                'helm', 'uninstall', release_name,
+                '--namespace', namespace
+            ], capture_output=True, text=True, check=True)
+            
+            print(f"✅ Helm release '{release_name}' uninstalled")
+            
+            # Count remaining resources (optional cleanup)
+            try:
+                # Delete PVCs that might remain
+                pvcs = self.core_v1.list_namespaced_persistent_volume_claim(namespace=namespace)
+                pvc_count = 0
+                for pvc in pvcs.items:
+                    if 'prometheus' in pvc.metadata.name or 'grafana' in pvc.metadata.name:
+                        self.core_v1.delete_namespaced_persistent_volume_claim(
+                            name=pvc.metadata.name, 
+                            namespace=namespace
+                        )
+                        pvc_count += 1
+                
+                if pvc_count > 0:
+                    print(f"✅ Cleaned up {pvc_count} persistent volume claims")
+                
+            except Exception as cleanup_error:
+                print(f"⚠️  Could not clean up some resources: {cleanup_error}")
+            
+            return {
+                'success': True,
+                'resources_deleted': pvc_count
+            }
+            
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.decode() if e.stderr else str(e)
+            return {
+                'success': False,
+                'error': f'Failed to uninstall Helm release: {error_msg}'
+            }
+        except Exception as e:
+            return {
+                'success': False,
+                'error': f'Failed to delete monitoring stack: {str(e)}'
+            }
+    
+    def _get_helm_monitoring_services(self, namespace: str) -> Dict:
+        """Get service URLs for Helm monitoring components"""
+        services_info = {}
+        
+        try:
+            # Get services
+            services = self.core_v1.list_namespaced_service(namespace=namespace)
+            
+            for service in services.items:
+                service_name = service.metadata.name
+                
+                if 'grafana' in service_name:
+                    url = self._get_service_url(service, namespace, 80)
+                    if url:
+                        services_info['grafana_url'] = url
+                
+                elif 'prometheus' in service_name and 'operated' not in service_name:
+                    url = self._get_service_url(service, namespace, 9090)
+                    if url:
+                        services_info['prometheus_url'] = url
+                
+                elif 'alertmanager' in service_name and 'operated' not in service_name:
+                    url = self._get_service_url(service, namespace, 9093)
+                    if url:
+                        services_info['alertmanager_url'] = url
+        
+        except Exception as e:
+            print(f"⚠️  Could not get service information: {e}")
+        
+        return services_info
+    
+    def _get_monitoring_pods_status(self, namespace: str) -> List[Dict]:
+        """Get status of monitoring pods"""
+        pods_info = []
+        
+        try:
+            pods = self.core_v1.list_namespaced_pod(namespace=namespace)
+            
+            for pod in pods.items:
+                if any(component in pod.metadata.name for component in 
+                      ['prometheus', 'grafana', 'alertmanager', 'node-exporter', 'kube-state-metrics']):
+                    
+                    ready_containers = 0
+                    total_containers = len(pod.status.container_statuses) if pod.status.container_statuses else 0
+                    
+                    if pod.status.container_statuses:
+                        ready_containers = sum(1 for cs in pod.status.container_statuses if cs.ready)
+                    
+                    pods_info.append({
+                        'name': pod.metadata.name,
+                        'status': pod.status.phase,
+                        'ready': ready_containers,
+                        'total': total_containers
+                    })
+        
+        except Exception as e:
+            print(f"⚠️  Could not get pod status: {e}")
+        
+        return pods_info

{k8s_helper_cli-0.5.0.dist-info → k8s_helper_cli-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: k8s-helper-cli
-Version: 0.5.0
+Version: 0.5.2
 Summary: A simplified Python wrapper for common Kubernetes operations
 Author-email: Harshit Chatterjee <harshitchatterjee50@gmail.com>
 License-Expression: MIT

k8s_helper_cli-0.5.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+k8s_helper/__init__.py,sha256=6P0gvzwSbX4EBvqjSs8DO6uNsGzJAFG36qUqVY9vlnQ,2666
+k8s_helper/cli.py,sha256=3eP3J7srPIM0bm_G5RxdU_RvtDwJHLX2xBguF2EmXtk,95115
+k8s_helper/config.py,sha256=P7YdfyvCHprrNs2J9DRb3RrClylfTTh5hfTtDzLug0A,6867
+k8s_helper/core.py,sha256=WNri9uYRPdU_NRCdEpkgJhxzAC3iKaF2UntALvZS4ng,160448
+k8s_helper/utils.py,sha256=wYgTd5ktyuI-EiVcfW7FrxA7MzXY5odrEKQgmMVdueY,9496
+k8s_helper_cli-0.5.2.dist-info/licenses/LICENSE,sha256=tXPvVl3gLVc6e0qCEoLH9KjeA7z4JVL78UybpvGtBCw,1096
+k8s_helper_cli-0.5.2.dist-info/METADATA,sha256=1G1nZLtXZPaYsaCr4pyjRWqor80TUNa0DnQhSriSZSo,30789
+k8s_helper_cli-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+k8s_helper_cli-0.5.2.dist-info/entry_points.txt,sha256=IoCMWUZ6mn90LwzQzEy5YkWOwvogDdZ6ycqUWAzCFTQ,50
+k8s_helper_cli-0.5.2.dist-info/top_level.txt,sha256=x9A1jflyer-z2cFnkqk5B42juoH2q0fy5hkT9upsTG8,11
+k8s_helper_cli-0.5.2.dist-info/RECORD,,

k8s_helper_cli-0.5.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-k8s_helper/__init__.py,sha256=wtG9p8ZbOO4WDPZxf3acQ_pNu4x92MJBnwI9l8G7LCc,2666
-k8s_helper/cli.py,sha256=dBqPBfSNoh3NAFq5qiyERD0uV6Entf-rEwpuBhuYHGk,81655
-k8s_helper/config.py,sha256=P7YdfyvCHprrNs2J9DRb3RrClylfTTh5hfTtDzLug0A,6867
-k8s_helper/core.py,sha256=rf4dwcrV9fTyRZrWTucslOHJDTKhlnMXKqV_OWTIYQ8,130172
-k8s_helper/utils.py,sha256=wYgTd5ktyuI-EiVcfW7FrxA7MzXY5odrEKQgmMVdueY,9496
-k8s_helper_cli-0.5.0.dist-info/licenses/LICENSE,sha256=tXPvVl3gLVc6e0qCEoLH9KjeA7z4JVL78UybpvGtBCw,1096
-k8s_helper_cli-0.5.0.dist-info/METADATA,sha256=dHNcGQ7c-7KH9Z98yj4DFcXphLjDtQtoAt0cYaxEsSc,30789
-k8s_helper_cli-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-k8s_helper_cli-0.5.0.dist-info/entry_points.txt,sha256=IoCMWUZ6mn90LwzQzEy5YkWOwvogDdZ6ycqUWAzCFTQ,50
-k8s_helper_cli-0.5.0.dist-info/top_level.txt,sha256=x9A1jflyer-z2cFnkqk5B42juoH2q0fy5hkT9upsTG8,11
-k8s_helper_cli-0.5.0.dist-info/RECORD,,