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