log = logger.WithField("logger", "govpp/socketclient")
}
-const socketMissing = `
-------------------------------------------------------------
- No socket file found at: %s
- VPP binary API socket file is missing!
-
- - is VPP running with socket for binapi enabled?
- - is the correct socket name configured?
-
- To enable it add following section to your VPP config:
- socksvr {
- socket-name /run/vpp/api.sock
- }
-------------------------------------------------------------
-`
-
-var warnOnce sync.Once
-
-func (c *socketClient) printMissingSocketMsg() {
- fmt.Fprintf(os.Stderr, socketMissing, c.sockAddr)
-}
-
-type socketClient struct {
- sockAddr string
+type Client struct {
+ socketPath string
clientName string
conn *net.UnixConn
wg sync.WaitGroup
}
-func NewVppClient(sockAddr string) *socketClient {
- if sockAddr == "" {
- sockAddr = DefaultSocketName
+// NewVppClient returns a new Client using socket.
+// If socket is empty string DefaultSocketName is used.
+func NewVppClient(socket string) *Client {
+ if socket == "" {
+ socket = DefaultSocketName
}
- return &socketClient{
- sockAddr: sockAddr,
+ return &Client{
+ socketPath: socket,
clientName: DefaultClientName,
connectTimeout: DefaultConnectTimeout,
disconnectTimeout: DefaultDisconnectTimeout,
}
// SetClientName sets a client name used for identification.
-func (c *socketClient) SetClientName(name string) {
+func (c *Client) SetClientName(name string) {
c.clientName = name
}
// SetConnectTimeout sets timeout used during connecting.
-func (c *socketClient) SetConnectTimeout(t time.Duration) {
+func (c *Client) SetConnectTimeout(t time.Duration) {
c.connectTimeout = t
}
// SetDisconnectTimeout sets timeout used during disconnecting.
-func (c *socketClient) SetDisconnectTimeout(t time.Duration) {
+func (c *Client) SetDisconnectTimeout(t time.Duration) {
c.disconnectTimeout = t
}
-func (c *socketClient) SetMsgCallback(cb adapter.MsgCallback) {
+func (c *Client) SetMsgCallback(cb adapter.MsgCallback) {
log.Debug("SetMsgCallback")
c.msgCallback = cb
}
-const legacySocketName = "/run/vpp-api.sock"
-
-func (c *socketClient) checkLegacySocket() bool {
- if c.sockAddr == legacySocketName {
- return false
- }
- log.Debugf("checking legacy socket: %s", legacySocketName)
- // check if socket exists
- if _, err := os.Stat(c.sockAddr); err == nil {
- return false // socket exists
- } else if !os.IsNotExist(err) {
- return false // some other error occurred
- }
- // check if legacy socket exists
- if _, err := os.Stat(legacySocketName); err == nil {
- // legacy socket exists, update sockAddr
- c.sockAddr = legacySocketName
- return true
- }
- // no socket socket found
- return false
-}
-
// WaitReady checks socket file existence and waits for it if necessary
-func (c *socketClient) WaitReady() error {
+func (c *Client) WaitReady() error {
// check if socket already exists
- if _, err := os.Stat(c.sockAddr); err == nil {
+ if _, err := os.Stat(c.socketPath); err == nil {
return nil // socket exists, we are ready
} else if !os.IsNotExist(err) {
return err // some other error occurred
}
- if c.checkLegacySocket() {
- return nil
- }
-
// socket does not exist, watch for it
watcher, err := fsnotify.NewWatcher()
if err != nil {
}()
// start directory watcher
- if err := watcher.Add(filepath.Dir(c.sockAddr)); err != nil {
+ if err := watcher.Add(filepath.Dir(c.socketPath)); err != nil {
return err
}
for {
select {
case <-timeout.C:
- if c.checkLegacySocket() {
- return nil
- }
- return fmt.Errorf("timeout waiting (%s) for socket file: %s", MaxWaitReady, c.sockAddr)
+ return fmt.Errorf("timeout waiting (%s) for socket file: %s", MaxWaitReady, c.socketPath)
case e := <-watcher.Errors:
return e
case ev := <-watcher.Events:
log.Debugf("watcher event: %+v", ev)
- if ev.Name == c.sockAddr && (ev.Op&fsnotify.Create) == fsnotify.Create {
+ if ev.Name == c.socketPath && (ev.Op&fsnotify.Create) == fsnotify.Create {
// socket created, we are ready
return nil
}
}
}
-func (c *socketClient) Connect() error {
- c.checkLegacySocket()
-
+func (c *Client) Connect() error {
// check if socket exists
- if _, err := os.Stat(c.sockAddr); os.IsNotExist(err) {
- warnOnce.Do(c.printMissingSocketMsg)
- return fmt.Errorf("VPP API socket file %s does not exist", c.sockAddr)
+ if _, err := os.Stat(c.socketPath); os.IsNotExist(err) {
+ return fmt.Errorf("VPP API socket file %s does not exist", c.socketPath)
} else if err != nil {
return fmt.Errorf("VPP API socket error: %v", err)
}
- if err := c.connect(c.sockAddr); err != nil {
+ if err := c.connect(c.socketPath); err != nil {
return err
}
return nil
}
-func (c *socketClient) Disconnect() error {
+func (c *Client) Disconnect() error {
if c.conn == nil {
return nil
}
// Don't bother sending a vl_api_sockclnt_delete_t message,
// just close the socket.
-
if err := c.disconnect(); err != nil {
return err
}
const defaultBufferSize = 4096
-func (c *socketClient) connect(sockAddr string) error {
+func (c *Client) connect(sockAddr string) error {
addr := &net.UnixAddr{Name: sockAddr, Net: "unix"}
- log.Debugf("Connecting to: %v", c.sockAddr)
+ log.Debugf("Connecting to: %v", c.socketPath)
conn, err := net.DialUnix("unix", nil, addr)
if err != nil {
return nil
}
-func (c *socketClient) disconnect() error {
+func (c *Client) disconnect() error {
log.Debugf("Closing socket")
if err := c.conn.Close(); err != nil {
log.Debugln("Closing socket failed:", err)
deleteMsgContext = byte(124)
)
-func (c *socketClient) open() error {
+func (c *Client) open() error {
var msgCodec = codec.DefaultCodec
// Request socket client create
return nil
}
-func (c *socketClient) GetMsgID(msgName string, msgCrc string) (uint16, error) {
+func (c *Client) GetMsgID(msgName string, msgCrc string) (uint16, error) {
if msgID, ok := c.msgTable[msgName+"_"+msgCrc]; ok {
return msgID, nil
}
}
}
-func (c *socketClient) SendMsg(context uint32, data []byte) error {
+func (c *Client) SendMsg(context uint32, data []byte) error {
if len(data) < 10 {
return fmt.Errorf("invalid message data, length must be at least 10 bytes")
}
binary.BigEndian.PutUint32(data[6:10], context)
}
-func (c *socketClient) writeMsg(msg []byte) error {
+func (c *Client) writeMsg(msg []byte) error {
// we lock to prevent mixing multiple message writes
c.writeMu.Lock()
defer c.writeMu.Unlock()
return nil
}
-func (c *socketClient) readerLoop() {
+func (c *Client) readerLoop() {
defer c.wg.Done()
defer log.Debugf("reader loop done")
return
}
-func (c *socketClient) readMsgTimeout(buf []byte, timeout time.Duration) ([]byte, error) {
+func (c *Client) readMsgTimeout(buf []byte, timeout time.Duration) ([]byte, error) {
// set read deadline
readDeadline := time.Now().Add(timeout)
if err := c.conn.SetReadDeadline(readDeadline); err != nil {
return msgReply, nil
}
-func (c *socketClient) readMsg(buf []byte) ([]byte, error) {
+func (c *Client) readMsg(buf []byte) ([]byte, error) {
log.Debug("reading msg..")
header := c.headerPool.Get().([]byte)
"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
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,
}
}
if sc.isConnected {
return fmt.Errorf("already connected")
}
- if err := sc.validate(); err != nil {
+ if err := sc.checkSocketValid(); err != nil {
return err
}
sc.done = make(chan struct{})
- sc.monitorSocket()
if sc.statSegment, err = sc.connect(); err != nil {
return err
}
+ sc.monitorSocket()
+ sc.isConnected = true
return nil
}
// Disconnect from the socket, unmap shared memory and terminate
// socket monitor
func (sc *StatsClient) Disconnect() error {
+ if !sc.isConnected {
+ return nil // not connected
+ }
+ sc.isConnected = false
close(sc.done)
return sc.disconnect()
}
return nil
}
-// validate file presence by retrieving its file info
-func (sc *StatsClient) validate() error {
- 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)
+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)
}
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)
return nil, fmt.Errorf("stat segment version is not supported: %v (min: %v, max: %v)",
version, minVersion, maxVersion)
}
- sc.isConnected = true
+
return ss, nil
}
if err = sc.disconnect(); err != nil {
return fmt.Errorf("error disconnecting socket: %v", err)
}
- if err = sc.validate(); err != nil {
+ if err = sc.checkSocketValid(); err != nil {
return fmt.Errorf("error validating socket: %v", err)
}
if sc.statSegment, err = sc.connect(); err != nil {
// disconnect unmaps socket data from the memory and resets the header
func (sc *StatsClient) disconnect() error {
- sc.isConnected = false
if sc.headerData == nil {
return nil
}
Log.Errorf("error occurred during socket reconnect: %v", err)
}
// path must be re-added to the watcher
- if err = watcher.Add(sc.sockAddr); err != nil {
+ if err = watcher.Add(sc.socketPath); err != nil {
Log.Errorf("failed to add socket address to the watcher: %v", err)
}
}
}
}()
- if err := watcher.Add(sc.sockAddr); err != nil {
+ if err := watcher.Add(sc.socketPath); err != nil {
Log.Errorf("failed to add socket address to the watcher: %v", err)
}
}
Code Review / govpp.git / commitdiff