Configure centralized cron management with Ansible automation and systemd timers

#!/usr/bin/env bash

set -euo pipefail

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Global variables
SCRIPT_DIR="/opt/ansible-cron"
ANSIBLE_USER="ansible"
INVENTORY_FILE=""
SSH_KEY_PATH=""

# Usage function
usage() {
    echo "Usage: $0 [OPTIONS]"
    echo "Options:"
    echo "  -u USERNAME    Ansible user (default: ansible)"
    echo "  -i INVENTORY   Path to inventory file"
    echo "  -k SSH_KEY     Path to SSH private key"
    echo "  -h             Show this help"
    exit 1
}

# Parse arguments
while getopts "u:i:k:h" opt; do
    case $opt in
        u) ANSIBLE_USER="$OPTARG" ;;
        i) INVENTORY_FILE="$OPTARG" ;;
        k) SSH_KEY_PATH="$OPTARG" ;;
        h) usage ;;
        *) usage ;;
    esac
done

# Logging functions
log_info() {
    echo -e "${GREEN}[INFO]${NC} $1"
}

log_warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# Cleanup function
cleanup() {
    log_error "Installation failed. Cleaning up..."
    if [[ -d "$SCRIPT_DIR" ]]; then
        rm -rf "$SCRIPT_DIR"
    fi
    exit 1
}

trap cleanup ERR

# Check if running as root or with sudo
check_privileges() {
    if [[ $EUID -ne 0 ]]; then
        log_error "This script must be run as root or with sudo"
        exit 1
    fi
}

# Detect distribution
detect_distro() {
    if [[ -f /etc/os-release ]]; then
        . /etc/os-release
        case "$ID" in
            ubuntu|debian) 
                PKG_MGR="apt"
                PKG_INSTALL="apt install -y"
                PKG_UPDATE="apt update"
                EPEL_NEEDED=false
                ;;
            almalinux|rocky|centos|rhel|ol)
                PKG_MGR="dnf"
                PKG_INSTALL="dnf install -y"
                PKG_UPDATE="dnf makecache"
                EPEL_NEEDED=true
                ;;
            fedora)
                PKG_MGR="dnf"
                PKG_INSTALL="dnf install -y"
                PKG_UPDATE="dnf makecache"
                EPEL_NEEDED=false
                ;;
            amzn)
                PKG_MGR="yum"
                PKG_INSTALL="yum install -y"
                PKG_UPDATE="yum makecache"
                EPEL_NEEDED=true
                ;;
            *)
                log_error "Unsupported distribution: $ID"
                exit 1
                ;;
        esac
        export PKG_MGR PKG_INSTALL PKG_UPDATE EPEL_NEEDED
        log_info "Detected distribution: $PRETTY_NAME"
    else
        log_error "Cannot detect distribution"
        exit 1
    fi
}

# Install packages
install_packages() {
    log_info "[1/7] Installing required packages..."
    
    $PKG_UPDATE
    
    if [[ "$EPEL_NEEDED" == "true" ]]; then
        if [[ "$PKG_MGR" == "dnf" ]]; then
            $PKG_INSTALL epel-release
        elif [[ "$PKG_MGR" == "yum" ]]; then
            $PKG_INSTALL epel-release
        fi
    fi
    
    case "$PKG_MGR" in
        apt)
            $PKG_INSTALL ansible python3-pip openssh-client
            ;;
        dnf|yum)
            $PKG_INSTALL ansible python3-pip openssh-clients
            ;;
    esac
    
    pip3 install --upgrade ansible-core
    log_info "Packages installed successfully"
}

# Create directory structure
create_directories() {
    log_info "[2/7] Creating directory structure..."
    
    mkdir -p "$SCRIPT_DIR"/{playbooks,templates,group_vars,inventory}
    chown -R root:root "$SCRIPT_DIR"
    chmod 755 "$SCRIPT_DIR"
    find "$SCRIPT_DIR" -type d -exec chmod 755 {} \;
    
    log_info "Directory structure created"
}

# Create systemd timer template
create_timer_template() {
    log_info "[3/7] Creating systemd timer template..."
    
    cat > "$SCRIPT_DIR/templates/systemd-timer.j2" << 'EOF'
[Unit]
Description={{ item.description | default('Scheduled task') }}
Requires={{ item.name }}.service

[Timer]
OnCalendar={{ item.schedule }}
Persistent=true
RandomizedDelaySec={{ item.randomized_delay | default('0') }}

[Install]
WantedBy=timers.target
EOF
    
    chmod 644 "$SCRIPT_DIR/templates/systemd-timer.j2"
    log_info "Timer template created"
}

# Create systemd service template
create_service_template() {
    log_info "[4/7] Creating systemd service template..."
    
    cat > "$SCRIPT_DIR/templates/systemd-service.j2" << 'EOF'
[Unit]
Description={{ item.description | default('Scheduled task service') }}
After=network.target

[Service]
Type=oneshot
User={{ item.user | default('root') }}
Group={{ item.group | default('root') }}
WorkingDirectory={{ item.working_directory | default('/tmp') }}
ExecStart={{ item.command }}
StandardOutput=journal
StandardError=journal
SyslogIdentifier={{ item.name }}
{% if item.environment is defined %}
{% for env_var in item.environment %}
Environment={{ env_var }}
{% endfor %}
{% endif %}

[Install]
WantedBy=multi-user.target
EOF
    
    chmod 644 "$SCRIPT_DIR/templates/systemd-service.j2"
    log_info "Service template created"
}

# Create sample configuration
create_sample_config() {
    log_info "[5/7] Creating sample configuration..."
    
    cat > "$SCRIPT_DIR/group_vars/all.yml" << 'EOF'
---
cron_jobs:
  - name: backup-database
    description: "Daily database backup"
    command: "/usr/local/bin/backup-db.sh"
    schedule: "daily"
    user: "backup"
    group: "backup"
    working_directory: "/var/backups"
    environment:
      - "BACKUP_RETENTION=7"
      - "BACKUP_COMPRESSION=gzip"
    
  - name: log-cleanup
    description: "Weekly log file cleanup"
    command: "/usr/local/bin/cleanup-logs.sh"
    schedule: "weekly"
    user: "root"
    randomized_delay: "1h"
    
  - name: system-update-check
    description: "Check for system updates every 4 hours"
    command: "/usr/local/bin/check-updates.sh"
    schedule: "*-*-* 00,04,08,12,16,20:00:00"
    user: "root"
    
  - name: web-health-check
    description: "Monitor web application health every 5 minutes"
    command: "/usr/local/bin/health-check.sh"
    schedule: "*:0/5"
    user: "monitor"
    group: "monitor"
    working_directory: "/opt/monitoring"
EOF
    
    chmod 644 "$SCRIPT_DIR/group_vars/all.yml"
    log_info "Sample configuration created"
}

# Create main playbook
create_playbook() {
    log_info "[6/7] Creating main Ansible playbook..."
    
    cat > "$SCRIPT_DIR/playbooks/deploy-cron.yml" << 'EOF'
---
- name: Deploy centralized cron management with systemd timers
  hosts: cron_servers
  become: yes
  
  tasks:
    - name: Create systemd service files
      template:
        src: systemd-service.j2
        dest: "/etc/systemd/system/{{ item.name }}.service"
        mode: '0644'
        owner: root
        group: root
      loop: "{{ cron_jobs }}"
      notify: reload systemd
      
    - name: Create systemd timer files
      template:
        src: systemd-timer.j2
        dest: "/etc/systemd/system/{{ item.name }}.timer"
        mode: '0644'
        owner: root
        group: root
      loop: "{{ cron_jobs }}"
      notify: reload systemd
      
    - name: Remove old cron jobs if they exist
      cron:
        name: "{{ item.name }}"
        state: absent
      loop: "{{ cron_jobs }}"
      
    - name: Start and enable systemd timers
      systemd:
        name: "{{ item.name }}.timer"
        state: started
        enabled: yes
        daemon_reload: yes
      loop: "{{ cron_jobs }}"
      
  handlers:
    - name: reload systemd
      systemd:
        daemon_reload: yes
EOF
    
    chmod 644 "$SCRIPT_DIR/playbooks/deploy-cron.yml"
    log_info "Main playbook created"
}

# Create sample inventory and helper scripts
create_helpers() {
    log_info "[7/7] Creating helper files..."
    
    # Sample inventory
    cat > "$SCRIPT_DIR/inventory/hosts" << EOF
[cron_servers]
# Add your servers here:
# web1.example.com ansible_host=10.0.1.10
# web2.example.com ansible_host=10.0.1.11
# db1.example.com ansible_host=10.0.1.12

[all:vars]
ansible_user=${ANSIBLE_USER}
ansible_ssh_private_key_file=~/.ssh/ansible_key
EOF
    
    # Deployment script
    cat > "$SCRIPT_DIR/deploy.sh" << 'EOF'
#!/bin/bash
cd "$(dirname "$0")"
ansible-playbook -i inventory/hosts playbooks/deploy-cron.yml "$@"
EOF
    
    # Status check script
    cat > "$SCRIPT_DIR/check-timers.sh" << 'EOF'
#!/bin/bash
cd "$(dirname "$0")"
ansible cron_servers -i inventory/hosts -m shell -a "systemctl list-timers --no-pager" "$@"
EOF
    
    chmod 755 "$SCRIPT_DIR/deploy.sh" "$SCRIPT_DIR/check-timers.sh"
    chmod 644 "$SCRIPT_DIR/inventory/hosts"
    
    log_info "Helper files created"
}

# Verify installation
verify_installation() {
    log_info "Verifying installation..."
    
    # Check Ansible installation
    if ! command -v ansible >/dev/null 2>&1; then
        log_error "Ansible not found in PATH"
        return 1
    fi
    
    # Check directory structure
    local required_files=(
        "$SCRIPT_DIR/templates/systemd-timer.j2"
        "$SCRIPT_DIR/templates/systemd-service.j2"
        "$SCRIPT_DIR/playbooks/deploy-cron.yml"
        "$SCRIPT_DIR/group_vars/all.yml"
        "$SCRIPT_DIR/inventory/hosts"
        "$SCRIPT_DIR/deploy.sh"
        "$SCRIPT_DIR/check-timers.sh"
    )
    
    for file in "${required_files[@]}"; do
        if [[ ! -f "$file" ]]; then
            log_error "Required file missing: $file"
            return 1
        fi
    done
    
    log_info "Installation verification completed successfully"
}

# Main installation function
main() {
    log_info "Starting centralized cron management installation..."
    
    check_privileges
    detect_distro
    install_packages
    create_directories
    create_timer_template
    create_service_template
    create_sample_config
    create_playbook
    create_helpers
    verify_installation
    
    log_info "Installation completed successfully!"
    echo
    echo -e "${GREEN}Next steps:${NC}"
    echo "1. Edit $SCRIPT_DIR/inventory/hosts to add your servers"
    echo "2. Configure SSH key authentication for Ansible user"
    echo "3. Customize job definitions in $SCRIPT_DIR/group_vars/all.yml"
    echo "4. Run deployment: $SCRIPT_DIR/deploy.sh"
    echo "5. Check timer status: $SCRIPT_DIR/check-timers.sh"
}

main "$@"