Merge pull request #183 from arangodb-helper/feature/upgrade-plan

Upgrade plan

Author: ewoutp

Makefile

@@ -58,7 +58,7 @@ ifdef TRAVIS
 	echo Using IP=$(IP)
 endif
 
-TEST_TIMEOUT := 20m
+TEST_TIMEOUT := 25m
 
 BINNAME := arangodb$(GOEXE)
 BIN := $(BINDIR)/$(GOOS)/$(GOARCH)/$(BINNAME)
@@ -125,6 +125,7 @@ $(GOBUILDDIR):
 	@rm -f $(GOBUILDDIR)/src/github.com/ryanuber && ln -s ../../../deps/github.com/ryanuber $(GOBUILDDIR)/src/github.com/ryanuber
 	@rm -f $(GOBUILDDIR)/src/github.com/voxelbrain && ln -s ../../../deps/github.com/voxelbrain $(GOBUILDDIR)/src/github.com/voxelbrain
 	@rm -f $(GOBUILDDIR)/src/golang.org/x && ln -s ../../../deps/golang.org/x $(GOBUILDDIR)/src/golang.org/x
+	@GOPATH=$(GOBUILDDIR) go get github.com/arangodb/go-upgrade-rules
 
 .PHONY: $(CACHEVOL)
 $(CACHEVOL):

client/api.go

@@ -22,7 +22,11 @@
 
 package client
 
-import "context"
+import (
+	"context"
+
+	driver "github.com/arangodb/go-driver"
+)
 
 // API is the interface implemented by the starter's HTTP API's.
 type API interface {
@@ -32,6 +36,10 @@ type API interface {
 	// Version requests the starter version.
 	Version(ctx context.Context) (VersionInfo, error)
 
+	// DatabaseVersion returns the version of the `arangod` binary that is being
+	// used by this starter.
+	DatabaseVersion(ctx context.Context) (driver.Version, error)
+
 	// Processes loads information of all the database server processes launched by the starter.
 	Processes(ctx context.Context) (ProcessList, error)
 
@@ -41,6 +49,22 @@ type API interface {
 	// Shutdown will shutdown a starter (and all its started database servers).
 	// With goodbye set, it will remove the peer slot for the starter.
 	Shutdown(ctx context.Context, goodbye bool) error
+
+	// StartDatabaseUpgrade is called to start the upgrade process
+	StartDatabaseUpgrade(ctx context.Context) error
+
+	// RetryDatabaseUpgrade resets a failure mark in the existing upgrade plan
+	// such that the starters will retry the upgrade once more.
+	RetryDatabaseUpgrade(ctx context.Context) error
+
+	// AbortDatabaseUpgrade removes the existing upgrade plan.
+	// Note that Starters working on an entry of the upgrade
+	// will finish that entry.
+	// If there is no plan, a NotFoundError will be returned.
+	AbortDatabaseUpgrade(ctx context.Context) error
+
+	// Status returns the status of any upgrade plan
+	UpgradeStatus(context.Context) (UpgradeStatus, error)
 }
 
 // IDInfo contains the ID of the starter
@@ -54,6 +78,11 @@ type VersionInfo struct {
 	Build   string `json:"build"`
 }
 
+// DatabaseVersionResponse is the JSON response of a `/database-version` request.
+type DatabaseVersionResponse struct {
+	Version driver.Version `json:"version"`
+}
+
 // EndpointList is the JSON response of a `/endpoints` request.
 // It contains URL's of all starters, agents & coordinators in the cluster.
 type EndpointList struct {
@@ -101,3 +130,33 @@ func (list ProcessList) ServerByType(serverType ServerType) (ServerProcess, bool
 	}
 	return ServerProcess{}, false
 }
+
+// UpgradeStatus is the JSON structure returns from a `GET /database-auto-upgrade`
+// request.
+type UpgradeStatus struct {
+	// Ready is set to true when the entire upgrade has been finished succesfully.
+	Ready bool `json:"ready"`
+	// Failed is set to true when the upgrade process has yielded an error
+	Failed bool `json:"failed"`
+	// Reasons contains a human readable description of the state
+	Reason string `json:"reason,omitempty"`
+	// FromVersions contains all database versions found that will be upgraded.
+	FromVersions []driver.Version `json:"from_versions"`
+	// ToVersion contains the database version that will be upgraded to.
+	ToVersion driver.Version `json:"to_version"`
+	// ServersUpgraded contains the servers that have been upgraded
+	ServersUpgraded []UpgradeStatusServer `json:"servers_upgraded"`
+	// ServersRemaining contains the servers that have not yet been upgraded
+	ServersRemaining []UpgradeStatusServer `json:"servers_remaining"`
+}
+
+// UpgradeStatusServer is the nested JSON structure returns from a `GET /database-auto-upgrade`
+// request.
+type UpgradeStatusServer struct {
+	// Type of the server
+	Type ServerType `json:"type"`
+	// Port the server is listening on
+	Port int `json:"port"`
+	// Address of the server (IP or hostname)
+	Address string `json:"address"`
+}

client/client.go

@@ -25,11 +25,11 @@ package client
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 	"io/ioutil"
 	"net/http"
 	"net/url"
 
+	driver "github.com/arangodb/go-driver"
 	"github.com/pkg/errors"
 )
 
@@ -101,6 +101,30 @@ func (c *client) Version(ctx context.Context) (VersionInfo, error) {
 	return result, nil
 }
 
+// DatabaseVersion returns the version of the `arangod` binary that is being
+// used by this starter.
+func (c *client) DatabaseVersion(ctx context.Context) (driver.Version, error) {
+	url := c.createURL("/database-version", nil)
+
+	var result DatabaseVersionResponse
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return "", maskAny(err)
+	}
+	if ctx != nil {
+		req = req.WithContext(ctx)
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return "", maskAny(err)
+	}
+	if err := c.handleResponse(resp, "GET", url, &result); err != nil {
+		return "", maskAny(err)
+	}
+
+	return result.Version, nil
+}
+
 // Processes loads information of all the server processes launched by a specific arangodb.
 func (c *client) Processes(ctx context.Context) (ProcessList, error) {
 	url := c.createURL("/process", nil)
@@ -174,6 +198,99 @@ func (c *client) Shutdown(ctx context.Context, goodbye bool) error {
 	return nil
 }
 
+// StartDatabaseUpgrade is called to start the upgrade process
+func (c *client) StartDatabaseUpgrade(ctx context.Context) error {
+	url := c.createURL("/database-auto-upgrade", nil)
+
+	req, err := http.NewRequest("POST", url, nil)
+	if err != nil {
+		return maskAny(err)
+	}
+	if ctx != nil {
+		req = req.WithContext(ctx)
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return maskAny(err)
+	}
+	if err := c.handleResponse(resp, "POST", url, nil); err != nil {
+		return maskAny(err)
+	}
+
+	return nil
+}
+
+// RetryDatabaseUpgrade resets a failure mark in the existing upgrade plan
+// such that the starters will retry the upgrade once more.
+func (c *client) RetryDatabaseUpgrade(ctx context.Context) error {
+	url := c.createURL("/database-auto-upgrade", nil)
+
+	req, err := http.NewRequest("PUT", url, nil)
+	if err != nil {
+		return maskAny(err)
+	}
+	if ctx != nil {
+		req = req.WithContext(ctx)
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return maskAny(err)
+	}
+	if err := c.handleResponse(resp, "PUT", url, nil); err != nil {
+		return maskAny(err)
+	}
+
+	return nil
+}
+
+// AbortDatabaseUpgrade removes the existing upgrade plan.
+// Note that Starters working on an entry of the upgrade
+// will finish that entry.
+// If there is no plan, a NotFoundError will be returned.
+func (c *client) AbortDatabaseUpgrade(ctx context.Context) error {
+	url := c.createURL("/database-auto-upgrade", nil)
+
+	req, err := http.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return maskAny(err)
+	}
+	if ctx != nil {
+		req = req.WithContext(ctx)
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return maskAny(err)
+	}
+	if err := c.handleResponse(resp, "DELETE", url, nil); err != nil {
+		return maskAny(err)
+	}
+
+	return nil
+}
+
+// Status returns the status of any upgrade plan
+func (c *client) UpgradeStatus(ctx context.Context) (UpgradeStatus, error) {
+	url := c.createURL("/database-auto-upgrade", nil)
+
+	var result UpgradeStatus
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return UpgradeStatus{}, maskAny(err)
+	}
+	if ctx != nil {
+		req = req.WithContext(ctx)
+	}
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return UpgradeStatus{}, maskAny(err)
+	}
+	if err := c.handleResponse(resp, "GET", url, &result); err != nil {
+		return UpgradeStatus{}, maskAny(err)
+	}
+
+	return result, nil
+}
+
 // handleResponse checks the given response status and decodes any JSON result.
 func (c *client) handleResponse(resp *http.Response, method, url string, result interface{}) error {
 	// Read response body into memory
@@ -184,11 +301,16 @@ func (c *client) handleResponse(resp *http.Response, method, url string, result
 	}
 
 	if resp.StatusCode != http.StatusOK {
-		/*var er ErrorResponse
+		var er ErrorResponse
 		if err := json.Unmarshal(body, &er); err == nil {
-			return &er
-		}*/
-		return maskAny(fmt.Errorf("Invalid status %d", resp.StatusCode))
+			return maskAny(StatusError{
+				StatusCode: resp.StatusCode,
+				message:    er.Error,
+			})
+		}
+		return maskAny(StatusError{
+			StatusCode: resp.StatusCode,
+		})
 	}
 
 	// Got a success status

client/error.go

@@ -43,6 +43,7 @@ var (
 	InternalServerError = StatusError{StatusCode: http.StatusInternalServerError, message: "internal server error"}
 )
 
+// StatusError is an error with a given HTTP status code.
 type StatusError struct {
 	StatusCode int
 	message    string
@@ -75,10 +76,16 @@ func IsStatusErrorWithCode(err error, code int) bool {
 	return false
 }
 
+// ErrorResponse is the JSON structure returned in an API error.
 type ErrorResponse struct {
 	Error string
 }
 
+// IsNotFound returns true if the given error is caused by a NotFoundError.
+func IsNotFound(err error) bool {
+	return IsStatusErrorWithCode(err, http.StatusNotFound)
+}
+
 // IsServiceUnavailable returns true if the given error is caused by a ServiceUnavailableError.
 func IsServiceUnavailable(err error) bool {
 	return IsStatusErrorWithCode(err, http.StatusServiceUnavailable)
@@ -99,6 +106,31 @@ func IsInternalServer(err error) bool {
 	return IsStatusErrorWithCode(err, http.StatusInternalServerError)
 }
 
+// NewNotFoundError creates a not found error with given message.
+func NewNotFoundError(msg string) error {
+	return StatusError{StatusCode: http.StatusNotFound, message: msg}
+}
+
+// NewServiceUnavailableError creates a service unavailable error with given message.
+func NewServiceUnavailableError(msg string) error {
+	return StatusError{StatusCode: http.StatusServiceUnavailable, message: msg}
+}
+
+// NewBadRequestError creates a bad request error with given message.
+func NewBadRequestError(msg string) error {
+	return StatusError{StatusCode: http.StatusBadRequest, message: msg}
+}
+
+// NewPreconditionFailedError creates a precondition failed error with given message.
+func NewPreconditionFailedError(msg string) error {
+	return StatusError{StatusCode: http.StatusPreconditionFailed, message: msg}
+}
+
+// NewInternalServerError creates a internal server error with given message.
+func NewInternalServerError(msg string) error {
+	return StatusError{StatusCode: http.StatusInternalServerError, message: msg}
+}
+
 // ParseResponseError returns an error from given response.
 // It tries to parse the body (if given body is nil, will be read from response)
 // for ErrorResponse.