scheduler: rename JobID to JobName to avoid overloading JobID meaning.

scheduler/appengine/ui/presentation.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 ui
 
 import (
         "bytes"
         "fmt"
         "sort"
-        "strings"
         "time"
 
         "github.com/dustin/go-humanize"
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
 
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/logging"
 
         "github.com/luci/luci-go/common/data/sortby"
         "github.com/luci/luci-go/scheduler/appengine/catalog"
         "github.com/luci/luci-go/scheduler/appengine/engine"
         "github.com/luci/luci-go/scheduler/appengine/messages"
         "github.com/luci/luci-go/scheduler/appengine/presentation"
         "github.com/luci/luci-go/scheduler/appengine/schedule"
         "github.com/luci/luci-go/scheduler/appengine/task"
 )
 
 // schedulerJob is UI representation of engine.Job entity.
 type schedulerJob struct {
         ProjectID      string
-        JobID          string
+        JobName        string
         Schedule       string
         Definition     string
         Revision       string
         RevisionURL    string
         State          string
         Overruns       int
         NextRun        string
         Paused         bool
         LabelClass     string
         JobFlavorIcon  string
@@ skipping 52 matching lines @@
                 // Job invocation is still in the task queue, but new invocation should be
                 // starting now (so the queue is lagging for some reason).
                 labelClass = "label-warning"
         }
         // Put triggers after regular jobs.
         sortGroup := "A"
         if j.Flavor == catalog.JobFlavorTrigger {
                 sortGroup = "B"
         }
 
-        // JobID has form <project>/<id>. Split it into components.
-        chunks := strings.Split(j.JobID, "/")
-
         return &schedulerJob{
-                ProjectID:      chunks[0],
-                JobID:          chunks[1],
+                ProjectID:      j.ProjectID,
+                JobName:        j.GetJobName(),
                 Schedule:       j.Schedule,
                 Definition:     taskToText(j.Task),
                 Revision:       j.Revision,
                 RevisionURL:    j.RevisionURL,
                 State:          string(state),
                 Overruns:       j.State.Overruns,
                 NextRun:        nextRun,
                 Paused:         j.Paused,
                 LabelClass:     labelClass,
                 JobFlavorIcon:  flavorToIconClass[j.Flavor],
@@ skipping 21 matching lines @@
 }
 
 type sortedJobs []*schedulerJob
 
 func (s sortedJobs) Len() int      { return len(s) }
 func (s sortedJobs) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
 func (s sortedJobs) Less(i, j int) bool {
         return sortby.Chain{
                 func(i, j int) bool { return s[i].ProjectID < s[j].ProjectID },
                 func(i, j int) bool { return s[i].sortGroup < s[j].sortGroup },
-                func(i, j int) bool { return s[i].JobID < s[j].JobID },
+                func(i, j int) bool { return s[i].JobName < s[j].JobName },
         }.Use(i, j)
 }
 
 // sortJobs instantiate a bunch of schedulerJob objects and sorts them in
 // display order.
 func sortJobs(c context.Context, jobs []*engine.Job) sortedJobs {
         out := make(sortedJobs, len(jobs))
         for i, job := range jobs {
                 out[i] = makeJob(c, job)
         }
         sort.Sort(out)
         return out
 }
 
 // invocation is UI representation of engine.Invocation entity.
 type invocation struct {
         ProjectID   string
-        JobID       string
+        JobName     string
         InvID       int64
         Attempt     int64
         Revision    string
         RevisionURL string
         Definition  string
         TriggeredBy string
         Started     string
         Duration    string
         Status      string
         DebugLog    string
@@ skipping 43 matching lines @@
         if finished.IsZero() {
                 finished = j.now
         }
         duration := humanize.RelTime(i.Started, finished, "", "")
         if duration == "now" {
                 duration = "1 second" // "now" looks weird for durations
         }
 
         return &invocation{
                 ProjectID:   j.ProjectID,
-                JobID:       j.JobID,
+                JobName:     j.JobName,
                 InvID:       i.ID,
                 Attempt:     i.RetryCount + 1,
                 Revision:    i.Revision,
                 RevisionURL: i.RevisionURL,
                 Definition:  taskToText(i.Task),
                 TriggeredBy: triggeredBy,
                 Started:     humanize.RelTime(i.Started, j.now, "ago", "from now"),
                 Duration:    duration,
                 Status:      string(status),
                 DebugLog:    i.DebugLog,
                 RowClass:    statusToRowClass[status],
                 LabelClass:  statusToLabelClass[status],
                 ViewURL:     i.ViewURL,
         }
 }