Run Mon Wed Fri Tasks at 10 AM | CronBase

#!/usr/bin/env bash
# Production deployment script to install the cron job safely
set -euo pipefail

CRON_SCHEDULE="0 10 * * 1,3,5"
JOB_COMMAND="/usr/local/bin/run-triweekly-sync.sh >> /var/log/cron_sync.log 2>&1"
CRON_LINE="${CRON_SCHEDULE} ${JOB_COMMAND}"

echo "Installing cron job for Monday, Wednesday, Friday at 10:00 AM..."

# Ensure we do not duplicate the cron job
(crontab -l 2>/dev/null | grep -Fv "${JOB_COMMAND}" ; echo "${CRON_LINE}") | crontab -

echo "Cron job successfully installed and verified."

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

// Schedule task to run at 10:00 AM on Mondays, Wednesdays, and Fridays
const schedule = '0 10 * * 1,3,5';

console.log(`Initializing cron runner with schedule: ${schedule}`);

const task = cron.schedule(schedule, () => {
  const timestamp = new Date().toISOString();
  console.log(`[${timestamp}] Starting scheduled tri-weekly data pipeline...`);
  
  exec('/usr/local/bin/pipeline-trigger.sh', (error, stdout, stderr) => {
    if (error) {
      console.error(`[${timestamp}] Execution Error: ${error.message}`);
      return;
    }
    if (stderr) {
      console.warn(`[${timestamp}] Execution Warning: ${stderr}`);
    }
    console.log(`[${timestamp}] Execution Output: ${stdout}`);
  });
}, {
  scheduled: true,
  timezone: "America/New_York"
});

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

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

def execute_triweekly_job():
    logger.info("Tri-weekly job execution started.")
    try:
        # Place your production logic here
        pass
    except Exception as e:
        logger.error(f"Job execution failed: {str(e)}", exc_info=True)

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    # 1,3,5 corresponds to mon,wed,fri
    scheduler.add_job(
        execute_triweekly_job,
        'cron',
        day_of_week='mon,wed,fri',
        hour=10,
        minute=0,
        timezone='UTC'
    )
    logger.info("Scheduler started for Monday, Wednesday, Friday at 10:00 UTC")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")

package main

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

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

func main() {
	// Use NewWithLocation to explicitly handle timezone considerations
	nyc, err := time.LoadLocation("America/New_York")
	if err != nil {
		log.Fatalf("Failed to load timezone: %v", err)
	}

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

	// Standard cron dialect for Mon, Wed, Fri at 10:00 AM
	_, err = c.AddFunc("0 10 * * 1,3,5", func() {
		fmt.Printf("[%s] Running scheduled tri-weekly sync\n", time.Now().Format(time.RFC3339))
		// Execute production workload here
	})
	if err != nil {
		log.Fatalf("Failed to schedule cron job: %v", err)
	}

	c.Start()
	log.Println("Cron engine started for Mon, Wed, Fri at 10:00 AM EST/EDT")

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

	log.Println("Shutting down cron scheduler...")
	c.Stop()
}

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

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

    // Standard cron pattern: second, minute, hour, day of month, month, day(s) of week
    // Spring's cron format accepts 6 fields. We specify 0 for seconds.
    @Scheduled(cron = "0 0 10 * * MON,WED,FRI", zone = "America/New_York")
    public void executeTask() {
        logger.info("Triggering scheduled tri-weekly sync at: {}", Instant.now());
        try {
            // Production business logic goes here
            runDataPipeline();
        } catch (Exception e) {
            logger.error("Error during scheduled job execution", e);
        }
    }

    private void runDataPipeline() {
        // Actual implementation logic
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: triweekly-data-sync
  namespace: production
spec:
  schedule: "0 10 * * 1,3,5"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: sync-worker
            image: registry.example.com/data-sync:v1.2.0
            imagePullPolicy: IfNotPresent
            resources:
              limits:
                cpu: "1000m"
                memory: "2Gi"
              requests:
                cpu: "500m"
                memory: "1Gi"
          restartPolicy: OnFailure