From 8499055fbaebc9fd0d309ae43a6072c8f5b4a68e Mon Sep 17 00:00:00 2001 From: mquinson Date: Thu, 30 Mar 2006 22:59:18 +0000 Subject: [PATCH] Here come the new GRAS RPC git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@2023 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- src/gras/Msg/msg.c | 235 ++++++++++++++++++++++++------------- src/gras/Msg/msg_private.h | 48 ++++---- src/gras/Msg/rl_msg.c | 81 +++++++++++-- src/gras/Msg/rpc.c | 119 +++++++++++++++++++ src/gras/Msg/sg_msg.c | 36 +++++- 5 files changed, 396 insertions(+), 123 deletions(-) create mode 100644 src/gras/Msg/rpc.c diff --git a/src/gras/Msg/msg.c b/src/gras/Msg/msg.c index 1ac3636a79..9276115872 100644 --- a/src/gras/Msg/msg.c +++ b/src/gras/Msg/msg.c @@ -12,6 +12,7 @@ #include "gras/Virtu/virtu_interface.h" #include "gras/DataDesc/datadesc_interface.h" #include "gras/Transport/transport_interface.h" /* gras_select */ +#include "portable.h" /* execinfo when available to propagate exceptions */ #ifndef MIN #define MIN(a,b) ((a) < (b) ? (a) : (b)) @@ -22,6 +23,8 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(gras_msg,gras,"High level messaging"); xbt_set_t _gras_msgtype_set = NULL; static char *make_namev(const char *name, short int ver); char _GRAS_header[6]; +const char *e_gras_msg_kind_names[e_gras_msg_kind_count]= + {"UNKNOWN","ONEWAY","RPC call","RPC answer","RPC error"}; /* * Creating procdata for this module @@ -117,33 +120,14 @@ static char *make_namev(const char *name, short int ver) { return namev; } -/** @brief declare a new message type of the given name. It only accepts the given datadesc as payload - * - * @param name: name as it should be used for logging messages (must be uniq) - * @param payload: datadescription of the payload - */ -void gras_msgtype_declare(const char *name, - gras_datadesc_type_t payload) { - gras_msgtype_declare_v(name, 0, payload); -} +/* Internal function doing the crude work of registering messages */ +void +gras_msgtype_declare_ext(const char *name, + short int version, + e_gras_msg_kind_t kind, + gras_datadesc_type_t payload_request, + gras_datadesc_type_t payload_answer) { -/** @brief declare a new versionned message type of the given name and payload - * - * @param name: name as it should be used for logging messages (must be uniq) - * @param version: something like versionning symbol - * @param payload: datadescription of the payload - * - * Registers a message to the GRAS mechanism. Use this version instead of - * gras_msgtype_declare when you change the semantic or syntax of a message and - * want your programs to be able to deal with both versions. Internally, each - * will be handled as an independent message type, so you can register - * differents for each of them. - */ -void -gras_msgtype_declare_v(const char *name, - short int version, - gras_datadesc_type_t payload) { - gras_msgtype_t msgtype=NULL; char *namev=make_namev(name,version); volatile int found = 0; @@ -159,30 +143,76 @@ gras_msgtype_declare_v(const char *name, } if (found) { - VERB2("Re-register version %d of message '%s' (same payload, ignored).", + VERB2("Re-register version %d of message '%s' (same kind & payload, ignored).", version, name); - xbt_assert3(!gras_datadesc_type_cmp(msgtype->ctn_type, payload), + xbt_assert3(msgtype->kind == kind, + "Message %s re-registered as a %s (it was known as a %s)", + namev,e_gras_msg_kind_names[kind],e_gras_msg_kind_names[msgtype->kind]); + xbt_assert3(!gras_datadesc_type_cmp(msgtype->ctn_type, payload_request), "Message %s re-registred with another payload (%s was %s)", - namev,gras_datadesc_get_name(payload), + namev,gras_datadesc_get_name(payload_request), gras_datadesc_get_name(msgtype->ctn_type)); + xbt_assert3(!gras_datadesc_type_cmp(msgtype->answer_type, payload_answer), + "Message %s re-registred with another answer payload (%s was %s)", + namev,gras_datadesc_get_name(payload_answer), + gras_datadesc_get_name(msgtype->answer_type)); + return ; /* do really ignore it */ } - VERB3("Register version %d of message '%s' (payload: %s).", - version, name, gras_datadesc_get_name(payload)); + VERB4("Register version %d of message '%s' " + "(payload: %s; answer payload: %s).", + version, name, gras_datadesc_get_name(payload_request), + gras_datadesc_get_name(payload_answer)); msgtype = xbt_new(s_gras_msgtype_t,1); msgtype->name = (namev == name ? strdup(name) : namev); msgtype->name_len = strlen(namev); msgtype->version = version; - msgtype->ctn_type = payload; + msgtype->kind = kind; + msgtype->ctn_type = payload_request; + msgtype->answer_type = payload_answer; xbt_set_add(_gras_msgtype_set, (xbt_set_elm_t)msgtype, &gras_msgtype_free); } + +/** @brief declare a new message type of the given name. It only accepts the given datadesc as payload + * + * @param name: name as it should be used for logging messages (must be uniq) + * @param payload: datadescription of the payload + */ +void gras_msgtype_declare(const char *name, + gras_datadesc_type_t payload) { + gras_msgtype_declare_ext(name, 0, e_gras_msg_kind_oneway, payload, NULL); +} + + + +/** @brief declare a new versionned message type of the given name and payload + * + * @param name: name as it should be used for logging messages (must be uniq) + * @param version: something like versionning symbol + * @param payload: datadescription of the payload + * + * Registers a message to the GRAS mechanism. Use this version instead of + * gras_msgtype_declare when you change the semantic or syntax of a message and + * want your programs to be able to deal with both versions. Internally, each + * will be handled as an independent message type, so you can register + * differents for each of them. + */ +void +gras_msgtype_declare_v(const char *name, + short int version, + gras_datadesc_type_t payload) { + + gras_msgtype_declare_ext(name, version, + e_gras_msg_kind_oneway, payload, NULL); +} + /** @brief retrive an existing message type from its name. */ gras_msgtype_t gras_msgtype_by_name (const char *name) { return gras_msgtype_by_namev(name,0); @@ -191,10 +221,16 @@ gras_msgtype_t gras_msgtype_by_name (const char *name) { /** @brief retrive an existing message type from its name and version. */ gras_msgtype_t gras_msgtype_by_namev(const char *name, short int version) { - gras_msgtype_t res; + gras_msgtype_t res = NULL; char *namev = make_namev(name,version); + xbt_ex_t e; - res = (gras_msgtype_t)xbt_set_get_by_name(_gras_msgtype_set, namev); + TRY { + res = (gras_msgtype_t)xbt_set_get_by_name(_gras_msgtype_set, namev); + } CATCH(e) { + xbt_ex_free(e); + THROW1(not_found_error,0,"No registred message of that name: %s",name); + } if (name != namev) free(namev); @@ -222,13 +258,13 @@ gras_msgtype_t gras_msgtype_by_id(int id) { void gras_msg_wait_ext(double timeout, + gras_msgtype_t msgt_want, gras_socket_t expe_want, - int_f_pvoid_pvoid_t payl_filter, - void *filter_ctx, - gras_msgtype_t *msgt_got, - gras_socket_t *expe_got, - void *payl_got) { + gras_msg_filter_t filter, + void *filter_ctx, + + gras_msg_t msg_got) { s_gras_msg_t msg; double start, now; @@ -236,6 +272,7 @@ gras_msg_wait_ext(double timeout, int cpt; xbt_assert0(msgt_want,"Cannot wait for the NULL message"); + xbt_assert0(msg_got,"msg_got is an output parameter"); VERB1("Waiting for message '%s'",msgt_want->name); @@ -245,15 +282,9 @@ gras_msg_wait_ext(double timeout, if ( ( !msgt_want || (msg.type->code == msgt_want->code)) && (!expe_want || (!strcmp( gras_socket_peer_name(msg.expe), gras_socket_peer_name(expe_want)))) - && (!payl_filter || payl_filter(msg.payl,filter_ctx))) { - - if (expe_got) - *expe_got = msg.expe; - if (msgt_got) - *msgt_got = msg.type; - if (payl_got) - memcpy(payl_got, msg.payl, msg.payl_size); - free(msg.payl); + && (!filter || filter(&msg,filter_ctx))) { + + memcpy(msg_got,&msg,sizeof(s_gras_msg_t)); xbt_dynar_cursor_rm(pd->msg_queue, &cpt); VERB0("The waited message was queued"); return; @@ -265,19 +296,14 @@ gras_msg_wait_ext(double timeout, msg.expe = gras_trp_select(timeout - now + start); gras_msg_recv(msg.expe, &msg); + DEBUG0("Here"); if ( ( !msgt_want || (msg.type->code == msgt_want->code)) && (!expe_want || (!strcmp( gras_socket_peer_name(msg.expe), gras_socket_peer_name(expe_want)))) - && (!payl_filter || payl_filter(msg.payl,filter_ctx))) { - - if (expe_got) - *expe_got=msg.expe; - if (msgt_got) - *msgt_got = msg.type; - if (payl_got) - memcpy(payl_got, msg.payl, msg.payl_size); - free(msg.payl); + && (!filter || filter(&msg,filter_ctx))) { + + memcpy(msg_got,&msg,sizeof(s_gras_msg_t)); return; } @@ -309,10 +335,14 @@ gras_msg_wait(double timeout, gras_msgtype_t msgt_want, gras_socket_t *expeditor, void *payload) { + s_gras_msg_t msg; return gras_msg_wait_ext(timeout, msgt_want, NULL, NULL, NULL, - NULL, expeditor, payload); + &msg); + memcpy(payload,msg.payl,msg.payl_size); + free(msg.payl); + *expeditor = msg.expe; } @@ -323,7 +353,7 @@ gras_msg_send(gras_socket_t sock, gras_msgtype_t msgtype, void *payload) { - gras_msg_send_ext(sock, e_gras_msg_kind_oneway, msgtype, payload); + gras_msg_send_ext(sock, e_gras_msg_kind_oneway,0, msgtype, payload); } /** @brief Handle an incomming message or timer (or wait up to \a timeOut seconds) @@ -341,13 +371,11 @@ gras_msg_handle(double timeOut) { int cpt; s_gras_msg_t msg; - gras_socket_t expeditor=NULL; - void *payload=NULL; - gras_msgtype_t msgtype=NULL; gras_msg_procdata_t pd=(gras_msg_procdata_t)gras_libdata_by_id(gras_msg_libdata_id); gras_cblist_t *list=NULL; gras_msg_cb_t cb; + s_gras_msg_cb_ctx_t ctx; int timerexpected, timeouted; xbt_ex_t e; @@ -372,12 +400,9 @@ gras_msg_handle(double timeOut) { if (xbt_dynar_length(pd->msg_queue)) { DEBUG0("Get a message from the queue"); xbt_dynar_shift(pd->msg_queue,&msg); - expeditor = msg.expe; - msgtype = msg.type; - payload = msg.payl; } else { TRY { - expeditor = gras_trp_select(timeOut); + msg.expe = gras_trp_select(timeOut); } CATCH(e) { if (e.category != timeout_error) RETHROW; @@ -388,12 +413,12 @@ gras_msg_handle(double timeOut) { if (!timeouted) { TRY { /* FIXME: if not the right kind, queue it and recall ourself or goto >:-) */ - gras_msg_recv(expeditor, &msg); - msgtype = msg.type; - payload = msg.payl; + gras_msg_recv(msg.expe, &msg); + DEBUG0("Here"); + } CATCH(e) { RETHROW1("Error caught while receiving a message on select()ed socket %p: %s", - expeditor); + msg.expe); } } } @@ -424,7 +449,7 @@ gras_msg_handle(double timeOut) { /* A message was already there or arrived in the meanwhile. handle it */ xbt_dynar_foreach(pd->cbl_list,cpt,list) { - if (list->id == msgtype->code) { + if (list->id == msg.type->code) { break; } else { list=NULL; @@ -432,24 +457,65 @@ gras_msg_handle(double timeOut) { } if (!list) { INFO1("No callback for the incomming '%s' message. Discarded.", - msgtype->name); + msg.type->name); WARN0("FIXME: gras_datadesc_free not implemented => leaking the payload"); return; } - xbt_dynar_foreach(list->cbs,cpt,cb) { - VERB3("Use the callback #%d (@%p) for incomming msg %s", - cpt+1,cb,msgtype->name); - if ((*cb)(expeditor,payload)) { - /* cb handled the message */ - free(payload); - return; + ctx.expeditor = msg.expe; + ctx.ID = msg.ID; + ctx.msgtype = msg.type; + + switch (msg.type->kind) { + case e_gras_msg_kind_oneway: + case e_gras_msg_kind_rpccall: + TRY { + xbt_dynar_foreach(list->cbs,cpt,cb) { + VERB3("Use the callback #%d (@%p) for incomming msg %s", + cpt+1,cb,msg.type->name); + if ((*cb)(&ctx,msg.payl)) { + /* cb handled the message */ + free(msg.payl); + return; + } + } + } CATCH(e) { + if (msg.type->kind == e_gras_msg_kind_rpccall) { + /* The callback raised an exception, propagate it on the network */ + e.host = (char*)gras_os_myname(); +#ifdef HAVE_EXECINFO_H + e.bt_strings = backtrace_symbols (e.bt, e.used); +#endif + gras_msg_send_ext(msg.expe, e_gras_msg_kind_rpcerror , msg.ID, msg.type, &e); + e.host = NULL; + INFO2("RPC callback raised an exception, which were propagated back to %s:%d", + gras_socket_peer_name(msg.expe), gras_socket_peer_port(msg.expe)); + xbt_ex_free(e); + return; + } + RETHROW; } + /* FIXME: gras_datadesc_free not implemented => leaking the payload */ + THROW1(mismatch_error,0, + "Message '%s' refused by all registered callbacks", msg.type->name); + break; + + + case e_gras_msg_kind_rpcanswer: + INFO1("Unexpected RPC answer discarded (type: %s)", msg.type->name); + WARN0("FIXME: gras_datadesc_free not implemented => leaking the payload"); + return; + + case e_gras_msg_kind_rpcerror: + INFO1("Unexpected RPC error discarded (type: %s)", msg.type->name); + WARN0("FIXME: gras_datadesc_free not implemented => leaking the payload"); + return; + + default: + THROW1(unknown_error,0, + "Cannot handle messages of kind %d yet",msg.type->kind); } - /* FIXME: gras_datadesc_free not implemented => leaking the payload */ - THROW1(mismatch_error,0, - "Message '%s' refused by all registered callbacks", msgtype->name); } void @@ -529,3 +595,8 @@ gras_cb_unregister(gras_msgtype_t msgtype, VERB1("Ignoring removal of unexisting callback to msg id %d", msgtype->code); } + +/** \brief Retrieve the expeditor of the message */ +gras_socket_t gras_msg_cb_ctx_from(gras_msg_cb_ctx_t ctx) { + return ctx->expeditor; +} diff --git a/src/gras/Msg/msg_private.h b/src/gras/Msg/msg_private.h index a14458081b..8366af1802 100644 --- a/src/gras/Msg/msg_private.h +++ b/src/gras/Msg/msg_private.h @@ -32,29 +32,15 @@ extern char _GRAS_header[6]; extern int gras_msg_libdata_id; /* The identifier of our libdata */ -typedef enum { - e_gras_msg_kind_unknown = 0, - e_gras_msg_kind_oneway = 1 - /* future: - method call (answer expected; sessionID attached) - successful return (usual datatype attached, with sessionID) - error return (payload = exception) - [+ call cancel, and others] - even after: - forwarding request and other application level routing stuff - group communication - */ - -} e_gras_msg_kind_t; - -/** @brief Message instance */ -typedef struct { - gras_socket_t expe; - e_gras_msg_kind_t kind; - gras_msgtype_t type; - void *payl; - int payl_size; -} s_gras_msg_t, *gras_msg_t; +extern const char *e_gras_msg_kind_names[e_gras_msg_kind_count]; + +/* declare either regular messages or RPC or whatever */ +void +gras_msgtype_declare_ext(const char *name, + short int version, + e_gras_msg_kind_t kind, + gras_datadesc_type_t payload_request, + gras_datadesc_type_t payload_answer); /** * gras_msgtype_t: @@ -69,7 +55,9 @@ typedef struct s_gras_msgtype { /* payload */ short int version; + e_gras_msg_kind_t kind; gras_datadesc_type_t ctn_type; + gras_datadesc_type_t answer_type; /* only used for RPC */ } s_gras_msgtype_t; extern xbt_set_t _gras_msgtype_set; /* of gras_msgtype_t */ @@ -81,6 +69,7 @@ void gras_msg_recv(gras_socket_t sock, gras_msg_t msg/*OUT*/); void gras_msg_send_ext(gras_socket_t sock, e_gras_msg_kind_t kind, + unsigned long int ID, gras_msgtype_t msgtype, void *payload); @@ -98,6 +87,18 @@ typedef struct s_gras_cblist gras_cblist_t; void gras_cbl_free(void *); /* used to free the memory at the end */ void gras_cblist_free(void *cbl); +/** + * gras_msg_cbctx_t: + * + * Context associated to a given callback (to either regular message or RPC) + */ +struct s_gras_msg_cb_ctx { + gras_socket_t expeditor; + gras_msgtype_t msgtype; + unsigned long int ID; + +}; +typedef struct s_gras_msg_cb_ctx s_gras_msg_cb_ctx_t; /* ********* * * * TIMER * * @@ -113,4 +114,5 @@ typedef struct { double gras_msg_timer_handle(void); + #endif /* GRAS_MESSAGE_PRIVATE_H */ diff --git a/src/gras/Msg/rl_msg.c b/src/gras/Msg/rl_msg.c index bfbd5e4b15..c4f1be2d6d 100644 --- a/src/gras/Msg/rl_msg.c +++ b/src/gras/Msg/rl_msg.c @@ -18,10 +18,12 @@ XBT_LOG_DEFAULT_CATEGORY(gras_msg); void gras_msg_send_ext(gras_socket_t sock, e_gras_msg_kind_t kind, + unsigned long int ID, gras_msgtype_t msgtype, void *payload) { static gras_datadesc_type_t string_type=NULL; + static gras_datadesc_type_t ulong_type=NULL; char c_kind=(char)kind; if (!msgtype) @@ -32,15 +34,39 @@ void gras_msg_send_ext(gras_socket_t sock, string_type = gras_datadesc_by_name("string"); xbt_assert(string_type); } + if (!ulong_type) { + ulong_type = gras_datadesc_by_name("unsigned long int"); + xbt_assert(ulong_type); + } DEBUG3("send '%s' to %s:%d", msgtype->name, gras_socket_peer_name(sock),gras_socket_peer_port(sock)); gras_trp_send(sock, _GRAS_header, 6, 1 /* stable */); gras_trp_send(sock, &c_kind, 1, 1 /* stable */); - + switch (kind) { + case e_gras_msg_kind_oneway: + break; + + case e_gras_msg_kind_rpccall: + case e_gras_msg_kind_rpcanswer: + case e_gras_msg_kind_rpcerror: + gras_datadesc_send(sock,ulong_type,&ID); + break; + + default: + THROW1(unknown_error,0,"Unknown msg kind %d",kind); + } + gras_datadesc_send(sock, string_type, &msgtype->name); - if (msgtype->ctn_type) - gras_datadesc_send(sock, msgtype->ctn_type, payload); + if (kind == e_gras_msg_kind_rpcerror) { + /* error on remote host, carfull, payload is an exception */ + gras_datadesc_send(sock, gras_datadesc_by_name("ex_t"),payload); + } else { + /* regular message */ + if (msgtype->ctn_type) + gras_datadesc_send(sock, msgtype->ctn_type, payload); + } + gras_trp_flush(sock); } @@ -53,6 +79,7 @@ gras_msg_recv(gras_socket_t sock, xbt_ex_t e; static gras_datadesc_type_t string_type=NULL; + static gras_datadesc_type_t ulong_type=NULL; char header[6]; int cpt; int r_arch; @@ -65,6 +92,11 @@ gras_msg_recv(gras_socket_t sock, string_type=gras_datadesc_by_name("string"); xbt_assert(string_type); } + if (!ulong_type) { + ulong_type = gras_datadesc_by_name("unsigned long int"); + xbt_assert(ulong_type); + } + TRY { gras_trp_recv(sock, header, 6); @@ -86,6 +118,20 @@ gras_msg_recv(gras_socket_t sock, DEBUG2("Handle an incoming message using protocol %d (remote is %s)", (int)header[4],gras_datadesc_arch_name(r_arch)); + switch (msg->kind) { + case e_gras_msg_kind_oneway: + break; + + case e_gras_msg_kind_rpccall: + case e_gras_msg_kind_rpcanswer: + case e_gras_msg_kind_rpcerror: + gras_datadesc_recv(sock,ulong_type,r_arch, &msg->ID); + break; + + default: + THROW_IMPOSSIBLE; + } + gras_datadesc_recv(sock, string_type, r_arch, &msg_name); TRY { msg->type = (gras_msgtype_t)xbt_set_get_by_name(_gras_msgtype_set,msg_name); @@ -96,16 +142,25 @@ gras_msg_recv(gras_socket_t sock, } free(msg_name); - if (msg->type->ctn_type) { - msg->payl_size=gras_datadesc_size(msg->type->ctn_type); - xbt_assert2(msg->payl_size > 0, - "%s %s", - "Dynamic array as payload is forbided for now (FIXME?).", - "Reference to dynamic array is allowed."); - msg->payl = xbt_malloc(msg->payl_size); - gras_datadesc_recv(sock, msg->type->ctn_type, r_arch, msg->payl); + if (msg->kind == e_gras_msg_kind_rpcerror) { + /* error on remote host. Carfull with that exception, eugene */ + msg->payl_size=gras_datadesc_size(gras_datadesc_by_name("ex_t")); + msg->payl=xbt_malloc(msg->payl_size); + gras_datadesc_recv(sock, gras_datadesc_by_name("ex_t"), r_arch, msg->payl); + } else { - msg->payl = NULL; - msg->payl_size = 0; + /* regular message */ + if (msg->type->ctn_type) { + msg->payl_size=gras_datadesc_size(msg->type->ctn_type); + xbt_assert2(msg->payl_size > 0, + "%s %s", + "Dynamic array as payload is forbided for now (FIXME?).", + "Reference to dynamic array is allowed."); + msg->payl = xbt_malloc(msg->payl_size); + gras_datadesc_recv(sock, msg->type->ctn_type, r_arch, msg->payl); + } else { + msg->payl = NULL; + msg->payl_size = 0; + } } } diff --git a/src/gras/Msg/rpc.c b/src/gras/Msg/rpc.c new file mode 100644 index 0000000000..a3c09c5ee1 --- /dev/null +++ b/src/gras/Msg/rpc.c @@ -0,0 +1,119 @@ +/* $Id$ */ + +/* rpc - RPC implementation on top of GRAS messages */ + +/* Copyright (c) 2005 Martin Quinson. All rights reserved. */ + +/* This program is free software; you can redistribute it and/or modify it + * under the terms of the license (GNU LGPL) which comes with this package. */ + +#include "gras/Msg/msg_private.h" + +//XBT_LOG_NEW_DEFAULT_SUBCATEGORY(gras_rpc,gras_msg,"RPCing"); + +xbt_set_t _gras_rpctype_set = NULL; + +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(gras_rpc,gras_msg,"RPC mecanism"); + + +/** @brief declare a new versionned RPC type of the given name and payloads + * + * @param name: name as it should be used for logging messages (must be uniq) + * @param version: something like versionning symbol + * @param payload: datadescription of the payload + * + * Registers a new RPC message to the GRAS mechanism. RPC are constituted of a pair + * of messages. + */ +void +gras_msgtype_declare_rpc(const char *name, + gras_datadesc_type_t payload_request, + gras_datadesc_type_t payload_answer) { + + gras_msgtype_declare_ext(name, 0, + e_gras_msg_kind_rpccall, + payload_request, payload_answer); + +} + +/** @brief declare a new versionned RPC type of the given name and payloads + * + * @param name: name as it should be used for logging messages (must be uniq) + * @param version: something like versionning symbol + * @param payload: datadescription of the payload + * + * Registers a new RPC message to the GRAS mechanism. RPC are constituted of a pair + * of messages. + * + * Use this version instead of gras_rpctype_declare when you change the + * semantic or syntax of a message and want your programs to be able to deal + * with both versions. Internally, each will be handled as an independent + * message type, so you can register differents for each of them. + */ +void +gras_msgtype_declare_rpc_v(const char *name, + short int version, + gras_datadesc_type_t payload_request, + gras_datadesc_type_t payload_answer) { + + gras_msgtype_declare_ext(name, version, + e_gras_msg_kind_rpccall, + payload_request, payload_answer); + +} + +static unsigned long int last_msg_ID = 0; + +static int msgfilter_rpcID(gras_msg_t msg, void* ctx) { + unsigned long int ID= *(unsigned long int*)ctx; + int res = msg->ID == ID && + (msg->kind == e_gras_msg_kind_rpcanswer || msg->kind == e_gras_msg_kind_rpcerror); + + DEBUG5("Filter a message of ID %lu, type '%s' and kind '%s'. Waiting for ID=%lu. %s", + msg->ID,msg->type->name,e_gras_msg_kind_names[msg->kind],ID, + res?"take it": "reject"); + return res; +} + +/** @brief Conduct a RPC call + * + */ +void gras_msg_rpccall(gras_socket_t server, + double timeOut, + gras_msgtype_t msgtype, + void *request, void *answer) { + + unsigned long int msg_ID = last_msg_ID++; + s_gras_msg_t received; + + DEBUG2("Send a RPC of type '%s' (ID=%lu)",msgtype->name,msg_ID); + + gras_msg_send_ext(server, e_gras_msg_kind_rpccall, msg_ID, msgtype, request); + gras_msg_wait_ext(timeOut, + msgtype, NULL, msgfilter_rpcID, &msg_ID, + &received); + if (received.kind == e_gras_msg_kind_rpcerror) { + /* Damn. Got an exception. Extract it and revive it */ + xbt_ex_t e; + VERB0("Raise a remote exception"); + memcpy(&e,received.payl,received.payl_size); + free(received.payl); + memcpy((void*)&(__xbt_ex_ctx()->ctx_ex),&e,sizeof(xbt_ex_t)); + DO_THROW(__xbt_ex_ctx()->ctx_ex); + + } + memcpy(answer,received.payl,received.payl_size); + free(received.payl); +} + + +/** @brief Return the result of a RPC call + * + * It done before the actual return of the callback so that the callback can do + * some cleanups before leaving. + */ + +void gras_msg_rpcreturn(double timeOut,gras_msg_cb_ctx_t ctx,void *answer) { + gras_msg_send_ext(ctx->expeditor, e_gras_msg_kind_rpcanswer, ctx->ID, ctx->msgtype, answer); +} + diff --git a/src/gras/Msg/sg_msg.c b/src/gras/Msg/sg_msg.c index 93a9ae18d3..97e612e178 100644 --- a/src/gras/Msg/sg_msg.c +++ b/src/gras/Msg/sg_msg.c @@ -17,8 +17,12 @@ #include "gras/Transport/transport_interface.h" /* gras_trp_chunk_send/recv */ #include "gras/Transport/transport_private.h" /* sock->data */ +XBT_LOG_EXTERNAL_CATEGORY(gras_msg); +XBT_LOG_DEFAULT_CATEGORY(gras_msg); + void gras_msg_send_ext(gras_socket_t sock, e_gras_msg_kind_t kind, + unsigned long int ID, gras_msgtype_t msgtype, void *payload) { @@ -33,12 +37,22 @@ void gras_msg_send_ext(gras_socket_t sock, msg=xbt_new0(s_gras_msg_t,1); msg->type=msgtype; - + msg->ID = ID; - msg->payl_size=gras_datadesc_size(msgtype->ctn_type); - msg->payl=xbt_malloc(msg->payl_size); - if (msgtype->ctn_type) - whole_payload_size = gras_datadesc_copy(msgtype->ctn_type,payload,msg->payl); + if (kind == e_gras_msg_kind_rpcerror) { + /* error on remote host, carfull, payload is an exception */ + msg->payl_size=gras_datadesc_size(gras_datadesc_by_name("ex_t")); + msg->payl=xbt_malloc(msg->payl_size); + whole_payload_size = gras_datadesc_copy(gras_datadesc_by_name("ex_t"), + payload,msg->payl); + } else { + msg->payl_size=gras_datadesc_size(msgtype->ctn_type); + msg->payl=xbt_malloc(msg->payl_size); + if (msgtype->ctn_type) + whole_payload_size = gras_datadesc_copy(msgtype->ctn_type, + payload, msg->payl); + } + msg->kind = kind; task=MSG_task_create(msgtype->name,0, @@ -47,6 +61,10 @@ void gras_msg_send_ext(gras_socket_t sock, if (MSG_task_put(task, sock_data->to_host,sock_data->to_chan) != MSG_OK) THROW0(system_error,0,"Problem during the MSG_task_put"); + VERB3("Sent a message type '%s' kind '%s' ID %lu", + msg->type->name, + e_gras_msg_kind_names[msg->kind], + msg->ID); } /* * receive the next message on the given socket. @@ -64,15 +82,23 @@ gras_msg_recv(gras_socket_t sock, xbt_assert0(msg,"msg is an out parameter of gras_msg_recv..."); + if (MSG_task_get(&task, pd->chan) != MSG_OK) THROW0(system_error,0,"Error in MSG_task_get()"); msg_got=MSG_task_get_data(task); + msg_got->expe= msg->expe; memcpy(msg,msg_got,sizeof(s_gras_msg_t)); free(msg_got); if (MSG_task_destroy(task) != MSG_OK) THROW0(system_error,0,"Error in MSG_task_destroy()"); + + VERB3("Received a message type '%s' kind '%s' ID %lu",// from %s", + msg->type->name, + e_gras_msg_kind_names[msg->kind], + msg->ID); + // gras_socket_peer_name(msg->expe)); } -- 2.20.1