examples/stats-client/stats_api.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 package main
  16
  17 import (
  18         "flag"
  19         "fmt"
  20         "log"
  21         "os"
  22         "strings"
  23         "time"
  24
  25         "git.fd.io/govpp.git/adapter"
  26         "git.fd.io/govpp.git/adapter/statsclient"
  27         "git.fd.io/govpp.git/api"
  28         "git.fd.io/govpp.git/core"
  29 )
  30
  31 // ------------------------------------------------------------------
  32 // Example - Stats API
  33 // ------------------------------------------------------------------
  34 // The example stats_api demonstrates how to retrieve stats
  35 // from the VPP using the new stats API.
  36 // ------------------------------------------------------------------
  37
  38 var (
  39         statsSocket = flag.String("socket", statsclient.DefaultSocketName, "Path to VPP stats socket")
  40         dumpAll     = flag.Bool("all", false, "Dump all stats including ones with zero values")
  41         pollPeriod  = flag.Duration("period", time.Second*5, "Polling interval period")
  42         async       = flag.Bool("async", false, "Use asynchronous connection")
  43 )
  44
  45 func init() {
  46         flag.Usage = func() {
  47                 fmt.Fprintf(os.Stderr, "%s: usage [ls|dump|poll|errors|interfaces|nodes|system|buffers|memory] <patterns>...\n", os.Args[0])
  48                 flag.PrintDefaults()
  49                 os.Exit(1)
  50         }
  51 }
  52
  53 func main() {
  54         flag.Parse()
  55         skipZeros := !*dumpAll
  56
  57         var patterns []string
  58         if flag.NArg() > 0 {
  59                 patterns = flag.Args()[1:]
  60         }
  61
  62         var (
  63                 client *statsclient.StatsClient
  64                 c      *core.StatsConnection
  65                 err    error
  66         )
  67
  68         if *async {
  69                 var statsChan chan core.ConnectionEvent
  70                 client = statsclient.NewStatsClient(*statsSocket)
  71                 c, statsChan, err = core.AsyncConnectStats(client, core.DefaultMaxReconnectAttempts, core.DefaultReconnectInterval)
  72                 if err != nil {
  73                         log.Fatalln("Asynchronous connecting failed:", err)
  74                 }
  75                 select {
  76                 case e := <-statsChan:
  77                         if e.State == core.Connected {
  78                                 // OK
  79                         } else {
  80                                 log.Fatalf("VPP stats asynchronous connection failed: %s\n", e.State.String())
  81                         }
  82                 }
  83         } else {
  84                 client = statsclient.NewStatsClient(*statsSocket)
  85                 c, err = core.ConnectStats(client)
  86                 if err != nil {
  87                         log.Fatalln("Connecting failed:", err)
  88                 }
  89         }
  90         defer c.Disconnect()
  91
  92         switch cmd := flag.Arg(0); cmd {
  93         case "system":
  94                 stats := new(api.SystemStats)
  95                 if err := c.GetSystemStats(stats); err != nil {
  96                         log.Fatalln("getting system stats failed:", err)
  97                 }
  98                 fmt.Printf("System stats: %+v\n", stats)
  99
 100         case "poll-system":
 101                 pollSystem(c)
 102
 103         case "nodes":
 104                 fmt.Println("Listing node stats..")
 105                 stats := new(api.NodeStats)
 106                 if err := c.GetNodeStats(stats); err != nil {
 107                         log.Fatalln("getting node stats failed:", err)
 108                 }
 109
 110                 for _, node := range stats.Nodes {
 111                         if skipZeros && node.Calls == 0 && node.Suspends == 0 && node.Clocks == 0 && node.Vectors == 0 {
 112                                 continue
 113                         }
 114                         fmt.Printf(" - %+v\n", node)
 115                 }
 116                 fmt.Printf("Listed %d node counters\n", len(stats.Nodes))
 117
 118         case "interfaces":
 119                 fmt.Println("Listing interface stats..")
 120                 stats := new(api.InterfaceStats)
 121                 if err := c.GetInterfaceStats(stats); err != nil {
 122                         log.Fatalln("getting interface stats failed:", err)
 123                 }
 124                 for _, iface := range stats.Interfaces {
 125                         fmt.Printf(" - %+v\n", iface)
 126                 }
 127                 fmt.Printf("Listed %d interface counters\n", len(stats.Interfaces))
 128
 129         case "poll-interfaces":
 130                 pollInterfaces(c)
 131
 132         case "errors":
 133                 fmt.Printf("Listing error stats.. %s\n", strings.Join(patterns, " "))
 134                 stats := new(api.ErrorStats)
 135                 if err := c.GetErrorStats(stats); err != nil {
 136                         log.Fatalln("getting error stats failed:", err)
 137                 }
 138                 n := 0
 139                 for _, counter := range stats.Errors {
 140                         if skipZeros && counter.Value == 0 {
 141                                 continue
 142                         }
 143                         fmt.Printf(" - %v\n", counter)
 144                         n++
 145                 }
 146                 fmt.Printf("Listed %d (%d) error counters\n", n, len(stats.Errors))
 147
 148         case "buffers":
 149                 stats := new(api.BufferStats)
 150                 if err := c.GetBufferStats(stats); err != nil {
 151                         log.Fatalln("getting buffer stats failed:", err)
 152                 }
 153                 fmt.Printf("Buffer stats: %+v\n", stats)
 154
 155         case "memory":
 156                 stats := new(api.MemoryStats)
 157                 if err := c.GetMemoryStats(stats); err != nil {
 158                         log.Fatalln("getting memory stats failed:", err)
 159                 }
 160                 fmt.Printf("Memory stats: %+v\n", stats)
 161
 162         case "dump":
 163                 fmt.Printf("Dumping stats.. %s\n", strings.Join(patterns, " "))
 164
 165                 dumpStats(client, patterns, skipZeros)
 166
 167         case "poll":
 168                 fmt.Printf("Polling stats.. %s\n", strings.Join(patterns, " "))
 169
 170                 pollStats(client, patterns, skipZeros)
 171
 172         case "list", "ls", "":
 173                 fmt.Printf("Listing stats.. %s\n", strings.Join(patterns, " "))
 174
 175                 listStats(client, patterns)
 176
 177         default:
 178                 fmt.Printf("invalid command: %q\n", cmd)
 179         }
 180 }
 181
 182 func listStats(client adapter.StatsAPI, patterns []string) {
 183         list, err := client.ListStats(patterns...)
 184         if err != nil {
 185                 log.Fatalln("listing stats failed:", err)
 186         }
 187
 188         for _, stat := range list {
 189                 fmt.Printf(" - %v\n", stat)
 190         }
 191
 192         fmt.Printf("Listed %d stats\n", len(list))
 193 }
 194
 195 func dumpStats(client adapter.StatsAPI, patterns []string, skipZeros bool) {
 196         stats, err := client.DumpStats(patterns...)
 197         if err != nil {
 198                 log.Fatalln("dumping stats failed:", err)
 199         }
 200
 201         n := 0
 202         for _, stat := range stats {
 203                 if skipZeros && (stat.Data == nil || stat.Data.IsZero()) {
 204                         continue
 205                 }
 206                 fmt.Printf(" - %-50s %25v %+v\n", stat.Name, stat.Type, stat.Data)
 207                 n++
 208         }
 209
 210         fmt.Printf("Dumped %d (%d) stats\n", n, len(stats))
 211 }
 212
 213 func pollStats(client adapter.StatsAPI, patterns []string, skipZeros bool) {
 214         dir, err := client.PrepareDir(patterns...)
 215         if err != nil {
 216                 log.Fatalln("preparing dir failed:", err)
 217         }
 218
 219         tick := time.Tick(*pollPeriod)
 220         for {
 221                 n := 0
 222                 fmt.Println(time.Now().Format(time.Stamp))
 223                 for _, stat := range dir.Entries {
 224                         if skipZeros && (stat.Data == nil || stat.Data.IsZero()) {
 225                                 continue
 226                         }
 227                         fmt.Printf("%-50s %+v\n", stat.Name, stat.Data)
 228                         n++
 229                 }
 230                 fmt.Println()
 231
 232                 select {
 233                 case <-tick:
 234                         if err := client.UpdateDir(dir); err != nil {
 235                                 if err == adapter.ErrStatsDirStale {
 236                                         if dir, err = client.PrepareDir(patterns...); err != nil {
 237                                                 log.Fatalln("preparing dir failed:", err)
 238                                         }
 239                                         continue
 240                                 }
 241                                 log.Fatalln("updating dir failed:", err)
 242                         }
 243                 }
 244         }
 245 }
 246
 247 func pollSystem(client api.StatsProvider) {
 248         stats := new(api.SystemStats)
 249
 250         if err := client.GetSystemStats(stats); err != nil {
 251                 log.Fatalln("updating system stats failed:", err)
 252         }
 253
 254         tick := time.Tick(*pollPeriod)
 255         for {
 256                 fmt.Printf("System stats: %+v\n", stats)
 257                 fmt.Println()
 258
 259                 select {
 260                 case <-tick:
 261                         if err := client.GetSystemStats(stats); err != nil {
 262                                 log.Println("updating system stats failed:", err)
 263                         }
 264                 }
 265         }
 266 }
 267
 268 func pollInterfaces(client api.StatsProvider) {
 269         stats := new(api.InterfaceStats)
 270
 271         if err := client.GetInterfaceStats(stats); err != nil {
 272                 log.Fatalln("updating system stats failed:", err)
 273         }
 274
 275         tick := time.Tick(*pollPeriod)
 276         for {
 277                 fmt.Printf("Interface stats (%d interfaces)\n", len(stats.Interfaces))
 278                 for i := range stats.Interfaces {
 279                         fmt.Printf(" - %+v\n", stats.Interfaces[i])
 280                 }
 281                 fmt.Println()
 282
 283                 select {
 284                 case <-tick:
 285                         if err := client.GetInterfaceStats(stats); err != nil {
 286                                 log.Println("updating system stats failed:", err)
 287                         }
 288                 }
 289         }
 290 }