VES5.0/evel/evel-library/code/evel_training/14-measurement-interval/hello_evel_world.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <sys/time.h>
   5
   6 #include "evel.h"
   7 #include "evel_test_control.h"
   8
   9 /*****************************************************************************/
  10 /* Local prototypes.                                                         */
  11 /*****************************************************************************/
  12 static void demo_heartbeat();
  13 static void demo_measurement(const int interval);
  14
  15 unsigned long long epoch_start = 0;
  16
  17 int main(int argc, char ** argv)
  18 {
  19   printf("\nHello AT&T Vendor Event world!\n");
  20   fflush(stdout);
  21
  22   if (argc != 5)
  23   {
  24     fprintf(stderr,
  25             "Usage: %s <FQDN>|<IP address> <port> "
  26             "<username> <password>\n", argv[0]);
  27     exit(-1);
  28   }
  29
  30   char * api_fqdn = argv[1];
  31   int api_port = atoi(argv[2]);
  32   int api_secure = 0;
  33
  34   /***************************************************************************/
  35   /* Initialize                                                              */
  36   /***************************************************************************/
  37   if (evel_initialize(api_fqdn,                     /* FQDN                  */
  38                       api_port,                     /* Port                  */
  39                       NULL,                         /* optional path         */
  40                       NULL,                         /* optional topic        */
  41                       api_secure,                   /* HTTPS?                */
  42                       argv[3],                      /* Username              */
  43                       argv[4],                      /* Password              */
  44                       EVEL_SOURCE_VIRTUAL_MACHINE,  /* Source type           */
  45                       "EVEL training demo",         /* Role                  */
  46                       0))                           /* Verbosity             */
  47   {
  48     fprintf(stderr, "\nFailed to initialize the EVEL library!!!\n");
  49     exit(-1);
  50   }
  51   else
  52   {
  53     printf("\nInitialization completed\n");
  54   }
  55
  56   /***************************************************************************/
  57   /* Work out a start time for measurements, and sleep for initial period.   */
  58   /***************************************************************************/
  59   int sleep_time = 1;
  60   struct timeval tv_start;
  61   gettimeofday(&tv_start, NULL);
  62   epoch_start = tv_start.tv_usec + 1000000 * tv_start.tv_sec;
  63   sleep(sleep_time);
  64
  65   int index;
  66   for (index = 0; index < 10; index++)
  67   {
  68     /*************************************************************************/
  69     /* On the second and fifth iteration, get the test_collector to change   */
  70     /* the interval.                                                         */
  71     /*************************************************************************/
  72     if (index == 2)
  73     {
  74       printf("TestControl: measurement interval -> 2s\n");
  75       evel_test_control_meas_interval(2, api_secure, api_fqdn, api_port);
  76     }
  77     if (index == 5)
  78     {
  79       printf("TestControl: measurement interval -> 5s\n");
  80       evel_test_control_meas_interval(5, api_secure, api_fqdn, api_port);
  81     }
  82
  83     /*************************************************************************/
  84     /* Heartbeat to pick up the suppression change.                          */
  85     /*************************************************************************/
  86     demo_heartbeat();
  87
  88     /*************************************************************************/
  89     /* Raise a measurement and sleep.                                        */
  90     /*************************************************************************/
  91     printf("Report measurements\n");
  92     fflush(stdout);
  93     demo_measurement(sleep_time);
  94     printf("Sleeping for %ds\n", sleep_time);
  95     fflush(stdout);
  96     sleep(sleep_time);
  97
  98     /*************************************************************************/
  99     /* Update measurement interval.                                          */
 100     /*************************************************************************/
 101     int measurement_interval;
 102     measurement_interval = evel_get_measurement_interval();
 103     if (measurement_interval == EVEL_MEASUREMENT_INTERVAL_UKNOWN)
 104     {
 105       sleep_time = 1;
 106     }
 107     else
 108     {
 109       sleep_time = measurement_interval;
 110     }
 111     printf("EVEL measurement interval = %d\n\n", measurement_interval);
 112   }
 113
 114   /***************************************************************************/
 115   /* Terminate                                                               */
 116   /***************************************************************************/
 117   sleep(1);
 118   evel_terminate();
 119   printf("Terminated\n");
 120
 121   return 0;
 122 }
 123
 124 /**************************************************************************//**
 125  * Create and send a heatbeat.
 126  *****************************************************************************/
 127 void demo_heartbeat()
 128 {
 129   EVENT_HEADER * heartbeat = NULL;
 130   EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
 131
 132   heartbeat = evel_new_heartbeat();
 133   if (heartbeat != NULL)
 134   {
 135     evel_rc = evel_post_event(heartbeat);
 136     if (evel_rc != EVEL_SUCCESS)
 137     {
 138       printf("Post failed %d (%s)", evel_rc, evel_error_string());
 139     }
 140   }
 141   else
 142   {
 143     printf("New heartbeat failed");
 144   }
 145 }
 146
 147 /**************************************************************************//**
 148  * Create and send a measurement event.
 149  *****************************************************************************/
 150 void demo_measurement(const int interval)
 151 {
 152   EVENT_MEASUREMENT * measurement = NULL;
 153   MEASUREMENT_LATENCY_BUCKET * bucket = NULL;
 154   MEASUREMENT_VNIC_PERFORMANCE * vnic_performance = NULL;
 155   EVEL_ERR_CODES evel_rc = EVEL_SUCCESS;
 156   MEASUREMENT_CPU_USE *cpu_use;
 157
 158   /***************************************************************************/
 159   /* Measurement                                                             */
 160   /***************************************************************************/
 161   measurement = evel_new_measurement(interval);
 162   if (measurement != NULL)
 163   {
 164     printf("New measurement created...\n");
 165     evel_measurement_type_set(measurement, "Perf management...");
 166     evel_measurement_conc_sess_set(measurement, 1);
 167     evel_measurement_cfg_ents_set(measurement, 2);
 168     evel_measurement_mean_req_lat_set(measurement, 4.4);
 169     evel_measurement_request_rate_set(measurement, 6);
 170
 171   cpu_use = evel_measurement_new_cpu_use_add(measurement, "cpu1", 11.11);
 172   evel_measurement_cpu_use_idle_set(cpu_use,22.22);
 173   evel_measurement_cpu_use_interrupt_set(cpu_use,33.33);
 174   evel_measurement_cpu_use_nice_set(cpu_use,44.44);
 175   evel_measurement_cpu_use_softirq_set(cpu_use,55.55);
 176   evel_measurement_cpu_use_steal_set(cpu_use,66.66);
 177   evel_measurement_cpu_use_system_set(cpu_use,77.77);
 178   evel_measurement_cpu_use_usageuser_set(cpu_use,88.88);
 179   evel_measurement_cpu_use_wait_set(cpu_use,99.99);
 180
 181   cpu_use = evel_measurement_new_cpu_use_add(measurement, "cpu2", 22.22);
 182   evel_measurement_cpu_use_idle_set(cpu_use,12.22);
 183   evel_measurement_cpu_use_interrupt_set(cpu_use,33.33);
 184   evel_measurement_cpu_use_nice_set(cpu_use,44.44);
 185   evel_measurement_cpu_use_softirq_set(cpu_use,55.55);
 186   evel_measurement_cpu_use_steal_set(cpu_use,66.66);
 187   evel_measurement_cpu_use_system_set(cpu_use,77.77);
 188   evel_measurement_cpu_use_usageuser_set(cpu_use,88.88);
 189   evel_measurement_cpu_use_wait_set(cpu_use,19.99);
 190
 191     evel_measurement_fsys_use_add(measurement,"00-11-22",100.11, 100.22, 33,
 192                                   200.11, 200.22, 44);
 193     evel_measurement_fsys_use_add(measurement,"33-44-55",300.11, 300.22, 55,
 194                                   400.11, 400.22, 66);
 195
 196     bucket = evel_new_meas_latency_bucket(20);
 197     evel_meas_latency_bucket_low_end_set(bucket, 0.0);
 198     evel_meas_latency_bucket_high_end_set(bucket, 10.0);
 199     evel_meas_latency_bucket_add(measurement, bucket);
 200
 201     bucket = evel_new_meas_latency_bucket(30);
 202     evel_meas_latency_bucket_low_end_set(bucket, 10.0);
 203     evel_meas_latency_bucket_high_end_set(bucket, 20.0);
 204     evel_meas_latency_bucket_add(measurement, bucket);
 205
 206     vnic_performance = evel_measurement_new_vnic_performance("eth0", "true");
 207
 208   evel_vnic_performance_rx_bcast_pkt_acc_set(vnic_performance, 1000000.023);
 209   evel_vnic_performance_rx_bcast_pkt_delta_set(vnic_performance,1234.767346);
 210   evel_vnic_performance_rx_discard_pkt_acc_set(vnic_performance, 127146784.234738587);
 211   evel_vnic_performance_rx_discard_pkt_delta_set(vnic_performance, 123445);
 212   evel_vnic_performance_rx_error_pkt_acc_set(vnic_performance, 2736448376);
 213   evel_vnic_performance_rx_error_pkt_delta_set(vnic_performance, 3474438764);
 214   evel_vnic_performance_rx_mcast_pkt_acc_set(vnic_performance, 42464676);
 215   evel_vnic_performance_rx_mcast_pkt_delta_set(vnic_performance, 42678657654);
 216   evel_vnic_performance_rx_octets_acc_set(vnic_performance, 47658745);
 217   evel_vnic_performance_rx_octets_delta_set(vnic_performance, 47656465465);
 218   evel_vnic_performance_rx_total_pkt_acc_set(vnic_performance, 4765764654444);
 219   evel_vnic_performance_rx_total_pkt_delta_set(vnic_performance, 4545665656);
 220   evel_vnic_performance_rx_ucast_pkt_acc_set(vnic_performance, 4765745546.);
 221   evel_vnic_performance_rx_ucast_pkt_delta_set(vnic_performance, 4768765.78347856);
 222   evel_vnic_performance_tx_bcast_pkt_acc_set(vnic_performance, 747665.347647);
 223   evel_vnic_performance_tx_bcast_pkt_delta_set(vnic_performance, 3468765.4774);
 224   evel_vnic_performance_tx_discarded_pkt_acc_set(vnic_performance, 53625345.53);
 225   evel_vnic_performance_tx_discarded_pkt_delta_set(vnic_performance, 5465345.72455);
 226   evel_vnic_performance_tx_error_pkt_acc_set(vnic_performance, 7632754.754);
 227   evel_vnic_performance_tx_error_pkt_delta_set(vnic_performance, 34646875444.);
 228   evel_vnic_performance_tx_mcast_pkt_acc_set(vnic_performance, 2734875.5534);
 229   evel_vnic_performance_tx_mcast_pkt_delta_set(vnic_performance, 562346534.654);
 230   evel_vnic_performance_tx_octets_acc_set(vnic_performance, 2785845.76874);
 231     evel_meas_vnic_performance_add(measurement, vnic_performance);
 232
 233     vnic_performance = evel_measurement_new_vnic_performance("eth1", "false");
 234   evel_vnic_performance_rx_mcast_pkt_delta_set(vnic_performance, 42678657654);
 235   evel_vnic_performance_rx_octets_acc_set(vnic_performance, 47658745);
 236   evel_vnic_performance_rx_octets_delta_set(vnic_performance, 47656465465);
 237   evel_vnic_performance_rx_total_pkt_acc_set(vnic_performance, 4765764654444);
 238   evel_vnic_performance_rx_total_pkt_delta_set(vnic_performance, 4545665656);
 239   evel_vnic_performance_rx_ucast_pkt_acc_set(vnic_performance, 4765745546.);
 240   evel_vnic_performance_rx_ucast_pkt_delta_set(vnic_performance, 4768765.78347856);
 241   evel_vnic_performance_tx_bcast_pkt_acc_set(vnic_performance, 747665.347647);
 242   evel_vnic_performance_tx_bcast_pkt_delta_set(vnic_performance, 3468765.4774);
 243   evel_vnic_performance_tx_discarded_pkt_acc_set(vnic_performance, 53625345.53);
 244     evel_meas_vnic_performance_add(measurement, vnic_performance);
 245
 246     evel_measurement_errors_set(measurement, 1, 0, 2, 1);
 247
 248     evel_measurement_feature_use_add(measurement, "FeatureA", 123);
 249     evel_measurement_feature_use_add(measurement, "FeatureB", 567);
 250
 251     evel_measurement_codec_use_add(measurement, "G711a", 91);
 252     evel_measurement_codec_use_add(measurement, "G729ab", 92);
 253
 254     evel_measurement_media_port_use_set(measurement, 1234);
 255
 256     evel_measurement_vnfc_scaling_metric_set(measurement, 1234.5678);
 257
 258     evel_measurement_custom_measurement_add(measurement,
 259                                             "Group1", "Name1", "Value1");
 260     evel_measurement_custom_measurement_add(measurement,
 261                                             "Group2", "Name1", "Value1");
 262     evel_measurement_custom_measurement_add(measurement,
 263                                             "Group2", "Name2", "Value2");
 264
 265     /*************************************************************************/
 266     /* Work out the time, to use as end of measurement period.               */
 267     /*************************************************************************/
 268     struct timeval tv_now;
 269     gettimeofday(&tv_now, NULL);
 270     unsigned long long epoch_now = tv_now.tv_usec + 1000000 * tv_now.tv_sec;
 271     evel_start_epoch_set(&measurement->header, epoch_start);
 272     evel_last_epoch_set(&measurement->header, epoch_now);
 273     epoch_start = epoch_now;
 274     evel_reporting_entity_name_set(&measurement->header, "measurer");
 275     evel_reporting_entity_id_set(&measurement->header, "measurer_id");
 276
 277     evel_rc = evel_post_event((EVENT_HEADER *)measurement);
 278     if (evel_rc == EVEL_SUCCESS)
 279     {
 280       printf("Post OK!\n");
 281     }
 282     else
 283     {
 284       printf("Post Failed %d (%s)\n", evel_rc, evel_error_string());
 285     }
 286   }
 287   else
 288   {
 289     printf("Failed to create event (%s)\n", evel_error_string());
 290   }
 291
 292   printf("   Processed Measurement\n");
 293 }