Verified Commit 765dc772 authored by Alberto Miranda's avatar Alberto Miranda ♨️
Browse files

Add encoding functions for ADM_qos_*_t types

parent f9bc8ceb

src/common/net/proto/rpc_types.c

+397 −0
Original line number Diff line number Diff line
@@ -24,6 +24,151 @@ 


#include "rpc_types.h"



hg_return_t (*hg_proc_ADM_qos_scope_t)(hg_proc_t, void*) = hg_proc_hg_uint32_t;

hg_return_t (*hg_proc_ADM_qos_class_t)(hg_proc_t, void*) = hg_proc_hg_uint32_t;



hg_return_t

hg_proc_ADM_node_t(hg_proc_t proc, void* data) {



    hg_return_t ret = HG_SUCCESS;

    ADM_node_t* node = (ADM_node_t*) data;

    ADM_node_t tmp = NULL;

    hg_size_t node_length = 0;



    switch(hg_proc_get_op(proc)) {



        case HG_ENCODE:

            // find out the length of the adm_node object we need to send

            node_length = *node ? sizeof(adm_node) : 0;

            ret = hg_proc_hg_size_t(proc, &node_length);



            if(ret != HG_SUCCESS) {

                break;

            }



            if(!node_length) {

                return HG_SUCCESS;

            }



            // if we actually need to send an adm_node object,

            // write it to the mercury buffer

            tmp = *node;



            ret = hg_proc_adm_node(proc, tmp);



            if(ret != HG_SUCCESS) {

                break;

            }



            break;



        case HG_DECODE:

            // find out the length of the adm_node object

            ret = hg_proc_hg_size_t(proc, &node_length);



            if(ret != HG_SUCCESS) {

                break;

            }



            if(!node_length) {

                *node = NULL;

                break;

            }



            // if the received adm_node object was not NULL, read each of

            // its fields from the mercury buffer

            tmp = (adm_node*) calloc(1, sizeof(adm_node));



            ret = hg_proc_adm_node(proc, tmp);



            if(ret != HG_SUCCESS) {

                break;

            }



            // return the newly-created ctx

            *node = tmp;

            break;



        case HG_FREE:

            tmp = *node;

            free(tmp);

            break;

    }



    return ret;

}



hg_return_t

hg_proc_ADM_dataset_t(hg_proc_t proc, void* data) {



    hg_return_t ret = HG_SUCCESS;

    ADM_dataset_t* dataset = (ADM_dataset_t*) data;

    ADM_dataset_t tmp = NULL;

    hg_size_t dataset_length = 0;



    switch(hg_proc_get_op(proc)) {



        case HG_ENCODE:

            // find out the length of the adm_dataset object we need to send

            dataset_length = *dataset ? sizeof(adm_node) : 0;

            ret = hg_proc_hg_size_t(proc, &dataset_length);



            if(ret != HG_SUCCESS) {

                break;

            }



            if(!dataset_length) {

                return HG_SUCCESS;

            }



            // if we actually need to send an adm_dataset object,

            // write it to the mercury buffer

            tmp = *dataset;



            ret = hg_proc_adm_dataset(proc, tmp);



            if(ret != HG_SUCCESS) {

                break;

            }



            break;



        case HG_DECODE:

            // find out the length of the adm_dataset object

            ret = hg_proc_hg_size_t(proc, &dataset_length);



            if(ret != HG_SUCCESS) {

                break;

            }



            if(!dataset_length) {

                *dataset = NULL;

                break;

            }



            // if the received adm_dataset object was not NULL, read each of

            // its fields from the mercury buffer

            tmp = (adm_dataset*) calloc(1, sizeof(adm_dataset));



            ret = hg_proc_adm_dataset(proc, tmp);



            if(ret != HG_SUCCESS) {

                break;

            }



            // return the newly-created ctx

            *dataset = tmp;

            break;



        case HG_FREE:

            tmp = *dataset;

            free(tmp);

            break;

    }



    return ret;

}



hg_return_t

hg_proc_ADM_job_t(hg_proc_t proc, void* data) {
@@ -95,8 +240,80 @@ hg_proc_ADM_job_t(hg_proc_t proc, void* data) { 
    return ret;

}



hg_return_t

hg_proc_ADM_transfer_t(hg_proc_t proc, void* data) {



    hg_return_t ret = HG_SUCCESS;

    ADM_transfer_t* transfer = (ADM_transfer_t*) data;

    ADM_transfer_t tmp = NULL;

    hg_size_t transfer_length = 0;



    switch(hg_proc_get_op(proc)) {



        case HG_ENCODE:

            // find out the length of the adm_transfer object we need to send

            transfer_length = *transfer ? sizeof(adm_transfer) : 0;

            ret = hg_proc_hg_size_t(proc, &transfer_length);



            if(ret != HG_SUCCESS) {

                break;

            }



            if(!transfer_length) {

                return HG_SUCCESS;

            }



            // if we actually need to send an adm_transfer object,

            // write it to the mercury buffer

            tmp = *transfer;



            ret = hg_proc_adm_transfer(proc, tmp);



            if(ret != HG_SUCCESS) {

                break;

            }



            break;



        case HG_DECODE:

            // find out the length of the adm_transfer object

            ret = hg_proc_hg_size_t(proc, &transfer_length);



            if(ret != HG_SUCCESS) {

                break;

            }



            if(!transfer_length) {

                *transfer = NULL;

                break;

            }



            // if the received adm_transfer object was not NULL, read each of

            // its fields from the mercury buffer

            tmp = (adm_transfer*) calloc(1, sizeof(adm_transfer));



            ret = hg_proc_adm_transfer(proc, tmp);



            if(ret != HG_SUCCESS) {

                break;

            }



            // return the newly-created ctx

            *transfer = tmp;

            break;



        case HG_FREE:

            tmp = *transfer;

            free(tmp);

            break;

    }



    return ret;

}



hg_return_t

hg_proc_ADM_dataset_list_t(hg_proc_t proc, void* data) {



    hg_return_t ret = HG_SUCCESS;

    ADM_dataset_list_t* list = (ADM_dataset_list_t*) data;

    ADM_dataset_list_t tmp = NULL;
@@ -424,3 +641,183 @@ hg_proc_ADM_pfs_context_t(hg_proc_t proc, void* data) { 


    return ret;

}





hg_return_t

hg_proc_ADM_qos_limit_list_t(hg_proc_t proc, void* data) {

    hg_return_t ret = HG_SUCCESS;

    ADM_qos_limit_list_t* list = (ADM_qos_limit_list_t*) data;

    ADM_qos_limit_list_t tmp = NULL;



    hg_size_t length = 0;



    switch(hg_proc_get_op(proc)) {



        case HG_ENCODE:

            tmp = *list;

            // write the length of the list

            length = tmp->l_length;

            ret = hg_proc_hg_size_t(proc, &tmp->l_length);



            if(ret != HG_SUCCESS) {

                break;

            }



            // write the list

            for(size_t i = 0; i < length; ++i) {

                ret = hg_proc_adm_qos_limit(proc, &tmp->l_limits[i]);



                if(ret != HG_SUCCESS) {

                    break;

                }

            }

            break;



        case HG_DECODE: {



            // find out the length of the list

            ret = hg_proc_hg_size_t(proc, &length);



            if(ret != HG_SUCCESS) {

                break;

            }



            // loop and create list elements

            tmp = (ADM_qos_limit_list_t) calloc(

                    1, sizeof(struct adm_qos_limit_list));

            tmp->l_length = length;

            tmp->l_limits =

                    (adm_qos_limit*) calloc(length, sizeof(adm_qos_limit));



            for(size_t i = 0; i < length; ++i) {

                ret = hg_proc_adm_qos_limit(proc, &tmp->l_limits[i]);



                if(ret != HG_SUCCESS) {

                    break;

                }

            }



            // return the newly-created list

            *list = tmp;



            break;

        }



        case HG_FREE:

            tmp = *list;

            free(tmp->l_limits);

            free(tmp);

            ret = HG_SUCCESS;

            break;

    }



    return ret;

}



hg_return_t

hg_proc_ADM_qos_entity_t(hg_proc_t proc, void* data) {



    hg_return_t ret = HG_SUCCESS;

    ADM_qos_entity_t* qos_entity = (ADM_qos_entity_t*) data;

    ADM_qos_entity_t tmp = NULL;

    hg_size_t qos_entity_length = 0;



    switch(hg_proc_get_op(proc)) {



        case HG_ENCODE:

            // find out the length of the adm_qos_entity object we need to send

            qos_entity_length = *qos_entity ? sizeof(adm_qos_entity) : 0;

            ret = hg_proc_hg_size_t(proc, &qos_entity_length);



            if(ret != HG_SUCCESS) {

                break;

            }



            if(!qos_entity_length) {

                return HG_SUCCESS;

            }



            // if we actually need to send an adm_qos_entity object,

            // write each of its fields to the mercury buffer



            // 1. the QoS scope

            ret = hg_proc_ADM_qos_scope_t(proc, &tmp->e_scope);



            if(ret != HG_SUCCESS) {

                break;

            }



            // 2. the appropriate related data depending on the scope (i.e. an

            // ADM_node_t, ADM_job_t, ADM_dataset_t, or ADM_transfer_t)

            switch(tmp->e_scope) {



                case ADM_QOS_SCOPE_DATASET:

                    ret = hg_proc_ADM_dataset_t(proc, &tmp->e_dataset);

                    break;

                case ADM_QOS_SCOPE_NODE:

                    ret = hg_proc_ADM_node_t(proc, &tmp->e_node);

                    break;

                case ADM_QOS_SCOPE_JOB:

                    ret = hg_proc_ADM_job_t(proc, &tmp->e_job);

                    break;

                case ADM_QOS_SCOPE_TRANSFER:

                    ret = hg_proc_ADM_transfer_t(proc, &tmp->e_transfer);

                    break;

            }



            break;



        case HG_DECODE:

            // find out the length of the adm_qos_entity object

            ret = hg_proc_hg_size_t(proc, &qos_entity_length);



            if(ret != HG_SUCCESS) {

                break;

            }



            if(!qos_entity_length) {

                *qos_entity = NULL;

                break;

            }



            // if the received adm_qos_entity object was not NULL, read each

            // of its fields from the mercury buffer

            tmp = (adm_qos_entity*) calloc(1, sizeof(adm_qos_entity));



            // 1. the QoS scope

            ret = hg_proc_ADM_qos_scope_t(proc, &tmp->e_scope);



            if(ret != HG_SUCCESS) {

                break;

            }



            // 2. the appropriate related data depending on the scope (i.e. an

            // ADM_node_t, ADM_job_t, ADM_dataset_t, or ADM_transfer_t)

            switch(tmp->e_scope) {



                case ADM_QOS_SCOPE_DATASET:

                    ret = hg_proc_ADM_dataset_t(proc, &tmp->e_dataset);

                    break;

                case ADM_QOS_SCOPE_NODE:

                    ret = hg_proc_ADM_node_t(proc, &tmp->e_node);

                    break;

                case ADM_QOS_SCOPE_JOB:

                    ret = hg_proc_ADM_job_t(proc, &tmp->e_job);

                    break;

                case ADM_QOS_SCOPE_TRANSFER:

                    ret = hg_proc_ADM_transfer_t(proc, &tmp->e_transfer);

                    break;

            }



            // return the newly-created entity

            *qos_entity = tmp;

            break;



        case HG_FREE:

            tmp = *qos_entity;

            free(tmp);

            break;

    }



    return ret;

}

src/common/net/proto/rpc_types.h

+13 −2
Original line number Diff line number Diff line
@@ -44,6 +44,9 @@ typedef struct adm_node { 
    const char* n_hostname;

} adm_node;



hg_return_t

hg_proc_ADM_node_t(hg_proc_t proc, void* data);



// clang-format off

MERCURY_GEN_STRUCT_PROC(

    adm_node, // NOLINT
@@ -55,6 +58,9 @@ typedef struct adm_dataset { 
    const char* d_id;

} adm_dataset;



hg_return_t

hg_proc_ADM_dataset_t(hg_proc_t proc, void* data);



// clang-format off

MERCURY_GEN_STRUCT_PROC(

    adm_dataset, // NOLINT
@@ -86,7 +92,8 @@ typedef struct adm_qos_entity { 
    };

} adm_qos_entity;



// TODO: encoder/decoder

extern hg_return_t (*hg_proc_ADM_qos_scope_t)(hg_proc_t, void*);



hg_return_t

hg_proc_ADM_qos_entity_t(hg_proc_t proc, void* data);
@@ -96,7 +103,8 @@ typedef struct adm_qos_limit { 
    hg_uint64_t l_value;

} adm_qos_limit;



// TODO: encoder/decoder

extern hg_return_t (*hg_proc_ADM_qos_class_t)(hg_proc_t, void*);



// clang-format off

MERCURY_GEN_STRUCT_PROC(

    adm_qos_limit, // NOLINT
@@ -110,6 +118,9 @@ typedef struct adm_transfer { 
    uint64_t t_id;

} adm_transfer;



hg_return_t

hg_proc_ADM_transfer_t(hg_proc_t proc, void* data);



// clang-format off

MERCURY_GEN_STRUCT_PROC(

    adm_transfer, // NOLINT