mirror of
https://git.proxmox.com/git/mirror_corosync
synced 2025-05-25 23:20:27 +00:00
cba04f10c5
git-svn-id: http://svn.fedorahosted.org/svn/corosync/trunk@135 fd59a12c-fef9-0310-b244-a6a79926bd2f
869 lines
22 KiB
C
869 lines
22 KiB
C
/*
|
|
* Test program for event service
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/poll.h>
|
|
#include <malloc.h>
|
|
#include "ais_types.h"
|
|
#include "ais_evt.h"
|
|
|
|
|
|
void testresult (SaErrorT result, SaErrorT expected, int test_no)
|
|
{
|
|
if (result == expected) {
|
|
printf ("Test %d passed\n", test_no);
|
|
} else {
|
|
printf ("ERROR: Test %d FAILED (expected %d got %d)\n", test_no, expected, result);
|
|
}
|
|
}
|
|
|
|
SaVersionT version1 = { 'A', 0x01, 0x01 };
|
|
SaVersionT version2 = { 'a', 0x01, 0x01 };
|
|
SaVersionT version3 = { 'b', 0x01, 0x01 };
|
|
SaVersionT version4 = { 'a', 0x02, 0x01 };
|
|
SaVersionT version5 = { 'a', 0xff, 0x01 };
|
|
SaVersionT version6 = { 'a', 0x01, 0xff };
|
|
SaVersionT version7 = { 'A', 0xff, 0xff };
|
|
SaVersionT version8 = { 'B', 0xff, 0xff };
|
|
|
|
struct version_test {
|
|
SaVersionT *version;
|
|
SaErrorT result;
|
|
};
|
|
|
|
struct version_test versions[] = {
|
|
{ &version1, SA_OK },
|
|
{ &version2, SA_OK },
|
|
{ &version3, SA_ERR_VERSION },
|
|
{ &version4, SA_ERR_VERSION},
|
|
// { &version5, SA_OK },
|
|
//{ &version6, SA_OK },
|
|
//{ &version7, SA_OK },
|
|
{ &version8, SA_ERR_VERSION},
|
|
{ 0, SA_ERR_VERSION}
|
|
};
|
|
|
|
int version_size = sizeof(versions) / sizeof(struct version_test);
|
|
|
|
void event_callback( SaEvtSubscriptionIdT subscriptionId,
|
|
const SaEvtEventHandleT eventHandle,
|
|
const SaSizeT eventDataSize);
|
|
|
|
SaEvtCallbacksT callbacks = {
|
|
0,
|
|
event_callback
|
|
};
|
|
|
|
char channel[256] = "TESTEVT_CHANNEL";
|
|
SaEvtSubscriptionIdT subscription_id = 0xabcdef;
|
|
unsigned long long test_ret_time = 30000000000ULL; /* 30 seconds */
|
|
|
|
|
|
/*
|
|
* event data
|
|
*/
|
|
|
|
long *exp_data;
|
|
#define DATA_SIZE 2048 /* default data size */
|
|
#define LCOUNT DATA_SIZE/sizeof(long)
|
|
|
|
void test_initialize (void) {
|
|
int result;
|
|
SaEvtHandleT handle;
|
|
int i;
|
|
|
|
|
|
/*
|
|
* version check tests
|
|
*/
|
|
printf("Test lib version check on initlialize\n");
|
|
for (i=0; i < version_size; i++) {
|
|
result = saEvtInitialize (&handle, 0, versions[i].version);
|
|
testresult (result, versions[i].result, i);
|
|
if (result == SA_OK) {
|
|
saEvtFinalize(handle);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
#define patt1 "Filter pattern 1"
|
|
#define patt1_size sizeof(patt1)
|
|
|
|
#define patt2 "Filter pattern 2"
|
|
#define patt2_size sizeof(patt2)
|
|
|
|
#define patt3 "Filter pattern 3"
|
|
#define patt3_size sizeof(patt3)
|
|
|
|
#define patt4 "Filter pattern 4"
|
|
#define patt4_size sizeof(patt4)
|
|
|
|
|
|
SaEvtEventFilterT filters[] = {
|
|
{SA_EVT_PREFIX_FILTER, {patt1, patt1_size}},
|
|
{SA_EVT_SUFFIX_FILTER, {patt2, patt2_size}},
|
|
{SA_EVT_EXACT_FILTER, {patt3, patt3_size}},
|
|
{SA_EVT_PASS_ALL_FILTER, {patt4, patt4_size}}
|
|
};
|
|
|
|
SaEvtEventFilterArrayT subscribe_filters = {
|
|
filters,
|
|
sizeof(filters)/sizeof(SaEvtEventFilterT)
|
|
};
|
|
|
|
void
|
|
test_channel()
|
|
{
|
|
SaEvtHandleT handle;
|
|
SaEvtChannelHandleT channel_handle;
|
|
SaEvtChannelOpenFlagsT flags;
|
|
SaNameT channel_name;
|
|
int result;
|
|
|
|
flags = SA_EVT_CHANNEL_PUBLISHER |
|
|
SA_EVT_CHANNEL_SUBSCRIBER |
|
|
SA_EVT_CHANNEL_CREATE;
|
|
strcpy(channel_name.value, channel);
|
|
channel_name.length = strlen(channel);
|
|
/*
|
|
* Channel open/close test
|
|
*/
|
|
printf("Test Channel operations:\n");
|
|
|
|
printf("Channel open:\n");
|
|
result = saEvtInitialize (&handle, &callbacks, versions[0].version);
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Event Initialize result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
result = saEvtChannelOpen(handle, &channel_name, flags, 0,
|
|
&channel_handle);
|
|
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: channel open result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Event Finalize result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
printf("Channel close:\n");
|
|
result = saEvtChannelClose(channel_handle);
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: channel close result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
result = saEvtFinalize(handle);
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Event Finalize result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Test channel subscribe
|
|
*/
|
|
printf("Channel subscribe:\n");
|
|
result = saEvtInitialize (&handle, &callbacks, versions[0].version);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Event Initialize result: %d\n", result);
|
|
return;
|
|
}
|
|
result = saEvtChannelOpen(handle, &channel_name, flags, 0,
|
|
&channel_handle);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: channel open result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Finalize result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
result = saEvtEventSubscribe(channel_handle,
|
|
&subscribe_filters,
|
|
subscription_id);
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event subscribe result: %d\n", result);
|
|
result = saEvtChannelClose(channel_handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Channel close result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Finalize result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
|
|
printf("Channel unsubscribe:\n");
|
|
|
|
result = saEvtEventUnsubscribe(channel_handle, subscription_id);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event unsubscribe result: %d\n", result);
|
|
result = saEvtChannelClose(channel_handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Channel close result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Finalize result: %d\n", result);
|
|
return;
|
|
}
|
|
result = saEvtChannelClose(channel_handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Channel close result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Finalize result: %d\n", result);
|
|
|
|
/*
|
|
* Test channel subscribe with no close
|
|
*/
|
|
printf("Channel subscribe with no close at end:\n");
|
|
result = saEvtInitialize (&handle, &callbacks, versions[0].version);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Event Initialize result: %d\n", result);
|
|
return;
|
|
}
|
|
result = saEvtChannelOpen(handle, &channel_name, flags, 0,
|
|
&channel_handle);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: channel open result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
return;
|
|
}
|
|
|
|
result = saEvtEventSubscribe(channel_handle,
|
|
&subscribe_filters,
|
|
subscription_id);
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event subscribe result: %d\n", result);
|
|
result = saEvtChannelClose(channel_handle);
|
|
}
|
|
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Finalize failed\n");
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Test multiple subscriptions
|
|
*/
|
|
result = saEvtInitialize (&handle, &callbacks, versions[0].version);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Event Initialize result: %d\n", result);
|
|
return;
|
|
}
|
|
result = saEvtChannelOpen(handle, &channel_name, flags, 0,
|
|
&channel_handle);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: channel open result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Finalize result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
result = saEvtEventSubscribe(channel_handle,
|
|
&subscribe_filters,
|
|
subscription_id);
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: First event subscribe result: %d\n", result);
|
|
result = saEvtChannelClose(channel_handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Channel close result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Finalize result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
result = saEvtEventSubscribe(channel_handle,
|
|
&subscribe_filters,
|
|
subscription_id+1);
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: second event subscribe result: %d\n", result);
|
|
result = saEvtChannelClose(channel_handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Channel close result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Finalize result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Test duplicate subscription
|
|
*/
|
|
printf("Duplicate subscription\n");
|
|
|
|
result = saEvtEventSubscribe(channel_handle,
|
|
&subscribe_filters,
|
|
subscription_id);
|
|
|
|
if (result != SA_ERR_EXIST) {
|
|
printf("ERROR: First event subscribe result: %d\n", result);
|
|
result = saEvtChannelClose(channel_handle);
|
|
result = saEvtFinalize(handle);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Test unsubscribe non-existent sub_id
|
|
*/
|
|
printf("Unsubscribe non-existent sub_id\n");
|
|
|
|
result = saEvtEventUnsubscribe(channel_handle, subscription_id+2);
|
|
if (result != SA_ERR_INVALID_PARAM) {
|
|
printf("ERROR: event unsubscribe result: %d\n", result);
|
|
result = saEvtChannelClose(channel_handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Channel close result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Finalize result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
printf("Unsubscribe from both, close, and finalize\n");
|
|
result = saEvtEventUnsubscribe(channel_handle, subscription_id);
|
|
if (result != SA_OK)
|
|
printf("ERROR: first event unsubscribe result: %d\n", result);
|
|
result = saEvtEventUnsubscribe(channel_handle, subscription_id+1);
|
|
if (result != SA_OK)
|
|
printf("ERROR: second event unsubscribe result: %d\n", result);
|
|
result = saEvtChannelClose(channel_handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Channel close result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Finalize result: %d\n", result);
|
|
printf("Done\n");
|
|
|
|
}
|
|
|
|
SaUint8T pat0[100];
|
|
SaUint8T pat1[100];
|
|
SaUint8T pat2[100];
|
|
SaUint8T pat3[100];
|
|
SaUint8T pat4[100];
|
|
SaEvtEventPatternT evt_patts[5] = {
|
|
{pat0, 100},
|
|
{pat1, 100},
|
|
{pat2, 100},
|
|
{pat3, 100},
|
|
{pat4, 100}};
|
|
SaEvtEventPatternArrayT evt_pat_get_array = { evt_patts, 0 };
|
|
|
|
SaEvtEventPatternT patterns[] = {
|
|
{patt1, patt1_size},
|
|
{patt2, patt2_size},
|
|
{patt3, patt3_size},
|
|
{patt4, patt4_size}
|
|
};
|
|
SaNameT test_pub_name = {13, "Test Pub Name"};
|
|
#define TEST_PRIORITY 2
|
|
|
|
SaEvtEventPatternArrayT evt_pat_set_array = {
|
|
patterns,
|
|
sizeof(patterns)/sizeof(SaEvtEventPatternT)
|
|
};
|
|
|
|
char event_data[1000];
|
|
#define EVENT_DATA_SIZE 1000
|
|
|
|
SaEvtEventIdT event_id = 0;
|
|
SaUint8T priority;
|
|
SaTimeT retention_time = 0ULL;
|
|
SaNameT publisher_name = {0, {0}};
|
|
SaSizeT event_data_size;
|
|
|
|
void
|
|
test_event()
|
|
{
|
|
SaEvtHandleT handle;
|
|
SaEvtChannelHandleT channel_handle;
|
|
SaEvtEventHandleT event_handle;
|
|
SaEvtChannelOpenFlagsT flags;
|
|
SaNameT channel_name;
|
|
|
|
SaTimeT publish_time;
|
|
struct pollfd pfd;
|
|
int nfd;
|
|
int fd;
|
|
int timeout = 5000;
|
|
|
|
|
|
|
|
int result;
|
|
int i;
|
|
|
|
flags = SA_EVT_CHANNEL_PUBLISHER|SA_EVT_CHANNEL_SUBSCRIBER;
|
|
strcpy(channel_name.value, channel);
|
|
channel_name.length = strlen(channel);
|
|
|
|
printf("Test Event operations:\n");
|
|
|
|
result = saEvtInitialize (&handle, &callbacks, versions[0].version);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Event Initialize result: %d\n", result);
|
|
return;
|
|
}
|
|
result = saEvtChannelOpen(handle, &channel_name, flags, 0,
|
|
&channel_handle);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: channel open result: %d\n", result);
|
|
goto evt_fin;
|
|
}
|
|
|
|
/*
|
|
* Allocate an event
|
|
*/
|
|
printf("Event allocation\n");
|
|
result = saEvtEventAllocate(channel_handle, &event_handle);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event Allocate result: %d\n", result);
|
|
goto evt_close;
|
|
}
|
|
|
|
printf("Get event attributes(1)\n");
|
|
result = saEvtEventAttributesGet(event_handle,
|
|
0, /* patterns */
|
|
0, /* priority */
|
|
0, /* retention time */
|
|
0, /* publisher name */
|
|
0, /* publish time */
|
|
0 /* event_id */
|
|
);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event get attr result(1): %d\n", result);
|
|
goto evt_free;
|
|
}
|
|
|
|
/*
|
|
* Get event attributes, this time supply pointers.
|
|
* validate the default values.
|
|
*/
|
|
printf("Get event attributes(2)\n");
|
|
evt_pat_get_array.patternsNumber = 4;
|
|
result = saEvtEventAttributesGet(event_handle,
|
|
&evt_pat_get_array, /* patterns */
|
|
&priority, /* priority */
|
|
&retention_time, /* retention time */
|
|
&publisher_name, /* publisher name */
|
|
&publish_time, /* publish time */
|
|
&event_id /* event_id */
|
|
);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event get attr result(2): %d\n", result);
|
|
goto evt_free;
|
|
}
|
|
if (evt_pat_get_array.patternsNumber != 0) {
|
|
printf("ERROR: pattern array count not zero: %d\n",
|
|
evt_pat_get_array.patternsNumber);
|
|
}
|
|
if (priority != SA_EVT_LOWEST_PRIORITY) {
|
|
printf("ERROR: priority not lowest: 0x%x\n", priority);
|
|
}
|
|
if (retention_time != 0) {
|
|
printf("ERROR: retention time not zero: %0llx\n", retention_time);
|
|
}
|
|
if (publisher_name.length != 0) {
|
|
printf("ERROR: publisher name not null: %s\n", publisher_name.value);
|
|
}
|
|
if (event_id != 0) {
|
|
printf("ERROR: event id not zero: 0x%llx\n", event_id);
|
|
}
|
|
|
|
|
|
/*
|
|
* Set some attributes, then read them back
|
|
*/
|
|
printf("Set event attributes(1)\n");
|
|
result = saEvtEventAttributesSet(event_handle,
|
|
&evt_pat_set_array,
|
|
TEST_PRIORITY,
|
|
test_ret_time,
|
|
&test_pub_name);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event set attr result(1): %d\n", result);
|
|
goto evt_free;
|
|
}
|
|
|
|
printf("Get event attributes(3)\n");
|
|
evt_pat_get_array.patternsNumber = 4;
|
|
result = saEvtEventAttributesGet(event_handle,
|
|
&evt_pat_get_array, /* patterns */
|
|
&priority, /* priority */
|
|
&retention_time, /* retention time */
|
|
&publisher_name, /* publisher name */
|
|
&publish_time, /* publish time */
|
|
&event_id /* event_id */
|
|
);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event get attr result(2): %d\n", result);
|
|
goto evt_free;
|
|
}
|
|
if (evt_pat_get_array.patternsNumber != 4) {
|
|
printf("ERROR: pattern array count not 4: %d\n",
|
|
evt_pat_get_array.patternsNumber);
|
|
}
|
|
for (i = 0; i < evt_pat_get_array.patternsNumber; i++) {
|
|
if (evt_pat_get_array.patterns[i].patternSize !=
|
|
evt_pat_set_array.patterns[i].patternSize) {
|
|
printf("ERROR: pattern %d count not equal g=%d, s=%d\n",
|
|
i,
|
|
evt_pat_get_array.patterns[i].patternSize,
|
|
evt_pat_set_array.patterns[i].patternSize);
|
|
printf("ERROR: pattern %d content g=\"%s\", s=\"%s\"\n",
|
|
i,
|
|
evt_pat_get_array.patterns[i].pattern,
|
|
evt_pat_set_array.patterns[i].pattern);
|
|
} else {
|
|
if (memcmp(evt_pat_get_array.patterns[i].pattern,
|
|
evt_pat_set_array.patterns[i].pattern,
|
|
evt_pat_get_array.patterns[i].patternSize) != 0){
|
|
printf(
|
|
"ERROR: pattern %d don't match g=\"%s\", s=\"%s\"\n",
|
|
i,
|
|
evt_pat_get_array.patterns[i].pattern,
|
|
evt_pat_set_array.patterns[i].pattern);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (priority != TEST_PRIORITY) {
|
|
printf("ERROR: priority: e=0x%x a=0x%x\n",
|
|
TEST_PRIORITY, priority);
|
|
}
|
|
if (retention_time != test_ret_time) {
|
|
printf("ERROR: retention: e=0x%llx a=0x%llx\n",
|
|
test_ret_time, retention_time);
|
|
}
|
|
if (publisher_name.length != test_pub_name.length) {
|
|
printf("ERROR: publisher name length: e=%d, a=%d\n",
|
|
test_pub_name.length,
|
|
publisher_name.length);
|
|
} else {
|
|
if (memcmp(publisher_name.value, test_pub_name.value,
|
|
publisher_name.length) != 0) {
|
|
printf("ERROR: publisher name content: e=%s, a=%s\n",
|
|
test_pub_name.value,
|
|
publisher_name.value);
|
|
}
|
|
}
|
|
|
|
if (event_id != 0) {
|
|
printf("ERROR: event id not zero: 0x%llx\n", event_id);
|
|
}
|
|
/*
|
|
* Event attr patterns: short reads/long reads
|
|
*/
|
|
/* TODO */
|
|
|
|
/*
|
|
* event user data
|
|
*/
|
|
printf("Get event data(1)\n");
|
|
result = saEvtEventDataGet(event_handle, 0, 0);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Get event data(1) result: %d\n", result);
|
|
}
|
|
printf("Get event data(2)\n");
|
|
result = saEvtEventDataGet(event_handle, event_data, 0);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Get event data(2) result: %d\n", result);
|
|
}
|
|
printf("Get event data(3)\n");
|
|
event_data_size = EVENT_DATA_SIZE;
|
|
result = saEvtEventDataGet(event_handle, 0, &event_data_size);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Get event data(3) result: %d\n", result);
|
|
}
|
|
printf("Get event data(4)\n");
|
|
event_data_size = EVENT_DATA_SIZE;
|
|
result = saEvtEventDataGet(event_handle, event_data, &event_data_size);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Get event data(4) result: %d\n", result);
|
|
}
|
|
printf("Get event data(5)\n");
|
|
event_data_size = 1;
|
|
result = saEvtEventDataGet(event_handle, event_data, &event_data_size);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Get event data(5) result: %d\n", result);
|
|
}
|
|
|
|
printf("Free event(1)\n");
|
|
result = saEvtEventFree(event_handle);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event free result: %d\n", result);
|
|
}
|
|
|
|
/*
|
|
* Test publication.
|
|
*/
|
|
|
|
printf("Publish with no patterns set\n");
|
|
|
|
result = saEvtEventAllocate(channel_handle, &event_handle);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event Allocate result: %d\n", result);
|
|
goto evt_close;
|
|
}
|
|
|
|
result = saEvtEventPublish(event_handle, 0, 0, &event_id);
|
|
if (result != SA_ERR_INVALID_PARAM) {
|
|
printf("ERROR: event Publish result(1): %d\n", result);
|
|
goto evt_close;
|
|
}
|
|
|
|
/*
|
|
* Publish with pattens
|
|
*/
|
|
printf("Publish with patterns set\n");
|
|
|
|
result = saEvtEventSubscribe(channel_handle,
|
|
&subscribe_filters,
|
|
subscription_id);
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event subscribe result: %d\n", result);
|
|
result = saEvtChannelClose(channel_handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Channel close result: %d\n", result);
|
|
result = saEvtFinalize(handle);
|
|
if (result != SA_OK)
|
|
printf("ERROR: Finalize result: %d\n", result);
|
|
return;
|
|
}
|
|
|
|
retention_time = 0ULL;
|
|
result = saEvtEventAttributesSet(event_handle,
|
|
&evt_pat_set_array,
|
|
TEST_PRIORITY,
|
|
retention_time,
|
|
&test_pub_name);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event set attr result(2): %d\n", result);
|
|
goto evt_free;
|
|
}
|
|
|
|
/*
|
|
* Generate event data
|
|
*/
|
|
exp_data = malloc(DATA_SIZE);
|
|
for (i = 0; i < LCOUNT; i++) {
|
|
exp_data[i] = lrand48();
|
|
}
|
|
event_data_size = DATA_SIZE;
|
|
|
|
/*
|
|
* Send it
|
|
*/
|
|
result = saEvtEventPublish(event_handle, exp_data, DATA_SIZE,
|
|
&event_id);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event Publish result(2): %d\n", result);
|
|
goto evt_close;
|
|
}
|
|
|
|
/*
|
|
* See if we got the event
|
|
*/
|
|
result = saEvtSelectionObjectGet(handle, &fd);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: saEvtSelectionObject get %d\n", result);
|
|
/* error */
|
|
return;
|
|
}
|
|
pfd.fd = fd;
|
|
pfd.events = POLLIN;
|
|
nfd = poll(&pfd, 1, timeout);
|
|
if (nfd <= 0) {
|
|
printf("ERROR: poll fds %d\n", nfd);
|
|
if (nfd < 0) {
|
|
perror("ERROR: poll error");
|
|
}
|
|
/* Error */
|
|
return;
|
|
}
|
|
|
|
result = saEvtDispatch(handle, SA_DISPATCH_ONE);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: saEvtDispatch %d\n", result);
|
|
/* error */
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Test cleanup
|
|
*/
|
|
evt_free:
|
|
result = saEvtEventFree(event_handle);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event free result: %d\n", result);
|
|
}
|
|
|
|
evt_close:
|
|
result = saEvtChannelClose(channel_handle);
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: channel close result: %d\n", result);
|
|
}
|
|
evt_fin:
|
|
result = saEvtFinalize(handle);
|
|
|
|
if (result != SA_OK) {
|
|
printf("ERROR: Event Finalize result: %d\n", result);
|
|
}
|
|
printf("Done\n");
|
|
|
|
}
|
|
void
|
|
event_callback(SaEvtSubscriptionIdT my_subscription_id,
|
|
const SaEvtEventHandleT event_handle,
|
|
const SaSizeT my_event_data_size)
|
|
{
|
|
SaErrorT result;
|
|
SaUint8T my_priority;
|
|
SaTimeT my_retention_time;
|
|
SaNameT my_publisher_name = {0, {0}};
|
|
SaTimeT my_publish_time;
|
|
SaEvtEventIdT my_event_id;
|
|
int i;
|
|
long *act_data;
|
|
SaSizeT data_size;
|
|
|
|
printf("event_callback called\n");
|
|
if (my_subscription_id != subscription_id) {
|
|
printf("ERROR: sub ID: e=%lx, a=%lx\n",
|
|
subscription_id, my_subscription_id);
|
|
}
|
|
if (my_event_data_size != event_data_size) {
|
|
printf("ERROR: event data size e=%d, a=%d\n",
|
|
event_data_size,
|
|
my_event_data_size);
|
|
}
|
|
|
|
evt_pat_get_array.patternsNumber = 4;
|
|
result = saEvtEventAttributesGet(event_handle,
|
|
&evt_pat_get_array, /* patterns */
|
|
&my_priority, /* priority */
|
|
&my_retention_time, /* retention time */
|
|
&my_publisher_name, /* publisher name */
|
|
&my_publish_time, /* publish time */
|
|
&my_event_id /* event_id */
|
|
);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event get attr result(2): %d\n", result);
|
|
goto evt_free;
|
|
}
|
|
|
|
if (my_event_id != event_id) {
|
|
printf("ERROR: Call back event ID error: e=%llx, a=%llx\n",
|
|
event_id, my_event_id);
|
|
}
|
|
|
|
if (evt_pat_get_array.patternsNumber != 4) {
|
|
printf("ERROR: pattern array count not 4: %d\n",
|
|
evt_pat_get_array.patternsNumber);
|
|
}
|
|
for (i = 0; i < evt_pat_get_array.patternsNumber; i++) {
|
|
if (evt_pat_get_array.patterns[i].patternSize !=
|
|
evt_pat_set_array.patterns[i].patternSize) {
|
|
printf("ERROR: pattern %d count not equal g=%d, s=%d\n",
|
|
i,
|
|
evt_pat_get_array.patterns[i].patternSize,
|
|
evt_pat_set_array.patterns[i].patternSize);
|
|
printf("ERROR: pattern %d content g=\"%s\", s=\"%s\"\n",
|
|
i,
|
|
evt_pat_get_array.patterns[i].pattern,
|
|
evt_pat_set_array.patterns[i].pattern);
|
|
} else {
|
|
if (memcmp(evt_pat_get_array.patterns[i].pattern,
|
|
evt_pat_set_array.patterns[i].pattern,
|
|
evt_pat_get_array.patterns[i].patternSize) != 0){
|
|
printf(
|
|
"ERROR: pattern %d don't match g=\"%s\", s=\"%s\"\n",
|
|
i,
|
|
evt_pat_get_array.patterns[i].pattern,
|
|
evt_pat_set_array.patterns[i].pattern);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (priority != my_priority) {
|
|
printf("ERROR: priority: e=0x%x a=0x%x\n",
|
|
priority, my_priority);
|
|
}
|
|
if (retention_time != my_retention_time) {
|
|
printf("ERROR: retention: e=0x%llx a=0x%llx\n",
|
|
retention_time, my_retention_time);
|
|
}
|
|
if (publisher_name.length != my_publisher_name.length) {
|
|
printf("ERROR: publisher name length: e=%d, a=%d\n",
|
|
publisher_name.length,
|
|
my_publisher_name.length);
|
|
} else {
|
|
if (memcmp(publisher_name.value, my_publisher_name.value,
|
|
publisher_name.length) != 0) {
|
|
printf("ERROR: publisher name content: e=%s, a=%s\n",
|
|
publisher_name.value,
|
|
my_publisher_name.value);
|
|
}
|
|
}
|
|
|
|
act_data = malloc(my_event_data_size);
|
|
memset(act_data, 0, my_event_data_size);
|
|
data_size = my_event_data_size;
|
|
result = saEvtEventDataGet(event_handle, act_data, &data_size);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event data get result: %d\n", result);
|
|
goto dat_free;
|
|
}
|
|
if (data_size != event_data_size) {
|
|
printf("ERROR: Data size: e=%d a=%d\n",
|
|
event_data_size, data_size);
|
|
}
|
|
for (i = 0; i < (data_size/sizeof(long)); i++) {
|
|
if (act_data[i] != exp_data[i]) {
|
|
printf("ERROR: Event Data e=%lx a=%lx at index %d\n",
|
|
exp_data[i], act_data[i], i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
dat_free:
|
|
free(act_data);
|
|
evt_free:
|
|
result = saEvtEventFree(event_handle);
|
|
if (result != SA_OK) {
|
|
printf("ERROR: event free result: %d\n", result);
|
|
}
|
|
}
|
|
|
|
|
|
int main (void)
|
|
{
|
|
test_initialize ();
|
|
test_channel();
|
|
test_event();
|
|
|
|
return (0);
|
|
}
|