X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=adapter%2Fstatsclient%2Fstatsclient.go;h=18c1266e5cf91f1312f539cc8e04aa2c8a9be834;hb=refs%2Fchanges%2F73%2F36773%2F2;hp=a39cbd5595cdfdc4af76b562666dfe8c7e1da454;hpb=e517439567ad843033257664fdfe90a9173b0aa6;p=govpp.git

diff --git a/adapter/statsclient/statsclient.go b/adapter/statsclient/statsclient.go
index a39cbd5..18c1266 100644
--- a/adapter/statsclient/statsclient.go
+++ b/adapter/statsclient/statsclient.go
@@ -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 {
-     socket-name /run/vpp/stats.sock
-   }
-------------------------------------------------------------
-`
+	// 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 := sc.GetDirectoryVector()
-	if dirVector == 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 := sc.GetDirectoryVector()
-	if dirVector == 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 := sc.GetDirectoryVector()
-	if dirVector == 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 := 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: 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 := sc.GetDirectoryVector()
-	if dirVector == 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) ||
+		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
+}