src/vpp-api/python/vpp_papi/vpp_stats.py

   1 #!/usr/bin/env python
   2
   3 from __future__ import print_function
   4 from cffi import FFI
   5 import time
   6
   7 ffi = FFI()
   8 ffi.cdef("""
   9 typedef uint64_t counter_t;
  10 typedef struct {
  11   counter_t packets;
  12   counter_t bytes;
  13 } vlib_counter_t;
  14
  15 typedef enum {
  16   STAT_DIR_TYPE_ILLEGAL = 0,
  17   STAT_DIR_TYPE_SCALAR_INDEX,
  18   STAT_DIR_TYPE_COUNTER_VECTOR_SIMPLE,
  19   STAT_DIR_TYPE_COUNTER_VECTOR_COMBINED,
  20   STAT_DIR_TYPE_ERROR_INDEX,
  21   STAT_DIR_TYPE_NAME_VECTOR,
  22 } stat_directory_type_t;
  23
  24 typedef struct
  25 {
  26   stat_directory_type_t type;
  27   union {
  28     uint64_t offset;
  29     uint64_t index;
  30     uint64_t value;
  31   };
  32   uint64_t offset_vector;
  33   char name[128]; // TODO change this to pointer to "somewhere"
  34 } stat_segment_directory_entry_t;
  35
  36 typedef struct
  37 {
  38   char *name;
  39   stat_directory_type_t type;
  40   union
  41   {
  42     double scalar_value;
  43     counter_t *error_vector;
  44     counter_t **simple_counter_vec;
  45     vlib_counter_t **combined_counter_vec;
  46     uint8_t **name_vector;
  47   };
  48 } stat_segment_data_t;
  49
  50 typedef struct
  51 {
  52   uint64_t version;
  53   uint64_t epoch;
  54   uint64_t in_progress;
  55   uint64_t directory_offset;
  56   uint64_t error_offset;
  57   uint64_t stats_offset;
  58 } stat_segment_shared_header_t;
  59
  60 typedef struct
  61 {
  62   uint64_t current_epoch;
  63   stat_segment_shared_header_t *shared_header;
  64   stat_segment_directory_entry_t *directory_vector;
  65   ssize_t memory_size;
  66 } stat_client_main_t;
  67
  68 stat_client_main_t * stat_client_get(void);
  69 void stat_client_free(stat_client_main_t * sm);
  70 int stat_segment_connect_r (char *socket_name, stat_client_main_t * sm);
  71 int stat_segment_connect (char *socket_name);
  72 void stat_segment_disconnect_r (stat_client_main_t * sm);
  73 void stat_segment_disconnect (void);
  74
  75 uint32_t *stat_segment_ls_r (uint8_t ** patterns, stat_client_main_t * sm);
  76 uint32_t *stat_segment_ls (uint8_t ** pattern);
  77 stat_segment_data_t *stat_segment_dump_r (uint32_t * stats,
  78                                           stat_client_main_t * sm);
  79 stat_segment_data_t *stat_segment_dump (uint32_t * counter_vec);
  80 void stat_segment_data_free (stat_segment_data_t * res);
  81
  82 double stat_segment_heartbeat_r (stat_client_main_t * sm);
  83 int stat_segment_vec_len(void *vec);
  84 uint8_t **stat_segment_string_vector(uint8_t **string_vector, char *string);
  85 char *stat_segment_index_to_name_r (uint32_t index, stat_client_main_t * sm);
  86 uint64_t stat_segment_version(void);
  87 uint64_t stat_segment_version_r(stat_client_main_t *sm);
  88 void free(void *ptr);
  89 """)
  90
  91
  92 # Utility functions
  93 def make_string_vector(api, strings):
  94     vec = ffi.NULL
  95     if type(strings) is not list:
  96         strings = [strings]
  97     for s in strings:
  98         vec = api.stat_segment_string_vector(vec, ffi.new("char []",
  99                                                           s.encode('utf-8')))
 100     return vec
 101
 102
 103 def make_string_list(api, vec):
 104     vec_len = api.stat_segment_vec_len(vec)
 105     return [ffi.string(vec[i]) for i in range(vec_len)]
 106
 107
 108 # 2-dimensonal array of thread, index
 109 def simple_counter_vec_list(api, e):
 110     vec = []
 111     for thread in range(api.stat_segment_vec_len(e)):
 112         len_interfaces = api.stat_segment_vec_len(e[thread])
 113         if_per_thread = [e[thread][interfaces]
 114                          for interfaces in range(len_interfaces)]
 115         vec.append(if_per_thread)
 116     return vec
 117
 118
 119 def vlib_counter_dict(c):
 120     return {'packets': c.packets,
 121             'bytes': c.bytes}
 122
 123
 124 def combined_counter_vec_list(api, e):
 125     vec = []
 126     for thread in range(api.stat_segment_vec_len(e)):
 127         len_interfaces = api.stat_segment_vec_len(e[thread])
 128         if_per_thread = [vlib_counter_dict(e[thread][interfaces])
 129                          for interfaces in range(len_interfaces)]
 130         vec.append(if_per_thread)
 131     return vec
 132
 133 def error_vec_list(api, e):
 134     vec = []
 135     for thread in range(api.stat_segment_vec_len(e)):
 136         vec.append(e[thread])
 137     return vec
 138
 139 def name_vec_list(api, e):
 140     return [ffi.string(e[i]).decode('utf-8') for i in
 141             range(api.stat_segment_vec_len(e)) if e[i] != ffi.NULL]
 142
 143
 144 def stat_entry_to_python(api, e):
 145     # Scalar index
 146     if e.type == 1:
 147         return e.scalar_value
 148     if e.type == 2:
 149         return simple_counter_vec_list(api, e.simple_counter_vec)
 150     if e.type == 3:
 151         return combined_counter_vec_list(api, e.combined_counter_vec)
 152     if e.type == 4:
 153         return error_vec_list(api, e.error_vector)
 154     if e.type == 5:
 155         return name_vec_list(api, e.name_vector)
 156     raise NotImplementedError()
 157
 158
 159 class VPPStatsIOError(IOError):
 160     message = "Stat segment client connection returned: " \
 161               "%(retval)s %(strerror)s."
 162
 163     strerror = {-1: "Stat client couldn't open socket",
 164                 -2: "Stat client socket open but couldn't connect",
 165                 -3: "Receiving file descriptor failed",
 166                 -4: "mmap fstat failed",
 167                 -5: "mmap map failed"
 168                 }
 169
 170     def __init__(self, message=None, **kwargs):
 171         if 'retval' in kwargs:
 172             self.retval = kwargs['retval']
 173             kwargs['strerror'] = self.strerror[int(self.retval)]
 174
 175         if not message:
 176             try:
 177                 message = self.message % kwargs
 178             except Exception as e:
 179                 message = self.message
 180         else:
 181             message = message % kwargs
 182
 183         super(VPPStatsIOError, self).__init__(message)
 184
 185
 186 class VPPStatsClientLoadError(RuntimeError):
 187     pass
 188
 189
 190 class VPPStats(object):
 191     VPPStatsIOError = VPPStatsIOError
 192
 193     default_socketname = '/var/run/vpp/stats.sock'
 194     sharedlib_name = 'libvppapiclient.so'
 195
 196     def __init__(self, socketname=default_socketname, timeout=10):
 197         try:
 198             self.api = ffi.dlopen(VPPStats.sharedlib_name)
 199         except Exception:
 200             raise VPPStatsClientLoadError("Could not open: %s" %
 201                                           VPPStats.sharedlib_name)
 202         self.client = self.api.stat_client_get()
 203
 204         poll_end_time = time.time() + timeout
 205         while time.time() < poll_end_time:
 206             rv = self.api.stat_segment_connect_r(socketname.encode('utf-8'),
 207                                                  self.client)
 208             # Break out if success or any other error than "no such file"
 209             # (indicating that VPP hasn't started yet)
 210             if rv == 0 or ffi.errno != 2:
 211                 break
 212
 213         if rv != 0:
 214             raise VPPStatsIOError(retval=rv)
 215
 216     def heartbeat(self):
 217         return self.api.stat_segment_heartbeat_r(self.client)
 218
 219     def ls(self, patterns):
 220         return self.api.stat_segment_ls_r(make_string_vector(self.api,
 221                                                              patterns),
 222                                           self.client)
 223
 224     def lsstr(self, patterns):
 225         rv = self.api.stat_segment_ls_r(make_string_vector(self.api,
 226                                                            patterns),
 227                                         self.client)
 228
 229         if rv == ffi.NULL:
 230             raise VPPStatsIOError()
 231         return [ffi.string(self.api.stat_segment_index_to_name_r(
 232             rv[i], self.client)).decode('utf-8')
 233                 for i in range(self.api.stat_segment_vec_len(rv))]
 234
 235     def dump(self, counters):
 236         stats = {}
 237         rv = self.api.stat_segment_dump_r(counters, self.client)
 238         # Raise exception and retry
 239         if rv == ffi.NULL:
 240             raise VPPStatsIOError()
 241         rv_len = self.api.stat_segment_vec_len(rv)
 242
 243         for i in range(rv_len):
 244             n = ffi.string(rv[i].name).decode('utf-8')
 245             e = stat_entry_to_python(self.api, rv[i])
 246             if e is not None:
 247                 stats[n] = e
 248         return stats
 249
 250     def get_counter(self, name):
 251         retries = 0
 252         while True:
 253             try:
 254                 d = self.ls(name)
 255                 s = self.dump(d)
 256                 if len(s) > 1:
 257                     raise AttributeError('Matches multiple counters {}'
 258                                          .format(name))
 259                 k, v = s.popitem()
 260                 return v
 261             except VPPStatsIOError as e:
 262                 if retries > 10:
 263                     return None
 264                 retries += 1
 265
 266     def get_err_counter(self, name):
 267         """Get an error counter. The errors from each worker thread
 268            are summed"""
 269         return sum(self.get_counter(name))
 270
 271     def disconnect(self):
 272         self.api.stat_segment_disconnect_r(self.client)
 273         self.api.stat_client_free(self.client)
 274
 275     def set_errors(self):
 276         '''Return all errors counters > 0'''
 277         retries = 0
 278         while True:
 279             try:
 280                 error_names = self.ls(['/err/'])
 281                 error_counters = self.dump(error_names)
 282                 break
 283             except VPPStatsIOError as e:
 284                 if retries > 10:
 285                     return None
 286                 retries += 1
 287
 288         return {k: sum(error_counters[k])
 289                 for k in error_counters.keys() if sum(error_counters[k])}
 290
 291     def set_errors_str(self):
 292         '''Return all errors counters > 0 pretty printed'''
 293         s = 'ERRORS:\n'
 294         error_counters = self.set_errors()
 295         for k in sorted(error_counters):
 296             s += '{:<60}{:>10}\n'.format(k, error_counters[k])
 297         return s