demos: add more demos, fix issues.

Author: sfermigier

.gitignore

@@ -11,6 +11,7 @@ packages-ignored
 packages-ignored2
 /local-notes
 /docs/site/
+/demos/logs/
 
 # Temp
 /packages/hop3-web/src/hop3_web/lib/

demos/demo.py

@@ -38,6 +38,7 @@
 from lib.context import DemoContext, OutputLevel
 from lib.discovery import discover_demos, resolve_demo
 from lib.display import list_demos, print_banner, print_config, show_inventory
+from lib.logging import get_log_session, init_logging
 from lib.output import (
     pause,
     print_demo_result,
@@ -85,6 +86,13 @@ def main() -> int:
     if getattr(args, "debug", False):
         set_debug_mode(True)
 
+    # Initialize logging (unless --no-logs)
+    if not getattr(args, "no_logs", False):
+        logs_dir = getattr(args, "logs_dir", None)
+        log_session = init_logging(logs_dir)
+        if output_level >= OutputLevel.NORMAL:
+            print_info(f"Logs: {log_session.session_dir}")
+
     # Discover and resolve demos
     available_demos = discover_demos(args.demo_dirs)
     demos_to_run = _resolve_demos(args, available_demos)
@@ -245,6 +253,13 @@ def _show_summary(ctx: DemoContext, results: list, overall_start: float) -> int:
 
     print_summary_stats(passed, failed, skipped, overall_duration)
 
+    # Show log directory if there were failures
+    if failed > 0:
+        log_session = get_log_session()
+        if log_session:
+            print()
+            print_info(f"Detailed logs: {log_session.session_dir}")
+
     # Show admin credentials and UI URL if keeping apps
     if ctx.no_cleanup and ctx.output_level >= OutputLevel.NORMAL:
         print()

demos/demo33/app/app.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2025, Abilian SAS
+# SPDX-License-Identifier: Apache-2.0
+"""Demo 33: Native Python app with declarative PostgreSQL provider.
+
+A Flask application demonstrating the [[provider]] section in hop3.toml
+for declaring addon dependencies.
+"""
+from __future__ import annotations
+
+import os
+
+from flask import Flask, jsonify
+
+app = Flask(__name__)
+
+# Get DATABASE_URL from environment (set by Hop3 when addon is attached)
+DATABASE_URL = os.environ.get("DATABASE_URL")
+
+
+def get_db_connection():
+    """Get a database connection if DATABASE_URL is configured."""
+    if not DATABASE_URL:
+        return None
+    import psycopg2
+
+    return psycopg2.connect(DATABASE_URL)
+
+
+@app.route("/")
+def home():
+    """Home page."""
+    return jsonify({
+        "app": "demo33",
+        "type": "native",
+        "feature": "declarative-provider",
+        "message": "Welcome to demo33 - Declarative PostgreSQL Provider!",
+        "database_configured": DATABASE_URL is not None,
+    })
+
+
+@app.route("/db-status")
+def db_status():
+    """Check database connection status."""
+    if not DATABASE_URL:
+        return jsonify({"status": "not_configured", "message": "DATABASE_URL not set"})
+
+    try:
+        conn = get_db_connection()
+        with conn.cursor() as cur:
+            cur.execute("SELECT version();")
+            version = cur.fetchone()[0]
+        conn.close()
+        return jsonify({
+            "status": "connected",
+            "version": version,
+        })
+    except Exception as e:
+        return jsonify({"status": "error", "error": str(e)}), 500
+
+
+@app.route("/db-test")
+def db_test():
+    """Test database operations (create table, insert, query)."""
+    if not DATABASE_URL:
+        return jsonify({"status": "not_configured"}), 400
+
+    try:
+        conn = get_db_connection()
+        with conn.cursor() as cur:
+            # Create test table
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS provider_items (
+                    id SERIAL PRIMARY KEY,
+                    name VARCHAR(100),
+                    created_at TIMESTAMP DEFAULT NOW()
+                )
+            """)
+            # Insert a test row
+            cur.execute(
+                "INSERT INTO provider_items (name) VALUES (%s) RETURNING id",
+                (f"item-{os.urandom(4).hex()}",)
+            )
+            new_id = cur.fetchone()[0]
+            # Count rows
+            cur.execute("SELECT COUNT(*) FROM provider_items")
+            count = cur.fetchone()[0]
+        conn.commit()
+        conn.close()
+        return jsonify({
+            "status": "success",
+            "inserted_id": new_id,
+            "total_items": count,
+        })
+    except Exception as e:
+        return jsonify({"status": "error", "error": str(e)}), 500
+
+
+@app.route("/health")
+def health():
+    """Health check endpoint."""
+    return jsonify({"status": "healthy"})
+
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 5000))
+    app.run(host="0.0.0.0", port=port)

demos/demo33/app/hop3.toml

@@ -0,0 +1,23 @@
+# hop3.toml - Native Python app with declarative PostgreSQL provider
+#
+# This demo showcases the [[provider]] section for declaring addon dependencies.
+# The [[provider]] section declares that this app needs a PostgreSQL database.
+
+[metadata]
+id = "demo33-provider-postgres"
+version = "0.1.0"
+title = "Declarative PostgreSQL Demo"
+description = "Demonstrates declarative addon provisioning with [[provider]] section"
+tags = ["python", "postgres", "provider"]
+
+[build]
+builder = "python-3.12"
+pip-install = ["-r", "requirements.txt"]
+
+[run]
+start = "gunicorn --workers 2 --bind 0.0.0.0:$PORT app:app"
+
+# Declarative provider section - this declares that the app needs PostgreSQL
+[[provider]]
+name = "postgres"
+plan = "standard"

demos/demo33/app/requirements.txt

@@ -0,0 +1,3 @@
+flask
+gunicorn
+psycopg2-binary

demos/demo33/demo-script.py

@@ -0,0 +1,202 @@
+# Copyright (c) 2025, Abilian SAS
+# SPDX-License-Identifier: Apache-2.0
+"""Demo 33: Declarative PostgreSQL Provider.
+
+Demonstrates the [[provider]] section in hop3.toml for declaring addon dependencies.
+This demo shows how to use the declarative format to specify that an app requires
+a PostgreSQL database.
+
+Note: Currently, addons are still created manually via CLI commands.
+The [[provider]] section documents the app's requirements and will be used
+for automatic provisioning in a future version.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lib import DemoContext
+
+# Demo metadata
+TITLE = "Demo 33: Declarative PostgreSQL Provider"
+DESCRIPTION = """
+Demonstrates the [[provider]] section in hop3.toml:
+  - Declaring addon requirements with [[provider]]
+  - App uses 'name = "postgres"' in provider section
+  - Shows how declarative provisioning will work
+  - Currently creates addons manually (auto-provisioning coming)
+"""
+
+APP_NAME = "demo33"
+APP_DIR = Path(__file__).parent / "app"
+DEFAULT_HOSTNAME = "demo33.hop"
+DB_NAME = "demo33-db"
+
+
+def run(ctx: DemoContext) -> None:
+    """Run the demo."""
+    from lib import (
+        check_app_status,
+        cleanup_app,
+        deploy_app,
+        pause,
+        print_blank,
+        print_header,
+        print_info,
+        print_step,
+        print_success,
+        print_warning,
+        redeploy_app,
+        set_hostname,
+        show_app_structure,
+        show_file_content,
+        test_app_via_curl,
+        wait_for_app,
+    )
+    from lib.commands import run_hop3
+
+    app_hostname = DEFAULT_HOSTNAME
+    app_url = f"https://{app_hostname}"
+
+    # Clean up any leftover database from previous failed runs
+    run_hop3(f"addons:destroy {DB_NAME} --service-type postgres", check=False, show=False)
+
+    # Show app structure
+    print_header("Deploying App with Declarative PostgreSQL Provider")
+
+    show_app_structure(
+        APP_NAME,
+        [
+            ("app.py", "Flask application with PostgreSQL support"),
+            ("requirements.txt", "Python dependencies (flask, psycopg2)"),
+            ("hop3.toml", "Hop3 configuration WITH [[provider]] section"),
+        ],
+    )
+    print_info("This demo showcases the [[provider]] section in hop3.toml.")
+    print_info("The app declares its PostgreSQL requirement declaratively.")
+    print_blank()
+    pause(ctx.pause_between_steps)
+
+    # Show hop3.toml - emphasize the [[provider]] section
+    print_header("hop3.toml with [[provider]] Section")
+    show_file_content(APP_DIR / "hop3.toml", "hop3.toml:")
+    print_blank()
+    print_info("Note the [[provider]] section at the end!")
+    print_info("This declares that the app needs a 'postgres' addon.")
+    pause(ctx.pause_between_steps)
+
+    # Deploy the application
+    print_header("Step 1: Deploy Application")
+    deploy_app(ctx, APP_NAME, APP_DIR)
+    set_hostname(ctx, APP_NAME, app_hostname)
+    redeploy_app(ctx, APP_NAME, APP_DIR)
+    wait_for_app(seconds=5, message="Waiting for application to start...")
+    check_app_status(ctx, APP_NAME)
+
+    # Test main endpoint
+    print_header("Step 2: Test Application (Without Database)")
+    test_app_via_curl(ctx, app_url, expected_content="Welcome to demo33")
+    pause(ctx.pause_between_steps)
+
+    # Test database status - should show not_configured
+    print_header("Step 3: Check Database Status (Before Addon)")
+    print_step("Testing /db-status endpoint...")
+    test_app_via_curl(ctx, f"{app_url}/db-status", expected_content="not_configured")
+    print_blank()
+    print_info("The [[provider]] section declared the need for PostgreSQL,")
+    print_info("but the addon hasn't been provisioned yet.")
+    pause(ctx.pause_between_steps)
+
+    # Create PostgreSQL addon (manual for now)
+    print_header("Step 4: Provision PostgreSQL (Manual)")
+    print_info("In the future, this will be automatic based on [[provider]].")
+    print_info("For now, we create the addon manually:")
+    print_blank()
+    print_step(f"Creating PostgreSQL database '{DB_NAME}'...")
+    result = run_hop3(f"addons:create postgres {DB_NAME}", check=False)
+
+    postgres_available = result.returncode == 0
+    if not postgres_available:
+        print_warning("PostgreSQL creation failed.")
+        if result.stderr:
+            print_info(f"  Error: {result.stderr.strip()}")
+    else:
+        print_success(f"PostgreSQL database '{DB_NAME}' created.")
+    pause(ctx.pause_between_steps)
+
+    # Attach database to app
+    if postgres_available:
+        print_header("Step 5: Attach Database to Application")
+        print_step(f"Attaching '{DB_NAME}' to '{APP_NAME}'...")
+        result = run_hop3(
+            f"addons:attach {DB_NAME} --app {APP_NAME} --service-type postgres",
+            check=False,
+        )
+
+        if result.returncode != 0:
+            print_warning("Failed to attach database.")
+            postgres_available = False
+        else:
+            print_success("Database attached. DATABASE_URL is now set.")
+        pause(ctx.pause_between_steps)
+
+    # Redeploy to pick up DATABASE_URL
+    if postgres_available:
+        print_header("Step 6: Redeploy to Apply Configuration")
+        print_step("Redeploying application with DATABASE_URL...")
+        redeploy_app(ctx, APP_NAME, APP_DIR)
+        wait_for_app(seconds=5)
+
+        # Test database connection
+        print_header("Step 7: Verify Database Connection")
+        print_step("Testing /db-status endpoint...")
+        test_app_via_curl(ctx, f"{app_url}/db-status", expected_content="connected")
+        print_success("App connected to PostgreSQL!")
+        pause(ctx.pause_between_steps)
+
+        # Test database operations
+        print_header("Step 8: Test Database Operations")
+        print_step("Testing /db-test endpoint...")
+        test_app_via_curl(ctx, f"{app_url}/db-test", expected_content="success")
+        print_success("Database operations working!")
+        pause(ctx.pause_between_steps)
+
+        # Cleanup database
+        print_header("Step 9: Cleanup Database")
+        print_step("Detaching and destroying database...")
+        run_hop3(
+            f"addons:detach {DB_NAME} --app {APP_NAME} --service-type postgres",
+            check=False,
+        )
+        run_hop3(f"addons:destroy {DB_NAME} --service-type postgres", check=False)
+        print_success("Database cleaned up.")
+        pause(ctx.pause_between_steps)
+    else:
+        print_header("PostgreSQL Not Available")
+        print_info("The [[provider]] section would enable automatic provisioning")
+        print_info("once that feature is implemented.")
+        print_blank()
+        pause(ctx.pause_between_steps)
+
+    # Cleanup app
+    cleanup_app(ctx, APP_NAME, app_url)
+
+    print_blank()
+    print_header("Summary: [[provider]] Section")
+    print_info("This demo showed the declarative [[provider]] section:")
+    print_info("  [[provider]]")
+    print_info('  name = "postgres"')
+    print_info('  plan = "standard"')
+    print_blank()
+    print_info("Benefits of declarative providers:")
+    print_info("  - Documents app requirements in hop3.toml")
+    print_info("  - Enables future automatic provisioning")
+    print_info("  - Marketplace displays required services")
+    print_blank()
+
+    if postgres_available:
+        print_success("Demo 33 completed: Declarative PostgreSQL provider demonstrated.")
+    else:
+        print_success("Demo 33 completed: [[provider]] section showcased (PostgreSQL unavailable).")