func (f JSONConfigFile) GetTimeAtPath(path string) keybase1.Time {
var ret keybase1.Time
s, _ := f.GetStringAtPath(path)
if len(s) == 0 {
return ret
}
u, err := strconv.ParseUint(s, 10, 64)
if err != nil {
return ret
}
ret = keybase1.Time(u)
return ret
}
func LoadUserPlusKeys(g *GlobalContext, uid keybase1.UID) (keybase1.UserPlusKeys, error) {
var up keybase1.UserPlusKeys
if uid.IsNil() {
return up, fmt.Errorf("Nil UID")
}
arg := NewLoadUserArg(g)
arg.UID = uid
arg.PublicKeyOptional = true
u, err := LoadUser(arg)
if err != nil {
return up, err
}
if u == nil {
return up, fmt.Errorf("Nil user, nil error from LoadUser")
}
return u.ExportToUserPlusKeys(keybase1.Time(0)), nil
}
func (n NullConfiguration) GetUpdateLastChecked() keybase1.Time { return keybase1.Time(0) }
func (n NullConfiguration) GetUpdatePreferenceSnoozeUntil() keybase1.Time { return keybase1.Time(0) }
func (f *JSONConfigFile) SetTimeAtPath(path string, t keybase1.Time) error {
if t == keybase1.Time(0) {
return f.SetNullAtPath(path)
}
return f.SetStringAtPath(path, fmt.Sprintf("%d", t))
}
// Insert adds a user to the cache, keyed on UID.
func (c *Identify2Cache) Insert(up *keybase1.UserPlusKeys) error {
tmp := *up
copy := &tmp
copy.Uvv.CachedAt = keybase1.Time(time.Now().Unix())
return c.cache.Set(string(up.Uid), copy)
}
func (u *Updater) checkForUpdate(skipAssetDownload bool, force bool, requested bool) (update *keybase1.Update, err error) {
u.log.Info("Checking for update, current version is %s", u.options.Version)
if u.options.Force {
force = true
}
// Don't snooze if the user requested/wants an update (check) or we're forcing a check
if !requested && !force {
if snz := u.config.GetUpdatePreferenceSnoozeUntil(); snz > 0 {
snoozeUntil := keybase1.FromTime(snz)
if time.Now().Before(snoozeUntil) {
u.log.Info("Snoozing until %s", snoozeUntil)
return nil, nil
}
u.log.Debug("Snooze expired at %s", snoozeUntil)
// Clear out the snooze
u.config.SetUpdatePreferenceSnoozeUntil(keybase1.Time(0))
}
}
currentSemVersion, err := semver.Make(u.options.Version)
if err != nil {
return
}
u.log.Info("Using updater source: %s", u.source.Description())
u.log.Debug("Using options: %#v", u.options)
update, err = u.source.FindUpdate(u.options)
if err != nil || update == nil {
return
}
u.log.Info("Checking update with version: %s", update.Version)
updateSemVersion, err := semver.Make(update.Version)
if err != nil {
return
}
// Update instruction might be empty, if so we'll fill in with the default
// instructions for the platform.
if update.Instructions == nil || *update.Instructions == "" {
instructions, err := libkb.PlatformSpecificUpgradeInstructionsString()
if err != nil {
u.log.Errorf("Error trying to get update instructions: %s", err)
}
if instructions == "" {
instructions = u.options.DefaultInstructions
}
if instructions != "" {
u.log.Debug("Using default platform instructions: %s", instructions)
update.Instructions = &instructions
} else {
u.log.Debug("No instructions set for update")
}
}
if skipVersion := u.config.GetUpdatePreferenceSkip(); len(skipVersion) != 0 {
u.log.Debug("Update preference: skip %s", skipVersion)
if vers, err := semver.Make(skipVersion); err != nil {
u.log.Warning("Bad 'skipVersion' in config file: %q", skipVersion)
} else if vers.GE(updateSemVersion) {
u.log.Debug("Skipping updated version via config preference: %q", update.Version)
return nil, nil
}
}
if updateSemVersion.EQ(currentSemVersion) {
// Versions are the same, we are up to date
u.log.Info("Update matches current version: %s = %s", updateSemVersion, currentSemVersion)
if !force {
update = nil
return
}
} else if updateSemVersion.LT(currentSemVersion) {
u.log.Info("Update is older version: %s < %s", updateSemVersion, currentSemVersion)
if !force {
update = nil
return
}
}
if !skipAssetDownload && update.Asset != nil {
downloadPath, _, dlerr := u.downloadAsset(*update.Asset)
if dlerr != nil {
err = dlerr
return
}
update.Asset.LocalPath = downloadPath
}
return
}
func (u *Updater) checkForUpdate(skipAssetDownload bool, force bool, requested bool) (update *keybase1.Update, err error) {
u.log.Info("Checking for update, current version is %s", u.options.Version)
if u.options.Force {
force = true
}
// Don't snooze if the user requested/wants an update (check) or we're forcing a check
if !requested && !force {
if snz := u.config.GetUpdatePreferenceSnoozeUntil(); snz > 0 {
snoozeUntil := keybase1.FromTime(snz)
if time.Now().Before(snoozeUntil) {
u.log.Info("Snoozing until %s", snoozeUntil)
return nil, nil
}
u.log.Debug("Snooze expired at %s", snoozeUntil)
// Clear out the snooze
u.config.SetUpdatePreferenceSnoozeUntil(keybase1.Time(0))
}
}
currentSemVersion, err := semver.Make(u.options.Version)
if err != nil {
return
}
u.log.Info("Using updater source: %s", u.source.Description())
u.log.Debug("Using options: %#v", u.options)
update, err = u.source.FindUpdate(u.options)
if err != nil || update == nil {
return
}
u.log.Info("Checking update with version: %s", update.Version)
updateSemVersion, err := semver.Make(update.Version)
if err != nil {
return
}
if skp := u.config.GetUpdatePreferenceSkip(); len(skp) != 0 {
u.log.Debug("Update preference: skip %s", skp)
if vers, err := semver.Make(skp); err != nil {
u.log.Warning("Bad 'skipVersion' in config file: %q", skp)
} else if vers.GE(updateSemVersion) {
u.log.Debug("Skipping updated version via config preference: %q", update.Version)
return nil, nil
}
}
if updateSemVersion.EQ(currentSemVersion) {
// Versions are the same, we are up to date
u.log.Info("Update matches current version: %s = %s", updateSemVersion, currentSemVersion)
if !force {
update = nil
return
}
} else if updateSemVersion.LT(currentSemVersion) {
u.log.Info("Update is older version: %s < %s", updateSemVersion, currentSemVersion)
if !force {
update = nil
return
}
}
if !skipAssetDownload {
downloadPath, _, dlerr := u.downloadAsset(update.Asset)
if dlerr != nil {
err = dlerr
return
}
update.Asset.LocalPath = downloadPath
}
return
}