Migrate tsmon protos to proto3

appengine/tsmon/middleware.go

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package tsmon
 
 import (
         "fmt"
         "net/http"
         "strings"
         "sync"
         "time"
 
-        "github.com/golang/protobuf/proto"
         "github.com/julienschmidt/httprouter"
         "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/info"
         gaeauth "github.com/luci/luci-go/appengine/gaeauth/client"
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/gcloud/pubsub"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/tsmon"
         "github.com/luci/luci-go/common/tsmon/monitor"
         "github.com/luci/luci-go/common/tsmon/store"
@@ skipping 41 matching lines @@
 
                 var err error
                 mon, err = monitor.NewPubsubMonitor(client, pubsubProject, pubsubTopic)
                 if err != nil {
                         return err
                 }
         }
 
         // Create the target.
         tar := &target.Task{
-                DataCenter:  proto.String(targetDataCenter),
-                ServiceName: proto.String(i.AppID()),
-                JobName:     proto.String(i.ModuleName()),
-                HostName:    proto.String(strings.SplitN(i.VersionID(), ".", 2)[0]),
-                TaskNum:     proto.Int32(-1),
+                DataCenter:  targetDataCenter,
+                ServiceName: i.AppID(),
+                JobName:     i.ModuleName(),
+                HostName:    strings.SplitN(i.VersionID(), ".", 2)[0],
+                TaskNum:     -1,
         }
 
         tsmon.Initialize(c, mon, store.NewInMemory(tar))
         return nil
 }
 
 func flushIfNeeded(c context.Context) {
         if !updateLastFlushed(c) {
                 return
         }
@@ skipping 24 matching lines @@
         if !ok {
                 // tsmon probably failed to initialize - just do nothing.
                 return fmt.Errorf("default tsmon target is not a Task: %v", tsmon.Store(c).DefaultTarget())
         }
 
         logger := logging.Get(c)
         entity := getOrCreateInstanceEntity(c)
         now := clock.Now(c)
 
         if entity.TaskNum < 0 {
-                if *task.TaskNum >= 0 {
+                if task.TaskNum >= 0 {
                         // We used to have a task number but we don't any more (we were inactive
                         // for too long), so clear our state.
                         logging.Warningf(c, "Instance %s got purged from Datastore, but is still alive. "+
                                 "Clearing cumulative metrics", info.Get(c).InstanceID())
                         tsmon.ResetCumulativeMetrics(c)
                 }
-                task.TaskNum = proto.Int32(-1)
+                task.TaskNum = -1
                 lastFlushed.Time = entity.LastUpdated
 
                 // Start complaining if we haven't been given a task number after some time.
                 shouldHaveTaskNumBy := entity.LastUpdated.Add(instanceExpectedToHaveTaskNum)
                 if shouldHaveTaskNumBy.Before(now) {
                         logger.Warningf("Instance %s is %s old with no task_num.",
                                 info.Get(c).InstanceID(), now.Sub(shouldHaveTaskNumBy).String())
                 }
                 return nil
         }
 
-        task.TaskNum = proto.Int32(int32(entity.TaskNum))
+        task.TaskNum = int32(entity.TaskNum)
         tsmon.Store(c).SetDefaultTarget(task)
 
         // Update the instance entity and put it back in the datastore asynchronously.
         entity.LastUpdated = now
         putDone := make(chan struct{})
         go func() {
                 defer close(putDone)
                 if err := datastore.Get(c).Put(entity); err != nil {
                         logger.Errorf("Failed to update instance entity: %s", err)
                 }
         }()
 
         ret := tsmon.Flush(c)
         resetGlobalCallbackMetrics(c)
 
         <-putDone
         return ret
 }