Deployment Operations

# From models/deployment.py
class DeploymentStatus(enum.Enum):
    PENDING = "pending"          # Deployment created, waiting to start
    QUEUED = "queued"           # Queued in ARQ for processing
    BUILDING = "building"       # Building Docker image
    DEPLOYING = "deploying"     # Actively deploying to server
    RUNNING = "running"         # Legacy - use DEPLOYING instead
    SUCCESS = "success"         # Deployment completed successfully
    FAILED = "failed"           # Deployment failed with error
    CANCELLED = "cancelled"     # Deployment cancelled by user
    ROLLED_BACK = "rolled_back" # Previous deployment rolled back
    DESTROYED = "destroyed"     # Environment was destroyed

POST /api/v1/deployments/{deployment_id}/retry
Authorization: Bearer <token>

curl -X POST https://api.oec.sh/api/v1/deployments/a1b2c3d4-5678-90ab-cdef-1234567890ab/retry \
  -H "Authorization: Bearer YOUR_TOKEN"

{
  "id": "e5f6g7h8-90ab-cdef-1234-567890abcdef",
  "project_id": "proj_abc123",
  "environment_id": "env_xyz789",
  "version": 5,
  "status": "pending",
  "trigger": "manual",
  "git_commit": "a1b2c3d",
  "git_branch": "main",
  "extra_data": {
    "retry_of": "a1b2c3d4-5678-90ab-cdef-1234567890ab"
  },
  "created_at": "2025-01-15T10:30:00Z"
}

# From routes/deployments.py - Line 570
@router.post("/{deployment_id}/retry")
async def retry_deployment(
    db: DBSession,
    current_user: CurrentUser,
    deployment_id: UUID,
) -> DeploymentResponse:
    # Validate deployment status
    if original.status != DeploymentStatus.FAILED:
        raise HTTPException(400, "Can only retry failed deployments")
 
    # Check for ongoing deployments
    if has_ongoing_deployment(project_id):
        raise HTTPException(409, "Deployment already in progress")
 
    # Create new deployment with same config
    new_deployment = Deployment(
        project_id=original.project_id,
        version=next_version,
        git_branch=original.git_branch,
        git_commit=original.git_commit,
        extra_data={"retry_of": str(original.id)}
    )
 
    # Queue for execution via ARQ
    await enqueue_task("deploy_environment", ...)

POST /api/v1/deployments/{deployment_id}/cancel
Authorization: Bearer <token>

curl -X POST https://api.oec.sh/api/v1/deployments/abc123/cancel \
  -H "Authorization: Bearer YOUR_TOKEN"

{
  "message": "Deployment cancelled"
}

# From routes/deployments.py - Line 504
@router.post("/{deployment_id}/cancel")
async def cancel_deployment(
    db: DBSession,
    current_user: CurrentUser,
    deployment_id: UUID,
) -> dict[str, str]:
    # Validate current status
    if deployment.status not in (DeploymentStatus.PENDING, DeploymentStatus.RUNNING):
        raise HTTPException(400, f"Cannot cancel deployment in {deployment.status} state")
 
    # Mark as cancelled
    deployment.status = DeploymentStatus.CANCELLED
 
    # Log cancellation
    log_entry = DeploymentLog(
        deployment_id=deployment.id,
        level=LogLevel.WARNING,
        message="Deployment cancelled by user",
        data={"cancelled_by": str(current_user.id)}
    )
 
    await db.commit()

POST /api/v1/deployments/{deployment_id}/rollback
Authorization: Bearer <token>

# Rollback TO deployment abc123 (the last known good deployment)
curl -X POST https://api.oec.sh/api/v1/deployments/abc123/rollback \
  -H "Authorization: Bearer YOUR_TOKEN"

{
  "id": "new_deployment_id",
  "project_id": "proj_abc123",
  "environment_id": "env_xyz789",
  "version": 8,
  "status": "pending",
  "trigger": "rollback",
  "git_commit": "a1b2c3d",
  "git_branch": "main",
  "rollback_from_id": "abc123",
  "extra_data": {
    "rollback_to": "abc123"
  }
}

# Get deployment history to find rollback target
curl https://api.oec.sh/api/v1/deployments?project_id=proj_abc123&status=success \
  -H "Authorization: Bearer YOUR_TOKEN"

# Scenario: Rollback from v2 to v1
v1 deployment:
  - Odoo modules: sale, purchase
  - Database: odoo_schema_v1
 
v2 deployment (added CRM):
  - Odoo modules: sale, purchase, crm
  - Database: odoo_schema_v2 (crm tables added)
 
Rollback to v1:
  - Code: ✅ Reverted to v1 (no CRM module)
  - Database: ⚠️  Still has crm tables from v2
  - Result: May cause errors if CRM dependencies exist

# From routes/deployments.py - Line 673
@router.post("/{deployment_id}/rollback")
async def rollback_deployment(...):
    # Validate target
    if target.status != DeploymentStatus.SUCCESS:
        raise HTTPException(400, "Can only rollback to successful deployments")
 
    # Create new deployment with rollback trigger
    rollback = Deployment(
        project_id=target.project_id,
        trigger=DeploymentTrigger.ROLLBACK,
        version=next_version,
        git_branch=target.git_branch,
        git_commit=target.git_commit,
        rollback_from_id=target.id
    )
 
    # Deploy using OdooDeployer (same as normal deploy)
    await enqueue_task("deploy_environment", ...)

# 1. Find backup from before problematic deployment
GET /api/v1/environments/{env_id}/backups
 
# 2. Restore backup (includes database + filestore)
POST /api/v1/environments/{env_id}/restore
{
  "backup_id": "backup_from_before_issue"
}
 
# 3. Then rollback code to match
POST /api/v1/deployments/{old_deployment_id}/rollback

POST /api/v1/environments/{environment_id}/deploy
Authorization: Bearer <token>
Content-Type: application/json
 
{
  "force": true
}

# Force redeploy of environment
curl -X POST https://api.oec.sh/api/v1/environments/env_xyz789/deploy \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "force": true,
    "git_branch": "main"
  }'

# From tasks/worker.py - Line 108
async def redeploy_environment(
    ctx: dict,
    environment_id: str,
    task_id: str | None = None,
    **kwargs
) -> dict:
    # Delegate to deploy with force=True
    return await execute_deploy(
        ctx,
        environment_id,
        task_id=task_id,
        force=True,  # Force redeploy
        **kwargs
    )

DELETE /api/v1/deployments/environment/{environment_id}/destroy?delete_data=false
Authorization: Bearer <token>

# Destroy containers only (preserve filestore and custom addons)
curl -X DELETE https://api.oec.sh/api/v1/deployments/environment/env_xyz789/destroy \
  -H "Authorization: Bearer YOUR_TOKEN"
 
# Destroy everything including data
curl -X DELETE https://api.oec.sh/api/v1/deployments/environment/env_xyz789/destroy?delete_data=true \
  -H "Authorization: Bearer YOUR_TOKEN"

{
  "message": "Environment destroyed successfully",
  "environment_id": "env_xyz789",
  "deleted_containers": true,
  "deleted_database": true,
  "deleted_data": false
}

# Docker containers
docker stop {env_id}_odoo
docker rm {env_id}_odoo
docker stop {env_id}_db
docker rm {env_id}_db
 
# Docker network
docker network rm paasportal_net_{env_id}
 
# PostgreSQL volume (CRITICAL: Required for fresh DB credentials)
docker volume rm paasportal_pgdata_{env_id}
 
# Odoo configuration
rm /opt/paasportal/{env_id}/odoo.conf

# Entire environment directory
rm -rf /opt/paasportal/{env_id}/
  ├── odoo.conf          # Config file
  ├── addons/           # Custom addons (git clones)
  ├── filestore/        # User uploaded files
  └── logs/             # Odoo log files

# Problem scenario if volume NOT removed:
1. Deploy environment with password "abc123"
   → PostgreSQL volume created with password hash
2. Destroy environment
3. Redeploy with password "xyz789"
   → New password in odoo.conf
   → Volume still has old password hash
   → Connection fails: FATAL: password authentication failed

# From routes/deployments.py - Line 1187
destroy_record = Deployment(
    project_id=project.id,
    environment_id=environment_id,
    trigger=DeploymentTrigger.DESTROY,
    status=DeploymentStatus.DESTROYED,
    started_at=datetime.now(UTC),
    completed_at=datetime.now(UTC)
)

environment.status = EnvironmentStatus.PENDING
environment.container_id = None
environment.container_name = None
environment.is_active = False  # CRITICAL: Releases quota

# From services/quota_service.py
def _get_total_resources(org_id):
    # Only count active environments
    result = db.execute(
        select(func.sum(ProjectEnvironment.cpu_cores))
        .where(
            ProjectEnvironment.organization_id == org_id,
            ProjectEnvironment.is_active == True  # ← Must be set to False on destroy
        )
    )

# From models/deployment.py
class DeploymentTrigger(enum.Enum):
    MANUAL = "manual"              # User clicked deploy button
    GIT_PUSH = "git_push"          # Git webhook (GitHub/GitLab push)
    WEBHOOK = "webhook"            # Generic webhook trigger
    SCHEDULED = "scheduled"        # Scheduled deployment (future)
    ROLLBACK = "rollback"          # Rollback operation
    AUTO_DEPLOY = "auto_deploy"    # Auto-deploy on branch update
    DESTROY = "destroy"            # Environment destroyed
    CONFIG_UPDATE = "config_update" # Configuration changed

POST /api/v1/deployments
{
  "project_id": "proj_abc123",
  "environment_id": "env_xyz789",
  "git_branch": "main"
}

# Webhook URL
POST https://api.oec.sh/api/v1/webhooks/github
 
# Headers
X-Hub-Signature-256: sha256=<hmac_signature>
X-GitHub-Event: push
X-GitHub-Delivery: <delivery_id>
 
# Payload
{
  "ref": "refs/heads/main",
  "repository": {
    "full_name": "your-org/your-repo"
  },
  "commits": [...]
}

# From routes/webhooks.py - Line 53
def verify_github_signature(payload: bytes, signature: str, secret: str) -> bool:
    expected = "sha256=" + hmac.new(
        secret.encode("utf-8"),
        payload,
        hashlib.sha256
    ).hexdigest()
 
    return hmac.compare_digest(expected, signature)

PATCH /api/v1/projects/{project_id}/environments/{env_id}
{
  "auto_deploy": true,
  "git_branch": "main"
}

# From routes/webhooks.py - Line 100
async def _trigger_module_repo_deploys(repo_url, branch):
    # Find all module repos with:
    # - Same git_url
    # - Same git_branch
    # - auto_deploy = true
    # - status = ACTIVE
 
    for repo in matching_repos:
        # Queue deployment for each environment
        await enqueue_task("deploy_module_repository", ...)

{
  "schedule": {
    "cron": "0 2 * * *",
    "timezone": "UTC",
    "enabled": true
  }
}

# From config.py - Line 472
class QueueSettings(BaseSettings):
    max_jobs: int = 10              # Max concurrent jobs
    job_timeout: int = 600           # 10 minutes per job
    max_tries: int = 3               # Retry failed jobs 3 times
    queue_name: str = "paasportal:arq:queue"
    deployment_timeout: int = 1800   # 30 min deployment timeout

# From routes/deployments.py - Line 113
# Check for ongoing deployments
result = await db.execute(
    select(Deployment).where(
        Deployment.environment_id == environment_id,
        Deployment.status.in_([
            DeploymentStatus.PENDING,
            DeploymentStatus.RUNNING
        ])
    )
)
 
if result.scalar_one_or_none():
    raise HTTPException(409, "Deployment already in progress")

# From tasks/worker.py - Line 78
async def deploy_environment(ctx, environment_id, task_id, **kwargs):
    # Jobs processed in order queued
    logger.info(f"Starting deployment {environment_id}")

# From tasks/worker.py - Line 457
async def check_stuck_deployments(ctx: dict) -> None:
    # Find deployments stuck for > 30 minutes
    cutoff_time = datetime.now(UTC) - timedelta(seconds=1800)
 
    stuck = db.execute(
        select(Deployment).where(
            Deployment.status.in_([PENDING, RUNNING]),
            Deployment.started_at < cutoff_time
        )
    )
 
    for deployment in stuck:
        deployment.status = DeploymentStatus.FAILED
        deployment.error_message = "Deployment timed out after 30 minutes"
        environment.status = EnvironmentStatus.ERROR

# Retry schedule (from config)
retry_base_delay: 5.0 seconds
retry_max_delay: 300.0 seconds (5 minutes)
 
# Actual retries
Attempt 1: Immediate
Attempt 2: 5 seconds later
Attempt 3: 15 seconds later (exponential backoff)

# DLQ storage
dlq_key = f"paasportal:dlq:{job_id}"
redis.hset(dlq_key, {
    "function_name": "deploy_environment",
    "args": [...],
    "error": "SSH connection timeout",
    "retry_count": 3,
    "traceback": "..."
})

# Future API endpoint (planned)
GET /api/v1/admin/dead-letter-queue

# From models/deployment.py
deployment.image_tag = "odoo:17.0"  # Full image URL

deployment.extra_data = {
    "git": {
        "committer_name": "John Doe",
        "committer_email": "john@example.com",
        "commit_date": "2025-01-15T10:00:00Z"
    },
    "config": {
        "cpu_cores": 2,
        "ram_mb": 4096,
        "disk_gb": 20,
        "workers": 4
    },
    "addons": [
        {"name": "platform-addons", "branch": "17.0"},
        {"name": "org-addons", "branch": "main"}
    ]
}

# From services/odoo_deployer.py - Line 453
git_info = {
    "git_commit": "a1b2c3d4e5f6g7h8i9j0",  # Full SHA
    "git_message": "Fix authentication bug",
    "git_branch": "main",
    "committer_name": "Jane Smith",
    "committer_email": "jane@example.com",
    "commit_date": "2025-01-15T14:23:45Z"
}

Deployment #12 - main@a1b2c3d
"Fix authentication bug"
by Jane Smith on Jan 15, 2025 at 2:23 PM

# Create backup before risky deployment
POST /api/v1/environments/{env_id}/backups
{
  "backup_type": "manual",
  "comment": "Before v2.0 deployment"
}
 
# If deployment fails, restore backup
POST /api/v1/environments/{env_id}/restore
{
  "backup_id": "backup_xyz"
}

# From services/odoo_deployer.py - Line 598
result.step = DeploymentStep.HEALTH_CHECK
 
healthy = await self._health_check(config)
 
if healthy:
    result.add_log("Health check passed!")
else:
    result.add_log("Warning: Health check failed, but container is running")

docker inspect {container_name} --format='{{.State.Health.Status}}'
 
# Expected: "healthy" or "running"

async def _health_check(config):
    url = f"https://{config.subdomain}.{config.apps_domain}"
 
    try:
        response = await http.get(url, timeout=30)
        return response.status_code == 200
    except Exception as e:
        logger.warning(f"Health check failed: {e}")
        return False

docker exec {db_container} pg_isready -U odoo
 
# Expected: "accepting connections"

{
  "health_checks": [
    {
      "type": "http",
      "path": "/web/health",
      "expected_status": 200,
      "timeout": 10
    },
    {
      "type": "tcp",
      "port": 8069,
      "timeout": 5
    }
  ]
}

{
  "health_check_policy": {
    "enabled": true,
    "rollback_on_failure": true,
    "retries": 3,
    "retry_interval": 30
  }
}

# From models/deployment.py - Line 175
class DeploymentLog(Base):
    id: UUID
    deployment_id: UUID
    timestamp: datetime
    level: LogLevel  # DEBUG, INFO, WARNING, ERROR
    message: str
    step: str  # Deployment step identifier
    data: dict  # Additional structured data

class LogLevel(enum.Enum):
    DEBUG = "debug"      # Verbose debugging info
    INFO = "info"        # Normal operational messages
    WARNING = "warning"  # Warning but not fatal
    ERROR = "error"      # Fatal errors causing failure

# From services/odoo_deployer.py - Line 49
DEPLOYMENT_STEPS = [
    "initializing",              # Preparing deployment config
    "connecting",               # SSH connection to server
    "creating_network",         # Docker network creation
    "configuring_dns",          # DNS record creation
    "creating_postgres",        # PostgreSQL container
    "cloning_platform_repos",   # Platform addon repos
    "cloning_org_repos",        # Organization addon repos
    "cloning_repo",            # Project primary repository
    "pulling_image",           # Odoo Docker image
    "generating_config",       # odoo.conf generation
    "starting_container",      # Odoo container start
    "installing_dependencies", # apt.txt + requirements.txt
    "initializing_database",   # Database initialization
    "verifying_dns",          # DNS propagation check
    "configuring_traefik",    # Traefik routing setup
    "health_check",           # Post-deployment health check
    "completed"               # Deployment success
]

GET /api/v1/deployments/{deployment_id}/logs?level=error&skip=0&limit=500
Authorization: Bearer <token>

{
  "deployment_id": "abc123",
  "logs": [
    {
      "id": "log_001",
      "level": "info",
      "message": "Connecting to 192.168.1.100...",
      "timestamp": "2025-01-15T10:30:05Z",
      "data": {
        "vm_ip": "192.168.1.100",
        "ssh_port": 22
      }
    },
    {
      "id": "log_002",
      "level": "info",
      "message": "SSH connection established (1.2s)",
      "timestamp": "2025-01-15T10:30:06Z",
      "data": {
        "duration_seconds": 1.2
      }
    }
  ]
}

[
  {"level": "info", "message": "Initializing deployment..."},
  {"level": "info", "message": "Connecting to 192.168.1.100..."},
  {"level": "info", "message": "SSH connection established (1.2s)"},
  {"level": "info", "message": "Creating network paasportal_net_abc123..."},
  {"level": "info", "message": "Network created (0.3s)"},
  {"level": "info", "message": "Configuring DNS record (early for propagation)..."},
  {"level": "info", "message": "DNS record created: env1.apps.oec.sh -> 192.168.1.100 (0.8s)"},
  {"level": "info", "message": "Creating PostgreSQL container abc123_db..."},
  {"level": "info", "message": "PostgreSQL container running (3.2s)"},
  {"level": "info", "message": "Cloning 2 platform addon repositories..."},
  {"level": "info", "message": "[1/2] Cloning platform-addons (17.0)..."},
  {"level": "info", "message": "[1/2] platform-addons ready (2.1s)"},
  {"level": "info", "message": "Pulling Odoo 17.0 image..."},
  {"level": "info", "message": "Image ready (8.3s)"},
  {"level": "info", "message": "Starting Odoo container abc123_odoo..."},
  {"level": "info", "message": "Container started: 9f8e7d6c5b4a (2.7s)"},
  {"level": "info", "message": "Initializing Odoo database..."},
  {"level": "info", "message": "Database initialization complete (45.2s)"},
  {"level": "info", "message": "Performing health check..."},
  {"level": "info", "message": "Health check passed! (3.1s)"},
  {"level": "info", "message": "Deployment completed! Total: 68.9s (1.1 min)"}
]

[
  {"level": "info", "message": "Initializing deployment..."},
  {"level": "info", "message": "Connecting to 192.168.1.100..."},
  {"level": "error", "message": "SSH connection timeout after 30 seconds"},
  {"level": "error", "message": "Deployment failed: Failed to connect to server via SSH"}
]

// Frontend: Subscribe to deployment logs
const eventSource = new EventSource(
  `/api/v1/events?organizationId=${orgId}`
);
 
eventSource.addEventListener('deployment.log', (event) => {
  const log = JSON.parse(event.data);
  console.log(`[${log.level}] ${log.message}`);
});

{
  "event": "deployment.log",
  "data": {
    "deployment_id": "abc123",
    "level": "info",
    "message": "Container started: 9f8e7d6c5b4a (2.7s)",
    "step": "starting_container",
    "timestamp": "2025-01-15T10:35:22Z"
  }
}

Portal Admin (55+ permissions)
  └─ Organization Owner (40+ permissions)
      └─ Organization Admin (30+ permissions)
          └─ Project Admin (20+ permissions)
              └─ Project Member (10+ permissions)

# From routes/deployments.py - Line 66
@router.post("", response_model=DeploymentResponse)
async def create_deployment(...):
    # Check permission
    has_permission = await check_permission(
        db=db,
        user=current_user,
        permission_code="project.environments.deploy",
        organization_id=project.organization_id,
        project_id=project.id,
    )
 
    if not has_permission:
        raise HTTPException(403, "You don't have permission to deploy.")

# Future feature
if environment.type == "production":
    # Require special permission for production deploy
    has_prod_permission = await check_permission(
        db, user,
        "project.production.deploy",
        organization_id, project_id
    )
 
    if not has_prod_permission:
        raise HTTPException(403, "Production deployment requires special permission")

{
  "project_id": "proj_abc123",
  "environment_id": "env_xyz789",
  "git_branch": "main",
  "git_commit": "a1b2c3d4e5f6"
}

{
  "id": "deploy_001",
  "project_id": "proj_abc123",
  "environment_id": "env_xyz789",
  "version": 1,
  "status": "pending",
  "trigger": "manual",
  "triggered_by": "user_123",
  "git_branch": "main",
  "git_commit": "a1b2c3d4e5f6",
  "created_at": "2025-01-15T10:30:00Z"
}

[
  {
    "id": "deploy_001",
    "project_id": "proj_abc123",
    "environment_id": "env_xyz789",
    "version": 5,
    "status": "success",
    "trigger": "manual",
    "git_commit": "a1b2c3d",
    "git_message": "Fix authentication bug",
    "started_at": "2025-01-15T10:30:00Z",
    "completed_at": "2025-01-15T10:32:15Z",
    "duration_seconds": 135.2
  }
]

{
  "id": "deploy_001",
  "project_id": "proj_abc123",
  "environment_id": "env_xyz789",
  "vm_id": "vm_001",
  "version": 5,
  "status": "success",
  "trigger": "manual",
  "triggered_by": "user_123",
  "git_commit": "a1b2c3d4e5f6",
  "git_branch": "main",
  "git_message": "Fix authentication bug",
  "started_at": "2025-01-15T10:30:00Z",
  "completed_at": "2025-01-15T10:32:15Z",
  "duration_seconds": 135.2,
  "container_id": "9f8e7d6c5b4a",
  "image_tag": "odoo:17.0",
  "extra_data": {
    "git": {
      "committer_name": "Jane Smith",
      "committer_email": "jane@example.com",
      "commit_date": "2025-01-15T09:00:00Z"
    }
  }
}

{
  "deployment_id": "deploy_001",
  "logs": [
    {
      "id": "log_001",
      "level": "info",
      "message": "Connecting to 192.168.1.100...",
      "timestamp": "2025-01-15T10:30:05Z",
      "data": {"vm_ip": "192.168.1.100"}
    }
  ]
}

{
  "id": "deploy_new",
  "project_id": "proj_abc123",
  "version": 6,
  "status": "pending",
  "trigger": "manual",
  "git_branch": "main",
  "git_commit": "a1b2c3d",
  "extra_data": {
    "retry_of": "deploy_001"
  }
}

{
  "id": "deploy_rollback",
  "project_id": "proj_abc123",
  "version": 7,
  "status": "pending",
  "trigger": "rollback",
  "git_branch": "main",
  "git_commit": "previous_commit",
  "rollback_from_id": "deploy_005",
  "extra_data": {
    "rollback_to": "deploy_001"
  }
}

{
  "message": "Deployment cancelled"
}

{
  "message": "Environment destroyed successfully",
  "environment_id": "env_xyz789",
  "deleted_containers": true,
  "deleted_database": true,
  "deleted_data": false
}

{
  "deployment_id": "deploy_001",
  "status": "deploying",
  "progress_percent": 65,
  "steps": [
    {
      "id": "initializing",
      "name": "Initializing",
      "description": "Preparing deployment configuration",
      "status": "completed",
      "logs": [
        {"message": "Initializing deployment...", "timestamp": "2025-01-15T10:30:00Z"}
      ]
    },
    {
      "id": "connecting",
      "name": "Connecting",
      "description": "Connecting to server via SSH",
      "status": "completed",
      "logs": [
        {"message": "SSH connection established (1.2s)", "timestamp": "2025-01-15T10:30:01Z"}
      ]
    },
    {
      "id": "pulling_image",
      "name": "Pulling Image",
      "description": "Downloading Odoo Docker image",
      "status": "running",
      "logs": []
    },
    {
      "id": "starting_container",
      "name": "Starting Container",
      "status": "pending"
    }
  ],
  "current_step": "pulling_image",
  "started_at": "2025-01-15T10:30:00Z"
}

# Deployment Runbook: [Feature Name]
 
## Pre-Deployment
- [ ] Code review completed
- [ ] Tests passing in CI/CD
- [ ] Database migrations reviewed
- [ ] Backup created (ID: _________)
- [ ] Staging deployment successful
- [ ] Rollback procedure documented
 
## Deployment Steps
1. Deploy to production via dashboard
2. Monitor deployment logs for errors
3. Verify health checks pass
4. Run smoke tests
5. Monitor error rates for 15 minutes
 
## Rollback Plan
**If deployment fails**:
1. Cancel deployment if in progress
2. Check error logs: /api/v1/deployments/{id}/logs
3. Rollback to deployment ID: _________
4. If rollback fails, restore backup: _________
 
## Breaking Changes
- Database migration: Adds `new_column` (compatible with v1)
- API endpoint changed: `/v1/old` → `/v2/new` (v1 still supported)
 
## Success Criteria
- [ ] All health checks pass
- [ ] Error rate < 0.1%
- [ ] Response time < 500ms p95
- [ ] No user-reported issues in first 30 min

# Check deployment logs
GET /api/v1/deployments/{id}/logs?level=error
 
# Check ARQ worker status
# (Admin only - via SSH to backend server)
docker logs paasportal_worker

# Get detailed error message
GET /api/v1/deployments/{id}
 
# Common error patterns
"SSH connection timeout"          → Server unreachable
"Git clone failed"               → Invalid credentials or repo URL
"Docker pull failed"             → Registry authentication issue
"PostgreSQL connection failed"   → Database container not starting

# Check VM is reachable
ping {vm_ip}
 
# Check SSH port open
nc -zv {vm_ip} 22
 
# Update VM SSH credentials if changed
PATCH /api/v1/vms/{vm_id}

# Verify repository URL
curl -I {git_repo_url}
 
# Check git credentials
# - For GitHub: OAuth token in user profile
# - For private repos: Ensure git connection configured
GET /api/v1/organizations/{org_id}/git-connections

# Check Docker registry credentials
# - For custom registries: Update OdooVersion config
GET /api/v1/admin/odoo-versions/{version_id}
 
# Test pull manually on server
docker pull odoo:17.0

# Check if target deployment is too old
GET /api/v1/deployments/{target_id}
 
# Compare database schemas
# (Manual - requires database access)
psql -U postgres -d {db_name} -c "\d"

# Check deployment status
GET /api/v1/deployments/{id}
 
# Check SSE connection
# (Frontend - browser console)
EventSource readyState: 1 (connected)

# Check environment is_active status
GET /api/v1/environments/{env_id}
 
# Check quota usage
GET /api/v1/organizations/{org_id}/quota

# Manually set is_active to false
# (Admin only - direct database update)
UPDATE project_environments
SET is_active = false
WHERE id = '{env_id}';
 
# Quota will recalculate on next check