extras/vom/vom/stat_client.cpp

   1 /*
   2  * Copyright (c) 2018 Cisco and/or its affiliates.
   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
  16 #include "vom/stat_client.hpp"
  17
  18 namespace VOM {
  19
  20 stat_client::stat_data_t::stat_data_t(const stat_segment_data_t& stat_seg_data)
  21   : m_name(stat_seg_data.name)
  22   , m_type(stat_seg_data.type)
  23 {
  24   switch (m_type) {
  25     case STAT_DIR_TYPE_SCALAR_INDEX:
  26       m_scalar_value = stat_seg_data.scalar_value;
  27       break;
  28     case STAT_DIR_TYPE_COUNTER_VECTOR_SIMPLE:
  29       m_simple_counter_vec = stat_seg_data.simple_counter_vec;
  30       break;
  31     case STAT_DIR_TYPE_COUNTER_VECTOR_COMBINED:
  32       m_combined_counter_vec = stat_seg_data.combined_counter_vec;
  33       break;
  34     case STAT_DIR_TYPE_ERROR_INDEX:
  35       m_error_vec = stat_seg_data.error_vector;
  36       break;
  37     case STAT_DIR_TYPE_NAME_VECTOR:
  38       break;
  39     case STAT_DIR_TYPE_ILLEGAL:
  40       break;
  41   }
  42 }
  43
  44 const std::string&
  45 stat_client::stat_data_t::name() const
  46 {
  47   return m_name;
  48 }
  49
  50 const stat_directory_type_t&
  51 stat_client::stat_data_t::type() const
  52 {
  53   return m_type;
  54 }
  55
  56 double
  57 stat_client::stat_data_t::get_stat_segment_scalar_data() const
  58 {
  59   return m_scalar_value;
  60 }
  61
  62 uint64_t*
  63 stat_client::stat_data_t::get_stat_segment_error_data() const
  64 {
  65   return m_error_vec;
  66 }
  67
  68 uint64_t**
  69 stat_client::stat_data_t::get_stat_segment_simple_counter_data() const
  70 {
  71   return m_simple_counter_vec;
  72 }
  73
  74 vlib_counter_t**
  75 stat_client::stat_data_t::get_stat_segment_combined_counter_data() const
  76 {
  77   return m_combined_counter_vec;
  78 }
  79
  80 stat_client::stat_client(std::string& socket_name)
  81   : m_socket_name(socket_name)
  82   , m_patterns()
  83   , m_stat_connect(false)
  84   , m_counter_vec()
  85   , m_stat_seg_data(nullptr)
  86   , m_stat_data()
  87 {
  88   m_patterns.push_back("/if");
  89 }
  90
  91 stat_client::stat_client(std::vector<std::string>& pattern)
  92   : m_socket_name("/run/vpp/stats.sock")
  93   , m_patterns(pattern)
  94   , m_stat_connect(false)
  95   , m_counter_vec()
  96   , m_stat_seg_data(nullptr)
  97   , m_stat_data()
  98 {
  99 }
 100
 101 stat_client::stat_client(std::string socket_name,
 102                          std::vector<std::string> patterns)
 103   : m_socket_name(socket_name)
 104   , m_patterns(patterns)
 105   , m_stat_connect(false)
 106   , m_counter_vec()
 107   , m_stat_seg_data(nullptr)
 108   , m_stat_data()
 109 {
 110 }
 111
 112 stat_client::stat_client()
 113   : m_socket_name("/run/vpp/stats.sock")
 114   , m_patterns()
 115   , m_stat_connect(false)
 116   , m_counter_vec()
 117   , m_stat_seg_data(nullptr)
 118   , m_stat_data()
 119 {
 120   m_patterns.push_back("/if");
 121 }
 122
 123 stat_client::~stat_client()
 124 {
 125   stat_segment_vec_free(m_counter_vec);
 126   data_free();
 127   if (m_stat_connect)
 128     stat_segment_disconnect();
 129 }
 130
 131 stat_client::stat_client(const stat_client& o)
 132   : m_socket_name(o.m_socket_name)
 133   , m_patterns(o.m_patterns)
 134 {
 135 }
 136
 137 int
 138 stat_client::connect()
 139 {
 140   if (stat_segment_connect(m_socket_name.c_str()) == 0) {
 141     m_stat_connect = true;
 142     ls();
 143   }
 144   return m_stat_connect;
 145 }
 146
 147 void
 148 stat_client::disconnect()
 149 {
 150   if (m_stat_connect)
 151     stat_segment_disconnect();
 152   m_stat_connect = false;
 153 }
 154
 155 int
 156 stat_client::vec_len(void* vec)
 157 {
 158   return stat_segment_vec_len(vec);
 159 }
 160
 161 void
 162 stat_client::vec_free(void* vec)
 163 {
 164   stat_segment_vec_free(vec);
 165 }
 166
 167 void
 168 stat_client::ls()
 169 {
 170   uint8_t** string_vec = { 0 };
 171   for (auto& pattern : m_patterns) {
 172     string_vec = stat_segment_string_vector(string_vec, pattern.c_str());
 173   }
 174   m_counter_vec = stat_segment_ls(string_vec);
 175   stat_segment_vec_free(string_vec);
 176 }
 177
 178 const stat_client::stat_data_vec_t&
 179 stat_client::dump()
 180 {
 181   stat_segment_data_free(m_stat_seg_data);
 182   m_stat_seg_data = NULL;
 183   if (m_stat_data.size()) {
 184     m_stat_data.clear();
 185   }
 186   if (m_stat_connect) {
 187     m_stat_seg_data = stat_segment_dump(m_counter_vec);
 188     if (!m_stat_seg_data) {
 189       ls();
 190       return m_stat_data;
 191     }
 192     for (int i = 0; i < stat_segment_vec_len(m_stat_seg_data); i++) {
 193       stat_data_t sd(m_stat_seg_data[i]);
 194       m_stat_data.push_back(sd);
 195     }
 196   }
 197   return m_stat_data;
 198 }
 199
 200 const stat_client::stat_data_vec_t&
 201 stat_client::dump_entry(uint32_t index)
 202 {
 203   stat_segment_data_free(m_stat_seg_data);
 204   m_stat_seg_data = NULL;
 205   if (m_stat_data.size()) {
 206     m_stat_data.clear();
 207   }
 208   if (m_stat_connect) {
 209     m_stat_seg_data = stat_segment_dump_entry(index);
 210     if (!m_stat_seg_data) {
 211       ls();
 212       return m_stat_data;
 213     }
 214     for (int i = 0; i < stat_segment_vec_len(m_stat_seg_data); i++) {
 215       stat_data_t sd(m_stat_seg_data[i]);
 216       m_stat_data.push_back(sd);
 217     }
 218   }
 219   return m_stat_data;
 220 }
 221
 222 void
 223 stat_client::data_free()
 224 {
 225   stat_segment_data_free(m_stat_seg_data);
 226 }
 227
 228 double
 229 stat_client::heartbeat()
 230 {
 231   return stat_segment_heartbeat();
 232 }
 233
 234 std::string
 235 stat_client::index_to_name(uint32_t index)
 236 {
 237   return stat_segment_index_to_name(index);
 238 }
 239
 240 } // namespace VOM
 241
 242 /*
 243  * fd.io coding-style-patch-verification: ON
 244  *
 245  * Local Variables:
 246  * eval: (c-set-style "mozilla")
 247  * End:
 248  */