Merge pull request #36 from fossas/feat/selfupdate

feat(update): #23 add fossa update command

Author: elldritch

.circleci/config.yml

@@ -6,34 +6,42 @@ jobs:
     working_directory: /home/fossa/go/src/github.com/fossas/fossa-cli
     environment:
       TEST_RESULTS: /tmp/test-results
+      ARTIFACTS: /tmp/artifacts
     steps:
       - checkout
-      - run: mkdir -p $TEST_RESULTS
+      - run:
+          name: Make folders
+          command: |
+            mkdir -p $TEST_RESULTS
+            mkdir -p $ARTIFACTS
       - restore_cache:
           keys:
-            - gopkg-cache-{{ checksum "Gopkg.lock" }}
+            - v1-gopkg-cache-{{ checksum "Gopkg.lock" }}
       - run:
           name: Compile CLI
           command: |
             # Invalidate pkg cache for FOSSA CLI binary
-            rm -rf pkg/linux_amd64/github.com/fossas/fossa-cli
+            rm -rf /home/fossa/go/pkg/linux_amd64/github.com/fossas/fossa-cli
             dep ensure
             make
+      - save_cache:
+          key: v1-gopkg-cache-{{ checksum "Gopkg.lock" }}
+          paths:
+            - "/home/fossa/go/pkg"
+            - "/home/fossa/go/src/github.com/fossas/fossa-cli/vendor"
       - run:
           name: Run integration test
           command: |
             go test ./build
       - run:
           name: Run FOSSA build
           command: |
-            fossa
+            fossa --debug 2>$ARTIFACTS/fossa-build-stderr
       - run:
           name: Run FOSSA license check
           command: |
-            fossa test
-      - save_cache:
-          key: gopkg-cache-{{ checksum "Gopkg.lock" }}
-          paths:
-            - "/home/fossa/go/pkg"
+            fossa test --debug 2>$ARTIFACTS/fossa-test-stderr
       - store_test_results:
           path: /tmp/test-results
+      - store_artifacts:
+          path: /tmp/artifacts

Gopkg.lock

@@ -496,10 +496,12 @@ func (builder *GoBuilder) Analyze(m module.Module, allowUnresolved bool) ([]modu
 	depSet := make(map[GoPkg]bool)
 	projectImports := strings.TrimPrefix(projectFolder, filepath.Join(os.Getenv("GOPATH"), "src")+string(filepath.Separator))
 	for _, dep := range traced {
+		goLogger.Debugf("Resolving raw import: %s", dep.ImportPath)
 		// Strip out `/vendor/` weirdness in import paths.
 		const vendorPrefix = "/vendor/"
 		vendoredPathSections := strings.Split(dep.ImportPath, vendorPrefix)
 		importPath := vendoredPathSections[len(vendoredPathSections)-1]
+		goLogger.Debugf("Resolving import: %s", importPath)
 
 		// Get revisions (often these are scoped to repository, not package)
 		project, err := findRevision(lockfileVersions, importPath)
@@ -518,7 +520,7 @@ func (builder *GoBuilder) Analyze(m module.Module, allowUnresolved bool) ([]modu
 				goLogger.Debugf("$GOPATH: %#v", os.Getenv("GOPATH"))
 				goLogger.Debugf("Project folder relative to $GOPATH: %#v", projectImports)
 				goLogger.Debugf("Lockfile versions: %#v", lockfileVersions)
-				return nil, fmt.Errorf("could not resolve import: %#v", dep.ImportPath)
+				return nil, fmt.Errorf("could not resolve import: %#v", importPath)
 			}
 		} else {
 			depSet[GoPkg{ImportPath: project, Version: lockfileVersions[project], isInternal: dep.isInternal}] = true

build/golang.go

@@ -3,26 +3,48 @@ package main
 import (
 	"bytes"
 	"fmt"
+	"io"
 	"io/ioutil"
+	"net"
 	"net/http"
+	"net/url"
+	"time"
 
 	logging "github.com/op/go-logging"
 )
 
 var commonLogger = logging.MustGetLogger("common")
+var client = http.Client{
+	Timeout: 10 * time.Second,
+}
+
+func isTimeout(err error) bool {
+	if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+		return true
+	}
+	if urlErr, ok := err.(*url.Error); ok && urlErr.Err == io.EOF {
+		return true
+	}
+	return false
+}
 
 // Common utilities among commands
-func makeAPIRequest(method, url, apiKey string, payload []byte) ([]byte, error) {
-	commonLogger.Debugf("Making API request %#v %#v %#v %#v", method, url, apiKey, string(payload))
-	req, err := http.NewRequest(method, url, bytes.NewReader(payload))
+func makeAPIRequest(method, endpoint, apiKey string, payload []byte) ([]byte, error) {
+	commonLogger.Debugf("Making API request %#v %#v %#v %#v", method, endpoint, apiKey, string(payload))
+	req, err := http.NewRequest(method, endpoint, bytes.NewReader(payload))
 	if err != nil {
 		return nil, fmt.Errorf("could not construct API HTTP request: %s", err.Error())
 	}
+	req.Close = true
 	req.Header.Set("Authorization", "token "+apiKey)
 	req.Header.Set("Content-Type", "application/json")
 
-	resp, err := http.DefaultClient.Do(req)
+	resp, err := client.Do(req)
 	if err != nil {
+		if isTimeout(err) {
+			commonLogger.Debugf("API request timed out")
+			return nil, err
+		}
 		return nil, fmt.Errorf("failed to send API HTTP request: %s", err.Error())
 	}
 	defer resp.Body.Close()

cmd/fossa/common.go

@@ -253,7 +253,7 @@ func initialize(c *cli.Context) (cliConfig, error) {
 	} else {
 		formatter := logging.MustStringFormatter(`%{color}%{level}%{color:reset} %{message}`)
 		stderrBackend := logging.AddModuleLevel(logging.NewBackendFormatter(logging.NewLogBackend(os.Stderr, "", 0), formatter))
-		stderrBackend.SetLevel(logging.WARNING, "")
+		stderrBackend.SetLevel(logging.INFO, "")
 		logging.SetBackend(stderrBackend)
 	}
 

cmd/fossa/config.go

@@ -110,6 +110,14 @@ func main() {
 				cli.BoolFlag{Name: "debug", Usage: debugUsage},
 			},
 		},
+		{
+			Name:   "update",
+			Usage:  "Updates `fossa` to the latest version",
+			Action: updateCmd,
+			Flags: []cli.Flag{
+				cli.BoolFlag{Name: "debug", Usage: debugUsage},
+			},
+		},
 	}
 
 	app.Run(os.Args)
@@ -244,6 +252,10 @@ func defaultCmd(c *cli.Context) {
 		mainLogger.Fatalf("Could not load configuration: %s", err.Error())
 	}
 
+	if ok, err := checkUpdate(); err == nil && ok {
+		mainLogger.Noticef("An update is available for this CLI; run `fossa update` to get the latest version.")
+	}
+
 	if len(config.modules) == 0 {
 		mainLogger.Fatal("No modules specified for analysis.")
 	}

cmd/fossa/main.go

@@ -45,6 +45,9 @@ func getBuild(endpoint, apiKey, project, revision string) (buildResponse, error)
 
 	testLogger.Debugf("Making Builds API request to: %#v", url)
 	res, err := makeAPIRequest(http.MethodPut, url, apiKey, nil)
+	if isTimeout(err) {
+		return buildResponse{}, err
+	}
 	if err != nil {
 		return buildResponse{}, fmt.Errorf("could not make FOSSA build request: %s", err)
 	}
@@ -104,6 +107,10 @@ func doTest(s *spinner.Spinner, race chan testResult, endpoint, apiKey, project,
 buildLoop:
 	for {
 		build, err := getBuild(endpoint, apiKey, project, revision)
+		if isTimeout(err) {
+			time.Sleep(pollRequestDelay)
+			continue
+		}
 		if err != nil {
 			race <- testResult{err: err, issues: nil}
 			return

cmd/fossa/test.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/blang/semver"
+	logging "github.com/op/go-logging"
+	"github.com/rhysd/go-github-selfupdate/selfupdate"
+	"github.com/urfave/cli"
+)
+
+const updateEndpoint = "fossas/fossa-cli"
+
+var updateLogger = logging.MustGetLogger("update")
+
+func getSemver(v string) string {
+	if v[0] != 'v' {
+		return ""
+	}
+	return v[1:]
+}
+
+func checkUpdate() (bool, error) {
+	latest, found, err := selfupdate.DetectLatest(updateEndpoint)
+	if err != nil {
+		return false, fmt.Errorf("could not check for updates: %s", err.Error())
+	}
+
+	parsedVersion := getSemver(version)
+	updateLogger.Debugf("checking version for updates (%s -> %s)", version, parsedVersion)
+	v, err := semver.Parse(parsedVersion)
+	if err != nil {
+		return false, errors.New("invalid version (are you using a development binary?)")
+	}
+	if !found || latest.Version.Equals(v) {
+		return false, nil
+	}
+	return true, nil
+}
+
+func doSelfUpdate() error {
+	parsedVersion := getSemver(version)
+	v, err := semver.Parse(parsedVersion)
+	if err != nil {
+		return errors.New("invalid version (are you using a development binary?)")
+	}
+	latest, err := selfupdate.UpdateSelf(v, updateEndpoint)
+	if err != nil {
+		return fmt.Errorf("could not update: %s", err.Error())
+	}
+	if latest.Version.Equals(v) {
+		return errors.New("no update required")
+	}
+	updateLogger.Debugf("updating binary versions (%s -> %s)", version, latest.Version)
+	return nil
+}
+
+func updateCmd(c *cli.Context) {
+	ok, err := checkUpdate()
+	if err != nil {
+		updateLogger.Fatalf("Unable to update: %s", err.Error())
+	}
+	if !ok {
+		updateLogger.Fatalf("No updates available")
+	}
+
+	if err := doSelfUpdate(); err != nil {
+		updateLogger.Fatalf("Update failed: %s", err.Error())
+	}
+
+	updateLogger.Info("fossa has been updated; run `fossa -v` to view the current version")
+}

cmd/fossa/update.go

@@ -142,12 +142,14 @@ func doUpload(config cliConfig, results []normalizedModule) (string, error) {
 	analysisLogger.Debugf("Sending build data to <%#v>", postURL)
 
 	req, _ := http.NewRequest("POST", postURL, bytes.NewReader(buildData))
+	req.Close = true
+
 	req.Header.Set("Authorization", "token "+config.apiKey)
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return "", fmt.Errorf("could not begin upload: %#v", err)
+		return "", fmt.Errorf("could not begin upload: %s", err.Error())
 	}
 	defer resp.Body.Close()
 	responseBytes, _ := ioutil.ReadAll(resp.Body)