From 6b342b1a62a7ce85509ea1177c5624cfb41472f8 Mon Sep 17 00:00:00 2001 From: Mark Haverkamp Date: Thu, 2 Sep 2004 17:16:25 +0000 Subject: [PATCH] (Logical change 1.63) git-svn-id: http://svn.fedorahosted.org/svn/corosync/trunk@229 fd59a12c-fef9-0310-b244-a6a79926bd2f --- test/evtbench.c | 386 +++++++++++++++++++++++++++++++++++++++++++ test/publish.c | 394 +++++++++++++++++++++++++++++++++++++++++++ test/sa_error.c | 48 ++++++ test/subscription.c | 395 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 1223 insertions(+) diff --git a/test/evtbench.c b/test/evtbench.c index e69de29b..73990423 100644 --- a/test/evtbench.c +++ b/test/evtbench.c @@ -0,0 +1,386 @@ +/* + * Test program for event service + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ais_types.h" +#include "ais_evt.h" + +// #define EVENT_SUBSCRIBE + +SaVersionT version = { 'A', 0x01, 0x01 }; + +void event_callback( SaEvtSubscriptionIdT subscriptionId, + const SaEvtEventHandleT eventHandle, + const SaSizeT eventDataSize); + +SaEvtCallbacksT callbacks = { + 0, + event_callback +}; + + +char channel[256] = "EVENT_TEST_CHANNEL"; +unsigned int subscription_id = 0xfedcba98; +unsigned long long ret_time = 0000000000ULL; /* 0 seconds */ +char pubname[256] = "Test Pub Name"; + + +#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) +}; + + + 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; +#define TEST_PRIORITY 2 + +SaEvtEventPatternArrayT evt_pat_set_array = { + patterns, + sizeof(patterns)/sizeof(SaEvtEventPatternT) +}; + +char user_data_file[256]; +char user_data[65536]; +int user_data_size = 1024; + +uint64_t clust_time_now(void) +{ + struct timeval tv; + uint64_t time_now; + + if (gettimeofday(&tv, 0)) { + return 0ULL; + } + + time_now = (uint64_t)(tv.tv_sec) * 1000000000ULL; + time_now += (uint64_t)(tv.tv_usec) * 1000ULL; + + return time_now; +} + +void +test_pub() +{ + SaEvtHandleT handle; + SaEvtChannelHandleT channel_handle; + SaEvtEventHandleT event_handle; + SaEvtChannelOpenFlagsT flags; + SaNameT channel_name; + uint64_t test_retention; + int 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(channel_name.value, channel); + channel_name.length = strlen(channel); + + + result = saEvtInitialize (&handle, &callbacks, &version); + if (result != SA_OK) { + printf("Event Initialize result: %d\n", result); + exit(1); + } + result = saEvtChannelOpen(handle, &channel_name, flags, 0, + &channel_handle); + if (result != SA_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_OK) { + printf("event subscribe result: %d\n", result); + result = saEvtChannelClose(channel_handle); + if (result != SA_OK) + printf("Channel close result: %d\n", result); + result = saEvtFinalize(handle); + if (result != SA_OK) + printf("Finalize result: %d\n", result); + return; + } +#endif + result = saEvtEventAllocate(channel_handle, &event_handle); + if (result != SA_OK) { + printf("event Allocate result: %d\n", result); + goto evt_free; + } + + strcpy(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_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_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: 0x%llx\n", event_id); + + /* + * See if we got the event + */ + result = saEvtSelectionObjectGet(handle, &fd); + if (result != SA_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_OK) { + printf("saEvtDispatch %d\n", result); + goto evt_fin; + } +#endif + + + /* + * Test cleanup + */ +evt_free: + result = saEvtEventFree(event_handle); + if (result != SA_OK) { + printf("event free result: %d\n", result); + } + +evt_close: + result = saEvtChannelClose(channel_handle); + + if (result != SA_OK) { + printf("channel close result: %d\n", result); + } +evt_fin: + result = saEvtFinalize(handle); + + if (result != SA_OK) { + printf("Event Finalize result: %d\n", result); + } + printf("Done\n"); + +} + +void +event_callback( SaEvtSubscriptionIdT subscription_id, + const SaEvtEventHandleT event_handle, + const SaSizeT event_data_size) +{ + SaErrorT result; + SaUint8T priority; + SaTimeT retention_time; + SaNameT publisher_name = {0, {0}}; + SaTimeT publish_time; + SaEvtEventIdT event_id; + int i; + + printf("event_callback called\n"); + printf("sub ID: %lx\n", subscription_id); + printf("event_handle %lx\n", event_handle); + printf("event data size %d\n", event_data_size); + + 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("event get attr result(2): %d\n", result); + goto evt_free; + } + printf("pattern array count: %d\n", evt_pat_get_array.patternsNumber); + for (i = 0; i < evt_pat_get_array.patternsNumber; i++) { + printf( "pattern %d =\"%s\"\n", i, + evt_pat_get_array.patterns[i].pattern); + } + + printf("priority: 0x%x\n", priority); + printf("retention: 0x%llx\n", retention_time); + printf("publisher name content: \"%s\"\n", publisher_name.value); + printf("event id: 0x%llx\n", event_id); +evt_free: + result = saEvtEventFree(event_handle); + printf("event free result: %d\n", result); +} + + +int main (int argc, char **argv) +{ + static const char opts[] = "c:i:t:n:x:u:"; + + int pub_count = 1; + int option; + + while (1) { + option = getopt(argc, argv, opts); + if (option == -1) + break; + + switch (option) { + case 'u': { + int fd; + int sz; + + strcpy(user_data_file, optarg); + fd = open(user_data_file, O_RDONLY); + if (fd < 0) { + printf("Can't open user data file %s\n", + user_data_file); + exit(1); + } + sz = read(fd, user_data, 65536); + if (sz < 0) { + perror("subscription\n"); + exit(1); + } + close(fd); + user_data_size = sz; + break; + } + + case 'c': + strcpy(channel, optarg); + break; + case 'n': + strcpy(pubname, optarg); + break; + case 'i': + subscription_id = + (unsigned int)strtoul(optarg, NULL, 0); + break; + case 't': + ret_time = strtoull(optarg, NULL, 0); + ret_time *= 1000000000; + break; + case 'x': + pub_count = strtoul(optarg, NULL, 0); + break; + default: + printf("invalid arg: \"%s\"\n", optarg); + return 1; + } + } + + while (pub_count--) { + test_pub(); + } + + return 0; +} diff --git a/test/publish.c b/test/publish.c index e69de29b..410eebe0 100644 --- a/test/publish.c +++ b/test/publish.c @@ -0,0 +1,394 @@ +/* + * Test program for event service + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ais_types.h" +#include "ais_evt.h" + +// #define EVENT_SUBSCRIBE + +extern int get_sa_error(SaErrorT, char *, int); +char result_buf[256]; +int result_buf_len = sizeof(result_buf); + +static int pub_count = 1; +static int wait_time = -1; + +SaVersionT version = { 'A', 0x01, 0x01 }; + +void event_callback( SaEvtSubscriptionIdT subscriptionId, + const SaEvtEventHandleT eventHandle, + const SaSizeT eventDataSize); + +SaEvtCallbacksT callbacks = { + 0, + event_callback +}; + + +char channel[256] = "EVENT_TEST_CHANNEL"; +unsigned int subscription_id = 0xfedcba98; +unsigned long long ret_time = 30000000000ULL; /* 30 seconds */ +char pubname[256] = "Test Pub Name"; + + +#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) +}; + + + 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; +#define TEST_PRIORITY 2 + +SaEvtEventPatternArrayT evt_pat_set_array = { + patterns, + sizeof(patterns)/sizeof(SaEvtEventPatternT) +}; + +char user_data_file[256]; +char user_data[65536]; +int user_data_size = 0; + +uint64_t clust_time_now(void) +{ + struct timeval tv; + uint64_t time_now; + + if (gettimeofday(&tv, 0)) { + return 0ULL; + } + + time_now = (uint64_t)(tv.tv_sec) * 1000000000ULL; + time_now += (uint64_t)(tv.tv_usec) * 1000ULL; + + return time_now; +} + +int +test_pub() +{ + SaEvtHandleT handle; + SaEvtChannelHandleT channel_handle; + SaEvtEventHandleT event_handle; + SaEvtChannelOpenFlagsT flags; + SaNameT channel_name; + uint64_t test_retention; + int fd; + int i; + + SaEvtEventIdT event_id; +#ifdef EVENT_SUBSCRIBE + struct pollfd pfd; + int nfd; + int timeout = 1000; +#endif + + + + SaErrorT result; + + flags = SA_EVT_CHANNEL_PUBLISHER | +#ifdef EVENT_SUBSCRIBE + SA_EVT_CHANNEL_SUBSCRIBER | +#endif + SA_EVT_CHANNEL_CREATE; + strcpy(channel_name.value, channel); + channel_name.length = strlen(channel); + + + result = saEvtInitialize (&handle, &callbacks, &version); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("Event Initialize result: %s\n", result_buf); + exit(result); + } + result = saEvtChannelOpen(handle, &channel_name, flags, 0, + &channel_handle); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("channel open result: %s\n", result_buf); + exit(result); + } + + /* + * Publish with pattens + */ + printf("Publish\n"); + +#ifdef EVENT_SUBSCRIBE + result = saEvtEventSubscribe(channel_handle, + &subscribe_filters, + subscription_id); + + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("event subscribe result: %s\n", result_buf); + exit(result); + } +#endif + result = saEvtEventAllocate(channel_handle, &event_handle); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("event Allocate result: %s\n", result_buf); + exit(result); + } + + strcpy(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_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("event set attr result(2): %s\n", result_buf); + exit(result); + } + + for (i = 0; i < pub_count; i++) { + result = saEvtEventPublish(event_handle, user_data, + user_data_size, &event_id); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("event Publish result(2): %s\n", result_buf); + exit(result); + } + + printf("Published event ID: 0x%llx\n", event_id); + } + + /* + * See if we got the event + */ + result = saEvtSelectionObjectGet(handle, &fd); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("saEvtSelectionObject get %s\n", result_buf); + /* error */ + exit(result); + } +#ifdef EVENT_SUBSCRIBE + + for (i = 0; i < pub_count; i++) { + 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_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("saEvtDispatch %s\n", result_buf); + exit(result); + } + } +#endif + + + /* + * Test cleanup + */ + result = saEvtEventFree(event_handle); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("event free result: %s\n", result_buf); + exit(result); + } + + result = saEvtChannelClose(channel_handle); + + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("channel close result: %s\n", result_buf); + exit(result); + } + result = saEvtFinalize(handle); + + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("Event Finalize result: %s\n", result_buf); + exit(result); + } + printf("Done\n"); + return 0; + +} + +void +event_callback( SaEvtSubscriptionIdT subscription_id, + const SaEvtEventHandleT event_handle, + const SaSizeT event_data_size) +{ + SaErrorT result; + SaUint8T priority; + SaTimeT retention_time; + SaNameT publisher_name = {0, {0}}; + SaTimeT publish_time; + SaEvtEventIdT event_id; + int i; + + printf("event_callback called\n"); + printf("sub ID: %lx\n", subscription_id); + printf("event_handle %lx\n", event_handle); + printf("event data size %d\n", event_data_size); + + 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) { + get_sa_error(result, result_buf, result_buf_len); + printf("event get attr result(2): %s\n", result_buf); + goto evt_free; + } + printf("pattern array count: %d\n", evt_pat_get_array.patternsNumber); + for (i = 0; i < evt_pat_get_array.patternsNumber; i++) { + printf( "pattern %d =\"%s\"\n", i, + evt_pat_get_array.patterns[i].pattern); + } + + printf("priority: 0x%x\n", priority); + printf("retention: 0x%llx\n", retention_time); + printf("publisher name content: \"%s\"\n", publisher_name.value); + printf("event id: 0x%llx\n", event_id); +evt_free: + result = saEvtEventFree(event_handle); + get_sa_error(result, result_buf, result_buf_len); + printf("event free result: %s\n", result_buf); +} + + +int main (int argc, char **argv) +{ + static const char opts[] = "c:i:t:n:x:u:w:"; + + int ret; + int option; + + while (1) { + option = getopt(argc, argv, opts); + if (option == -1) + break; + + switch (option) { + case 'u': { + int fd; + int sz; + + strcpy(user_data_file, optarg); + fd = open(user_data_file, O_RDONLY); + if (fd < 0) { + printf("Can't open user data file %s\n", + user_data_file); + exit(1); + } + sz = read(fd, user_data, 65536); + if (sz < 0) { + perror("subscription\n"); + exit(1); + } + close(fd); + user_data_size = sz; + break; + } + + case 'c': + strcpy(channel, optarg); + break; + case 'n': + strcpy(pubname, optarg); + break; + case 'i': + subscription_id = + (unsigned int)strtoul(optarg, NULL, 0); + break; + case 'w': + wait_time = + (unsigned int)strtoul(optarg, NULL, 0); + break; + case 't': + ret_time = strtoull(optarg, NULL, 0); + ret_time *= 1000000000; + break; + case 'x': + pub_count = strtoul(optarg, NULL, 0); + break; + default: + printf("invalid arg: \"%s\"\n", optarg); + return 1; + } + } + do { + ret = test_pub(); + if (ret != 0) { + exit(ret); + } + if (wait_time < 0) { + break; + } + sleep(wait_time); + } while(1); +} diff --git a/test/sa_error.c b/test/sa_error.c index e69de29b..75414133 100644 --- a/test/sa_error.c +++ b/test/sa_error.c @@ -0,0 +1,48 @@ +#include +#include +#include "ais_types.h" + +const char *sa_error_list[] = { + "OUT_OF_RANGE", + "SA_OK", + "SA_ERR_LIBRARY", + "SA_ERR_VERSION", + "SA_ERR_INIT", + "SA_ERR_TIMEOUT", + "SA_ERR_TRY_AGAIN", + "SA_ERR_INVALID_PARAM", + "SA_ERR_NO_MEMORY", + "SA_ERR_BAD_HANDLE", + "SA_ERR_BUSY", + "SA_ERR_ACCESS", + "SA_ERR_NOT_EXIST", + "SA_ERR_NAME_TOO_LONG", + "SA_ERR_EXIST", + "SA_ERR_NO_SPACE", + "SA_ERR_INTERRUPT", + "SA_ERR_SYSTEM", + "SA_ERR_NAME_NOT_FOUND", + "SA_ERR_NO_RESOURCES", + "SA_ERR_NOT_SUPPORTED", + "SA_ERR_BAD_OPERATION", + "SA_ERR_FAILED_OPERATION", + "SA_ERR_MESSAGE_ERROR", + "SA_ERR_NO_MESSAGE", + "SA_ERR_QUEUE_FULL", + "SA_ERR_QUEUE_NOT_AVAILABLE", + "SA_ERR_BAD_CHECKPOINT", + "SA_ERR_BAD_FLAGS", + "SA_ERR_SECURITY", +}; + +int get_sa_error(SaErrorT error, char *str, int len) +{ + if (error < SA_OK || + error > SA_ERR_SECURITY || + len < strlen(sa_error_list[error])) { + errno = EINVAL; + return -1; + } + strncpy(str, sa_error_list[error], len); + return 0; +} diff --git a/test/subscription.c b/test/subscription.c index e69de29b..492f452c 100644 --- a/test/subscription.c +++ b/test/subscription.c @@ -0,0 +1,395 @@ +/* + * Test program for event service subscriptions + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ais_types.h" +#include "ais_evt.h" + +#define TEST_EVENT_ORDER 1 + +extern int get_sa_error(SaErrorT, char *, int); +char result_buf[256]; +int result_buf_len = sizeof(result_buf); + +int quiet = 0; + +SaVersionT version = { 'A', 0x01, 0x01 }; + +void event_callback( SaEvtSubscriptionIdT subscriptionId, + const SaEvtEventHandleT eventHandle, + const SaSizeT eventDataSize); + +SaEvtCallbacksT callbacks = { + 0, + event_callback +}; + +char channel[256] = "EVENT_TEST_CHANNEL"; + +#define MAX_NODES 256 +SaEvtEventIdT last_event_id[MAX_NODES] = {0,}; + +#define MAX_SUB 100 + +uint32_t subscription_id[MAX_SUB] = {0xfedcba98}; + +int sub_next = 0; + +char pubname[256] = "Test Pub Name"; + +#define patt1 "Filter pattern 1" +#define patt1_size sizeof(patt1) + +SaEvtEventFilterT filters[MAX_SUB] = { + {SA_EVT_PASS_ALL_FILTER, {0, 0}} +}; + +SaEvtEventFilterArrayT subscribe_filters[MAX_SUB] = { + { &filters[0] , + 1}, +}; + + +#define PAT_SIZE 100 +SaUint8T pat0[PAT_SIZE]; +SaUint8T pat1[PAT_SIZE]; +SaUint8T pat2[PAT_SIZE]; +SaUint8T pat3[PAT_SIZE]; +SaUint8T pat4[PAT_SIZE]; +SaEvtEventPatternT evt_patts[5] = { + {pat0, PAT_SIZE}, + {pat1, PAT_SIZE}, + {pat2, PAT_SIZE}, + {pat3, PAT_SIZE}, + {pat4, PAT_SIZE}}; +SaEvtEventPatternArrayT evt_pat_get_array = { evt_patts, 0 }; + +SaNameT test_pub_name = {13, "Test Pub Name"}; + + +char user_data_file[256]; +char user_data[65536]; +char event_data[65536]; +int user_data_size = 0; + +void +test_subscription() +{ + SaEvtHandleT handle; + SaEvtChannelHandleT channel_handle; + SaEvtChannelOpenFlagsT flags; + SaNameT channel_name; + + struct pollfd pfd; + int nfd; + int fd; + int timeout = 60000; + int i; + + + + int result; + + flags = SA_EVT_CHANNEL_SUBSCRIBER | SA_EVT_CHANNEL_CREATE; + strcpy(channel_name.value, channel); + channel_name.length = strlen(channel); + + printf("Test subscription:\n"); + + result = saEvtInitialize (&handle, &callbacks, &version); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("Event Initialize result: %s\n", result_buf); + return; + } + result = saEvtChannelOpen(handle, &channel_name, flags, 0, + &channel_handle); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("channel open result: %s\n", result_buf); + goto init_fin; + } + + if (sub_next == 0) + sub_next = 1; + + for (i = 0; i < sub_next; i++) { + result = saEvtEventSubscribe(channel_handle, + &subscribe_filters[i], + subscription_id[i]); + + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("event subscribe result: %s\n", result_buf); + goto chan_fin; + } + + } + /* + * See if we got the event + */ + result = saEvtSelectionObjectGet(handle, &fd); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("saEvtSelectionObject get %s\n", result_buf); + goto sub_fin; + } + + while (1) { + pfd.fd = fd; + pfd.events = POLLIN; + nfd = poll(&pfd, 1, timeout); + if (nfd < 0) { + printf("poll fds %d\n", nfd); + perror("poll error"); + goto sub_fin; + } else if (nfd == 0) { + printf("Still waiting\n"); + continue; + } + + if (pfd.revents & (POLLERR|POLLHUP)) { + printf("Error recieved on poll fd %d\n", fd); + return; + } + result = saEvtDispatch(handle, SA_DISPATCH_ONE); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("saEvtDispatch %s\n", result_buf); + goto sub_fin; + } + if (!quiet) + printf(" - - - - - - - - - - - - - - - -\n\n"); + } + +sub_fin: +#if 0 + result = saEvtEventUnsubscribe(channel_handle, subscription_id); + if (result != SA_OK) + printf("Channel unsubscribe result: %d\n", result); +#endif +chan_fin: + result = saEvtChannelClose(channel_handle); + if (result != SA_OK) + get_sa_error(result, result_buf, result_buf_len); + printf("Channel close result: %s\n", result_buf); +init_fin: + result = saEvtFinalize(handle); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("Finalize result: %s\n", result_buf); + } + +} + +static char time_buf[1024]; + +char *ais_time_str(SaTimeT time) +{ + time_t t; + t = time / 1000000000ULL; + strcpy(time_buf, ctime(&t)); + return time_buf; +} + +void +event_callback( SaEvtSubscriptionIdT subscription_id, + const SaEvtEventHandleT event_handle, + const SaSizeT event_data_size) +{ + SaErrorT result; + SaUint8T priority; + SaTimeT retention_time; + SaNameT publisher_name = {0, {0}}; + SaTimeT publish_time; + SaEvtEventIdT event_id; + SaSizeT received_size; + int i; +#ifdef TEST_EVENT_ORDER + int idx; +#endif + + if (!quiet) + printf("event_callback called\n"); + if (!quiet) + printf("sub ID: %lx\n", subscription_id); + if (!quiet) + printf("event_handle %lx\n", event_handle); + if (!quiet) + printf("event data size %d\n", event_data_size); + + evt_pat_get_array.patterns[0].patternSize = PAT_SIZE; + evt_pat_get_array.patterns[1].patternSize = PAT_SIZE; + evt_pat_get_array.patterns[2].patternSize = PAT_SIZE; + evt_pat_get_array.patterns[3].patternSize = PAT_SIZE; + 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) { + get_sa_error(result, result_buf, result_buf_len); + printf("event get attr result(2): %s\n", result_buf); + goto evt_free; + } + if (!quiet) { + printf("pattern array count: %d\n", + evt_pat_get_array.patternsNumber); + for (i = 0; i < evt_pat_get_array.patternsNumber; i++) { + printf( "pattern %d =\"%s\"\n", i, + evt_pat_get_array.patterns[i].pattern); + } + + printf("priority: 0x%x\n", priority); + printf("retention: 0x%llx\n", retention_time); + printf("publisher name content: \"%s\"\n", + publisher_name.value); + } + if (evt_pat_get_array.patternsNumber > 0) { + if (strcmp(evt_pat_get_array.patterns[0].pattern, SA_EVT_LOST_EVENT) == 0) { + printf("*** Events have been dropped at %s\n", + ais_time_str(publish_time)); + } + } + if (quiet < 2) { + printf("event id: 0x%016llx\n", event_id); + } + +#ifdef TEST_EVENT_ORDER + for (idx = 0; idx < MAX_NODES; idx++) { + if (last_event_id[idx] == 0) { + last_event_id[idx] = event_id; + break; + } else { + if ((last_event_id[idx] >> 32) == (event_id >> 32)) { + last_event_id[idx]++; + if (last_event_id[idx] != event_id) { + printf("*** expected %016llx got %016llx event_id\n", + last_event_id[idx], + event_id); + last_event_id[idx] = event_id; + } + break; + } + } + } + if (idx == MAX_NODES) { + printf("*** Too many nodes in cluster\n"); + exit(1); + } +#endif + + if (event_data_size != user_data_size) { + printf("unexpected data size: e=%d, a=%d\n", + user_data_size, event_data_size); + goto evt_free; + } + + received_size = user_data_size; + result = saEvtEventDataGet(event_handle, event_data, + &received_size); + if (result != SA_OK) { + get_sa_error(result, result_buf, result_buf_len); + printf("event get data result: %s\n", result_buf); + goto evt_free; + } + if (received_size != event_data_size) { + printf("event data mismatch e=%d, a=%d\n", + event_data_size, + received_size); + goto evt_free; + } + if (memcmp(user_data, event_data, user_data_size) != 0 ) { + printf("event data doesn't match specified file data\n"); + goto evt_free; + } + if (!quiet) { + printf("Received %d bytes of data OK\n", + user_data_size); + } + +evt_free: + result = saEvtEventFree(event_handle); + if (!quiet) { + get_sa_error(result, result_buf, result_buf_len); + printf("event free result: %s\n", result_buf); + } +} + + +int main (int argc, char **argv) +{ + static const char opts[] = "c:s:n:qu:"; + + int option; + char *p; + + while (1) { + option = getopt(argc, argv, opts); + if (option == -1) + break; + + switch (option) { + case 'u': { + int fd; + int sz; + + strcpy(user_data_file, optarg); + fd = open(user_data_file, O_RDONLY); + if (fd < 0) { + printf("Can't open user data file %s\n", + user_data_file); + exit(1); + } + sz = read(fd, user_data, 65536); + if (sz < 0) { + perror("subscription\n"); + exit(1); + } + close(fd); + user_data_size = sz; + break; + } + case 'q': + quiet++; + break; + case 'c': + strcpy(channel, optarg); + break; + case 'n': + strcpy(pubname, optarg); + break; + case 's': + p = strsep(&optarg, ","); + subscription_id[sub_next] = + (unsigned int)strtoul(p, NULL, 0); + p = strsep(&optarg, ","); + filters[sub_next].filter.pattern = malloc(strlen(p)); + strcpy(filters[sub_next].filter.pattern, p); + filters[sub_next].filter.patternSize = strlen(p); + p = strsep(&optarg, ","); + filters[sub_next++].filterType = strtoul(p,0, 0); + break; + default: + printf("invalid arg: \"%s\"\n", optarg); + return 1; + } + } + test_subscription(); + + return 0; +} +