Properly close the socket watcher
[govpp.git] / adapter / statsclient / statsclient.go
index f3be4e0..6231f69 100644 (file)
@@ -20,11 +20,14 @@ import (
        "fmt"
        "net"
        "os"
+       "path/filepath"
        "regexp"
+       "sync/atomic"
        "syscall"
        "time"
 
        "git.fd.io/govpp.git/adapter"
+       "github.com/fsnotify/fsnotify"
        "github.com/ftrvxmtrx/fd"
        logger "github.com/sirupsen/logrus"
 )
@@ -32,21 +35,14 @@ import (
 const (
        // DefaultSocketName is default VPP stats socket file path.
        DefaultSocketName = adapter.DefaultStatsSocket
-)
-
-const socketMissing = `
-------------------------------------------------------------
- VPP stats socket file %s is missing!
 
-  - is VPP running with stats segment enabled?
-  - is the correct socket name configured?
+       // DefaultSocketRetryPeriod is the time period after the socket availability
+       // will be re-checked
+       DefaultSocketRetryPeriod = 50 * time.Millisecond
 
- To enable it add following section to your VPP config:
-   statseg {
-     default
-   }
-------------------------------------------------------------
-`
+       // DefaultSocketRetryTimeout is the maximum time for the stats socket
+       DefaultSocketRetryTimeout = 3 * time.Second
+)
 
 var (
        // Debug is global variable that determines debug mode
@@ -76,44 +72,78 @@ var _ adapter.StatsAPI = (*StatsClient)(nil)
 
 // StatsClient is the pure Go implementation for VPP stats API.
 type StatsClient struct {
-       sockAddr    string
-       headerData  []byte
-       isConnected bool
+       socket       string
+       retryPeriod  time.Duration
+       retryTimeout time.Duration
+
+       headerData []byte
+
+       // defines the adapter connection state
+       connected uint32
+
+       // to quit socket monitor
+       done chan struct{}
 
        statSegment
 }
 
-// NewStatsClient returns new VPP stats API client.
-func NewStatsClient(sockAddr string) *StatsClient {
-       if sockAddr == "" {
-               sockAddr = DefaultSocketName
+// Option is a StatsClient option
+type Option func(*StatsClient)
+
+// SetSocketRetryPeriod is and optional parameter to define a custom
+// retry period while waiting for the VPP socket
+func SetSocketRetryPeriod(t time.Duration) Option {
+       return func(c *StatsClient) {
+               c.retryPeriod = t
        }
-       return &StatsClient{
-               sockAddr: sockAddr,
+}
+
+// SetSocketRetryTimeout is and optional parameter to define a custom
+// timeout while waiting for the VPP socket
+func SetSocketRetryTimeout(t time.Duration) Option {
+       return func(c *StatsClient) {
+               c.retryTimeout = t
        }
 }
-// Connect to the VPP stats socket
-func (sc *StatsClient) Connect() (err error) {
-       // check if socket exists
-       if _, err := os.Stat(sc.sockAddr); os.IsNotExist(err) {
-               fmt.Fprintf(os.Stderr, socketMissing, sc.sockAddr)
-               return fmt.Errorf("stats socket file %s does not exist", sc.sockAddr)
-       } else if err != nil {
-               return fmt.Errorf("stats socket error: %v", err)
+
+// NewStatsClient returns a new StatsClient using socket.
+// If socket is empty string DefaultSocketName is used.
+func NewStatsClient(socket string, options ...Option) *StatsClient {
+       if socket == "" {
+               socket = DefaultSocketName
        }
-       if sc.isConnected {
-               return fmt.Errorf("already connected")
+       s := &StatsClient{
+               socket: socket,
        }
+       for _, option := range options {
+               option(s)
+       }
+       if s.retryPeriod == 0 {
+               s.retryPeriod = DefaultSocketRetryPeriod
+       }
+       if s.retryTimeout == 0 {
+               s.retryTimeout = DefaultSocketRetryTimeout
+       }
+       return s
+}
+
+// Connect to validated VPP stats socket and start monitoring
+// socket file changes
+func (sc *StatsClient) Connect() (err error) {
+       if err := sc.waitForSocket(); err != nil {
+               return err
+       }
+       sc.done = make(chan struct{})
        if sc.statSegment, err = sc.connect(); err != nil {
                return err
        }
-       sc.isConnected = true
+       sc.monitorSocket()
        return nil
 }
 
-// Disconnect from the socket and unmap shared memory
+// Disconnect from the socket, unmap shared memory and terminate
+// socket monitor
 func (sc *StatsClient) Disconnect() error {
-       sc.isConnected = false
        if sc.headerData == nil {
                return nil
        }
@@ -122,137 +152,115 @@ func (sc *StatsClient) Disconnect() error {
                return fmt.Errorf("unmapping shared memory failed: %v", err)
        }
        sc.headerData = nil
+       sc.done <- struct{}{}
 
        Log.Debugf("successfully unmapped shared memory")
        return nil
 }
 
-func (sc *StatsClient) ListStats(patterns ...string) ([]string, error) {
+func (sc *StatsClient) ListStats(patterns ...string) (entries []adapter.StatIdentifier, err error) {
+       if !sc.isConnected() {
+               return nil, adapter.ErrStatsDisconnected
+       }
        accessEpoch := sc.accessStart()
        if accessEpoch == 0 {
                return nil, adapter.ErrStatsAccessFailed
        }
 
-       indexes, err := sc.listIndexes(patterns...)
+       entries, err = sc.getIdentifierEntries(patterns...)
        if err != nil {
                return nil, err
        }
 
-       dirVector, err := sc.GetDirectoryVector()
-       if err != nil {
-               return nil, fmt.Errorf("failed to list stats: %v", err)
-       }
-       vecLen := *(*uint32)(vectorLen(dirVector))
-
-       var names []string
-       for _, index := range indexes {
-               if index >= vecLen {
-                       return nil, fmt.Errorf("stat entry index %d out of dir vector len (%d)", index, vecLen)
-               }
-               _, dirName, _ := sc.GetStatDirOnIndex(dirVector, index)
-               names = append(names, string(dirName))
-       }
-
        if !sc.accessEnd(accessEpoch) {
                return nil, adapter.ErrStatsDataBusy
        }
-
-       return names, nil
+       return entries, nil
 }
 
 func (sc *StatsClient) DumpStats(patterns ...string) (entries []adapter.StatEntry, err error) {
+       if !sc.isConnected() {
+               return nil, adapter.ErrStatsDisconnected
+       }
+
        accessEpoch := sc.accessStart()
        if accessEpoch == 0 {
                return nil, adapter.ErrStatsAccessFailed
        }
 
-       indexes, err := sc.listIndexes(patterns...)
+       entries, err = sc.getStatEntries(patterns...)
        if err != nil {
                return nil, err
        }
 
-       dirVector, err := sc.GetDirectoryVector()
-       if err != nil {
-               return nil, err
-       }
-       dirLen := *(*uint32)(vectorLen(dirVector))
-
-       debugf("dumping entries for %d indexes", len(indexes))
-
-       entries = make([]adapter.StatEntry, 0, len(indexes))
-       for _, index := range indexes {
-               if index >= dirLen {
-                       return nil, fmt.Errorf("stat entry index %d out of dir vector length (%d)", index, dirLen)
-               }
-               dirPtr, dirName, dirType := sc.GetStatDirOnIndex(dirVector, index)
-               if len(dirName) == 0 {
-                       continue
-               }
-               entry := adapter.StatEntry{
-                       Name: append([]byte(nil), dirName...),
-                       Type: adapter.StatType(dirType),
-                       Data: sc.CopyEntryData(dirPtr),
-               }
-               entries = append(entries, entry)
-       }
-
        if !sc.accessEnd(accessEpoch) {
                return nil, adapter.ErrStatsDataBusy
        }
-
        return entries, nil
 }
 
 func (sc *StatsClient) PrepareDir(patterns ...string) (*adapter.StatDir, error) {
-       dir := new(adapter.StatDir)
+       if !sc.isConnected() {
+               return nil, adapter.ErrStatsDisconnected
+       }
 
        accessEpoch := sc.accessStart()
        if accessEpoch == 0 {
                return nil, adapter.ErrStatsAccessFailed
        }
 
-       indexes, err := sc.listIndexes(patterns...)
+       entries, err := sc.getStatEntries(patterns...)
        if err != nil {
                return nil, err
        }
-       dir.Indexes = indexes
 
-       dirVector, err := sc.GetDirectoryVector()
-       if err != nil {
-               return nil, err
+       if !sc.accessEnd(accessEpoch) {
+               return nil, adapter.ErrStatsDataBusy
        }
-       dirLen := *(*uint32)(vectorLen(dirVector))
 
-       debugf("dumping entries for %d indexes", len(indexes))
+       dir := &adapter.StatDir{
+               Epoch:   accessEpoch,
+               Entries: entries,
+       }
 
-       entries := make([]adapter.StatEntry, 0, len(indexes))
-       for _, index := range indexes {
-               if index >= dirLen {
-                       return nil, fmt.Errorf("stat entry index %d out of dir vector length (%d)", index, dirLen)
-               }
-               dirPtr, dirName, dirType := sc.GetStatDirOnIndex(dirVector, index)
-               if len(dirName) == 0 {
-                       continue
-               }
-               entry := adapter.StatEntry{
-                       Name: append([]byte(nil), dirName...),
-                       Type: adapter.StatType(dirType),
-                       Data: sc.CopyEntryData(dirPtr),
-               }
-               entries = append(entries, entry)
+       return dir, nil
+}
+
+func (sc *StatsClient) PrepareDirOnIndex(indexes ...uint32) (*adapter.StatDir, error) {
+       if !sc.isConnected() {
+               return nil, adapter.ErrStatsDisconnected
+       }
+
+       accessEpoch := sc.accessStart()
+       if accessEpoch == 0 {
+               return nil, adapter.ErrStatsAccessFailed
+       }
+       vector := sc.GetDirectoryVector()
+       if vector == nil {
+               return nil, fmt.Errorf("failed to prepare dir on index: directory vector is nil")
+       }
+       entries, err := sc.getStatEntriesOnIndex(vector, indexes...)
+       if err != nil {
+               return nil, err
        }
-       dir.Entries = entries
 
        if !sc.accessEnd(accessEpoch) {
                return nil, adapter.ErrStatsDataBusy
        }
-       dir.Epoch = accessEpoch
+
+       dir := &adapter.StatDir{
+               Epoch:   accessEpoch,
+               Entries: entries,
+       }
 
        return dir, nil
 }
 
 // UpdateDir refreshes directory data for all counters
 func (sc *StatsClient) UpdateDir(dir *adapter.StatDir) (err error) {
+       if !sc.isConnected() {
+               return adapter.ErrStatsDisconnected
+       }
        epoch, _ := sc.GetEpoch()
        if dir.Epoch != epoch {
                return adapter.ErrStatsDirStale
@@ -262,41 +270,53 @@ func (sc *StatsClient) UpdateDir(dir *adapter.StatDir) (err error) {
        if accessEpoch == 0 {
                return adapter.ErrStatsAccessFailed
        }
-
-       dirVector, err := sc.GetDirectoryVector()
-       if err != nil {
+       dirVector := sc.GetDirectoryVector()
+       if dirVector == nil {
                return err
        }
-       for i, index := range dir.Indexes {
-               statSegDir, dirName, dirType := sc.GetStatDirOnIndex(dirVector, index)
-               if len(dirName) == 0 {
-                       continue
-               }
-               entry := &dir.Entries[i]
-               if !bytes.Equal(dirName, entry.Name) {
-                       continue
-               }
-               if adapter.StatType(dirType) != entry.Type {
-                       continue
-               }
-               if entry.Data == nil {
-                       continue
-               }
-               if err := sc.UpdateEntryData(statSegDir, &entry.Data); err != nil {
-                       return fmt.Errorf("updating stat data for entry %s failed: %v", dirName, err)
+       for i := 0; i < len(dir.Entries); i++ {
+               if err := sc.updateStatOnIndex(&dir.Entries[i], dirVector); err != nil {
+                       return err
                }
        }
        if !sc.accessEnd(accessEpoch) {
                return adapter.ErrStatsDataBusy
        }
+       return nil
+}
 
+// checks the socket existence and waits for it for the designated
+// time if it is not available immediately
+func (sc *StatsClient) waitForSocket() error {
+       if _, err := os.Stat(sc.socket); err != nil {
+               if os.IsNotExist(err) {
+                       n := time.Now()
+                       ticker := time.NewTicker(sc.retryPeriod)
+                       timeout := time.After(sc.retryTimeout)
+                       for {
+                               select {
+                               case <-ticker.C:
+                                       if _, err := os.Stat(sc.socket); err == nil {
+                                               return nil
+                                       }
+                               case <-timeout:
+                                       return fmt.Errorf("stats socket file %s is not ready within timeout (after %.2f s) ",
+                                               sc.socket, time.Since(n).Seconds())
+                               }
+                       }
+               } else {
+                       return fmt.Errorf("stats socket error: %v", err)
+               }
+       }
        return nil
 }
 
-func (sc *StatsClient) connect() (statSegment, error) {
+// connect to the socket and map it into the memory. According to the
+// header version info, an appropriate segment handler is returned
+func (sc *StatsClient) connect() (ss statSegment, err error) {
        addr := net.UnixAddr{
                Net:  "unixpacket",
-               Name: sc.sockAddr,
+               Name: sc.socket,
        }
        Log.Debugf("connecting to: %v", addr)
 
@@ -343,13 +363,82 @@ func (sc *StatsClient) connect() (statSegment, error) {
        version := getVersion(sc.headerData)
        switch version {
        case 1:
-               return newStatSegmentV1(sc.headerData, size), nil
+               ss = newStatSegmentV1(sc.headerData, size)
        case 2:
-               return newStatSegmentV2(sc.headerData, size), nil
+               ss = newStatSegmentV2(sc.headerData, size)
        default:
                return nil, fmt.Errorf("stat segment version is not supported: %v (min: %v, max: %v)",
                        version, minVersion, maxVersion)
        }
+
+       // set connected
+       atomic.CompareAndSwapUint32(&sc.connected, 0, 1)
+
+       return ss, nil
+}
+
+// reconnect disconnects from the socket, re-validates it and
+// connects again
+func (sc *StatsClient) reconnect() (err error) {
+       if err = sc.disconnect(); err != nil {
+               return fmt.Errorf("error disconnecting socket: %v", err)
+       }
+       if err = sc.waitForSocket(); err != nil {
+               return fmt.Errorf("error while waiting on socket: %v", err)
+       }
+       if sc.statSegment, err = sc.connect(); err != nil {
+               return fmt.Errorf("error connecting socket: %v", err)
+       }
+       return nil
+}
+
+// disconnect unmaps socket data from the memory and resets the header
+func (sc *StatsClient) disconnect() error {
+       if !atomic.CompareAndSwapUint32(&sc.connected, 1, 0) {
+               return fmt.Errorf("stats client is already disconnected")
+       }
+       if sc.headerData == nil {
+               return nil
+       }
+       if err := syscall.Munmap(sc.headerData); err != nil {
+               Log.Debugf("unmapping shared memory failed: %v", err)
+               return fmt.Errorf("unmapping shared memory failed: %v", err)
+       }
+       sc.headerData = nil
+
+       Log.Debugf("successfully unmapped shared memory")
+       return nil
+}
+
+func (sc *StatsClient) monitorSocket() {
+       watcher, err := fsnotify.NewWatcher()
+       if err != nil {
+               Log.Errorf("error starting socket monitor: %v", err)
+               return
+       }
+
+       go func() {
+               for {
+                       select {
+                       case event := <-watcher.Events:
+                               if event.Op == fsnotify.Remove && event.Name == sc.socket {
+                                       if err := sc.reconnect(); err != nil {
+                                               Log.Errorf("error occurred during socket reconnect: %v", err)
+                                       }
+                               }
+                       case err := <-watcher.Errors:
+                               Log.Errorf("socket monitor delivered error event: %v", err)
+                       case <-sc.done:
+                               err := watcher.Close()
+                               Log.Debugf("socket monitor closed (error: %v)", err)
+                               return
+                       }
+               }
+       }()
+
+       if err := watcher.Add(filepath.Dir(sc.socket)); err != nil {
+               Log.Errorf("failed to add socket address to the watcher: %v", err)
+       }
 }
 
 // Starts monitoring 'inProgress' field. Returns stats segment
@@ -379,10 +468,85 @@ func (sc *StatsClient) accessEnd(accessEpoch int64) bool {
        return true
 }
 
+// getStatEntries retrieves all stats matching desired patterns, or all stats if no pattern is provided.
+func (sc *StatsClient) getStatEntries(patterns ...string) (entries []adapter.StatEntry, err error) {
+       vector := sc.GetDirectoryVector()
+       if vector == nil {
+               return nil, fmt.Errorf("failed to get stat entries: directory vector is nil")
+       }
+       indexes, err := sc.listIndexes(vector, patterns...)
+       if err != nil {
+               return nil, err
+       }
+       return sc.getStatEntriesOnIndex(vector, indexes...)
+}
+
+// getIdentifierEntries retrieves all identifiers matching desired patterns, or all identifiers
+// if no pattern is provided.
+func (sc *StatsClient) getIdentifierEntries(patterns ...string) (identifiers []adapter.StatIdentifier, err error) {
+       vector := sc.GetDirectoryVector()
+       if vector == nil {
+               return nil, fmt.Errorf("failed to get identifier entries: directory vector is nil")
+       }
+       indexes, err := sc.listIndexes(vector, patterns...)
+       if err != nil {
+               return nil, err
+       }
+       return sc.getIdentifierEntriesOnIndex(vector, indexes...)
+}
+
+// getStatEntriesOnIndex retrieves stats on indexes, or all stats if indexes are not defined.
+func (sc *StatsClient) getStatEntriesOnIndex(vector dirVector, indexes ...uint32) (entries []adapter.StatEntry, err error) {
+       dirLen := *(*uint32)(vectorLen(vector))
+       for _, index := range indexes {
+               if index >= dirLen {
+                       return nil, fmt.Errorf("stat entry index %d out of dir vector length (%d)", index, dirLen)
+               }
+               dirPtr, dirName, dirType := sc.GetStatDirOnIndex(vector, index)
+               if len(dirName) == 0 {
+                       return
+               }
+               var t adapter.StatType
+               d := sc.CopyEntryData(dirPtr, ^uint32(0))
+               if d != nil {
+                       t = d.Type()
+               }
+               entries = append(entries, adapter.StatEntry{
+                       StatIdentifier: adapter.StatIdentifier{
+                               Index: index,
+                               Name:  dirName,
+                       },
+                       Type:    t,
+                       Data:    d,
+                       Symlink: adapter.StatType(dirType) == adapter.Symlink,
+               })
+       }
+       return entries, nil
+}
+
+// getIdentifierEntriesOnIndex retrieves identifiers on indexes, or all identifiers if indexes are not defined.
+func (sc *StatsClient) getIdentifierEntriesOnIndex(vector dirVector, indexes ...uint32) (identifiers []adapter.StatIdentifier, err error) {
+       dirLen := *(*uint32)(vectorLen(vector))
+       for _, index := range indexes {
+               if index >= dirLen {
+                       return nil, fmt.Errorf("stat entry index %d out of dir vector length (%d)", index, dirLen)
+               }
+               _, dirName, _ := sc.GetStatDirOnIndex(vector, index)
+               if len(dirName) == 0 {
+                       return
+               }
+               identifiers = append(identifiers, adapter.StatIdentifier{
+                       Index: index,
+                       Name:  dirName,
+               })
+       }
+       return identifiers, nil
+}
+
 // listIndexes lists indexes for all stat entries that match any of the regex patterns.
-func (sc *StatsClient) listIndexes(patterns ...string) (indexes []uint32, err error) {
+func (sc *StatsClient) listIndexes(vector dirVector, patterns ...string) (indexes []uint32, err error) {
        if len(patterns) == 0 {
-               return sc.listIndexesFunc(nil)
+               return sc.listIndexesFunc(vector, nil)
        }
        var regexes = make([]*regexp.Regexp, len(patterns))
        for i, pattern := range patterns {
@@ -392,7 +556,7 @@ func (sc *StatsClient) listIndexes(patterns ...string) (indexes []uint32, err er
                }
                regexes[i] = r
        }
-       nameMatches := func(name []byte) bool {
+       nameMatches := func(name dirName) bool {
                for _, r := range regexes {
                        if r.Match(name) {
                                return true
@@ -400,26 +564,20 @@ func (sc *StatsClient) listIndexes(patterns ...string) (indexes []uint32, err er
                }
                return false
        }
-       return sc.listIndexesFunc(nameMatches)
+       return sc.listIndexesFunc(vector, nameMatches)
 }
 
 // listIndexesFunc lists stats indexes. The optional function
 // argument filters returned values or returns all if empty
-func (sc *StatsClient) listIndexesFunc(f func(name []byte) bool) (indexes []uint32, err error) {
+func (sc *StatsClient) listIndexesFunc(vector dirVector, f func(name dirName) bool) (indexes []uint32, err error) {
        if f == nil {
                // there is around ~3157 stats, so to avoid too many allocations
                // we set capacity to 3200 when listing all stats
                indexes = make([]uint32, 0, 3200)
        }
-
-       dirVector, err := sc.GetDirectoryVector()
-       if err != nil {
-               return nil, err
-       }
-       vecLen := *(*uint32)(vectorLen(dirVector))
-
+       vecLen := *(*uint32)(vectorLen(vector))
        for i := uint32(0); i < vecLen; i++ {
-               _, dirName, _ := sc.GetStatDirOnIndex(dirVector, i)
+               _, dirName, _ := sc.GetStatDirOnIndex(vector, i)
                if f != nil {
                        if len(dirName) == 0 || !f(dirName) {
                                continue
@@ -430,3 +588,26 @@ func (sc *StatsClient) listIndexesFunc(f func(name []byte) bool) (indexes []uint
 
        return indexes, nil
 }
+
+func (sc *StatsClient) isConnected() bool {
+       return atomic.LoadUint32(&sc.connected) == 1
+}
+
+// updateStatOnIndex refreshes the entry data.
+func (sc *StatsClient) updateStatOnIndex(entry *adapter.StatEntry, vector dirVector) (err error) {
+       dirLen := *(*uint32)(vectorLen(vector))
+       if entry.Index >= dirLen {
+               return fmt.Errorf("stat entry index %d out of dir vector length (%d)", entry.Index, dirLen)
+       }
+       dirPtr, dirName, dirType := sc.GetStatDirOnIndex(vector, entry.Index)
+       if len(dirName) == 0 ||
+               !bytes.Equal(dirName, entry.Name) ||
+               adapter.StatType(dirType) != entry.Type ||
+               entry.Data == nil {
+               return nil
+       }
+       if err := sc.UpdateEntryData(dirPtr, &entry.Data); err != nil {
+               err = fmt.Errorf("updating stat data for entry %s failed: %v", dirName, err)
+       }
+       return
+}