UDS support

Support for connecting to neo4j server via Unix domain socket.

Author: Peter Wilhelmsson

neo4j/directrouter.go

@@ -21,15 +21,15 @@ package neo4j
 
 // A router implementation that never routes
 type directRouter struct {
-	server string
+	address string
 }
 
 func (r *directRouter) Readers(database string) ([]string, error) {
-	return []string{r.server}, nil
+	return []string{r.address}, nil
 }
 
 func (r *directRouter) Writers(database string) ([]string, error) {
-	return []string{r.server}, nil
+	return []string{r.address}, nil
 }
 
 func (r *directRouter) Invalidate(database string) {

neo4j/driver.go

@@ -82,17 +82,27 @@ func NewDriver(target string, auth AuthToken, configurers ...func(*Config)) (Dri
 	if err != nil {
 		return nil, err
 	}
-	if parsed.Port() == "" {
-		parsed.Host = parsed.Host + ":7687"
-	}
 
 	d := driver{target: parsed}
 
 	routing := true
+	d.connector.Network = "tcp"
+	address := parsed.Host
 	switch parsed.Scheme {
 	case "bolt":
 		routing = false
 		d.connector.SkipEncryption = true
+	case "bolt+unix":
+		// bolt+unix://<path to socket>
+		routing = false
+		d.connector.SkipEncryption = true
+		d.connector.Network = "unix"
+		if parsed.Host != "" {
+			return nil, &UsageError{
+				Message: fmt.Sprintf("Host part should be empty for scheme %s", parsed.Scheme),
+			}
+		}
+		address = parsed.Path
 	case "bolt+s":
 		routing = false
 	case "bolt+ssc":
@@ -105,10 +115,15 @@ func NewDriver(target string, auth AuthToken, configurers ...func(*Config)) (Dri
 	case "neo4j+s":
 	default:
 		return nil, &UsageError{
-			Message: fmt.Sprintf("URL scheme %s is not supported", parsed.Scheme),
+			Message: fmt.Sprintf("URI scheme %s is not supported", parsed.Scheme),
 		}
 	}
 
+	if parsed.Host != "" && parsed.Port() == "" {
+		address += ":7687"
+		parsed.Host = address
+	}
+
 	if !routing && len(parsed.RawQuery) > 0 {
 		return nil, &UsageError{
 			Message: fmt.Sprintf("Routing context is not supported for URL scheme %s", parsed.Scheme),
@@ -150,7 +165,7 @@ func NewDriver(target string, auth AuthToken, configurers ...func(*Config)) (Dri
 	d.pool = pool.New(d.config.MaxConnectionPoolSize, d.config.MaxConnectionLifetime, d.connector.Connect, d.log, d.logId)
 
 	if !routing {
-		d.router = &directRouter{server: parsed.Host}
+		d.router = &directRouter{address: address}
 	} else {
 		var routersResolver func() []string
 		addressResolverHook := d.config.AddressResolver
@@ -165,10 +180,10 @@ func NewDriver(target string, auth AuthToken, configurers ...func(*Config)) (Dri
 			}
 		}
 		// Let the router use the same logid as the driver to simplify log reading.
-		d.router = router.New(parsed.Host, routersResolver, routingContext, d.pool, d.log, d.logId)
+		d.router = router.New(address, routersResolver, routingContext, d.pool, d.log, d.logId)
 	}
 
-	d.log.Infof(log.Driver, d.logId, "Created { target: %s }", target)
+	d.log.Infof(log.Driver, d.logId, "Created { target: %s }", address)
 	return &d, nil
 }
 

neo4j/driver_test.go

@@ -34,6 +34,13 @@ func assertNoRouter(t *testing.T, d Driver) {
 		t.Error("Expected no router")
 	}
 }
+func assertNoRouterAddress(t *testing.T, d Driver, address string) {
+	t.Helper()
+	direct := d.(*driver).router.(*directRouter)
+	if direct.address != address {
+		t.Errorf("Address mismatch %s vs %s", address, direct.address)
+	}
+}
 
 func assertRouter(t *testing.T, d Driver) {
 	t.Helper()
@@ -52,46 +59,80 @@ func assertRouterContext(t *testing.T, d Driver, context map[string]string) {
 	}
 }
 
-var uriSchemeTests = []struct {
-	name    string
-	scheme  string
-	testing string
-	router  bool
-}{
-	{"bolt://", "bolt", "bolt://localhost:7687", false},
-	{"bolt+s://", "bolt", "bolt://localhost:7687", false},
-	{"bolt+ssc://", "bolt", "bolt://localhost:7687", false},
-	{"neo4j://", "neo4j", "neo4j://localhost:7687", true},
-	{"neo4j+s://", "neo4j", "neo4j://localhost:7687", true},
-	{"neo4j+ssc://", "neo4j", "neo4j://localhost:7687", true},
+func assertSkipEncryption(t *testing.T, d Driver, skipEncryption bool) {
+	t.Helper()
+	c := d.(*driver).connector
+	if c.SkipEncryption != skipEncryption {
+		t.Errorf("SkipEncryption mismatch, %t vs %t", skipEncryption, c.SkipEncryption)
+	}
+}
+
+func assertSkipVerify(t *testing.T, d Driver, skipVerify bool) {
+	t.Helper()
+	c := d.(*driver).connector
+	if c.SkipVerify != skipVerify {
+		t.Errorf("SkipVerify mismatch, %t vs %t", skipVerify, c.SkipVerify)
+	}
 }
 
-func TestDriverURISchemesX(t *testing.T) {
+func assertNetwork(t *testing.T, d Driver, network string) {
+	t.Helper()
+	c := d.(*driver).connector
+	if c.Network != network {
+		t.Errorf("Network mismatch, %s vs %s", network, c.Network)
+	}
+}
+
+func TestDriverURISchemes(t *testing.T) {
+	uriSchemeTests := []struct {
+		scheme         string
+		testing        string
+		router         bool
+		skipEncryption bool
+		skipVerify     bool
+		network        string
+		address        string
+	}{
+		{"bolt", "bolt://localhost:7687", false, true, false, "tcp", "localhost:7687"},
+		{"bolt+s", "bolt+s://localhost:7687", false, false, false, "tcp", "localhost:7687"},
+		{"bolt+ssc", "bolt+ssc://localhost:7687", false, false, true, "tcp", "localhost:7687"},
+		{"bolt+unix", "bolt+unix:///tmp/a.socket", false, true, false, "unix", "/tmp/a.socket"},
+		{"neo4j", "neo4j://localhost:7687", true, true, false, "tcp", ""},
+		{"neo4j+s", "neo4j+s://localhost:7687", true, false, false, "tcp", ""},
+		{"neo4j+ssc", "neo4j+ssc://localhost:7687", true, false, true, "tcp", ""},
+	}
+
 	for _, tt := range uriSchemeTests {
-		t.Run(tt.name, func(t *testing.T) {
+		t.Run(tt.scheme, func(t *testing.T) {
 			driver, err := NewDriver(tt.testing, NoAuth())
 
 			AssertNoError(t, err)
 			AssertStringEqual(t, driver.Target().Scheme, tt.scheme)
 			if !tt.router {
 				assertNoRouter(t, driver)
+				assertNoRouterAddress(t, driver, tt.address)
 			} else {
 				assertRouter(t, driver)
 			}
+			assertSkipEncryption(t, driver, tt.skipEncryption)
+			if !tt.skipEncryption {
+				assertSkipVerify(t, driver, tt.skipVerify)
+			}
+			assertNetwork(t, driver, tt.network)
 		})
 	}
 }
 
-var invalidURISchemeTests = []struct {
-	name    string
-	scheme  string
-	testing string
-}{
-	{"bolt+routing://", "bolt+routing", "bolt+routing://localhost:7687"},
-	{"invalid://", "invalid", "invalid://localhost:7687"},
-}
+func TestDriverInvalidURISchemes(t *testing.T) {
+	invalidURISchemeTests := []struct {
+		name    string
+		scheme  string
+		testing string
+	}{
+		{"bolt+routing://", "bolt+routing", "bolt+routing://localhost:7687"},
+		{"invalid://", "invalid", "invalid://localhost:7687"},
+	}
 
-func TestDriverInvalidURISchemesX(t *testing.T) {
 	for _, tt := range invalidURISchemeTests {
 		t.Run(tt.name, func(t *testing.T) {
 			_, err := NewDriver(tt.testing, NoAuth())
@@ -127,7 +168,6 @@ func TestDriverURIRoutingContext(t *testing.T) {
 }
 
 func TestDriverDefaultPort(t *testing.T) {
-
 	t.Run("neo4j://localhost should default to port 7687", func(t1 *testing.T) {
 		driver, err := NewDriver("neo4j://localhost", NoAuth())
 		driverTarget := driver.Target()
@@ -139,7 +179,6 @@ func TestDriverDefaultPort(t *testing.T) {
 }
 
 func TestNewDriverAndClose(t *testing.T) {
-
 	driver, err := NewDriver("bolt://localhost:7687", NoAuth())
 	AssertNoError(t, err)
 
@@ -172,19 +211,19 @@ func TestNewDriverAndClose(t *testing.T) {
 	}
 }
 
-var driverSessionCreationTests = []struct {
-	name      string
-	testing   string
-	mode      AccessMode
-	bookmarks []string
-}{
-	{"case one", "bolt://localhost:7687", AccessModeWrite, []string(nil)},
-	{"case two", "bolt://localhost:7687", AccessModeRead, []string(nil)},
-	{"case three", "bolt://localhost:7687", AccessModeWrite, []string{"B1", "B2", "B3"}},
-	{"case four", "bolt://localhost:7687", AccessModeRead, []string{"B1", "B2", "B3", "B4"}},
-}
+func TestDriverSessionCreation(t *testing.T) {
+	driverSessionCreationTests := []struct {
+		name      string
+		testing   string
+		mode      AccessMode
+		bookmarks []string
+	}{
+		{"Write", "bolt://localhost:7687", AccessModeWrite, []string(nil)},
+		{"Read", "bolt://localhost:7687", AccessModeRead, []string(nil)},
+		{"Write+bookmarks", "bolt://localhost:7687", AccessModeWrite, []string{"B1", "B2", "B3"}},
+		{"Read+bookmarks", "bolt://localhost:7687", AccessModeRead, []string{"B1", "B2", "B3", "B4"}},
+	}
 
-func TestDriverSessionCreationX(t *testing.T) {
 	for _, tt := range driverSessionCreationTests {
 		t.Run(tt.name, func(t *testing.T) {
 			driver, err := NewDriver(tt.testing, NoAuth())

neo4j/internal/connector/connector.go

@@ -43,6 +43,7 @@ type Connector struct {
 	Log             log.Logger
 	UserAgent       string
 	RoutingContext  map[string]string
+	Network         string
 }
 
 type ConnectError struct {
@@ -67,7 +68,7 @@ func (c Connector) Connect(address string) (db.Connection, error) {
 		dialer.KeepAlive = -1 * time.Second // Turns keep-alive off
 	}
 
-	conn, err := dialer.Dial("tcp", address)
+	conn, err := dialer.Dial(c.Network, address)
 	if err != nil {
 		return nil, &ConnectError{inner: err}
 	}