TibrvMsg*
TibrvMsg::detach()
{
if ((_detached == TIBRV_TRUE) || (_status != TIBRV_OK))
return NULL;
// allocate new object
TibrvMsg * newmsg = new TibrvMsg();
if (newmsg == NULL) return NULL;
// detach if not yet detached
if (_detached == TIBRV_FALSE) // this is redundand but may be needed
{
TibrvStatus status;
if (_msg != NULL)
{
if ((status = tibrvMsg_Detach(_msg)) != TIBRV_OK)
{
delete newmsg;
return NULL;
}
}
_detached = TIBRV_TRUE;
}
newmsg->attach(_msg,TIBRV_TRUE);
// invalidate this handle so we won't try to delete it
_msg=NULL;
_status = TIBRV_NOT_INITIALIZED;
_detached = TIBRV_TRUE;
return newmsg;
}
void onMsg(TibrvListener* listener, TibrvMsg& msg)
{
const char* sendSubject = NULL;
const char* msgString = NULL;
// Get the subject name to which this message was sent
msg.getSendSubject(sendSubject);
// Convert the incoming message to a string
msg.convertToString(msgString);
printf("Received message on subject %s: %s\n",
sendSubject, msgString);
fflush(stdout);
}
void onMsg(TibrvListener* listener, TibrvMsg& msg)
{
const char* msgString = NULL;
// Convert the incoming message to a string
msg.convertToString(msgString);
// Report we are processing the message
printf("Processing message %s\n",msgString);
fflush(stdout);
// Imitate delay of one second
waitQueue.timedDispatch((tibrv_f64)1.0);
/* Increase count of processed messages. In real world
* access to this variable should be guarded
* because we may be changing it from multiple
* dispatcher threads at the same time.
*/
processedMessageCount++;
/* If we have processed all messages then report it
* and create a timer on the trigger queue so the
* dispatch call on that queue returns.
*/
if (processedMessageCount == TOTAL_MESSAGES)
{
/* we don't need to keep the timer here */
TibrvTimer* timer = new TibrvTimer();
timer->create(&triggerQueue,
new TimerCallback(),
(tibrv_f64)0, /* no delay */
NULL);
}
}
TibrvStatus
TibrvMsg::updateMsg(const char* fieldName,const TibrvMsg& msg, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
return tibrvMsg_UpdateMsgEx(_msg,fieldName,msg.getHandle(),fieldId);
}
// ////////////////////////////////////////////////////////////////////////////
// Update TibrvMsgDateTime
void UpdateRvField(TibrvMsg &msg, const char *field_name,
const TibrvMsgDateTime &value, tibrv_u16 field_id)
{
TibrvStatus rv_status;
if ((rv_status = msg.updateDateTime(field_name, value, field_id)) != TIBRV_OK)
ThrowIfUpdateRvFieldError(rv_status, field_name, field_id);
}
// ////////////////////////////////////////////////////////////////////////////
// Update tibrv_ipport16
void UpdateRvFieldIPPort16(TibrvMsg &msg, const char *field_name,
const tibrv_ipport16 &value, tibrv_u16 field_id)
{
TibrvStatus rv_status;
if ((rv_status = msg.updateIPPort16 (field_name, value, field_id)) != TIBRV_OK)
ThrowIfUpdateRvFieldError(rv_status, field_name, field_id);
}
// ////////////////////////////////////////////////////////////////////////////
// Update unsigned 64-bit long
void UpdateRvField(TibrvMsg &msg, const char *field_name,
unsigned TIBRV_I64_TYPE value, tibrv_u16 field_id)
{
TibrvStatus rv_status;
if ((rv_status = msg.updateU64(field_name, value, field_id)) != TIBRV_OK)
ThrowIfUpdateRvFieldError(rv_status, field_name, field_id);
}
// ////////////////////////////////////////////////////////////////////////////
// Update signed short
void UpdateRvField(TibrvMsg &msg, const char *field_name, signed short value,
tibrv_u16 field_id)
{
TibrvStatus rv_status;
if ((rv_status = msg.updateI16(field_name, value, field_id)) != TIBRV_OK)
ThrowIfUpdateRvFieldError(rv_status, field_name, field_id);
}
// ////////////////////////////////////////////////////////////////////////////
// Update XML byte string
void UpdateRvFieldXml(TibrvMsg &msg, const char *field_name,
const std::string &value, tibrv_u16 field_id)
{
TibrvStatus rv_status;
if ((rv_status = msg.updateXml(field_name, value.c_str(),
static_cast<unsigned int>(value.size()), field_id)) != TIBRV_OK)
ThrowIfUpdateRvFieldError(rv_status, field_name, field_id);
}
// ////////////////////////////////////////////////////////////////////////////
// Update XML byte string
void UpdateRvFieldXml(TibrvMsg &msg, const char *field_name, const char *value,
tibrv_u16 field_id)
{
TibrvStatus rv_status;
if ((rv_status = msg.updateXml(field_name, value,
static_cast<unsigned int>(strlen(value)), field_id)) != TIBRV_OK)
ThrowIfUpdateRvFieldError(rv_status, field_name, field_id);
}
// ////////////////////////////////////////////////////////////////////////////
// Update XML byte string
void UpdateRvFieldXml(TibrvMsg &msg, const char *field_name, unsigned int length,
const void *value, tibrv_u16 field_id)
{
TibrvStatus rv_status;
if ((rv_status = msg.updateXml(field_name, value, length, field_id)) !=
TIBRV_OK)
ThrowIfUpdateRvFieldError(rv_status, field_name, field_id);
}
// ////////////////////////////////////////////////////////////////////////////
// Update bool
void UpdateRvField(TibrvMsg &msg, const char *field_name, bool value,
tibrv_u16 field_id)
{
TibrvStatus rv_status;
if ((rv_status = msg.updateBool(field_name,
((value) ? TIBRV_TRUE : TIBRV_FALSE), field_id)) != TIBRV_OK)
ThrowIfUpdateRvFieldError(rv_status, field_name, field_id);
}
TibrvStatus
TibrvMsg::createCopy(TibrvMsg& copy)
{
_create();
if (_status != TIBRV_OK) return _status;
tibrvMsg newmsg;
tibrv_status status = tibrvMsg_CreateCopy(_msg,&newmsg);
if (status == TIBRV_OK)
copy.attach(newmsg,TIBRV_TRUE);
return status;
}
TibrvStatus
TibrvMsg::getMsg(const char* fieldName, TibrvMsg& subMessage, tibrv_u16 fieldId)
{
_create();
if (_status != TIBRV_OK) return TibrvStatus(_status);
TibrvStatus status;
tibrvMsg msg;
status = tibrvMsg_GetMsgEx(_msg,fieldName,&msg,fieldId);
if (status != TIBRV_OK)
return status;
subMessage.attach(msg);
return TIBRV_OK;
}
TibrvMsg::TibrvMsg(const TibrvMsg& msg)
{
_msg = NULL;
_detached = TIBRV_TRUE;
_initsize = 0;
const void* bytes;
if ((_status = tibrvMsg_GetAsBytes(msg.getHandle(),&bytes)) != TIBRV_OK)
return;
if ((_status = tibrvMsg_CreateFromBytes(&_msg,bytes)) != TIBRV_OK)
_msg = NULL;
}
int main(int argc, char** argv)
{
TibrvStatus status;
int i;
// open Tibrv
status = Tibrv::open();
if (status != TIBRV_OK)
{
fprintf(stderr,"Error: could not open TIB/RV, status=%d, text=%s\n",
(int)status,status.getText());
exit(-1);
}
// get process transport
TibrvTransport* transport = Tibrv::processTransport();
// create two queues
TibrvQueue queue1;
TibrvQueue queue2;
queue1.create();
queue2.create();
// Set priorities
queue1.setPriority(1);
queue2.setPriority(2);
// Create queue group and add queues
TibrvQueueGroup group;
group.create();
group.add(&queue1);
group.add(&queue2);
// Create callback object
MsgCallback* callback = new MsgCallback();
// Create listeners
TibrvListener listener1, listener2;
listener1.create(&queue1,callback,transport,subject1,NULL);
listener2.create(&queue2,callback,transport,subject2,NULL);
TibrvMsg msg;
// Send 10 messages on subject1
msg.setSendSubject(subject1);
for (i=0; i<10; i++)
{
char valstr[32];
sprintf(valstr,"value-1-%d",(i+1));
msg.updateString("field",valstr);
transport->send(msg);
}
// Send 10 messages on subject2
msg.setSendSubject(subject2);
for (i=0; i<10; i++)
{
char valstr[32];
sprintf(valstr,"value-2-%d",(i+1));
msg.updateString("field",valstr);
transport->send(msg);
}
// Dispatch the group. When all events are
// dispatched timedDispatch() will return
// TIBRV_TIMEOUT so we'll break out the while() loop.
while (group.timedDispatch(1) == TIBRV_OK);
// Close Tibrv
Tibrv::close();
return 0;
}
static PyObject*
typemethod_send(PyTibrvNetTransportObject *self, PyObject *args, PyObject *kwds)
{
char *send_subject = NULL, *reply_subject = NULL;
PyObject* message_dictionary;
static char *kwlist[] = {"sendsubject", "message", "replysubject", NULL};
if (! PyArg_ParseTupleAndKeywords(args, kwds, "sO|s", kwlist, &send_subject, &message_dictionary, &reply_subject))
return NULL;
TibrvStatus status;
TibrvMsg msg;
status = msg.setSendSubject(send_subject);
if (status != TIBRV_OK)
{
PyErr_Tibrv(status);
return NULL;
}
if (reply_subject != 0)
msg.setReplySubject(reply_subject);
if (!PyDict_Check(message_dictionary))
{
PyErr_SetString(PyExc_TypeError, "expected message to be dictionary");
return NULL;
}
PyObject *key, *value;
int pos = 0;
while (PyDict_Next(message_dictionary, &pos, &key, &value))
{
if (PyObject_Is<const char*>(key))
{
const char* mnemonic = PyObject_As<const char*>(key);
if (PyObject_Is<tibrv_i32>(value))
status = msg.addI32(mnemonic, PyObject_As<tibrv_i32>(value));
else if (PyObject_Is<const char*>(value))
status = msg.addString(mnemonic, PyObject_As<const char*>(value));
else if (PyObject_Is<tibrv_f64>(value))
status = msg.addF64(mnemonic, PyObject_As<tibrv_f64>(value));
else if (PyObject_Is<tibrv_bool>(value))
status = msg.addBool(mnemonic, PyObject_As<tibrv_bool>(value));
else if (PyObject_Is<tibrvMsgDateTime>(value))
status = msg.addDateTime(mnemonic, PyObject_As<tibrvMsgDateTime>(value));
else
{
PyErr_SetString(PyExc_TypeError, "invalid type for tibco message");
return NULL;
}
if (status != TIBRV_OK)
{
PyErr_Tibrv(status);
return NULL;
}
}
}
status = self->transport->send(msg);
if (status != TIBRV_OK)
{
PyErr_Tibrv(status);
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
int main(int argc, char** argv)
{
TibrvStatus status;
int i, j;
// open Tibrv
status = Tibrv::open();
if (status != TIBRV_OK)
{
fprintf(stderr,"Error: could not open TIB/RV, status=%d, text=%s\n",
(int)status,status.getText());
exit(-1);
}
// Get process transport
TibrvTransport* transport = Tibrv::processTransport();
// Create the queue
TibrvQueue queue;
queue.create();
// Create trigger queue
triggerQueue.create();
// Create wait queue
waitQueue.create();
// Create listener
TibrvListener listener;
listener.create(&queue,new MsgCallback(),transport,subject,NULL);
// Create message and set send subject in it.
TibrvMsg msg;
msg.setSendSubject(subject);
// Create two dispatchers
TibrvDispatcher dispatcher1, dispatcher2;
dispatcher1.create(&queue);
dispatcher2.create(&queue);
// Get start time
startTime = time(0);
// We use this to track the message number
int msgIndex = 0;
// Report we are starting to publish messages
printf("Started publishing messages at %d seconds\n\n",
(int)(time(0)-startTime));
fflush(stdout);
// Start publishing two messages at a time
// every second, total of TOTAL_MESSAGES messages
for (i=0; i<TOTAL_MESSAGES/2; i++)
{
// Publish 2 messages
for (j=0; j<2; j++)
{
char str[32];
msgIndex++;
sprintf(str,"value-%d",msgIndex);
msg.updateString("field",str);
transport->send(msg);
}
/* Sleep for 1 second if we have not done publishing */
if (i < TOTAL_MESSAGES/2-1)
{
waitQueue.timedDispatch((tibrv_f64)1.0);
}
}
// Report we've published all messages
printf("\nStopped publishing messages at %d seconds\n\n",
(int)(time(0)-startTime));
fflush(stdout);
// We should not quit main because that will
// cause the program to quit before we
// process all messages.
// Wait until we process all messages and
// post an event into the trigger queue which
// will cause dispatch() to return.
triggerQueue.dispatch();
// Report we have processed all messages
printf("\nProcessed all messages in %d seconds\n",(int)(time(0)-startTime));
fflush(stdout);
// Close Tibrv
Tibrv::close();
return 0;
}