main.c

Go to the documentation of this file.

#include <stdbool.h>
#include <stdio.h>
#include <string.h>
 
#include "rte/app/appmanager/rte_appmanager.h"
#include "rte/oal/log/rte_log.h"
#include "rte/oal/memory/rte_mem_util.h"
#include "rte/posix_osadapter/rte_posix_osadapter.h"
 
#include "ab_gp_channel_cycle_hooks.h"
#include "../com/ab_gp_channel.h"
#include "../com/ab_gp_jru_forward.h"
#include "../../common/app_main_common.h"
#include "../../common/rbc_util_frame.h"
#include "../../common/site_config.h"
 
#include "rte/core/rte_core_version.h"
#include "rte_rbc2oo2_version.h"
#include "rte_gp_run.h" /* declares rte_gp_run() itself - included so the
                           * definition below is checked against it */
 





static int fatal_setup_step_failed(const char *step, rte_status_t status, ab_gp_channel_handle_t handle);
static rte_appmanager_config_t ab_gp_channel_make_config(ab_gp_channel_handle_t handle);
static const char *ab_gp_channel_get_name(void);
static const char *ab_gp_channel_get_version(void);
 
 
 

int rte_gp_run(int argc, char **argv)
{
    rte_status_t status;
    rte_example_site_t site;
    bool is_role_a;
    ab_gp_channel_handle_t handle = NULL;
    rte_appmanager_config_t config;
    const char *framework_actual_version;
 
    /* Printed unconditionally, before arg validation, so even a
     * usage-error run identifies itself - see rte_rbc2oo2_version.h.in's
     * own doc for why the framework-version comparison matters (catches a
     * stale statically-linked framework .a / wrong RTE_FRAMEWORK_DIST_DIR
     * that wouldn't otherwise be visible until something broke at
     * runtime). Plain fprintf, not rte_log_write_event() - this runs
     * before app_main_common_init() below, which is what initializes
     * logging. */
    framework_actual_version = rte_core_get_version();
    (void)fprintf(stdout, "%s version %s (framework %s, expected %s)\n", argv[0], RTE_RBC2OO2_VERSION,
                  framework_actual_version, RTE_FRAMEWORK_EXPECTED_VERSION);
    if (strcmp(framework_actual_version, RTE_FRAMEWORK_EXPECTED_VERSION) != 0)
    {
        (void)fprintf(stderr,
                       "WARNING: linked safeAPIFreamwork version (%s) does not match what this binary was "
                       "built against (%s) - a stale library archive or wrong framework dist/ may be linked in\n",
                       framework_actual_version, RTE_FRAMEWORK_EXPECTED_VERSION);
    }
 
    if (argc < 3)
    {
        (void)fprintf(stderr, "usage: %s {A|B} {WEST|EAST}\n", argv[0]);
        return 1;
    }
    if (!site_config_parse(argv[2], &site))
    {
        (void)fprintf(stderr, "unknown site '%s' - expected WEST or EAST\n", argv[2]);
        return 1;
    }
    if (strcmp(argv[1], "A") == 0)
    {
        is_role_a = true;
    }
    else if (strcmp(argv[1], "B") == 0)
    {
        is_role_a = false;
    }
    else
    {
        (void)fprintf(stderr, "unknown role '%s' - expected A or B\n", argv[1]);
        return 1;
    }
 
    status = app_main_common_init(argc, argv);
    if (status != RTE_STATUS_OK)
    {
        return 1;
    }
 
    /* Overrides the plain POSIX log OSAdapter app_main_common_init() just registered with a
     * wrapper that delegates to it (identical local stderr behaviour) and additionally
     * forwards INFO+ events to Gateway once the channel below opens - see
     * Platform_Protocol_JRU/CLAUDE.md's "Wiring" section. Best-effort, non-safety
     * (ADR-001 section 4); a failure here only means this process loses log forwarding to
     * Gateway, never local logging. */
    (void)ab_gp_jru_forward_install(rte_posix_osadapter_log());
 
    /* Composition root: this function owns every setup step described in
     * this file's own "Startup sequence" header doc, in order, before
     * handing off to rte_appmanager_run() for the cyclic executive
     * proper - see that doc for each step's fatal/non-fatal posture. */
    status = ab_gp_channel_open_link(is_role_a, site, &handle);
    if (status != RTE_STATUS_OK)
    {
        /* Step 1 alone: self-cleaned already, must NOT call ab_gp_channel_close_link() - see its own doc. */
        char msg[64];
 
        (void)snprintf(msg, sizeof(msg), "channel open failed: %s", rte_status_to_string(status));
        rte_log_write(RTE_LOG_LEVEL_ERROR, "MAIN", msg);
        return 1;
    }
 
    /* From here on, every rte_log_write()/rte_log_write_event() call in this process also
     * republishes (INFO+) to Gateway over the just-opened relay channel - see
     * ab_gp_jru_forward_install() above. */
    ab_gp_jru_forward_set_channel(handle, is_role_a ? (uint8_t)RBC_UTIL_SRC_A : (uint8_t)RBC_UTIL_SRC_B);
 
    status = ab_gp_channel_train_codec_setup(handle);
    if (status != RTE_STATUS_OK)
    {
        return fatal_setup_step_failed("train codec setup", status, handle);
    }
 
    status = ab_gp_channel_ga_setup(handle);
    if (status != RTE_STATUS_OK)
    {
        return fatal_setup_step_failed("GA setup", status, handle);
    }
 
    ab_gp_channel_relay_queues_setup(handle); /* cannot fail */
 
    status = ab_gp_channel_saf_train_setup(handle);
    if (status != RTE_STATUS_OK)
    {
        return fatal_setup_step_failed("train-link SaF setup", status, handle);
    }
 
    status = ab_gp_channel_negotiate_setup(handle);
    if (status != RTE_STATUS_OK)
    {
        return fatal_setup_step_failed("negotiate setup", status, handle);
    }
 
    (void)ab_gp_channel_checkpoint_setup(handle); /* non-fatal - see its own doc */
    (void)ab_gp_channel_dual_setup(handle);       /* non-fatal - see its own doc */
    (void)ab_gp_channel_watchdog_setup(handle);   /* non-fatal - see its own doc */
 
    status = ab_gp_channel_crosscompare_setup(handle);
    if (status != RTE_STATUS_OK)
    {
        return fatal_setup_step_failed("cross-comparator setup", status, handle);
    }
 
    status = ab_gp_channel_cycle_timer_setup(handle);
    if (status != RTE_STATUS_OK)
    {
        return fatal_setup_step_failed("cycle timer setup", status, handle);
    }
 
    config = ab_gp_channel_make_config(handle);
    return rte_appmanager_run(&config);
}
 
 
/****Local functions ****/

static int fatal_setup_step_failed(const char *step, rte_status_t status, ab_gp_channel_handle_t handle)
{
    char msg[64];
 
    (void)snprintf(msg, sizeof(msg), "%s failed: %s", step, rte_status_to_string(status));
    rte_log_write(RTE_LOG_LEVEL_ERROR, "MAIN", msg);
    ab_gp_channel_close_link(handle);
    return 1;
}

static rte_appmanager_config_t ab_gp_channel_make_config(ab_gp_channel_handle_t handle)
{
    /* ADR-019 (safeAPIFreamwork): the original single-function execute()
     * is now split across pre_execute()/execute()/post_execute() - see
     * this file's own header for the phase mapping. Designated
     * initializers, not positional: a positional initializer here would
     * silently shift fields if this struct's layout ever changes again. */
    static const rte_appmanager_operations_t ops = {
        .init = ab_gp_channel_init,
        .pre_execute = ab_gp_channel_pre_execute,
        .execute = ab_gp_channel_execute,
        .post_execute = ab_gp_channel_post_execute,
        .on_checkpoint_result = ab_gp_channel_on_checkpoint_result,
        .shutdown = ab_gp_channel_shutdown,
        .get_name = ab_gp_channel_get_name,
        .get_version = ab_gp_channel_get_version
    };
    rte_appmanager_config_t config;
 
    rte_mem_set(&config, 0, sizeof(config));
    config.ops = &ops;
    config.context = (void *)handle;
    config.max_iterations = 0U; /* infinite: runs until signalled - see main()'s own SIGINT/SIGTERM handling */
    config.error_threshold = 0U; /* no limit: a robust always-on cycle does not give up on a transient error
                                   * - the two truly fatal conditions (CRC-64 corruption, logical M24/M15
                                   * disagreement) bypass this entirely via RTE_SAFESTATE. */
    config.checkpoint = ab_gp_channel_checkpoint_config(handle); /* ADR-019 addendum (ADR-025 rewiring).
                                   * NULL until (and unless) ab_gp_channel_checkpoint_setup() ran and
                                   * succeeded on this handle - rte_appmanager_run() does not treat that
                                   * as a startup error; the pointed-to config's own voter field is also
                                   * toggled back to NULL by ab_gp_channel_io.c whenever the peer link is
                                   * known down, so a transient reconnect never risks the built-in
                                   * checkpoint's own mandatory SAFE-state reaction. */
 
    return config;
}

static const char *ab_gp_channel_get_name(void)
{
    return "safeAPIRBC2oo2-AB";
}

static const char *ab_gp_channel_get_version(void)
{
    return "3.0.0";
}