Configure custom Grafana plugins for specialized monitoring requirements

#!/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'

# Global variables
GRAFANA_USER="grafana"
GRAFANA_GROUP="grafana"
GRAFANA_HOME="/usr/share/grafana"
PLUGIN_DIR=""
TEMP_DIR=""

# Usage
usage() {
    cat << EOF
Usage: $0 [OPTIONS]
Install and configure Grafana with custom plugin development environment

Options:
    -h, --help          Show this help message
    -p, --plugin-name   Custom plugin name (default: status-panel)

Examples:
    $0
    $0 -p my-custom-panel
EOF
}

# 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() {
    local exit_code=$?
    if [ $exit_code -ne 0 ]; then
        log_error "Installation failed. Cleaning up..."
        [ -n "$TEMP_DIR" ] && rm -rf "$TEMP_DIR"
        if systemctl is-enabled grafana-server >/dev/null 2>&1; then
            systemctl stop grafana-server || true
            systemctl disable grafana-server || true
        fi
    fi
    exit $exit_code
}

trap cleanup ERR

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

    if ! command -v curl >/dev/null 2>&1; then
        log_error "curl is required but not installed"
        exit 1
    fi
}

# Detect distribution
detect_distro() {
    if [ ! -f /etc/os-release ]; then
        log_error "/etc/os-release not found. Cannot detect distribution."
        exit 1
    fi

    . /etc/os-release
    case "$ID" in
        ubuntu|debian)
            PKG_MGR="apt"
            PKG_UPDATE="apt update"
            PKG_INSTALL="apt install -y"
            FIREWALL_CMD="ufw"
            ;;
        almalinux|rocky|centos|rhel|ol|fedora)
            PKG_MGR="dnf"
            PKG_UPDATE="dnf update -y"
            PKG_INSTALL="dnf install -y"
            FIREWALL_CMD="firewall-cmd"
            # Use yum for older versions
            if ! command -v dnf >/dev/null 2>&1; then
                PKG_MGR="yum"
                PKG_UPDATE="yum update -y"
                PKG_INSTALL="yum install -y"
            fi
            ;;
        amzn)
            PKG_MGR="yum"
            PKG_UPDATE="yum update -y"
            PKG_INSTALL="yum install -y"
            FIREWALL_CMD="iptables"
            ;;
        *)
            log_error "Unsupported distribution: $ID"
            exit 1
            ;;
    esac

    log_info "Detected distribution: $ID"
}

# Install Node.js
install_nodejs() {
    log_info "[1/6] Installing Node.js development environment..."
    
    case "$PKG_MGR" in
        apt)
            $PKG_INSTALL apt-transport-https ca-certificates gnupg
            curl -fsSL https://deb.nodesource.com/setup_20.x | bash -
            $PKG_INSTALL nodejs git build-essential
            ;;
        dnf|yum)
            curl -fsSL https://rpm.nodesource.com/setup_20.x | bash -
            $PKG_INSTALL nodejs npm git gcc-c++ make
            ;;
    esac

    # Install yarn and Grafana toolkit
    npm install -g yarn @grafana/toolkit
    
    log_info "Node.js $(node --version) installed successfully"
}

# Install Grafana
install_grafana() {
    log_info "[2/6] Installing Grafana..."
    
    case "$PKG_MGR" in
        apt)
            $PKG_INSTALL apt-transport-https software-properties-common wget gpg
            mkdir -p /etc/apt/keyrings/
            wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | tee /etc/apt/keyrings/grafana.gpg > /dev/null
            echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | tee -a /etc/apt/sources.list.d/grafana.list
            apt update
            $PKG_INSTALL grafana
            ;;
        dnf|yum)
            cat > /etc/yum.repos.d/grafana.repo << 'EOF'
[grafana]
name=grafana
baseurl=https://rpm.grafana.com
repo_gpgcheck=1
enabled=1
gpgcheck=1
gpgkey=https://rpm.grafana.com/gpg.key
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt
EOF
            $PKG_INSTALL grafana
            ;;
    esac

    # Set proper permissions
    chown -R $GRAFANA_USER:$GRAFANA_GROUP /etc/grafana
    chown -R $GRAFANA_USER:$GRAFANA_GROUP /var/lib/grafana
    chown -R $GRAFANA_USER:$GRAFANA_GROUP /var/log/grafana
}

# Configure Grafana for development
configure_grafana() {
    log_info "[3/6] Configuring Grafana for plugin development..."
    
    # Enable development mode in Grafana config
    if grep -q "app_mode.*development" /etc/grafana/grafana.ini; then
        sed -i 's/^;app_mode = production/app_mode = development/' /etc/grafana/grafana.ini
    else
        sed -i '/\[DEFAULT\]/a app_mode = development' /etc/grafana/grafana.ini
    fi
    
    # Allow unsigned plugins
    if grep -q "allow_loading_unsigned_plugins" /etc/grafana/grafana.ini; then
        sed -i 's/^;allow_loading_unsigned_plugins =/allow_loading_unsigned_plugins = true/' /etc/grafana/grafana.ini
    else
        sed -i '/\[plugins\]/a allow_loading_unsigned_plugins = true' /etc/grafana/grafana.ini
    fi
    
    # Set plugin directory
    PLUGIN_DIR="/var/lib/grafana/plugins"
    mkdir -p "$PLUGIN_DIR"
    chown $GRAFANA_USER:$GRAFANA_GROUP "$PLUGIN_DIR"
    chmod 755 "$PLUGIN_DIR"
}

# Create sample plugin
create_sample_plugin() {
    log_info "[4/6] Creating sample custom plugin..."
    
    TEMP_DIR="/tmp/grafana-plugin-dev"
    mkdir -p "$TEMP_DIR"
    cd "$TEMP_DIR"
    
    # Initialize plugin using Grafana toolkit
    npx @grafana/toolkit plugin:create "${PLUGIN_NAME}"
    cd "${PLUGIN_NAME}"
    
    # Build the plugin
    npm install
    npm run build
    
    # Install plugin to Grafana
    cp -r dist "${PLUGIN_DIR}/${PLUGIN_NAME}"
    chown -R $GRAFANA_USER:$GRAFANA_GROUP "${PLUGIN_DIR}/${PLUGIN_NAME}"
    chmod -R 755 "${PLUGIN_DIR}/${PLUGIN_NAME}"
    
    log_info "Sample plugin '${PLUGIN_NAME}' created and installed"
}

# Configure firewall
configure_firewall() {
    log_info "[5/6] Configuring firewall..."
    
    case "$FIREWALL_CMD" in
        ufw)
            if command -v ufw >/dev/null 2>&1 && ufw status | grep -q "Status: active"; then
                ufw allow 3000/tcp
                log_info "UFW rule added for Grafana (port 3000)"
            fi
            ;;
        firewall-cmd)
            if systemctl is-active firewalld >/dev/null 2>&1; then
                firewall-cmd --permanent --add-port=3000/tcp
                firewall-cmd --reload
                log_info "Firewalld rule added for Grafana (port 3000)"
            fi
            ;;
        iptables)
            if iptables -L >/dev/null 2>&1; then
                iptables -I INPUT -p tcp --dport 3000 -j ACCEPT
                service iptables save || true
                log_info "Iptables rule added for Grafana (port 3000)"
            fi
            ;;
    esac
}

# Start services
start_services() {
    log_info "[6/6] Starting Grafana service..."
    
    systemctl daemon-reload
    systemctl enable grafana-server
    systemctl start grafana-server
    
    # Wait for Grafana to start
    local count=0
    while ! curl -s http://localhost:3000 >/dev/null 2>&1; do
        sleep 2
        count=$((count + 1))
        if [ $count -gt 30 ]; then
            log_error "Grafana failed to start within 60 seconds"
            exit 1
        fi
    done
}

# Verify installation
verify_installation() {
    log_info "Verifying installation..."
    
    # Check Node.js
    if ! command -v node >/dev/null 2>&1; then
        log_error "Node.js verification failed"
        return 1
    fi
    
    # Check Grafana service
    if ! systemctl is-active grafana-server >/dev/null 2>&1; then
        log_error "Grafana service verification failed"
        return 1
    fi
    
    # Check Grafana HTTP response
    if ! curl -s http://localhost:3000 >/dev/null 2>&1; then
        log_error "Grafana HTTP verification failed"
        return 1
    fi
    
    # Check plugin directory
    if [ ! -d "$PLUGIN_DIR" ]; then
        log_error "Plugin directory verification failed"
        return 1
    fi
    
    log_info "All verifications passed!"
    return 0
}

# Parse command line arguments
PLUGIN_NAME="status-panel"
while [[ $# -gt 0 ]]; do
    case $1 in
        -h|--help)
            usage
            exit 0
            ;;
        -p|--plugin-name)
            PLUGIN_NAME="$2"
            shift 2
            ;;
        *)
            log_error "Unknown option: $1"
            usage
            exit 1
            ;;
    esac
done

# Main execution
main() {
    log_info "Starting Grafana custom plugin development environment setup..."
    
    check_prerequisites
    detect_distro
    install_nodejs
    install_grafana
    configure_grafana
    create_sample_plugin
    configure_firewall
    start_services
    
    if verify_installation; then
        log_info "Installation completed successfully!"
        echo
        echo "Grafana is now running at: http://localhost:3000"
        echo "Default credentials: admin/admin"
        echo "Custom plugin '${PLUGIN_NAME}' has been installed"
        echo "Plugin development directory: ${PLUGIN_DIR}"
        echo
        echo "To develop plugins:"
        echo "1. Create plugins in: ${TEMP_DIR}"
        echo "2. Build with: npm run build"
        echo "3. Copy dist/ to: ${PLUGIN_DIR}/your-plugin-name/"
        echo "4. Restart Grafana: systemctl restart grafana-server"
    else
        log_error "Installation verification failed"
        exit 1
    fi
}

main "$@"