LogDog: Update client/bootstrap to generate URLs.

logdog/client/butler/butler.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 butler
 
 import (
         "errors"
         "fmt"
         "io"
@@ skipping 295 matching lines @@
                 for {
                         rc, config := streamServer.Next()
                         if rc == nil {
                                 log.Debugf(ctx, "StreamServer returned nil stream; terminating.")
                                 return
                         }
 
                         // Add this Stream to the Butler.
                         //
                         // We run this in a function so we can ensure cleanup on failure.
-                        if err := b.AddStream(rc, *config); err != nil {
+                        if err := b.AddStream(rc, config); err != nil {
                                 log.Fields{
                                         log.ErrorKey: err,
                                 }.Errorf(ctx, "Failed to add stream.")
 
                                 if err := rc.Close(); err != nil {
                                         log.Fields{
                                                 log.ErrorKey: err,
                                         }.Warningf(ctx, "Failed to close stream.")
                                 }
                         }
@@ skipping 13 matching lines @@
         }()
 }
 
 // AddStream adds a Stream to the Butler. This is goroutine-safe.
 //
 // If no error is returned, the Butler assumes ownership of the supplied stream.
 // The stream will be closed when processing is finished.
 //
 // If an error is occurred, the caller is still the owner of the stream and
 // is responsible for closing it.
-func (b *Butler) AddStream(rc io.ReadCloser, p streamproto.Properties) error {
+func (b *Butler) AddStream(rc io.ReadCloser, p *streamproto.Properties) error {
+        p = p.Clone()
         if p.Timestamp == nil || p.Timestamp.Time().IsZero() {
                 p.Timestamp = google.NewTimestamp(clock.Now(b.ctx))
         }
         if err := p.Validate(); err != nil {
                 return err
         }
 
         if p.Timeout > 0 {
                 if rts, ok := rc.(iotools.ReadTimeoutSetter); ok {
                         if err := rts.SetReadTimeout(p.Timeout); err != nil {
@@ skipping 25 matching lines @@
         case streamproto.TeeStderr:
                 if b.c.TeeStderr == nil {
                         return errors.New("butler: cannot tee through STDERR; no STDERR is configured")
                 }
                 reader = io.TeeReader(rc, b.c.TeeStderr)
 
         default:
                 return fmt.Errorf("invalid tee value: %v", p.Tee)
         }
 
-        p.Prefix = string(b.c.Prefix)
         if err := b.registerStream(p.Name); err != nil {
                 return err
         }
 
+        // Register this stream with our Bundler. It will take ownership of "p", so
+        // we should not use it after this point.
+        streamCtx := log.SetField(b.ctx, "stream", p.Name)
         bs, err := b.bundler.Register(p)
         if err != nil {
                 return err
         }
+        p = nil
 
         b.streamC <- &stream{
-                Context: log.SetField(b.ctx, "stream", p.Name),
+                Context: streamCtx,
                 r:       reader,
                 c:       rc,
                 bs:      bs,
         }
         return nil
 }
 
 func (b *Butler) runStreams(activateC chan struct{}) {
         streamFinishedC := make(chan struct{})
         streamC := b.streamC
@@ skipping 123 matching lines @@
         // shutdown prematurely, so this should be reasonably quick.
         b.Activate()
 }
 
 // Returns the configured Butler error.
 func (b *Butler) getRunErr() error {
         b.shutdownMu.Lock()
         defer b.shutdownMu.Unlock()
         return b.runErr
 }