X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=adapter%2Fstats_api.go;h=1319d71b9326b301e33c2c1fde36e5b8ec6c95b9;hb=ba6e92d715c59dc71c4e18e66b262d07578d524b;hp=40878653e5a7a5a9eb35a181a7405a735c18c402;hpb=df1b888a2bfadefadc7dbfce59d34f811ff002ec;p=govpp.git diff --git a/adapter/stats_api.go b/adapter/stats_api.go index 4087865..1319d71 100644 --- a/adapter/stats_api.go +++ b/adapter/stats_api.go @@ -15,22 +15,40 @@ package adapter import ( + "errors" "fmt" ) +const ( + // DefaultStatsSocket defines a default socket file path for VPP stats API. + DefaultStatsSocket = "/run/vpp/stats.sock" +) + +var ( + ErrStatsDataBusy = errors.New("stats data busy") + ErrStatsDirStale = errors.New("stats dir stale") + ErrStatsDisconnected = errors.New("stats disconnected") + ErrStatsAccessFailed = errors.New("stats access failed") +) + // StatsAPI provides connection to VPP stats API. type StatsAPI interface { // Connect establishes client connection to the stats API. Connect() error - // Disconnect terminates client connection. Disconnect() error - // ListStats lists names for all stats. - ListStats(patterns ...string) (statNames []string, err error) - + // ListStats lists indexed names for stats matching patterns. + ListStats(patterns ...string) (indexes []StatIdentifier, err error) // DumpStats dumps all stat entries. - DumpStats(patterns ...string) ([]*StatEntry, error) + DumpStats(patterns ...string) (entries []StatEntry, err error) + + // PrepareDir prepares new stat dir for entries that match any of prefixes. + PrepareDir(patterns ...string) (*StatDir, error) + // PrepareDirOnIndex prepares new stat dir for entries that match any of indexes. + PrepareDirOnIndex(indexes ...uint32) (*StatDir, error) + // UpdateDir updates stat dir and all of their entries. + UpdateDir(dir *StatDir) error } // StatType represents type of stat directory and simply @@ -44,6 +62,8 @@ const ( CombinedCounterVector StatType = 3 ErrorIndex StatType = 4 NameVector StatType = 5 + Empty StatType = 6 + Symlink StatType = 7 ) func (d StatType) String() string { @@ -58,57 +78,201 @@ func (d StatType) String() string { return "ErrorIndex" case NameVector: return "NameVector" + case Empty: + return "Empty" + case Symlink: + return "Symlink" } return fmt.Sprintf("UnknownStatType(%d)", d) } +// StatDir defines directory of stats entries created by PrepareDir. +type StatDir struct { + Epoch int64 + Entries []StatEntry +} + +// StatIdentifier holds a stat entry name and index +type StatIdentifier struct { + Index uint32 + Name []byte +} + // StatEntry represents single stat entry. The type of stat stored in Data // is defined by Type. type StatEntry struct { - Name string - Type StatType - Data Stat + StatIdentifier + Type StatType + Data Stat + Symlink bool } -// Counter represents simple counter with single value. +// Counter represents simple counter with single value, which is usually packet count. type Counter uint64 // CombinedCounter represents counter with two values, for packet count and bytes count. -type CombinedCounter struct { - Packets Counter - Bytes Counter +type CombinedCounter [2]uint64 + +func (s CombinedCounter) Packets() uint64 { + return s[0] +} + +func (s CombinedCounter) Bytes() uint64 { + return s[1] } // Name represents string value stored under name vector. -type Name string +type Name []byte + +func (n Name) String() string { + return string(n) +} + +// Stat represents some type of stat which is usually defined by StatType. +type Stat interface { + // IsZero returns true if all of its values equal to zero. + IsZero() bool + + // Type returns underlying type of a stat + Type() StatType + + // isStat is intentionally unexported to limit implementations of interface to this package, + isStat() +} // ScalarStat represents stat for ScalarIndex. type ScalarStat float64 -// ErrorStat represents stat for ErrorIndex. -type ErrorStat uint64 +// ErrorStat represents stat for ErrorIndex. The array represents workers. +type ErrorStat []Counter -// SimpleCounterStat represents stat for SimpleCounterVector. +// SimpleCounterStat represents indexed stat for SimpleCounterVector. // The outer array represents workers and the inner array represents interface/node/.. indexes. // Values should be aggregated per interface/node for every worker. +// ReduceSimpleCounterStatIndex can be used to reduce specific index. type SimpleCounterStat [][]Counter -// CombinedCounterStat represents stat for CombinedCounterVector. +// CombinedCounterStat represents indexed stat for CombinedCounterVector. // The outer array represents workers and the inner array represents interface/node/.. indexes. // Values should be aggregated per interface/node for every worker. +// ReduceCombinedCounterStatIndex can be used to reduce specific index. type CombinedCounterStat [][]CombinedCounter // NameStat represents stat for NameVector. type NameStat []Name -// Data represents some type of stat which is usually defined by StatType. -type Stat interface { - // isStat is unexported to limit implementations of Data interface to this package, - isStat() -} +// EmptyStat represents removed counter directory +type EmptyStat string func (ScalarStat) isStat() {} func (ErrorStat) isStat() {} func (SimpleCounterStat) isStat() {} func (CombinedCounterStat) isStat() {} func (NameStat) isStat() {} +func (EmptyStat) isStat() {} + +func (s ScalarStat) IsZero() bool { + return s == 0 +} + +func (s ScalarStat) Type() StatType { + return ScalarIndex +} + +func (s ErrorStat) IsZero() bool { + if s == nil { + return true + } + for _, ss := range s { + if ss != 0 { + return false + } + } + return true +} + +func (s ErrorStat) Type() StatType { + return ErrorIndex +} + +func (s SimpleCounterStat) IsZero() bool { + if s == nil { + return true + } + for _, ss := range s { + for _, sss := range ss { + if sss != 0 { + return false + } + } + } + return true +} + +func (s SimpleCounterStat) Type() StatType { + return SimpleCounterVector +} + +func (s CombinedCounterStat) IsZero() bool { + if s == nil { + return true + } + for _, ss := range s { + if ss == nil { + return true + } + for _, sss := range ss { + if sss[0] != 0 || sss[1] != 0 { + return false + } + } + } + return true +} + +func (s CombinedCounterStat) Type() StatType { + return CombinedCounterVector +} + +func (s NameStat) IsZero() bool { + if s == nil { + return true + } + for _, ss := range s { + if len(ss) > 0 { + return false + } + } + return true +} + +func (s NameStat) Type() StatType { + return NameVector +} + +func (s EmptyStat) IsZero() bool { + return true +} + +func (s EmptyStat) Type() StatType { + return Empty +} + +// ReduceSimpleCounterStatIndex returns reduced SimpleCounterStat s for index i. +func ReduceSimpleCounterStatIndex(s SimpleCounterStat, i int) uint64 { + var val uint64 + for _, w := range s { + val += uint64(w[i]) + } + return val +} + +// ReduceCombinedCounterStatIndex returns reduced CombinedCounterStat s for index i. +func ReduceCombinedCounterStatIndex(s CombinedCounterStat, i int) [2]uint64 { + var val [2]uint64 + for _, w := range s { + val[0] += w[i][0] + val[1] += w[i][1] + } + return val +}