ab_gp_status.c

Go to the documentation of this file.

#include "ab_gp_status.h"
#include "ab_gp_site_status.h"
 
#include <stdio.h>
#include <string.h>
 
#include "rte/oal/log/rte_log.h"
#include "rte/redundancy/dual/rte_dual_negotiator.h"
 
#include "../../common/common_config.h"
#include "../../common/rbc_util_frame.h"
#include "../../common/site_config.h"
 
/* RTE_EXAMPLE_STATUS_PERIOD_MS worth of cycles. */
#define AB_GP_STATUS_EVERY_CYCLES \
    ((uint32_t)RTE_EXAMPLE_STATUS_PERIOD_MS / (uint32_t)RTE_EXAMPLE_AB_CYCLE_PERIOD_MS)
 
static uint8_t s_seq; /* per-process publish sequence, wraps */
 
static uint8_t connected_train_count(const ab_gp_channel_context_t *ctx)
{
    uint8_t n = 0U;
    uint8_t i;
 
    for (i = 0U; i < (uint8_t)RTE_EXAMPLE_MAX_TRAINS; i++)
    {
        if (ctx->sessions[i].in_use)
        {
            n++;
        }
    }
    return n;
}
 
void ab_gp_status_tick(ab_gp_channel_handle_t handle, const ab_gp_channel_context_t *ctx, uint32_t cycle)
{
    char             payload[RBC_UTIL_PAYLOAD_MAX];
    uint8_t          frame[RBC_UTIL_FRAME_SIZE];
    rte_dual_state_t own_state;
    rte_dual_state_t peer_state;
    bool             peer_up;
    uint8_t          src_id;
 
    static uint32_t s_status_last_cycle = 0U; /* one channel per process */
 
    if (ctx == NULL)
    {
        return;
    }
    /* Not "cycle % N": the cycle number follows real time (missed ticks are counted) and is renumbered by a state
     * transfer, so it can step by 2 or jump back, and a modulo test then never hit for a minute (Docker takeover test:
     * no status line for 70 s after a promotion). Emit when N cycles have passed since the last one, or the number went back. */
    if ((cycle != 1U) && (cycle >= s_status_last_cycle) && ((cycle - s_status_last_cycle) < AB_GP_STATUS_EVERY_CYCLES))
    {
        return;
    }
    s_status_last_cycle = cycle;
 
    rte_site_role_get_negotiator_states(&ctx->site_role, &own_state, &peer_state);
    /* Peer (A<->B within this site) considered up if it sent us an
     * AB_SAMPLE within the last few cycles. */
    peer_up = ((cycle - ctx->last_peer_sample_cycle) <= 3U);
    src_id  = ctx->is_role_a ? (uint8_t)RBC_UTIL_SRC_A : (uint8_t)RBC_UTIL_SRC_B;
 
    (void)snprintf(payload, sizeof(payload),
                   "unit=%s up=1 role=%s site=%s other=%s peer=%d trains=%u single=%d",
                   ctx->role_tag,
                   ctx->is_online ? "ONLINE" : "STANDBY",
                   rte_dual_state_to_string(own_state),
                   rte_dual_state_to_string(peer_state),
                   peer_up ? 1 : 0,
                   (unsigned int)connected_train_count(ctx),
                   ctx->single_mode ? 1 : 0);
 
    {
        /* ADR-040 step 4b: the current takeover challenge, which the issuer MACs into this channel's token. Absent
         * without a takeover key (interim unauthenticated path) or while no challenge is held. */
        uint32_t challenge = 0U;
        size_t used = strlen(payload);
 
        if (rte_site_role_takeover_challenge(&ctx->site_role, &challenge))
        {
            (void)snprintf(&payload[used], sizeof(payload) - used, " tko=%08x", (unsigned int)challenge);
        }
    }
 
    {
        /* The site status monitor's view: what this channel waits for and why its role last changed. */
        ab_gp_site_status_t site_status;
        size_t used = strlen(payload);
 
        ab_gp_site_status_collect(ctx, &site_status);
        (void)ab_gp_site_status_append_text(&site_status, &payload[used], sizeof(payload) - used);
    }
 
    /* Self line - independent of whether the util link / broker are up. */
    rte_log_write_event(RTE_LOG_LEVEL_INFO, site_config_name(ctx->site), cycle, ctx->role_tag, "-",
                          "STATUS", "self", payload);
 
    /* Publish to the C-side broker over the UTIL relay (best-effort). */
    s_seq++;
    rbc_util_frame_encode(frame, RBC_UTIL_MSG_PUBLISH, src_id, (uint16_t)RBC_UTIL_TOPIC_STATUS, s_seq,
                          payload);
    (void)ab_gp_channel_send_relay(handle, RTE_EXAMPLE_RELAY_KIND_UTIL, 0U, frame,
                                    (size_t)RBC_UTIL_FRAME_SIZE);
}