Run Morning Jobs Every Weekday at 6 AM | CronBase

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

// Schedule task to run at 6:00 AM, Monday through Friday
cron.schedule('0 6 * * 1-5', () => {
    console.log(`[${new Date().toISOString()}] Starting morning weekday process...`);
    exec('/usr/local/bin/process-data.sh', (error, stdout, stderr) => {
        if (error) {
            console.error(`[ERROR] Task failed: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`[WARN] Task stderr: ${stderr}`);
        }
        console.log(`[SUCCESS] Task output: ${stdout}`);
    });
}, {
    scheduled: true,
    timezone: "UTC"
});

#!/bin/bash
# Morning weekday execution script
set -euo pipefail
LOG_FILE="/var/log/morning_sync.log"

echo "$(date -u) - Starting morning weekday job" >> "$LOG_FILE"

# Execute core system logic
if /usr/local/bin/run-warmups.sh >> "$LOG_FILE" 2>&1; then
    echo "$(date -u) - Job completed successfully" >> "$LOG_FILE"
else
    echo "$(date -u) - Job failed" >> "$LOG_FILE"
    exit 1
fi

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

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def morning_job():
    logger.info("Executing scheduled morning weekday task...")
    try:
        # Insert your core application/cleanup logic here
        pass
    except Exception as e:
        logger.error(f"Task failed: {e}", exc_info=True)

scheduler = BlockingScheduler()
# Standard 0 6 * * 1-5 maps to minute=0, hour=6, day_of_week='mon-fri'
trigger = CronTrigger(minute=0, hour=6, day_of_week='mon-fri', timezone='UTC')
scheduler.add_job(morning_job, trigger)

try:
    logger.info("Starting scheduler...")
    scheduler.start()
except (KeyboardInterrupt, SystemExit):
    logger.info("Scheduler stopped.")

package main

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

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

func main() {
	// Use the standard 5-field cron parser
	c := cron.New(cron.WithParser(cron.NewParser(
		cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor,
	)))

	_, err := c.AddFunc("0 6 * * 1-5", func() {
		log.Println("Starting weekday morning task execution...")
		// Execute application tasks here
	})
	if err != nil {
		log.Fatalf("Failed to schedule job: %v", err)
	}

	c.Start()
	log.Println("Cron scheduler initialized successfully")

	// Prevent main routine from exiting
	sig := make(chan os.Signal, 1)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
	<-sig
	c.Stop()
}

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 MorningTaskScheduler {
    private static final Logger logger = LoggerFactory.getLogger(MorningTaskScheduler.class);

    // Spring cron: second, minute, hour, day of month, month, day(s) of week
    @Scheduled(cron = "0 0 6 * * MON-FRI", zone = "UTC")
    public void executeMorningJob() {
        logger.info("Starting weekday morning scheduled task...");
        try {
            // Core business logic goes here
            logger.info("Scheduled task completed successfully.");
        } catch (Exception e) {
            logger.error("Exception caught during scheduled task execution", e);
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekday-morning-job
  namespace: default
spec:
  schedule: "0 6 * * 1-5"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: busybox:1.36
            command:
            - /bin/sh
            - -c
            - "echo 'Waking up systems...'; date; sleep 30"
          restartPolicy: OnFailure