Make selfupdate maintain client version as well.

cipd/client/cipd/client.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 // Package cipd implements client side of Chrome Infra Package Deployer.
 //
 // Binary package file format (in free form representation):
 //   <binary package> := <zipped data>
 //   <zipped data> := DeterministicZip(<all input files> + <manifest json>)
 //   <manifest json> := File{
@@ skipping 14 matching lines @@
 // built it, revision of the source code it was built from, etc. All that
 // information will be distributed as a separate metadata packet associated with
 // the package when it gets uploaded to the server.
 //
 // TODO: expand more when there's server-side package data model (labels
 // and stuff).
 package cipd
 
 import (
         "bufio"
+        "encoding/json"
         "fmt"
         "io"
         "net/http"
         "os"
         "path/filepath"
         "runtime"
         "sort"
         "strings"
         "sync"
         "time"
 
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
 
         "github.com/luci/luci-go/cipd/client/cipd/common"
         "github.com/luci/luci-go/cipd/client/cipd/internal"
         "github.com/luci/luci-go/cipd/client/cipd/local"
+        "github.com/luci/luci-go/cipd/version"
 )
 
 // PackageACLChangeAction defines a flavor of PackageACLChange.
 type PackageACLChangeAction string
 
 const (
         // GrantRole is used in PackageACLChange to request a role to be granted.
         GrantRole PackageACLChangeAction = "GRANT"
         // RevokeRole is used in PackageACLChange to request a role to be revoked.
         RevokeRole PackageACLChangeAction = "REVOKE"
@@ skipping 647 matching lines @@
                 clientFileName = "cipd.exe"
         }
 
         arch := runtime.GOARCH
         if arch == "arm" {
                 arch = "armv6l"
         }
         clientPackage = fmt.Sprintf("%s/%s-%s", clientPackageBase, platform, arch)
 }
 
+func (client *clientImpl) ensureClientVersionInfo(ctx context.Context, fs local.FileSystem, pin common.Pin, exePath string) {
+        verFile := version.GetVersionFile(exePath)
+        vfStat, err := os.Stat(verFile)

[Vadim Sh., 2016/11/27 01:25:55]

I'd remove both of these checks and just read the file and compare its content
to what it should be, it is tiny. I don't like reliance on ModTime.

[iannucci, 2016/11/29 01:46:20]

Done.

+        if err == nil {
+                eStat, err := os.Stat(exePath)
+                if err == nil {
+                        if vfStat.ModTime().After(eStat.ModTime()) {
+                                // version file already up to date
+                                return
+                        }
+                }
+        }
+        // there was an error statting one or both files, or the version file is older
+        // than the exe. Proceed with EnsureFile.
+
+        err = fs.EnsureFile(ctx, verFile, func(of *os.File) error {

[Vadim Sh., 2016/11/27 01:25:55]

I forgot, does it create a full path? i.e. if ".versions" directory is missing?

[iannucci, 2016/11/29 01:46:20]

Yes :)

+                return json.NewEncoder(of).Encode(version.Info{
+                        PackageName: pin.PackageName,
+                        InstanceID:  pin.InstanceID,
+                })
+        })
+        if err != nil {
+                logging.Warningf(ctx, "Unable to update version info %q: %s", verFile, err)
+        }
+}
+
 func (client *clientImpl) MaybeUpdateClient(ctx context.Context, fs local.FileSystem, targetVersion, currentHash, destination string) error {
         if err := common.ValidateFileHash(currentHash); err != nil {
                 return err
         }
 
         client.BeginBatch(ctx)
         defer client.EndBatch(ctx)
 
         logging.Infof(ctx, "cipd: maybe updating client to version %q", targetVersion)
         pin, err := client.ResolveVersion(ctx, clientPackage, targetVersion)
         if err != nil {
                 return err
         }
 
         cache := client.getTagCache()
         exeHash := ""
         if cache != nil {
                 if exeHash, err = cache.ResolveFile(ctx, pin, clientFileName); err != nil {
                         return err
                 }
         }
         if exeHash == currentHash {
-                // already up-to-date
+                // already up-to-date. Make sure version file is up to date.
+                client.ensureClientVersionInfo(ctx, fs, pin, destination)
                 return nil
         }
 
         logging.Infof(ctx, "cipd: updating client to %s", pin)
 
         info, err := client.remote.fetchClientBinaryInfo(ctx, pin)
         if err != nil {
                 return err
         }
         if cache != nil {
                 if err = cache.AddFile(ctx, pin, clientFileName, info.clientBinary.SHA1); err != nil {
                         return err
                 }
         }
         client.doBatchAwareOp(ctx, batchAwareOpSaveTagCache)
         if info.clientBinary.SHA1 == currentHash {
-                // already up-to-date, but the cache didn't know that.
+                // already up-to-date, but the cache didn't know that. Make sure version
+                // file is update.
+                client.ensureClientVersionInfo(ctx, fs, pin, destination)
                 return nil
         }
 
-        return client.installClient(ctx, fs, info.clientBinary.FetchURL, destination)
+        if err := client.installClient(ctx, fs, info.clientBinary.FetchURL, destination); err != nil {
+                return err
+        }
+
+        client.ensureClientVersionInfo(ctx, fs, pin, destination)
+        return nil
 }
 
 func (client *clientImpl) RegisterInstance(ctx context.Context, instance local.PackageInstance, timeout time.Duration) error {
         // Attempt to register.
         logging.Infof(ctx, "cipd: registering %s", instance.Pin())
         result, err := client.remote.registerInstance(ctx, instance.Pin())
         if err != nil {
                 return err
         }
 
@@ skipping 526 matching lines @@
 }
 
 // buildInstanceIDMap builds mapping {package name -> instance ID}.
 func buildInstanceIDMap(pins []common.Pin) map[string]string {
         out := map[string]string{}
         for _, p := range pins {
                 out[p.PackageName] = p.InstanceID
         }
         return out
 }