Run Every 30 Minutes During Business Hours | CronBase

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

// Schedule task to run every 30 minutes during business hours (9 AM - 5 PM, Mon-Fri)
const task = cron.schedule('*/30 9-17 * * 1-5', () => {
  console.log(`[${new Date().toISOString()}] Starting business hour sync...`);
  exec('/usr/local/bin/sync-job.sh', (error, stdout, stderr) => {
    if (error) {
      console.error(`Execution error: ${error.message}`);
      return;
    }
    if (stderr) console.warn(`Stderr: ${stderr}`);
    console.log(`Stdout: ${stdout}`);
  });
}, {
  scheduled: true,
  timezone: "America/New_York" // Explicitly define timezone to handle DST shifts
});
task.start();

#!/bin/bash
# Safe script to install the cron job for the current user
CRON_EXPR="*/30 9-17 * * 1-5"
JOB_CMD="/usr/local/bin/sync_crm_data.sh >> /var/log/crm_sync.log 2>&1"
# Ensure we do not duplicate the entry in the crontab
(crontab -l 2>/dev/null | grep -F "$JOB_CMD") && echo "Cron job already installed" && exit 0
(crontab -l 2>/dev/null; echo "$CRON_EXPR $JOB_CMD") | crontab -
echo "Cron job successfully installed: $CRON_EXPR"

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

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("business_hours_scheduler")

def run_sync_task():
    logger.info("Starting business hour data synchronization task...")
    try:
        result = subprocess.run(["/usr/local/bin/sync-job.sh"], capture_output=True, text=True, check=True)
        logger.info(f"Task completed successfully. Output: {result.stdout}")
    except subprocess.CalledProcessError as e:
        logger.error(f"Task failed with exit code {e.returncode}. Error: {e.stderr}")

scheduler = BlockingScheduler(timezone="America/New_York")
# Standard cron fields: minute, hour, day, month, day_of_week
scheduler.add_job(run_sync_task, 'cron', minute='*/30', hour='9-17', day_of_week='mon-fri')

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

package main

import (
	"fmt"
	"log"
	"os/exec"
	"time"

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

func runTask() {
	log.Println("Starting scheduled business-hours synchronization...")
	cmd := exec.Command("/usr/local/bin/sync-job.sh")
	output, err := cmd.CombinedOutput()
	if err != nil {
		log.Printf("Error executing job: %v. Output: %s", err, string(output))
		return
	}
	log.Printf("Job completed successfully: %s", string(output))
}

func main() {
	// Use New with Location to handle DST and timezone offsets
	nyc, err := time.LoadLocation("America/New_York")
	if err != nil {
		log.Fatalf("Failed to load timezone: %v", err)
	}

	c := cron.New(cron.WithLocation(nyc))
	_, err = c.AddFunc("*/30 9-17 * * 1-5", runTask)
	if err != nil {
		log.Fatalf("Error scheduling job: %v", err)
	}

	log.Println("Scheduler initiated for standard weekday business hours.")
	c.Start()
	// Keep the process alive
	select {}
}

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import java.util.TimeZone;

public class BusinessHoursScheduler {
    public static class SyncJob implements Job {
        @Override
        public void execute(JobExecutionContext context) throws JobExecutionException {
            System.out.println("Executing business hours synchronization task...");
            try {
                Process process = Runtime.getRuntime().exec("/usr/local/bin/sync-job.sh");
                int exitCode = process.waitFor();
                if (exitCode != 0) {
                    throw new JobExecutionException("Task failed with exit code: " + exitCode);
                }
            } catch (Exception e) {
                throw new JobExecutionException("Execution failed", e);
            }
        }
    }

    public static void main(String[] args) {
        try {
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            scheduler.start();

            JobDetail job = JobBuilder.newJob(SyncJob.class)
                    .withIdentity("syncJob", "group1")
                    .build();

            // Quartz uses 6-7 fields (seconds, minutes, hours, day-of-month, month, day-of-week)
            // Standard cron: */30 9-17 * * 1-5 maps to Quartz: 0 0/30 9-17 ? * MON-FRI
            CronTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("syncTrigger", "group1")
                    .withSchedule(CronScheduleBuilder.cronSchedule("0 0/30 9-17 ? * MON-FRI")
                            .inTimeZone(TimeZone.getTimeZone("America/New_York")))
                    .build();

            scheduler.scheduleJob(job, trigger);
            System.out.println("Quartz Scheduler started successfully.");
        } catch (SchedulerException se) {
            se.printStackTrace();
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: business-hours-sync
  namespace: default
spec:
  schedule: "*/30 9-17 * * 1-5"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: sync-worker
            image: registry.example.com/sync-worker:v1.2.0
            imagePullPolicy: IfNotPresent
            command:
            - /usr/local/bin/sync-job.sh
            resources:
              limits:
                cpu: "500m"
                memory: "512Mi"
              requests:
                cpu: "250m"
                memory: "256Mi"
          restartPolicy: OnFailure