comparing version before updating

Author: tok-kkk

.circleci/config.yml

@@ -32,7 +32,7 @@ commands:
                     wget https://github.com/tcnksm/ghr/releases/download/v0.13.0/ghr_v0.13.0_linux_amd64.tar.gz
                     tar xvzf ghr_v0.13.0_linux_amd64.tar.gz
                     mv ghr_v0.13.0_linux_amd64/ghr ghr
-                    ./ghr -t ${GITHUB_TOKEN} -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} -c ${CIRCLE_SHA1} -delete $(cat ./VERSION) ./artifacts/
+                    ./ghr -t ${GITHUB_TOKEN} -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} -c ${CIRCLE_SHA1} -soft $(cat ./VERSION) ./artifacts/
 
     test_env:
         description: "Push the binaries to aws s3, so that we can test before releasing."

cmd/exec.go

@@ -12,9 +12,6 @@ import (
 // execScript execute a bash script on a darknode or a set of darknodes by the tags.
 func execScript(ctx *cli.Context) error {
 	name := ctx.Args().First()
-	if err := util.ValidateNodeName(name); err != nil {
-		return err
-	}
 	tags := ctx.String("tags")
 	file := ctx.String("file")
 	script := ctx.String("script")

cmd/switch.go

@@ -20,9 +20,6 @@ var (
 func updateServiceStatus(ctx *cli.Context, cmd string) error {
 	tags := ctx.String("tags")
 	name := ctx.Args().First()
-	if err := util.ValidateNodeName(name); err != nil {
-		return err
-	}
 
 	// Get the script we want to run depends on the command.
 	var script, message string

cmd/update.go

@@ -1,11 +1,19 @@
 package main
 
 import (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"os"
+	"strings"
+	"time"
 
 	"github.com/fatih/color"
+	"github.com/hashicorp/go-version"
 	"github.com/renproject/darknode-cli/util"
 	"github.com/renproject/phi"
 	"github.com/urfave/cli"
@@ -15,23 +23,62 @@ import (
 // to update the config file of the darknode.
 func updateNode(ctx *cli.Context) error {
 	name := ctx.Args().First()
-	if err := util.ValidateNodeName(name); err != nil {
-		return err
-	}
 	tags := ctx.String("tags")
 	version := ctx.String("version")
 
 	nodes, err := util.ParseNodesFromNameAndTags(name, tags)
 	if err != nil {
 		return err
 	}
+	if !compareVersion(nodes, version){
+		return nil
+	}
+
 	errs := make([]error, len(nodes))
 	phi.ParForAll(nodes, func(i int) {
 		errs[i] = updateSingleNode(nodes[i], version)
 	})
 	return util.HandleErrs(errs)
 }
 
+// Compare the current version and target version. Show warning to user if the
+// current version is greater than the target version and confirm with user
+// before updating. Returned boolean indicates whether we want to continue.
+func compareVersion(nodes []string, new string) bool {
+	curVersions := make([]string, len(nodes))
+	phi.ParForAll(nodes, func(i int) {
+		// Ignore the error. Leave the version as empty string if we cannot get its current version.
+		curVersions[i], _ = getCurrentVersion(nodes[i])
+	})
+
+	newVersion, err := version.NewVersion(new)
+	if err != nil {
+		return true
+	}
+	lower := false
+	for i, ver := range curVersions{
+		if ver == ""{
+			continue
+		}
+		curVersion , err := version.NewVersion(ver)
+		if err != nil {
+			continue
+		}
+		if curVersion.GreaterThan(newVersion){
+			color.Red("Darknode [%v] currently running with version %v, and you are trying to downgrade to %v", nodes[i], curVersion.String(), newVersion.String())
+			lower = true
+		}
+	}
+	if lower {
+		color.Red("Do you want to continue?(y/N)")
+		reader := bufio.NewReader(os.Stdin)
+		text, _ := reader.ReadString('\n')
+		input := strings.ToLower(strings.TrimSpace(text))
+		return input == "yes" || input == "y"
+	}
+	return true
+}
+
 func updateSingleNode(name, ver string) error {
 	url := "https://www.github.com/renproject/darknode-release/releases/latest/download/darknode"
 	if ver != "" {
@@ -41,7 +88,7 @@ func updateSingleNode(name, ver string) error {
 		url = fmt.Sprintf("https://github.com/renproject/darknode-release/releases/download/%v/darknode", ver)
 	}
 
-	script := fmt.Sprintf(`rm ~/.darknode/bin/darknode && curl -sL %v > ~/.darknode/bin/darknode && chmod +x ~/.darknode/bin/darknode && systemctl --user restart darknode`, url)
+	script := fmt.Sprintf(`mv ~/.darknode/bin/darknode ~/.darknode/bin/darknode-backup && curl -sL %v > ~/.darknode/bin/darknode && chmod +x ~/.darknode/bin/darknode && systemctl --user restart darknode`, url)
 	if err := util.RemoteRun(name, script); err != nil {
 		return err
 	}
@@ -53,6 +100,46 @@ func updateSingleNode(name, ver string) error {
 	return nil
 }
 
+func getCurrentVersion(name string) (string, error) {
+	request := `{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "ren_queryStat",
+    "params": {}
+}`
+	buf := bytes.NewBuffer([]byte(request))
+	ip, err:= util.IP(name)
+	if err != nil {
+		return"",  err
+	}
+	url := fmt.Sprintf("http://%v:18515", ip)
+	ctx, cancel := context.WithTimeout(context.Background(), 2 * time.Second)
+	defer cancel()
+	req, err:= http.NewRequestWithContext(ctx, "POST", url, buf)
+	if err != nil {
+		return"",  err
+	}
+	client := new(http.Client)
+	resp, err := client.Do(req)
+	if err!= nil {
+		return "", err
+	}
+	response := struct{
+		Result struct{
+			Version string `json:"version"`
+		} `json:"result"`
+	} {}
+
+	if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
+		return"",  err
+	}
+	versionString := strings.Split(response.Result.Version, "-")
+	if len(versionString) < 1 {
+		return "", fmt.Errorf("invalid version = %v", response.Result.Version)
+	}
+	return versionString[0], nil
+}
+
 func validateVersion(version string) error {
 	url := fmt.Sprintf("https://api.github.com/repos/renproject/darknode-release/releases/tags/%v", version)
 	response, err := http.Get(url)

util/node.go

@@ -32,7 +32,7 @@ func ParseNodesFromNameAndTags(name, tags string) ([]string, error) {
 	} else if name == "" && tags != "" {
 		return GetNodesByTags(tags)
 	} else if name != "" && tags == "" {
-		return []string{name}, nil
+		return []string{name}, ValidateNodeName(name)
 	} else {
 		return nil, ErrTooManyArguments
 	}