Backup Creation and Scheduling

curl -X POST https://oec.sh/api/v1/backups/environments/{env-id}/backups \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "backup_type": "manual",
    "include_filestore": true,
    "retention_type": "daily",
    "storage_config_id": "uuid-of-storage-config"
  }'

interface BackupCreate {
  backup_type?: "manual" | "scheduled" | "pre_restore" | "pre_upgrade" | "pre_destroy";
  storage_config_id?: string; // UUID (uses org default if null)
  include_filestore?: boolean; // Default: true
  retention_type?: "daily" | "weekly" | "monthly" | "yearly" | "permanent"; // Auto-determined if null
}

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "environment_id": "660e8400-e29b-41d4-a716-446655440000",
  "status": "pending",
  "backup_type": "manual",
  "database_size": 0,
  "filestore_size": 0,
  "total_size": 0,
  "retention_type": "daily",
  "created_at": "2024-12-11T10:30:00Z",
  "task_id": "770e8400-e29b-41d4-a716-446655440000"
}

┌─────────────────────────────────────────────────────┐
│ ARQ Worker: execute_backup()                        │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ 1. Update status to IN_PROGRESS                     │
│ 2. Connect to VM via SSH                            │
│ 3. Create environment snapshot (metadata JSON)      │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ Database Backup (pg_dump)                           │
│ - Container: {env_id}_db                           │
│ - Format: PostgreSQL custom format (-Fc)            │
│ - Compression: Level 9 (-Z9)                        │
│ - Output: /tmp/backup_{uuid}.dump                  │
│ - Checksum: SHA-256                                 │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ Filestore Backup (tar.gz)                           │
│ - Container: {env_id}_odoo                          │
│ - Path: /var/lib/odoo/filestore/{db_name}          │
│ - Command: tar -czf                                 │
│ - Output: /tmp/filestore_{uuid}.tar.gz              │
│ - Checksum: SHA-256                                 │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ Download Files via SFTP                             │
│ - Remote → Local: PaaSPortal backend                │
│ - Verify checksums match                            │
│ - Save to temp directory                            │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ Create Backup ZIP Package                           │
│ - File: {backup_id}.zip                            │
│ - Contents:                                         │
│   • dump.sql (database)                             │
│   • filestore.tar.gz (files)                        │
│   • manifest.json (metadata)                        │
│ - Compression: ZIP_DEFLATED                         │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ Upload to Cloud Storage                             │
│ - Status: UPLOADING                                 │
│ - Key: organizations/{org}/projects/{proj}/      │
│        environments/{env}/{backup_id}.zip          │
│ - Provider: S3/R2/B2/MinIO/FTP/SFTP                 │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ Finalization                                        │
│ - Status: COMPLETED                                 │
│ - Calculate expiration date                         │
│ - Update storage usage metrics                      │
│ - Cleanup temp files                                │
│ - Send notification (if enabled)                    │
└─────────────────────────────────────────────────────┘

# Executed inside postgres container
docker exec {env_id}_db \
  pg_dump -U odoo -Fc -Z9 {database_name} \
  > /tmp/backup_{uuid}.dump

# Executed inside odoo container
docker exec {env_id}_odoo \
  tar -czf - \
  -C /var/lib/odoo/filestore {db_name} \
  > /tmp/filestore_{uuid}.tar.gz

/var/lib/odoo/filestore/
└── {database_name}/
    ├── 00/
    ├── 01/
    ├── ...
    └── ff/

{
  "version": "1.0",
  "backup_id": "550e8400-e29b-41d4-a716-446655440000",
  "environment_id": "660e8400-e29b-41d4-a716-446655440000",
  "backup_type": "manual",
  "created_at": "2024-12-11T10:30:00Z",
 
  "database": {
    "name": "prod_db_main",
    "key": "organizations/.../550e8400.zip",
    "size": 52428800,
    "checksum": "a1b2c3d4e5f6...",
    "format": "pg_dump_custom"
  },
 
  "filestore": {
    "key": null,
    "size": 104857600,
    "checksum": "f6e5d4c3b2a1...",
    "format": "tar.gz"
  },
 
  "environment_snapshot": {
    "environment": {
      "id": "660e8400-e29b-41d4-a716-446655440000",
      "name": "Production",
      "type": "production",
      "status": "running",
      "container_name": "660e8400_odoo",
      "db_name": "prod_db_main",
      "domain": "prod.example.com"
    },
    "project": {
      "id": "770e8400-e29b-41d4-a716-446655440000",
      "name": "E-commerce Platform",
      "slug": "ecommerce-platform",
      "odoo_version": "18.0"
    },
    "vm": {
      "id": "880e8400-e29b-41d4-a716-446655440000",
      "name": "server-1",
      "ip_address": "165.22.65.97"
    },
    "timestamp": "2024-12-11T10:30:00Z"
  },
 
  "retention": {
    "type": "daily",
    "expires_at": "2024-12-18T10:30:00Z"
  }
}

curl -X POST https://oec.sh/api/v1/backups/environments/{env-id}/policy \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "is_enabled": true,
    "schedule_cron": "0 2 * * *",
    "timezone": "UTC",
    "daily_retention": 7,
    "weekly_retention": 4,
    "monthly_retention": 12,
    "yearly_retention": 2,
    "weekly_backup_day": 6,
    "storage_config_id": "uuid-of-storage",
    "notify_on_success": false,
    "notify_on_failure": true
  }'

interface BackupPolicyCreate {
  is_enabled: boolean;          // Enable/disable automated backups
  schedule_cron: string;         // Cron expression (5 parts)
  timezone: string;              // Timezone for cron (default: "UTC")
 
  // GFS Retention Settings
  daily_retention: number;       // Days to keep daily backups (0-365)
  weekly_retention: number;      // Weeks to keep weekly backups (0-52)
  monthly_retention: number;     // Months to keep monthly backups (0-60)
  yearly_retention: number;      // Years to keep yearly backups (0-10)
  weekly_backup_day: number;     // Day for weekly (0=Mon, 6=Sun)
 
  // Storage
  storage_config_id?: string;    // Default storage (optional)
 
  // Notifications
  notify_on_success: boolean;    // Email on successful backup
  notify_on_failure: boolean;    // Email on failed backup
}

┌───────────── minute (0 - 59)
│ ┌───────────── hour (0 - 23)
│ │ ┌───────────── day of month (1 - 31)
│ │ │ ┌───────────── month (1 - 12)
│ │ │ │ ┌───────────── day of week (0 - 6, 0=Monday)
│ │ │ │ │
* * * * *

┌─────────────────────────────────────────────────────┐
│ Cron Job: execute_scheduled_backups()               │
│ Frequency: Every hour (at :00)                      │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ Query all enabled BackupPolicy records              │
│ WHERE is_enabled = true                             │
│   AND next_backup_at <= NOW()                       │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ For each policy:                                    │
│ 1. Create scheduled backup                          │
│ 2. Update last_backup_at = NOW()                    │
│ 3. Calculate next_backup_at using croniter          │
│ 4. Update last_backup_status                        │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ Send notifications (if configured)                  │
│ - Success: notify_on_success = true                 │
│ - Failure: notify_on_failure = true                 │
└─────────────────────────────────────────────────────┘

# Run at the start of every hour
cron(
    execute_scheduled_backups,
    minute=0,
)

from croniter import croniter
from datetime import datetime, UTC
 
now = datetime.now(UTC)
cron = croniter(policy.schedule_cron, now)
next_backup_at = cron.get_next(datetime)

# From backend/services/backup_service.py
def _determine_retention_type(self, environment_id: UUID) -> RetentionType:
    now = datetime.now(UTC)
 
    # First day of year → YEARLY
    if now.month == 1 and now.day == 1:
        return RetentionType.YEARLY
 
    # First day of month → MONTHLY
    if now.day == 1:
        return RetentionType.MONTHLY
 
    # Sunday (weekday 6) → WEEKLY
    if now.weekday() == 6:
        return RetentionType.WEEKLY
 
    # All other days → DAILY
    return RetentionType.DAILY

# From BackupPolicy defaults
daily_retention = 7      # Keep 7 daily backups
weekly_retention = 4     # Keep 4 weekly backups
monthly_retention = 12   # Keep 12 monthly backups
yearly_retention = 2     # Keep 2 yearly backups

# From backend/tasks/worker.py
cron(
    execute_retention_cleanup,
    hour=3,
    minute=0,
)

┌─────────────────────────────────────────────────────┐
│ 1. Mark Expired Backups                             │
│    - Query: WHERE expires_at < NOW()                │
│    - Action: status = EXPIRED                       │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ 2. Delete Storage Objects                           │
│    - Find: status IN (EXPIRED, DELETED)             │
│    - Delete from cloud storage                      │
│    - Update storage_config usage metrics            │
│    - Clear storage keys from backup record          │
└─────────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────────┐
│ 3. Promote Eligible Backups                         │
│    - Check each enabled policy                      │
│    - Promote daily → weekly                         │
│    - Promote weekly → monthly                       │
│    - Promote monthly → yearly                       │
│    - Update retention_type and expires_at           │
└─────────────────────────────────────────────────────┘

Day 1 (Monday):
  CREATE: Backup A (DAILY, expires in 7 days)

Day 7 (Sunday):
  CREATE: Backup B (WEEKLY, expires in 4 weeks)
  EXPIRE: Backup A (past 7 days)

Day 30 (First Sunday of month):
  CREATE: Backup C (WEEKLY, expires in 4 weeks)
  PROMOTE: Backup B → MONTHLY (new expiration: 12 months)

Day 365 (January 1):
  CREATE: Backup D (YEARLY, expires in 2 years)
  PROMOTE: Oldest MONTHLY → YEARLY

Result after 1 year:
  - 7 DAILY backups (last 7 days)
  - 4 WEEKLY backups (last 4 weeks)
  - 12 MONTHLY backups (last 12 months)
  - 1 YEARLY backup (start of year)

-- From backend/models/backup.py
CREATE TABLE backups (
    id UUID PRIMARY KEY,
    environment_id UUID NOT NULL REFERENCES project_environments(id),
    storage_config_id UUID REFERENCES storage_configs(id),
    task_id UUID REFERENCES tasks(id),
 
    -- Status tracking
    status VARCHAR NOT NULL,  -- pending, in_progress, uploading, completed, failed, expired, deleted
    backup_type VARCHAR NOT NULL,  -- manual, scheduled, pre_restore, pre_upgrade, pre_destroy
 
    -- Storage paths
    database_key VARCHAR(500),    -- S3 key for ZIP file
    filestore_key VARCHAR(500),   -- NULL (included in ZIP)
    manifest_key VARCHAR(500),    -- NULL (included in ZIP)
 
    -- Sizes (bytes)
    database_size BIGINT DEFAULT 0,
    filestore_size BIGINT DEFAULT 0,
    total_size BIGINT DEFAULT 0,
    compressed_size BIGINT DEFAULT 0,
 
    -- Timing
    started_at TIMESTAMP WITH TIME ZONE,
    completed_at TIMESTAMP WITH TIME ZONE,
    duration_seconds INTEGER,
 
    -- Retention (GFS)
    retention_type VARCHAR,  -- daily, weekly, monthly, yearly, permanent
    expires_at TIMESTAMP WITH TIME ZONE,
 
    -- Verification
    is_verified BOOLEAN DEFAULT FALSE,
    verified_at TIMESTAMP WITH TIME ZONE,
    verification_error TEXT,
 
    -- Integrity checksums
    database_checksum VARCHAR(64),  -- SHA-256
    filestore_checksum VARCHAR(64),
 
    -- Error tracking
    error_message TEXT,
    error_details JSON,
 
    -- Environment snapshot
    environment_snapshot JSON,
 
    -- Audit fields
    create_date TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
    write_date TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
    created_by UUID,
    write_by UUID
);
 
-- Indexes for performance
CREATE INDEX idx_backups_environment ON backups(environment_id);
CREATE INDEX idx_backups_status ON backups(status);
CREATE INDEX idx_backups_expires_at ON backups(expires_at);

# From backup_service.py
storage_config.total_size_bytes += backup.compressed_size
storage_config.object_count += 1
storage_config.last_used_at = datetime.now(UTC)

{
  "project": {
    "odoo_version": "18.0"
  }
}

created_by UUID REFERENCES users(id)

organizations/{org_id}/
  projects/{project_id}/
    environments/{env_id}/
      {backup_id}.zip

organizations/550e8400-e29b-41d4-a716-446655440000/
  projects/660e8400-e29b-41d4-a716-446655440000/
    environments/770e8400-e29b-41d4-a716-446655440000/
      880e8400-e29b-41d4-a716-446655440000.zip

# From backup_service.py
def _calculate_file_checksum(self, file_path: Path) -> str:
    sha256 = hashlib.sha256()
    with open(file_path, "rb") as f:
        for chunk in iter(lambda: f.read(8192), b""):
            sha256.update(chunk)
    return sha256.hexdigest()

# Remote checksum (on VM)
exit_code, stdout, _ = ssh.execute_command(f"sha256sum {remote_temp}")
remote_checksum = stdout.split()[0]
 
# Local checksum (on PaaSPortal backend)
local_checksum = self._calculate_file_checksum(local_path)
 
# Compare
if remote_checksum != local_checksum:
    raise BackupError("Checksum mismatch")

class Backup:
    is_verified: bool = False
    verified_at: datetime | None
    verification_error: str | None
 
    database_checksum: str  # SHA-256
    filestore_checksum: str  # SHA-256

SELECT
    SUM(compressed_size) as total_backup_storage
FROM backups
WHERE environment_id IN (
    SELECT id FROM project_environments
    WHERE project_id IN (
        SELECT id FROM projects
        WHERE organization_id = :org_id
    )
)
AND status NOT IN ('EXPIRED', 'DELETED');

GET /api/v1/organizations/{org-id}/usage

┌──────────────────┐
│   API Request    │
│ POST /backups    │
└────────┬─────────┘
         │
         ↓
┌────────────────────────────────────────┐
│ 1. Create Task (status: PENDING)       │
│ 2. Create Backup (status: PENDING)     │
│ 3. Enqueue to ARQ                      │
│ 4. Return job_id to client             │
└────────┬───────────────────────────────┘
         │
         ↓
┌────────────────────────────────────────┐
│         Redis Queue                    │
│  queue_name: "paasportal:queue"        │
└────────┬───────────────────────────────┘
         │
         ↓
┌────────────────────────────────────────┐
│      ARQ Worker Pool                   │
│  max_jobs: 10 (configurable)           │
│  job_timeout: 3600s (1 hour)           │
└────────┬───────────────────────────────┘
         │
         ↓
┌────────────────────────────────────────┐
│ execute_backup() task function         │
│ - Updates task status via SSE          │
│ - Calls BackupService.execute_backup() │
│ - Sends completion notification        │
└────────────────────────────────────────┘

# From backend/tasks/backup_tasks.py
 
async def execute_backup(
    ctx: dict,
    task_id: str,
    environment_id: str,
    backup_type: str = "manual",
    storage_config_id: str | None = None,
    include_filestore: bool = True,
    user_id: str | None = None,
    backup_id: str | None = None,
) -> dict[str, Any]:
    # 1. Load task and backup records
    task = await db.get(Task, UUID(task_id))
    backup = await db.get(Backup, UUID(backup_id))
 
    # 2. Update task status
    task.status = TaskStatus.RUNNING
    task.started_at = datetime.now(UTC)
    await broadcast_task_status(task, previous_status)
 
    # 3. Execute backup via service
    backup = await service.execute_backup(
        backup=backup,
        include_filestore=include_filestore,
    )
 
    # 4. Mark task as completed
    task.status = TaskStatus.COMPLETED
    task.result = {"backup_id": str(backup.id)}
    task.completed_at = datetime.now(UTC)
 
    # 5. Send notification
    await _send_backup_notification(db, task, env_name, success=True)
 
    return {"success": True, "backup_id": str(backup.id)}

# From backend/tasks/worker.py (WorkerSettings)
max_tries = 3  # Retry failed jobs up to 3 times

GET /api/v1/tasks/{task-id}

const eventSource = new EventSource('/api/v1/events/stream');
 
eventSource.addEventListener('task.status', (event) => {
  const data = JSON.parse(event.data);
  console.log(`Task ${data.task_id}: ${data.status}`);
});

cron(
    execute_scheduled_backups,
    minute=0,
)

async def execute_scheduled_backups(ctx: dict) -> dict[str, Any]:
    now = datetime.now(UTC)
 
    # Find policies due for backup
    result = await db.execute(
        select(BackupPolicy).where(
            BackupPolicy.is_enabled == True,
            BackupPolicy.next_backup_at <= now,
        )
    )
    policies = list(result.scalars().all())
 
    for policy in policies:
        # Create scheduled backup
        backup = await service.create_backup(
            environment_id=policy.environment_id,
            backup_type=BackupType.SCHEDULED,
            storage_config_id=policy.storage_config_id,
            include_filestore=True,
        )
 
        # Update policy
        policy.last_backup_at = now
        policy.last_backup_status = backup.status.value
        policy.next_backup_at = _calculate_next_backup(policy)
 
    return &#123;"triggered": triggered_count, "errors": errors&#125;

cron(
    execute_retention_cleanup,
    hour=3,
    minute=0,
)

{
  "expired": 12,
  "deleted_storage": 11,
  "promoted": 3,
  "errors": []
}

POST /api/v1/backups/environments/{environment_id}/backups

Authorization: Bearer {token}
Content-Type: application/json

{
  "backup_type": "manual",
  "storage_config_id": "550e8400-e29b-41d4-a716-446655440000",
  "include_filestore": true,
  "retention_type": "daily"
}

{
  "id": "660e8400-e29b-41d4-a716-446655440000",
  "environment_id": "770e8400-e29b-41d4-a716-446655440000",
  "storage_config_id": "550e8400-e29b-41d4-a716-446655440000",
  "task_id": "880e8400-e29b-41d4-a716-446655440000",
  "status": "pending",
  "backup_type": "manual",
  "database_size": 0,
  "filestore_size": 0,
  "total_size": 0,
  "compressed_size": 0,
  "retention_type": "daily",
  "expires_at": null,
  "is_verified": false,
  "created_at": "2024-12-11T10:30:00Z"
}

GET /api/v1/backups/environments/{environment_id}/backups?status=completed&page=1&page_size=20

{
  "items": [
    {
      "id": "660e8400-e29b-41d4-a716-446655440000",
      "environment_id": "770e8400-e29b-41d4-a716-446655440000",
      "status": "completed",
      "backup_type": "manual",
      "database_size": 52428800,
      "filestore_size": 104857600,
      "total_size": 157286400,
      "compressed_size": 147286400,
      "started_at": "2024-12-11T10:30:00Z",
      "completed_at": "2024-12-11T10:35:23Z",
      "duration_seconds": 323,
      "retention_type": "daily",
      "expires_at": "2024-12-18T10:30:00Z",
      "is_verified": true,
      "created_at": "2024-12-11T10:30:00Z"
    }
  ],
  "total": 45,
  "page": 1,
  "page_size": 20,
  "pages": 3
}

GET /api/v1/backups/{backup_id}

{
  "id": "660e8400-e29b-41d4-a716-446655440000",
  "environment_id": "770e8400-e29b-41d4-a716-446655440000",
  "storage_config_id": "550e8400-e29b-41d4-a716-446655440000",
  "task_id": "880e8400-e29b-41d4-a716-446655440000",
  "status": "completed",
  "backup_type": "manual",
  "database_size": 52428800,
  "filestore_size": 104857600,
  "total_size": 157286400,
  "compressed_size": 147286400,
  "started_at": "2024-12-11T10:30:00Z",
  "completed_at": "2024-12-11T10:35:23Z",
  "duration_seconds": 323,
  "retention_type": "daily",
  "expires_at": "2024-12-18T10:30:00Z",
  "is_verified": true,
  "verified_at": "2024-12-11T10:35:30Z",
  "database_checksum": "a1b2c3d4e5f6...",
  "filestore_checksum": "f6e5d4c3b2a1...",
  "created_at": "2024-12-11T10:30:00Z"
}

DELETE /api/v1/backups/{backup_id}

GET /api/v1/backups/{backup_id}/download?expires_in=3600

{
  "backup_id": "660e8400-e29b-41d4-a716-446655440000",
  "database_url": "https://s3.amazonaws.com/bucket/path/backup.zip?X-Amz-Signature=...",
  "filestore_url": null,
  "manifest_url": null,
  "expires_in": 3600,
  "expires_at": "2024-12-11T11:30:00Z"
}

POST /api/v1/backups/environments/{environment_id}/policy

{
  "is_enabled": true,
  "schedule_cron": "0 2 * * *",
  "timezone": "UTC",
  "daily_retention": 7,
  "weekly_retention": 4,
  "monthly_retention": 12,
  "yearly_retention": 2,
  "weekly_backup_day": 6,
  "storage_config_id": "550e8400-e29b-41d4-a716-446655440000",
  "notify_on_success": false,
  "notify_on_failure": true
}

{
  "id": "990e8400-e29b-41d4-a716-446655440000",
  "environment_id": "770e8400-e29b-41d4-a716-446655440000",
  "is_enabled": true,
  "schedule_cron": "0 2 * * *",
  "timezone": "UTC",
  "daily_retention": 7,
  "weekly_retention": 4,
  "monthly_retention": 12,
  "yearly_retention": 2,
  "weekly_backup_day": 6,
  "storage_config_id": "550e8400-e29b-41d4-a716-446655440000",
  "notify_on_success": false,
  "notify_on_failure": true,
  "last_backup_at": null,
  "last_backup_status": null,
  "next_backup_at": "2024-12-12T02:00:00Z",
  "created_at": "2024-12-11T10:30:00Z",
  "updated_at": "2024-12-11T10:30:00Z"
}

PATCH /api/v1/backups/environments/{environment_id}/policy

{
  "is_enabled": false,
  "daily_retention": 14
}

DELETE /api/v1/backups/environments/{environment_id}/policy

GET /api/v1/backups/environments/{environment_id}/summary

{
  "environment_id": "770e8400-e29b-41d4-a716-446655440000",
  "total_backups": 45,
  "completed_backups": 42,
  "failed_backups": 2,
  "total_size_bytes": 6442450944,
  "oldest_backup_at": "2024-11-01T02:00:00Z",
  "newest_backup_at": "2024-12-11T02:00:00Z",
  "last_successful_backup_at": "2024-12-11T02:00:00Z",
  "policy_enabled": true,
  "next_scheduled_backup": "2024-12-12T02:00:00Z"
}

{
  "daily_retention": 14,
  "weekly_retention": 8,
  "monthly_retention": 24,
  "yearly_retention": 5
}

{
  "daily_retention": 3,
  "weekly_retention": 2,
  "monthly_retention": 6,
  "yearly_retention": 1
}

{
  "daily_retention": 7,
  "weekly_retention": 4,
  "monthly_retention": 12,
  "yearly_retention": 7,
  "retention_type": "permanent"  // For yearly backups
}

# 1. Create pre-deployment backup
POST /api/v1/backups/environments/{id}/backups
{"backup_type": "manual", "retention_type": "weekly"}
 
# 2. Wait for completion (monitor via SSE or polling)
 
# 3. Proceed with deployment
POST /api/v1/environments/{id}/deploy

GET /api/v1/organizations/{org-id}/usage

{
  "notify_on_success": true,   // Confirm backups are working
  "notify_on_failure": true
}

{
  "notify_on_success": false,  // Reduce noise
  "notify_on_failure": true    // Only alert on failures
}

docker ps | grep worker

redis-cli -h redis -p 6379
> LLEN paasportal:queue

docker compose restart worker

pg_dump failed: could not connect to database

docker ps | grep {env_id}_db

docker exec {env_id}_db psql -U odoo -d {db_name} -c "SELECT 1"

GET /api/v1/environments/{id}

docker exec {env_id}_odoo ls -la /var/lib/odoo/filestore/{db_name}

docker exec {env_id}_odoo du -sh /var/lib/odoo/filestore/{db_name}

Failed to upload backup: Connection timeout

POST /api/v1/backups/storage-configs/{id}/test

GET /api/v1/backups/storage-configs/{id}

Checksum mismatch: remote=abc123, local=def456

ssh root@{vm_ip} "df -h && iostat"

df -h /tmp

# backend/tasks/worker.py
job_timeout = 7200  # 2 hours

-- Reduce work_mem during dump
SET work_mem = '256MB';

# Modify pg_dump command to use -Z6 instead of -Z9

GET /api/v1/backups/environments/{id}/policy

# Check worker logs
docker logs worker 2>&1 | grep execute_scheduled_backups

from croniter import croniter
croniter.is_valid("0 2 * * *")  # Should return True

# Via ARQ worker console
await execute_scheduled_backups({})

# Review worker logs
docker logs worker 2>&1 | grep execute_retention_cleanup

# Via API or worker console
from services.retention_service import RetentionService
service = RetentionService(db)
summary = await service.run_retention_cleanup()

# Should run daily at 3 AM UTC
cron(execute_retention_cleanup, hour=3, minute=0)