Merge pull request #88 from arangodb-helper/resilientsingle

Resilient single server support

Author: ewoutp

.travis.yml

@@ -6,12 +6,12 @@ services:
 language: go
 
 env:
-  - TEST_SUITE=run-tests-local-process ARANGODB=arangodb:3.1
-  - TEST_SUITE=run-tests-docker        ARANGODB=arangodb:3.1
-  - TEST_SUITE=run-tests-local-process ARANGODB=arangodb/arangodb:latest
-  - TEST_SUITE=run-tests-docker        ARANGODB=arangodb/arangodb:latest
-  - TEST_SUITE=run-tests-local-process ARANGODB=arangodb/arangodb-preview:latest
-  - TEST_SUITE=run-tests-docker        ARANGODB=arangodb/arangodb-preview:latest
+  - TEST_SUITE=run-tests-local-process ARANGODB=arangodb:3.1 STARTER_MODES="single,cluster"
+  - TEST_SUITE=run-tests-docker        ARANGODB=arangodb:3.1 STARTER_MODES="single,cluster"
+  - TEST_SUITE=run-tests-local-process ARANGODB=arangodb/arangodb:latest STARTER_MODES="single,cluster"
+  - TEST_SUITE=run-tests-docker        ARANGODB=arangodb/arangodb:latest STARTER_MODES="single,cluster"
+  - TEST_SUITE=run-tests-local-process ARANGODB=arangodb/arangodb-preview:latest STARTER_MODES="single,cluster,resilientsingle"
+  - TEST_SUITE=run-tests-docker        ARANGODB=arangodb/arangodb-preview:latest STARTER_MODES="single,cluster,resilientsingle"
 
 script: make $TEST_SUITE
 

.vscode/settings.json

@@ -1,5 +1,10 @@
 // Place your settings in this file to overwrite default and user settings.
 {
     "go.testFlags": ["-v"],
-    "go.testTimeout": "600s"
+    "go.testTimeout": "600s",
+    "search.exclude": {
+        "**/node_modules": true,
+        "**/bower_components": true,
+        "vendor": true
+    }
 }

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
@@ -156,15 +156,16 @@ run-tests-local-process: build test-images
 		-e DATA_DIR=/tmp \
 		-e STARTER=/usr/code/bin/linux/amd64/arangodb \
 		-e TEST_MODES=localprocess \
+		-e STARTER_MODES=$(STARTER_MODES) \
 		-e TESTOPTIONS=$(TESTOPTIONS) \
 		-e DEBUG_CLUSTER=$(DEBUG_CLUSTER) \
 		-w /usr/code/ \
 		arangodb-golang \
 		go test -timeout $(TEST_TIMEOUT) $(TESTOPTIONS) -v $(REPOPATH)/test
 
 run-tests-docker: docker
-	GOPATH=$(GOBUILDDIR) TEST_MODES=docker IP=$(IP) ARANGODB=$(ARANGODB) go test -timeout $(TEST_TIMEOUT) $(TESTOPTIONS) -v $(REPOPATH)/test
+	GOPATH=$(GOBUILDDIR) TEST_MODES=docker STARTER_MODES=$(STARTER_MODES) IP=$(IP) ARANGODB=$(ARANGODB) go test -timeout $(TEST_TIMEOUT) $(TESTOPTIONS) -v $(REPOPATH)/test
 
 # Run all integration tests on the local system
 run-tests-local: local
-	GOPATH=$(GOBUILDDIR) TEST_MODES="localprocess docker" STARTER=$(ROOTDIR)/arangodb go test -timeout $(TEST_TIMEOUT) $(TESTOPTIONS) -v $(REPOPATH)/test
+	GOPATH=$(GOBUILDDIR) TEST_MODES="localprocess,docker" STARTER_MODES=$(STARTER_MODES) STARTER=$(ROOTDIR)/arangodb go test -timeout $(TEST_TIMEOUT) $(TESTOPTIONS) -v $(REPOPATH)/test

README.md

@@ -194,6 +194,62 @@ docker run -it --name=adb --rm -p 8528:8528 \
     --starter.mode=single
 ```
 
+Starting a resilient single server pair
+---------------------------------------
+
+If you want to start a resilient single database server, use `--starter.mode=resilientsingle`.
+In this mode a 3 machine agency is started and 2 single servers that perform 
+asynchronous replication an failover if needed.
+
+```
+arangodb --starter.mode=resilientsingle --starter.join A,B,C
+```
+
+Run this on machine A, B & C.
+
+The starter will decide on which 2 machines to run a single server instance.
+To override this decision (only valid while bootstrapping), add a 
+`--cluster.start-single=false` to the machine where the single server 
+instance should NOT be scheduled.
+
+Starting a resilient single server pair in Docker
+-------------------------------------------------
+
+If you want to start a resilient single database server running in docker containers,
+use the normal docker arguments, combined with `--starter.mode=resilientsingle`.
+
+```
+export IP=<IP of docker host>
+docker volume create arangodb
+docker run -it --name=adb --rm -p 8528:8528 \
+    -v arangodb:/data \
+    -v /var/run/docker.sock:/var/run/docker.sock \
+    arangodb/arangodb-starter \
+    --starter.address=$IP \
+    --starter.mode=resilientsingle \
+    --starter.join=A,B,C
+```
+
+Run this on machine A, B & C.
+
+The starter will decide on which 2 machines to run a single server instance.
+To override this decision (only valid while bootstrapping), add a 
+`--cluster.start-single=false` to the machine where the single server 
+instance should NOT be scheduled.
+
+Starting a local test resilient single sever pair
+-------------------------------------------------
+
+If you want to start a local resilient server pair quickly, use the `--starter.local` flag. 
+It will start all servers within the context of a single starter process.
+
+```
+arangodb --starter.local --starter.mode=resilientsingle
+```
+
+Note: When you restart the started, it remembers the original `--starter.local` flag.
+
+
 Starting & stopping in detached mode 
 ------------------------------------
 

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,

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,14 @@ 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.automatic-failover", "true"},
+			optionPair{"--cluster.my-address", myTCPURL},
+			optionPair{"--cluster.my-role", "SINGLE"},
+		)
 	}
 	if serverType != ServerTypeAgent && serverType != ServerTypeSingle {
 		for _, p := range clusterConfig.AllAgents() {

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.

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 == ""
 

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)

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 {