Run Weekly Tasks Every Monday at 9 AM | CronBase

#!/usr/bin/env bash
# Production-ready Bash script to install a crontab entry
set -euo pipefail

CRON_SCHEDULE="0 9 * * 1"
JOB_COMMAND="/usr/local/bin/weekly-report-generator.sh >> /var/log/weekly-report.log 2>&1"

echo "Configuring cron job for weekly execution..."
# Check if crontab exists, if not create an empty one
current_cron=$(crontab -l 2>/dev/null || true)

# Avoid duplicate entries
if echo "$current_cron" | grep -Fq "$JOB_COMMAND"; then
    echo "Cron job already exists. Skipping installation."
else
    (echo "$current_cron"; echo "$CRON_SCHEDULE $JOB_COMMAND") | crontab -
    echo "Cron job successfully installed."
fi

// Ensure you have installed node-cron: npm install node-cron
const cron = require('node-cron');
const { exec } = require('child_process');

// Schedule the weekly task for Monday at 9:00 AM
const schedule = '0 9 * * 1';

console.log(`Initializing scheduler with pattern: ${schedule}`);

const task = cron.schedule(schedule, () => {
  const timestamp = new Date().toISOString();
  console.log(`[${timestamp}] Starting weekly reporting job...`);
  
  exec('/usr/local/bin/weekly-report.sh', (error, stdout, stderr) => {
    if (error) {
      console.error(`[${timestamp}] Job execution failed:`, error.message);
      return;
    }
    if (stderr) {
      console.warn(`[${timestamp}] Job stderr output:`, stderr);
    }
    console.log(`[${timestamp}] Job completed successfully. Output:\n`, stdout);
  });
}, {
  scheduled: true,
  timezone: "UTC"
});

# Production-ready weekly scheduler using APScheduler
# Required dependency: pip install apscheduler
import logging
import sys
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',
    handlers=[logging.StreamHandler(sys.stdout)]
)

def run_weekly_job():
    logging.info("Executing weekly maintenance and reporting task...")
    try:
        # Simulate business logic
        logging.info("Weekly task completed successfully.")
    except Exception as e:
        logging.error(f"Failed to execute weekly task: {str(e)}")

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 0 9 * * 1 translates to: day_of_week='mon', hour=9, minute=0
    trigger = CronTrigger(day_of_week='mon', hour=9, minute=0, timezone='UTC')
    
    scheduler.add_job(
        run_weekly_job,
        trigger=trigger,
        id='weekly_maintenance_job',
        replace_existing=True
    )
    
    logging.info("Scheduler started. Running weekly job at 9:00 AM UTC every Monday.")
    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, "[WeeklyScheduler] ", log.LstdFlags|log.Lshortfile)
	logger.Println("Initializing cron runner...")

	// Use UTC timezone for standard, predictable execution times
	c := cron.New(cron.WithLocation(time.UTC))

	// 0 9 * * 1: Every Monday at 09:00
	_, err := c.AddFunc("0 9 * * 1", func() {
		logger.Println("Starting weekly database maintenance and report generation...")
		// Execute production logic here
		logger.Println("Weekly tasks completed successfully.")
	})

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

	c.Start()
	logger.Println("Scheduler running. Waiting for Monday 09:00 UTC...")

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

	logger.Println("Shutting down scheduler...")
	c.Stop()
	logger.Println("Scheduler stopped cleanly.")
}

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 WeeklyTaskScheduler {

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

    /**
     * Executes every Monday at 9:00 AM.
     * Cron format: second, minute, hour, day of month, month, day(s) of week
     * Spring cron uses 6 fields (adding seconds at the start).
     */
    @Scheduled(cron = "0 0 9 * * MON", zone = "UTC")
    public void executeWeeklyJob() {
        logger.info("Weekly maintenance job started at Monday 9:00 AM UTC.");
        try {
            performBusinessLogic();
            logger.info("Weekly maintenance job completed successfully.");
        } catch (Exception e) {
            logger.error("Error occurred during weekly maintenance execution", e);
        }
    }

    private void performBusinessLogic() {
        // Implement database cleanup, report generation, or email dispatch here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-reporting-job
  namespace: default
  labels: 
    app: weekly-reporter
spec:
  schedule: "0 9 * * 1"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  startingDeadlineSeconds: 600
  jobTemplate:
    spec:
      template:
        metadata:
          labels:
            app: weekly-reporter
        spec:
          containers:
          - name: reporter
            image: curlimages/curl:7.85.0
            imagePullPolicy: IfNotPresent
            command:
            - /bin/sh
            - -c
            - |
              echo "Starting weekly report generation..."
              curl -fsS --retry 3 https://api.internal.services/reports/generate-weekly
              echo "Weekly report successfully triggered."
          restartPolicy: OnFailure