Linux Job Scheduling Without Cron

How Sleep Loops Work

Sleep loops are a way to schedule tasks in Linux without cron. This method uses shell commands to create a loop that runs a task at set times.

Here's a diagram showing the sleep loop process:

Basic Sleep Loop Example

while true; do
    echo "Task executed at $(date)"
    sleep 60
done &

This loop prints a message with the current date every 60 seconds.

while true; do
    current_time=$(date +%s)
    target_time=$(date -d "23:00" +%s)
    sleep_duration=$((target_time - current_time))

    if [ $sleep_duration -lt 0 ]; then
        sleep_duration=$((sleep_duration + 86400))
    fi

    sleep $sleep_duration

    # Run your task here
    echo "Task executed at $(date)"
done &

Complex Task Example

while true; do
    /path/to/your/script.sh
    sleep 3600
done &

This example runs a script every hour (3600 seconds).

Advantages and Limitations

Best Use Cases

Sleep loops are best for:

• Quick, temporary scheduling needs
• Testing and development environments
• Systems where cron or systemd are not available
• Tasks that need to run non-stop with a fixed interval

Setting Up Systemd Timers

Systemd timers schedule tasks in Linux systems that use systemd as their init system. To set up a systemd timer, create two files: a timer unit and a service unit.

Here's a guide with examples:

1. Create a timer unit file:

sudo nano /etc/systemd/system/backup.timer

Add the following content:

[Unit]
Description=Daily Backup Timer

[Timer]
OnCalendar=*-*-* 02:00:00
Unit=backup.service

[Install]
WantedBy=timers.target

2. Create a service unit file:

sudo nano /etc/systemd/system/backup.service

Add the following content:

[Unit]
Description=Daily Backup Service

[Service]
ExecStart=/home/user/scripts/daily_backup.sh

[Install]
WantedBy=multi-user.target

3. Enable and start the timer:

sudo systemctl enable backup.timer
sudo systemctl start backup.timer

This example sets up a daily backup task that runs at 2 AM every day.

sudo systemctl daemon-reload

Customizing Systemd Timer Schedules

Systemd timers use the OnCalendar option to set schedules. Here are examples of schedules:

You can also use other time expressions:

OnBootSec

Runs the task a set time after boot. For example:

[Timer]
OnBootSec=5min

This runs a task 5 minutes after the system boots, useful for initialization scripts.

OnUnitActiveSec

Runs the task at set intervals after the service was last activated. For example:

[Timer]
OnUnitActiveSec=30min

This is useful for tasks that need to run often, like checking for software updates every 30 minutes.

Visualizing Systemd Timer Flow

Practical Use Cases

• Log Cleanup: Set up a timer to remove old log files weekly.
• Database Backups: Create hourly database backups during business hours.
• System Updates: Schedule automatic system updates during off-hours.
• Temporary File Cleanup: Clear temporary files daily to free up disk space.

2. Create the service file (/etc/systemd/system/cleanup.service):
```ini
[Unit]
Description=Temporary File Cleanup Service

[Service]
ExecStart=/bin/sh -c 'find /tmp -type f -atime +7 -delete'

[Install]
WantedBy=multi-user.target

Monitoring Systemd Timers

To check the status of your timers:

systemctl list-timers

This command shows all active timers, their last and next trigger times, and the associated unit.

Advantages of Systemd Timers

• Integration with systemd logging
• Accurate timing even if a scheduled time is missed (e.g., system was off)
• Can trigger based on system events, not just time
• Easy to manage with standard systemd commands

For more information on systemd timers, refer to the official systemd documentation.

Understanding Anacron's Functionality

Anacron is a job scheduling program for systems with irregular uptime. It runs tasks even if the system is offline during the scheduled time. This is useful for:

• Personal computers used intermittently
• Servers that may be powered down occasionally
• Devices in environments with unreliable power supply

which anacron

How Anacron Works

Advanced Anacron Usage

Using Environment Variables

Anacron lets you set environment variables for your jobs. This can help configure paths, set options, or pass information to scripts.

Example:

SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=admin@example.com

1 5 daily-backup HOME=/home/user /path/to/backup-script.sh

In this example, the HOME variable is set for the daily-backup job.

Handling Job Output

By default, Anacron sends job output via email to the local user. You can redirect output to a file or discard it:

• Redirect to a file: 1 5 daily-task /path/to/script.sh > /path/to/logfile 2>&1
• Discard output: 1 5 daily-task /path/to/script.sh > /dev/null 2>&1

Using Anacron with Cron

For systems that are usually on but may be off occasionally, you can combine Anacron with cron for more flexibility:

1. Create an Anacron job file (e.g., /etc/cron.daily/anacron-daily):

#!/bin/bash
/usr/sbin/anacron -s

2. Make it executable:

sudo chmod +x /etc/cron.daily/anacron-daily

This setup runs Anacron daily through cron, allowing it to catch up on missed jobs when the system is on.

Pros and Cons

Sleep Loops

Systemd Timers

Anacron

Choosing the Right Method

To select the best scheduling method, consider these factors:

1. System uptime: For always-on systems, systemd timers or sleep loops work well. For intermittent use, Anacron is better.

2. Timing precision: For exact timing, use systemd timers. Sleep loops and Anacron are less precise.

3. Ease of setup: Sleep loops are simplest, while systemd timers and Anacron need more configuration.

4. System compatibility: Sleep loops work on any Linux system. Systemd timers need systemd, and Anacron may need separate installation.

5. Task complexity: For simple tasks, sleep loops might be enough. For complex scheduling, use systemd timers or Anacron.

By considering these factors, you can choose the method that fits your needs and system.

Additional Resources

• Systemd Timers Documentation
• Anacron Manual Page
• Linux Shell Scripting Tutorial