stats: removing empty object in stats vector

[vpp.git] / src / vpp-api / python / vpp_papi / vpp_stats.py

diff --git a/src/vpp-api/python/vpp_papi/vpp_stats.py b/src/vpp-api/python/vpp_papi/vpp_stats.py
index 06daaf8..76ccf10 100644 (file)
--- a/src/vpp-api/python/vpp_papi/vpp_stats.py
+++ b/src/vpp-api/python/vpp_papi/vpp_stats.py
@@ -18,6 +18,7 @@ typedef enum {
   STAT_DIR_TYPE_COUNTER_VECTOR_SIMPLE,
   STAT_DIR_TYPE_COUNTER_VECTOR_COMBINED,
   STAT_DIR_TYPE_ERROR_INDEX,
+  STAT_DIR_TYPE_NAME_VECTOR,
 } stat_directory_type_t;
 
 typedef struct
@@ -39,9 +40,10 @@ typedef struct
   union
   {
     double scalar_value;
-    uint64_t error_value;
+    counter_t *error_vector;
     counter_t **simple_counter_vec;
     vlib_counter_t **combined_counter_vec;
+    uint8_t **name_vector;
   };
 } stat_segment_data_t;
 
@@ -76,9 +78,10 @@ stat_segment_data_t *stat_segment_dump (uint32_t * counter_vec);
 void stat_segment_data_free (stat_segment_data_t * res);
 
 double stat_segment_heartbeat_r (stat_client_main_t * sm);
-double stat_segment_heartbeat (void);
 int stat_segment_vec_len(void *vec);
 uint8_t **stat_segment_string_vector(uint8_t **string_vector, char *string);
+char *stat_segment_index_to_name_r (uint32_t index, stat_client_main_t * sm);
+void free(void *ptr);
 """)
 
 
@@ -89,7 +92,7 @@ def make_string_vector(api, strings):
         strings = [strings]
     for s in strings:
         vec = api.stat_segment_string_vector(vec, ffi.new("char []",
-                                                          s.encode()))
+                                                          s.encode('utf-8')))
     return vec
 
 
@@ -123,23 +126,55 @@ def combined_counter_vec_list(api, e):
         vec.append(if_per_thread)
     return vec
 
+def error_vec_list(api, e):
+    vec = []
+    for thread in range(api.stat_segment_vec_len(e)):
+        vec.append(e[thread])
+    return vec
+
+def name_vec_list(api, e):
+    return [ffi.string(e[i]).decode('utf-8') for i in range(api.stat_segment_vec_len(e)) if e[i] != ffi.NULL]
 
 def stat_entry_to_python(api, e):
     # Scalar index
     if e.type == 1:
         return e.scalar_value
-        return None
     if e.type == 2:
         return simple_counter_vec_list(api, e.simple_counter_vec)
     if e.type == 3:
         return combined_counter_vec_list(api, e.combined_counter_vec)
     if e.type == 4:
-        return e.error_value
-    return None
+        return error_vec_list(api, e.error_vector)
+    if e.type == 5:
+        return name_vec_list(api, e.name_vector)
+    raise NotImplementedError()
 
 
 class VPPStatsIOError(IOError):
-    pass
+    message = "Stat segment client connection returned: " \
+              "%(retval)s %(strerror)s."
+
+    strerror = {-1: "Stat client couldn't open socket",
+                -2: "Stat client socket open but couldn't connect",
+                -3: "Receiving file descriptor failed",
+                -4: "mmap fstat failed",
+                -5: "mmap map failed"
+                }
+
+    def __init__(self, message=None, **kwargs):
+        if 'retval' in kwargs:
+            self.retval = kwargs['retval']
+            kwargs['strerror'] = self.strerror[int(self.retval)]
+
+        if not message:
+            try:
+                message = self.message % kwargs
+            except Exception as e:
+                message = self.message
+        else:
+            message = message % kwargs
+
+        super(VPPStatsIOError, self).__init__(message)
 
 
 class VPPStatsClientLoadError(RuntimeError):
@@ -149,7 +184,7 @@ class VPPStatsClientLoadError(RuntimeError):
 class VPPStats(object):
     VPPStatsIOError = VPPStatsIOError
 
-    default_socketname = '/var/run/stats.sock'
+    default_socketname = '/var/run/vpp/stats.sock'
     sharedlib_name = 'libvppapiclient.so'
 
     def __init__(self, socketname=default_socketname, timeout=10):
@@ -162,13 +197,15 @@ class VPPStats(object):
 
         poll_end_time = time.time() + timeout
         while time.time() < poll_end_time:
-            rv = self.api.stat_segment_connect_r(socketname.encode(),
+            rv = self.api.stat_segment_connect_r(socketname.encode('utf-8'),
                                                  self.client)
-            if rv == 0:
+            # Break out if success or any other error than "no such file"
+            # (indicating that VPP hasn't started yet)
+            if rv == 0 or ffi.errno != 2:
                 break
 
         if rv != 0:
-            raise VPPStatsIOError()
+            raise VPPStatsIOError(retval=rv)
 
     def heartbeat(self):
         return self.api.stat_segment_heartbeat_r(self.client)
@@ -178,6 +215,16 @@ class VPPStats(object):
                                                              patterns),
                                           self.client)
 
+    def lsstr(self, patterns):
+        rv = self.api.stat_segment_ls_r(make_string_vector(self.api,
+                                                           patterns),
+                                        self.client)
+
+        if rv == ffi.NULL:
+            raise VPPStatsIOError()
+        return [ffi.string(self.api.stat_segment_index_to_name_r(rv[i], self.client)).decode('utf-8')
+                for i in range(self.api.stat_segment_vec_len(rv))]
+
     def dump(self, counters):
         stats = {}
         rv = self.api.stat_segment_dump_r(counters, self.client)
@@ -185,8 +232,9 @@ class VPPStats(object):
         if rv == ffi.NULL:
             raise VPPStatsIOError()
         rv_len = self.api.stat_segment_vec_len(rv)
+
         for i in range(rv_len):
-            n = ffi.string(rv[i].name).decode()
+            n = ffi.string(rv[i].name).decode('utf-8')
             e = stat_entry_to_python(self.api, rv[i])
             if e is not None:
                 stats[n] = e
@@ -208,6 +256,11 @@ class VPPStats(object):
                     return None
                 retries += 1
 
+    def get_err_counter(self, name):
+        """Get an error counter. The errors from each worker thread
+           are summed"""
+        return sum(self.get_counter(name))
+
     def disconnect(self):
         self.api.stat_segment_disconnect_r(self.client)
         self.api.stat_client_free(self.client)
@@ -225,8 +278,8 @@ class VPPStats(object):
                     return None
                 retries += 1
 
-        return {k: error_counters[k]
-                for k in error_counters.keys() if error_counters[k]}
+        return {k: sum(error_counters[k])
+                for k in error_counters.keys() if sum(error_counters[k])}
 
     def set_errors_str(self):
         '''Return all errors counters > 0 pretty printed'''