Adding support for resilient single server mode

ewoutp · ewoutp · commit 8f454d44cf3a · 2017-10-12T09:05:43.000+02:00
diff --git a/Makefile b/Makefile
@@ -19,7 +19,7 @@ REPODIR := $(ORGDIR)/$(REPONAME)
 REPOPATH := $(ORGPATH)/$(REPONAME)
 
 GOPATH := $(GOBUILDDIR)
-GOVERSION := 1.9.0-alpine
+GOVERSION := 1.9.1-alpine
 
 ifndef GOOS
 	GOOS := linux
diff --git a/main.go b/main.go
@@ -79,6 +79,7 @@ var (
 	startAgent               []bool
 	startDBserver            []bool
 	startCoordinator         []bool
+	startResilientSingle     []bool
 	startLocalSlaves         bool
 	mode                     string
 	dataDir                  string
@@ -121,7 +122,7 @@ func init() {
 	f.BoolVar(&showVersion, "version", false, "If set, show version and exit")
 
 	f.StringSliceVar(&masterAddresses, "starter.join", nil, "join a cluster with master at given address")
-	f.StringVar(&mode, "starter.mode", "cluster", "Set the mode of operation to use (cluster|single)")
+	f.StringVar(&mode, "starter.mode", "cluster", "Set the mode of operation to use (cluster|single|resilientsingle)")
 	f.BoolVar(&startLocalSlaves, "starter.local", false, "If set, local slaves will be started to create a machine local (test) cluster")
 	f.StringVar(&ownAddress, "starter.address", "", "address under which this server is reachable, needed for running in docker or in single mode")
 	f.StringVar(&id, "starter.id", "", "Unique identifier of this peer")
@@ -137,6 +138,7 @@ func init() {
 	f.BoolSliceVar(&startAgent, "cluster.start-agent", nil, "should an agent instance be started")
 	f.BoolSliceVar(&startDBserver, "cluster.start-dbserver", nil, "should a dbserver instance be started")
 	f.BoolSliceVar(&startCoordinator, "cluster.start-coordinator", nil, "should a coordinator instance be started")
+	f.BoolSliceVar(&startResilientSingle, "cluster.start-single", nil, "should a (resilient) single server instance be started")
 
 	f.StringVar(&arangodPath, "server.arangod", "/usr/sbin/arangod", "Path of arangod")
 	f.StringVar(&arangodJSPath, "server.js-dir", "/usr/share/arangodb3/js", "Path of arango JS folder")
@@ -504,6 +506,7 @@ func mustPrepareService(generateAutoKeyFile bool) (*service.Service, service.Boo
 		StartAgent:               getOptionalBool("cluster.start-agent", startAgent),
 		StartDBserver:            getOptionalBool("cluster.start-dbserver", startDBserver),
 		StartCoordinator:         getOptionalBool("cluster.start-coordinator", startCoordinator),
+		StartResilientSingle:     getOptionalBool("cluster.start-single", startResilientSingle),
 		ServerStorageEngine:      serverStorageEngine,
 		JwtSecret:                jwtSecret,
 		SslKeyFile:               sslKeyFile,
diff --git a/service/arangod_config_builder.go b/service/arangod_config_builder.go
@@ -80,7 +80,7 @@ func createArangodConf(log *logging.Logger, bsCfg BootstrapConfig, myHostDir, my
 	case ServerTypeDBServer:
 		threads = "4"
 		v8Contexts = "4"
-	case ServerTypeCoordinator, ServerTypeSingle:
+	case ServerTypeCoordinator, ServerTypeSingle, ServerTypeResilientSingle:
 		threads = "16"
 		v8Contexts = "4"
 	}
@@ -246,6 +246,13 @@ func createArangodArgs(log *logging.Logger, config Config, clusterConfig Cluster
 			optionPair{"--foxx.queues", "true"},
 			optionPair{"--server.statistics", "true"},
 		)
+	case ServerTypeResilientSingle:
+		options = append(options,
+			optionPair{"--foxx.queues", "true"},
+			optionPair{"--server.statistics", "true"},
+			optionPair{"--replication.auto-failover", "true"},
+			optionPair{"--cluster.my-role", "SINGLE"},
+		)
 	}
 	if serverType != ServerTypeAgent && serverType != ServerTypeSingle {
 		for _, p := range clusterConfig.AllAgents() {
diff --git a/service/bootstrap_config.go b/service/bootstrap_config.go
@@ -34,6 +34,7 @@ type BootstrapConfig struct {
 	StartAgent               *bool       // If not nil, sets if starter starts a agent, otherwise default handling applies
 	StartDBserver            *bool       // If not nil, sets if starter starts a dbserver, otherwise default handling applies
 	StartCoordinator         *bool       // If not nil, sets if starter starts a coordinator, otherwise default handling applies
+	StartResilientSingle     *bool       // If not nil, sets if starter starts a resilient single, otherwise default handling applies
 	ServerStorageEngine      string      // mmfiles | rocksdb
 	JwtSecret                string      // JWT secret used for arangod communication
 	SslKeyFile               string      // Path containing an x509 certificate + private key to be used by the servers.
diff --git a/service/bootstrap_master.go b/service/bootstrap_master.go
@@ -49,8 +49,9 @@ func (s *Service) bootstrapMaster(ctx context.Context, runner Runner, config Con
 	hasAgent := boolFromRef(bsCfg.StartAgent, !s.mode.IsSingleMode())
 	hasDBServer := boolFromRef(bsCfg.StartDBserver, true)
 	hasCoordinator := boolFromRef(bsCfg.StartCoordinator, true)
+	hasResilientSingle := boolFromRef(bsCfg.StartResilientSingle, s.mode.IsResilientSingleMode())
 	s.myPeers.Initialize(
-		NewPeer(s.id, config.OwnAddress, s.announcePort, 0, config.DataDir, hasAgent, hasDBServer, hasCoordinator, s.IsSecure()),
+		NewPeer(s.id, config.OwnAddress, s.announcePort, 0, config.DataDir, hasAgent, hasDBServer, hasCoordinator, hasResilientSingle, s.IsSecure()),
 		bsCfg.AgencySize)
 	s.learnOwnAddress = config.OwnAddress == ""
 
diff --git a/service/bootstrap_slave.go b/service/bootstrap_slave.go
@@ -42,14 +42,15 @@ func (s *Service) bootstrapSlave(peerAddress string, runner Runner, config Confi
 			s.log.Fatalf("Failed to get HTTP server port: %#v", err)
 		}
 		encoded, err := json.Marshal(HelloRequest{
-			DataDir:      config.DataDir,
-			SlaveID:      s.id,
-			SlaveAddress: config.OwnAddress,
-			SlavePort:    hostPort,
-			IsSecure:     s.IsSecure(),
-			Agent:        copyBoolRef(bsCfg.StartAgent),
-			DBServer:     copyBoolRef(bsCfg.StartDBserver),
-			Coordinator:  copyBoolRef(bsCfg.StartCoordinator),
+			DataDir:         config.DataDir,
+			SlaveID:         s.id,
+			SlaveAddress:    config.OwnAddress,
+			SlavePort:       hostPort,
+			IsSecure:        s.IsSecure(),
+			Agent:           copyBoolRef(bsCfg.StartAgent),
+			DBServer:        copyBoolRef(bsCfg.StartDBserver),
+			Coordinator:     copyBoolRef(bsCfg.StartCoordinator),
+			ResilientSingle: copyBoolRef(bsCfg.StartResilientSingle),
 		})
 		if err != nil {
 			s.log.Fatalf("Failed to encode Hello request: %#v", err)
diff --git a/service/cluster_config.go b/service/cluster_config.go
@@ -154,6 +154,18 @@ func (p ClusterConfig) HaveEnoughAgents() bool {
 	return count >= p.AgencySize
 }
 
+// HaveEnoughResilientSingles returns true when the number of peers that have an resilient single server
+// is equal to 2.
+func (p ClusterConfig) HaveEnoughResilientSingles() bool {
+	count := 0
+	for _, x := range p.AllPeers {
+		if x.HasResilientSingle() {
+			count++
+		}
+	}
+	return count >= 2
+}
+
 // IsSecure returns true if any of the peers is secure.
 func (p ClusterConfig) IsSecure() bool {
 	for _, x := range p.AllPeers {
diff --git a/service/mode.go b/service/mode.go
@@ -25,8 +25,9 @@ package service
 type ServiceMode string
 
 const (
-	ServiceModeCluster = ServiceMode("cluster")
-	ServiceModeSingle  = ServiceMode("single")
+	ServiceModeCluster         = ServiceMode("cluster")
+	ServiceModeSingle          = ServiceMode("single")
+	ServiceModeResilientSingle = ServiceMode("resilientsingle")
 )
 
 // IsClusterMode returns true when the service is running in cluster mode.
@@ -38,3 +39,8 @@ func (m ServiceMode) IsClusterMode() bool {
 func (m ServiceMode) IsSingleMode() bool {
 	return m == "single"
 }
+
+// IsResilientSingleMode returns true when the service is running in resilient single server mode.
+func (m ServiceMode) IsResilientSingleMode() bool {
+	return m == "resilientsingle"
+}
diff --git a/service/passthrough.go b/service/passthrough.go
@@ -64,7 +64,7 @@ var (
 func (o *PassthroughOption) valueForServerType(serverType ServerType) []string {
 	var result []string
 	switch serverType {
-	case ServerTypeSingle:
+	case ServerTypeSingle, ServerTypeResilientSingle:
 		result = o.Values.All
 	case ServerTypeCoordinator:
 		result = o.Values.Coordinators
diff --git a/service/peer.go b/service/peer.go
@@ -35,27 +35,29 @@ import (
 
 // Peer contains all persistent settings of a starter.
 type Peer struct {
-	ID                 string // Unique of of the peer
-	Address            string // IP address of arangodb peer server
-	Port               int    // Port number of arangodb peer server
-	PortOffset         int    // Offset to add to base ports for the various servers (agent, coordinator, dbserver)
-	DataDir            string // Directory holding my data
-	HasAgentFlag       bool   `json:"HasAgent"`                 // If set, this peer is running an agent
-	HasDBServerFlag    *bool  `json:"HasDBServer,omitempty"`    // If set or is nil, this peer is running a dbserver
-	HasCoordinatorFlag *bool  `json:"HasCoordinator,omitempty"` // If set or is nil, this peer is running a coordinator
-	IsSecure           bool   // If set, servers started by this peer are using an SSL connection
+	ID                     string // Unique of of the peer
+	Address                string // IP address of arangodb peer server
+	Port                   int    // Port number of arangodb peer server
+	PortOffset             int    // Offset to add to base ports for the various servers (agent, coordinator, dbserver)
+	DataDir                string // Directory holding my data
+	HasAgentFlag           bool   `json:"HasAgent"`                     // If set, this peer is running an agent
+	HasDBServerFlag        *bool  `json:"HasDBServer,omitempty"`        // If set or is nil, this peer is running a dbserver
+	HasCoordinatorFlag     *bool  `json:"HasCoordinator,omitempty"`     // If set or is nil, this peer is running a coordinator
+	HasResilientSingleFlag bool   `json:"HasResilientSingle,omitempty"` // If set, this peer is running a resilient single server
+	IsSecure               bool   // If set, servers started by this peer are using an SSL connection
 }
 
 // NewPeer initializes a new Peer instance with given values.
-func NewPeer(id, address string, port, portOffset int, dataDir string, hasAgent, hasDBServer, hasCoordinator, isSecure bool) Peer {
+func NewPeer(id, address string, port, portOffset int, dataDir string, hasAgent, hasDBServer, hasCoordinator, hasResilientSingle, isSecure bool) Peer {
 	p := Peer{
-		ID:           id,
-		Address:      address,
-		Port:         port,
-		PortOffset:   portOffset,
-		DataDir:      dataDir,
-		HasAgentFlag: hasAgent,
-		IsSecure:     isSecure,
+		ID:                     id,
+		Address:                address,
+		Port:                   port,
+		PortOffset:             portOffset,
+		DataDir:                dataDir,
+		HasAgentFlag:           hasAgent,
+		IsSecure:               isSecure,
+		HasResilientSingleFlag: hasResilientSingle,
 	}
 	if !hasDBServer {
 		p.HasDBServerFlag = boolRef(false)
@@ -75,6 +77,9 @@ func (p Peer) HasDBServer() bool { return p.HasDBServerFlag == nil || *p.HasDBSe
 // HasCoordinator returns true if this peer is running a coordinator
 func (p Peer) HasCoordinator() bool { return p.HasCoordinatorFlag == nil || *p.HasCoordinatorFlag }
 
+// HasResilientSingle returns true if this peer is running an resilient single server
+func (p Peer) HasResilientSingle() bool { return p.HasResilientSingleFlag }
+
 // CreateStarterURL creates a URL to the relative path to the starter on this peer.
 func (p Peer) CreateStarterURL(relPath string) string {
 	addr := net.JoinHostPort(p.Address, strconv.Itoa(p.Port+p.PortOffset))
diff --git a/service/runtime_cluster_manager.go b/service/runtime_cluster_manager.go
@@ -232,7 +232,7 @@ func (s *runtimeClusterManager) Run(ctx context.Context, log *logging.Logger, ru
 	s.runtimeContext = runtimeContext
 	s.interruptChan = make(chan struct{}, 32)
 	_, myPeer, mode := runtimeContext.ClusterConfig()
-	if !mode.IsClusterMode() {
+	if !mode.IsClusterMode() && !mode.IsResilientSingleMode() {
 		// Cluster manager is only relevant in cluster mode
 		return
 	}
diff --git a/service/runtime_server_manager.go b/service/runtime_server_manager.go
@@ -317,6 +317,17 @@ func (s *runtimeServerManager) Run(ctx context.Context, log *logging.Logger, run
 		if bsCfg.StartCoordinator == nil || *bsCfg.StartCoordinator {
 			go s.runArangod(ctx, log, runtimeContext, runner, config, bsCfg, *myPeer, ServerTypeCoordinator, &s.coordinatorProc)
 		}
+	} else if mode.IsResilientSingleMode() {
+		// Start agent:
+		if myPeer.HasAgent() {
+			go s.runArangod(ctx, log, runtimeContext, runner, config, bsCfg, *myPeer, ServerTypeAgent, &s.agentProc)
+			time.Sleep(time.Second)
+		}
+
+		// Start Single server:
+		if myPeer.HasResilientSingle() {
+			go s.runArangod(ctx, log, runtimeContext, runner, config, bsCfg, *myPeer, ServerTypeResilientSingle, &s.singleProc)
+		}
 	} else if mode.IsSingleMode() {
 		// Start Single server:
 		go s.runArangod(ctx, log, runtimeContext, runner, config, bsCfg, *myPeer, ServerTypeSingle, &s.singleProc)
diff --git a/service/server.go b/service/server.go
@@ -49,14 +49,15 @@ const (
 
 // HelloRequest is the data structure send of the wire in a `/hello` POST request.
 type HelloRequest struct {
-	SlaveID      string // Unique ID of the slave
-	SlaveAddress string // IP address used to reach the slave (if empty, this will be derived from the request)
-	SlavePort    int    // Port used to reach the slave
-	DataDir      string // Directory used for data by this slave
-	IsSecure     bool   // If set, servers started by this peer are using an SSL connection
-	Agent        *bool  `json:",omitempty"` // If not nil, sets if server gets an agent or not. If nil, default handling applies
-	DBServer     *bool  `json:",omitempty"` // If not nil, sets if server gets an dbserver or not. If nil, default handling applies
-	Coordinator  *bool  `json:",omitempty"` // If not nil, sets if server gets an coordinator or not. If nil, default handling applies
+	SlaveID         string // Unique ID of the slave
+	SlaveAddress    string // IP address used to reach the slave (if empty, this will be derived from the request)
+	SlavePort       int    // Port used to reach the slave
+	DataDir         string // Directory used for data by this slave
+	IsSecure        bool   // If set, servers started by this peer are using an SSL connection
+	Agent           *bool  `json:",omitempty"` // If not nil, sets if server gets an agent or not. If nil, default handling applies
+	DBServer        *bool  `json:",omitempty"` // If not nil, sets if server gets an dbserver or not. If nil, default handling applies
+	Coordinator     *bool  `json:",omitempty"` // If not nil, sets if server gets an coordinator or not. If nil, default handling applies
+	ResilientSingle *bool  `json:",omitempty"` // If not nil, sets if server gets an resilient single or not. If nil, default handling applies
 }
 
 type GoodbyeRequest struct {
diff --git a/service/server_type.go b/service/server_type.go
@@ -28,10 +28,11 @@ import "fmt"
 type ServerType string
 
 const (
-	ServerTypeCoordinator = "coordinator"
-	ServerTypeDBServer    = "dbserver"
-	ServerTypeAgent       = "agent"
-	ServerTypeSingle      = "single"
+	ServerTypeCoordinator     = "coordinator"
+	ServerTypeDBServer        = "dbserver"
+	ServerTypeAgent           = "agent"
+	ServerTypeSingle          = "single"
+	ServerTypeResilientSingle = "resilientsingle"
 )
 
 // String returns a string representation of the given ServerType.
@@ -42,7 +43,7 @@ func (s ServerType) String() string {
 // PortOffset returns the offset from a peer base port for the given type of server.
 func (s ServerType) PortOffset() int {
 	switch s {
-	case ServerTypeCoordinator, ServerTypeSingle:
+	case ServerTypeCoordinator, ServerTypeSingle, ServerTypeResilientSingle:
 		return _portOffsetCoordinator
 	case ServerTypeDBServer:
 		return _portOffsetDBServer
diff --git a/service/service.go b/service/service.go
@@ -647,10 +647,11 @@ func (s *Service) HandleHello(ownAddress, remoteAddress string, req *HelloReques
 			if s.mode.IsSingleMode() {
 				return ClusterConfig{}, maskAny(errors.Wrap(client.BadRequestError, "In single server mode, slaves cannot be added."))
 			}
+			// Ok. We're now in cluster or resilient single mode.
 			// ID not yet found, add it
 			portOffset := s.myPeers.GetFreePortOffset(slaveAddr, slavePort, s.cfg.AllPortOffsetsUnique)
 			s.log.Debugf("Set slave port offset to %d, got slaveAddr=%s, slavePort=%d", portOffset, slaveAddr, slavePort)
-			hasAgent := s.mode.IsClusterMode() && !s.myPeers.HaveEnoughAgents()
+			hasAgent := !s.myPeers.HaveEnoughAgents()
 			if req.Agent != nil {
 				hasAgent = *req.Agent
 			}
@@ -662,7 +663,11 @@ func (s *Service) HandleHello(ownAddress, remoteAddress string, req *HelloReques
 			if req.Coordinator != nil {
 				hasCoordinator = *req.Coordinator
 			}
-			newPeer := NewPeer(req.SlaveID, slaveAddr, slavePort, portOffset, req.DataDir, hasAgent, hasDBServer, hasCoordinator, req.IsSecure)
+			hasResilientSingle := !s.myPeers.HaveEnoughResilientSingles()
+			if req.ResilientSingle != nil {
+				hasResilientSingle = *req.ResilientSingle
+			}
+			newPeer := NewPeer(req.SlaveID, slaveAddr, slavePort, portOffset, req.DataDir, hasAgent, hasDBServer, hasCoordinator, hasResilientSingle, req.IsSecure)
 			s.myPeers.AddPeer(newPeer)
 			s.log.Infof("Added new peer '%s': %s, portOffset: %d", newPeer.ID, newPeer.Address, newPeer.PortOffset)
 		}
