1 /**************************************************************************//**
3 * Utility providing example use of the ECOMP Vendor Event Listener API.
5 * This software is intended to show the essential elements of the library's
11 * Copyright(c) <2016>, AT&T Intellectual Property. All other rights reserved.
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions are met:
16 * 1. Redistributions of source code must retain the above copyright notice,
17 * this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright notice,
19 * this list of conditions and the following disclaimer in the documentation
20 * and/or other materials provided with the distribution.
21 * 3. All advertising materials mentioning features or use of this software
22 * must display the following acknowledgement: This product includes software
23 * developed by the AT&T.
24 * 4. Neither the name of AT&T nor the names of its contributors may be used to
25 * endorse or promote products derived from this software without specific
26 * prior written permission.
28 * THIS SOFTWARE IS PROVIDED BY AT&T INTELLECTUAL PROPERTY ''AS IS'' AND ANY
29 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
30 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
31 * DISCLAIMED. IN NO EVENT SHALL AT&T INTELLECTUAL PROPERTY BE LIABLE FOR ANY
32 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
33 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
34 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
35 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
37 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 *****************************************************************************/
44 #include <sys/signal.h>
51 #include "evel_demo.h"
52 #include "evel_test_control.h"
54 /**************************************************************************//**
55 * Definition of long options to the program.
57 * See the documentation for getopt_long() for details of the structure's use.
58 *****************************************************************************/
59 static const struct option long_options[] = {
60 {"help", no_argument, 0, 'h'},
61 {"fqdn", required_argument, 0, 'f'},
62 {"port", required_argument, 0, 'n'},
63 {"path", required_argument, 0, 'p'},
64 {"topic", required_argument, 0, 't'},
65 {"https", no_argument, 0, 's'},
66 {"verbose", no_argument, 0, 'v'},
67 {"cycles", required_argument, 0, 'c'},
68 {"username", required_argument, 0, 'u'},
69 {"password", required_argument, 0, 'w'},
70 {"nothrott", no_argument, 0, 'x'},
74 /**************************************************************************//**
75 * Definition of short options to the program.
76 *****************************************************************************/
77 static const char* short_options = "hf:n:p:t:sc:u:w:vx";
79 /**************************************************************************//**
80 * Basic user help text describing the usage of the application.
81 *****************************************************************************/
82 static const char* usage_text =
83 "evel_demo [--help]\n"
85 " --port <port_number>\n"
87 " [--topic <topic>]\n"
88 " [--username <username>]\n"
89 " [--password <password>]\n"
91 " [--cycles <cycles>]\n"
94 "Demonstrate use of the ECOMP Vendor Event Listener API.\n"
96 " -h Display this usage message.\n"
99 " -f The FQDN or IP address to the RESTful API.\n"
102 " -n The port number the RESTful API.\n"
105 " -p The optional path prefix to the RESTful API.\n"
108 " -t The optional topic part of the RESTful API.\n"
111 " -u The optional username for basic authentication of requests.\n"
114 " -w The optional password for basic authentication of requests.\n"
117 " -s Use HTTPS rather than HTTP for the transport.\n"
120 " -c Loop <cycles> times round the main loop. Default = 1.\n"
123 " -v Generate much chattier logs.\n"
126 " -x Exclude throttling commands from demonstration.\n"
129 #define DEFAULT_SLEEP_SECONDS 3
130 #define MINIMUM_SLEEP_SECONDS 1
132 unsigned long long epoch_start = 0;
142 /*****************************************************************************/
143 /* Local prototypes. */
144 /*****************************************************************************/
145 static void demo_heartbeat(void);
146 static void demo_fault(void);
147 static void demo_measurement(const int interval);
148 static void demo_mobile_flow(void);
149 static void demo_heartbeat_field_event(void);
150 static void demo_signaling(void);
151 static void demo_state_change(void);
152 static void demo_syslog(void);
153 static void demo_other(void);
154 static void demo_voicequality(void);
156 /**************************************************************************//**
157 * Global flag to initiate shutdown.
158 *****************************************************************************/
159 static int glob_exit_now = 0;
161 static char * api_fqdn = NULL;
162 static int api_port = 0;
163 static int api_secure = 0;
165 static void show_usage(FILE* fp)
167 fputs(usage_text, fp);
170 /**************************************************************************//**
173 * Parses the command-line then ...
175 * @param[in] argc Argument count.
176 * @param[in] argv Argument vector - for usage see usage_text.
177 *****************************************************************************/
178 int main(int argc, char ** argv)
182 int option_index = 0;
184 char * api_path = NULL;
185 char * api_topic = NULL;
186 char * api_username = "";
187 char * api_password = "";
188 int verbose_mode = 0;
189 int exclude_throttling = 0;
192 int measurement_interval = EVEL_MEASUREMENT_INTERVAL_UKNOWN;
194 /***************************************************************************/
195 /* We're very interested in memory management problems so check behavior. */
196 /***************************************************************************/
204 param = getopt_long(argc, argv,
222 api_port = atoi(optarg);
234 api_username = optarg;
238 api_password = optarg;
246 cycles = atoi(optarg);
254 exclude_throttling = 1;
258 /*********************************************************************/
259 /* Unrecognized parameter - getopt_long already printed an error */
261 /*********************************************************************/
265 fprintf(stderr, "Code error: recognized but missing option (%d)!\n",
270 /*************************************************************************/
271 /* Extract next parameter. */
272 /*************************************************************************/
273 param = getopt_long(argc, argv,
279 /***************************************************************************/
280 /* All the command-line has parsed cleanly, so now check that the options */
281 /* are meaningful. */
282 /***************************************************************************/
283 if (api_fqdn == NULL)
285 fprintf(stderr, "FQDN of the Vendor Event Listener API server must be "
289 if (api_port <= 0 || api_port > 65535)
291 fprintf(stderr, "Port for the Vendor Event Listener API server must be "
292 "specified between 1 and 65535.\n");
297 fprintf(stderr, "Number of cycles around the main loop must be an"
298 "integer greater than zero.\n");
302 /***************************************************************************/
303 /* Set up default signal behaviour. Block all signals we trap explicitly */
304 /* on the signal_watcher thread. */
305 /***************************************************************************/
306 sigemptyset(&sig_set);
307 sigaddset(&sig_set, SIGALRM);
308 sigaddset(&sig_set, SIGINT);
309 pthread_sigmask(SIG_BLOCK, &sig_set, NULL);
311 /***************************************************************************/
312 /* Start the signal watcher thread. */
313 /***************************************************************************/
314 if (pthread_create(&thread_id, NULL, signal_watcher, &sig_set) != 0)
316 fprintf(stderr, "Failed to start signal watcher thread.");
319 pthread_detach(thread_id);
321 /***************************************************************************/
323 /***************************************************************************/
324 printf("%s built %s %s\n", argv[0], __DATE__, __TIME__);
326 /***************************************************************************/
327 /* Initialize the EVEL interface. */
328 /***************************************************************************/
329 if (evel_initialize(api_fqdn,
336 EVEL_SOURCE_VIRTUAL_MACHINE,
340 fprintf(stderr, "Failed to initialize the EVEL library!!!");
345 EVEL_INFO("Initialization completed");
348 /***************************************************************************/
349 /* Work out a start time for measurements, and sleep for initial period. */
350 /***************************************************************************/
351 struct timeval tv_start;
352 gettimeofday(&tv_start, NULL);
353 epoch_start = tv_start.tv_usec + 1000000 * tv_start.tv_sec;
354 sleep(DEFAULT_SLEEP_SECONDS);
356 /***************************************************************************/
358 /***************************************************************************/
359 printf("Starting %d loops...\n", cycles);
361 while (cycle++ < cycles)
363 EVEL_INFO("MAI: Starting main loop");
364 printf("\nStarting main loop %d\n", cycle);
366 /*************************************************************************/
367 /* A 20s-long repeating cycle of behaviour. */
368 /*************************************************************************/
369 if (exclude_throttling == 0)
374 printf(" 1 - Resetting throttle specification for all domains\n");
375 evel_test_control_scenario(TC_RESET_ALL_DOMAINS,
382 printf(" 2 - Switching measurement interval to 2s\n");
383 evel_test_control_meas_interval(2,
390 printf(" 3 - Suppressing fault domain\n");
391 evel_test_control_scenario(TC_FAULT_SUPPRESS_FIELDS_AND_PAIRS,
398 printf(" 4 - Suppressing measurement domain\n");
399 evel_test_control_scenario(TC_MEAS_SUPPRESS_FIELDS_AND_PAIRS,
406 printf(" 5 - Switching measurement interval to 5s\n");
407 evel_test_control_meas_interval(5,
414 printf(" 6 - Suppressing mobile flow domain\n");
415 evel_test_control_scenario(TC_MOBILE_SUPPRESS_FIELDS_AND_PAIRS,
422 printf(" 7 - Suppressing state change domain\n");
423 evel_test_control_scenario(TC_STATE_SUPPRESS_FIELDS_AND_PAIRS,
430 printf(" 8 - Suppressing signaling domain\n");
431 evel_test_control_scenario(TC_SIGNALING_SUPPRESS_FIELDS,
438 printf(" 9 - Suppressing service event domain\n");
439 evel_test_control_scenario(TC_SERVICE_SUPPRESS_FIELDS_AND_PAIRS,
446 printf(" 10 - Switching measurement interval to 20s\n");
447 evel_test_control_meas_interval(20,
454 printf(" 11 - Suppressing syslog domain\n");
455 evel_test_control_scenario(TC_SYSLOG_SUPPRESS_FIELDS_AND_PAIRS,
462 printf(" 12 - Switching measurement interval to 10s\n");
463 evel_test_control_meas_interval(10,
470 printf(" Requesting provide throttling spec\n");
471 evel_test_control_scenario(TC_PROVIDE_THROTTLING_SPEC,
480 /*************************************************************************/
481 /* Send a bunch of events. */
482 /*************************************************************************/
485 demo_measurement((measurement_interval ==
486 EVEL_MEASUREMENT_INTERVAL_UKNOWN) ?
487 DEFAULT_SLEEP_SECONDS : measurement_interval);
489 demo_heartbeat_field_event();
496 /*************************************************************************/
497 /* MAIN RETRY LOOP. Check and implement the measurement interval. */
498 /*************************************************************************/
503 /***********************************************************************/
504 /* We have a minimum loop time. */
505 /***********************************************************************/
506 sleep(MINIMUM_SLEEP_SECONDS);
508 /***********************************************************************/
509 /* Get the latest measurement interval and sleep for the remainder. */
510 /***********************************************************************/
511 measurement_interval = evel_get_measurement_interval();
512 printf("Measurement Interval = %d\n", measurement_interval);
514 if (measurement_interval == EVEL_MEASUREMENT_INTERVAL_UKNOWN)
516 sleep_time = DEFAULT_SLEEP_SECONDS - MINIMUM_SLEEP_SECONDS;
520 sleep_time = measurement_interval - MINIMUM_SLEEP_SECONDS;
526 /***************************************************************************/
527 /* We are exiting, but allow the final set of events to be dispatched */
528 /* properly first. */
529 /***************************************************************************/
531 printf("All done - exiting!\n");
535 /**************************************************************************//**
538 * Signal catcher for incoming signal processing. Work out which signal has
539 * been received and process it accordingly.
541 * param[in] void_sig_set The signal mask to listen for.
542 *****************************************************************************/
543 void *signal_watcher(void *void_sig_set)
545 sigset_t *sig_set = (sigset_t *)void_sig_set;
550 /***************************************************************************/
551 /* Set this thread to be cancellable immediately. */
552 /***************************************************************************/
553 pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old_type);
555 while (!glob_exit_now)
557 /*************************************************************************/
558 /* Wait for a signal to be received. */
559 /*************************************************************************/
560 sig = sigwaitinfo(sig_set, &sig_info);
564 /*********************************************************************/
565 /* Failed to do something in the given amount of time. Exit. */
566 /*********************************************************************/
567 EVEL_ERROR( "Timeout alarm");
568 fprintf(stderr,"Timeout alarm - quitting!\n");
573 EVEL_INFO( "Interrupted - quitting");
574 printf("\n\nInterrupted - quitting!\n");
585 /**************************************************************************//**
586 * Create and send a heartbeat event.
587 *****************************************************************************/
588 void demo_heartbeat(void)
590 EVENT_HEADER * heartbeat = NULL;
591 EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
593 /***************************************************************************/
595 /***************************************************************************/
596 heartbeat = evel_new_heartbeat();
597 if (heartbeat != NULL)
599 evel_rc = evel_post_event(heartbeat);
600 if (evel_rc != EVEL_SUCCESS)
602 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
607 EVEL_ERROR("New Heartbeat failed");
609 printf(" Processed Heartbeat\n");
612 /**************************************************************************//**
614 *****************************************************************************/
615 void evel_get_cpu_stats(EVENT_MEASUREMENT * measurement)
628 MEASUREMENT_CPU_USE *cpu_use;
630 /* Open the command for reading. */
631 //fp = popen("/bin/ls /etc/", "r");
632 fp = popen("/usr/bin/top -bn 2 -d 0.01 | grep '^%Cpu' | tail -n 1 ", "r");
634 printf("Failed to run command\n" );
638 /* Read the output a line at a time - output it. */
639 while (fgets(path, sizeof(path)-1, fp) != NULL) {
640 printf("%s", path+10);
641 sscanf(path+10," %lf us, %lf sy, %lf ni, %lf id, %lf wa, %lf hi, %lf si, %lf st",
642 &user,&sys,&nice,&idle,&wait,&intrpt,&softirq,&steal);
648 cpu_use = evel_measurement_new_cpu_use_add(measurement, "cpu1", usage);
649 evel_measurement_cpu_use_idle_set(cpu_use,idle);
650 evel_measurement_cpu_use_interrupt_set(cpu_use,intrpt);
651 evel_measurement_cpu_use_nice_set(cpu_use,nice);
652 evel_measurement_cpu_use_softirq_set(cpu_use,softirq);
653 evel_measurement_cpu_use_steal_set(cpu_use,steal);
654 evel_measurement_cpu_use_system_set(cpu_use,sys);
655 evel_measurement_cpu_use_usageuser_set(cpu_use,user);
656 evel_measurement_cpu_use_wait_set(cpu_use,wait);
657 //evel_measurement_cpu_use_add(measurement, "cpu2", usage,idle,intrpt,nice,softirq,steal,sys,user,wait);
660 /**************************************************************************//**
661 * tap live disk stats
662 *****************************************************************************/
663 void evel_get_disk_stats(EVENT_MEASUREMENT * measurement)
680 MEASUREMENT_DISK_USE * disk_use = NULL;
682 /* Open the command for reading. */
683 //fp = popen("/bin/ls /etc/", "r");
684 fp = popen("/usr/bin/iostat -xtd | grep '^sda' | tail -n 1 ", "r");
686 printf("Failed to run command\n" );
690 /* Read the output a line at a time - output it. */
691 while (fgets(path, sizeof(path)-1, fp) != NULL) {
692 printf("%s", path+10);
693 sscanf(path+10,"%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
694 &rrqm,&wrqm,&rs,&ws,&rkbs,&wkbs,&avgrqs,&avgqqs,&wait,&rawait,&wawait,&svctm,&util);
700 disk_use = evel_measurement_new_disk_use_add(measurement, "sda");
701 evel_measurement_disk_use_iotimeavg_set(disk_use, rrqm);
702 evel_measurement_disk_use_iotimelast_set(disk_use, wrqm);
703 evel_measurement_disk_use_iotimemax_set(disk_use, rs);
704 evel_measurement_disk_use_iotimemin_set(disk_use, ws);
705 evel_measurement_disk_use_mergereadavg_set(disk_use, rkbs);
706 evel_measurement_disk_use_mergereadlast_set(disk_use, wkbs);
707 evel_measurement_disk_use_mergereadmax_set(disk_use, avgrqs);
708 evel_measurement_disk_use_mergereadmin_set(disk_use, avgqqs);
709 evel_measurement_disk_use_mergewritelast_set(disk_use, wait);
710 evel_measurement_disk_use_mergewritemax_set(disk_use, rawait);
711 evel_measurement_disk_use_mergewritemin_set(disk_use, wawait);
712 evel_measurement_disk_use_octetsreadavg_set(disk_use, svctm);
713 evel_measurement_disk_use_octetsreadlast_set(disk_use, util);
717 /**************************************************************************//**
718 * tap live memory stats
719 *****************************************************************************/
720 void evel_get_mem_stats(EVENT_MEASUREMENT * measurement)
725 int bcount=0,lcount=0;
727 double membuffsz=0.0;
729 double memconfig=0.0;
733 double slabunrecl=0.0;
735 MEASUREMENT_MEM_USE *mem_use = NULL;
738 FILE * filp = fopen("/proc/meminfo", "rb");
739 int bytes_read = fread(buffer, sizeof(char), 4096, filp);
742 printf("meminfo %d\n",bytes_read);
744 while ( bcount < bytes_read )
746 for(lcount=0; buffer[bcount] != '\n';bcount++,lcount++)
748 line[lcount] = buffer[bcount];
753 //printf("%s\n",line);
754 if(!strncmp(line,"Buffers:", strlen("Buffers:")))
756 sscanf(line+strlen("Buffers:"),"%lf",&membuffsz);
757 //printf("membuff %lf\n",membuffsz);
759 else if(!strncmp(line,"Cached:", strlen("Cached:")))
761 sscanf(line+strlen("Cached:"),"%lf",&memcache);
763 else if(!strncmp(line,"MemTotal:", strlen("MemTotal:")))
765 sscanf(line+strlen("MemTotal:"),"%lf",&memconfig);
767 else if(!strncmp(line,"MemFree:", strlen("MemFree:")))
769 sscanf(line+strlen("MemFree:"),"%lf",&memfree);
771 else if(!strncmp(line,"Slab:", strlen("Slab:")))
773 sscanf(line+strlen("Slab:"),"%lf",&slab);
775 else if(!strncmp(line,"SReclaimable:", strlen("SReclaimable:")))
777 sscanf(line+strlen("SReclaimable:"),"%lf",&slabrecl);
779 else if(!strncmp(line,"SUnreclaim:", strlen("SUnreclaim:")))
781 sscanf(line+strlen("SUnreclaim:"),"%lf",&slabunrecl);
787 memused = memconfig - memfree - membuffsz - memcache - slab;
788 printf("memused %lf\n",memused);
790 mem_use = evel_measurement_new_mem_use_add(measurement, "RAM", "vm1", membuffsz);
791 evel_measurement_mem_use_memcache_set(mem_use,memcache);
792 evel_measurement_mem_use_memconfig_set(mem_use,memconfig);
793 evel_measurement_mem_use_memfree_set(mem_use,memfree);
794 evel_measurement_mem_use_slab_reclaimed_set(mem_use,slabrecl);
795 evel_measurement_mem_use_slab_unreclaimable_set(mem_use,slabunrecl);
796 evel_measurement_mem_use_usedup_set(mem_use,memused);
800 /**************************************************************************//**
801 * Create and send three fault events.
802 *****************************************************************************/
803 void demo_fault(void)
805 EVENT_FAULT * fault = NULL;
806 EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
808 /***************************************************************************/
810 /***************************************************************************/
811 fault = evel_new_fault("An alarm condition",
813 EVEL_PRIORITY_NORMAL,
815 EVEL_SOURCE_VIRTUAL_MACHINE,
816 EVEL_VF_STATUS_READY_TERMINATE);
819 evel_rc = evel_post_event((EVENT_HEADER *)fault);
820 if (evel_rc != EVEL_SUCCESS)
822 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
827 EVEL_ERROR("New Fault failed");
829 printf(" Processed empty Fault\n");
831 fault = evel_new_fault("Another alarm condition",
833 EVEL_PRIORITY_NORMAL,
836 EVEL_VF_STATUS_REQ_TERMINATE);
839 evel_fault_type_set(fault, "Bad things happening");
840 evel_fault_category_set(fault, "Failed category");
841 evel_fault_interface_set(fault, "An Interface Card");
842 evel_rc = evel_post_event((EVENT_HEADER *)fault);
843 if (evel_rc != EVEL_SUCCESS)
845 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
850 EVEL_ERROR("New Fault failed");
852 printf(" Processed partial Fault\n");
854 fault = evel_new_fault("My alarm condition",
855 "It broke very badly",
856 EVEL_PRIORITY_NORMAL,
859 EVEL_VF_STATUS_PREP_TERMINATE);
862 evel_fault_type_set(fault, "Bad things happen...");
863 evel_fault_interface_set(fault, "My Interface Card");
864 evel_fault_addl_info_add(fault, "name1", "value1");
865 evel_fault_addl_info_add(fault, "name2", "value2");
866 evel_rc = evel_post_event((EVENT_HEADER *)fault);
867 if (evel_rc != EVEL_SUCCESS)
869 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
874 EVEL_ERROR("New Fault failed");
876 printf(" Processed full Fault\n");
879 /**************************************************************************//**
880 * Create and send a measurement event.
881 *****************************************************************************/
882 void demo_measurement(const int interval)
884 EVENT_MEASUREMENT * measurement = NULL;
885 MEASUREMENT_LATENCY_BUCKET * bucket = NULL;
886 MEASUREMENT_VNIC_PERFORMANCE * vnic_performance = NULL;
887 EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
889 /***************************************************************************/
891 /***************************************************************************/
892 measurement = evel_new_measurement(interval);
893 if (measurement != NULL)
895 evel_measurement_type_set(measurement, "Perf management...");
896 evel_measurement_conc_sess_set(measurement, 1);
897 evel_measurement_cfg_ents_set(measurement, 2);
898 evel_measurement_mean_req_lat_set(measurement, 4.4);
899 evel_measurement_request_rate_set(measurement, 6);
900 //evel_measurement_cpu_use_add(measurement, "cpu1", 11.11);
901 //evel_measurement_cpu_use_add(measurement, "cpu2", 22.22);
902 evel_measurement_addl_info_add(measurement, "name1", "value1");
903 evel_measurement_addl_info_add(measurement, "name2", "value2");
904 evel_get_cpu_stats(measurement);
905 evel_get_disk_stats(measurement);
906 evel_measurement_fsys_use_add(measurement,"00-11-22",100.11, 100.22, 33,
908 evel_measurement_fsys_use_add(measurement,"33-44-55",300.11, 300.22, 55,
911 bucket = evel_new_meas_latency_bucket(20);
912 evel_meas_latency_bucket_low_end_set(bucket, 0.0);
913 evel_meas_latency_bucket_high_end_set(bucket, 10.0);
914 evel_meas_latency_bucket_add(measurement, bucket);
916 bucket = evel_new_meas_latency_bucket(30);
917 evel_meas_latency_bucket_low_end_set(bucket, 10.0);
918 evel_meas_latency_bucket_high_end_set(bucket, 20.0);
919 evel_meas_latency_bucket_add(measurement, bucket);
921 vnic_performance = evel_measurement_new_vnic_performance("eth0", "true");
923 evel_vnic_performance_rx_bcast_pkt_acc_set(vnic_performance, 1000000.023);
924 evel_vnic_performance_rx_bcast_pkt_delta_set(vnic_performance,1234.767346);
925 evel_vnic_performance_rx_discard_pkt_acc_set(vnic_performance, 127146784.234738587);
926 evel_vnic_performance_rx_discard_pkt_delta_set(vnic_performance, 123445);
927 evel_vnic_performance_rx_error_pkt_acc_set(vnic_performance, 2736448376);
928 evel_vnic_performance_rx_error_pkt_delta_set(vnic_performance, 3474438764);
929 evel_vnic_performance_rx_mcast_pkt_acc_set(vnic_performance, 42464676);
930 evel_vnic_performance_rx_mcast_pkt_delta_set(vnic_performance, 42678657654);
931 evel_vnic_performance_rx_octets_acc_set(vnic_performance, 47658745);
932 evel_vnic_performance_rx_octets_delta_set(vnic_performance, 47656465465);
933 evel_vnic_performance_rx_total_pkt_acc_set(vnic_performance, 4765764654444);
934 evel_vnic_performance_rx_total_pkt_delta_set(vnic_performance, 4545665656);
935 evel_vnic_performance_rx_ucast_pkt_acc_set(vnic_performance, 4765745546.);
936 evel_vnic_performance_rx_ucast_pkt_delta_set(vnic_performance, 4768765.78347856);
937 evel_vnic_performance_tx_bcast_pkt_acc_set(vnic_performance, 747665.347647);
938 evel_vnic_performance_tx_bcast_pkt_delta_set(vnic_performance, 3468765.4774);
939 evel_vnic_performance_tx_discarded_pkt_acc_set(vnic_performance, 53625345.53);
940 evel_vnic_performance_tx_discarded_pkt_delta_set(vnic_performance, 5465345.72455);
941 evel_vnic_performance_tx_error_pkt_acc_set(vnic_performance, 7632754.754);
942 evel_vnic_performance_tx_error_pkt_delta_set(vnic_performance, 34646875444.);
943 evel_vnic_performance_tx_mcast_pkt_acc_set(vnic_performance, 2734875.5534);
944 evel_vnic_performance_tx_mcast_pkt_delta_set(vnic_performance, 562346534.654);
945 evel_vnic_performance_tx_octets_acc_set(vnic_performance, 2785845.76874);
946 evel_vnic_performance_tx_octets_delta_set(vnic_performance, 76532645.75);
947 evel_vnic_performance_tx_total_pkt_acc_set(vnic_performance, 652365.5435);
948 evel_vnic_performance_tx_total_pkt_delta_set(vnic_performance, 754354.456);
949 evel_vnic_performance_tx_ucast_pkt_acc_set(vnic_performance, 738254835);
950 evel_vnic_performance_tx_ucast_pkt_delta_set(vnic_performance, 763274);
951 evel_meas_vnic_performance_add(measurement, vnic_performance);
953 vnic_performance = evel_measurement_new_vnic_performance("eth1", "false");
954 evel_vnic_performance_rx_mcast_pkt_delta_set(vnic_performance, 42678657654);
955 evel_vnic_performance_rx_octets_acc_set(vnic_performance, 47658745);
956 evel_vnic_performance_rx_octets_delta_set(vnic_performance, 47656465465);
957 evel_vnic_performance_rx_total_pkt_acc_set(vnic_performance, 4765764654444);
958 evel_vnic_performance_rx_total_pkt_delta_set(vnic_performance, 4545665656);
959 evel_vnic_performance_rx_ucast_pkt_acc_set(vnic_performance, 4765745546.);
960 evel_vnic_performance_rx_ucast_pkt_delta_set(vnic_performance, 4768765.78347856);
961 evel_vnic_performance_tx_bcast_pkt_acc_set(vnic_performance, 747665.347647);
962 evel_vnic_performance_tx_bcast_pkt_delta_set(vnic_performance, 3468765.4774);
963 evel_vnic_performance_tx_discarded_pkt_acc_set(vnic_performance, 53625345.53);
964 evel_meas_vnic_performance_add(measurement, vnic_performance);
966 evel_measurement_errors_set(measurement, 1, 0, 2, 1);
968 evel_measurement_feature_use_add(measurement, "FeatureA", 123);
969 evel_measurement_feature_use_add(measurement, "FeatureB", 567);
971 evel_measurement_codec_use_add(measurement, "G711a", 91);
972 evel_measurement_codec_use_add(measurement, "G729ab", 92);
974 evel_get_mem_stats(measurement);
975 evel_measurement_media_port_use_set(measurement, 1234);
977 evel_measurement_vnfc_scaling_metric_set(measurement, 1234.5678);
979 evel_measurement_custom_measurement_add(measurement,
980 "Group1", "Name1", "Value1");
981 evel_measurement_custom_measurement_add(measurement,
982 "Group2", "Name1", "Value1");
983 evel_measurement_custom_measurement_add(measurement,
984 "Group2", "Name2", "Value2");
986 /*************************************************************************/
987 /* Work out the time, to use as end of measurement period. */
988 /*************************************************************************/
989 struct timeval tv_now;
990 gettimeofday(&tv_now, NULL);
991 unsigned long long epoch_now = tv_now.tv_usec + 1000000 * tv_now.tv_sec;
992 evel_start_epoch_set(&measurement->header, epoch_start);
993 evel_last_epoch_set(&measurement->header, epoch_now);
994 epoch_start = epoch_now;
995 evel_reporting_entity_name_set(&measurement->header, "measurer");
996 evel_reporting_entity_id_set(&measurement->header, "measurer_id");
998 evel_rc = evel_post_event((EVENT_HEADER *)measurement);
999 if (evel_rc != EVEL_SUCCESS)
1001 EVEL_ERROR("Post Measurement failed %d (%s)",
1003 evel_error_string());
1008 EVEL_ERROR("New Measurement failed");
1010 printf(" Processed Measurement\n");
1013 /**************************************************************************//**
1014 * Create and send three mobile flow events.
1015 *****************************************************************************/
1016 void demo_mobile_flow(void)
1018 MOBILE_GTP_PER_FLOW_METRICS * metrics = NULL;
1019 EVENT_MOBILE_FLOW * mobile_flow = NULL;
1020 EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
1022 /***************************************************************************/
1024 /***************************************************************************/
1025 metrics = evel_new_mobile_gtp_flow_metrics(12.3,
1055 if (metrics != NULL)
1057 mobile_flow = evel_new_mobile_flow("Outbound",
1065 if (mobile_flow != NULL)
1067 evel_rc = evel_post_event((EVENT_HEADER *)mobile_flow);
1068 if (evel_rc != EVEL_SUCCESS)
1070 EVEL_ERROR("Post Mobile Flow failed %d (%s)",
1072 evel_error_string());
1077 EVEL_ERROR("New Mobile Flow failed");
1079 printf(" Processed empty Mobile Flow\n");
1083 EVEL_ERROR("New GTP Per Flow Metrics failed - skipping Mobile Flow");
1084 printf(" Skipped empty Mobile Flow\n");
1087 metrics = evel_new_mobile_gtp_flow_metrics(132.0001,
1117 if (metrics != NULL)
1119 mobile_flow = evel_new_mobile_flow("Inbound",
1127 if (mobile_flow != NULL)
1129 evel_mobile_flow_app_type_set(mobile_flow, "Demo application");
1130 evel_mobile_flow_app_prot_type_set(mobile_flow, "GSM");
1131 evel_mobile_flow_app_prot_ver_set(mobile_flow, "1");
1132 evel_mobile_flow_cid_set(mobile_flow, "65535");
1133 evel_mobile_flow_con_type_set(mobile_flow, "S1-U");
1134 evel_mobile_flow_ecgi_set(mobile_flow, "e65535");
1135 evel_mobile_flow_gtp_prot_type_set(mobile_flow, "GTP-U");
1136 evel_mobile_flow_gtp_prot_ver_set(mobile_flow, "1");
1137 evel_mobile_flow_http_header_set(mobile_flow,
1138 "http://www.something.com");
1139 evel_mobile_flow_imei_set(mobile_flow, "209917614823");
1140 evel_mobile_flow_imsi_set(mobile_flow, "355251/05/850925/8");
1141 evel_mobile_flow_lac_set(mobile_flow, "1");
1142 evel_mobile_flow_mcc_set(mobile_flow, "410");
1143 evel_mobile_flow_mnc_set(mobile_flow, "04");
1144 evel_mobile_flow_msisdn_set(mobile_flow, "6017123456789");
1145 evel_mobile_flow_other_func_role_set(mobile_flow, "MME");
1146 evel_mobile_flow_rac_set(mobile_flow, "514");
1147 evel_mobile_flow_radio_acc_tech_set(mobile_flow, "LTE");
1148 evel_mobile_flow_sac_set(mobile_flow, "1");
1149 evel_mobile_flow_samp_alg_set(mobile_flow, 1);
1150 evel_mobile_flow_tac_set(mobile_flow, "2099");
1151 evel_mobile_flow_tunnel_id_set(mobile_flow, "Tunnel 1");
1152 evel_mobile_flow_vlan_id_set(mobile_flow, "15");
1154 evel_rc = evel_post_event((EVENT_HEADER *)mobile_flow);
1155 if (evel_rc != EVEL_SUCCESS)
1157 EVEL_ERROR("Post Mobile Flow failed %d (%s)",
1159 evel_error_string());
1164 EVEL_ERROR("New Mobile Flow failed");
1166 printf(" Processed partial Mobile Flow\n");
1170 EVEL_ERROR("New GTP Per Flow Metrics failed - skipping Mobile Flow");
1171 printf(" Skipped partial Mobile Flow\n");
1174 metrics = evel_new_mobile_gtp_flow_metrics(12.32,
1204 if (metrics != NULL)
1206 evel_mobile_gtp_metrics_dur_con_fail_set(metrics, 12);
1207 evel_mobile_gtp_metrics_dur_tun_fail_set(metrics, 13);
1208 evel_mobile_gtp_metrics_act_by_set(metrics, "Remote");
1209 evel_mobile_gtp_metrics_act_time_set(metrics, (time_t)1470409423);
1210 evel_mobile_gtp_metrics_deact_by_set(metrics, "Remote");
1211 evel_mobile_gtp_metrics_con_status_set(metrics, "Connected");
1212 evel_mobile_gtp_metrics_tun_status_set(metrics, "Not tunneling");
1213 evel_mobile_gtp_metrics_iptos_set(metrics, 1, 13);
1214 evel_mobile_gtp_metrics_iptos_set(metrics, 17, 1);
1215 evel_mobile_gtp_metrics_iptos_set(metrics, 4, 99);
1216 evel_mobile_gtp_metrics_large_pkt_rtt_set(metrics, 80);
1217 evel_mobile_gtp_metrics_large_pkt_thresh_set(metrics, 600.0);
1218 evel_mobile_gtp_metrics_max_rcv_bit_rate_set(metrics, 1357924680);
1219 evel_mobile_gtp_metrics_max_trx_bit_rate_set(metrics, 235711);
1220 evel_mobile_gtp_metrics_num_echo_fail_set(metrics, 1);
1221 evel_mobile_gtp_metrics_num_tun_fail_set(metrics, 4);
1222 evel_mobile_gtp_metrics_num_http_errors_set(metrics, 2);
1223 evel_mobile_gtp_metrics_tcp_flag_count_add(metrics, EVEL_TCP_CWR, 10);
1224 evel_mobile_gtp_metrics_tcp_flag_count_add(metrics, EVEL_TCP_URG, 121);
1225 evel_mobile_gtp_metrics_qci_cos_count_add(
1226 metrics, EVEL_QCI_COS_UMTS_CONVERSATIONAL, 11);
1227 evel_mobile_gtp_metrics_qci_cos_count_add(
1228 metrics, EVEL_QCI_COS_LTE_65, 122);
1230 mobile_flow = evel_new_mobile_flow("Outbound",
1238 if (mobile_flow != NULL)
1240 evel_mobile_flow_addl_field_add(mobile_flow, "name1", "value1");
1241 evel_mobile_flow_addl_field_add(mobile_flow, "name2", "value2");
1242 evel_mobile_flow_addl_field_add(mobile_flow, "name3", "value3");
1244 evel_mobile_flow_app_type_set(mobile_flow, "Demo application 2");
1245 evel_mobile_flow_app_prot_type_set(mobile_flow, "GSM");
1246 evel_mobile_flow_app_prot_ver_set(mobile_flow, "2");
1247 evel_mobile_flow_cid_set(mobile_flow, "1");
1248 evel_mobile_flow_con_type_set(mobile_flow, "S1-U");
1249 evel_mobile_flow_ecgi_set(mobile_flow, "e1");
1250 evel_mobile_flow_gtp_prot_type_set(mobile_flow, "GTP-U");
1251 evel_mobile_flow_gtp_prot_ver_set(mobile_flow, "1");
1252 evel_mobile_flow_http_header_set(mobile_flow, "http://www.google.com");
1253 evel_mobile_flow_imei_set(mobile_flow, "209917614823");
1254 evel_mobile_flow_imsi_set(mobile_flow, "355251/05/850925/8");
1255 evel_mobile_flow_lac_set(mobile_flow, "1");
1256 evel_mobile_flow_mcc_set(mobile_flow, "410");
1257 evel_mobile_flow_mnc_set(mobile_flow, "04");
1258 evel_mobile_flow_msisdn_set(mobile_flow, "6017123456789");
1259 evel_mobile_flow_other_func_role_set(mobile_flow, "MMF");
1260 evel_mobile_flow_rac_set(mobile_flow, "514");
1261 evel_mobile_flow_radio_acc_tech_set(mobile_flow, "3G");
1262 evel_mobile_flow_sac_set(mobile_flow, "1");
1263 evel_mobile_flow_samp_alg_set(mobile_flow, 2);
1264 evel_mobile_flow_tac_set(mobile_flow, "2099");
1265 evel_mobile_flow_tunnel_id_set(mobile_flow, "Tunnel 2");
1266 evel_mobile_flow_vlan_id_set(mobile_flow, "4096");
1268 evel_rc = evel_post_event((EVENT_HEADER *)mobile_flow);
1269 if (evel_rc != EVEL_SUCCESS)
1271 EVEL_ERROR("Post Mobile Flow failed %d (%s)",
1273 evel_error_string());
1278 EVEL_ERROR("New Mobile Flow failed");
1280 printf(" Processed full Mobile Flow\n");
1284 EVEL_ERROR("New GTP Per Flow Metrics failed - skipping Mobile Flow");
1285 printf(" Skipped full Mobile Flow\n");
1289 /**************************************************************************//**
1290 * Create and send a Heartbeat field event.
1291 *****************************************************************************/
1292 void demo_heartbeat_field_event(void)
1294 EVENT_HEARTBEAT_FIELD * event = NULL;
1295 EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
1297 event = evel_new_heartbeat_field(3);
1300 evel_hrtbt_interval_set(event, 10);
1301 evel_hrtbt_field_addl_field_add(event, "Name1", "Value1");
1302 evel_hrtbt_field_addl_field_add(event, "Name2", "Value2");
1304 evel_rc = evel_post_event((EVENT_HEADER *) event);
1305 if (evel_rc != EVEL_SUCCESS)
1307 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
1312 EVEL_ERROR("New heartbeat field failed");
1314 printf(" Processed heartbeat Events\n");
1317 /**************************************************************************//**
1318 * Create and send a Signaling event.
1319 *****************************************************************************/
1320 void demo_signaling(void)
1322 EVENT_SIGNALING * event = NULL;
1323 EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
1325 event = evel_new_signaling("vendor_x", "correlator", "1.0.3.1", "1234", "192.168.1.3","3456");
1328 evel_signaling_addl_info_add(event, "name1", "value1");
1329 evel_signaling_addl_info_add(event, "name2", "value2");
1330 evel_signaling_type_set(event, "Signaling");
1331 evel_signaling_correlator_set(event, "vendor_x_correlator");
1332 evel_signaling_local_ip_address_set(event, "1.0.3.1");
1333 evel_signaling_local_port_set(event, "1031");
1334 evel_signaling_remote_ip_address_set(event, "5.3.3.0");
1335 evel_signaling_remote_port_set(event, "5330");
1336 evel_signaling_compressed_sip_set(event, "compressed_sip");
1337 evel_signaling_summary_sip_set(event, "summary_sip");
1338 evel_signaling_vnfmodule_name_set(event, "vendor_x_module");
1339 evel_signaling_vnfname_set(event, "vendor_x_vnf");
1340 evel_rc = evel_post_event((EVENT_HEADER *) event);
1341 if (evel_rc != EVEL_SUCCESS)
1343 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
1348 EVEL_ERROR("New Signaling failed");
1350 printf(" Processed Signaling\n");
1353 /**************************************************************************//**
1354 * Create and send a state change event.
1355 *****************************************************************************/
1356 void demo_state_change(void)
1358 EVENT_STATE_CHANGE * state_change = NULL;
1359 EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
1361 /***************************************************************************/
1363 /***************************************************************************/
1364 state_change = evel_new_state_change(EVEL_ENTITY_STATE_IN_SERVICE,
1365 EVEL_ENTITY_STATE_OUT_OF_SERVICE,
1367 if (state_change != NULL)
1369 evel_state_change_type_set(state_change, "State Change");
1370 evel_state_change_addl_field_add(state_change, "Name1", "Value1");
1371 evel_state_change_addl_field_add(state_change, "Name2", "Value2");
1372 evel_rc = evel_post_event((EVENT_HEADER *)state_change);
1373 if (evel_rc != EVEL_SUCCESS)
1375 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
1380 EVEL_ERROR("New State Change failed");
1382 printf(" Processed State Change\n");
1385 /**************************************************************************//**
1386 * Create and send two syslog events.
1387 *****************************************************************************/
1388 void demo_syslog(void)
1390 EVENT_SYSLOG * syslog = NULL;
1391 EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
1393 /***************************************************************************/
1395 /***************************************************************************/
1396 syslog = evel_new_syslog(EVEL_SOURCE_VIRTUAL_NETWORK_FUNCTION,
1397 "EVEL library message",
1401 evel_rc = evel_post_event((EVENT_HEADER *)syslog);
1402 if (evel_rc != EVEL_SUCCESS)
1404 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
1409 EVEL_ERROR("New Syslog failed");
1411 printf(" Processed empty Syslog\n");
1413 syslog = evel_new_syslog(EVEL_SOURCE_VIRTUAL_MACHINE,
1414 "EVEL library message",
1418 evel_syslog_event_source_host_set(syslog, "Virtual host");
1419 evel_syslog_facility_set(syslog, EVEL_SYSLOG_FACILITY_LOCAL0);
1420 evel_syslog_proc_set(syslog, "vnf_process");
1421 evel_syslog_proc_id_set(syslog, 1423);
1422 evel_syslog_version_set(syslog, 1);
1423 evel_syslog_addl_filter_set(syslog, "Name1=Value1|Name2=Value2|Name3=Value3");
1424 evel_syslog_sdid_set(syslog, "u354@876876");
1425 evel_syslog_severity_set(syslog, "Error");
1426 evel_rc = evel_post_event((EVENT_HEADER *)syslog);
1427 if (evel_rc != EVEL_SUCCESS)
1429 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
1434 EVEL_ERROR("New Syslog failed");
1436 printf(" Processed full Syslog\n");
1440 /**************************************************************************//**
1441 * Create and send VoiceQuality events.
1442 *****************************************************************************/
1443 void demo_voicequality(void)
1445 EVENT_VOICE_QUALITY * vq = NULL;
1446 EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
1448 /***************************************************************************/
1450 /***************************************************************************/
1451 vq = evel_new_voice_quality("calleeCodec", "callerCodec",
1452 "correlator", "midrtcp",
1456 evel_rc = evel_post_event((EVENT_HEADER *)vq);
1457 if (evel_rc != EVEL_SUCCESS)
1459 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
1464 EVEL_ERROR("New Syslog failed");
1466 printf(" Processed empty Syslog\n");
1468 vq = evel_new_voice_quality("calleeCodec", "callerCodec",
1469 "correlator", "midrtcp",
1473 evel_voice_quality_end_metrics_add(vq, "adjacent", EVEL_SERVICE_ENDPOINT_CALLER,
1474 0,1,2,3,4,5,6,7,8,9,10,11,12,13,4,15,16,17,18);
1475 evel_voice_quality_end_metrics_add(vq, "adjacent", EVEL_SERVICE_ENDPOINT_CALLEE,
1476 0,1,2,3,4,5,6,7,8,9,10,11,12,13,4,15,16,17,18);
1478 evel_voice_quality_vnfmodule_name_set(vq, "vnfmodule");
1479 evel_voice_quality_vnfname_set(vq, "vFW");
1480 evel_voice_quality_phone_number_set(vq, "123456789");
1483 evel_rc = evel_post_event((EVENT_HEADER *)vq);
1484 if (evel_rc != EVEL_SUCCESS)
1486 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
1491 EVEL_ERROR("New Syslog failed");
1493 printf(" Processed full Syslog\n");
1496 /**************************************************************************//**
1497 * Create and send two other events.
1498 *****************************************************************************/
1499 void demo_other(void)
1501 EVENT_OTHER * other = NULL;
1502 EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
1504 /***************************************************************************/
1506 /***************************************************************************/
1507 other = evel_new_other();
1510 evel_rc = evel_post_event((EVENT_HEADER *)other);
1511 if (evel_rc != EVEL_SUCCESS)
1513 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
1518 EVEL_ERROR("New Other failed");
1520 printf(" Processed empty Other\n");
1522 other = evel_new_other();
1528 "\"data1\":[1,2,3,4,5,6,7,8,9],"
1540 char * jsstr2 = "{ \"employee\":{ \"name\":\"John\", \"age\":30, \"city\":\"New York\" } }";
1542 evel_other_field_set_namedarraysize(other,50);
1543 evel_other_field_add_namedarray(other,"name1", "disk1", "10000");
1544 evel_other_field_add_namedarray(other,"name2", "disk2", "20000");
1545 evel_other_field_add_namedarray(other,"name1", "disk2", "20000");
1546 evel_other_field_add_namedarray(other,"name1", "disk1", "20000");
1548 EVEL_JSON_OBJECT_INSTANCE * njinst = evel_new_jsonobjinstance(jsstr );
1549 evel_epoch_microsec_set(njinst,9287578586767);
1550 EVEL_INTERNAL_KEY * nkey = evel_new_internal_key("key1");
1551 evel_internal_key_keyorder_set(nkey , 2);
1552 evel_internal_key_keyvalue_set(nkey , "val1");
1553 EVEL_INTERNAL_KEY * nkey2= evel_new_internal_key("key2");
1554 evel_internal_key_keyorder_set(nkey2, 2);
1555 evel_internal_key_keyvalue_set(nkey2, "val2");
1556 evel_jsonobjinst_add_objectkey(njinst, nkey);
1557 evel_jsonobjinst_add_objectkey(njinst, nkey2);
1559 EVEL_JSON_OBJECT_INSTANCE * njinst2 = evel_new_jsonobjinstance(jsstr2 );
1560 evel_epoch_microsec_set(njinst2,927578586767);
1562 EVEL_JSON_OBJECT * myobj = evel_new_jsonobject("Myjobject");
1563 evel_jsonobject_objectschema_set(myobj,"jsonschema5.0");
1564 evel_jsonobject_objectschemaurl_set(myobj,"http://jsonschema5.0.att.com");
1565 evel_jsonobject_nfsubscribedobjname_set(myobj,"nfobj1");
1566 evel_jsonobject_nfsubscriptionid_set(myobj,"nfid1234");
1567 evel_jsonobject_add_jsoninstance(myobj,njinst);
1568 evel_jsonobject_add_jsoninstance(myobj,njinst2);
1569 evel_other_field_add_jsonobj(other,myobj);
1571 evel_other_field_add(other,
1576 evel_rc = evel_post_event((EVENT_HEADER *)other);
1577 if (evel_rc != EVEL_SUCCESS)
1579 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
1584 EVEL_ERROR("New Other failed");
1586 printf(" Processed small Other\n");
1587 other = evel_new_other();
1590 evel_other_field_add(other,
1593 evel_other_field_add(other,
1596 evel_other_field_add(other,
1600 evel_rc = evel_post_event((EVENT_HEADER *)other);
1601 if (evel_rc != EVEL_SUCCESS)
1603 EVEL_ERROR("Post failed %d (%s)", evel_rc, evel_error_string());
1608 EVEL_ERROR("New Other failed");
1610 printf(" Processed large Other\n");