mirror of
https://github.com/jesseduffield/lazygit.git
synced 2026-11-21 04:46:29 +03:00
The option "background" exists, but since the background check never ran, it never did anything. If lazygit can update itself, i.e. it was installed from one of our release archives into a folder that we can write to, install a new version as soon as a check finds it. The new version takes effect the next time the user starts lazygit; until then, the note in the bottom-right corner says so. If installing fails, we try again in an hour, and the user gets the usual reminders in the meantime. For all other installs, "background" works like "prompt". Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
406 lines
12 KiB
Go
406 lines
12 KiB
Go
package updates
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"github.com/jesseduffield/lazygit/pkg/common"
|
|
"github.com/jesseduffield/lazygit/pkg/config"
|
|
"github.com/jesseduffield/lazygit/pkg/constants"
|
|
"github.com/jesseduffield/lazygit/pkg/gui/types"
|
|
)
|
|
|
|
const (
|
|
checkTimeout = 30 * time.Second
|
|
installTimeout = 10 * time.Minute
|
|
|
|
// How long we wait before showing the update menu again after the user
|
|
// responded to it
|
|
reminderInterval = 24 * time.Hour
|
|
// How long an update must have been available before we show the update
|
|
// menu at startup, if the user hasn't responded to it otherwise
|
|
startupReminderDelay = 7 * 24 * time.Hour
|
|
// How long after lazygit started we use ReminderMenuAtStartup
|
|
startupPeriod = time.Minute
|
|
)
|
|
|
|
// The ways in which lazygit reminds the user of an available update
|
|
type Reminder int
|
|
|
|
const (
|
|
// Show the update menu after the user hasn't used lazygit for a while
|
|
ReminderMenuWhenIdle Reminder = iota
|
|
// Show the update menu at startup. We only do this if the user hasn't
|
|
// responded to the menu for a long time, e.g. because they never leave
|
|
// lazygit idle.
|
|
ReminderMenuAtStartup
|
|
// Print a message to the terminal after lazygit exits
|
|
ReminderExitMessage
|
|
)
|
|
|
|
// The part of config.AppConfigurer that the updater needs
|
|
type appStateStore interface {
|
|
ReadAppState() (*config.AppState, error)
|
|
UpdateAppState(update func(state *config.AppState)) error
|
|
}
|
|
|
|
// Updater checks for new lazygit releases, and installs them if lazygit was
|
|
// installed from one of our release archives.
|
|
type Updater struct {
|
|
*common.Common
|
|
appState appStateStore
|
|
installation Installation
|
|
currentVersion *types.VersionNumber
|
|
|
|
httpClient *http.Client
|
|
repoURL string
|
|
goos string
|
|
goarch string
|
|
|
|
installing atomic.Bool
|
|
|
|
statusMutex sync.Mutex
|
|
status Status
|
|
|
|
startTime time.Time
|
|
|
|
// Replaced in tests
|
|
now func() time.Time
|
|
|
|
// Held while we replace the executable, so that lazygit doesn't exit in
|
|
// the middle of it
|
|
replaceMutex sync.Mutex
|
|
}
|
|
|
|
func NewUpdater(cmn *common.Common, config config.AppConfigurer) *Updater {
|
|
currentVersion, _ := types.ParseVersionNumber(config.GetVersion())
|
|
|
|
return &Updater{
|
|
Common: cmn,
|
|
appState: config,
|
|
installation: DetectInstallation(config.GetBuildSource(), config.GetVersion(), executablePath()),
|
|
currentVersion: currentVersion,
|
|
httpClient: &http.Client{},
|
|
repoURL: constants.Links.RepoUrl,
|
|
goos: runtime.GOOS,
|
|
goarch: runtime.GOARCH,
|
|
startTime: time.Now(),
|
|
now: time.Now,
|
|
}
|
|
}
|
|
|
|
func executablePath() string {
|
|
path, err := os.Executable()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
if resolvedPath, err := filepath.EvalSymlinks(path); err == nil {
|
|
return resolvedPath
|
|
}
|
|
return path
|
|
}
|
|
|
|
func (u *Updater) Installation() Installation {
|
|
return u.installation
|
|
}
|
|
|
|
// CurrentVersion returns nil for dev builds
|
|
func (u *Updater) CurrentVersion() *types.VersionNumber {
|
|
return u.currentVersion
|
|
}
|
|
|
|
// Status is what lazygit knows about updates
|
|
type Status struct {
|
|
// The latest release that a check found, if it is newer than the running
|
|
// lazygit
|
|
AvailableVersion *types.VersionNumber
|
|
// The version that an update installed in place of the running lazygit.
|
|
// This lazygit, or another one running from the same executable, can have
|
|
// installed it. The new version takes effect when lazygit is restarted.
|
|
InstalledVersion *types.VersionNumber
|
|
}
|
|
|
|
// ChecksEnabled returns whether lazygit checks for updates regularly. It
|
|
// doesn't for dev builds.
|
|
func (u *Updater) ChecksEnabled() bool {
|
|
return u.installation.Kind != InstallKindDevBuild
|
|
}
|
|
|
|
// CheckForUpdateIfDue checks for an update if lazygit checks regularly, and
|
|
// the last successful check is long enough ago.
|
|
func (u *Updater) CheckForUpdateIfDue() error {
|
|
if !u.ChecksEnabled() {
|
|
return nil
|
|
}
|
|
|
|
state := u.readAppState()
|
|
interval := time.Duration(u.UserConfig().Update.Days) * 24 * time.Hour
|
|
if u.now().Sub(time.Unix(state.Updates.LastCheck, 0)) < interval {
|
|
u.RefreshStatus()
|
|
return nil
|
|
}
|
|
|
|
_, err := u.CheckForUpdate()
|
|
return err
|
|
}
|
|
|
|
// CheckForUpdate returns the latest version if it is newer than the current
|
|
// one, or nil if it isn't. Don't call it for dev builds.
|
|
func (u *Updater) CheckForUpdate() (*types.VersionNumber, error) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), checkTimeout)
|
|
defer cancel()
|
|
|
|
latestVersion, err := fetchLatestVersion(ctx, u.httpClient, u.repoURL)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
u.Log.Infof("Current version is %s, latest version is %s", u.currentVersion, latestVersion)
|
|
u.updateAppState(func(state *config.AppState) {
|
|
state.Updates.LastCheck = u.now().Unix()
|
|
if state.Updates.LatestVersion != latestVersion.String() {
|
|
state.Updates.LatestVersion = latestVersion.String()
|
|
state.Updates.LatestVersionFoundAt = u.now().Unix()
|
|
}
|
|
})
|
|
u.RefreshStatus()
|
|
|
|
if !u.currentVersion.IsOlderThan(latestVersion) {
|
|
return nil, nil
|
|
}
|
|
return latestVersion, nil
|
|
}
|
|
|
|
// CheckCanInstall returns an error if we can't install an update in place
|
|
// because we don't have write access to the folder of the executable. Only call
|
|
// it for InstallKindRelease.
|
|
func (u *Updater) CheckCanInstall() error {
|
|
return checkCanReplaceExecutable(u.installation.ExecutablePath)
|
|
}
|
|
|
|
// Install downloads the given release and installs it in place of the running
|
|
// lazygit. Only call it for InstallKindRelease.
|
|
func (u *Updater) Install(version *types.VersionNumber) error {
|
|
if !u.installing.CompareAndSwap(false, true) {
|
|
return errors.New("an update is already in progress")
|
|
}
|
|
defer u.installing.Store(false)
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), installTimeout)
|
|
defer cancel()
|
|
|
|
url := assetURL(u.repoURL, version, u.goos, u.goarch)
|
|
u.Log.Infof("Installing %s", url)
|
|
|
|
binary, err := downloadBinary(ctx, u.httpClient, url, u.goos)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := u.replaceExecutable(binary); err != nil {
|
|
return err
|
|
}
|
|
|
|
u.updateAppState(func(state *config.AppState) {
|
|
state.Updates.InstalledVersion = version.String()
|
|
state.Updates.InstalledPath = u.installation.ExecutablePath
|
|
})
|
|
u.RefreshStatus()
|
|
return nil
|
|
}
|
|
|
|
func (u *Updater) replaceExecutable(binary []byte) error {
|
|
u.replaceMutex.Lock()
|
|
defer u.replaceMutex.Unlock()
|
|
return replaceExecutable(u.installation.ExecutablePath, binary, u.goos)
|
|
}
|
|
|
|
// RefreshStatus reads the status from the app state, where other lazygit
|
|
// instances can have changed it, and returns it. Don't call it on the UI
|
|
// thread, because it accesses the file system.
|
|
func (u *Updater) RefreshStatus() Status {
|
|
state := u.readAppState()
|
|
|
|
status := u.statusFromAppState(state)
|
|
|
|
u.statusMutex.Lock()
|
|
defer u.statusMutex.Unlock()
|
|
u.status = status
|
|
return status
|
|
}
|
|
|
|
func (u *Updater) statusFromAppState(state *config.AppState) Status {
|
|
status := Status{
|
|
AvailableVersion: u.newerVersion(state.Updates.LatestVersion),
|
|
}
|
|
if state.Updates.InstalledPath == u.installation.ExecutablePath {
|
|
status.InstalledVersion = u.newerVersion(state.Updates.InstalledVersion)
|
|
}
|
|
return status
|
|
}
|
|
|
|
// Status returns the status as of the last refresh
|
|
func (u *Updater) Status() Status {
|
|
u.statusMutex.Lock()
|
|
defer u.statusMutex.Unlock()
|
|
return u.status
|
|
}
|
|
|
|
// IsStartingUp returns whether lazygit started less than a minute ago
|
|
func (u *Updater) IsStartingUp() bool {
|
|
return u.now().Sub(u.startTime) < startupPeriod
|
|
}
|
|
|
|
// RemindersEnabled returns whether lazygit reminds the user of available
|
|
// updates. With update.method set to never, it only shows the note in the
|
|
// bottom-right corner.
|
|
func (u *Updater) RemindersEnabled() bool {
|
|
return u.ChecksEnabled() && u.UserConfig().Update.Method != "never"
|
|
}
|
|
|
|
// DueReminder returns the version to remind the user of, or nil if no reminder
|
|
// is due
|
|
func (u *Updater) DueReminder(reminder Reminder) *types.VersionNumber {
|
|
return u.dueReminder(u.readAppState(), reminder)
|
|
}
|
|
|
|
// ClaimExitMessage returns the version to remind the user of in a message
|
|
// after lazygit exits, or nil if no reminder is due, and records that we print
|
|
// the message. We print it at most once a day.
|
|
func (u *Updater) ClaimExitMessage() *types.VersionNumber {
|
|
var version *types.VersionNumber
|
|
u.updateAppState(func(state *config.AppState) {
|
|
version = u.dueReminder(state, ReminderExitMessage)
|
|
if version != nil {
|
|
state.Updates.LastExitMessage = u.now().Unix()
|
|
}
|
|
})
|
|
return version
|
|
}
|
|
|
|
func (u *Updater) dueReminder(state *config.AppState, reminder Reminder) *types.VersionNumber {
|
|
if !u.RemindersEnabled() || u.IsInstalling() {
|
|
return nil
|
|
}
|
|
|
|
status := u.statusFromAppState(state)
|
|
if status.AvailableVersion == nil || status.InstalledVersion != nil {
|
|
return nil
|
|
}
|
|
if state.Updates.SkippedVersion == state.Updates.LatestVersion {
|
|
return nil
|
|
}
|
|
if u.now().Sub(time.Unix(state.Updates.LastResponse, 0)) < reminderInterval {
|
|
return nil
|
|
}
|
|
if reminder == ReminderMenuAtStartup {
|
|
if state.Updates.RespondedVersion == state.Updates.LatestVersion ||
|
|
u.now().Sub(time.Unix(state.Updates.LatestVersionFoundAt, 0)) < startupReminderDelay {
|
|
return nil
|
|
}
|
|
}
|
|
if reminder == ReminderExitMessage &&
|
|
u.now().Sub(time.Unix(state.Updates.LastExitMessage, 0)) < reminderInterval {
|
|
return nil
|
|
}
|
|
return status.AvailableVersion
|
|
}
|
|
|
|
// VersionToInstallInBackground returns the version that lazygit should install
|
|
// without asking the user, or nil if there's none. This is the case if the user
|
|
// config asks for it, and lazygit can update itself.
|
|
func (u *Updater) VersionToInstallInBackground() *types.VersionNumber {
|
|
if u.installation.Kind != InstallKindRelease || u.UserConfig().Update.Method != "background" {
|
|
return nil
|
|
}
|
|
|
|
state := u.readAppState()
|
|
status := u.statusFromAppState(state)
|
|
if status.AvailableVersion == nil || status.InstalledVersion != nil ||
|
|
state.Updates.SkippedVersion == state.Updates.LatestVersion {
|
|
return nil
|
|
}
|
|
if err := u.CheckCanInstall(); err != nil {
|
|
return nil
|
|
}
|
|
return status.AvailableVersion
|
|
}
|
|
|
|
// RecordResponse records that the user responded to the update menu for the
|
|
// given version, in whatever way. lazygit doesn't show the menu again for a
|
|
// day, and the other lazygit instances close theirs.
|
|
func (u *Updater) RecordResponse(version *types.VersionNumber) {
|
|
u.updateAppState(func(state *config.AppState) {
|
|
state.Updates.LastResponse = u.now().Unix()
|
|
state.Updates.RespondedVersion = version.String()
|
|
})
|
|
}
|
|
|
|
// IsHandledAfter returns whether the user responded to the update menu in any
|
|
// lazygit instance after the given time, or the update got installed. A menu
|
|
// that was shown at that time is obsolete then.
|
|
func (u *Updater) IsHandledAfter(t time.Time) bool {
|
|
state := u.readAppState()
|
|
return state.Updates.LastResponse > t.Unix() || u.statusFromAppState(state).InstalledVersion != nil
|
|
}
|
|
|
|
// SkipVersion keeps lazygit from reminding the user of the given version
|
|
func (u *Updater) SkipVersion(version *types.VersionNumber) {
|
|
u.updateAppState(func(state *config.AppState) {
|
|
state.Updates.SkippedVersion = version.String()
|
|
})
|
|
}
|
|
|
|
// newerVersion parses the given version and returns it if it is newer than the
|
|
// running lazygit, or nil otherwise
|
|
func (u *Updater) newerVersion(versionStr string) *types.VersionNumber {
|
|
if u.currentVersion == nil {
|
|
return nil
|
|
}
|
|
version, err := types.ParseVersionNumber(versionStr)
|
|
if err != nil || !u.currentVersion.IsOlderThan(version) {
|
|
return nil
|
|
}
|
|
return version
|
|
}
|
|
|
|
func (u *Updater) readAppState() *config.AppState {
|
|
state, err := u.appState.ReadAppState()
|
|
if err != nil {
|
|
u.Log.Errorf("Error reading the app state: %v", err)
|
|
}
|
|
return state
|
|
}
|
|
|
|
// Errors from saving the update state aren't worth bothering the user with; at
|
|
// worst, we check or remind again.
|
|
func (u *Updater) updateAppState(update func(state *config.AppState)) {
|
|
if err := u.appState.UpdateAppState(update); err != nil {
|
|
u.Log.Errorf("Error saving the app state: %v", err)
|
|
}
|
|
}
|
|
|
|
func (u *Updater) IsInstalling() bool {
|
|
return u.installing.Load()
|
|
}
|
|
|
|
// WaitForInstallToFinish waits until a running install is done replacing the
|
|
// executable, and keeps later installs from starting. Call it before exiting.
|
|
func (u *Updater) WaitForInstallToFinish() {
|
|
u.replaceMutex.Lock()
|
|
}
|
|
|
|
// CleanUpAfterUpdate removes files that an earlier update left behind
|
|
func (u *Updater) CleanUpAfterUpdate() {
|
|
if u.installation.Kind == InstallKindRelease {
|
|
cleanUpAfterUpdate(u.installation.ExecutablePath)
|
|
}
|
|
}
|