LogDog: Update client/bootstrap to generate URLs.

logdog/client/butler/bundler/bundler.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 bundler
 
 import (
         "container/heap"
         "fmt"
         "sync"
@@ skipping 75 matching lines @@
                 streams:   map[string]bundlerStream{},
         }
         b.streamsCond = cancelcond.New(&b.streamsLock)
 
         go b.makeBundles()
         return &b
 }
 
 // Register adds a new stream to the Bundler, returning a reference to the
 // registered stream.
-func (b *Bundler) Register(p streamproto.Properties) (Stream, error) {
+//
+// The Bundler takes ownership of the supplied Properties, and may modify them
+// as needed.
+func (b *Bundler) Register(p *streamproto.Properties) (Stream, error) {
         // Our Properties must validate.
         if err := p.Validate(); err != nil {
                 return nil, err
         }
 
         // Enforce that the log stream descriptor's Prefix is empty.
         p.Prefix = ""
 
         // Construct a parser for this stream.
         c := streamConfig{
                 name: p.Name,
                 template: logpb.ButlerLogBundle_Entry{
-                        Desc: &p.LogStreamDescriptor,
+                        Desc: p.LogStreamDescriptor,
                 },
                 maximumBufferDuration: b.c.MaxBufferDelay,
                 maximumBufferedBytes:  b.c.MaxBufferedBytes,
                 onAppend: func(appended bool) {
                         if appended {
                                 b.signalStreamUpdate()
                         }
                 },
         }
 
         err := error(nil)
-        c.parser, err = newParser(&p, &b.prefixCounter)
+        c.parser, err = newParser(p, &b.prefixCounter)
         if err != nil {
                 return nil, fmt.Errorf("failed to create stream parser: %s", err)
         }
 
         b.streamsLock.Lock()
         defer b.streamsLock.Unlock()
 
         // Ensure that this is not a duplicate stream name.
         if s := b.streams[p.Name]; s != nil {
                 return nil, fmt.Errorf("a Stream is already registered for %q", p.Name)
@@ skipping 358 matching lines @@
 
 func (s *streamState) Push(x interface{}) {
         s.streams = append(s.streams, x.(bundlerStream))
 }
 
 func (s *streamState) Pop() interface{} {
         last := s.streams[len(s.streams)-1]
         s.streams = s.streams[:len(s.streams)-1]
         return last
 }