ab_gp_jru_forward.c

Go to the documentation of this file.

#include "ab_gp_jru_forward.h"
 
#include "../../common/rbc_util_frame.h"
#include "../../common/rbc_util_jru_payload.h"
#include "../../common/site_config.h"



static rte_status_t osadapter_init(void);
static void osadapter_write(rte_log_level_t level, const char *tag, const char *message);

static const rte_osadapter_log_t s_forward_osadapter = { osadapter_init, osadapter_write };
static const rte_osadapter_log_t *s_delegate;
static ab_gp_channel_handle_t     s_handle;
static uint8_t                    s_source_id;
static uint8_t                    s_seq;
static __thread bool              s_in_forward;


rte_status_t ab_gp_jru_forward_install(const rte_osadapter_log_t *delegate)
{
    rte_status_t status;
 
    if (delegate == NULL)
    {
        status = RTE_STATUS_INVALID_PARAM;
    }
    else
    {
        s_delegate = delegate;
        s_handle = NULL;
        status = rte_osadapter_log_register(&s_forward_osadapter);
    }
    return status;
}
 
void ab_gp_jru_forward_set_channel(ab_gp_channel_handle_t handle, uint8_t source_id)
{
    s_handle = handle;
    s_source_id = source_id;
}
 
/****Local functions ****/
 
static rte_status_t osadapter_init(void)
{
    return (s_delegate != NULL) ? s_delegate->init() : RTE_STATUS_OK;
}
 
static void osadapter_write(rte_log_level_t level, const char *tag, const char *message)
{
    if (s_delegate != NULL)
    {
        s_delegate->write(level, tag, message);
    }
 
    /* Forward INFO and above only - DEBUG is high-volume local diagnostic detail, not the kind
     * of durable external record JRU/diagnostic forwarding exists for. Best-effort: no channel
     * attached yet (early startup, before ab_gp_jru_forward_set_channel()) or a full relay
     * queue silently drops the event - never affects the caller of write(), same contract as
     * every other rte_osadapter_log_t implementation in this workspace. ISS-020: while the
     * status service is unreachable the UTIL link is not open, and ab_gp_channel_send_relay()
     * lets this caller start at most one bounded open attempt
     * (RTE_EXAMPLE_UTIL_OPEN_ATTEMPT_TIMEOUT_MS) per RTE_EXAMPLE_UTIL_REOPEN_BACKOFF_MS; every
     * other event in that time is dropped without touching the link (ab_gp_util_link_gate.h). */
    if ((s_handle != NULL) && (level >= RTE_LOG_LEVEL_INFO) && !s_in_forward)
    {
        char    payload[RBC_UTIL_PAYLOAD_MAX];
        uint8_t frame[RBC_UTIL_FRAME_SIZE];
 
        s_in_forward = true;
        rbc_util_jru_payload_encode(payload, sizeof(payload), level, tag, message);
        s_seq++;
        rbc_util_frame_encode(frame, RBC_UTIL_MSG_PUBLISH, s_source_id, (uint16_t)RBC_UTIL_TOPIC_JRU_LOG,
                              s_seq, payload);
        (void)ab_gp_channel_send_relay(s_handle, RTE_EXAMPLE_RELAY_KIND_UTIL, 0U, frame,
                                        (size_t)RBC_UTIL_FRAME_SIZE);
        s_in_forward = false;
    }
}