attempt to remove dead socket on startup

CHANGES

@@ -1,3 +1,6 @@
+1.1.1 (TBD):
+- Try to remove dead sockets on startup instead of failing immediately if the socket file exists
+
 1.1.0 (Sep 19, 2023):
 - Add support for Client/GetTreatment(s)WithConfig operations.
 - Add support for Manager operations.

cmd/splitcli/main.go

@@ -11,6 +11,7 @@ import (
 	"github.com/splitio/splitd/splitio/conf"
 	"github.com/splitio/splitd/splitio/link"
 	"github.com/splitio/splitd/splitio/link/client/types"
+	"github.com/splitio/splitd/splitio/link/transfer"
 	"github.com/splitio/splitd/splitio/util"
 )
 
@@ -38,6 +39,21 @@ func main() {
 		VerboseWriter: os.Stderr,
 	})
 
+	if args.Method == "ping" {
+		// no consumer is created (to avoid registering)
+		c, err := transfer.NewClientConn(logger, &linkOpts.Transfer)
+		if err != nil {
+			logger.Error("error connecting to socket: ", err.Error())
+			os.Exit(2)
+		}
+		if err = c.Shutdown(); err != nil {
+			logger.Error("error closing connection: ", err.Error())
+			os.Exit(2)
+		}
+		logger.Info("socket is accepting connections properly")
+		os.Exit(0)
+	}
+
 	c, err := link.Consumer(logger, linkOpts)
 	if err != nil {
 		logger.Error("error creating client wrapper: ", err)

splitio/commitsha.go

@@ -1,3 +1,3 @@
 package splitio
 
-const CommitSHA = "29ff22d"
+const CommitSHA = "1472745"

splitio/link/service/v1/clientmgr.go

@@ -56,13 +56,13 @@ func (m *ClientManager) handleClientInteractions() error {
 		rpc, err := m.fetchRPC()
 		if err != nil {
 			if errors.Is(err, io.EOF) { // connection ended, no error
-				m.logger.Debug(fmt.Sprintf("connection remotely closed for metadata=%+v", m.clientConfig.Metadata))
+				m.logger.Debug(fmt.Sprintf("connection remotely closed for metadata=%s", formatClientConfig(m.clientConfig)))
 				return nil
 			} else if errors.Is(err, os.ErrDeadlineExceeded) { // we waited for an RPC, got none, try again.
-				m.logger.Debug(fmt.Sprintf("read timeout/no RPC fetched. restarting loop for metadata=%+v", m.clientConfig))
+				m.logger.Debug(fmt.Sprintf("read timeout/no RPC fetched. restarting loop for metadata=%s", formatClientConfig(m.clientConfig)))
 				continue
 			} else {
-				m.logger.Error(fmt.Sprintf("unexpected error reading RPC: %s. Closing conn for metadata=%+v", err, m.clientConfig))
+				m.logger.Error(fmt.Sprintf("unexpected error reading RPC: %s. Closing conn for metadata=%s", err, formatClientConfig(m.clientConfig)))
 				return err
 			}
 		}
@@ -313,3 +313,11 @@ func (m *ClientManager) handleSplits(rpc *protov1.RPC) (interface{}, error) {
 
 	return response, nil
 }
+
+func formatClientConfig(c *types.ClientConfig) string {
+	if c == nil {
+		return "<nil>"
+	}
+
+	return fmt.Sprintf("%+v", c)
+}

splitio/link/transfer/setup.go

@@ -4,6 +4,8 @@ import (
 	"errors"
 	"fmt"
 	"net"
+	"os"
+	"syscall"
 	"time"
 
 	"github.com/splitio/go-toolkit/v5/logging"
@@ -29,7 +31,8 @@ const (
 )
 
 var (
-	ErrInvalidConnType = errors.New("invalid conn type")
+	ErrInvalidConnType     = errors.New("invalid conn type")
+	ErrServiceAddressInUse = errors.New("provided socket file / address is already in use")
 )
 
 func NewAcceptor(logger logging.LoggerInterface, o *Options, listenerConfig *AcceptorConfig) (*Acceptor, error) {
@@ -46,6 +49,10 @@ func NewAcceptor(logger logging.LoggerInterface, o *Options, listenerConfig *Acc
 		return nil, ErrInvalidConnType
 	}
 
+	if err := ensureAddressUsable(logger, address); err != nil {
+		return nil, err
+	}
+
 	cf := func(c net.Conn) RawConn { return newConnWrapper(c, ff, o) }
 	return newAcceptor(address, cf, logger, listenerConfig), nil
 }
@@ -93,3 +100,35 @@ func DefaultOpts() Options {
 // helpers
 
 func lpFramerFromConn(c net.Conn) framing.Interface { return framing.NewLengthPrefix(c) }
+
+func ensureAddressUsable(logger logging.LoggerInterface, address net.Addr) error {
+	switch address.Network() {
+	case "unix", "unixpacket":
+		if _, err := os.Stat(address.String()); errors.Is(err, os.ErrNotExist) {
+			return nil // file doesn't exist, we're ok
+		}
+
+		logger.Warning("The socket file exists. Testing if it's currently accepting connections")
+		c, err := net.Dial(address.Network(), address.String())
+		if err == nil {
+			c.Close()
+			return ErrServiceAddressInUse
+		}
+
+		logger.Warning("The socket appears to be from a previous (dead) execution. Will try to remove it")
+
+		if !errors.Is(err, syscall.ECONNREFUSED) {
+			return fmt.Errorf("unknown error when testing for a dead socket: %w", err)
+		}
+
+		// the socket seems to be bound to a dead process, will try removing it
+		// so that a listener can be created
+		if err := os.Remove(address.String()); err != nil {
+			return fmt.Errorf("error removing dead-socket file from a previous execution: %w", err)
+		}
+
+		logger.Warning("Dead socket file removed successfuly")
+
+	}
+	return nil
+}

splitio/link/transfer/setup_test.go

@@ -1,12 +1,64 @@
 package transfer
 
 import (
-	"github.com/stretchr/testify/assert"
+	"net"
+	"os"
+	"path/filepath"
 	"testing"
+	"time"
+
+	"github.com/splitio/go-toolkit/v5/logging"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestConnType(t *testing.T) {
 	assert.Equal(t, "unix-seqpacket", ConnTypeUnixSeqPacket.String())
 	assert.Equal(t, "unix-stream", ConnTypeUnixStream.String())
 	assert.Equal(t, "invalid-socket-type", ConnType(123).String())
 }
+
+func TestEnsureAddressIsUsable(t *testing.T) {
+
+	logger := logging.NewLogger(nil)
+	assert.Nil(t, ensureAddressUsable(logger, &net.UDPAddr{}))
+	assert.Nil(t, ensureAddressUsable(logger, &net.TCPAddr{}))
+	assert.Nil(t, ensureAddressUsable(logger, &net.UnixAddr{Name: "/some/nonexistent/file"}))
+
+	// test unknown error (in this case trying to connect to a different socket type)
+	ready := make(chan struct{})
+	path := filepath.Join(os.TempDir(), "splitd_test_ensure_address_usable.sock")
+	os.Remove(path) // por las dudas
+	go func() {
+		l, err := net.ListenUnix("unix", &net.UnixAddr{Name: path, Net: "unix"})
+		assert.Nil(t, err)
+		defer l.Close()
+
+		l.SetDeadline(time.Now().Add(1 * time.Second))
+		go func() {
+			time.Sleep(100 * time.Millisecond)
+			ready <- struct{}{}
+		}()
+		l.Accept()
+	}()
+	<-ready
+	assert.ErrorContains(t, ensureAddressUsable(logger, &net.UnixAddr{Name: path, Net: "unixpacket"}), "unknown error when testing for a dead socket")
+
+	// test socket in use error
+	ready = make(chan struct{})
+	path = filepath.Join(os.TempDir(), "splitd_test_ensure_address_usable2.sock")
+	os.Remove(path) // por las dudas
+	go func() {
+		l, err := net.ListenUnix("unix", &net.UnixAddr{Name: path, Net: "unix"})
+		assert.Nil(t, err)
+		defer l.Close()
+
+		l.SetDeadline(time.Now().Add(1 * time.Second))
+		go func() {
+			time.Sleep(100 * time.Millisecond)
+			ready <- struct{}{}
+		}()
+		l.Accept()
+	}()
+	<-ready
+	assert.ErrorIs(t, ErrServiceAddressInUse, ensureAddressUsable(logger, &net.UnixAddr{Name: path, Net: "unix"}))
+}

splitio/version.go

@@ -1,3 +1,3 @@
 package splitio
 
-const Version = "1.1.0"
+const Version = "1.1.1"