"syscall"
"time"
- "git.fd.io/govpp.git/adapter"
+ "github.com/fsnotify/fsnotify"
"github.com/ftrvxmtrx/fd"
logger "github.com/sirupsen/logrus"
+
+ "git.fd.io/govpp.git/adapter"
)
const (
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?
-
- To enable it add following section to your VPP config:
- statseg {
- socket-name /run/vpp/stats.sock
- }
-------------------------------------------------------------
-`
-
var (
// Debug is global variable that determines debug mode
Debug = os.Getenv("DEBUG_GOVPP_STATS") != ""
// StatsClient is the pure Go implementation for VPP stats API.
type StatsClient struct {
- sockAddr string
+ socketPath string
+
headerData []byte
isConnected bool
+ // to quit socket monitor
+ done chan struct{}
+
statSegment
}
-// NewStatsClient returns new VPP stats API client.
-func NewStatsClient(sockAddr string) *StatsClient {
- if sockAddr == "" {
- sockAddr = DefaultSocketName
+// NewStatsClient returns a new StatsClient using socket.
+// If socket is empty string DefaultSocketName is used.
+func NewStatsClient(socket string) *StatsClient {
+ if socket == "" {
+ socket = DefaultSocketName
}
return &StatsClient{
- sockAddr: sockAddr,
+ socketPath: socket,
}
}
-// Connect to the VPP stats socket
+
+// Connect to validated VPP stats socket and start monitoring
+// socket file changes
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)
- }
if sc.isConnected {
return fmt.Errorf("already connected")
}
+ if err := sc.checkSocketValid(); err != nil {
+ return err
+ }
+ sc.done = make(chan struct{})
if sc.statSegment, err = sc.connect(); err != nil {
return err
}
+ sc.monitorSocket()
sc.isConnected = true
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
- }
- 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)
+ if !sc.isConnected {
+ return nil // not connected
}
- sc.headerData = nil
-
- Log.Debugf("successfully unmapped shared memory")
- return nil
+ sc.isConnected = false
+ close(sc.done)
+ return sc.disconnect()
}
func (sc *StatsClient) ListStats(patterns ...string) ([]string, error) {
return nil
}
-func (sc *StatsClient) connect() (statSegment, error) {
+func (sc *StatsClient) checkSocketValid() error {
+ if _, err := os.Stat(sc.socketPath); os.IsNotExist(err) {
+ return fmt.Errorf("stats socket file %s does not exist", sc.socketPath)
+ } else if err != nil {
+ return fmt.Errorf("stats socket error: %v", err)
+ }
+ return nil
+}
+
+// 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.socketPath,
}
Log.Debugf("connecting to: %v", addr)
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)
}
+
+ 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.checkSocketValid(); err != nil {
+ return fmt.Errorf("error validating 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 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 {
+ if err := sc.reconnect(); err != nil {
+ Log.Errorf("error occurred during socket reconnect: %v", err)
+ }
+ // path must be re-added to the watcher
+ if err = watcher.Add(sc.socketPath); err != nil {
+ Log.Errorf("failed to add socket address to the watcher: %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(sc.socketPath); err != nil {
+ Log.Errorf("failed to add socket address to the watcher: %v", err)
+ }
}
// Starts monitoring 'inProgress' field. Returns stats segment
Code Review / govpp.git / blobdiff