add cli upgraded supported for command up (#2405)

* add cli upgraded supported for command up

* improve unit case for package internal/mutex

* v2.3.1

Co-authored-by: houseme <housemecn@gmail.com>

cmd/gf/internal/cmd/cmd_fix.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"context"
+	"github.com/gogf/gf/v2/os/gproc"
 
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 	"github.com/gogf/gf/v2/errors/gerror"
@@ -19,8 +20,9 @@ type cFix struct {
 }
 
 type cFixInput struct {
-	g.Meta `name:"fix"`
+	g.Meta  `name:"fix"`
-	Path   string `name:"path" brief:"directory path, it uses current working directory in default"`
+	Path    string `name:"path"    short:"p" brief:"directory path, it uses current working directory in default"`
+	Version string `name:"version" short:"v" brief:"custom specified version to fix, leave it empty to auto detect"`
 }
 
 type cFixOutput struct{}
@@ -31,38 +33,45 @@ type cFixItem struct {
 }
 
 func (c cFix) Index(ctx context.Context, in cFixInput) (out *cFixOutput, err error) {
-	mlog.Print(`start auto fixing...`)
+
-	defer mlog.Print(`done!`)
 	if in.Path == "" {
 		in.Path = gfile.Pwd()
 	}
+	if in.Version == "" {
+		in.Version, err = c.autoDetectVersion(in)
+		if err != nil {
+			mlog.Fatal(err)
+		}
+		if in.Version == "" {
+			mlog.Print(`no GoFrame usage found, exit fixing`)
+			return
+		}
+		mlog.Debugf(`current GoFrame version auto detect "%s"`, in.Version)
+	}
+
+	if !gproc.IsChild() {
+		mlog.Printf(`start auto fixing directory path "%s"...`, in.Path)
+		defer mlog.Print(`done!`)
+	}
+
 	err = c.doFix(in)
 	return
 }
 
 func (c cFix) doFix(in cFixInput) (err error) {
-	version, err := c.getVersion(in)
-	if err != nil {
-		mlog.Fatal(err)
-	}
-	if version == "" {
-		mlog.Print(`no GoFrame usage found, exit fixing`)
-		return
-	}
-	mlog.Debugf(`current GoFrame version found "%s"`, version)
 
 	var items = []cFixItem{
 		{Version: "v2.3", Func: c.doFixV23},
 	}
 	for _, item := range items {
-		if gstr.CompareVersionGo(version, item.Version) < 0 {
+		if gstr.CompareVersionGo(in.Version, item.Version) < 0 {
 			mlog.Debugf(
-				`current GoFrame version "%s" is lesser than "%s", nothing to do`,
+				`current GoFrame or contrib package version "%s" is lesser than "%s", nothing to do`,
-				version, item.Version,
+				in.Version, item.Version,
 			)
 			continue
 		}
-		if err = item.Func(version); err != nil {
+		if err = item.Func(in.Version); err != nil {
 			return
 		}
 	}
@@ -87,7 +96,7 @@ func (c cFix) doFixV23(version string) error {
 	return gfile.ReplaceDirFunc(replaceFunc, ".", "*.go", true)
 }
 
-func (c cFix) getVersion(in cFixInput) (string, error) {
+func (c cFix) autoDetectVersion(in cFixInput) (string, error) {
 	var (
 		err     error
 		path    = gfile.Join(in.Path, "go.mod")

cmd/gf/internal/cmd/cmd_up.go

@@ -3,6 +3,9 @@ package cmd
 import (
 	"context"
 	"fmt"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
+	"github.com/gogf/gf/v2/container/gset"
+	"runtime"
 
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 	"github.com/gogf/gf/v2/frame/g"
@@ -26,7 +29,7 @@ const (
 gf up
 gf up -a
 gf up -c
-gf up -f -c
+gf up -cf
 `
 )
 
@@ -39,8 +42,8 @@ func init() {
 type cUpInput struct {
 	g.Meta `name:"up"  config:"gfcli.up"`
 	All    bool `name:"all" short:"a" brief:"upgrade both version and cli, auto fix codes" orphan:"true"`
-	Fix    bool `name:"fix" short:"f" brief:"auto fix codes" orphan:"true"`
+	Cli    bool `name:"cli" short:"c" brief:"also upgrade CLI tool" orphan:"true"`
-	Cli    bool `name:"cli" short:"c" brief:"also upgrade CLI tool (not supported yet)" orphan:"true"`
+	Fix    bool `name:"fix" short:"f" brief:"auto fix codes(it only make sense if cli is to be upgraded)" orphan:"true"`
 }
 
 type cUpOutput struct{}
@@ -48,28 +51,57 @@ type cUpOutput struct{}
 func (c cUp) Index(ctx context.Context, in cUpInput) (out *cUpOutput, err error) {
 	defer func() {
 		if err == nil {
-			mlog.Print(`done!`)
+			mlog.Print()
+			mlog.Print(`👏congratulations! you've upgraded to the latest version of GoFrame! enjoy it!👏`)
+			mlog.Print()
 		}
 	}()
 
+	var doUpgradeVersionOut *doUpgradeVersionOutput
 	if in.All {
 		in.Cli = true
 		in.Fix = true
 	}
-	if err = c.doUpgradeVersion(ctx, in); err != nil {
+	if doUpgradeVersionOut, err = c.doUpgradeVersion(ctx, in); err != nil {
 		return nil, err
 	}
-	//if in.Cli {
+
-	//	if err = c.doUpgradeCLI(ctx); err != nil {
+	if in.Cli {
-	//		return nil, err
+		if err = c.doUpgradeCLI(ctx); err != nil {
-	//	}
+			return nil, err
-	//}
+		}
+	}
+
+	if in.Cli && in.Fix {
+		if doUpgradeVersionOut != nil && len(doUpgradeVersionOut.Items) > 0 {
+			upgradedPathSet := gset.NewStrSet()
+			for _, item := range doUpgradeVersionOut.Items {
+				if !upgradedPathSet.AddIfNotExist(item.DirPath) {
+					continue
+				}
+				if err = c.doAutoFixing(ctx, item.DirPath, item.Version); err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
 	return
 }
 
-func (c cUp) doUpgradeVersion(ctx context.Context, in cUpInput) (err error) {
+type doUpgradeVersionOutput struct {
-	mlog.Print(`start upgrading version...`)
+	Items []doUpgradeVersionOutputItem
+}
 
+type doUpgradeVersionOutputItem struct {
+	DirPath string
+	Version string
+}
+
+func (c cUp) doUpgradeVersion(ctx context.Context, in cUpInput) (out *doUpgradeVersionOutput, err error) {
+	mlog.Print(`start upgrading version...`)
+	out = &doUpgradeVersionOutput{
+		Items: make([]doUpgradeVersionOutputItem, 0),
+	}
 	type Package struct {
 		Name    string
 		Version string
@@ -103,13 +135,10 @@ func (c cUp) doUpgradeVersion(ctx context.Context, in cUpInput) (err error) {
 				if err = gproc.ShellRun(ctx, command); err != nil {
 					return
 				}
-				mlog.Print()
+				out.Items = append(out.Items, doUpgradeVersionOutputItem{
-			}
+					DirPath: dir,
-			if in.Fix {
+					Version: pkg.Version,
-				if err = c.doAutoFixing(ctx, dir); err != nil {
+				})
-					return err
-				}
-				mlog.Print()
 			}
 			return
 		}
@@ -122,15 +151,51 @@ func (c cUp) doUpgradeVersion(ctx context.Context, in cUpInput) (err error) {
 	}
 }
 
+// doUpgradeCLI downloads the new version binary with process.
 func (c cUp) doUpgradeCLI(ctx context.Context) (err error) {
 	mlog.Print(`start upgrading cli...`)
+	var (
+		downloadUrl = fmt.Sprintf(
+			`https://github.com/gogf/gf/releases/latest/download/gf_%s_%s`,
+			runtime.GOOS, runtime.GOARCH,
+		)
+		localSaveFilePath = gfile.SelfPath() + "~"
+	)
+	mlog.Printf(`start downloading "%s" to "%s", it may take some time`, downloadUrl, localSaveFilePath)
+	err = utils.HTTPDownloadFileWithPercent(downloadUrl, localSaveFilePath)
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		mlog.Printf(`new version cli binary is successfully installed to "%s"`, gfile.SelfPath())
+		mlog.Printf(`remove temporary buffer file "%s"`, localSaveFilePath)
+		_ = gfile.Remove(localSaveFilePath)
+	}()
+
+	// It fails if file not exist or its size is less than 1MB.
+	if !gfile.Exists(localSaveFilePath) || gfile.Size(localSaveFilePath) < 1024*1024 {
+		mlog.Fatalf(`download "%s" to "%s" failed`, downloadUrl, localSaveFilePath)
+	}
+
+	// It replaces self binary with new version cli binary.
+	switch runtime.GOOS {
+	case "windows":
+		if err := gfile.Rename(localSaveFilePath, gfile.SelfPath()); err != nil {
+			mlog.Fatalf(`install failed: %s`, err.Error())
+		}
+
+	default:
+		if err := gfile.PutBytes(gfile.SelfPath(), gfile.GetBytes(localSaveFilePath)); err != nil {
+			mlog.Fatalf(`install failed: %s`, err.Error())
+		}
+	}
 	return
 }
 
-func (c cUp) doAutoFixing(ctx context.Context, dirPath string) (err error) {
+func (c cUp) doAutoFixing(ctx context.Context, dirPath string, version string) (err error) {
-	mlog.Printf(`auto fixing path "%s"...`, dirPath)
+	mlog.Printf(`auto fixing directory path "%s" from version "%s" ...`, dirPath, version)
-	err = cFix{}.doFix(cFixInput{
+	command := fmt.Sprintf(`gf fix -p %s`, dirPath)
-		Path: dirPath,
+	_ = gproc.ShellRun(ctx, command)
-	})
 	return
 }

cmd/gf/internal/utility/utils/utils.go

@@ -1,9 +1,16 @@
 package utils
 
 import (
+	"fmt"
+	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/text/gstr"
 	"golang.org/x/tools/imports"
+	"io"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
 
 	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
@@ -43,3 +50,88 @@ func IsFileDoNotEdit(filePath string) bool {
 	}
 	return gstr.Contains(gfile.GetContents(filePath), consts.DoNotEditKey)
 }
+
+// HTTPDownloadFileWithPercent downloads target url file to local path with percent process printing.
+func HTTPDownloadFileWithPercent(url string, localSaveFilePath string) error {
+	start := time.Now()
+	out, err := os.Create(localSaveFilePath)
+	if err != nil {
+		return gerror.Wrapf(err, `download "%s" to "%s" failed`, url, localSaveFilePath)
+	}
+	defer out.Close()
+
+	headResp, err := http.Head(url)
+	if err != nil {
+		return gerror.Wrapf(err, `download "%s" to "%s" failed`, url, localSaveFilePath)
+	}
+	defer headResp.Body.Close()
+
+	size, err := strconv.Atoi(headResp.Header.Get("Content-Length"))
+	if err != nil {
+		return gerror.Wrap(err, "retrieve Content-Length failed")
+	}
+	doneCh := make(chan int64)
+
+	go doPrintDownloadPercent(doneCh, localSaveFilePath, int64(size))
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return gerror.Wrapf(err, `download "%s" to "%s" failed`, url, localSaveFilePath)
+	}
+	defer resp.Body.Close()
+
+	wroteBytesCount, err := io.Copy(out, resp.Body)
+	if err != nil {
+		return gerror.Wrapf(err, `download "%s" to "%s" failed`, url, localSaveFilePath)
+	}
+
+	doneCh <- wroteBytesCount
+	elapsed := time.Since(start)
+	if elapsed > time.Minute {
+		mlog.Printf(`download completed in %.0fm`, float64(elapsed)/float64(time.Minute))
+	} else {
+		mlog.Printf(`download completed in %.0fs`, elapsed.Seconds())
+	}
+
+	return nil
+}
+
+func doPrintDownloadPercent(doneCh chan int64, localSaveFilePath string, total int64) {
+	var (
+		stop           = false
+		lastPercentFmt string
+	)
+	for {
+		select {
+		case <-doneCh:
+			stop = true
+
+		default:
+			file, err := os.Open(localSaveFilePath)
+			if err != nil {
+				mlog.Fatal(err)
+			}
+			fi, err := file.Stat()
+			if err != nil {
+				mlog.Fatal(err)
+			}
+			size := fi.Size()
+			if size == 0 {
+				size = 1
+			}
+			var (
+				percent    = float64(size) / float64(total) * 100
+				percentFmt = fmt.Sprintf(`%.0f`, percent) + "%"
+			)
+			if lastPercentFmt != percentFmt {
+				lastPercentFmt = percentFmt
+				mlog.Print(percentFmt)
+			}
+		}
+
+		if stop {
+			break
+		}
+		time.Sleep(time.Second)
+	}
+}

internal/mutex/mutex_z_unit_test.go

@@ -45,56 +45,58 @@ func TestSafeMutex(t *testing.T) {
 		go func() {
 			safeLock.Lock()
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(1000 * time.Millisecond)
 			array.Append(1)
 			safeLock.Unlock()
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			safeLock.Lock()
 			array.Append(1)
-			time.Sleep(200 * time.Millisecond)
+			time.Sleep(2000 * time.Millisecond)
 			array.Append(1)
 			safeLock.Unlock()
 		}()
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(500 * time.Millisecond)
 		t.Assert(array.Len(), 1)
-		time.Sleep(80 * time.Millisecond)
+		time.Sleep(800 * time.Millisecond)
 		t.Assert(array.Len(), 3)
-		time.Sleep(100 * time.Millisecond)
+		time.Sleep(1000 * time.Millisecond)
 		t.Assert(array.Len(), 3)
-		time.Sleep(100 * time.Millisecond)
+		time.Sleep(1000 * time.Millisecond)
 		t.Assert(array.Len(), 4)
 	})
 }
 
 func TestUnsafeMutex(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		unsafeLock := mutex.New()
+		var (
-		array := garray.New(true)
+			unsafeLock = mutex.New()
+			array      = garray.New(true)
+		)
 
 		go func() {
 			unsafeLock.Lock()
 			array.Append(1)
-			time.Sleep(100 * time.Millisecond)
+			time.Sleep(1000 * time.Millisecond)
 			array.Append(1)
 			unsafeLock.Unlock()
 		}()
 		go func() {
-			time.Sleep(10 * time.Millisecond)
+			time.Sleep(100 * time.Millisecond)
 			unsafeLock.Lock()
 			array.Append(1)
-			time.Sleep(200 * time.Millisecond)
+			time.Sleep(2000 * time.Millisecond)
 			array.Append(1)
 			unsafeLock.Unlock()
 		}()
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(500 * time.Millisecond)
 		t.Assert(array.Len(), 2)
-		time.Sleep(100 * time.Millisecond)
+		time.Sleep(1000 * time.Millisecond)
 		t.Assert(array.Len(), 3)
-		time.Sleep(50 * time.Millisecond)
+		time.Sleep(500 * time.Millisecond)
 		t.Assert(array.Len(), 3)
-		time.Sleep(100 * time.Millisecond)
+		time.Sleep(1000 * time.Millisecond)
 		t.Assert(array.Len(), 4)
 	})
 }

version.go

@@ -2,5 +2,5 @@ package gf
 
 const (
 	// VERSION  is the current GoFrame version.
-	VERSION = "v2.3.0"
+	VERSION = "v2.3.1"
 )