#!/usr/bin/env python3
# -*- coding: utf-8; py-indent-offset: 4 -*-
#
# Author:  Linuxfabrik GmbH, Zurich, Switzerland
# Contact: info (at) linuxfabrik (dot) ch
#          https://www.linuxfabrik.ch/
# License: The Unlicense, see LICENSE file.

# https://github.com/Linuxfabrik/monitoring-plugins/blob/main/CONTRIBUTING.md

"""See the check's README for more details."""

import argparse
import json
import os
import sys

import lib.args
import lib.base
import lib.lftest
import lib.redfish
import lib.txt
import lib.url
from lib.globals import STATE_CRIT, STATE_OK, STATE_UNKNOWN, STATE_WARN

__author__ = 'Linuxfabrik GmbH, Zurich/Switzerland'
__version__ = '2026060706'

DESCRIPTION = """Checks the state of all processors (CPUs) in a Redfish-compatible server via the
Redfish API. Alerts when any processor reports a degraded or failed state. System-level health
(memory, storage, power, temperature, indicator LED, etc.) is deliberately ignored by this check
so that a system warning unrelated to processors does not mask the processor status; use
`redfish-systems` for that."""

API_BASE = '/redfish/v1'
DEFAULT_CACHE_EXPIRE = 15  # minutes; keep below the controller's session timeout
DEFAULT_INSECURE = True
DEFAULT_NO_PROXY = False
DEFAULT_RETRIES = 3  # extra attempts on a failed Redfish request
DEFAULT_TIMEOUT = 8
DEFAULT_URL = 'https://localhost:5000'


def parse_args():
    """Parse command line arguments using argparse."""
    parser = argparse.ArgumentParser(description=DESCRIPTION)

    parser.add_argument(
        '-V',
        '--version',
        action='version',
        version=f'%(prog)s: v{__version__} by {__author__}',
    )

    parser.add_argument(
        '--always-ok',
        help=lib.args.help('--always-ok'),
        dest='ALWAYS_OK',
        action='store_true',
        default=False,
    )

    parser.add_argument(
        '--brief',
        help='Hide items that are OK and show only those in WARN/CRIT state. '
        'Alerting is unaffected: all items still drive the overall check state. '
        'Default: %(default)s',
        dest='BRIEF',
        action='store_true',
        default=False,
    )

    parser.add_argument(
        '--cache-expire',
        help=lib.args.help('--cache-expire') + ' Default: %(default)s',
        dest='CACHE_EXPIRE',
        type=int,
        default=DEFAULT_CACHE_EXPIRE,
    )

    parser.add_argument(
        '--ignore',
        help='Ignore items whose name matches this Python regular expression. '
        'Case-sensitive by default; use `(?i)` for case-insensitive matching. '
        'Can be specified multiple times.',
        dest='IGNORE',
        action='append',
        default=None,
    )

    parser.add_argument(
        '--insecure',
        help=lib.args.help('--insecure'),
        dest='INSECURE',
        action='store_true',
        default=DEFAULT_INSECURE,
    )

    parser.add_argument(
        '--inventory',
        help='Output the parsed components as JSON on stdout and exit OK, instead of '
        'running a health check. Use this to collect a hardware inventory: the JSON is a '
        'single object keyed by component type, so the output of several Redfish checks can '
        'be merged into one inventory document with `jq --slurp`. Ignores --brief, --match '
        'and --ignore. Default: %(default)s',
        dest='INVENTORY',
        action='store_true',
        default=False,
    )

    parser.add_argument(
        '--match',
        help='Only check items whose name matches this Python regular expression. '
        'Case-sensitive by default; use `(?i)` for case-insensitive matching. '
        'Can be specified multiple times.',
        dest='MATCH',
        action='append',
        default=None,
    )

    parser.add_argument(
        '--no-proxy',
        help=lib.args.help('--no-proxy'),
        dest='NO_PROXY',
        action='store_true',
        default=DEFAULT_NO_PROXY,
    )

    parser.add_argument(
        '--password',
        help='Redfish API password.',
        dest='PASSWORD',
    )

    parser.add_argument(
        '--retries',
        help='Number of extra attempts if a request to the Redfish API fails, before the '
        'check gives up. Helps against an occasionally slow or flaky management controller. '
        'Default: %(default)s',
        dest='RETRIES',
        type=int,
        default=DEFAULT_RETRIES,
    )

    parser.add_argument(
        '--test',
        help=lib.args.help('--test'),
        dest='TEST',
        type=lib.args.csv,
    )

    parser.add_argument(
        '--timeout',
        help=lib.args.help('--timeout') + ' Default: %(default)s (seconds)',
        dest='TIMEOUT',
        type=int,
        default=DEFAULT_TIMEOUT,
    )

    parser.add_argument(
        '--url',
        help='Redfish API URL. Default: %(default)s',
        dest='URL',
        default=DEFAULT_URL,
    )

    parser.add_argument(
        '--username',
        help='Redfish API username.',
        dest='USERNAME',
    )

    args, _ = parser.parse_known_args()
    return args


def load_test_fixture(test_args, path):
    # Replace the first element of args.TEST with the walk-specific
    # fixture path, read it via lib.lftest.test() and return the parsed
    # JSON. On a missing file or malformed JSON, exit STATE_UNKNOWN with
    # a helpful message instead of letting json.loads raise a traceback.
    if not os.path.isfile(path):
        lib.base.cu(f'Test fixture not found: "{path}".')
    test_args[0] = path
    stdout, _, _ = lib.lftest.test(test_args)
    try:
        return json.loads(stdout)
    except (json.JSONDecodeError, ValueError) as e:
        lib.base.cu(f'Test fixture "{path}" does not contain valid JSON: {e}')


def main():
    """The main function. This is where the magic happens."""

    # parse the command line
    try:
        args = parse_args()
    except SystemExit:
        sys.exit(STATE_UNKNOWN)

    # set default values for append parameters that were not specified
    if args.IGNORE is None:
        args.IGNORE = []
    if args.MATCH is None:
        args.MATCH = []

    # compile the item filter regexes once
    ignore_patterns = [
        lib.base.coe(p) for p in lib.txt.compile_regex(args.IGNORE, '--ignore')
    ]
    match_patterns = [
        lib.base.coe(p) for p in lib.txt.compile_regex(args.MATCH, '--match')
    ]

    # fetch data
    if args.TEST is None:
        if not args.URL.startswith('http'):
            lib.base.cu('--url parameter has to start with "http://" or https://".')
        header = {'Accept': 'application/json'}
        # reuse a cached Redfish session token across requests and runs, so we
        # do not create (and have the controller log) a new session each time
        header.update(lib.redfish.get_auth_header(args))
        # Entry point: the Systems collection
        result = lib.base.coe(
            lib.url.fetch_json(
                f'{args.URL}{API_BASE}/Systems',
                header=header,
                insecure=args.INSECURE,
                no_proxy=args.NO_PROXY,
                timeout=args.TIMEOUT,
                retries=args.RETRIES,
            )
        )
    else:
        # do not call the API, put in test data. Each API call in the
        # Redfish walk has an explicit fixture suffix, so the fixture
        # file names describe what they contain (systems, system,
        # processors, cpu-N).
        test_base = args.TEST[0]
        result = load_test_fixture(args.TEST, f'{test_base}-systems')
    # "Members": [
    #     {
    #         "@odata.id": "/redfish/v1/Systems/437XR1138R2"
    #     }
    # ],
    if len(result.get('Members', [])) == 0:
        lib.base.cu('Nothing to check, no Redfish members found.')

    # init some vars
    msg = ''
    state = STATE_OK
    perfdata = ''
    member_count = 0
    processor_count = 0
    processor_not_ok = 0
    # only allocated and populated in --inventory mode, so a normal health
    # check holds nothing extra in memory
    inventory = [] if args.INVENTORY else None

    # analyze data: follow each "Member" link, aggregate processor
    # health into `state`. System-level health is deliberately not
    # aggregated (see `redfish-systems` for that).
    for member in result.get('Members', []):
        if args.TEST is None:
            # "/redfish/v1/Systems/437XR1138R2"
            systems = lib.base.coe(
                lib.url.fetch_json(
                    f'{args.URL}{member["@odata.id"]}',
                    header=header,
                    insecure=args.INSECURE,
                    no_proxy=args.NO_PROXY,
                    timeout=args.TIMEOUT,
                    retries=args.RETRIES,
                )
            )
        else:
            systems = load_test_fixture(args.TEST, f'{test_base}-system')
        systems = lib.redfish.get_systems(systems)
        if systems['Status_State'] not in ['Enabled', 'Quiesced']:
            continue
        member_count += 1

        # build the message: only identify the member (manufacturer, model,
        # hostname, SKU, serial number). System-level health is intentionally
        # not aggregated here and not labelled with a state; use
        # `redfish-systems` for that.
        msg += 'Member:'
        msg += f' {systems["Manufacturer"]}' if systems['Manufacturer'] else ''
        msg += f' {systems["Model"]}' if systems['Model'] else ''
        msg += ', '
        msg += f'HostName: {systems["HostName"]}, ' if systems['HostName'] else ''
        msg += f'SKU: {systems["SKU"]}, ' if systems['SKU'] else ''
        msg += f'SerNo: {systems["SerialNumber"]}, ' if systems['SerialNumber'] else ''
        msg = msg[:-2]

        # get the processors link for the member
        if not systems['Processors_@odata.id']:
            msg += '\n\n'
            continue

        if args.TEST is None:
            # "/redfish/v1/Systems/437XR1138R2/Processors"
            processors = lib.base.coe(
                lib.url.fetch_json(
                    f'{args.URL}{systems["Processors_@odata.id"]}',
                    header=header,
                    insecure=args.INSECURE,
                    no_proxy=args.NO_PROXY,
                    timeout=args.TIMEOUT,
                    retries=args.RETRIES,
                )
            )
        else:
            processors = load_test_fixture(args.TEST, f'{test_base}-processors')
        table_data = []
        for cpu_idx, cpu in enumerate(processors.get('Members', [])):
            if args.TEST is None:
                # "/redfish/v1/Systems/437XR1138R2/Processors/CPU1"
                cpu_data = lib.base.coe(
                    lib.url.fetch_json(
                        f'{args.URL}{cpu["@odata.id"]}',
                        header=header,
                        insecure=args.INSECURE,
                        no_proxy=args.NO_PROXY,
                        timeout=args.TIMEOUT,
                        retries=args.RETRIES,
                    )
                )
            else:
                cpu_data = load_test_fixture(args.TEST, f'{test_base}-cpu-{cpu_idx}')
            cpu_data = lib.redfish.get_systems_processors(cpu_data)
            if cpu_data['Status_State'] not in ['Enabled', 'Quiesced']:
                continue
            # collect for --inventory before any display filter (--match/--ignore/--brief)
            if args.INVENTORY:
                inventory.append(dict(cpu_data, system_ids=systems['Id']))
            # --match/--ignore: filter by item name
            item_name = cpu_data['Name'] or cpu_data.get('Id', '')
            if ignore_patterns and any(p.search(item_name) for p in ignore_patterns):
                continue
            if match_patterns and not any(p.search(item_name) for p in match_patterns):
                continue
            # is the processor healthy at all?
            cpu_data_state = lib.redfish.get_state(cpu_data)
            state = lib.base.get_worst(state, cpu_data_state)
            cpu_data['State'] = lib.base.state2str(cpu_data_state, empty_ok=False)
            processor_count += 1
            if cpu_data_state != STATE_OK:
                processor_not_ok += 1
            table_data.append(cpu_data)

        if args.BRIEF:
            table_data = [r for r in table_data if r.get('State') != '[OK]']
        if table_data:
            keys = [
                'Socket',
                'ProcessorType',
                'Model',
                'Manufacturer',
                'TotalCores',
                'TotalThreads',
                'MaxSpeedMHz',
                'State',
            ]
            headers = [
                'Socket',
                'Type',
                'Model',
                'Manufacturer',
                'Cores',
                'Threads',
                'Max MHz',
                'State',
            ]
            msg += '\n\n' + lib.base.get_table(table_data, keys, header=headers)

        msg += '\n\n'

    # --inventory: emit the collected components as JSON and exit before
    # building the human-readable message and perfdata
    if args.INVENTORY:
        print(
            json.dumps(
                {'processor': inventory}, ensure_ascii=False, indent=4, sort_keys=True
            )
        )
        sys.exit(STATE_OK)

    # build the message
    members = lib.txt.pluralize('member', member_count)
    if state == STATE_CRIT:
        msg = (
            f'Checked processors on {member_count} {members}.'
            f' There are critical errors.\n\n'
        ) + msg
    elif state == STATE_WARN:
        msg = (
            f'Checked processors on {member_count} {members}. There are warnings.\n\n'
        ) + msg
    else:
        msg = (
            f'Everything is ok, checked processors on {member_count} {members}.\n\n'
        ) + msg

    # perfdata: how many processors were checked and how many are not OK
    perfdata = lib.base.get_perfdata(
        'processors',
        processor_count,
        _min=0,
    )
    perfdata += lib.base.get_perfdata(
        'processors_not_ok',
        processor_not_ok,
        _min=0,
    )

    # over and out
    lib.base.oao(msg, state, perfdata, always_ok=args.ALWAYS_OK)


if __name__ == '__main__':
    try:
        main()
    except Exception:
        lib.base.cu()
