Schedule Weekly Sunday Maintenance at 3 AM | CronBase

#!/usr/bin/env bash

# Ensure the script exits on any error
set -euo pipefail

# Log file configuration
LOG_FILE="/var/log/weekly_maintenance.log"

# Main execution function
run_maintenance() {
    echo "[$(date -u)] Starting weekly maintenance task..." >> "$LOG_FILE"
    # Add your production backup or cleanup command here
    # e.g., pg_dumpall -U postgres | gzip > /backups/db_$(date +%F).sql.gz
    echo "[$(date -u)] Maintenance completed successfully." >> "$LOG_FILE"
}

# Execute with error logging
if ! run_maintenance; then
    echo "[$(date -u)] CRITICAL: Weekly maintenance failed!" >&2
    exit 1
fi

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

// Schedule task to run every Sunday at 3:00 AM
cron.schedule('0 3 * * 0', () => {
  console.log(`[${new Date().toISOString()}] Initiating weekly cleanup job...`);
  
  exec('/usr/local/bin/weekly-cleanup.sh', (error, stdout, stderr) => {
    if (error) {
      console.error(`[ERROR] Weekly cleanup failed: ${error.message}`);
      return;
    }
    if (stderr) {
      console.warn(`[WARNING] Standard error output: ${stderr}`);
    }
    console.log(`[SUCCESS] Cleanup output:\n${stdout}`);
  });
}, {
  scheduled: true,
  timezone: "UTC"
});

import logging
from apscheduler.schedulers.blocking import BlockingScheduler

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def execute_weekly_maintenance():
    logger.info("Starting weekly database vacuum and optimization...")
    try:
        # Simulate maintenance work
        # db.vacuum_analyze_all()
        logger.info("Weekly maintenance completed successfully.")
    except Exception as e:
        logger.error(f"Maintenance failed: {str(e)}", exc_info=True)

if __name__ == '__main__':
    scheduler = BlockingScheduler(timezone="UTC")
    # 0 3 * * 0 translates to: minute 0, hour 3, day of week 6 (Sunday in APScheduler standard is 6 or 'sun')
    scheduler.add_job(execute_weekly_maintenance, 'cron', day_of_week='sun', hour=3, minute=0)
    logger.info("Scheduler started. Waiting for Sunday 3:00 AM UTC...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        pass

package main

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

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

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

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

	// Register the job to run at 3:00 AM on Sunday
	_, err = c.AddFunc("0 3 * * 0", func() {
		log.Println("Weekly maintenance job started...")
		// Perform production safety checks and database rotations here
		log.Println("Weekly maintenance job finished successfully.")
	})
	if err != nil {
		log.Fatalf("Error scheduling cron job: %v", err)
	}

	c.Start()
	log.Println("Cron engine initialized. Scheduled for every Sunday at 03:00 UTC.")

	// Keep application running until interrupted
	sig := make(chan os.Signal, 1)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
	<-sig
	c.Stop()
}

package com.example.cron;

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

@Component
public class WeeklyMaintenanceScheduler {
    private static final Logger logger = LoggerFactory.getLogger(WeeklyMaintenanceScheduler.class);

    // Spring's cron syntax uses 6 fields: second, minute, hour, day, month, day-of-week.
    // "0 0 3 * * SUN" targets 3:00:00 AM every Sunday.
    @Scheduled(cron = "0 0 3 * * SUN", zone = "UTC")
    public void runWeeklyMaintenance() {
        logger.info("Initializing scheduled Sunday maintenance tasks...");
        try {
            // Invoke service layer task
            logger.info("Scheduled Sunday maintenance executed successfully.");
        } catch (Exception e) {
            logger.error("Critical failure during weekly maintenance execution: ", e);
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-maintenance-job
  namespace: default
spec:
  schedule: "0 3 * * 0"
  concurrencyPolicy: Forbid
  startingDeadlineSeconds: 1800
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: alpine:latest
            command:
            - /bin/sh
            - -c
            - "echo 'Starting weekly database maintenance'; /usr/local/bin/backup-script.sh"
          restartPolicy: OnFailure