utils_devops 0.1.158__tar.gz → 0.1.160__tar.gz

{utils_devops-0.1.158 → utils_devops-0.1.160}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utils_devops
-Version: 0.1.158
+Version: 0.1.160
 Summary: Lightweight DevOps utilities for automation scripts: config editing (YAML/JSON/INI/.env), templating, diffing, and CLI tools
 License: MIT
 Keywords: devops,automation,nginx,cli,jinja2,yaml,config,diff,templating,logging,docker,compose,file-ops

{utils_devops-0.1.158 → utils_devops-0.1.160}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "utils_devops"
-version = "0.1.158"  # Bumped for new string features + diffing
+version = "0.1.160"  # Bumped for new string features + diffing
 description = "Lightweight DevOps utilities for automation scripts: config editing (YAML/JSON/INI/.env), templating, diffing, and CLI tools"
 authors = ["Hamed Sheikhan <sh.sheikhan.m@gmail.com>"]
 license = "MIT"

{utils_devops-0.1.158 → utils_devops-0.1.160}/src/utils_devops/extras/docker_ops.py

@@ -8,7 +8,6 @@ import json
 import os
 import re
 from logging import Logger
-import re
 import sys
 import tarfile
 import tempfile
@@ -618,7 +617,7 @@ def compose_restart(compose_file: str, remove_volumes: bool = False,
 
 def compose_ps(compose_file: str, project_name: Optional[str] = None, env_file: Optional[str] = None) -> List[ContainerInfo]:
     """List compose services status using detected compose command"""
-    result = run_compose_command(compose_file, ["ps", "--format", "json"], project_name , env_file)
+    result = run_compose_command(compose_file, ["ps" ,"-a", "--format", "json"], project_name , env_file)
     
     containers = []
     try:
@@ -909,7 +908,7 @@ def check_health_from_compose_ps(compose_file: str) -> Dict[str, Any]:
     """
     try:
         # Run docker compose ps with JSON format
-        result = run_compose_command(compose_file, ["ps", "--format", "json"])
+        result = run_compose_command(compose_file, ["ps","-a", "--format", "json"])
         if result.rc != 0:
             return {"healthy": False, "error": f"docker compose ps failed: {result.stderr}"}
        
@@ -2220,8 +2219,7 @@ def playwright_test_compose(
     pull_missing: bool = True,
     no_build: bool = True,
     no_pull: bool = True,
-    keep_up: bool = False,
-    # Keep services up after each test_compose call so we can sequence them
+    keep_compose_up: bool = False,
     dry_run: bool = False,
     project_name: Optional[str] = None,
     logger: Optional[logger] = None,
@@ -2231,7 +2229,7 @@ def playwright_test_compose(
     application compose and a separate Playwright compose. This function reuses the
     existing `test_compose` function to perform validation, startup and health checks for
     the application compose.
-
+    
     Behavior summary:
     1. Validate inputs and (optionally) update version as in test_compose.
     2. Set STATIC_CAPTCHA=true in the system process environment (without modifying the file).
@@ -2241,19 +2239,34 @@ def playwright_test_compose(
     5. Follow logs (simulating -f) for the Playwright service(s) while polling the compose state
        to detect completion, and determine pass/fail from exit status and log patterns.
     6. Return a detailed result dict similar in structure to test_compose.
-
+    
     Notes:
     - Reuses `test_compose` for application startup and health checks.
     - Sets STATIC_CAPTCHA in the process environment only (os.environ).
     - Does not automatically bring services down; that is left to the caller.
     - Success is determined by all containers exiting with code 0 and/or presence of success patterns in logs.
-
+    
     Returns:
         Dict with keys: test_id, success, steps, app_result, logs_captured, duration, error
     """
+    
+    # Minimal sticker set - only what's necessary
+    STICKERS = {
+        'start': '🎬',
+        'success': '✅',
+        'error': '❌',
+        'info': 'ℹ️',
+        'waiting': '⏳',
+        'complete': '🏁',
+        'logs': '📝',
+        'analysis': '📊',
+        'cleanup': '🧹',
+    }
+    
     logger = logger or DEFAULT_LOGGER
     test_id = str(uuid.uuid4())[:8]
     start_time = dt_ops.current_datetime()
+    
     result = {
         "test_id": test_id,
         "success": False,
@@ -2263,40 +2276,50 @@ def playwright_test_compose(
         "duration": 0.0,
         "error": None,
     }
+    
+    project_name_playwright = project_name
+    
     try:
-        logger.info(f"▶️ Playwright test workflow starting ({test_id})")
-        logger.info(f" Compose files: app={compose_file} playwright={playwright_compose_file}")
-        # Step 0: Basic validation
-        logger.info("Step 0: validating compose and env files")
+        # Start header - clean and professional
+        logger.info(f"{STICKERS['start']} Playwright test starting (ID: {test_id})")
+        logger.info(f"{STICKERS['info']} App: {compose_file}")
+        logger.info(f"{STICKERS['info']} Playwright: {playwright_compose_file}")
+        if dry_run:
+            logger.info(f"{STICKERS['info']} Dry run mode")
+        logger.info("")
+        
+        # STEP 0: Validation
+        logger.info(f"{STICKERS['info']} STEP 0: Validating files")
         if not files.file_exists(compose_file):
             raise DockerOpsError(f"Application compose file not found: {compose_file}")
         if not files.file_exists(playwright_compose_file):
             raise DockerOpsError(f"Playwright compose file not found: {playwright_compose_file}")
-        # Step 1: Optional version update
-        if update_version and not dry_run:
-            logger.info("Step 1: updating version in env (requested)")
-            new_version = _update_env_version(env_file=env_file, source=version_source, logger=logger)
-            if new_version:
-                logger.info(f" Version updated to {new_version}")
-                # make sure runtime env sees new values
-                envs.import_env_to_system(get_env_compose(env_file))
-        elif update_version and dry_run:
-            logger.info("Step 1: version update skipped (dry run)")
-        else:
-            logger.info("Step 1: version update not requested")
-        # Step 2: Set STATIC_CAPTCHA=true in system process env
-        logger.info("Step 2: setting STATIC_CAPTCHA=true in process environment")
+        logger.info(f"{STICKERS['success']} Validation complete")
+        logger.info("")
+        
+        # STEP 1: Version update
+        if update_version:
+            logger.info(f"{STICKERS['info']} STEP 1: Updating version")
+            if not dry_run:
+                new_version = _update_env_version(env_file=env_file, source=version_source, logger=logger)
+                if new_version:
+                    logger.info(f"{STICKERS['success']} Version updated to {new_version}")
+                envs.set_system_env(key='STATIC_CAPTCHA', value='true')
+            else:
+                logger.info(f"{STICKERS['info']} Version update skipped (dry run)")
+            logger.info("")
+        
+        # STEP 2: Environment
         if not dry_run:
             envs.set_system_env(key='STATIC_CAPTCHA', value='true')
-        else:
-            logger.info("Step 2: env set skipped (dry run)")
-        # Step 3: Start application compose using test_compose but keep services up
-        logger.info("Step 3: bringing up application stack (health checks via test_compose)")
+        
+        # STEP 3: Application stack
+        logger.info(f"{STICKERS['info']} STEP 3: Starting application stack")
         if not dry_run:
             app_result = test_compose(
                 compose_file=compose_file,
                 env_file=env_file,
-                update_version=False,  # already handled
+                update_version=False,
                 services=services,
                 health_timeout=health_timeout,
                 health_interval=health_interval,
@@ -2305,126 +2328,215 @@ def playwright_test_compose(
                 pull_missing=pull_missing,
                 no_build=no_build,
                 no_pull=no_pull,
-                keep_compose_up=True,  # DO NOT tear down
+                keep_compose_up=True,
                 project_name=project_name,
                 dry_run=dry_run,
                 logger=logger,
             )
+            
             result['app_result'] = app_result
             if not app_result.get('success'):
-                raise DockerOpsError("Application compose failed to start or pass health checks")
-            logger.info(" Application stack is up and healthy")
+                raise DockerOpsError("Application stack failed")
+            
+            logger.info(f"{STICKERS['success']} Application stack ready")
+            logger.info("")
         else:
-            logger.info("Step 3: application start skipped (dry run)")
-        # Step 4: Start Playwright compose using compose_up
-        logger.info("Step 4: bringing up Playwright runner stack with compose_up")
+            logger.info(f"{STICKERS['info']} Application start skipped (dry run)")
+            logger.info("")
+        
+        # STEP 4: Playwright stack
+        logger.info(f"{STICKERS['info']} STEP 4: Starting Playwright runner")
         if not dry_run:
+            logger.info(f"{STICKERS['info']} Project: {project_name_playwright}")
             up_success = compose_up(
                 playwright_compose_file,
                 services=playwright_services,
-                project_name=project_name,
-                # Assume detached by default or add param if needed; help shows no param for detached, perhaps always detached
+                project_name=project_name_playwright,
             )
+            
             if not up_success:
                 raise DockerOpsError("Playwright compose_up failed")
-            logger.info(" Playwright stack started - now following logs until completion")
+            
+            logger.info(f"{STICKERS['success']} Playwright started")
+            logger.info(f"{STICKERS['waiting']} Following logs until completion...")
+            logger.info("")
         else:
-            logger.info("Step 4: playwright start skipped (dry run)")
-        # Step 5: Follow logs and wait for completion (simulate logs -f with polling)
+            logger.info(f"{STICKERS['info']} Playwright start skipped (dry run)")
+            logger.info("")
+        
+        # STEP 5: Log capture
+        pw_services = []
+        logs_acc = {}
+        
         if not dry_run and capture_logs:
-            logger.info("Step 5: following Playwright logs and waiting for completion")
-            pw_services = playwright_services or list(read_compose_file(playwright_compose_file, env_file).get('services', {}).keys())
-            logs_acc = {s: [] for s in pw_services}
+            logger.info(f"{STICKERS['logs']} STEP 5: Capturing logs")
+            
+            # Determine services to monitor
+            compose_config = read_compose_file(playwright_compose_file, env_file)
+            all_services = list(compose_config.get('services', {}).keys())
+            pw_services = playwright_services or all_services
+            
+            logger.info(f"{STICKERS['info']} Services: {', '.join(pw_services)}")
+            logger.info(f"{STICKERS['info']} Tail: {log_tail} lines, Timeout: {health_timeout}s")
+            logger.info("")
+            
+            logs_acc = {service: [] for service in pw_services}
             deadline = time.time() + health_timeout
             finished = False
-            timed_out = False
-            while not finished and not timed_out:
-                # Fetch current log snapshot
-                for svc in pw_services:
+            
+            # Wait for containers to initialize
+            time.sleep(3)
+            
+            while not finished:
+                current_time = time.time()
+                if current_time > deadline:
+                    raise DockerOpsError(f"Playwright runner timed out after {health_timeout}s")
+                
+                for service in pw_services:
                     try:
-                        lines = [l.text for l in compose_logs(playwright_compose_file, services=[svc], tail=log_tail)]
+                        # Get fresh logs for this service
+                        log_lines = compose_logs(
+                            playwright_compose_file,
+                            services=[service],
+                            tail=log_tail,
+                            project_name=project_name_playwright,
+                            follow=True,
+                            
+                        )
+                        
+                        for log_line in log_lines:
+                            if hasattr(log_line, 'message'):
+                                log_message = log_line.message
+                                # Add only new log lines
+                                if log_message not in logs_acc[service]:
+                                    logs_acc[service].append(log_message)
+                                    # Print with clean formatting: only service name at the beginning
+                                    logger.info(f"{STICKERS['info']} {service}")
+                                    logger.info(log_message)
                     except Exception as e:
-                        lines = [f"Error fetching logs: {str(e)}"]
-                    # Append new unique lines
-                    for ln in lines:
-                        if ln not in logs_acc[svc]:
-                            logs_acc[svc].append(ln)
-                            logger.info(f"[{svc}] {ln}")  # Simulate real-time logging
-                # Check if all services have exited
-                ps = compose_ps(playwright_compose_file, project_name=project_name)
-                running = any(
-                    'running' in (c.status or '').lower() or 'up' in (c.status or '').lower()
-                    for c in ps if (c.service or '') in pw_services
-                )
-                if not running:
+                        error_msg = f"Error fetching logs: {str(e)}"
+                        logger.error(f"{STICKERS['error']} {service} - {error_msg}")
+                
+                # Check if all services have finished
+                ps = compose_ps(playwright_compose_file, project_name=project_name_playwright)
+                running_count = 0
+                
+                for container in ps:
+                    service_name = container.service or ''
+                    if service_name in pw_services:
+                        status = (container.status or '').lower()
+                        if 'running' in status or 'up' in status:
+                            running_count += 1
+                
+                if running_count == 0:
                     finished = True
-                if time.time() > deadline:
-                    timed_out = True
-                if not finished and not timed_out:
+                    logger.info(f"{STICKERS['complete']} All services completed")
+                    logger.info("")
+                else:
                     time.sleep(health_interval)
+            
             result['logs_captured'] = logs_acc
-            result['steps']['playwright_logs'] = {
-                'finished': finished,
-                'timed_out': timed_out,
-            }
-            if timed_out:
-                raise DockerOpsError("Playwright runner timed out")
-        else:
-            if dry_run:
-                logger.info("Step 5: log following skipped (dry run)")
-        # Step 6: Analyze outcome
-        logger.info("Step 6: analyzing Playwright runner outcome")
+        
+        # STEP 6: Analysis
+        logger.info(f"{STICKERS['analysis']} STEP 6: Analyzing results")
+        
         if not dry_run:
             # Get exit codes
-            ps = compose_ps(playwright_compose_file, project_name=project_name)
+            ps = compose_ps(playwright_compose_file, project_name=project_name_playwright)
             exit_codes = {}
-            for c in ps:
-                if (c.service or '') in pw_services:
-                    exit_code = getattr(c, 'exit_code', None) or 1  # Assume non-zero if missing
-                    exit_codes[c.service] = exit_code
+            
+            for container in ps:
+                service_name = container.service or ''
+                if service_name in pw_services:
+                    exit_code = getattr(container, 'exit_code', None) or 1
+                    exit_codes[service_name] = exit_code
+            
+            # Check overall success
             all_success = all(code == 0 for code in exit_codes.values())
-            # Log analysis
-            aggregated_logs = '\n'.join(' '.join(v) for v in logs_acc.values())
-            failed = any(re.search(pat, aggregated_logs, re.I) for pat in ['FAILED', 'FAIL', 'ERROR', 'AssertionError', 'Test Failed'])
-            passed = any(re.search(pat, aggregated_logs, re.I) for pat in ['All tests passed', 'Tests passed', 'PASS'])
-            if all_success and (passed or not failed):
+            
+            if all_success:
                 result['success'] = True
-                logger.info(f"Playwright run successful ({test_id})")
+                logger.info(f"{STICKERS['success']} " + "="*50)
+                logger.info(f"{STICKERS['success']} TESTS PASSED")
+                logger.info(f"{STICKERS['success']} Test ID: {test_id}")
+                logger.info(f"{STICKERS['success']} " + "="*50)
             else:
                 result['success'] = False
-                result['error'] = 'Playwright tests failed based on exit codes or logs'
-                logger.error(f"Playwright run failed ({test_id})")
-            result['steps']['analysis'] = {
-                'exit_codes': exit_codes,
-                'passed_patterns': passed,
-                'failed_patterns': failed,
-            }
+                result['error'] = 'Playwright tests failed'
+                logger.error(f"{STICKERS['error']} " + "="*50)
+                logger.error(f"{STICKERS['error']} TESTS FAILED")
+                logger.error(f"{STICKERS['error']} Exit codes: {exit_codes}")
+                logger.error(f"{STICKERS['error']} " + "="*50)
         else:
-            result['success'] = True  # Assume success in dry run
+            result['success'] = True
+            logger.info(f"{STICKERS['info']} Analysis skipped (dry run)")
+        
+        # Final timing
         result['duration'] = (dt_ops.current_datetime() - start_time).total_seconds()
-        if not keep_up :
+        logger.info(f"{STICKERS['info']} Duration: {result['duration']:.2f}s")
+        logger.info("")
+        
+        # Cleanup
+        if not keep_compose_up and not dry_run:
+            logger.info(f"{STICKERS['cleanup']} Cleaning up")
+            logger.info(f"{STICKERS['info']} Stopping Playwright stack...")
             compose_down(
                 compose_file=playwright_compose_file,
+                project_name=project_name_playwright
             )
-            logger.info("Playwright compose down")
+            logger.info(f"{STICKERS['success']} Playwright stopped")
+            
+            logger.info(f"{STICKERS['info']} Stopping Application stack...")
             compose_down(
                 compose_file=compose_file,
+                project_name=project_name
             )
-            logger.info("all servise compose down")
+            logger.info(f"{STICKERS['success']} Application stopped")
+            logger.info(f"{STICKERS['success']} Cleanup complete")
+            logger.info("")
+        
+        # Final summary
+        if result['success']:
+            logger.info(f"{STICKERS['complete']} " + "="*70)
+            logger.info(f"{STICKERS['complete']} TEST COMPLETE: SUCCESS")
+            logger.info(f"{STICKERS['complete']} Duration: {result['duration']:.2f}s")
+            logger.info(f"{STICKERS['complete']} Test ID: {test_id}")
+            logger.info(f"{STICKERS['complete']} " + "="*70)
+        else:
+            logger.error(f"{STICKERS['error']} " + "="*70)
+            logger.error(f"{STICKERS['error']} TEST COMPLETE: FAILED")
+            logger.error(f"{STICKERS['error']} Duration: {result['duration']:.2f}s")
+            logger.error(f"{STICKERS['error']} Test ID: {test_id}")
+            logger.error(f"{STICKERS['error']} " + "="*70)
+        
         return result
+        
     except Exception as e:
         result['duration'] = (dt_ops.current_datetime() - start_time).total_seconds()
         result['error'] = str(e)
-        logger.error(f"Playwright test workflow failed ({test_id}): {e}")
-        if not keep_up :
-            compose_down(
-                compose_file=playwright_compose_file,
-            )
-            logger.info("Playwright compose down")
-            compose_down(
-                compose_file=compose_file,
-            )
-            logger.info("all servise compose down")
+        
+        logger.error(f"{STICKERS['error']} Test failed: {e}")
+        logger.error(f"{STICKERS['info']} Duration: {result['duration']:.2f}s")
+        
+        # Emergency cleanup
+        if not keep_compose_up and not dry_run:
+            logger.info(f"{STICKERS['cleanup']} Emergency cleanup")
+            try:
+                compose_down(
+                    compose_file=playwright_compose_file,
+                    project_name=project_name_playwright
+                )
+            except:
+                pass
+            
+            try:
+                compose_down(
+                    compose_file=compose_file,
+                    project_name=project_name
+                )
+            except:
+                pass
+        
         return result