adapter/vppapiclient/stat_client.go

   1 // Copyright (c) 2018 Cisco and/or its affiliates.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at:
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 // +build !windows,!darwin
  16
  17 package vppapiclient
  18
  19 /*
  20 #cgo CFLAGS: -DPNG_DEBUG=1
  21 #cgo LDFLAGS: -lvppapiclient
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <stdint.h>
  26 #include <arpa/inet.h>
  27 #include <vpp-api/client/vppapiclient.h>
  28 #include <vpp-api/client/stat_client.h>
  29
  30 static int
  31 govpp_stat_connect(char *socket_name)
  32 {
  33         return stat_segment_connect(socket_name);
  34 }
  35
  36 static void
  37 govpp_stat_disconnect()
  38 {
  39     stat_segment_disconnect();
  40 }
  41
  42 static uint32_t*
  43 govpp_stat_segment_ls(uint8_t **pattern)
  44 {
  45         return stat_segment_ls(pattern);
  46 }
  47
  48 static int
  49 govpp_stat_segment_vec_len(void *vec)
  50 {
  51         return stat_segment_vec_len(vec);
  52 }
  53
  54 static void
  55 govpp_stat_segment_vec_free(void *vec)
  56 {
  57         stat_segment_vec_free(vec);
  58 }
  59
  60 static char*
  61 govpp_stat_segment_dir_index_to_name(uint32_t *dir, uint32_t index)
  62 {
  63         return stat_segment_index_to_name(dir[index]);
  64 }
  65
  66 static stat_segment_data_t*
  67 govpp_stat_segment_dump(uint32_t *counter_vec)
  68 {
  69         return stat_segment_dump(counter_vec);
  70 }
  71
  72 static stat_segment_data_t
  73 govpp_stat_segment_dump_index(stat_segment_data_t *data, int index)
  74 {
  75         return data[index];
  76 }
  77
  78 static int
  79 govpp_stat_segment_data_type(stat_segment_data_t *data)
  80 {
  81         return data->type;
  82 }
  83
  84 static double
  85 govpp_stat_segment_data_get_scalar_value(stat_segment_data_t *data)
  86 {
  87         return data->scalar_value;
  88 }
  89
  90 static double
  91 govpp_stat_segment_data_get_error_value(stat_segment_data_t *data)
  92 {
  93         return data->error_value;
  94 }
  95
  96 static uint64_t**
  97 govpp_stat_segment_data_get_simple_counter(stat_segment_data_t *data)
  98 {
  99         return data->simple_counter_vec;
 100 }
 101
 102 static uint64_t*
 103 govpp_stat_segment_data_get_simple_counter_index(stat_segment_data_t *data, int index)
 104 {
 105         return data->simple_counter_vec[index];
 106 }
 107
 108 static uint64_t
 109 govpp_stat_segment_data_get_simple_counter_index_value(stat_segment_data_t *data, int index, int index2)
 110 {
 111         return data->simple_counter_vec[index][index2];
 112 }
 113
 114 static vlib_counter_t**
 115 govpp_stat_segment_data_get_combined_counter(stat_segment_data_t *data)
 116 {
 117         return data->combined_counter_vec;
 118 }
 119
 120 static vlib_counter_t*
 121 govpp_stat_segment_data_get_combined_counter_index(stat_segment_data_t *data, int index)
 122 {
 123         return data->combined_counter_vec[index];
 124 }
 125
 126 static uint64_t
 127 govpp_stat_segment_data_get_combined_counter_index_packets(stat_segment_data_t *data, int index, int index2)
 128 {
 129         return data->combined_counter_vec[index][index2].packets;
 130 }
 131
 132 static uint64_t
 133 govpp_stat_segment_data_get_combined_counter_index_bytes(stat_segment_data_t *data, int index, int index2)
 134 {
 135         return data->combined_counter_vec[index][index2].bytes;
 136 }
 137
 138 static uint8_t**
 139 govpp_stat_segment_data_get_name_vector(stat_segment_data_t *data)
 140 {
 141         return data->name_vector;
 142 }
 143
 144 static char*
 145 govpp_stat_segment_data_get_name_vector_index(stat_segment_data_t *data, int index)
 146 {
 147         return data->name_vector[index];
 148 }
 149
 150 static void
 151 govpp_stat_segment_data_free(stat_segment_data_t *data)
 152 {
 153         stat_segment_data_free(data);
 154 }
 155
 156 static uint8_t**
 157 govpp_stat_segment_string_vector(uint8_t ** string_vector, char *string)
 158 {
 159         return stat_segment_string_vector(string_vector, string);
 160 }
 161 */
 162 import "C"
 163 import (
 164         "fmt"
 165         "os"
 166         "unsafe"
 167
 168         "git.fd.io/govpp.git/adapter"
 169 )
 170
 171 var (
 172         // DefaultStatSocket is the default path for the VPP stat socket file.
 173         DefaultStatSocket = "/run/vpp/stats.sock"
 174 )
 175
 176 // global VPP stats API client, library vppapiclient only supports
 177 // single connection at a time
 178 var globalStatClient *statClient
 179
 180 // stubStatClient is the default implementation of StatsAPI.
 181 type statClient struct {
 182         socketName string
 183 }
 184
 185 // NewStatClient returns new VPP stats API client.
 186 func NewStatClient(socketName string) adapter.StatsAPI {
 187         return &statClient{
 188                 socketName: socketName,
 189         }
 190 }
 191
 192 func (c *statClient) Connect() error {
 193         if globalStatClient != nil {
 194                 return fmt.Errorf("already connected to stats API, disconnect first")
 195         }
 196
 197         var sockName string
 198         if c.socketName == "" {
 199                 sockName = DefaultStatSocket
 200         } else {
 201                 sockName = c.socketName
 202         }
 203
 204         rc := C.govpp_stat_connect(C.CString(sockName))
 205         if rc != 0 {
 206                 return fmt.Errorf("connecting to VPP stats API failed (rc=%v)", rc)
 207         }
 208
 209         globalStatClient = c
 210         return nil
 211 }
 212
 213 func (c *statClient) Disconnect() error {
 214         globalStatClient = nil
 215
 216         C.govpp_stat_disconnect()
 217         return nil
 218 }
 219
 220 func (c *statClient) ListStats(patterns ...string) (stats []string, err error) {
 221         dir := C.govpp_stat_segment_ls(convertStringSlice(patterns))
 222         defer C.govpp_stat_segment_vec_free(unsafe.Pointer(dir))
 223
 224         l := C.govpp_stat_segment_vec_len(unsafe.Pointer(dir))
 225         for i := 0; i < int(l); i++ {
 226                 nameChar := C.govpp_stat_segment_dir_index_to_name(dir, C.uint32_t(i))
 227                 stats = append(stats, C.GoString(nameChar))
 228                 C.free(unsafe.Pointer(nameChar))
 229         }
 230
 231         return stats, nil
 232 }
 233
 234 func (c *statClient) DumpStats(patterns ...string) (stats []*adapter.StatEntry, err error) {
 235         dir := C.govpp_stat_segment_ls(convertStringSlice(patterns))
 236         defer C.govpp_stat_segment_vec_free(unsafe.Pointer(dir))
 237
 238         dump := C.govpp_stat_segment_dump(dir)
 239         defer C.govpp_stat_segment_data_free(dump)
 240
 241         l := C.govpp_stat_segment_vec_len(unsafe.Pointer(dump))
 242         for i := 0; i < int(l); i++ {
 243                 v := C.govpp_stat_segment_dump_index(dump, C.int(i))
 244                 nameChar := v.name
 245                 name := C.GoString(nameChar)
 246                 typ := adapter.StatType(C.govpp_stat_segment_data_type(&v))
 247
 248                 stat := &adapter.StatEntry{
 249                         Name: name,
 250                         Type: typ,
 251                 }
 252
 253                 switch typ {
 254                 case adapter.ScalarIndex:
 255                         stat.Data = adapter.ScalarStat(C.govpp_stat_segment_data_get_scalar_value(&v))
 256
 257                 case adapter.ErrorIndex:
 258                         stat.Data = adapter.ErrorStat(C.govpp_stat_segment_data_get_error_value(&v))
 259
 260                 case adapter.SimpleCounterVector:
 261                         length := int(C.govpp_stat_segment_vec_len(unsafe.Pointer(C.govpp_stat_segment_data_get_simple_counter(&v))))
 262                         vector := make([][]adapter.Counter, length)
 263                         for k := 0; k < length; k++ {
 264                                 for j := 0; j < int(C.govpp_stat_segment_vec_len(unsafe.Pointer(C.govpp_stat_segment_data_get_simple_counter_index(&v, C.int(k))))); j++ {
 265                                         vector[k] = append(vector[k], adapter.Counter(C.govpp_stat_segment_data_get_simple_counter_index_value(&v, C.int(k), C.int(j))))
 266                                 }
 267                         }
 268                         stat.Data = adapter.SimpleCounterStat(vector)
 269
 270                 case adapter.CombinedCounterVector:
 271                         length := int(C.govpp_stat_segment_vec_len(unsafe.Pointer(C.govpp_stat_segment_data_get_combined_counter(&v))))
 272                         vector := make([][]adapter.CombinedCounter, length)
 273                         for k := 0; k < length; k++ {
 274                                 for j := 0; j < int(C.govpp_stat_segment_vec_len(unsafe.Pointer(C.govpp_stat_segment_data_get_combined_counter_index(&v, C.int(k))))); j++ {
 275                                         vector[k] = append(vector[k], adapter.CombinedCounter{
 276                                                 Packets: adapter.Counter(C.govpp_stat_segment_data_get_combined_counter_index_packets(&v, C.int(k), C.int(j))),
 277                                                 Bytes:   adapter.Counter(C.govpp_stat_segment_data_get_combined_counter_index_bytes(&v, C.int(k), C.int(j))),
 278                                         })
 279                                 }
 280                         }
 281                         stat.Data = adapter.CombinedCounterStat(vector)
 282
 283                 case adapter.NameVector:
 284                         length := int(C.govpp_stat_segment_vec_len(unsafe.Pointer(C.govpp_stat_segment_data_get_name_vector(&v))))
 285                         var vector []adapter.Name
 286                         for k := 0; k < length; k++ {
 287                                 s := C.govpp_stat_segment_data_get_name_vector_index(&v, C.int(k))
 288                                 var name adapter.Name
 289                                 if s != nil {
 290                                         name = adapter.Name(C.GoString(s))
 291                                 }
 292                                 vector = append(vector, name)
 293                         }
 294                         stat.Data = adapter.NameStat(vector)
 295
 296                 default:
 297                         fmt.Fprintf(os.Stderr, "invalid stat type: %v (%v)\n", typ, name)
 298                         continue
 299
 300                 }
 301
 302                 stats = append(stats, stat)
 303         }
 304
 305         return stats, nil
 306 }
 307
 308 func convertStringSlice(strs []string) **C.uint8_t {
 309         var arr **C.uint8_t
 310         for _, str := range strs {
 311                 arr = C.govpp_stat_segment_string_vector(arr, C.CString(str))
 312         }
 313         return arr
 314 }