# Standard serial configuration format: SPEED PARITY DATA_BITS STOP_BITS FLOW_CONTROL
# Example: 115200n8 = 115200 baud, no parity, 8 data bits, 1 stop bit, no flow control

# Common enterprise configurations:
# 9600n8    - Legacy systems, high reliability
# 57600n8   - Balanced performance and compatibility  
# 115200n8  - Modern high-performance systems

#!/bin/bash
# Enterprise IPMI Configuration and Management Script

set -euo pipefail

# Configuration variables
IPMI_USER="admin"
IPMI_PASS_FILE="/etc/ipmi/admin.pass"
IPMI_CHANNEL="1"
LOG_FILE="/var/log/ipmi-config.log"

# Logging function
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# IPMI service configuration
configure_ipmi_service() {
    log_message "Configuring IPMI service..."
    
    # Install IPMI tools
    if command -v apt >/dev/null 2>&1; then
        apt update && apt install -y ipmitool openipmi
    elif command -v yum >/dev/null 2>&1; then
        yum install -y ipmitool OpenIPMI
    elif command -v dnf >/dev/null 2>&1; then
        dnf install -y ipmitool OpenIPMI
    fi
    
    # Load IPMI kernel modules
    modprobe ipmi_msghandler
    modprobe ipmi_devintf
    modprobe ipmi_si
    
    # Enable IPMI service
    systemctl enable ipmi
    systemctl start ipmi
    
    # Verify IPMI functionality
    if ipmitool mc info >/dev/null 2>&1; then
        log_message "IPMI service configured successfully"
    else
        log_message "ERROR: IPMI service configuration failed"
        return 1
    fi
}

# Advanced BMC configuration
configure_bmc() {
    local bmc_ip="$1"
    local bmc_netmask="$2"
    local bmc_gateway="$3"
    
    log_message "Configuring BMC network settings..."
    
    # Set BMC IP configuration
    ipmitool lan set "$IPMI_CHANNEL" ipsrc static
    ipmitool lan set "$IPMI_CHANNEL" ipaddr "$bmc_ip"
    ipmitool lan set "$IPMI_CHANNEL" netmask "$bmc_netmask"
    ipmitool lan set "$IPMI_CHANNEL" defgw ipaddr "$bmc_gateway"
    
    # Enable BMC network access
    ipmitool lan set "$IPMI_CHANNEL" access on
    ipmitool lan set "$IPMI_CHANNEL" arp respond on
    ipmitool lan set "$IPMI_CHANNEL" auth ADMIN MD5
    
    # Configure SOL settings
    ipmitool sol set volatile-bit-rate 115.2 "$IPMI_CHANNEL"
    ipmitool sol set non-volatile-bit-rate 115.2 "$IPMI_CHANNEL"
    ipmitool sol set payload-channel "$IPMI_CHANNEL" "$IPMI_CHANNEL"
    
    log_message "BMC configuration completed for IP: $bmc_ip"
}

# User management
configure_ipmi_users() {
    log_message "Configuring IPMI users..."
    
    # Create secure password if not exists
    if [[ ! -f "$IPMI_PASS_FILE" ]]; then
        mkdir -p "$(dirname "$IPMI_PASS_FILE")"
        openssl rand -base64 32 > "$IPMI_PASS_FILE"
        chmod 600 "$IPMI_PASS_FILE"
    fi
    
    local password=$(cat "$IPMI_PASS_FILE")
    
    # Configure admin user
    ipmitool user set name 2 "$IPMI_USER"
    ipmitool user set password 2 "$password"
    ipmitool user priv 2 4 "$IPMI_CHANNEL"  # Administrator privilege
    ipmitool user enable 2
    
    # Configure SOL access
    ipmitool sol payload enable "$IPMI_CHANNEL" 2
    
    log_message "IPMI user configuration completed"
}

# Security hardening
harden_ipmi_security() {
    log_message "Implementing IPMI security hardening..."
    
    # Disable anonymous access
    ipmitool lan set "$IPMI_CHANNEL" auth USER MD5,PASSWORD
    ipmitool lan set "$IPMI_CHANNEL" auth OPERATOR MD5,PASSWORD
    ipmitool lan set "$IPMI_CHANNEL" auth ADMIN MD5,PASSWORD
    
    # Configure cipher suites (prefer stronger encryption)
    ipmitool lan set "$IPMI_CHANNEL" cipher_privs aaaaXXaaXXaaXX
    
    # Set access restrictions
    ipmitool raw 0x06 0x40 0x01 0x82 0x84 0x00 0x00 0x00 0x00
    
    # Configure session timeout
    ipmitool raw 0x06 0x3c 0x01 0x01 0x88 0x13 0x00 0x00
    
    log_message "IPMI security hardening completed"
}

# Health monitoring setup
setup_ipmi_monitoring() {
    log_message "Setting up IPMI monitoring..."
    
    # Create monitoring script
    cat > /usr/local/bin/ipmi-health-check << 'EOF'
#!/bin/bash
# IPMI Health Monitoring Script

LOGFILE="/var/log/ipmi-health.log"
ALERT_TEMP_THRESHOLD=75
ALERT_FAN_THRESHOLD=500

log_health() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOGFILE"
}

# Check temperature sensors
check_temperatures() {
    local max_temp=0
    
    while IFS='|' read -r sensor temp status; do
        if [[ "$temp" =~ ^[0-9]+$ ]] && [[ $temp -gt $max_temp ]]; then
            max_temp=$temp
        fi
        
        if [[ $temp -gt $ALERT_TEMP_THRESHOLD ]]; then
            log_health "ALERT: High temperature detected - $sensor: ${temp}°C"
        fi
    done < <(ipmitool sensor | grep -i temp | grep -v 'na' | awk -F'|' '{print $1"|"$2"|"$3}')
    
    log_health "Temperature check completed - Max: ${max_temp}°C"
}

# Check fan speeds
check_fans() {
    while IFS='|' read -r fan speed status; do
        if [[ "$speed" =~ ^[0-9]+$ ]] && [[ $speed -lt $ALERT_FAN_THRESHOLD ]]; then
            log_health "ALERT: Low fan speed detected - $fan: ${speed} RPM"
        fi
    done < <(ipmitool sensor | grep -i fan | grep -v 'na' | awk -F'|' '{print $1"|"$2"|"$3}')
    
    log_health "Fan speed check completed"
}

# Check power supplies
check_power() {
    ipmitool sensor | grep -i "pwr\|power" | while IFS='|' read -r psu status rest; do
        if [[ "$status" != *"ok"* ]] && [[ "$status" != *"na"* ]]; then
            log_health "ALERT: Power supply issue detected - $psu: $status"
        fi
    done
    
    log_health "Power supply check completed"
}

# Execute all checks
check_temperatures
check_fans  
check_power

# Log system event log entries
ipmitool sel list | tail -10 >> "$LOGFILE"
EOF
    
    chmod +x /usr/local/bin/ipmi-health-check
    
    # Create systemd timer for regular monitoring
    cat > /etc/systemd/system/ipmi-health-check.timer << 'EOF'
[Unit]
Description=IPMI Health Check Timer
Requires=ipmi-health-check.service

[Timer]
OnCalendar=*:0/5
Persistent=true

[Install]
WantedBy=timers.target
EOF
    
    cat > /etc/systemd/system/ipmi-health-check.service << 'EOF'
[Unit]
Description=IPMI Health Check Service
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/ipmi-health-check
User=root
EOF
    
    systemctl daemon-reload
    systemctl enable ipmi-health-check.timer
    systemctl start ipmi-health-check.timer
    
    log_message "IPMI monitoring setup completed"
}

# Main execution
case "${1:-help}" in
    "setup")
        configure_ipmi_service
        ;;
    "configure-bmc")
        configure_bmc "$2" "$3" "$4"
        ;;
    "configure-users")
        configure_ipmi_users
        ;;
    "harden")
        harden_ipmi_security
        ;;
    "monitor")
        setup_ipmi_monitoring
        ;;
    "full-setup")
        configure_ipmi_service
        configure_ipmi_users
        harden_ipmi_security
        setup_ipmi_monitoring
        log_message "Full IPMI setup completed"
        ;;
    "help"|*)
        echo "Usage: $0 {setup|configure-bmc|configure-users|harden|monitor|full-setup}"
        echo ""
        echo "Commands:"
        echo "  setup                        - Install and configure IPMI service"
        echo "  configure-bmc <ip> <mask> <gw> - Configure BMC network settings"
        echo "  configure-users              - Set up IPMI user accounts"
        echo "  harden                       - Apply security hardening"
        echo "  monitor                      - Set up health monitoring"
        echo "  full-setup                   - Complete IPMI configuration"
        ;;
esac

#!/usr/bin/env python3
"""
Enterprise IPMI Management Framework
"""

import subprocess
import json
import time
import logging
from dataclasses import dataclass
from typing import List, Dict, Optional
from pathlib import Path
import paramiko
from concurrent.futures import ThreadPoolExecutor

@dataclass
class IPMIHost:
    hostname: str
    ipmi_ip: str
    username: str
    password: str
    description: str = ""
    
@dataclass
class SensorReading:
    name: str
    value: float
    unit: str
    status: str
    lower_critical: Optional[float] = None
    upper_critical: Optional[float] = None

class EnterpriseIPMIManager:
    def __init__(self, config_file: str = "/etc/ipmi/hosts.json"):
        self.config_file = Path(config_file)
        self.logger = logging.getLogger(__name__)
        self.hosts = self.load_hosts()
        
    def load_hosts(self) -> List[IPMIHost]:
        """Load IPMI host configuration"""
        try:
            with open(self.config_file, 'r') as f:
                config = json.load(f)
                
            hosts = []
            for host_config in config.get('hosts', []):
                hosts.append(IPMIHost(**host_config))
                
            return hosts
        except FileNotFoundError:
            self.logger.warning(f"Configuration file not found: {self.config_file}")
            return []
        except Exception as e:
            self.logger.error(f"Failed to load configuration: {e}")
            return []
    
    def execute_ipmi_command(self, host: IPMIHost, command: List[str], timeout: int = 30) -> Dict:
        """Execute IPMI command on remote host"""
        cmd = [
            'ipmitool', '-I', 'lanplus',
            '-H', host.ipmi_ip,
            '-U', host.username,
            '-P', host.password
        ] + command
        
        try:
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                timeout=timeout
            )
            
            return {
                'hostname': host.hostname,
                'success': result.returncode == 0,
                'stdout': result.stdout,
                'stderr': result.stderr,
                'returncode': result.returncode
            }
            
        except subprocess.TimeoutExpired:
            return {
                'hostname': host.hostname,
                'success': False,
                'error': 'Command timeout',
                'returncode': -1
            }
        except Exception as e:
            return {
                'hostname': host.hostname,
                'success': False,
                'error': str(e),
                'returncode': -1
            }
    
    def get_system_info(self, host: IPMIHost) -> Dict:
        """Get comprehensive system information"""
        commands = {
            'mc_info': ['mc', 'info'],
            'chassis_status': ['chassis', 'status'],
            'power_status': ['power', 'status'],
            'sensor_list': ['sensor', 'list'],
            'sel_list': ['sel', 'list'],
            'fru_print': ['fru', 'print'],
            'lan_print': ['lan', 'print', '1']
        }
        
        results = {}
        for cmd_name, cmd_args in commands.items():
            result = self.execute_ipmi_command(host, cmd_args)
            results[cmd_name] = result
            
        return results
    
    def parse_sensor_data(self, sensor_output: str) -> List[SensorReading]:
        """Parse IPMI sensor output into structured data"""
        sensors = []
        
        for line in sensor_output.strip().split('\n'):
            if '|' not in line:
                continue
                
            parts = [p.strip() for p in line.split('|')]
            if len(parts) < 4:
                continue
                
            try:
                name = parts[0]
                value_str = parts[1]
                unit = parts[2]
                status = parts[3]
                
                # Parse numeric value
                value = None
                if value_str and value_str != 'na':
                    try:
                        value = float(value_str)
                    except ValueError:
                        pass
                
                # Parse thresholds if available
                lower_critical = None
                upper_critical = None
                
                if len(parts) > 6:
                    try:
                        if parts[5]:
                            lower_critical = float(parts[5])
                        if parts[6]:
                            upper_critical = float(parts[6])
                    except (ValueError, IndexError):
                        pass
                
                sensors.append(SensorReading(
                    name=name,
                    value=value,
                    unit=unit,
                    status=status,
                    lower_critical=lower_critical,
                    upper_critical=upper_critical
                ))
                
            except Exception as e:
                self.logger.warning(f"Failed to parse sensor line: {line} - {e}")
                continue
        
        return sensors
    
    def check_sensor_health(self, sensors: List[SensorReading]) -> Dict:
        """Analyze sensor readings for health issues"""
        health_status = {
            'overall_status': 'OK',
            'warnings': [],
            'critical_alerts': [],
            'sensor_summary': {
                'temperature_max': 0,
                'fan_min': float('inf'),
                'power_consumption': 0
            }
        }
        
        for sensor in sensors:
            if sensor.value is None:
                continue
                
            # Temperature analysis
            if 'temp' in sensor.name.lower():
                health_status['sensor_summary']['temperature_max'] = max(
                    health_status['sensor_summary']['temperature_max'],
                    sensor.value
                )
                
                if sensor.upper_critical and sensor.value >= sensor.upper_critical:
                    health_status['critical_alerts'].append(
                        f"Critical temperature: {sensor.name} = {sensor.value}°C"
                    )
                    health_status['overall_status'] = 'CRITICAL'
                elif sensor.upper_critical and sensor.value >= sensor.upper_critical * 0.9:
                    health_status['warnings'].append(
                        f"High temperature: {sensor.name} = {sensor.value}°C"
                    )
                    if health_status['overall_status'] == 'OK':
                        health_status['overall_status'] = 'WARNING'
            
            # Fan analysis
            elif 'fan' in sensor.name.lower():
                if sensor.value > 0:
                    health_status['sensor_summary']['fan_min'] = min(
                        health_status['sensor_summary']['fan_min'],
                        sensor.value
                    )
                
                if sensor.lower_critical and sensor.value <= sensor.lower_critical:
                    health_status['critical_alerts'].append(
                        f"Critical fan speed: {sensor.name} = {sensor.value} RPM"
                    )
                    health_status['overall_status'] = 'CRITICAL'
            
            # Power analysis
            elif 'power' in sensor.name.lower() or 'watt' in sensor.unit.lower():
                health_status['sensor_summary']['power_consumption'] += sensor.value
        
        # Fix infinite fan minimum
        if health_status['sensor_summary']['fan_min'] == float('inf'):
            health_status['sensor_summary']['fan_min'] = 0
            
        return health_status
    
    def mass_power_operation(self, operation: str, host_filter: Optional[str] = None) -> Dict:
        """Perform power operations on multiple hosts"""
        valid_operations = ['on', 'off', 'reset', 'cycle', 'status']
        if operation not in valid_operations:
            raise ValueError(f"Invalid operation. Must be one of: {valid_operations}")
        
        target_hosts = self.hosts
        if host_filter:
            target_hosts = [h for h in self.hosts if host_filter in h.hostname]
        
        results = {}
        
        with ThreadPoolExecutor(max_workers=10) as executor:
            futures = {}
            
            for host in target_hosts:
                future = executor.submit(
                    self.execute_ipmi_command,
                    host,
                    ['power', operation]
                )
                futures[future] = host.hostname
            
            for future in futures:
                hostname = futures[future]
                try:
                    result = future.result(timeout=30)
                    results[hostname] = result
                except Exception as e:
                    results[hostname] = {
                        'success': False,
                        'error': str(e)
                    }
        
        return results
    
    def generate_infrastructure_report(self) -> Dict:
        """Generate comprehensive infrastructure health report"""
        report = {
            'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
            'total_hosts': len(self.hosts),
            'host_details': {},
            'summary': {
                'healthy_hosts': 0,
                'warning_hosts': 0,
                'critical_hosts': 0,
                'unreachable_hosts': 0
            }
        }
        
        with ThreadPoolExecutor(max_workers=10) as executor:
            futures = {}
            
            for host in self.hosts:
                future = executor.submit(self.get_system_info, host)
                futures[future] = host
            
            for future in futures:
                host = futures[future]
                try:
                    system_info = future.result(timeout=60)
                    
                    # Parse sensor data if available
                    health_status = {'overall_status': 'UNKNOWN'}
                    if (system_info.get('sensor_list', {}).get('success') and 
                        system_info['sensor_list']['stdout']):
                        
                        sensors = self.parse_sensor_data(system_info['sensor_list']['stdout'])
                        health_status = self.check_sensor_health(sensors)
                    
                    report['host_details'][host.hostname] = {
                        'host_info': {
                            'hostname': host.hostname,
                            'ipmi_ip': host.ipmi_ip,
                            'description': host.description
                        },
                        'system_info': system_info,
                        'health_status': health_status
                    }
                    
                    # Update summary
                    status = health_status['overall_status']
                    if status == 'OK':
                        report['summary']['healthy_hosts'] += 1
                    elif status == 'WARNING':
                        report['summary']['warning_hosts'] += 1
                    elif status == 'CRITICAL':
                        report['summary']['critical_hosts'] += 1
                    else:
                        report['summary']['unreachable_hosts'] += 1
                        
                except Exception as e:
                    self.logger.error(f"Failed to get info for {host.hostname}: {e}")
                    report['summary']['unreachable_hosts'] += 1
                    report['host_details'][host.hostname] = {
                        'error': str(e)
                    }
        
        return report

# Example configuration file
example_config = {
    "hosts": [
        {
            "hostname": "server01.example.com",
            "ipmi_ip": "10.1.1.101",
            "username": "admin",
            "password": "secure_password",
            "description": "Web server cluster node 1"
        },
        {
            "hostname": "server02.example.com", 
            "ipmi_ip": "10.1.1.102",
            "username": "admin",
            "password": "secure_password",
            "description": "Web server cluster node 2"
        },
        {
            "hostname": "db01.example.com",
            "ipmi_ip": "10.1.1.201",
            "username": "admin",
            "password": "secure_password", 
            "description": "Primary database server"
        }
    ]
}

# Usage example
if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    
    # Create example configuration
    config_dir = Path("/etc/ipmi")
    config_dir.mkdir(exist_ok=True)
    
    with open(config_dir / "hosts.json", 'w') as f:
        json.dump(example_config, f, indent=2)
    
    # Initialize manager
    ipmi_manager = EnterpriseIPMIManager()
    
    # Generate infrastructure report
    report = ipmi_manager.generate_infrastructure_report()
    
    # Save report
    with open('/tmp/infrastructure_report.json', 'w') as f:
        json.dump(report, f, indent=2)
    
    print("Infrastructure report generated: /tmp/infrastructure_report.json")
    print(f"Summary: {report['summary']}")

#!/bin/bash
# Enterprise GRUB Serial Console Configuration

configure_grub_serial() {
    local baud_rate="${1:-115200}"
    local serial_port="${2:-0}"
    local grub_config="/etc/default/grub"
    
    echo "Configuring GRUB for serial console..."
    echo "Baud rate: $baud_rate"
    echo "Serial port: ttyS$serial_port"
    
    # Backup existing configuration
    cp "$grub_config" "${grub_config}.backup.$(date +%Y%m%d_%H%M%S)"
    
    # Remove existing serial configuration
    sed -i '/^GRUB_CMDLINE_LINUX.*console=/d' "$grub_config"
    sed -i '/^GRUB_TERMINAL/d' "$grub_config"
    sed -i '/^GRUB_SERIAL_COMMAND/d' "$grub_config"
    
    # Add new serial configuration
    cat >> "$grub_config" << EOF

# Serial console configuration
GRUB_CMDLINE_LINUX="console=tty0 console=ttyS${serial_port},${baud_rate}n8"
GRUB_TERMINAL="console serial"
GRUB_SERIAL_COMMAND="serial --speed=${baud_rate} --unit=${serial_port} --word=8 --parity=no --stop=1"

# Timeout configuration for remote access
GRUB_TIMEOUT=10
GRUB_TIMEOUT_STYLE=menu
EOF
    
    # Update GRUB configuration
    update-grub
    
    # Update initramfs to include serial support
    update-initramfs -u
    
    echo "GRUB serial console configuration completed"
    echo "Reboot required to activate changes"
}

# Advanced GRUB menu customization
create_advanced_grub_menu() {
    cat > /etc/grub.d/40_custom << 'EOF'
#!/bin/sh
exec tail -n +3 $0
# Advanced GRUB menu entries

# Recovery mode with serial console
menuentry 'Recovery Mode (Serial Console)' {
    load_video
    gfxmode $linux_gfx_mode
    insmod gzio
    insmod part_gpt
    insmod ext2
    set root='hd0,gpt2'
    linux /boot/vmlinuz root=UUID=xxx ro recovery nomodeset console=ttyS0,115200n8
    initrd /boot/initrd.img
}

# Single user mode
menuentry 'Single User Mode (Serial)' {
    load_video
    gfxmode $linux_gfx_mode
    insmod gzio
    insmod part_gpt
    insmod ext2
    set root='hd0,gpt2'
    linux /boot/vmlinuz root=UUID=xxx ro single console=ttyS0,115200n8
    initrd /boot/initrd.img
}

# Memory test with serial output
menuentry 'Memory Test (Serial)' {
    linux16 /boot/memtest86+.bin console=ttyS0,115200n8
}

# Network boot option
menuentry 'Network Boot (PXE)' {
    insmod net
    insmod efinet
    insmod tftp
    net_bootp
    chainloader (tftp)/pxelinux.0
}
EOF
    
    chmod +x /etc/grub.d/40_custom
    update-grub
}

# UEFI-specific configuration
configure_uefi_serial() {
    local efi_dir="/boot/efi/EFI/ubuntu"
    
    if [[ -d "$efi_dir" ]]; then
        echo "Configuring UEFI for serial console..."
        
        # Create UEFI serial configuration
        cat > "$efi_dir/serial.cfg" << 'EOF'
# UEFI Serial Console Configuration
serial --speed=115200 --unit=0 --word=8 --parity=no --stop=1
terminal_input --append serial
terminal_output --append serial
EOF
        
        # Update GRUB EFI configuration
        grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=ubuntu
        
        echo "UEFI serial console configuration completed"
    else
        echo "UEFI directory not found, skipping UEFI configuration"
    fi
}

# Execute configuration
case "${1:-help}" in
    "configure")
        configure_grub_serial "$2" "$3"
        ;;
    "advanced-menu")
        create_advanced_grub_menu
        ;;
    "uefi")
        configure_uefi_serial
        ;;
    "full")
        configure_grub_serial "$2" "$3"
        create_advanced_grub_menu
        configure_uefi_serial
        ;;
    *)
        echo "Usage: $0 {configure|advanced-menu|uefi|full} [baud_rate] [serial_port]"
        echo "Example: $0 configure 115200 0"
        ;;
esac

# /etc/systemd/system/serial-getty@ttyS0.service.d/override.conf
[Service]
# High baud rate for modern systems
ExecStart=
ExecStart=-/sbin/agetty -8 -L %i 115200 $TERM
Restart=always
RestartSec=0

# Security enhancements
NoNewPrivileges=true
PrivateTmp=true
ProtectHome=true
ProtectSystem=strict

# Performance optimization
StandardInput=tty
StandardOutput=inherit
StandardError=inherit
TTYPath=/dev/%i
TTYReset=yes
TTYVHangup=yes
TTYVTDisallocate=yes

#!/bin/bash
# Kernel parameter optimization for serial console

optimize_kernel_params() {
    local grub_config="/etc/default/grub"
    
    # Advanced kernel parameters for serial console
    local kernel_params=(
        "console=tty0"
        "console=ttyS0,115200n8"
        "earlycon=uart8250,io,0x3f8,115200n8"
        "ignore_loglevel"
        "no_console_suspend"
        "printk.devkmsg=on"
        "systemd.log_color=false"
        "systemd.log_level=info"
        "systemd.log_target=console"
    )
    
    # Join parameters
    local param_string=$(IFS=' '; echo "${kernel_params[*]}")
    
    # Update GRUB configuration
    sed -i "s/^GRUB_CMDLINE_LINUX=.*/GRUB_CMDLINE_LINUX=\"$param_string\"/" "$grub_config"
    
    # Additional optimizations
    cat >> "$grub_config" << 'EOF'

# Performance optimizations
GRUB_RECORDFAIL_TIMEOUT=5
GRUB_HIDDEN_TIMEOUT=0
GRUB_HIDDEN_TIMEOUT_QUIET=true

# Serial-specific optimizations
GRUB_GFXPAYLOAD_LINUX=text
GRUB_DISABLE_LINUX_UUID=false
EOF
    
    update-grub
    update-initramfs -u
    
    echo "Kernel parameters optimized for serial console"
}

# systemd-networkd integration for remote management
configure_network_console() {
    cat > /etc/systemd/system/network-console.service << 'EOF'
[Unit]
Description=Network Console Access
After=network.target
Wants=network.target

[Service]
Type=forking
ExecStart=/usr/sbin/in.telnetd -L /bin/login
Restart=always
RestartSec=5

# Security restrictions
User=nobody
Group=nogroup
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF
    
    # Enable but don't start (security consideration)
    systemctl enable network-console.service
    
    echo "Network console service configured (not started for security)"
}

optimize_kernel_params
configure_network_console

#!/usr/bin/env python3
"""
IPMI Metrics Exporter for Prometheus
"""

from prometheus_client import start_http_server, Gauge, Info, Counter
import subprocess
import time
import json
import re
from pathlib import Path

class IPMIMetricsExporter:
    def __init__(self, port=9290, config_file="/etc/ipmi/hosts.json"):
        self.port = port
        self.config_file = Path(config_file)
        
        # Define metrics
        self.ipmi_up = Gauge('ipmi_up', 'IPMI connectivity status', ['hostname', 'ipmi_ip'])
        self.temperature = Gauge('ipmi_temperature_celsius', 'Temperature in Celsius', 
                               ['hostname', 'sensor_name'])
        self.fan_speed = Gauge('ipmi_fan_speed_rpm', 'Fan speed in RPM', 
                             ['hostname', 'sensor_name'])
        self.power_consumption = Gauge('ipmi_power_watts', 'Power consumption in Watts',
                                     ['hostname', 'sensor_name'])
        self.voltage = Gauge('ipmi_voltage_volts', 'Voltage readings', 
                           ['hostname', 'sensor_name'])
        
        # System info
        self.system_info = Info('ipmi_system_info', 'IPMI system information',
                              ['hostname', 'ipmi_ip'])
        
        # Counters
        self.sel_entries = Counter('ipmi_sel_entries_total', 'Total SEL entries',
                                 ['hostname', 'severity'])
        
        self.hosts = self.load_hosts()
    
    def load_hosts(self):
        """Load host configuration"""
        try:
            with open(self.config_file, 'r') as f:
                config = json.load(f)
            return config.get('hosts', [])
        except Exception as e:
            print(f"Failed to load config: {e}")
            return []
    
    def execute_ipmi_command(self, host_config, command):
        """Execute IPMI command"""
        cmd = [
            'ipmitool', '-I', 'lanplus',
            '-H', host_config['ipmi_ip'],
            '-U', host_config['username'],
            '-P', host_config['password']
        ] + command
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            return result.returncode == 0, result.stdout, result.stderr
        except subprocess.TimeoutExpired:
            return False, "", "Timeout"
        except Exception as e:
            return False, "", str(e)
    
    def parse_sensor_output(self, output):
        """Parse IPMI sensor output"""
        sensors = {'temperature': {}, 'fan': {}, 'power': {}, 'voltage': {}}
        
        for line in output.strip().split('\n'):
            if '|' not in line:
                continue
                
            parts = [p.strip() for p in line.split('|')]
            if len(parts) < 4:
                continue
            
            sensor_name = parts[0]
            value_str = parts[1]
            unit = parts[2]
            status = parts[3]
            
            if value_str == 'na' or not value_str:
                continue
                
            try:
                value = float(value_str)
            except ValueError:
                continue
            
            # Categorize sensors
            sensor_lower = sensor_name.lower()
            if 'temp' in sensor_lower:
                sensors['temperature'][sensor_name] = value
            elif 'fan' in sensor_lower:
                sensors['fan'][sensor_name] = value
            elif 'power' in sensor_lower or 'watt' in unit.lower():
                sensors['power'][sensor_name] = value
            elif 'volt' in unit.lower():
                sensors['voltage'][sensor_name] = value
        
        return sensors
    
    def collect_metrics_for_host(self, host_config):
        """Collect metrics for a single host"""
        hostname = host_config['hostname']
        ipmi_ip = host_config['ipmi_ip']
        
        # Test connectivity
        success, output, error = self.execute_ipmi_command(host_config, ['mc', 'info'])
        self.ipmi_up.labels(hostname=hostname, ipmi_ip=ipmi_ip).set(1 if success else 0)
        
        if not success:
            return
        
        # Get system info
        try:
            system_info = {}
            for line in output.split('\n'):
                if ':' in line:
                    key, value = line.split(':', 1)
                    system_info[key.strip()] = value.strip()
            
            self.system_info.labels(hostname=hostname, ipmi_ip=ipmi_ip).info(system_info)
        except Exception as e:
            print(f"Failed to parse system info for {hostname}: {e}")
        
        # Get sensor data
        success, sensor_output, error = self.execute_ipmi_command(host_config, ['sensor', 'list'])
        if success:
            sensors = self.parse_sensor_output(sensor_output)
            
            # Update temperature metrics
            for sensor_name, value in sensors['temperature'].items():
                self.temperature.labels(hostname=hostname, sensor_name=sensor_name).set(value)
            
            # Update fan metrics
            for sensor_name, value in sensors['fan'].items():
                self.fan_speed.labels(hostname=hostname, sensor_name=sensor_name).set(value)
            
            # Update power metrics
            for sensor_name, value in sensors['power'].items():
                self.power_consumption.labels(hostname=hostname, sensor_name=sensor_name).set(value)
            
            # Update voltage metrics
            for sensor_name, value in sensors['voltage'].items():
                self.voltage.labels(hostname=hostname, sensor_name=sensor_name).set(value)
        
        # Get SEL data
        success, sel_output, error = self.execute_ipmi_command(host_config, ['sel', 'list'])
        if success:
            for line in sel_output.split('\n'):
                if '|' in line:
                    parts = line.split('|')
                    if len(parts) >= 6:
                        severity = parts[5].strip().lower()
                        if severity in ['critical', 'warning', 'informational']:
                            self.sel_entries.labels(hostname=hostname, severity=severity).inc()
    
    def collect_all_metrics(self):
        """Collect metrics from all configured hosts"""
        for host_config in self.hosts:
            try:
                self.collect_metrics_for_host(host_config)
            except Exception as e:
                print(f"Failed to collect metrics for {host_config['hostname']}: {e}")
    
    def start_server(self):
        """Start Prometheus metrics server"""
        start_http_server(self.port)
        print(f"IPMI metrics server started on port {self.port}")
        
        while True:
            try:
                self.collect_all_metrics()
            except Exception as e:
                print(f"Error during metrics collection: {e}")
            
            time.sleep(60)  # Collect every minute

if __name__ == "__main__":
    exporter = IPMIMetricsExporter()
    exporter.start_server()

{
  "dashboard": {
    "title": "Enterprise IPMI Infrastructure Monitoring",
    "panels": [
      {
        "title": "IPMI Connectivity Status",
        "type": "stat",
        "targets": [
          {
            "expr": "ipmi_up",
            "legendFormat": "{{hostname}}"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "thresholds": {
              "steps": [
                {"color": "red", "value": 0},
                {"color": "green", "value": 1}
              ]
            }
          }
        }
      },
      {
        "title": "Temperature Monitoring", 
        "type": "graph",
        "targets": [
          {
            "expr": "ipmi_temperature_celsius",
            "legendFormat": "{{hostname}} - {{sensor_name}}"
          }
        ],
        "yAxes": [
          {
            "label": "Temperature (°C)",
            "min": 0,
            "max": 100
          }
        ],
        "alert": {
          "conditions": [
            {
              "query": {"params": ["A", "5m", "now"]},
              "reducer": {"type": "avg"},
              "evaluator": {"params": [75], "type": "gt"}
            }
          ],
          "executionErrorState": "alerting",
          "noDataState": "no_data",
          "frequency": "10s"
        }
      },
      {
        "title": "Fan Speed Monitoring",
        "type": "graph", 
        "targets": [
          {
            "expr": "ipmi_fan_speed_rpm",
            "legendFormat": "{{hostname}} - {{sensor_name}}"
          }
        ],
        "yAxes": [
          {
            "label": "RPM",
            "min": 0
          }
        ]
      },
      {
        "title": "Power Consumption",
        "type": "graph",
        "targets": [
          {
            "expr": "ipmi_power_watts",
            "legendFormat": "{{hostname}} - {{sensor_name}}"
          }
        ],
        "yAxes": [
          {
            "label": "Watts",
            "min": 0
          }
        ]
      },
      {
        "title": "System Event Log Entries",
        "type": "graph",
        "targets": [
          {
            "expr": "increase(ipmi_sel_entries_total[1h])",
            "legendFormat": "{{hostname}} - {{severity}}"
          }
        ]
      }
    ],
    "time": {
      "from": "now-1h",
      "to": "now"
    },
    "refresh": "30s"
  }
}