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;
}
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;
// 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;
}