Merge remote-tracking branch 'origin/master' into tests/apis-storage-v1alpha

* origin/master: (145 commits)
  Enable LONG on kube-arangodb-long test
  fix rocksdb_encryption_test
  fix - /api/version will answer on all servers (not leader only)
  fixes required after merge
  add downgrade tests
  add missing uniuri
  Merged in master
  Fixed unit-test packages
  Fixed unit tests
  Do not Fail the deployment, unless there is REALLY no other way
  Updated tests
  Refactor DeploymentState to DeploymentPhase
  Revert example change
  Added detection on unschedulable pods
  Detect pods not being scheduled
  Same fix on ArangoLocalStorage
  AsOwner no longer things the owner refers to a controller. It refers to the ArangoDeployment
  disable upgrade tests to 3.4 until 3.4 is available on hub.docker.com
  Listen for secret changes
  Log improvements
  ...

Author: ObiWahn

Jenkinsfile.groovy

@@ -19,19 +19,72 @@ def notifySlack(String buildStatus = 'STARTED') {
     slackSend(color: color, channel: '#status-k8s', message: msg)
 }
 
+def fetchParamsFromGitLog() {
+    def myParams = [:];
+    // Copy configured params 
+    for (entry in params) {
+        myParams[entry.key] = entry.value;
+    }
+
+    // Is this a LONG test?
+    if ("${env.JOB_NAME}" == "kube-arangodb-long") {
+        myParams["LONG"] = true;
+    }
+
+    // Fetch params configured in git commit messages 
+    // Syntax: [ci OPT=value]
+    // Example: [ci TESTOPTIONS="-test.run ^TestSimpleSingle$"]
+    def options = sh(returnStdout: true, script: "git log --reverse remotes/origin/master..HEAD | grep -o \'\\[ci[^\\[]*\\]\' | sed -E \'s/\\[ci (.*)\\]/\\1/\'").trim().split("\n")
+    for (opt in options) {
+        def idx = opt.indexOf('=');
+        if (idx > 0) {
+            def key = opt.substring(0, idx);
+            def value = opt.substring(idx+1).replaceAll('^\"|\"$', '');
+            myParams[key] = value;
+            //println("Overwriting myParams.${key} with ${value}");
+        }
+    }
+
+    // Show params in log
+    for (entry in myParams) {
+        println("Using myParams.${entry.key} with ${entry.value}");
+    }
+
+    return myParams;
+}
+
 def kubeConfigRoot = "/home/jenkins/.kube"
 
-def buildTestSteps(String kubeConfigRoot, String kubeconfig) {
+def buildBuildSteps(Map myParams) {
+    return {
+        timestamps {
+            withEnv([
+            "DEPLOYMENTNAMESPACE=${myParams.TESTNAMESPACE}-${env.GIT_COMMIT}",
+            "DOCKERNAMESPACE=${myParams.DOCKERNAMESPACE}",
+            "IMAGETAG=jenkins-test",
+            "LONG=${myParams.LONG ? 1 : 0}",
+            "TESTOPTIONS=${myParams.TESTOPTIONS}",
+            ]) {
+                sh "make"
+                sh "make run-unit-tests"
+                sh "make docker-test"
+            }
+        }
+    }
+}
+
+def buildTestSteps(Map myParams, String kubeConfigRoot, String kubeconfig) {
     return {
         timestamps {
             withCredentials([string(credentialsId: 'ENTERPRISEIMAGE', variable: 'DEFAULTENTERPRISEIMAGE')]) { 
                 withEnv([
-                "DEPLOYMENTNAMESPACE=${params.TESTNAMESPACE}-${env.GIT_COMMIT}",
-                "DOCKERNAMESPACE=${params.DOCKERNAMESPACE}",
-                "ENTERPRISEIMAGE=${params.ENTERPRISEIMAGE}",
+                "DEPLOYMENTNAMESPACE=${myParams.TESTNAMESPACE}-${env.GIT_COMMIT}",
+                "DOCKERNAMESPACE=${myParams.DOCKERNAMESPACE}",
+                "ENTERPRISEIMAGE=${myParams.ENTERPRISEIMAGE}",
                 "IMAGETAG=jenkins-test",
                 "KUBECONFIG=${kubeConfigRoot}/${kubeconfig}",
-                "LONG=${params.LONG ? 1 : 0}",
+                "LONG=${myParams.LONG ? 1 : 0}",
+                "TESTOPTIONS=${myParams.TESTOPTIONS}",
                 ]) {
                     sh "make run-tests"
                 }
@@ -40,12 +93,12 @@ def buildTestSteps(String kubeConfigRoot, String kubeconfig) {
     }
 }
 
-def buildCleanupSteps(String kubeConfigRoot, String kubeconfig) {
+def buildCleanupSteps(Map myParams, String kubeConfigRoot, String kubeconfig) {
     return {
         timestamps {
             withEnv([
-                "DEPLOYMENTNAMESPACE=${params.TESTNAMESPACE}-${env.GIT_COMMIT}",
-                "DOCKERNAMESPACE=${params.DOCKERNAMESPACE}",
+                "DEPLOYMENTNAMESPACE=${myParams.TESTNAMESPACE}-${env.GIT_COMMIT}",
+                "DOCKERNAMESPACE=${myParams.DOCKERNAMESPACE}",
                 "KUBECONFIG=${kubeConfigRoot}/${kubeconfig}",
             ]) {
                 sh "make cleanup-tests"
@@ -66,31 +119,26 @@ pipeline {
       string(name: 'KUBECONFIGS', defaultValue: 'kube-ams1,scw-183a3b', description: 'KUBECONFIGS is a comma separated list of Kubernetes configuration files (relative to /home/jenkins/.kube) on which the tests are run', )
       string(name: 'TESTNAMESPACE', defaultValue: 'jenkins', description: 'TESTNAMESPACE sets the kubernetes namespace to ru tests in (this must be short!!)', )
       string(name: 'ENTERPRISEIMAGE', defaultValue: '', description: 'ENTERPRISEIMAGE sets the docker image used for enterprise tests)', )
+      string(name: 'TESTOPTIONS', defaultValue: '', description: 'TESTOPTIONS is used to pass additional test options to the integration test', )
     }
     stages {
         stage('Build') {
             steps {
-                timestamps {
-                    withEnv([
-                    "DEPLOYMENTNAMESPACE=${params.TESTNAMESPACE}-${env.GIT_COMMIT}",
-                    "DOCKERNAMESPACE=${params.DOCKERNAMESPACE}",
-                    "IMAGETAG=jenkins-test",
-                    "LONG=${params.LONG ? 1 : 0}",
-                    ]) {
-                        sh "make"
-                        sh "make run-unit-tests"
-                        sh "make docker-test"
-                    }
+                script {
+                    def myParams = fetchParamsFromGitLog();
+                    def buildSteps = buildBuildSteps(myParams);
+                    buildSteps();
                 }
             }
         }
         stage('Test') {
             steps {
                 script {
-                    def configs = "${params.KUBECONFIGS}".split(",")
+                    def myParams = fetchParamsFromGitLog();
+                    def configs = "${myParams.KUBECONFIGS}".split(",")
                     def testTasks = [:]
                     for (kubeconfig in configs) {
-                        testTasks["${kubeconfig}"] = buildTestSteps(kubeConfigRoot, kubeconfig)
+                        testTasks["${kubeconfig}"] = buildTestSteps(myParams, kubeConfigRoot, kubeconfig)
                     }
                     parallel testTasks
                 }
@@ -101,10 +149,11 @@ pipeline {
     post {
         always {
             script {
-                def configs = "${params.KUBECONFIGS}".split(",")
+                def myParams = fetchParamsFromGitLog();
+                def configs = "${myParams['KUBECONFIGS']}".split(",")
                 def cleanupTasks = [:]
                 for (kubeconfig in configs) {
-                    cleanupTasks["${kubeconfig}"] = buildCleanupSteps(kubeConfigRoot, kubeconfig)
+                    cleanupTasks["${kubeconfig}"] = buildCleanupSteps(myParams, kubeConfigRoot, kubeconfig)
                 }
                 parallel cleanupTasks
             }

Makefile

@@ -40,18 +40,25 @@ else
 	IMAGESUFFIX := :dev
 endif
 
-ifndef MANIFESTPATH 
-	MANIFESTPATH := manifests/arango-operator-dev.yaml
+ifeq ($(MANIFESTSUFFIX),-)
+	# Release setting
+	MANIFESTSUFFIX :=
+else
+ifndef MANIFESTSUFFIX
+	MANIFESTSUFFIX := -dev
+endif
 endif
+MANIFESTPATHDEPLOYMENT := manifests/arango-deployment$(MANIFESTSUFFIX).yaml
+MANIFESTPATHSTORAGE := manifests/arango-storage$(MANIFESTSUFFIX).yaml
 ifndef DEPLOYMENTNAMESPACE
 	DEPLOYMENTNAMESPACE := default
 endif
 
 ifndef OPERATORIMAGE
-	OPERATORIMAGE := $(DOCKERNAMESPACE)/arangodb-operator$(IMAGESUFFIX)
+	OPERATORIMAGE := $(DOCKERNAMESPACE)/kube-arangodb$(IMAGESUFFIX)
 endif
 ifndef TESTIMAGE
-	TESTIMAGE := $(DOCKERNAMESPACE)/arangodb-operator-test$(IMAGESUFFIX)
+	TESTIMAGE := $(DOCKERNAMESPACE)/kube-arangodb-test$(IMAGESUFFIX)
 endif
 ifndef ENTERPRISEIMAGE
 	ENTERPRISEIMAGE := $(DEFAULTENTERPRISEIMAGE)
@@ -189,7 +196,7 @@ endif
 .PHONY: manifests
 manifests: $(GOBUILDDIR)
 	GOPATH=$(GOBUILDDIR) go run $(ROOTDIR)/tools/manifests/manifest_builder.go \
-		--output=$(MANIFESTPATH) \
+		--output-suffix=$(MANIFESTSUFFIX) \
 		--image=$(OPERATORIMAGE) \
 		--image-sha256=$(IMAGESHA256) \
 		--namespace=$(DEPLOYMENTNAMESPACE)
@@ -210,7 +217,8 @@ run-unit-tests: $(GOBUILDDIR) $(SOURCES)
 		go test $(TESTVERBOSEOPTIONS) \
 			$(REPOPATH)/pkg/apis/deployment/v1alpha \
 			$(REPOPATH)/pkg/apis/storage/v1alpha \
-			$(REPOPATH)/pkg/deployment \
+			$(REPOPATH)/pkg/deployment/reconcile \
+			$(REPOPATH)/pkg/deployment/resources \
 			$(REPOPATH)/pkg/util/k8sutil \
 			$(REPOPATH)/pkg/util/k8sutil/test
 
@@ -241,15 +249,11 @@ ifneq ($(DEPLOYMENTNAMESPACE), default)
 	$(ROOTDIR)/scripts/kube_delete_namespace.sh $(DEPLOYMENTNAMESPACE)
 	kubectl create namespace $(DEPLOYMENTNAMESPACE)
 endif
-	kubectl apply -f $(MANIFESTPATH)
+	kubectl apply -f manifests/crd.yaml
+	kubectl apply -f $(MANIFESTPATHSTORAGE)
+	kubectl apply -f $(MANIFESTPATHDEPLOYMENT)
 	$(ROOTDIR)/scripts/kube_create_storage.sh $(DEPLOYMENTNAMESPACE)
-	kubectl --namespace $(DEPLOYMENTNAMESPACE) \
-		run arangodb-operator-test -i --rm --quiet --restart=Never \
-		--image=$(TESTIMAGE) \
-		--env="ENTERPRISEIMAGE=$(ENTERPRISEIMAGE)" \
-		--env="TEST_NAMESPACE=$(DEPLOYMENTNAMESPACE)" \
-		-- \
-		-test.v -test.timeout $(TESTTIMEOUT) $(TESTLENGTHOPTIONS)
+	$(ROOTDIR)/scripts/kube_run_tests.sh $(DEPLOYMENTNAMESPACE) $(TESTIMAGE) "$(ENTERPRISEIMAGE)" $(TESTTIMEOUT) $(TESTLENGTHOPTIONS)
 ifneq ($(DEPLOYMENTNAMESPACE), default)
 	kubectl delete namespace $(DEPLOYMENTNAMESPACE) --ignore-not-found --now
 endif
@@ -309,9 +313,12 @@ minikube-start:
 
 .PHONY: delete-operator
 delete-operator:
-	kubectl delete -f $(MANIFESTPATH) --ignore-not-found
+	kubectl delete -f $(MANIFESTPATHDEPLOYMENT) --ignore-not-found
+	kubectl delete -f $(MANIFESTPATHSTORAGE) --ignore-not-found
 
 .PHONY: redeploy-operator
 redeploy-operator: delete-operator manifests
-	kubectl apply -f $(MANIFESTPATH)
+	kubectl apply -f manifests/crd.yaml
+	kubectl apply -f $(MANIFESTPATHSTORAGE)
+	kubectl apply -f $(MANIFESTPATHDEPLOYMENT)
 	kubectl get pods 

README.md

@@ -2,14 +2,26 @@
 
 "Starter for Kubernetes"
 
-State: In development
+State: In heavy development. DO NOT USE FOR ANY PRODUCTION LIKE PURPOSE! THINGS WILL CHANGE.
 
 - [User manual](./docs/user/README.md)
 - [Design documents](./docs/design/README.md)
 
+## Installation of latest release
+
+```bash
+kubectl apply -f https://raw.githubusercontent.com/arangodb/kube-arangodb/0.0.1/manifests/crd.yaml
+kubectl apply -f https://raw.githubusercontent.com/arangodb/kube-arangodb/0.0.1/manifests/arango-deployment.yaml
+# To use `ArangoLocalStorage`, also run
+kubectl apply -f https://raw.githubusercontent.com/arangodb/kube-arangodb/0.0.1/manifests/arango-storage.yaml
+```
+
 ## Building
 
 ```bash
 DOCKERNAMESPACE=<your dockerhub account> make
-kubectl apply -f manifests/arango-operator-dev.yaml
+kubectl apply -f manifests/crd.yaml
+kubectl apply -f manifests/arango-deployment-dev.yaml
+# To use `ArangoLocalStorage`, also run
+kubectl apply -f manifests/arango-storage-dev.yaml
 ```

VERSION

@@ -1 +1 @@
-0.0.0+git
+0.0.1+git

deps/github.com/arangodb/go-driver/http/connection.go

@@ -67,6 +67,9 @@ type ConnectionConfig struct {
 	// directly after use, resulting in a large number of connections in `TIME_WAIT` state.
 	// When this value is not set, the driver will set it to 64 automatically.
 	Transport http.RoundTripper
+	// DontFollowRedirect; if set, redirect will not be followed, response from the initial request will be returned without an error
+	// DontFollowRedirect takes precendance over FailOnRedirect.
+	DontFollowRedirect bool
 	// FailOnRedirect; if set, redirect will not be followed, instead the status code is returned as error
 	FailOnRedirect bool
 	// Cluster configuration settings
@@ -137,7 +140,11 @@ func newHTTPConnection(endpoint string, config ConnectionConfig) (driver.Connect
 	httpClient := &http.Client{
 		Transport: config.Transport,
 	}
-	if config.FailOnRedirect {
+	if config.DontFollowRedirect {
+		httpClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse // Do not wrap, standard library will not understand
+		}
+	} else if config.FailOnRedirect {
 		httpClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
 			return driver.ArangoError{
 				HasError:     true,

docs/user/custom_resource.md

@@ -142,7 +142,8 @@ and restarting it.
 This setting specifies the name of a kubernetes `Secret` that contains
 a standard CA certificate + private key used to sign certificates for individual
 ArangoDB servers.
-The default value is empty. TBD
+When no name is specified, it defaults to `<deployment-name>-ca`.
+To disable authentication, set this value to `None`.
 
 If you specify a name of a `Secret` that does not exist, a self-signed CA certificate + key is created
 and stored in a `Secret` with given name.

docs/user/tls.md

@@ -1,11 +1,13 @@
 # TLS
 
-The ArangoDB operator allows you to create ArangoDB deployments that use
+The ArangoDB operator will by default create ArangoDB deployments that use
 secure TLS connections.
 
 It uses a single CA certificate (stored in a Kubernetes secret) and
 one certificate per ArangoDB server (stored in a Kubernetes secret per server).
 
+To disable TLS, set `spec.tls.caSecretName` to `None`.
+
 ## Install CA certificate
 
 If the CA certificate is self-signed, it will not be trusted by browsers,
@@ -16,7 +18,7 @@ To do so, you first have to fetch the CA certificate from its Kubernetes
 secret.
 
 ```bash
-kubectl get secret <deploy-name> --template='{{index .data "ca.crt"}}' | base64 -D > ca.crt
+kubectl get secret <deploy-name>-ca --template='{{index .data "ca.crt"}}' | base64 -D > ca.crt
 ```
 
 ### Windows
@@ -39,4 +41,4 @@ sudo /usr/bin/security remove-trusted-cert -d ca.crt
 
 ### Linux
 
-TODO
+TODO

docs/user/usage.md

@@ -6,7 +6,14 @@ The ArangoDB operator needs to be installed in your Kubernetes
 cluster first. To do so, clone this repository and run:
 
 ```bash
-kubectl apply -f manifests/arango-operator.yaml
+kubectl apply -f manifests/crd.yaml
+kubectl apply -f manifests/arango-deployment.yaml
+```
+
+To use `ArangoLocalStorage`, also run:
+
+```bash
+kubectl apply -f manifests/arango-storage.yaml
 ```
 
 ## Cluster creation
@@ -37,5 +44,7 @@ To remove the entire ArangoDB operator, remove all
 clusters first and then remove the operator by running:
 
 ```bash
-kubectl delete -f manifests/arango-operator.yaml
+kubectl delete -f manifests/arango-deployment.yaml
+# If `ArangoLocalStorage` is installed
+kubectl delete -f manifests/arango-storage.yaml
 ```

examples/nodeport-cluster.yaml

@@ -7,6 +7,7 @@ spec:
     app: arangodb
     role: coordinator
   type: NodePort
+  publishNotReadyAddresses: true
   ports:
   - protocol: TCP
     port: 8529

examples/simple-cluster-no-tls.yaml

@@ -0,0 +1,8 @@
+apiVersion: "database.arangodb.com/v1alpha"
+kind: "ArangoDeployment"
+metadata:
+  name: "example-simple-cluster-no-tls"
+spec:
+  mode: cluster
+  tls:
+    caSecretName: None