kitchen: CURRENT_TIMESTAMP support

client/cmd/kitchen/cook.go

 // Copyright 2016 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 main
 
 import (
         "encoding/json"
         "fmt"
         "io/ioutil"
         "net/url"
         "os"
         "os/exec"
         "path"
+        "strconv"
         "strings"
         "syscall"
 
         "github.com/maruel/subcommands"
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/common/cli"
+        "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/ctxcmd"
 )
 
 // BootstrapStepName is the name of kitchen's step where it makes preparations
 // for running a recipe, e.g. fetches a repository.
 const BootstrapStepName = "recipe bootstrap"
 
 // cmdCook checks out a repository at a revision and runs a recipe.
 var cmdCook = &subcommands.Command{
         UsageLine: "cook -repository <repository URL> -revision <revision> -recipe <recipe>",
@@ skipping 22 matching lines @@
                         "The working directory for recipe execution. Defaults to a temp dir.")
                 fs.StringVar(&c.Properties, "properties", "",
                         "A json string containing the properties. Mutually exclusive with -properties-file.")
                 fs.StringVar(&c.PropertiesFile, "properties-file", "",
                         "A file containing a json string of properties. Mutually exclusive with -properties.")
                 fs.StringVar(
                         &c.OutputResultJSONFile,
                         "output-result-json",
                         "",
                         "The file to write the JSON serialized returned value of the recipe to")
+                fs.BoolVar(
+                        &c.Timestamps,
+                        "timestamps",
+                        false,
+                        "If true, print CURRENT_TIMESTAMP annotations.")
                 return &c
         },
 }
 
 type cookRun struct {
         subcommands.CommandRunBase
 
         RepositoryURL        string
         Revision             string
         Recipe               string
         CheckoutDir          string
         Workdir              string
         Properties           string
         PropertiesFile       string
         OutputResultJSONFile string
+        Timestamps           bool
 }
 
 func (c *cookRun) validateFlags() error {
         // Validate Repository.
         if c.RepositoryURL == "" {
                 return fmt.Errorf("-repository is required")
         }
         repoURL, err := url.Parse(c.RepositoryURL)
         if err != nil {
                 return fmt.Errorf("invalid repository %q: %s", repoURL, err)
@@ skipping 34 matching lines @@
                 c.Workdir = tempWorkdir
         }
 
         recipe := recipeRun{
                 repositoryPath:       c.CheckoutDir,
                 workDir:              c.Workdir,
                 recipe:               c.Recipe,
                 propertiesJSON:       c.Properties,
                 propertiesFile:       c.PropertiesFile,
                 outputResultJSONFile: c.OutputResultJSONFile,
+                timestamps:           c.Timestamps,
         }
         recipeCmd, err := recipe.Command()
         if err != nil {
                 return 0, err
         }
 
         fmt.Printf("Running command %q %q in %q\n",
                 recipeCmd.Path, recipeCmd.Args, recipeCmd.Dir)
 
         recipeCtxCmd := ctxcmd.CtxCmd{Cmd: recipeCmd}
@@ skipping 25 matching lines @@
                 err = fmt.Errorf("unexpected arguments %v\n", args)
         } else {
                 err = c.validateFlags()
         }
         if err != nil {
                 fmt.Fprintln(os.Stderr, err)
                 c.Flags.Usage()
                 return 1
         }
 
+        if c.Timestamps {
+                annotateTime(ctx)
+        }
         annotate("SEED_STEP", BootstrapStepName)
         annotate("STEP_CURSOR", BootstrapStepName)
         annotate("STEP_STARTED")
+        defer func() {
+                annotate("STEP_CURSOR", BootstrapStepName)
+                if c.Timestamps {
+                        annotateTime(ctx)
+                }
+                annotate("STEP_CLOSED")
+                if c.Timestamps {
+                        annotateTime(ctx)
+                }
+        }()
+
         props, err := parseProperties(c.Properties, c.PropertiesFile)
         if err != nil {
                 fmt.Fprintln(os.Stderr, err)
                 return 1
         }
         for k, v := range props {
                 // Order is not stable, but that is okay.
                 jv, err := json.Marshal(v)
                 if err != nil {
                         fmt.Fprintln(os.Stderr, err)
                         return 1
                 }
                 annotate("SET_BUILD_PROPERTY", k, string(jv))
         }
 
         recipeExitCode, err := c.run(ctx)
-        annotate("STEP_CURSOR", BootstrapStepName)
         if err != nil {
                 if err != context.Canceled {
                         fmt.Fprintln(os.Stderr, err)
                 }
                 return -1
         }
-        annotate("STEP_CLOSED")
         return recipeExitCode
 }
 
 func parseProperties(properties, propertiesFile string) (result map[string]interface{}, err error) {
         if properties != "" {
                 err = json.Unmarshal([]byte(properties), &result)
                 if err != nil {
                         err = fmt.Errorf("could not parse properties %s\n%s", properties, err)
                 }
                 return
         }
         if propertiesFile != "" {
                 b, err := ioutil.ReadFile(propertiesFile)
                 if err != nil {
                         err = fmt.Errorf("could not read properties file %s\n%s", propertiesFile, err)
                         return nil, err
                 }
                 err = json.Unmarshal(b, &result)
                 if err != nil {
                         err = fmt.Errorf("could not parse JSON from file %s\n%s\n%s",
                                 propertiesFile, b, err)
                 }
         }
         return
 }
 
+func annotateTime(ctx context.Context) {
+        timestamp := clock.Get(ctx).Now().Unix()
+        annotate("CURRENT_TIMESTAMP", strconv.FormatInt(timestamp, 10))
+}
+
 func annotate(args ...string) {
         fmt.Printf("@@@%s@@@\n", strings.Join(args, "@"))
 }