X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvpp-api%2Fpython%2Fvpp_papi%2Fvpp_stats.py;h=18f13e9c4c0988b91e38783d3def093a55c7f532;hb=refs%2Fchanges%2F17%2F31817%2F3;hp=de72249ac6be56675ab9aa79e10e95515cfafbe0;hpb=85465588b18fef9c4712f864f512e00741e2d4f2;p=vpp.git

diff --git a/src/vpp-api/python/vpp_papi/vpp_stats.py b/src/vpp-api/python/vpp_papi/vpp_stats.py
old mode 100644
new mode 100755
index de72249ac6b..18f13e9c4c0
--- a/src/vpp-api/python/vpp_papi/vpp_stats.py
+++ b/src/vpp-api/python/vpp_papi/vpp_stats.py
@@ -1,294 +1,515 @@
-#!/usr/bin/env python
-
-from __future__ import print_function
-from cffi import FFI
+#!/usr/bin/env python3
+#
+# Copyright (c) 2021 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+'''
+This module implement Python access to the VPP statistics segment. It
+accesses the data structures directly in shared memory.
+VPP uses optimistic locking, so data structures may change underneath
+us while we are reading. Data is copied out and it's important to
+spend as little time as possible "holding the lock".
+
+Counters are stored in VPP as a two dimensional array.
+Index by thread and index (typically sw_if_index).
+Simple counters count only packets, Combined counters count packets
+and octets.
+
+Counters can be accessed in either dimension.
+stat['/if/rx'] - returns 2D lists
+stat['/if/rx'][0] - returns counters for all interfaces for thread 0
+stat['/if/rx'][0][1] - returns counter for interface 1 on thread 0
+stat['/if/rx'][0][1]['packets'] - returns the packet counter
+                                  for interface 1 on thread 0
+stat['/if/rx'][:, 1] - returns the counters for interface 1 on all threads
+stat['/if/rx'][:, 1].packets() - returns the packet counters for
+                                 interface 1 on all threads
+stat['/if/rx'][:, 1].sum_packets() - returns the sum of packet counters for
+                                     interface 1 on all threads
+stat['/if/rx-miss'][:, 1].sum() - returns the sum of packet counters for
+                                  interface 1 on all threads for simple counters
+'''
+
+import os
+import socket
+import array
+import mmap
+from struct import Struct
 import time
-
-ffi = FFI()
-ffi.cdef("""
-typedef uint64_t counter_t;
-typedef struct {
-  counter_t packets;
-  counter_t bytes;
-} vlib_counter_t;
-
-typedef enum {
-  STAT_DIR_TYPE_ILLEGAL = 0,
-  STAT_DIR_TYPE_SCALAR_INDEX,
-  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
-{
-  stat_directory_type_t type;
-  union {
-    uint64_t offset;
-    uint64_t index;
-    uint64_t value;
-  };
-  uint64_t offset_vector;
-  char name[128]; // TODO change this to pointer to "somewhere"
-} stat_segment_directory_entry_t;
-
-typedef struct
-{
-  char *name;
-  stat_directory_type_t type;
-  union
-  {
-    double scalar_value;
-    counter_t *error_vector;
-    counter_t **simple_counter_vec;
-    vlib_counter_t **combined_counter_vec;
-    uint8_t **name_vector;
-  };
-} stat_segment_data_t;
-
-typedef struct
-{
-  uint64_t epoch;
-  uint64_t in_progress;
-  uint64_t directory_offset;
-  uint64_t error_offset;
-  uint64_t stats_offset;
-} stat_segment_shared_header_t;
-
-typedef struct
-{
-  uint64_t current_epoch;
-  stat_segment_shared_header_t *shared_header;
-  stat_segment_directory_entry_t *directory_vector;
-  ssize_t memory_size;
-} stat_client_main_t;
-
-stat_client_main_t * stat_client_get(void);
-void stat_client_free(stat_client_main_t * sm);
-int stat_segment_connect_r (char *socket_name, stat_client_main_t * sm);
-int stat_segment_connect (char *socket_name);
-void stat_segment_disconnect_r (stat_client_main_t * sm);
-void stat_segment_disconnect (void);
-
-uint32_t *stat_segment_ls_r (uint8_t ** patterns, stat_client_main_t * sm);
-uint32_t *stat_segment_ls (uint8_t ** pattern);
-stat_segment_data_t *stat_segment_dump_r (uint32_t * stats,
-                                          stat_client_main_t * sm);
-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);
-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);
-""")
-
-
-# Utility functions
-def make_string_vector(api, strings):
-    vec = ffi.NULL
-    if type(strings) is not list:
-        strings = [strings]
-    for s in strings:
-        vec = api.stat_segment_string_vector(vec, ffi.new("char []",
-                                                          s.encode('utf-8')))
-    return vec
-
-
-def make_string_list(api, vec):
-    vec_len = api.stat_segment_vec_len(vec)
-    return [ffi.string(vec[i]) for i in range(vec_len)]
-
-
-# 2-dimensonal array of thread, index
-def simple_counter_vec_list(api, e):
-    vec = []
-    for thread in range(api.stat_segment_vec_len(e)):
-        len_interfaces = api.stat_segment_vec_len(e[thread])
-        if_per_thread = [e[thread][interfaces]
-                         for interfaces in range(len_interfaces)]
-        vec.append(if_per_thread)
-    return vec
-
-
-def vlib_counter_dict(c):
-    return {'packets': c.packets,
-            'bytes': c.bytes}
-
-
-def combined_counter_vec_list(api, e):
-    vec = []
-    for thread in range(api.stat_segment_vec_len(e)):
-        len_interfaces = api.stat_segment_vec_len(e[thread])
-        if_per_thread = [vlib_counter_dict(e[thread][interfaces])
-                         for interfaces in range(len_interfaces)]
-        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
-    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 error_vec_list(api, e.error_vector)
-    if e.type == 5:
-        return name_vec_list(api, e.name_vector)
-    raise NotImplementedError()
-
-
-class VPPStatsIOError(IOError):
-    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):
-    pass
-
-
-class VPPStats(object):
-    VPPStatsIOError = VPPStatsIOError
-
-    default_socketname = '/var/run/vpp/stats.sock'
-    sharedlib_name = 'libvppapiclient.so'
+import unittest
+import re
+
+def recv_fd(sock):
+    '''Get file descriptor for memory map'''
+    fds = array.array("i")   # Array of ints
+    _, ancdata, _, _ = sock.recvmsg(0, socket.CMSG_LEN(4))
+    for cmsg_level, cmsg_type, cmsg_data in ancdata:
+        if cmsg_level == socket.SOL_SOCKET and cmsg_type == socket.SCM_RIGHTS:
+            fds.frombytes(cmsg_data[:len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
+    return list(fds)[0]
+
+VEC_LEN_FMT = Struct('I')
+def get_vec_len(stats, vector_offset):
+    '''Equivalent to VPP vec_len()'''
+    return VEC_LEN_FMT.unpack_from(stats.statseg, vector_offset - 8)[0]
+
+def get_string(stats, ptr):
+    '''Get a string from a VPP vector'''
+    namevector = ptr - stats.base
+    namevectorlen = get_vec_len(stats, namevector)
+    if namevector + namevectorlen >= stats.size:
+        raise ValueError('String overruns stats segment')
+    return stats.statseg[namevector:namevector+namevectorlen-1].decode('ascii')
+
+
+class StatsVector:
+    '''A class representing a VPP vector'''
+
+    def __init__(self, stats, ptr, fmt):
+        self.vec_start = ptr - stats.base
+        self.vec_len = get_vec_len(stats, ptr - stats.base)
+        self.struct = Struct(fmt)
+        self.fmtlen = len(fmt)
+        self.elementsize = self.struct.size
+        self.statseg = stats.statseg
+        self.stats = stats
+
+        if self.vec_start + self.vec_len * self.elementsize >= stats.size:
+            raise ValueError('Vector overruns stats segment')
+
+    def __iter__(self):
+        with self.stats.lock:
+            return self.struct.iter_unpack(self.statseg[self.vec_start:self.vec_start +
+                                                        self.elementsize*self.vec_len])
+
+    def __getitem__(self, index):
+        if index > self.vec_len:
+            raise ValueError('Index beyond end of vector')
+        with self.stats.lock:
+            if self.fmtlen == 1:
+                return self.struct.unpack_from(self.statseg, self.vec_start +
+                                               (index * self.elementsize))[0]
+            return self.struct.unpack_from(self.statseg, self.vec_start +
+                                           (index * self.elementsize))
+
+class VPPStats():
+    '''Main class implementing Python access to the VPP statistics segment'''
+    # pylint: disable=too-many-instance-attributes
+    shared_headerfmt = Struct('QPQQPP')
+    default_socketname = '/run/vpp/stats.sock'
 
     def __init__(self, socketname=default_socketname, timeout=10):
-        try:
-            self.api = ffi.dlopen(VPPStats.sharedlib_name)
-        except Exception:
-            raise VPPStatsClientLoadError("Could not open: %s" %
-                                          VPPStats.sharedlib_name)
-        self.client = self.api.stat_client_get()
-
-        poll_end_time = time.time() + timeout
-        while time.time() < poll_end_time:
-            rv = self.api.stat_segment_connect_r(socketname.encode('utf-8'),
-                                                 self.client)
-            # 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(retval=rv)
-
-    def heartbeat(self):
-        return self.api.stat_segment_heartbeat_r(self.client)
-
-    def ls(self, patterns):
-        return self.api.stat_segment_ls_r(make_string_vector(self.api,
-                                                             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)
-        # Raise exception and retry
-        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('utf-8')
-            e = stat_entry_to_python(self.api, rv[i])
-            if e is not None:
-                stats[n] = e
-        return stats
-
-    def get_counter(self, name):
-        retries = 0
-        while True:
-            try:
-                d = self.ls(name)
-                s = self.dump(d)
-                if len(s) > 1:
-                    raise AttributeError('Matches multiple counters {}'
-                                         .format(name))
-                k, v = s.popitem()
-                return v
-            except VPPStatsIOError as e:
-                if retries > 10:
-                    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))
+        self.socketname = socketname
+        self.timeout = timeout
+        self.directory = {}
+        self.lock = StatsLock(self)
+        self.connected = False
+        self.size = 0
+        self.last_epoch = 0
+        self.error_vectors = 0
+        self.statseg = 0
+
+    def connect(self):
+        '''Connect to stats segment'''
+        if self.connected:
+            return
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
+        sock.connect(self.socketname)
+
+        mfd = recv_fd(sock)
+        sock.close()
+
+        stat_result = os.fstat(mfd)
+        self.statseg = mmap.mmap(mfd, stat_result.st_size, mmap.PROT_READ, mmap.MAP_SHARED)
+        socket.close(mfd)
+
+        self.size = stat_result.st_size
+        if self.version != 2:
+            raise Exception('Incompatbile stat segment version {}'
+                            .format(self.version))
+
+        self.refresh()
+        self.connected = True
 
     def disconnect(self):
-        self.api.stat_segment_disconnect_r(self.client)
-        self.api.stat_client_free(self.client)
+        '''Disconnect from stats segment'''
+        if self.connected:
+            self.statseg.close()
+            self.connected = False
+
+    @property
+    def version(self):
+        '''Get version of stats segment'''
+        return self.shared_headerfmt.unpack_from(self.statseg)[0]
+
+    @property
+    def base(self):
+        '''Get base pointer of stats segment'''
+        return self.shared_headerfmt.unpack_from(self.statseg)[1]
+
+    @property
+    def epoch(self):
+        '''Get current epoch value from stats segment'''
+        return self.shared_headerfmt.unpack_from(self.statseg)[2]
+
+    @property
+    def in_progress(self):
+        '''Get value of in_progress from stats segment'''
+        return self.shared_headerfmt.unpack_from(self.statseg)[3]
+
+    @property
+    def directory_vector(self):
+        '''Get pointer of directory vector'''
+        return self.shared_headerfmt.unpack_from(self.statseg)[4]
+
+    @property
+    def error_vector(self):
+        '''Get pointer of error vector'''
+        return self.shared_headerfmt.unpack_from(self.statseg)[5]
+
+    elementfmt = 'IQ128s'
+
+    def refresh(self):
+        '''Refresh directory vector cache (epoch changed)'''
+        directory = {}
+        with self.lock:
+            for direntry in StatsVector(self, self.directory_vector, self.elementfmt):
+                path_raw = direntry[2].find(b'\x00')
+                path = direntry[2][:path_raw].decode('ascii')
+                directory[path] = StatsEntry(direntry[0], direntry[1])
+            self.last_epoch = self.epoch
+            self.directory = directory
+
+            # Cache the error index vectors
+            self.error_vectors = []
+            for threads in StatsVector(self, self.error_vector, 'P'):
+                self.error_vectors.append(StatsVector(self, threads[0], 'Q'))
+
+    def __getitem__(self, item):
+        if not self.connected:
+            self.connect()
+        if self.last_epoch != self.epoch:
+            self.refresh()
+        with self.lock:
+            return self.directory[item].get_counter(self)
+
+    def __iter__(self):
+        return iter(self.directory.items())
 
     def set_errors(self):
-        '''Return all errors counters > 0'''
-        retries = 0
-        while True:
-            try:
-                error_names = self.ls(['/err/'])
-                error_counters = self.dump(error_names)
-                break
-            except VPPStatsIOError as e:
-                if retries > 10:
-                    return None
-                retries += 1
-
-        return {k: sum(error_counters[k])
-                for k in error_counters.keys() if sum(error_counters[k])}
+        '''Return dictionary of error counters > 0'''
+        if not self.connected:
+            self.connect()
+
+        errors = {k:v for k, v in self.directory.items() if k.startswith("/err/")}
+        result = {}
+        with self.lock:
+            for k, entry in errors.items():
+                total = 0
+                i = entry.value
+                for per_thread in self.error_vectors:
+                    total += per_thread[i]
+                if total:
+                    result[k] = total
+        return result
 
     def set_errors_str(self):
         '''Return all errors counters > 0 pretty printed'''
-        s = 'ERRORS:\n'
+        error_string = ['ERRORS:']
         error_counters = self.set_errors()
         for k in sorted(error_counters):
-            s += '{:<60}{:>10}\n'.format(k, error_counters[k])
-        return s
+            error_string.append('{:<60}{:>10}'.format(k, error_counters[k]))
+        return '%s\n' % '\n'.join(error_string)
+
+    def get_counter(self, name):
+        '''Alternative call to __getitem__'''
+        return self.__getitem__(name)
+
+    def get_err_counter(self, name):
+        '''Return a single value (sum of all threads)'''
+        if not self.connected:
+            self.connect()
+        return sum(self.directory[name].get_counter(self))
+
+    def ls(self, patterns):
+        '''Returns list of counters matching pattern'''
+        # pylint: disable=invalid-name
+        if not self.connected:
+            self.connect()
+        if not isinstance(patterns, list):
+            patterns = [patterns]
+        regex = [re.compile(i) for i in patterns]
+        return [k for k, v in self.directory.items()
+                if any(re.match(pattern, k) for pattern in regex)]
+
+    def dump(self, counters):
+        '''Given a list of counters return a dictionary of results'''
+        if not self.connected:
+            self.connect()
+        result = {}
+        for cnt in counters:
+            result[cnt] = self.__getitem__(cnt)
+        return result
+
+class StatsLock():
+    '''Stat segment optimistic locking'''
+
+    def __init__(self, stats):
+        self.stats = stats
+        self.epoch = 0
+
+    def __enter__(self):
+        acquired = self.acquire(blocking=True)
+        assert acquired, "Lock wasn't acquired, but blocking=True"
+        return self
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        self.release()
+
+    def acquire(self, blocking=True, timeout=-1):
+        '''Acquire the lock. Await in progress to go false. Record epoch.'''
+        self.epoch = self.stats.epoch
+        if timeout > 0:
+            start = time.monotonic()
+        while self.stats.in_progress:
+            if not blocking:
+                time.sleep(0.01)
+                if timeout > 0:
+                    if start + time.monotonic() > timeout:
+                        return False
+        return True
+
+    def release(self):
+        '''Check if data read while locked is valid'''
+        if self.stats.in_progress or self.stats.epoch != self.epoch:
+            raise IOError('Optimistic lock failed, retry')
+
+    def locked(self):
+        '''Not used'''
+
+
+class StatsCombinedList(list):
+    '''Column slicing for Combined counters list'''
+
+    def __getitem__(self, item):
+        '''Supports partial numpy style 2d support. Slice by column [:,1]'''
+        if isinstance(item, int):
+            return list.__getitem__(self, item)
+        return CombinedList([row[item[1]] for row in self])
+
+class CombinedList(list):
+    '''Combined Counters 2-dimensional by thread by index of packets/octets'''
+
+    def packets(self):
+        '''Return column (2nd dimension). Packets for all threads'''
+        return [pair[0] for pair in self]
+
+    def octets(self):
+        '''Return column (2nd dimension). Octets for all threads'''
+        return [pair[1] for pair in self]
+
+    def sum_packets(self):
+        '''Return column (2nd dimension). Sum of all packets for all threads'''
+        return sum(self.packets())
+
+    def sum_octets(self):
+        '''Return column (2nd dimension). Sum of all octets for all threads'''
+        return sum(self.octets())
+
+class StatsTuple(tuple):
+    '''A Combined vector tuple (packets, octets)'''
+    def __init__(self, data):
+        self.dictionary = {'packets': data[0], 'bytes': data[1]}
+        super().__init__()
+
+    def __repr__(self):
+        return dict.__repr__(self.dictionary)
+
+    def __getitem__(self, item):
+        if isinstance(item, int):
+            return tuple.__getitem__(self, item)
+        if item == 'packets':
+            return tuple.__getitem__(self, 0)
+        return tuple.__getitem__(self, 1)
+
+class StatsSimpleList(list):
+    '''Simple Counters 2-dimensional by thread by index of packets'''
+
+    def __getitem__(self, item):
+        '''Supports partial numpy style 2d support. Slice by column [:,1]'''
+        if isinstance(item, int):
+            return list.__getitem__(self, item)
+        return SimpleList([row[item[1]] for row in self])
+
+class SimpleList(list):
+    '''Simple counter'''
+
+    def sum(self):
+        '''Sum the vector'''
+        return sum(self)
+
+class StatsEntry():
+    '''An individual stats entry'''
+    # pylint: disable=unused-argument,no-self-use
+
+    def __init__(self, stattype, statvalue):
+        self.type = stattype
+        self.value = statvalue
+
+        if stattype == 1:
+            self.function = self.scalar
+        elif stattype == 2:
+            self.function = self.simple
+        elif stattype == 3:
+            self.function = self.combined
+        elif stattype == 4:
+            self.function = self.error
+        elif stattype == 5:
+            self.function = self.name
+        else:
+            self.function = self.illegal
+
+    def illegal(self, stats):
+        '''Invalid or unknown counter type'''
+        return None
+
+    def scalar(self, stats):
+        '''Scalar counter'''
+        return self.value
+
+    def simple(self, stats):
+        '''Simple counter'''
+        counter = StatsSimpleList()
+        for threads in StatsVector(stats, self.value, 'P'):
+            clist = [v[0] for v in StatsVector(stats, threads[0], 'Q')]
+            counter.append(clist)
+        return counter
+
+    def combined(self, stats):
+        '''Combined counter'''
+        counter = StatsCombinedList()
+        for threads in StatsVector(stats, self.value, 'P'):
+            clist = [StatsTuple(cnt) for cnt in StatsVector(stats, threads[0], 'QQ')]
+            counter.append(clist)
+        return counter
+
+    def error(self, stats):
+        '''Error counter'''
+        counter = SimpleList()
+        for clist in stats.error_vectors:
+            counter.append(clist[self.value])
+        return counter
+
+    def name(self, stats):
+        '''Name counter'''
+        counter = []
+        for name in StatsVector(stats, self.value, 'P'):
+            counter.append(get_string(stats, name[0]))
+        return counter
+
+    def get_counter(self, stats):
+        '''Return a list of counters'''
+        return self.function(stats)
+
+class TestStats(unittest.TestCase):
+    '''Basic statseg tests'''
+
+    def setUp(self):
+        '''Connect to statseg'''
+        self.stat = VPPStats()
+        self.stat.connect()
+        self.profile = cProfile.Profile()
+        self.profile.enable()
+
+    def tearDown(self):
+        '''Disconnect from statseg'''
+        self.stat.disconnect()
+        profile = Stats(self.profile)
+        profile.strip_dirs()
+        profile.sort_stats('cumtime')
+        profile.print_stats()
+        print("\n--->>>")
+
+    def test_counters(self):
+        '''Test access to statseg'''
+
+        print('/err/abf-input-ip4/missed', self.stat['/err/abf-input-ip4/missed'])
+        print('/sys/heartbeat', self.stat['/sys/heartbeat'])
+        print('/if/names', self.stat['/if/names'])
+        print('/if/rx-miss', self.stat['/if/rx-miss'])
+        print('/if/rx-miss', self.stat['/if/rx-miss'][1])
+        print('/nat44-ed/out2in/slowpath/drops', self.stat['/nat44-ed/out2in/slowpath/drops'])
+        print('Set Errors', self.stat.set_errors())
+        with self.assertRaises(KeyError):
+            print('NO SUCH COUNTER', self.stat['foobar'])
+        print('/if/rx', self.stat.get_counter('/if/rx'))
+        print('/err/ethernet-input/no error',
+              self.stat.get_err_counter('/err/ethernet-input/no error'))
+
+    def test_column(self):
+        '''Test column slicing'''
+
+        print('/if/rx-miss', self.stat['/if/rx-miss'])
+        print('/if/rx', self.stat['/if/rx'])  # All interfaces for thread #1
+        print('/if/rx thread #1', self.stat['/if/rx'][0])  # All interfaces for thread #1
+        print('/if/rx thread #1, interface #1',
+              self.stat['/if/rx'][0][1])  # All interfaces for thread #1
+        print('/if/rx if_index #1', self.stat['/if/rx'][:, 1])
+        print('/if/rx if_index #1 packets', self.stat['/if/rx'][:, 1].packets())
+        print('/if/rx if_index #1 packets', self.stat['/if/rx'][:, 1].sum_packets())
+        print('/if/rx if_index #1 packets', self.stat['/if/rx'][:, 1].octets())
+        print('/if/rx-miss', self.stat['/if/rx-miss'])
+        print('/if/rx-miss if_index #1 packets', self.stat['/if/rx-miss'][:, 1].sum())
+        print('/if/rx if_index #1 packets', self.stat['/if/rx'][0][1]['packets'])
+
+    def test_error(self):
+        '''Test the error vector'''
+
+        print('/err/ethernet-input', self.stat['/err/ethernet-input/no error'])
+        print('/err/nat44-ei-ha/pkts-processed', self.stat['/err/nat44-ei-ha/pkts-processed'])
+        print('/err/ethernet-input', self.stat.get_err_counter('/err/ethernet-input/no error'))
+        print('/err/ethernet-input', self.stat['/err/ethernet-input/no error'].sum())
+
+    def test_nat44(self):
+        '''Test the nat counters'''
+
+        print('/nat44-ei/ha/del-event-recv', self.stat['/nat44-ei/ha/del-event-recv'])
+        print('/err/nat44-ei-ha/pkts-processed', self.stat['/err/nat44-ei-ha/pkts-processed'].sum())
+
+    def test_legacy(self):
+        '''Legacy interface'''
+        directory = self.stat.ls(["^/if", "/err/ip4-input", "/sys/node/ip4-input"])
+        data = self.stat.dump(directory)
+        print(data)
+        print('Looking up sys node')
+        directory = self.stat.ls(["^/sys/node"])
+        print('Dumping sys node')
+        data = self.stat.dump(directory)
+        print(data)
+        directory = self.stat.ls(["^/foobar"])
+        data = self.stat.dump(directory)
+        print(data)
+
+    def test_sys_nodes(self):
+        '''Test /sys/nodes'''
+        counters = self.stat.ls('^/sys/node')
+        print('COUNTERS:', counters)
+        print('/sys/node', self.stat.dump(counters))
+        print('/net/route/to', self.stat['/net/route/to'])
+
+if __name__ == '__main__':
+    import cProfile
+    from pstats import Stats
+
+    unittest.main()