void tet_saEvtEventPublish(SaEvtEventHandleT *ptrEventHandle,
SaEvtEventIdT *ptrEvtId)
{
static int try_again_count;
gl_rc=saEvtEventPublish(*ptrEventHandle,gl_eventData,gl_eventDataSize,
ptrEvtId);
WHILE_TRY_AGAIN(gl_rc)
{
++try_again_count;
if(try_again_count==MAX_NUM_TRY_AGAINS)
{
printf("\n Publish API Crossed Max Try Agains: exiting \n");
break;
}
RETRY_SLEEP;
gl_rc=saEvtEventPublish(*ptrEventHandle,gl_eventData,gl_eventDataSize,
ptrEvtId);
if(gl_rc==SA_AIS_OK)
printf("\n Event Publish Try Again Count = %d\n",try_again_count);
}
resultSuccess("saEvtEventPublish() invoked",gl_rc);
printf("\nEvent Id (when published): %llu",*ptrEvtId);
strcpy (gl_eventData,"");
}
static SaAisErrorT csa113Comp_PublishEvent()
{
SaEvtEventIdT eventId = 0;
static int index = 0;
SaSizeT data_len = 0;
SaAisErrorT rc = SA_AIS_OK;
char *data = 0;
typedef void (*Generator)(char **, ClSizeT*);
//
// Note: to add a new generator, just define it above and then include
// the new functions name in the generators list.
// Next, maybe something that gets disk free info by way of getfsent
// and statfs?
static Generator generators[] =
{
generate_time_of_day,
generate_load_average
};
//
// every time through increment index and then set index to
// it's value modulo the number of entries in the generators
// array. This will cause us to cycle through the list of
// generators as we're called to publish events.
(*generators[index++])(&data, &data_len);
index %= (int)(sizeof generators / sizeof generators[0]);
if (data == 0 || data_len == 0)
{
clprintf(CL_LOG_SEV_ERROR, "No event data generated.");
return SA_AIS_ERR_NO_MEMORY;
}
clprintf(CL_LOG_SEV_INFO,"Publishing Event: %.*s\n",(int)data_len, data);
rc = saEvtEventPublish(eventHandle, (void *)data, data_len, &eventId);
if (rc != SA_AIS_OK)
{
clprintf(CL_LOG_SEV_ERROR,"Event publish attempt failed with error [%x]", rc);
}
clHeapFree(data);
return SA_AIS_OK;
}
static void testEvtMainLoop()
{
/* Main loop: Keep printing and publishing unless we are suspended */
int i=0;
SaAisErrorT saRc = SA_AIS_OK;
for(int i=0; i< LOOP_COUNT; i++)
{
//appPublishEvent();
ClEventIdT eventId = 0;
printf("Publishing Event\n");
ClCharT buff[40] = {0};
memset(buff,0,sizeof(buff));
sprintf(buff,"Event from external application_%d",i);
saRc = saEvtEventPublish(gTestInfo.eventHandle, (const void*)buff, strlen(buff), &eventId);
ClTimerTimeOutT delay;
delay.tsSec = 0;
delay.tsMilliSec = 200;
clOsalTaskDelay(delay);
}
}
static ClRcT
appPublishEvent()
{
ClEventIdT eventId = 0;
static int index = 0;
SaSizeT data_len = 0;
SaAisErrorT saRc = SA_AIS_OK;
char *data = 0;
typedef void (*Generator)(char **, ClSizeT*);
//
// Note: to add a new generator, just define it above and then include
// the new functions name in the generators list.
// Next, maybe something that gets disk free info by way of getfsent
// and statfs?
static Generator generators[] =
{
generate_time_of_day,
generate_load_average
};
//
// every time through increment index and then set index to
// it's value modulo the number of entries in the generators
// array. This will cause us to cycle through the list of
// generators as we're called to publish events.
(*generators[index++])(&data, &data_len);
index %= (int)(sizeof generators / sizeof generators[0]);
if (data == 0 || data_len == 0)
{
printf("no event data generated\n");
return CL_ERR_NO_MEMORY;
}
printf("Publishing Event: %.*s\n", (int)data_len, data);
saRc = saEvtEventPublish(gTestInfo.eventHandle, (void *)data, data_len, &eventId);
clHeapFree(data);
return CL_OK;
}
void
test_pub()
{
SaEvtHandleT handle;
SaEvtChannelHandleT channel_handle;
SaEvtEventHandleT event_handle;
SaEvtChannelOpenFlagsT flags;
SaNameT channel_name;
uint64_t test_retention;
SaSelectionObjectT fd;
int i;
struct timeval tv1, tv2, tv_elapsed;
int write_count = 10000;
int write_size = user_data_size;
SaEvtEventIdT event_id;
#ifdef EVENT_SUBSCRIBE
struct pollfd pfd;
int nfd;
int timeout = 1000;
#endif
int result;
flags = SA_EVT_CHANNEL_PUBLISHER |
#ifdef EVENT_SUBSCRIBE
SA_EVT_CHANNEL_SUBSCRIBER |
#endif
SA_EVT_CHANNEL_CREATE;
strcpy((char *)channel_name.value, channel);
channel_name.length = strlen(channel);
result = saEvtInitialize (&handle, &callbacks, &version);
if (result != SA_AIS_OK) {
printf("Event Initialize result: %d\n", result);
exit(1);
}
result = saEvtChannelOpen(handle, &channel_name, flags,
SA_TIME_MAX, &channel_handle);
if (result != SA_AIS_OK) {
printf("channel open result: %d\n", result);
goto evt_fin;
}
/*
* Publish with pattens
*/
printf("Publish\n");
#ifdef EVENT_SUBSCRIBE
result = saEvtEventSubscribe(channel_handle,
&subscribe_filters,
subscription_id);
if (result != SA_AIS_OK) {
printf("event subscribe result: %d\n", result);
result = saEvtChannelClose(channel_handle);
if (result != SA_AIS_OK)
printf("Channel close result: %d\n", result);
result = saEvtFinalize(handle);
if (result != SA_AIS_OK)
printf("Finalize result: %d\n", result);
return;
}
#endif
result = saEvtEventAllocate(channel_handle, &event_handle);
if (result != SA_AIS_OK) {
printf("event Allocate result: %d\n", result);
goto evt_free;
}
strcpy((char *)test_pub_name.value, pubname);
test_pub_name.length = strlen(pubname);
test_retention = ret_time;
result = saEvtEventAttributesSet(event_handle,
&evt_pat_set_array,
TEST_PRIORITY,
test_retention,
&test_pub_name);
if (result != SA_AIS_OK) {
printf("event set attr result(2): %d\n", result);
goto evt_free;
}
gettimeofday (&tv1, NULL);
for (i = 0; i < write_count; i++) {
result = saEvtEventPublish(event_handle, user_data,
write_size, &event_id);
if (result != SA_AIS_OK) {
printf("event Publish result(2): %d\n", result);
goto evt_close;
}
}
gettimeofday (&tv2, NULL);
timersub (&tv2, &tv1, &tv_elapsed);
printf ("%5d Writes ", write_count);
printf ("%5d bytes per write ", write_size);
printf ("%7.3f Seconds runtime ",
(tv_elapsed.tv_sec + (tv_elapsed.tv_usec / 1000000.0)));
printf ("%9.3f TP/s ",
((float)write_count) / (tv_elapsed.tv_sec + (tv_elapsed.tv_usec / 1000000.0)));
printf ("%7.3f MB/s.\n",
((float)write_count) * ((float)write_size) / ((tv_elapsed.tv_sec + (
tv_elapsed.tv_usec / 1000000.0)) * 1000000.0));
exit (1);
printf("Published event ID: %llx\n", (unsigned long long)event_id);
/*
* See if we got the event
*/
result = saEvtSelectionObjectGet(handle, &fd);
if (result != SA_AIS_OK) {
printf("saEvtSelectionObject get %d\n", result);
/* error */
return;
}
#ifdef EVENT_SUBSCRIBE
pfd.fd = fd;
pfd.events = POLLIN;
nfd = poll(&pfd, 1, timeout);
if (nfd <= 0) {
printf("poll fds %d\n", nfd);
if (nfd < 0) {
perror("poll error");
}
goto evt_free;
}
printf("Got poll event\n");
result = saEvtDispatch(handle, SA_DISPATCH_ONE);
if (result != SA_AIS_OK) {
printf("saEvtDispatch %d\n", result);
goto evt_fin;
}
#endif
/*
* Test cleanup
*/
evt_free:
result = saEvtEventFree(event_handle);
if (result != SA_AIS_OK) {
printf("event free result: %d\n", result);
}
evt_close:
result = saEvtChannelClose(channel_handle);
if (result != SA_AIS_OK) {
printf("channel close result: %d\n", result);
}
evt_fin:
result = saEvtFinalize(handle);
if (result != SA_AIS_OK) {
printf("Event Finalize result: %d\n", result);
}
printf("Done\n");
}
