bmctools 0.1.0__py3-none-any.whl

bmctools/cli/__init__.py

@@ -0,0 +1,3 @@
+"""BMCTools CLI module."""
+
+__version__ = '0.1.0'

bmctools/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command handlers."""

bmctools/cli/commands/common.py

@@ -0,0 +1,138 @@
+"""Common command utilities shared across all commands."""
+
+import sys
+from bmctools.cli.formatters import format_output
+from bmctools.cli.utils import (
+    handle_error,
+    get_exit_code,
+    print_verbose,
+    print_success
+)
+
+
+def wrap_command(func, args):
+    """Wrap command execution with common error handling.
+
+    Args:
+        func: Command function to execute
+        args: Parsed arguments
+
+    Returns:
+        Exit code (0 for success, non-zero for error)
+    """
+    try:
+        result = func(args)
+        if result is not None:
+            output = format_output(result, args.output)
+            print(output)
+        return 0
+    except Exception as e:
+        handle_error(e, args)
+        return get_exit_code(e)
+
+
+def read_file_lines(file_path):
+    """Read lines from a file.
+
+    Args:
+        file_path: Path to file
+
+    Returns:
+        List of lines (stripped of whitespace)
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+    """
+    try:
+        with open(file_path, 'r') as f:
+            lines = [line.strip() for line in f if line.strip()]
+        return lines
+    except FileNotFoundError:
+        raise FileNotFoundError(f"File not found: {file_path}")
+    except Exception as e:
+        raise ValueError(f"Failed to read file {file_path}: {e}")
+
+
+def parse_comma_list(value):
+    """Parse comma-separated list.
+
+    Args:
+        value: Comma-separated string
+
+    Returns:
+        List of strings
+    """
+    if not value:
+        return []
+    return [item.strip() for item in value.split(',') if item.strip()]
+
+
+def confirm_action(prompt, force=False):
+    """Prompt user for confirmation on destructive operations.
+
+    Args:
+        prompt: Confirmation prompt message
+        force: If True, skip confirmation and return True
+
+    Returns:
+        True if confirmed, False otherwise
+    """
+    if force:
+        return True
+
+    try:
+        response = input(f"{prompt} [y/N]: ").strip().lower()
+        return response in ('y', 'yes')
+    except (KeyboardInterrupt, EOFError):
+        print()  # New line after interrupt
+        return False
+
+
+def show_progress(message, done=False):
+    """Display progress indicator.
+
+    Args:
+        message: Progress message
+        done: If True, show completion, else show in-progress
+    """
+    if done:
+        print(f"✓ {message}", file=sys.stderr)
+    else:
+        print(f"⋯ {message}...", file=sys.stderr, end='', flush=True)
+
+
+def validate_file_exists(file_path):
+    """Validate that a file exists.
+
+    Args:
+        file_path: Path to file
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+    """
+    import os
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+    if not os.path.isfile(file_path):
+        raise ValueError(f"Not a file: {file_path}")
+
+
+def parse_key_value_pairs(pairs):
+    """Parse key=value pairs from list of strings.
+
+    Args:
+        pairs: List of "key=value" strings
+
+    Returns:
+        Dict of key-value pairs
+
+    Raises:
+        ValueError: If format is invalid
+    """
+    result = {}
+    for pair in pairs:
+        if '=' not in pair:
+            raise ValueError(f"Invalid key=value format: {pair}")
+        key, value = pair.split('=', 1)
+        result[key.strip()] = value.strip()
+    return result

bmctools/cli/commands/ipmi.py

@@ -0,0 +1,292 @@
+"""IPMI command handlers."""
+
+import sys
+from bmctools.cli.utils import (
+    establish_ipmi_connection,
+    print_verbose,
+)
+from bmctools.cli.commands.common import wrap_command
+
+
+def setup_ipmi_commands(parser):
+    """Setup IPMI subcommands.
+
+    Args:
+        parser: IPMI subparser
+    """
+    subparsers = parser.add_subparsers(dest='ipmi_group', help='IPMI operation group')
+
+    # Power management commands
+    power_parser = subparsers.add_parser('power', help='Power management')
+    setup_power_commands(power_parser)
+
+    # BMC management commands
+    bmc_parser = subparsers.add_parser('bmc', help='BMC management')
+    setup_bmc_commands(bmc_parser)
+
+    # SEL commands
+    sel_parser = subparsers.add_parser('sel', help='System Event Log')
+    setup_sel_commands(sel_parser)
+
+    # SOL commands
+    sol_parser = subparsers.add_parser('sol', help='Serial Over LAN')
+    setup_sol_commands(sol_parser)
+
+    # Raw command
+    raw_parser = subparsers.add_parser('raw', help='Execute raw IPMI command')
+    raw_parser.add_argument('command', help='Raw IPMI command')
+
+
+def setup_power_commands(parser):
+    """Setup power management subcommands."""
+    subparsers = parser.add_subparsers(dest='power_action', help='Power action')
+
+    subparsers.add_parser('status', help='Get power status')
+    subparsers.add_parser('on', help='Power on system')
+    subparsers.add_parser('off', help='Power off system')
+    subparsers.add_parser('reset', help='Hard reset system')
+
+
+def setup_bmc_commands(parser):
+    """Setup BMC management subcommands."""
+    subparsers = parser.add_subparsers(dest='bmc_action', help='BMC action')
+
+    subparsers.add_parser('reset-warm', help='Warm reset BMC')
+    subparsers.add_parser('reset-cold', help='Cold reset BMC')
+
+
+def setup_sel_commands(parser):
+    """Setup SEL subcommands."""
+    subparsers = parser.add_subparsers(dest='sel_action', help='SEL action')
+
+    p = subparsers.add_parser('list', help='List system event log')
+    p.add_argument('--elist', action='store_true',
+                  help='Use extended list format')
+    p.add_argument('--raw', action='store_true',
+                  help='Show raw data')
+    p.add_argument('--age',
+                  help='Filter by age (e.g., 7d, 24h)')
+
+
+def setup_sol_commands(parser):
+    """Setup SOL subcommands."""
+    subparsers = parser.add_subparsers(dest='sol_action', help='SOL action')
+
+    subparsers.add_parser('deactivate', help='Deactivate Serial Over LAN')
+
+    p = subparsers.add_parser('looptest', help='Run SOL loopback test')
+    p.add_argument('--loops', type=int, default=10,
+                  help='Number of loops (default: 10)')
+
+
+# Power Management Handlers
+
+def handle_power_status(args):
+    """Handle 'ipmi power status' command."""
+    ipmi = establish_ipmi_connection(args)
+    status = ipmi.power_status()
+    return {'power_status': status}
+
+
+def handle_power_on(args):
+    """Handle 'ipmi power on' command."""
+    ipmi = establish_ipmi_connection(args)
+    print_verbose("Powering on system...", args)
+    result = ipmi.power_on()
+    return {'message': 'Power on command sent', 'result': result}
+
+
+def handle_power_off(args):
+    """Handle 'ipmi power off' command."""
+    ipmi = establish_ipmi_connection(args)
+    print_verbose("Powering off system...", args)
+    result = ipmi.power_off()
+    return {'message': 'Power off command sent', 'result': result}
+
+
+def handle_power_reset(args):
+    """Handle 'ipmi power reset' command."""
+    ipmi = establish_ipmi_connection(args)
+    print_verbose("Resetting system...", args)
+    result = ipmi.power_reset()
+    return {'message': 'Power reset command sent', 'result': result}
+
+
+# BMC Management Handlers
+
+def handle_bmc_reset_warm(args):
+    """Handle 'ipmi bmc reset-warm' command."""
+    ipmi = establish_ipmi_connection(args)
+    print_verbose("Performing warm reset of BMC...", args)
+    result = ipmi.bmc_reset_warm()
+    return {'message': 'BMC warm reset command sent', 'result': result}
+
+
+def handle_bmc_reset_cold(args):
+    """Handle 'ipmi bmc reset-cold' command."""
+    ipmi = establish_ipmi_connection(args)
+    print_verbose("Performing cold reset of BMC...", args)
+    result = ipmi.bmc_reset_cold()
+    return {'message': 'BMC cold reset command sent', 'result': result}
+
+
+# SEL Handlers
+
+def handle_sel_list(args):
+    """Handle 'ipmi sel list' command."""
+    ipmi = establish_ipmi_connection(args)
+
+    elist = getattr(args, 'elist', False)
+    raw = getattr(args, 'raw', False)
+    age = getattr(args, 'age', None)
+
+    print_verbose(f"Fetching SEL (elist={elist}, raw={raw}, age={age})...", args)
+
+    result = ipmi.sel_list(elist=elist, raw=raw, age=age)
+
+    return {'sel_entries': result}
+
+
+# SOL Handlers
+
+def handle_sol_deactivate(args):
+    """Handle 'ipmi sol deactivate' command."""
+    ipmi = establish_ipmi_connection(args)
+    print_verbose("Deactivating Serial Over LAN...", args)
+    result = ipmi.sol_deactivate()
+    return {'message': 'SOL deactivate command sent', 'result': result}
+
+
+def handle_sol_looptest(args):
+    """Handle 'ipmi sol looptest' command."""
+    ipmi = establish_ipmi_connection(args)
+    loops = getattr(args, 'loops', 10)
+
+    print_verbose(f"Running SOL loopback test ({loops} loops)...", args)
+
+    result = ipmi.sol_looptest(num_loops=loops)
+
+    return {'message': f'SOL loopback test completed', 'result': result}
+
+
+# Raw Command Handler
+
+def handle_raw(args):
+    """Handle 'ipmi raw' command."""
+    ipmi = establish_ipmi_connection(args)
+
+    print_verbose(f"Executing raw IPMI command: {args.command}", args)
+
+    result = ipmi.ipmitool_command(args.command)
+
+    return {'command': args.command, 'result': result}
+
+
+# Dispatch Functions
+
+def dispatch(args):
+    """Dispatch IPMI command to appropriate handler.
+
+    Args:
+        args: Parsed arguments
+
+    Returns:
+        Exit code
+    """
+    group = args.ipmi_group
+
+    if group == 'power':
+        return dispatch_power(args)
+    elif group == 'bmc':
+        return dispatch_bmc(args)
+    elif group == 'sel':
+        return dispatch_sel(args)
+    elif group == 'sol':
+        return dispatch_sol(args)
+    elif group == 'raw':
+        return wrap_command(handle_raw, args)
+    else:
+        print(f"Error: Unknown IPMI group: {group}", file=sys.stderr)
+        return 1
+
+
+def dispatch_power(args):
+    """Dispatch power command."""
+    action = args.power_action
+    handlers = {
+        'status': handle_power_status,
+        'on': handle_power_on,
+        'off': handle_power_off,
+        'reset': handle_power_reset,
+    }
+
+    if action in handlers:
+        return wrap_command(handlers[action], args)
+    else:
+        print(f"Error: Unknown power action: {action}", file=sys.stderr)
+        return 1
+
+
+def dispatch_bmc(args):
+    """Dispatch BMC command."""
+    action = args.bmc_action
+    handlers = {
+        'reset-warm': handle_bmc_reset_warm,
+        'reset-cold': handle_bmc_reset_cold,
+    }
+
+    if action in handlers:
+        return wrap_command(handlers[action], args)
+    else:
+        print(f"Error: Unknown BMC action: {action}", file=sys.stderr)
+        return 1
+
+
+def dispatch_sel(args):
+    """Dispatch SEL command."""
+    action = args.sel_action
+    handlers = {
+        'list': handle_sel_list,
+    }
+
+    if action in handlers:
+        return wrap_command(handlers[action], args)
+    else:
+        print(f"Error: Unknown SEL action: {action}", file=sys.stderr)
+        return 1
+
+
+def dispatch_sol(args):
+    """Dispatch SOL command."""
+    action = args.sol_action
+    handlers = {
+        'deactivate': handle_sol_deactivate,
+        'looptest': handle_sol_looptest,
+    }
+
+    if action in handlers:
+        return wrap_command(handlers[action], args)
+    else:
+        print(f"Error: Unknown SOL action: {action}", file=sys.stderr)
+        return 1
+
+
+def handle_alias(args, target):
+    """Handle aliased commands.
+
+    Args:
+        args: Parsed arguments
+        target: Alias target identifier
+
+    Returns:
+        Exit code
+    """
+    if target == 'ipmi_power_on':
+        return wrap_command(handle_power_on, args)
+    elif target == 'ipmi_power_off':
+        return wrap_command(handle_power_off, args)
+    elif target == 'ipmi_power_status':
+        return wrap_command(handle_power_status, args)
+    else:
+        print(f"Error: Unknown IPMI alias: {target}", file=sys.stderr)
+        return 1

bmctools/cli/commands/racadm.py

@@ -0,0 +1,266 @@
+"""RACADM command handlers."""
+
+import sys
+from bmctools.cli.utils import (
+    establish_racadm_connection,
+    print_verbose,
+)
+from bmctools.cli.commands.common import wrap_command
+
+
+def setup_racadm_commands(parser):
+    """Setup RACADM subcommands.
+
+    Args:
+        parser: RACADM subparser
+    """
+    subparsers = parser.add_subparsers(dest='racadm_group', help='RACADM operation group')
+
+    # Get configuration
+    p = subparsers.add_parser('get', help='Get configuration')
+    p.add_argument('endpoint', help='Configuration endpoint')
+    p.add_argument('--format', action='store_true',
+                  help='Use formatted output')
+
+    # Set configuration
+    p = subparsers.add_parser('set', help='Set configuration')
+    p.add_argument('endpoint', help='Configuration endpoint')
+    p.add_argument('--args',
+                  help='Comma-separated arguments')
+
+    # Storage commands
+    storage_parser = subparsers.add_parser('storage', help='Storage management')
+    setup_storage_commands(storage_parser)
+
+    # Job queue commands
+    job_parser = subparsers.add_parser('job', help='Job queue management')
+    setup_job_commands(job_parser)
+
+
+def setup_storage_commands(parser):
+    """Setup storage subcommands."""
+    subparsers = parser.add_subparsers(dest='storage_action', help='Storage action')
+
+    p = subparsers.add_parser('get', help='Get storage configuration')
+    p.add_argument('endpoint', help='Storage endpoint')
+
+    p = subparsers.add_parser('check-vdisk', help='Check virtual disks')
+    p.add_argument('--format', action='store_true',
+                  help='Use formatted output')
+
+
+def setup_job_commands(parser):
+    """Setup job queue subcommands."""
+    subparsers = parser.add_subparsers(dest='job_action', help='Job action')
+
+    p = subparsers.add_parser('view', help='View job details')
+    p.add_argument('-j', '--job-id', required=True,
+                  help='Job ID')
+
+    p = subparsers.add_parser('status', help='Get job status')
+    p.add_argument('-j', '--job-id', required=True,
+                  help='Job ID')
+
+    p = subparsers.add_parser('wait', help='Wait for job completion')
+    p.add_argument('-j', '--job-id', required=True,
+                  help='Job ID')
+    p.add_argument('--timeout', type=int, default=300,
+                  help='Timeout in seconds (default: 300)')
+
+
+# Configuration Handlers
+
+def handle_get(args):
+    """Handle 'racadm get' command."""
+    racadm = establish_racadm_connection(args)
+
+    use_format = getattr(args, 'format', False)
+
+    print_verbose(f"Getting config: {args.endpoint} (format={use_format})", args)
+
+    result = racadm.get(
+        endpoint=args.endpoint,
+        arguments=None,
+        format=use_format
+    )
+
+    return {
+        'endpoint': args.endpoint,
+        'result': result
+    }
+
+
+def handle_set(args):
+    """Handle 'racadm set' command."""
+    racadm = establish_racadm_connection(args)
+
+    # Parse arguments
+    arguments = None
+    if args.args:
+        arguments = [arg.strip() for arg in args.args.split(',')]
+
+    print_verbose(f"Setting config: {args.endpoint} (args={arguments})", args)
+
+    result = racadm.set(
+        endpoint=args.endpoint,
+        arguments=arguments
+    )
+
+    return {
+        'endpoint': args.endpoint,
+        'arguments': arguments,
+        'result': result
+    }
+
+
+# Storage Handlers
+
+def handle_storage_get(args):
+    """Handle 'racadm storage get' command."""
+    racadm = establish_racadm_connection(args)
+
+    print_verbose(f"Getting storage config: {args.endpoint}", args)
+
+    result = racadm.storage_get(
+        endpoint=args.endpoint,
+        arguments=None
+    )
+
+    return {
+        'endpoint': args.endpoint,
+        'result': result
+    }
+
+
+def handle_storage_check_vdisk(args):
+    """Handle 'racadm storage check-vdisk' command."""
+    racadm = establish_racadm_connection(args)
+
+    use_format = getattr(args, 'format', False)
+
+    print_verbose(f"Checking virtual disks (format={use_format})", args)
+
+    result = racadm.check_vdisk(format=use_format)
+
+    return {
+        'result': result
+    }
+
+
+# Job Queue Handlers
+
+def handle_job_view(args):
+    """Handle 'racadm job view' command."""
+    racadm = establish_racadm_connection(args)
+
+    print_verbose(f"Viewing job: {args.job_id}", args)
+
+    result = racadm.jobqueue_view(job=args.job_id)
+
+    return {
+        'job_id': args.job_id,
+        'details': result
+    }
+
+
+def handle_job_status(args):
+    """Handle 'racadm job status' command."""
+    racadm = establish_racadm_connection(args)
+
+    print_verbose(f"Getting job status: {args.job_id}", args)
+
+    result = racadm.jobqueue_status(job=args.job_id)
+
+    return {
+        'job_id': args.job_id,
+        'status': result
+    }
+
+
+def handle_job_wait(args):
+    """Handle 'racadm job wait' command."""
+    racadm = establish_racadm_connection(args)
+
+    timeout = getattr(args, 'timeout', 300)
+
+    print_verbose(f"Waiting for job completion: {args.job_id} (timeout={timeout}s)", args)
+
+    result = racadm.jobqueue_wait(job=args.job_id)
+
+    return {
+        'job_id': args.job_id,
+        'completed': True,
+        'result': result
+    }
+
+
+# Dispatch Functions
+
+def dispatch(args):
+    """Dispatch RACADM command to appropriate handler.
+
+    Args:
+        args: Parsed arguments
+
+    Returns:
+        Exit code
+    """
+    group = args.racadm_group
+
+    if group == 'get':
+        return wrap_command(handle_get, args)
+    elif group == 'set':
+        return wrap_command(handle_set, args)
+    elif group == 'storage':
+        return dispatch_storage(args)
+    elif group == 'job':
+        return dispatch_job(args)
+    else:
+        print(f"Error: Unknown RACADM group: {group}", file=sys.stderr)
+        return 1
+
+
+def dispatch_storage(args):
+    """Dispatch storage command."""
+    action = args.storage_action
+    handlers = {
+        'get': handle_storage_get,
+        'check-vdisk': handle_storage_check_vdisk,
+    }
+
+    if action in handlers:
+        return wrap_command(handlers[action], args)
+    else:
+        print(f"Error: Unknown storage action: {action}", file=sys.stderr)
+        return 1
+
+
+def dispatch_job(args):
+    """Dispatch job queue command."""
+    action = args.job_action
+    handlers = {
+        'view': handle_job_view,
+        'status': handle_job_status,
+        'wait': handle_job_wait,
+    }
+
+    if action in handlers:
+        return wrap_command(handlers[action], args)
+    else:
+        print(f"Error: Unknown job action: {action}", file=sys.stderr)
+        return 1
+
+
+def handle_alias(args, target):
+    """Handle aliased commands.
+
+    Args:
+        args: Parsed arguments
+        target: Alias target identifier
+
+    Returns:
+        Exit code
+    """
+    # No RACADM aliases currently defined
+    print(f"Error: Unknown RACADM alias: {target}", file=sys.stderr)
+    return 1