Weekly Sunday Midnight Cron Schedule | CronBase

#!/usr/bin/env bash
# Weekly maintenance script designed to run via cron: 0 0 * * 0
set -euo pipefail

LOCKFILE="/var/lock/weekly-cleanup.lock"
LOGFILE="/var/log/weekly-cleanup.log"

# Ensure only one instance runs at a time
exec 9>"$LOCKFILE"
if ! flock -n 9; then
    echo "$(date -u) - ERROR: Another instance is already running." >&2
    exit 1
fi

echo "$(date -u) - Starting weekly database maintenance..." >> "$LOGFILE"
# Perform backup; redirect stderr to logfile
if pg_dump -U postgres -h localhost my_db > /backups/db_weekly_$(date +%F).sql 2>> "$LOGFILE"; then
    echo "$(date -u) - Weekly backup completed successfully." >> "$LOGFILE"
else
    echo "$(date -u) - CRITICAL: Weekly backup failed!" >&2
    exit 1
fi

const { CronJob } = require('cron');
const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  transports: [new winston.transports.Console()]
});

// Schedule for 0 0 * * 0 (Every Sunday at midnight UTC)
const job = new CronJob(
  '0 0 * * 0',
  async function() {
    logger.info('Starting weekly data aggregation task...');
    try {
      await performWeeklyAggregation();
      logger.info('Weekly data aggregation completed successfully.');
    } catch (error) {
      logger.error('Failed to execute weekly aggregation job:', error);
    }
  },
  null,
  true,
  'UTC'
);

async function performWeeklyAggregation() {
  // Simulate async processing logic
  return new Promise((resolve) => setTimeout(resolve, 5000));
}

job.start();

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

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

def run_weekly_cleanup():
    logging.info("Initiating weekly log rotation and cache eviction...")
    try:
        # Cleanup execution logic
        logging.info("Weekly cleanup successfully executed.")
    except Exception as e:
        logging.error(f"Weekly cleanup failed: {str(e)}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 0 0 * * 0 translates to day_of_week='sun', hour=0, minute=0
    trigger = CronTrigger(day_of_week='sun', hour=0, minute=0, timezone='UTC')
    scheduler.add_job(run_weekly_cleanup, trigger=trigger, id='weekly_job')
    
    logging.info("Starting scheduler. Job scheduled for every Sunday at 00:00 UTC.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler stopped.")

package main

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

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

func main() {
	logger := log.New(os.Stdout, "[WeeklyJob] ", log.LstdFlags|log.LUTC)
	
	// Create cron scheduler with UTC timezone enforcement
	c := cron.New(cron.WithLocation(time.UTC))

	_, err := c.AddFunc("0 0 * * 0", func() {
		logger.Println("Starting weekly backup and sync routine...")
		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Minute)
		defer cancel()

		if err := executeBackup(ctx); err != nil {
			logger.Printf("CRITICAL: Weekly backup failed: %v\n", err)
		} else {
			logger.Println("Weekly backup completed successfully.")
		}
	})

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

	c.Start()
	logger.Println("Cron runner started. Job scheduled for Sunday midnight UTC.")

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

	logger.Println("Shutting down cron runner...")
	c.Stop()
}

func executeBackup(ctx context.Context) error {
	select {
	case <-time.After(5 * time.Second):
		return nil
	case <-ctx.Done():
		return ctx.Err()
	}
}

package com.example.cron;

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 Cron syntax: second, minute, hour, day-of-month, month, day-of-week
    // Equivalent to standard cron: 0 0 * * 0
    @Scheduled(cron = "0 0 0 * * SUN", zone = "UTC")
    public void executeWeeklyMaintenance() {
        logger.info("Weekly maintenance cycle started at Sunday midnight UTC.");
        try {
            purgeExpiredSessions();
            optimizeDatabaseIndices();
            logger.info("Weekly maintenance cycle completed successfully.");
        } catch (Exception ex) {
            logger.error("CRITICAL: Weekly maintenance failed", ex);
        }
    }

    private void purgeExpiredSessions() {
        logger.info("Purging expired sessions...");
    }

    private void optimizeDatabaseIndices() {
        logger.info("Optimizing database indices...");
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-database-vacuum
  namespace: database
spec:
  schedule: "0 0 * * 0"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  startingDeadlineSeconds: 1800
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: db-vacuum-client
            image: postgres:15-alpine
            command: 
            - /bin/sh
            - -c
            - |
              echo "Starting database vacuuming..."
              vacuumdb -U postgres -h db-service.database.svc.cluster.local -a -v || exit 1
              echo "Vacuuming complete."
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: password
          restartPolicy: OnFailure