(Logical change 1.63)

git-svn-id: http://svn.fedorahosted.org/svn/corosync/trunk@229 fd59a12c-fef9-0310-b244-a6a79926bd2f

test/evtbench.c

@@ -0,0 +1,386 @@
+/*
+ * Test program for event service
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/poll.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <sys/time.h>
+#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;
+}

test/publish.c

@@ -0,0 +1,394 @@
+/*
+ * Test program for event service
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/poll.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <sys/time.h>
+#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);
+}

test/sa_error.c

@@ -0,0 +1,48 @@
+#include <string.h>
+#include <errno.h>
+#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;
+}

test/subscription.c

@@ -0,0 +1,395 @@
+/*
+ * Test program for event service subscriptions
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <time.h>
+#include <fcntl.h>
+#include <sys/poll.h>
+#include <stdlib.h>
+#include <getopt.h>
+#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;
+}
+