Add versioning to perf SQL database

perf/go/ingest/main.go

 package main
 
 // ingest is the command line tool for pulling performance data from Google
 // Storage and putting in Tiles. See the code in go/ingester for details on how
 // ingestion is done.
 
 import (
         "encoding/json"
         "flag"
         "net"
@@ skipping 17 matching lines @@
 // flags
 var (
         timestampFile  = flag.String("timestamp_file", "/tmp/timestamp.json", "File where timestamp data for ingester runs will be stored.")
         tileDir        = flag.String("tile_dir", "/tmp/tileStore2/", "Path where tiles will be placed.")
         gitRepoDir     = flag.String("git_repo_dir", "../../../skia", "Directory location for the Skia repo.")
         runEvery       = flag.Duration("run_every", 5*time.Minute, "How often the ingester should pull data from Google Storage.")
         runTrybotEvery = flag.Duration("run_trybot_every", 1*time.Minute, "How often the ingester to pull trybot data from Google Storage.")
         run            = flag.String("run", "nano,nano-trybot,golden", "A comma separated list of ingesters to run.")
         graphiteServer = flag.String("graphite_server", "skia-monitoring-b:2003", "Where is Graphite metrics ingestion server running.")
         doOauth        = flag.Bool("oauth", true, "Run through the OAuth 2.0 flow on startup, otherwise use a GCE service account.")
+        local          = flag.Bool("local", false, "Running locally if true. As opposed to in production.")
 )
 
 func Init() {
         metrics.RegisterRuntimeMemStats(metrics.DefaultRegistry)
         go metrics.CaptureRuntimeMemStats(metrics.DefaultRegistry, 1*time.Minute)
         addr, _ := net.ResolveTCPAddr("tcp", *graphiteServer)
         go metrics.Graphite(metrics.DefaultRegistry, 1*time.Minute, "ingest", addr)
 }
 
 // Timestamps is used to read and write the timestamp file, which records the time
@@ skipping 101 matching lines @@
                 client, err = auth.RunFlow()
                 if err != nil {
                         glog.Fatalf("Failed to auth: %s", err)
                 }
         } else {
                 client = nil
                 // Add back service account access here when it's fixed.
         }
 
         ingester.Init(client)
-        trybot.Init()
+        trybot.Init(*local)
         goldingester.Init()
         ts := NewTimestamps(*timestampFile)
         ts.Read()
         glog.Infof("Timestamps: %#v\n", ts.Ingester)
 
         git, err := gitinfo.NewGitInfo(*gitRepoDir, true)
         if err != nil {
                 glog.Fatal("Failed loading Git info: %s\n", err)
         }
 
         // ingesters is a list of all the types of ingestion we can do.
         ingesters := map[string]Process{
                 "nano":        NewIngestionProcess(ts, "ingest", git, *tileDir, config.DATASET_NANO, ingester.NanoBenchIngestion, "nano-json-v1", *runEvery),
                 "nano-trybot": NewIngestionProcess(ts, "trybot", git, *tileDir, config.DATASET_NANO, trybot.TrybotIngestion, "trybot/nano-json-v1", *runTrybotEvery),
                 "golden":      NewIngestionProcess(ts, "golden", git, *tileDir, config.DATASET_GOLDEN, goldingester.GoldenIngester, "dm-json-v1", *runEvery),
         }
 
         for _, name := range strings.Split(*run, ",") {
                 glog.Infof("Process name: %s", name)
                 if process, ok := ingesters[name]; ok {
                         go process()
                 } else {
                         glog.Fatalf("Not a valid ingester name: %s", name)
                 }
         }
 
         select {}
 }