[milo] build_source -> buildSource.

milo/buildsource/swarming/build.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 swarming
 
 import (
         "bytes"
         "fmt"
         "net/http"
         "net/url"
         "strings"
         "time"
 
         "golang.org/x/net/context"
 
         swarming "github.com/luci/luci-go/common/api/swarming/swarming/v1"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/proto/google"
         miloProto "github.com/luci/luci-go/common/proto/milo"
         "github.com/luci/luci-go/common/sync/parallel"
         "github.com/luci/luci-go/logdog/client/annotee"
         "github.com/luci/luci-go/logdog/client/coordinator"
         "github.com/luci/luci-go/logdog/common/types"
         "github.com/luci/luci-go/milo/api/resp"
-        "github.com/luci/luci-go/milo/build_source/raw_presentation"
+        "github.com/luci/luci-go/milo/buildsource/rawpresentation"
         "github.com/luci/luci-go/milo/common"
         "github.com/luci/luci-go/milo/common/model"
         "github.com/luci/luci-go/server/auth"
 )
 
 // errNotMiloJob is returned if a Swarming task is fetched that does not self-
 // identify as a Milo job.
 var errNotMiloJob = errors.New("Not a Milo Job or access denied")
 
 // SwarmingTimeLayout is time layout used by swarming.
@@ skipping 417 matching lines @@
         // Add a link to the bot.
         if sr.BotId != "" {
                 build.Summary.Bot = resp.NewLink(sr.BotId, botPageURL(server, sr.BotId))
         }
 
         return nil
 }
 
 // streamsFromAnnotatedLog takes in an annotated log and returns a fully
 // populated set of logdog streams
-func streamsFromAnnotatedLog(ctx context.Context, log string) (*raw_presentation.Streams, error) {
+func streamsFromAnnotatedLog(ctx context.Context, log string) (*rawpresentation.Streams, error) {
         c := &memoryClient{}
         p := annotee.New(ctx, annotee.Options{
                 Client:                 c,
                 MetadataUpdateInterval: -1, // Neverrrrrr send incr updates.
                 Offline:                true,
         })
 
         is := annotee.Stream{
                 Reader:           bytes.NewBufferString(log),
                 Name:             types.StreamName("stdout"),
@@ skipping 15 matching lines @@
 // for testing.
 type buildLoader struct {
         // logdogClientFunc returns a coordinator Client instance for the supplied
         // parameters.
         //
         // If nil, a production client will be generated.
         logDogClientFunc func(c context.Context, host string) (*coordinator.Client, error)
 }
 
 func (bl *buildLoader) newEmptyAnnotationStream(c context.Context, addr *types.StreamAddr) (
-        *raw_presentation.AnnotationStream, error) {
+        *rawpresentation.AnnotationStream, error) {
 
         fn := bl.logDogClientFunc
         if fn == nil {
-                fn = raw_presentation.NewClient
+                fn = rawpresentation.NewClient
         }
         client, err := fn(c, addr.Host)
         if err != nil {
                 return nil, errors.Annotate(err, "failed to create LogDog client").Err()
         }
 
-        as := raw_presentation.AnnotationStream{
+        as := rawpresentation.AnnotationStream{
                 Client:  client,
                 Project: addr.Project,
                 Path:    addr.Path,
         }
         if err := as.Normalize(); err != nil {
                 return nil, errors.Annotate(err, "failed to normalize annotation stream parameters").Err()
         }
 
         return &as, nil
 }
@@ skipping 57 matching lines @@
                         return true
                 },
         }
         fr, err := swarmingFetch(c, svc, taskID, fetchParams)
         if err != nil {
                 return nil, err
         }
 
         var build resp.MiloBuild
         var s *miloProto.Step
-        var lds *raw_presentation.Streams
-        var ub raw_presentation.URLBuilder
+        var lds *rawpresentation.Streams
+        var ub rawpresentation.URLBuilder
 
         // Load the build from the available data.
         //
         // If the Swarming task explicitly specifies its log location, we prefer that.
         // As a fallback, we will try and parse the Swarming task's output for
         // annotations.
         switch {
         case logDogStreamAddr != nil:
                 logging.Infof(c, "Loading build from LogDog stream at: %s", logDogStreamAddr)
 
                 // If the LogDog stream is available, load the step from that.
                 as, err := bl.newEmptyAnnotationStream(c, logDogStreamAddr)
                 if err != nil {
                         return nil, errors.Annotate(err, "failed to create LogDog annotation stream").Err()
                 }
 
                 prefix, _ := logDogStreamAddr.Path.Split()
-                ub = &raw_presentation.ViewerURLBuilder{
+                ub = &rawpresentation.ViewerURLBuilder{
                         Host:    logDogStreamAddr.Host,
                         Prefix:  prefix,
                         Project: logDogStreamAddr.Project,
                 }
 
                 if s, err = as.Fetch(c); err != nil {
                         switch errors.Unwrap(err) {
                         case coordinator.ErrNoSuchStream:
                                 // The stream was not found.  This could be due to one of two things:
                                 // 1. The step just started and we're just waiting for the logs
@@ skipping 41 matching lines @@
 
         default:
                 s = &miloProto.Step{}
                 ub = swarmingURLBuilder(linkBase)
         }
 
         if s != nil {
                 if err := addTaskToMiloStep(c, svc.getHost(), fr.res, s); err != nil {
                         return nil, err
                 }
-                raw_presentation.AddLogDogToBuild(c, ub, s, &build)
+                rawpresentation.AddLogDogToBuild(c, ub, s, &build)
         }
 
         if err := addTaskToBuild(c, svc.getHost(), fr.res, &build); err != nil {
                 return nil, err
         }
 
         return &build, nil
 }
 
 func infoComponent(st model.Status, label, text string) *resp.BuildComponent {
@@ skipping 86 matching lines @@
         for _, tag := range v {
                 var value string
                 parts := strings.SplitN(tag, ":", 2)
                 if len(parts) == 2 {
                         value = parts[1]
                 }
                 res[parts[0]] = value
         }
         return res
 }