Merge pull request #1119 from dagger/revert-1085-feat/check-universe-version

Revert "Improve version checking to also check universe"

cmd/dagger/cmd/mod/get.go

@@ -26,7 +26,8 @@ var getCmd = &cobra.Command{
 		ctx := lg.WithContext(cmd.Context())
 
 		project := common.CurrentProject(ctx)
-		doneCh := common.TrackProjectCommand(ctx, cmd, project, nil, &telemetry.Property{
+		st := common.CurrentEnvironmentState(ctx, project)
+		doneCh := common.TrackProjectCommand(ctx, cmd, project, st, &telemetry.Property{
 			Name:  "packages",
 			Value: args,
 		})

cmd/dagger/cmd/root.go

@@ -48,8 +48,7 @@ func init() {
 		}
 	}
 	rootCmd.PersistentPostRun = func(*cobra.Command, []string) {
-		warnDaggerVersion()
+		warnVersion()
-		warnUniverseVersion()
 	}
 
 	rootCmd.AddCommand(

cmd/dagger/cmd/version.go

@@ -1,68 +1,46 @@
 package cmd
 
 import (
-	"context"
-	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net/http"
 	"os"
 	"path"
 	"runtime"
-	"sort"
 	"strings"
 	"time"
 
 	goVersion "github.com/hashicorp/go-version"
 	"github.com/mitchellh/go-homedir"
-	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"go.dagger.io/dagger/cmd/dagger/cmd/common"
-	"go.dagger.io/dagger/mod"
-	"go.dagger.io/dagger/telemetry"
 	"go.dagger.io/dagger/version"
 	"golang.org/x/term"
 )
 
 const (
-	versionFile     = "~/.config/dagger/version-check"
+	versionFile = "~/.config/dagger/version-check"
-	versionURL      = "https://releases.dagger.io/dagger/latest_version"
+	versionURL  = "https://releases.dagger.io/dagger/latest_version"
-	universeTagsURL = "https://api.github.com/repos/dagger/universe/tags"
 )
 
 var (
-	daggerVersionMessage   = ""
+	versionMessage = ""
-	universeVersionMessage = ""
 )
 
 var versionCmd = &cobra.Command{
 	Use:   "version",
-	Short: "Print dagger and universe version",
+	Short: "Print dagger version",
 	// Disable version hook here to avoid double version check
 	PersistentPreRun:  func(*cobra.Command, []string) {},
 	PersistentPostRun: func(*cobra.Command, []string) {},
 	Args:              cobra.NoArgs,
 	Run: func(cmd *cobra.Command, args []string) {
-		ctx := cmd.Context()
-
-		project := common.CurrentProject(ctx)
-		doneCh := common.TrackProjectCommand(ctx, cmd, project, nil, &telemetry.Property{
-			Name:  "version",
-			Value: args,
-		})
-
 		fmt.Printf("dagger %s (%s) %s/%s\n",
 			version.Version,
 			version.Revision,
 			runtime.GOOS, runtime.GOARCH,
 		)
 
-		universeVersion, err := getUniverseCurrentVersion()
-		if err == nil {
-			fmt.Printf("universe %s\n", universeVersion.Original())
-		}
-
 		if check := viper.GetBool("check"); check {
 			versionFilePath, err := homedir.Expand(versionFile)
 			if err != nil {
@@ -71,20 +49,15 @@ var versionCmd = &cobra.Command{
 
 			_ = os.Remove(versionFilePath)
 			checkVersion()
-			if !warnDaggerVersion() {
+			if !warnVersion() {
 				fmt.Println("dagger is up to date.")
 			}
-			if !warnUniverseVersion() {
-				fmt.Println("universe is up to date.")
-			}
 		}
-
-		<-doneCh
 	},
 }
 
 func init() {
-	versionCmd.Flags().Bool("check", false, "check if dagger and universe are up to date")
+	versionCmd.Flags().Bool("check", false, "check if dagger is up to date")
 
 	if err := viper.BindPFlags(versionCmd.Flags()); err != nil {
 		panic(err)
@@ -114,7 +87,7 @@ func isCheckOutdated(path string) bool {
 	return !time.Now().Before(nextCheck)
 }
 
-func getDaggerLatestVersion(currentVersion *goVersion.Version) (*goVersion.Version, error) {
+func getLatestVersion(currentVersion *goVersion.Version) (*goVersion.Version, error) {
 	req, err := http.NewRequest("GET", versionURL, nil)
 	if err != nil {
 		return nil, err
@@ -139,136 +112,15 @@ func getDaggerLatestVersion(currentVersion *goVersion.Version) (*goVersion.Versi
 	return goVersion.NewVersion(latestVersion)
 }
 
-// Compare dagger version with the latest release online
+// Compare the binary version with the latest version online
-// Return the latest dagger version if current is outdated
+// Return the latest version if current is outdated
-func isDaggerVersionLatest() (string, error) {
+func isVersionLatest() (string, error) {
 	currentVersion, err := goVersion.NewVersion(version.Version)
 	if err != nil {
 		return "", err
 	}
 
-	latestVersion, err := getDaggerLatestVersion(currentVersion)
+	latestVersion, err := getLatestVersion(currentVersion)
-	if err != nil {
-		return "", err
-	}
-
-	if currentVersion.LessThan(latestVersion) {
-		return latestVersion.String(), nil
-	}
-	return "", nil
-}
-
-// Call https://api.github.com/repos/dagger/universe/tags
-func listUniverseTags() ([]string, error) {
-	req, err := http.NewRequest("GET", universeTagsURL, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-
-	defer resp.Body.Close()
-	data, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	var tagsDTO []struct {
-		Name string `json:"name"`
-	}
-
-	err = json.Unmarshal(data, &tagsDTO)
-	if err != nil {
-		return nil, err
-	}
-
-	// Reduce DTO to simple string array
-	tags := []string{}
-	for _, tag := range tagsDTO {
-		tags = append(tags, tag.Name)
-	}
-
-	return tags, nil
-}
-
-func getUniverseLatestVersion() (*goVersion.Version, error) {
-	tags, err := listUniverseTags()
-	if err != nil {
-		return nil, err
-	}
-
-	// Get latest available version
-	constraint, err := goVersion.NewConstraint(mod.UniverseVersionConstraint)
-	if err != nil {
-		return nil, err
-	}
-
-	// Retrieve the latest supported universe version
-	var versions []*goVersion.Version
-	for _, tag := range tags {
-		if !strings.HasPrefix(tag, "v") {
-			continue
-		}
-
-		v, err := goVersion.NewVersion(tag)
-		if err != nil {
-			continue
-		}
-
-		if constraint.Check(v) {
-			versions = append(versions, v)
-		}
-	}
-
-	if len(versions) == 0 {
-		return nil, fmt.Errorf("universe repository has no version matching the required version")
-	}
-
-	sort.Sort(sort.Reverse(goVersion.Collection(versions)))
-	return versions[0], nil
-}
-
-// Retrieve the current universe version from `cue.mod/dagger.mod`
-func getUniverseCurrentVersion() (*goVersion.Version, error) {
-	project := common.CurrentProject(context.Background())
-	pathMod := path.Join(project.Path, mod.ModFilePath)
-	fileMod, err := os.Open(pathMod)
-	if err != nil {
-		return nil, err
-	}
-
-	defer fileMod.Close()
-	data, err := ioutil.ReadAll(fileMod)
-	if err != nil {
-		return nil, err
-	}
-
-	currentVersion := ""
-	modules := strings.Split(string(data), "\n")
-	for _, module := range modules {
-		if !strings.HasPrefix(module, "alpha.dagger.io") {
-			continue
-		}
-
-		// Retrieve tag
-		tag := strings.Split(module, " ")
-		currentVersion = tag[1]
-	}
-	return goVersion.NewVersion(currentVersion)
-}
-
-// Compare the universe version with the latest version online
-// Return the latest universe version if the current is outdated
-func isUniverseVersionLatest() (string, error) {
-	currentVersion, err := getUniverseCurrentVersion()
-	if err != nil {
-		return "", err
-	}
-
-	latestVersion, err := getUniverseLatestVersion()
 	if err != nil {
 		return "", err
 	}
@@ -280,11 +132,8 @@ func isUniverseVersionLatest() (string, error) {
 }
 
 func checkVersion() {
-	lg := log.Ctx(context.Background()).With().Logger()
-
 	if version.Version == version.DevelopmentVersion {
 		// running devel version
-		lg.Debug().Msg("version checking ignored on development version")
 		return
 	}
 
@@ -305,28 +154,14 @@ func checkVersion() {
 		return
 	}
 
-	// Check version
-	lg.Debug().Msg("check for universe latest version...")
-	universeLatestVersion, err := isUniverseVersionLatest()
-	if err != nil {
-		lg.Debug().Msg(err.Error())
-		return
-	}
-
-	if universeLatestVersion != "" {
-		universeVersionMessage = fmt.Sprintf("A new version of universe is available (%s), please run 'dagger mod get github.com/dagger/universe/stdlib'", universeLatestVersion)
-	}
-
 	// Check timestamp
-	lg.Debug().Msg("check for dagger latest version...")
+	latestVersion, err := isVersionLatest()
-	daggerLatestVersion, err := isDaggerVersionLatest()
 	if err != nil {
-		lg.Debug().Msg(err.Error())
 		return
 	}
 
-	if daggerLatestVersion != "" {
+	if latestVersion != "" {
-		daggerVersionMessage = fmt.Sprintf("\nA new version of dagger is available (%s), please go to https://github.com/dagger/dagger/doc/install.md for instructions.", daggerLatestVersion)
+		versionMessage = fmt.Sprintf("\nA new version is available (%s), please go to https://github.com/dagger/dagger/doc/install.md for instructions.", latestVersion)
 	}
 
 	// Update check timestamps file
@@ -334,8 +169,8 @@ func checkVersion() {
 	ioutil.WriteFile(path.Join(versionFilePath), []byte(now), 0600)
 }
 
-func warnDaggerVersion() bool {
+func warnVersion() bool {
-	if daggerVersionMessage == "" {
+	if versionMessage == "" {
 		return false
 	}
 
@@ -350,15 +185,6 @@ func warnDaggerVersion() bool {
 	}
 
 	// Print default message
-	fmt.Println(daggerVersionMessage)
+	fmt.Println(versionMessage)
-	return true
-}
-
-func warnUniverseVersion() bool {
-	if universeVersionMessage == "" {
-		return false
-	}
-
-	fmt.Println(universeVersionMessage)
 	return true
 }

mod/file.go

@@ -17,7 +17,7 @@ import (
 )
 
 const (
-	ModFilePath  = "./cue.mod/dagger.mod"
+	modFilePath  = "./cue.mod/dagger.mod"
 	sumFilePath  = "./cue.mod/dagger.sum"
 	lockFilePath = "./cue.mod/dagger.lock"
 	destBasePath = "./cue.mod/pkg"
@@ -31,7 +31,7 @@ type file struct {
 }
 
 func readPath(workspacePath string) (*file, error) {
-	pMod := path.Join(workspacePath, ModFilePath)
+	pMod := path.Join(workspacePath, modFilePath)
 	fMod, err := os.Open(pMod)
 	if err != nil {
 		if !errors.Is(err, fs.ErrNotExist) {
@@ -276,7 +276,7 @@ func (f *file) write() error {
 		bMod.WriteString(fmt.Sprintf("%s %s\n", r.fullPath(), r.version))
 	}
 
-	err := ioutil.WriteFile(path.Join(f.workspacePath, ModFilePath), bMod.Bytes(), 0600)
+	err := ioutil.WriteFile(path.Join(f.workspacePath, modFilePath), bMod.Bytes(), 0600)
 	if err != nil {
 		return err
 	}