Run Weekly Maintenance at 2 AM Sunday | CronBase

#!/bin/bash
# System backup script scheduled weekly on Sundays at 2:00 AM via crontab
set -euo pipefail

BACKUP_DIR="/var/backups/weekly"
LOG_FILE="/var/log/weekly_backup.log"

echo "[$(date -u)] Starting weekly system backup..." >> "$LOG_FILE"

# Ensure backup directory exists
mkdir -p "$BACKUP_DIR"

# Perform backup with error handling
if tar -czf "$BACKUP_DIR/backup-$(date +%F).tar.gz" /var/www /etc 2>> "$LOG_FILE"; then
    echo "[$(date -u)] Backup completed successfully." >> "$LOG_FILE"
else
    echo "[$(date -u)] ERROR: Backup failed!" >> "$LOG_FILE" >&2
    exit 1
fi

const cron = require('node-cron');
const { exec } = require('child_process');

// Schedule task to run every Sunday at 2:00 AM
cron.schedule('0 2 * * 0', () => {
  console.log('[INFO] Starting weekly database maintenance at:', new Date().toISOString());
  
  exec('/usr/local/bin/db-optimize.sh', (error, stdout, stderr) => {
    if (error) {
      console.error(`[ERROR] Maintenance failed: ${error.message}`);
      return;
    }
    if (stderr) {
      console.warn(`[WARN] Maintenance stderr output: ${stderr}`);
    }
    console.log(`[SUCCESS] Maintenance output: ${stdout}`);
  });
}, {
  scheduled: true,
  timezone: "UTC"
});

import logging
from datetime import datetime
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger

logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')

def run_weekly_cleanup():
    logging.info("Starting weekly data pipeline cleanup process...")
    try:
        # Simulate cleanup logic
        logging.info("Weekly cleanup completed successfully.")
    except Exception as e:
        logging.error(f"Cleanup failed: {str(e)}")

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # Schedule weekly on Sunday at 2:00 AM UTC
    trigger = CronTrigger(day_of_week='sun', hour=2, minute=0, timezone='UTC')
    scheduler.add_job(run_weekly_cleanup, trigger=trigger)
    
    logging.info("Scheduler started. Waiting for Sunday at 2:00 AM UTC...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler stopped manually.")

package main

import (
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/robfig/cron/v3"
)

func main() {
	// Use UTC to avoid DST transition issues
	nyc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Failed to load timezone: %v", err)
	}

	c := cron.New(cron.WithLocation(nyc))

	// Schedule for Sunday at 2:00 AM
	_, err = c.AddFunc("0 2 * * 0", func() {
		log.Println("[INFO] Executing scheduled weekly report generation...")
		err := generateWeeklyReports()
		if err != nil {
			log.Printf("[ERROR] Report generation failed: %v", err)
		} else {
			log.Println("[SUCCESS] Reports generated successfully.")
		}
	})
	if err != nil {
		log.Fatalf("Failed to schedule cron job: %v", err)
	}

	c.Start()
	log.Println("Cron scheduler active. Running weekly at Sunday 2:00 AM UTC.")

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan
	c.Stop()
}

func generateWeeklyReports() error {
	return nil
}

package com.example.scheduler;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class WeeklyMaintenanceScheduler {

    private static final Logger logger = LoggerFactory.getLogger(WeeklyMaintenanceScheduler.class);

    // Runs every Sunday at 2:00 AM (Spring Cron: seconds, minutes, hours, day of month, month, day of week)
    @Scheduled(cron = "0 0 2 * * SUN", zone = "UTC")
    public void executeWeeklyTasks() {
        logger.info("Initiating scheduled weekly maintenance routine...");
        try {
            purgeExpiredSessions();
            logger.info("Weekly maintenance tasks completed successfully.");
        } catch (Exception e) {
            logger.error("Error occurred during weekly maintenance: ", e);
        }
    }

    private void purgeExpiredSessions() {
        // Business logic
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-database-vacuum
  namespace: database
spec:
  # Runs at 2:00 AM every Sunday
  schedule: "0 2 * * 0"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: postgres-vacuum
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "vacuumdb -U postgres -h db-service -a -z"
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: password
          restartPolicy: OnFailure