Backup Management

# From backup.py:113-123
"progress_details": {
    "original_size": job.original_size or 0,
    "compressed_size": job.compressed_size or 0,
    "deduplicated_size": job.deduplicated_size or 0,
    "nfiles": job.nfiles or 0,
    "current_file": job.current_file or "",
    "progress_percent": job.progress_percent or 0,
    "backup_speed": job.backup_speed or 0.0,
    "total_expected_size": job.total_expected_size or 0,
    "estimated_time_remaining": job.estimated_time_remaining or 0
}

GET /api/backup/jobs?limit=200&scheduled_only=false&manual_only=false

# From backup.py:74-133
@router.get("/jobs")
async def get_all_backup_jobs(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
    limit: int = 200,
    scheduled_only: bool = False,
    manual_only: bool = False
):
    query = db.query(BackupJob)
    
    if scheduled_only:
        query = query.filter(BackupJob.scheduled_job_id.isnot(None))
    elif manual_only:
        query = query.filter(BackupJob.scheduled_job_id.is_(None))
    
    jobs = query.order_by(BackupJob.id.desc()).limit(limit).all()

{
  "jobs": [
    {
      "id": 123,
      "repository": "ssh://[email protected]/backups/prod",
      "status": "completed",
      "started_at": "2026-02-28T10:30:00Z",
      "completed_at": "2026-02-28T10:45:30Z",
      "progress": "Backup completed successfully",
      "has_logs": false,
      "scheduled_job_id": null,
      "progress_details": {
        "original_size": 1073741824,
        "compressed_size": 644245094,
        "deduplicated_size": 214748364,
        "nfiles": 2500,
        "progress_percent": 100
      }
    }
  ]
}

POST /api/backup/cancel/{job_id}

# From backup.py:180-226
@router.post("/cancel/{job_id}")
async def cancel_backup(
    job_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    job = db.query(BackupJob).filter(BackupJob.id == job_id).first()
    
    if job.status != "running":
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Can only cancel running jobs"
        )
    
    # Try to terminate the actual process
    process_killed = await backup_service.cancel_backup(job_id)
    
    # Update job status in database
    job.status = "cancelled"
    job.completed_at = datetime.utcnow()
    job.error_message = "Backup cancelled by user"
    db.commit()

{
  "message": "Backup cancelled successfully",
  "process_terminated": true
}

GET /api/backup/logs/{job_id}/stream?offset=0

# From backup.py:332-418
@router.get("/logs/{job_id}/stream")
async def stream_backup_logs(
    job_id: int,
    offset: int = 0,  # Line number to start from
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    job = db.query(BackupJob).filter(BackupJob.id == job_id).first()
    
    # Check if logs point to a file
    if job.logs.startswith("Logs saved to:"):
        log_filename = job.logs.replace("Logs saved to: ", "").strip()
        log_file = Path("/data/logs") / log_filename
        
        log_content = log_file.read_text()
        log_lines = log_content.split('\n')
        
        # Apply offset for streaming
        lines_to_return = log_lines[offset:]

{
  "job_id": 123,
  "status": "running",
  "lines": [
    {"line_number": 1, "content": "Starting backup..."},
    {"line_number": 2, "content": "Processing /var/www"}
  ],
  "total_lines": 150,
  "has_more": true
}

GET /api/backup/logs/{job_id}/download?token=<auth_token>

# From backup.py:228-330
@router.get("/logs/{job_id}/download")
async def download_backup_logs(
    job_id: int,
    token: str = None,
    db: Session = Depends(get_db)
):
    # Only allow download for completed failed/cancelled backups
    if job.status == "running":
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="Cannot download logs for running backup"
        )
    
    # Return file as download
    return FileResponse(
        path=str(log_file),
        filename=f"backup_job_{job_id}_logs.txt",
        media_type="text/plain"
    )

# Repository configuration
{
  "pre_backup_script": "#!/bin/bash\ndocker stop webapp",
  "post_backup_script": "#!/bin/bash\ndocker start webapp",
  "pre_hook_timeout": 300,   // 5 minutes
  "post_hook_timeout": 300,  // 5 minutes
  "continue_on_hook_failure": false
}

# Scheduled job configuration
{
  "run_prune_after": true,
  "run_compact_after": true,
  "prune_keep_daily": 7,
  "prune_keep_weekly": 4,
  "prune_keep_monthly": 6,
  "prune_keep_yearly": 1
}

# From backup.py:159
"maintenance_status": job.maintenance_status

# From backup.py:36-46
repo_record = db.query(Repository).filter(
    Repository.path == backup_request.repository
).first()

backup_job = BackupJob(
    repository=backup_request.repository,
    status="pending",
    source_ssh_connection_id=repo_record.source_ssh_connection_id
)

{
  "status": "failed",
  "error_message": "Lock timeout: another operation is running",
  "logs": "Logs saved to: backup_123_20260228_103000.log"
}