Every Saturday at Noon Cron Schedule | CronBase

#!/usr/bin/env bash
set -euo pipefail

# Define log file and lock file to prevent overlapping executions
LOG_FILE="/var/log/weekly_cleanup.log"
LOCK_FILE="/var/run/weekly_cleanup.lock"

exec 9>"$LOCK_FILE"
if ! flock -n 9; then
    echo "Error: Another instance of the weekly cleanup is already running." >&2
    exit 1
fi

echo "[$(date -u)] Starting weekly maintenance task..." >> "$LOG_FILE"
# Perform the maintenance work (e.g., clearing old temp files, rotating logs)
if /usr/local/bin/perform_maintenance.sh >> "$LOG_FILE" 2>&1; then
    echo "[$(date -u)] Weekly maintenance completed successfully." >> "$LOG_FILE"
else
    echo "[$(date -u)] Error: Weekly maintenance failed!" >> "$LOG_FILE"
    exit 1
fi

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

console.log('Initializing Saturday noon weekly cron scheduler...');

// Schedule task to run every Saturday at 12:00 PM
cron.schedule('0 12 * * 6', () => {
    console.log(`[${new Date().toISOString()}] Starting scheduled weekly database backup...`);
    
    exec('/usr/local/bin/backup_db.sh', (error, stdout, stderr) => {
        if (error) {
            console.error(`[ERROR] Weekly backup failed: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`[WARN] Backup completed with warnings: ${stderr}`);
        }
        console.log(`[SUCCESS] Weekly backup finished: ${stdout.trim()}`);
    });
}, {
    scheduled: true,
    timezone: "UTC"
});

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

# Setup production logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[logging.StreamHandler(sys.stdout)]
)

def run_weekly_data_pipeline():
    logging.info("Starting weekly data pipeline synchronization...")
    try:
        # Simulate business logic execution
        logging.info("Weekly data pipeline synchronized successfully.")
    except Exception as e:
        logging.error(f"Failed to execute weekly data pipeline: {str(e)}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 0 12 * * 6 maps to day_of_week='sat', hour=12, minute=0
    scheduler.add_job(
        run_weekly_data_pipeline,
        'cron',
        day_of_week='sat',
        hour=12,
        minute=0,
        timezone='UTC',
        id='weekly_pipeline_job'
    )
    
    logging.info("Scheduler started. Waiting for Saturday 12:00 PM UTC...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler stopped cleanly.")

package main

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

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

func main() {
	logger := log.New(os.Stdout, "[CRON] ", log.LstdFlags|log.Lshortfile)
	logger.Println("Initializing Saturday noon scheduler...")

	c := cron.New(cron.WithLocation(time.UTC))

	_, err := c.AddFunc("0 12 * * 6", func() {
		logger.Println("Starting weekly audit report generation...")
		err := generateWeeklyAuditReport()
		if err != nil {
			logger.Printf("ERROR: Weekly audit report failed: %v\n", err)
			return
		}
		logger.Println("SUCCESS: Weekly audit report generated successfully.")
	})

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

	c.Start()
	defer c.Stop()

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan
	logger.Println("Shutting down scheduler gracefully...")
}

func generateWeeklyAuditReport() error {
	time.Sleep(2 * time.Second)
	return nil
}

package com.cronbase.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);

    // Spring uses 6 fields: second, minute, hour, day of month, month, day of week.
    @Scheduled(cron = "0 0 12 * * SAT", zone = "UTC")
    public void executeWeeklyMaintenance() {
        logger.info("Starting scheduled Saturday noon maintenance task...");
        try {
            performDatabaseMaintenance();
            logger.info("Weekly maintenance completed successfully.");
        } catch (Exception e) {
            logger.error("Error occurred during weekly maintenance job: ", e);
        }
    }

    private void performDatabaseMaintenance() throws Exception {
        Thread.sleep(5000);
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-database-vacuum
  namespace: production
  labels:
    app: database-maintenance
    tier: cron
spec:
  schedule: "0 12 * * 6"
  timeZone: "Etc/UTC"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: database-maintenance
        spec:
          restartPolicy: OnFailure
          containers:
          - name: vacuum-worker
            image: postgres:15-alpine
            env:
            - name: PGUSER
              value: "postgres"
            - name: PGDATABASE
              value: "production_db"
            - name: PGHOST
              value: "postgres-service.production.svc.cluster.local"
            command:
            - /bin/sh
            - -c
            - |
              echo "Starting database VACUUM ANALYZE..."
              vacuumdb -h "$PGHOST" -U "$PGUSER" -d "$PGDATABASE" -z -v
              echo "Vacuum completed successfully."