Cron Alternatives (Systemd Timers, Anacron, More)

# Systemd timers consist of two files: .timer and .service

# /etc/systemd/system/daily-backup.service
# [Unit]
# Description=Daily database backup
#
# [Service]
# Type=oneshot
# ExecStart=/usr/local/bin/backup.sh
# User=backup
#
# [Install]
# WantedBy=multi-user.target

# /etc/systemd/system/daily-backup.timer
# [Unit]
# Description=Run daily backup at 3 AM
#
# [Timer]
# OnCalendar=daily
# OnCalendar=03:00:00
# Persistent=true
# RandomizedDelaySec=300
#
# [Install]
# WantedBy=timers.target

# Enable and start the timer
sudo systemctl daemon-reload
sudo systemctl enable daily-backup.timer
sudo systemctl start daily-backup.timer

# List timers
systemctl list-timers --all

# Check timer status
systemctl status daily-backup.timer

# View timer logs
journalctl -u daily-backup.service

# Manually trigger the service
sudo systemctl start daily-backup.service

# Systemd timer advantages:
# 1. Logging: journalctl -u my-timer.service
# 2. Dependencies: After=network.target
# 3. Persistent=true catches missed runs after boot
# 4. RandomizedDelaySec prevents thundering herd
# 5. Resource control: CPUQuota, MemoryMax

# Cron advantages:
# 1. Simpler syntax: one line vs two files
# 2. More portable: works on any Unix
# 3. User crontabs without root
# 4. MAILTO for output delivery

# Systemd timer with complex schedule:
# /etc/systemd/system/custom-schedule.timer
# [Timer]
# OnCalendar=Mon..Fri 09:00:00
# OnCalendar=Sat 10:00:00
# Persistent=true

# Systemd calendar events:
# OnCalendar=hourly
# OnCalendar=daily
# OnCalendar=weekly
# OnCalendar=monthly
# OnCalendar=Mon..Fri 09:00:00
# OnCalendar=*-*-01 00:00:00 (first of month)
# OnCalendar=*:0/15 (every 15 minutes)

# Anacron runs jobs that were missed due to system downtime
# Ideal for laptops and desktops that are not always on

# /etc/anacrontab format:
# period delay job-identifier command
# 1    5    cron.daily      run-parts /etc/cron.daily
# 7    10   cron.weekly     run-parts /etc/cron.weekly
# 30   15   cron.monthly    run-parts /etc/cron.monthly

# Period: days between runs
# Delay: minutes to wait after boot before running
# Identifier: unique name (stored in /var/spool/anacron/)

# Add a custom anacron job:
# 7    20   my-weekly-job   /usr/local/bin/weekly-cleanup.sh

# Check when anacron last ran each job:
cat /var/spool/anacron/*

# at runs a command once at a specified time
# Unlike cron, no recurring schedules

# Schedule a one-time job
echo "/usr/local/bin/backup.sh" | at 03:00

# Schedule with date
echo "systemctl restart nginx" | at 23:00 today
echo "curl https://api.dodatech.com/deploy" | at 09:00 tomorrow

# Schedule with relative time
echo "shutdown -h now" | at now + 1 hour
echo "send_report.py" | at now + 30 minutes

# List pending at jobs
atq

# Remove a job
atrm 5    # Remove job number 5

# View at job details
at -c 5

#!/usr/bin/env python3
"""Application-level scheduler using Python schedule library."""
import schedule
import time
import threading

class AppScheduler:
    def __init__(self):
        self.jobs = []

    def everyday_at(self, time_str, func):
        schedule.every().day.at(time_str).do(func)

    def every_n_minutes(self, minutes, func):
        schedule.every(minutes).minutes.do(func)

    def on_monday(self, time_str, func):
        schedule.every().monday.at(time_str).do(func)

    def on_weekdays(self, time_str, func):
        schedule.every().monday.at(time_str).do(func)
        schedule.every().tuesday.at(time_str).do(func)
        schedule.every().wednesday.at(time_str).do(func)
        schedule.every().thursday.at(time_str).do(func)
        schedule.every().friday.at(time_str).do(func)

    def run_threaded(self):
        def loop():
            while True:
                schedule.run_pending()
                time.sleep(30)
        thread = threading.Thread(target=loop, daemon=True)
        thread.start()

    def run_once(self):
        schedule.run_pending()

def generate_report():
    print("Weekly report generated")

def cache_warm():
    print("Cache warmed")

scheduler = AppScheduler()
scheduler.everyday_at("03:00", lambda: print("Backup running"))
scheduler.every_n_minutes(30, cache_warm)
scheduler.on_monday("09:00", generate_report)
scheduler.run_threaded()
time.sleep(65)

# celery_app.py
from celery import Celery
from celery.schedules import crontab

app = Celery('tasks', broker='redis://localhost:6379')

app.conf.beat_schedule = {
    'add-every-30-seconds': {
        'task': 'tasks.add',
        'schedule': 30.0,
        'args': (16, 16),
    },
    'daily-report': {
        'task': 'tasks.generate_report',
        'schedule': crontab(hour=9, minute=0),
    },
    'weekly-cleanup': {
        'task': 'tasks.cleanup',
        'schedule': crontab(hour=2, minute=0, day_of_week=0),
    },
    'monthly-billing': {
        'task': 'tasks.run_billing',
        'schedule': crontab(0, 0, day_of_month='1'),
    },
}

@app.task
def add(x, y):
    return x + y

@app.task
def generate_report():
    return {'report': 'generated'}

@app.task
def cleanup():
    return {'cleaned': True}

@app.task
def run_billing():
    return {'billing': 'completed'}

schedulers = {
    'cron': {
        'best_for': 'Simple recurring tasks on always-on servers',
        'pros': 'Universal, simple syntax, no dependencies',
        'cons': 'No dependency management, minimal logging',
    },
    'systemd_timer': {
        'best_for': 'System-level tasks on modern Linux',
        'pros': 'Journal logging, dependencies, resource control',
        'cons': 'Linux only, two-file setup',
    },
    'anacron': {
        'best_for': 'Laptops and desktops that sleep',
        'pros': 'Runs missed jobs after downtime',
        'cons': 'Daily granularity only',
    },
    'celery_beat': {
        'best_for': 'Application tasks with database integration',
        'pros': 'Dynamic schedules, distributed execution',
        'cons': 'Requires Redis/RabbitMQ, complex setup',
    },
    'kubernetes_cronjob': {
        'best_for': 'Containerized workloads in Kubernetes',
        'pros': 'Declarative, self-healing, scalable',
        'cons': 'Requires Kubernetes cluster',
    },
}

for name, info in schedulers.items():
    print(f"{name:20s}")
    print(f"  Best for: {info['best_for']}")
    print(f"  Pros: {info['pros']}")
    print(f"  Cons: {info['cons']}")
    print()

# Create a systemd service and timer for log cleanup

# /etc/systemd/system/log-cleanup.service
cat > /etc/systemd/system/log-cleanup.service << 'EOF'
[Unit]
Description=Clean old log files
After=local-fs.target

[Service]
Type=oneshot
ExecStart=/usr/bin/find /var/log -name "*.log" -mtime +30 -delete
ExecStart=/usr/bin/journalctl --vacuum-time=30d
User=root
StandardOutput=journal
EOF

# /etc/systemd/system/log-cleanup.timer
cat > /etc/systemd/system/log-cleanup.timer << 'EOF'
[Unit]
Description=Run log cleanup daily
Requires=log-cleanup.service

[Timer]
OnCalendar=daily
Persistent=true
RandomizedDelaySec=600

[Install]
WantedBy=timers.target
EOF

# Enable and start
sudo systemctl daemon-reload
sudo systemctl enable log-cleanup.timer
sudo systemctl start log-cleanup.timer

# Verify
systemctl list-timers log-cleanup.timer
journalctl -u log-cleanup.service