Run Weekend Midnight Maintenance Tasks | CronBase

#!/usr/bin/env bash
# Cron execution: 0 0 * * 6,0 (Midnight on Saturday and Sunday)
set -euo pipefail
LOCKFILE="/var/lock/weekend_maintenance.lock"
exec 9>"$LOCKFILE"
if ! flock -n 9; then
    echo "Error: Another instance of the weekend maintenance job is already running." >&2
    exit 1
fi
echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Starting weekend maintenance..."
if ! tar -czf /backup/db_weekend_$(date +%F).tar.gz /var/lib/mysql; then
    echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Backup failed!" >&2
    exit 1
fi
echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Weekend maintenance completed successfully."

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

// Schedule task for midnight on Saturday (6) and Sunday (0)
cron.schedule('0 0 * * 6,0', () => {
    console.log(`[${new Date().toISOString()}] Initiating weekend database cleanup...`);
    exec('npm run db:cleanup', (error, stdout, stderr) => {
        if (error) {
            console.error(`[ERROR] Cleanup failed: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`[WARN] Cleanup stderr: ${stderr}`);
        }
        console.log(`[SUCCESS] Cleanup output: ${stdout}`);
    });
}, {
    scheduled: true,
    timezone: "UTC"
});

import logging
from datetime import datetime
from apscheduler.schedulers.blocking import BlockingScheduler

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

def execute_weekend_task():
    logger.info("Starting weekend maintenance job...")
    try:
        # Simulated maintenance task
        logger.info("Database optimization completed successfully.")
    except Exception as e:
        logger.error(f"Weekend maintenance job failed: {str(e)}")

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 0 0 * * 6,0 translates to day_of_week='sat,sun' at hour=0, minute=0
    scheduler.add_job(execute_weekend_task, 'cron', day_of_week='sat,sun', hour=0, minute=0, timezone='UTC')
    logger.info("Scheduler started. Waiting for Saturday/Sunday midnight...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped.")

package main

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

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

func main() {
	logger := log.New(os.Stdout, "[WeekendCron] ", log.LstdFlags|log.Lshortfile)
	c := cron.New(cron.WithLocation(time.UTC))

	_, err := c.AddFunc("0 0 * * 6,0", func() {
		logger.Println("Starting scheduled weekend maintenance...")
		err := runMaintenance()
		if err != nil {
			logger.Printf("ERROR: Maintenance task failed: %v", err)
			return
		}
		logger.Println("Maintenance task completed successfully.")
	})

	if err != nil {
		logger.Fatalf("Failed to schedule cron job: %v", err)
	}

	c.Start()
	logger.Println("Cron scheduler started...")

	sig := make(chan os.Signal, 1)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
	<-sig

	logger.Println("Stopping scheduler...")
	c.Stop()
}

func runMaintenance() error {
	// Simulate work
	time.Sleep(2 * time.Second)
	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 WeekendMaintenanceScheduler {

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

    // Spring cron format: second, minute, hour, day of month, month, day of week
    @Scheduled(cron = "0 0 0 * * SAT,SUN", zone = "UTC")
    public void runWeekendMaintenance() {
        logger.info("Initiating scheduled weekend maintenance job...");
        try {
            performMaintenance();
            logger.info("Weekend maintenance completed successfully.");
        } catch (Exception e) {
            logger.error("Error occurred during weekend maintenance: ", e);
        }
    }

    private void performMaintenance() throws Exception {
        // Logic for heavy operations (e.g., clearing caches, compressing tables)
        Thread.sleep(5000);
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekend-maintenance-job
  namespace: default
spec:
  schedule: "0 0 * * 6,0"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: maintenance-worker
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - |
              echo "Starting weekend PG database vacuum..."
              vacuumdb -U postgres -h db-service -a -v || exit 1
              echo "Database vacuum completed successfully."
          restartPolicy: OnFailure