From 9fad5c7875545597fda13c843c0cd899225c9dce Mon Sep 17 00:00:00 2001 From: nexustar Date: Wed, 1 Sep 2021 16:56:14 +0800 Subject: [PATCH] remove network request before enter component (#1539) --- pkg/environment/env.go | 59 ++++++++++++------------------ pkg/exec/run.go | 48 +++++++++++++++--------- pkg/repository/v1_repository.go | 65 +++++++++++++++++++++++++-------- 3 files changed, 104 insertions(+), 68 deletions(-) diff --git a/pkg/environment/env.go b/pkg/environment/env.go index 88b21f7f32..b01abb7e54 100644 --- a/pkg/environment/env.go +++ b/pkg/environment/env.go @@ -187,13 +187,6 @@ func (env *Environment) downloadComponent(component string, version utils.Versio // SelectInstalledVersion selects the installed versions and the latest release version // will be chosen if there is an empty version func (env *Environment) SelectInstalledVersion(component string, ver utils.Version) (utils.Version, error) { - if ver == utils.NightlyVersionAlias { - var err error - if ver, _, err = env.v1Repo.LatestNightlyVersion(component); err != nil { - return ver, err - } - } - installed, err := env.Profile().InstalledVersions(component) if err != nil { return ver, err @@ -201,7 +194,7 @@ func (env *Environment) SelectInstalledVersion(component string, ver utils.Versi versions := []string{} for _, v := range installed { - vi, err := env.v1Repo.ComponentVersion(component, v, true) + vi, err := env.v1Repo.LocalComponentVersion(component, v, true) if errors.Cause(err) == repository.ErrUnknownVersion { continue } @@ -211,44 +204,40 @@ func (env *Environment) SelectInstalledVersion(component string, ver utils.Versi if vi.Yanked { continue } + if (string(ver) == utils.NightlyVersionAlias) != utils.Version(v).IsNightly() { + continue + } versions = append(versions, v) } + // Reverse sort: v5.0.0-rc,v5.0.0-nightly-20210305,v4.0.11 + sort.Slice(versions, func(i, j int) bool { + return semver.Compare(versions[i], versions[j]) > 0 + }) errInstallFirst := errors.Annotatef(ErrInstallFirst, "use `tiup install %s` to install component `%s` first", component, component) - if len(installed) == 0 { - return ver, errInstallFirst - } - if !ver.IsEmpty() { + if ver.IsEmpty() || string(ver) == utils.NightlyVersionAlias { + var selected utils.Version for _, v := range versions { - if utils.Version(v) == ver { - return ver, nil + if semver.Prerelease(v) == "" { + return utils.Version(v), nil + } + // select prerelease version when there is only prelease version on local + if selected.IsEmpty() { + selected = utils.Version(v) } } - return ver, errInstallFirst - } - - sort.Slice(versions, func(i, j int) bool { - // Reverse sort: v5.0.0-rc,v5.0.0-nightly-20210305,v4.0.11 - return semver.Compare(versions[i], versions[j]) > 0 - }) - - for _, v := range versions { - if utils.Version(v).IsNightly() { - continue + if !selected.IsEmpty() { + return selected, nil } - if semver.Prerelease(v) == "" { - ver = utils.Version(v) - break - } else if ver.IsEmpty() { - ver = utils.Version(v) + } else { + for _, v := range versions { + if utils.Version(v) == ver { + return ver, nil + } } } - - if ver.IsEmpty() { - return ver, errInstallFirst - } - return ver, nil + return ver, errInstallFirst } // DownloadComponentIfMissing downloads the specific version of a component if it is missing diff --git a/pkg/exec/run.go b/pkg/exec/run.go index 0c497550e7..773caffcef 100644 --- a/pkg/exec/run.go +++ b/pkg/exec/run.go @@ -67,6 +67,7 @@ func RunComponent(env *environment.Environment, tag, spec, binPath string, args var sig syscall.Signal sc := make(chan os.Signal, 1) signal.Notify(sc, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT) + updateC := make(chan string) defer func() { for err := range ch { @@ -87,6 +88,35 @@ func RunComponent(env *environment.Environment, tag, spec, binPath string, args ch <- p.Cmd.Wait() }() + // timeout for check update + go func() { + time.Sleep(2 * time.Second) + updateC <- "" + }() + + go func() { + var updateInfo string + if version.IsEmpty() { + latestV, _, err := env.V1Repository().LatestStableVersion(p.Component, false) + if err != nil { + return + } + selectVer, _ := env.SelectInstalledVersion(component, version) + + if semver.Compare(selectVer.String(), latestV.String()) < 0 { + updateInfo = fmt.Sprint(color.YellowString(` +Found %[1]s newer version: + The latest version: %[2]s + Local installed version: %[3]s + Update current component: tiup update %[1]s + Update all components: tiup update --all +`, + p.Component, latestV.String(), selectVer.String())) + } + } + updateC <- updateInfo + }() + select { case s := <-sc: sig = s.(syscall.Signal) @@ -100,6 +130,7 @@ func RunComponent(env *environment.Environment, tag, spec, binPath string, args return nil case err := <-ch: + defer fmt.Print(<-updateC) return errors.Annotatef(err, "run `%s` (wd:%s) failed", p.Exec, p.Dir) } } @@ -151,23 +182,6 @@ func PrepareCommand(p *PrepareCommandParams) (*exec.Cmd, error) { return nil, err } - if p.Version.IsEmpty() && p.CheckUpdate { - latestV, _, err := env.V1Repository().LatestStableVersion(p.Component, false) - if err != nil { - return nil, err - } - if semver.Compare(selectVer.String(), latestV.String()) < 0 { - fmt.Fprintln(os.Stderr, color.YellowString(`Found %[1]s newer version: - - The latest version: %[2]s - Local installed version: %[3]s - Update current component: tiup update %[1]s - Update all components: tiup update --all -`, - p.Component, latestV.String(), selectVer.String())) - } - } - // playground && cluster version must greater than v1.0.0 if (p.Component == "playground" || p.Component == "cluster") && semver.Compare(selectVer.String(), "v1.0.0") < 0 { return nil, errors.Errorf("incompatible component version, please use `tiup update %s` to upgrade to the latest version", p.Component) diff --git a/pkg/repository/v1_repository.go b/pkg/repository/v1_repository.go index e0f9f60107..656493b4de 100644 --- a/pkg/repository/v1_repository.go +++ b/pkg/repository/v1_repository.go @@ -756,6 +756,54 @@ func (r *V1Repository) ComponentVersion(id, ver string, includeYanked bool) (*v1 return vi, nil } +// LocalComponentVersion returns version item of a component from local manifest file +func (r *V1Repository) LocalComponentVersion(id, ver string, includeYanked bool) (*v1manifest.VersionItem, error) { + index := v1manifest.Index{} + _, exists, err := r.Local().LoadManifest(&index) + if err != nil { + return nil, err + } + if !exists { + err = r.ensureManifests() + if err != nil { + return nil, err + } + _, _, err := r.Local().LoadManifest(&index) + + if err != nil { + return nil, err + } + } + + components := index.ComponentList() + comp := components[id] + filename := v1manifest.ComponentManifestFilename(id) + manifest, err := r.Local().LoadComponentManifest(&comp, filename) + if err != nil { + return nil, err + } + + if ver == utils.NightlyVersionAlias { + if !manifest.HasNightly(r.PlatformString()) { + return nil, errors.Annotatef(ErrUnknownVersion, "component %s does not have nightly on %s", id, r.PlatformString()) + } + + ver = manifest.Nightly + } + if ver == "" { + v, _, err := r.LatestStableVersion(id, includeYanked) + if err != nil { + return nil, err + } + ver = v.String() + } + vi := manifest.VersionItem(r.PlatformString(), ver, includeYanked) + if vi == nil { + return nil, errors.Annotatef(ErrUnknownVersion, "version %s on %s for component %s not found", ver, r.PlatformString(), id) + } + return vi, nil +} + // ResolveComponentVersionWithPlatform resolves the latest version of a component that satisfies the constraint func (r *V1Repository) ResolveComponentVersionWithPlatform(id, constraint, platform string) (utils.Version, error) { manifest, err := r.FetchComponentManifest(id, false) @@ -873,23 +921,8 @@ func (r *V1Repository) LatestStableVersion(id string, withYanked bool) (utils.Ve // Support you have install the component, need to get entry from local manifest. // Load the manifest locally only to get then Entry, do not force do something need access mirror. func (r *V1Repository) BinaryPath(installPath string, componentID string, ver string) (string, error) { - component, err := r.updateComponentManifest(componentID, false) - if err != nil { - return "", err - } - - // Always use the newest nightly entry. - // Because the one the user installed may be scraped. - if utils.Version(ver).IsNightly() { - if !component.HasNightly(r.PlatformString()) { - return "", errors.Errorf("the component `%s` on platform %s does not have a nightly version", componentID, r.PlatformString()) - } - - ver = component.Nightly - } - // We need yanked version because we may have installed that version before it was yanked - versionItem, err := r.ComponentVersion(componentID, ver, true) + versionItem, err := r.LocalComponentVersion(componentID, ver, true) if err != nil { return "", err }