Split ServerRoleSingleResilient in Active/Passive

Author: ewoutp

client_cluster_impl.go

@@ -34,7 +34,7 @@ func (c *client) Cluster(ctx context.Context) (Cluster, error) {
 	if err != nil {
 		return nil, WithStack(err)
 	}
-	if role == ServerRoleSingle || role == ServerRoleSingleResilient {
+	if role == ServerRoleSingle || role == ServerRoleSingleActive || role == ServerRoleSinglePassive {
 		// Standalone server, this is wrong
 		return nil, WithStack(newArangoError(412, 0, "Cluster expected, found SINGLE server"))
 	}

client_server_info.go

@@ -42,8 +42,10 @@ type ServerRole string
 const (
 	// ServerRoleSingle indicates that the server is a single-server instance
 	ServerRoleSingle ServerRole = "Single"
-	// ServerRoleSingleResilient indicates that the server is a single-server instance of a resilient pair
-	ServerRoleSingleResilient ServerRole = "SingleResilient"
+	// ServerRoleSingleActive indicates that the server is a the leader of a single-server resilient pair
+	ServerRoleSingleActive ServerRole = "SingleActive"
+	// ServerRoleSinglePassive indicates that the server is a a follower of a single-server resilient pair
+	ServerRoleSinglePassive ServerRole = "SinglePassive"
 	// ServerRoleDBServer indicates that the server is a dbserver within a cluster
 	ServerRoleDBServer ServerRole = "DBServer"
 	// ServerRoleCoordinator indicates that the server is a coordinator within a cluster

client_server_info_impl.go

@@ -54,26 +54,31 @@ type roleResponse struct {
 	Mode string `json:"mode,omitempty"`
 }
 
-// AsServerRole converts the response into a ServerRole
-func (r roleResponse) AsServerRole() ServerRole {
+// asServerRole converts the response into a ServerRole
+func (r roleResponse) asServerRole(ctx context.Context, c *client) (ServerRole, error) {
 	switch r.Role {
 	case "SINGLE":
 		switch r.Mode {
 		case "resilient":
-			return ServerRoleSingleResilient
+			if err := c.echo(ctx); IsNoLeader(err) {
+				return ServerRoleSinglePassive, nil
+			} else if err != nil {
+				return ServerRoleUndefined, WithStack(err)
+			}
+			return ServerRoleSingleActive, nil
 		default:
-			return ServerRoleSingle
+			return ServerRoleSingle, nil
 		}
 	case "PRIMARY":
-		return ServerRoleDBServer
+		return ServerRoleDBServer, nil
 	case "COORDINATOR":
-		return ServerRoleCoordinator
+		return ServerRoleCoordinator, nil
 	case "AGENT":
-		return ServerRoleAgent
+		return ServerRoleAgent, nil
 	case "UNDEFINED":
-		return ServerRoleUndefined
+		return ServerRoleUndefined, nil
 	default:
-		return ServerRoleUndefined
+		return ServerRoleUndefined, nil
 	}
 }
 
@@ -95,5 +100,26 @@ func (c *client) ServerRole(ctx context.Context) (ServerRole, error) {
 	if err := resp.ParseBody("", &data); err != nil {
 		return ServerRoleUndefined, WithStack(err)
 	}
-	return data.AsServerRole(), nil
+	role, err := data.asServerRole(ctx, c)
+	if err != nil {
+		return ServerRoleUndefined, WithStack(err)
+	}
+	return role, nil
+}
+
+// clusterEndpoints returns the endpoints of a cluster.
+func (c *client) echo(ctx context.Context) error {
+	req, err := c.conn.NewRequest("GET", "_admin/echo")
+	if err != nil {
+		return WithStack(err)
+	}
+	applyContextSettings(ctx, req)
+	resp, err := c.conn.Do(ctx, req)
+	if err != nil {
+		return WithStack(err)
+	}
+	if err := resp.CheckStatus(200); err != nil {
+		return WithStack(err)
+	}
+	return nil
 }

cluster/cluster.go

@@ -35,6 +35,10 @@ import (
 	driver "github.com/arangodb/go-driver"
 )
 
+const (
+	keyFollowLeaderRedirect driver.ContextKey = "arangodb-followLeaderRedirect"
+)
+
 // ConnectionConfig provides all configuration options for a cluster connection.
 type ConnectionConfig struct {
 	// DefaultTimeout is the timeout used by requests that have no timeout set in the given context.
@@ -102,8 +106,15 @@ func (c *clusterConnection) NewRequest(method, path string) (driver.Request, err
 
 // Do performs a given request, returning its response.
 func (c *clusterConnection) Do(ctx context.Context, req driver.Request) (driver.Response, error) {
+	followLeaderRedirect := true
 	if ctx == nil {
 		ctx = context.Background()
+	} else {
+		if v := ctx.Value(keyFollowLeaderRedirect); v != nil {
+			if on, ok := v.(bool); ok {
+				followLeaderRedirect = on
+			}
+		}
 	}
 	// Timeout management.
 	// We take the given timeout and divide it in 3 so we allow for other servers
@@ -156,7 +167,7 @@ func (c *clusterConnection) Do(ctx context.Context, req driver.Request) (driver.
 			}
 
 		}
-		if !isNoLeaderResponse {
+		if !isNoLeaderResponse || !followLeaderRedirect {
 			if err == nil {
 				// We're done
 				return resp, nil

context.go

@@ -53,6 +53,7 @@ const (
 	keyIgnoreRevs               ContextKey = "arangodb-ignoreRevs"
 	keyEnforceReplicationFactor ContextKey = "arangodb-enforceReplicationFactor"
 	keyConfigured               ContextKey = "arangodb-configured"
+	keyFollowLeaderRedirect     ContextKey = "arangodb-followLeaderRedirect"
 )
 
 // WithRevision is used to configure a context to make document
@@ -192,6 +193,13 @@ func WithConfigured(parent context.Context, value ...bool) context.Context {
 	return context.WithValue(contextOrBackground(parent), keyConfigured, v)
 }
 
+// WithFollowLeaderRedirect is used to configure a context to return turn on/off
+// following redirection responses from the server when the request is answered by a follower.
+// Default behavior is "on".
+func WithFollowLeaderRedirect(parent context.Context, value bool) context.Context {
+	return context.WithValue(contextOrBackground(parent), keyFollowLeaderRedirect, value)
+}
+
 type contextSettings struct {
 	Silent                   bool
 	WaitForSync              bool
@@ -205,6 +213,7 @@ type contextSettings struct {
 	IgnoreRevs               *bool
 	EnforceReplicationFactor *bool
 	Configured               *bool
+	FollowLeaderRedirect     *bool
 }
 
 // applyContextSettings returns the settings configured in the context in the given request.
@@ -312,6 +321,12 @@ func applyContextSettings(ctx context.Context, req Request) contextSettings {
 			result.Configured = &configured
 		}
 	}
+	// FollowLeaderRedirect
+	if v := ctx.Value(keyFollowLeaderRedirect); v != nil {
+		if followLeaderRedirect, ok := v.(bool); ok {
+			result.FollowLeaderRedirect = &followLeaderRedirect
+		}
+	}
 	return result
 }