Crontab Files and Management — Complete Guide

# Each user has their own crontab file stored in /var/spool/cron/crontabs/

# List current user's cron jobs
crontab -l

# Edit current user's crontab
crontab -e

# View another user's crontab (root only)
sudo crontab -u www-data -l

# Edit another user's crontab (root only)
sudo crontab -u www-data -e

# Remove all cron jobs for the current user
crontab -r

# Remove all cron jobs for another user (root only)
sudo crontab -u deploy -r

# Install a crontab from a file
crontab /path/to/my/crontab.txt

# Backup current crontab
crontab -l > ~/cron-backup-$(date +%Y%m%d).txt

# /etc/crontab has an ADDITIONAL field: the user to run as
# Minute Hour Day Month Weekday User Command

# Example /etc/crontab:
SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=admin@dodatech.com

# Run as root
0 3 * * * root /usr/local/bin/daily-backup.sh

# Run as www-data
*/15 * * * * www-data /usr/local/bin/cache-warm.php

# Run as deploy user
0 9 * * 1 deploy /usr/local/bin/deploy-check.sh

# Note: /etc/crontab uses 6 fields (5 time fields + user + command)
# User crontabs use 5 fields (5 time fields + command)

# /etc/cron.d contains individual snippet files
# Each file follows the same format as /etc/crontab (with user field)

# Example: /etc/cron.d/database-backups
# Database backup schedules for DodaTech
SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin

0 3 * * * root /usr/local/bin/mysql-backup.sh
30 3 * * * root /usr/local/bin/pg-backup.sh

# Example: /etc/cron.d/application
# Application-specific cron jobs
MAILTO=alerts@dodatech.com

*/5 * * * * www-data /usr/share/app/health-check.php
0 2 * * * www-data /usr/share/app/cleanup-sessions.php

# Files in /etc/cron.d must NOT have dots in their names
# (except for the standard files like .placeholder)

# /etc/cron.hourly/  - scripts run every hour
# /etc/cron.daily/   - scripts run once per day (at 6:25 AM by default)
# /etc/cron.weekly/  - scripts run once per week (at 6:47 AM on Sunday)
# /etc/cron.monthly/ - scripts run once per month (at 6:52 AM on the 1st)

# These directories use run-parts to execute every executable script inside

# Add a script to run hourly:
sudo tee /etc/cron.hourly/health-check << 'EOF'
#!/bin/bash
curl -s http://localhost/health > /dev/null
EOF
sudo chmod +x /etc/cron.hourly/health-check

# Daily maintenance script:
sudo tee /etc/cron.daily/clean-temp << 'EOF'
#!/bin/bash
find /tmp -type f -atime +7 -delete
EOF
sudo chmod +x /etc/cron.daily/clean-temp

# Check the anacron timestamps:
ls -la /var/spool/anacron/

#!/usr/bin/env python3
import subprocess
import sys

class CrontabManager:
    def __init__(self, user=None):
        self.user = user

    def _run_crontab(self, input_data=None):
        cmd = ['crontab']
        if self.user:
            cmd.extend(['-u', self.user])

        if input_data is not None:
            cmd.append('-')
            result = subprocess.run(cmd, input=input_data, capture_output=True, text=True)
        else:
            result = subprocess.run(cmd, capture_output=True, text=True)

        return result

    def list_jobs(self):
        result = subprocess.run(
            ['crontab', '-l'] if not self.user else ['crontab', '-u', self.user, '-l'],
            capture_output=True, text=True
        )
        if result.returncode == 0:
            return result.stdout.strip().split('\n')
        return []

    def add_job(self, schedule, command):
        existing = self.list_jobs()
        new_entry = f"{schedule} {command}"
        existing.append(new_entry)
        content = '\n'.join(existing) + '\n'
        result = self._run_crontab(content)
        return result.returncode == 0

    def remove_job(self, command_match):
        existing = self.list_jobs()
        filtered = [j for j in existing if command_match not in j]
        content = '\n'.join(filtered) + '\n'
        result = self._run_crontab(content)
        return result.returncode == 0

manager = CrontabManager()
jobs = manager.list_jobs()
print(f"Current cron jobs ({len(jobs)}):")
for j in jobs:
    print(f"  {j}")

# Backup all user crontabs to version control
#!/bin/bash
BACKUP_DIR="/backups/crontabs/$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

# Backup each user's crontab
for user in $(cut -f1 -d: /etc/passwd); do
    crontab -u "$user" -l > "$BACKUP_DIR/$user.crontab" 2>/dev/null
done

# Backup system cron files
cp -r /etc/cron.d "$BACKUP_DIR/cron.d"
cp /etc/crontab "$BACKUP_DIR/system.crontab"

# Git operations
cd /backups/crontabs
git add .
git commit -m "Crontab backup $(date +%Y-%m-%d)"
git push origin main

#!/usr/bin/env python3
import os
import sys
import subprocess
from datetime import datetime

class CrontabManager:
    def __init__(self, backup_dir='/backups/crontabs'):
        self.backup_dir = backup_dir

    def backup_all(self):
        date_str = datetime.now().strftime('%Y%m%d_%H%M%S')
        backup_path = os.path.join(self.backup_dir, date_str)
        os.makedirs(backup_path, exist_ok=True)

        with open('/etc/passwd') as f:
            for line in f:
                user = line.split(':')[0]
                result = subprocess.run(
                    ['crontab', '-u', user, '-l'],
                    capture_output=True, text=True
                )
                if result.returncode == 0 and result.stdout.strip():
                    filepath = os.path.join(backup_path, f"{user}.crontab")
                    with open(filepath, 'w') as out:
                        out.write(result.stdout)
                    print(f"Backed up: {user}")

        return backup_path

    def list_all_jobs(self):
        all_jobs = {}
        with open('/etc/passwd') as f:
            for line in f:
                user = line.split(':')[0]
                result = subprocess.run(
                    ['crontab', '-u', user, '-l'],
                    capture_output=True, text=True
                )
                if result.returncode == 0 and result.stdout.strip():
                    all_jobs[user] = result.stdout.strip().split('\n')
        return all_jobs

    def find_job(self, search_term):
        found = []
        all_jobs = self.list_all_jobs()
        for user, jobs in all_jobs.items():
            for job in jobs:
                if search_term in job:
                    found.append((user, job))
        return found

manager = CrontabManager()
backup = manager.backup_all()
print(f"Backup saved to: {backup}")

matches = manager.find_job('backup')
for user, job in matches:
    print(f"  [{user}] {job}")