MqContextC_SendApi_Basics_RB_API

MqContextC - finish the send-data-block and call synchronous/asynchronous a remote-service … More...

Collaboration diagram for MqContextC_SendApi_Basics_RB_API:

Functions
static OT_ProcRet	rbmqmsgque_MqContextC_SendEND (MqContextC_ARGS)
	Ruby: ctx.SendEND(token:string[4], ?timeout:MkTimeoutE|int32=DEFAULT?) → C-API MqContextC - finish the send-data-block and call synchronous/asynchronous a remote-service …
static OT_ProcRet	rbmqmsgque_MqContextC_SendEND_AND_CALLBACK (MqContextC_ARGS)
	Ruby: ctx.SendEND_AND_CALLBACK(token:string[4], callback:callable, ?timeout:MkTimeoutE|int32=DEFAULT?) → C-API finish the send-data-block, call the remote service, do not-wait for the result but expect the result on a callback …
static OT_ProcRet	rbmqmsgque_MqContextC_SendEND_AND_SUB (MqContextC_ARGS)
	Ruby: ctx.SendEND_AND_SUB(token:string[4], callback:callable, ?timeout:MkTimeoutE|int32=DEFAULT?) → C-API finish the send-data-block, call the remote service, do wait for the result and expect multiple sub-results on a callback …
static OT_ProcRet	rbmqmsgque_MqContextC_SendEND_AND_TRANSACTION (MqContextC_ARGS)
	Ruby: ctx.SendEND_AND_TRANSACTION(token:string[4], callback:string[4], ?timeout:MkTimeoutE|int32=DEFAULT?) → C-API finish the send-data-block, call the remote service to do a longterm-transaction-call …
static OT_ProcRet	rbmqmsgque_MqContextC_SendEND_AND_WAIT (MqContextC_ARGS)
	Ruby: ctx.SendEND_AND_WAIT(token:string[4], ?timeout:MkTimeoutE|int32=DEFAULT?) → C-API finish the send-data-block, call the remote service and wait for result…
static OT_ProcRet	rbmqmsgque_MqContextC_SendSTART (MqContextC_ARGS)
	Ruby: ctx.SendSTART() → C-API initialize the send-data-package. …
static OT_ProcRet	rbmqmsgque_MqContextC_SendSYNC (MqContextC_ARGS)
	Ruby: ctx.SendSYNC() → C-API garantee that all pending asynchronous-service-calls are processed. …

Detailed Description

MqContextC - finish the send-data-block and call synchronous/asynchronous a remote-service …

calling a remote service and wait timeout seconds for an result. If timeout == 0 it is an asynchronous-service-call and if the timeout > 0 it is a synchronous-service-call.

service-call	blocking	timeout
synchronous	yes	timeout > 0
asynchronous	no	timeout == 0

blocking mean waiting max timeout seconds to finishing the service-call:

• If the service-call is finished in less than timeout seconds… the results are available and can be processed.
• If the service-call is NOT finished in timeout seconds… an timeout-error is created and the transaction will be canceled.

If an error was raised on the server during the service-processing… the following error-handling will be available

1. on a synchronous-service-call the error will be the result of the service-call
2. on a asynchronous-service-call with callback the error will be the result of the callback
3. on a asynchronous-service-call without callback the error will be send asynchronous from the server to the client . On the client the error will be raised on the NEXT event-handlng-command or as background-error if the MqSetupS::BgError function was defined.

Parameters

[in]	mkrt	the MkRuntimeS instance to work on - the runtime argument, used by MK_RT_CALL (C-only)
[in]	ctx	the MqContextS instance to work on
[in]	token	the MqContextC SERVICE API to identify the service
[in]	timeout	in seconds until a timeout-error is raised (possible values like ProcessEvent) (MK_TIMEOUT_DEFAULT=0)

Exceptions

MkExceptionC

→ The default-exception from the Programming-Language-Micro-Kernel (PLMK)

See also

MqSendSYNC

Function Documentation

rbmqmsgque_MqContextC_SendEND()

static OT_ProcRet rbmqmsgque_MqContextC_SendEND ( MqContextC_ARGS )

static

Ruby: ctx.SendEND(token:string[4], ?timeout:MkTimeoutE|int32=DEFAULT?) → C-API
MqContextC - finish the send-data-block and call synchronous/asynchronous a remote-service …

Definition at line 2303 of file MqContextC_rb.c.

                                                           {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,SendEND_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendEND (hdl, token, timeout));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}

rbmqmsgque_MqContextC_SendEND_AND_CALLBACK()

static OT_ProcRet rbmqmsgque_MqContextC_SendEND_AND_CALLBACK ( MqContextC_ARGS )

static

Ruby: ctx.SendEND_AND_CALLBACK(token:string[4], callback:callable, ?timeout:MkTimeoutE|int32=DEFAULT?) → C-API
finish the send-data-block, call the remote service, do not-wait for the result but expect the result on a callback …

Definition at line 2318 of file MqContextC_rb.c.

                                                                        {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,3,SendEND_AND_CALLBACK_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  OT_SETUP_CALLABLE(callback)
  OT_CHECK_REQUIRED(OT_CHECK_CALLABLE(callback))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendEND_AND_CALLBACK (hdl, token, NS(ServiceCall), callback, NS(ServiceFree), timeout));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}

rbmqmsgque_MqContextC_SendEND_AND_SUB()

static OT_ProcRet rbmqmsgque_MqContextC_SendEND_AND_SUB ( MqContextC_ARGS )

static

Ruby: ctx.SendEND_AND_SUB(token:string[4], callback:callable, ?timeout:MkTimeoutE|int32=DEFAULT?) → C-API
finish the send-data-block, call the remote service, do wait for the result and expect multiple sub-results on a callback …

Definition at line 2336 of file MqContextC_rb.c.

                                                                   {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,3,SendEND_AND_SUB_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  OT_SETUP_CALLABLE(callback)
  OT_CHECK_REQUIRED(OT_CHECK_CALLABLE(callback))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendEND_AND_SUB (hdl, token, NS(ServiceCall), callback, NS(ServiceFree), timeout));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}

rbmqmsgque_MqContextC_SendEND_AND_TRANSACTION()

static OT_ProcRet rbmqmsgque_MqContextC_SendEND_AND_TRANSACTION ( MqContextC_ARGS )

static

Ruby: ctx.SendEND_AND_TRANSACTION(token:string[4], callback:string[4], ?timeout:MkTimeoutE|int32=DEFAULT?) → C-API
finish the send-data-block, call the remote service to do a longterm-transaction-call …

Definition at line 2354 of file MqContextC_rb.c.

                                                                           {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,3,SendEND_AND_TRANSACTION_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  MQ_TOK callback = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (callback))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendEND_AND_TRANSACTION (hdl, token, callback, timeout));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}

rbmqmsgque_MqContextC_SendEND_AND_WAIT()

static OT_ProcRet rbmqmsgque_MqContextC_SendEND_AND_WAIT ( MqContextC_ARGS )

static

Ruby: ctx.SendEND_AND_WAIT(token:string[4], ?timeout:MkTimeoutE|int32=DEFAULT?) → C-API
finish the send-data-block, call the remote service and wait for result…

Definition at line 2371 of file MqContextC_rb.c.

                                                                    {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,SendEND_AND_WAIT_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendEND_AND_WAIT (hdl, token, timeout));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}

rbmqmsgque_MqContextC_SendSTART()

static OT_ProcRet rbmqmsgque_MqContextC_SendSTART ( MqContextC_ARGS )

static

Ruby: ctx.SendSTART() → C-API
initialize the send-data-package. …

Definition at line 2386 of file MqContextC_rb.c.

                                                             {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendSTART_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendSTART (hdl));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}

rbmqmsgque_MqContextC_SendSYNC()

static OT_ProcRet rbmqmsgque_MqContextC_SendSYNC ( MqContextC_ARGS )

static

Ruby: ctx.SendSYNC() → C-API
garantee that all pending asynchronous-service-calls are processed. …

Definition at line 2397 of file MqContextC_rb.c.

                                                            {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendSYNC_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendSYNC (hdl));
  OT_retObj_SET_None;
  end: MK_UNUSED  /* LONG JUMP on error */
  OT_retObj_RETURN;
}