netdata/aclk/schema-wrappers/context.cc

// SPDX-License-Identifier: GPL-3.0-or-later

#include "proto/context/v1/context.pb.h"

#include "libnetdata/libnetdata.h"

#include "schema_wrapper_utils.h"

#include "context.h"

using namespace context::v1;

// ContextsSnapshot
contexts_snapshot_t contexts_snapshot_new(const char *claim_id, const char *node_id, uint64_t version)
{
    ContextsSnapshot *ctxs_snap = new ContextsSnapshot;

    if (ctxs_snap == NULL)
        fatal("Cannot allocate ContextsSnapshot object. OOM");

    ctxs_snap->set_claim_id(claim_id);
    ctxs_snap->set_node_id(node_id);
    ctxs_snap->set_version(version);

    return ctxs_snap;
}

void contexts_snapshot_delete(contexts_snapshot_t snapshot)
{
    delete (ContextsSnapshot *)snapshot;
}

void contexts_snapshot_set_version(contexts_snapshot_t ctxs_snapshot, uint64_t version)
{
    ((ContextsSnapshot *)ctxs_snapshot)->set_version(version);
}

static void fill_ctx_updated(ContextUpdated *ctx, struct context_updated *c_ctx)
{
    ctx->set_id(c_ctx->id);
    ctx->set_version(c_ctx->version);
    ctx->set_first_entry(c_ctx->first_entry);
    ctx->set_last_entry(c_ctx->last_entry);
    ctx->set_deleted(c_ctx->deleted);
    ctx->set_title(c_ctx->title);
    ctx->set_priority(c_ctx->priority);
    ctx->set_chart_type(c_ctx->chart_type);
    ctx->set_units(c_ctx->units);
    ctx->set_family(c_ctx->family);
}

void contexts_snapshot_add_ctx_update(contexts_snapshot_t ctxs_snapshot, struct context_updated *ctx_update)
{
    ContextsSnapshot *ctxs_snap = (ContextsSnapshot *)ctxs_snapshot;
    ContextUpdated *ctx = ctxs_snap->add_contexts();

    fill_ctx_updated(ctx, ctx_update);
}

char *contexts_snapshot_2bin(contexts_snapshot_t ctxs_snapshot, size_t *len)
{
    ContextsSnapshot *ctxs_snap = (ContextsSnapshot *)ctxs_snapshot;
    *len = PROTO_COMPAT_MSG_SIZE_PTR(ctxs_snap);
    char *bin = (char*)mallocz(*len);
    if (!ctxs_snap->SerializeToArray(bin, *len)) {
        freez(bin);
        delete ctxs_snap;
        return NULL;
    }

    delete ctxs_snap;
    return bin;
}

// ContextsUpdated
contexts_updated_t contexts_updated_new(const char *claim_id, const char *node_id, uint64_t version_hash, uint64_t created_at)
{
    ContextsUpdated *ctxs_updated = new ContextsUpdated;

    if (ctxs_updated == NULL)
        fatal("Cannot allocate ContextsUpdated object. OOM");

    ctxs_updated->set_claim_id(claim_id);
    ctxs_updated->set_node_id(node_id);
    ctxs_updated->set_version_hash(version_hash);
    ctxs_updated->set_created_at(created_at);

    return ctxs_updated;
}

void contexts_updated_delete(contexts_updated_t ctxs_updated)
{
    delete (ContextsUpdated *)ctxs_updated;
}

void contexts_updated_update_version_hash(contexts_updated_t ctxs_updated, uint64_t version_hash)
{
    ((ContextsUpdated *)ctxs_updated)->set_version_hash(version_hash);
}

void contexts_updated_add_ctx_update(contexts_updated_t ctxs_updated, struct context_updated *ctx_update)
{
    ContextsUpdated *ctxs_update = (ContextsUpdated *)ctxs_updated;
    ContextUpdated *ctx = ctxs_update->add_contextupdates();

    if (ctx == NULL)
        fatal("Cannot allocate ContextUpdated object. OOM");

    fill_ctx_updated(ctx, ctx_update);
}

char *contexts_updated_2bin(contexts_updated_t ctxs_updated, size_t *len)
{
    ContextsUpdated *ctxs_update = (ContextsUpdated *)ctxs_updated;
    *len = PROTO_COMPAT_MSG_SIZE_PTR(ctxs_update);
    char *bin = (char*)mallocz(*len);
    if (!ctxs_update->SerializeToArray(bin, *len)) {
        freez(bin);
        delete ctxs_update;
        return NULL;
    }

    delete ctxs_update;
    return bin;
}