LogDog: Update client/bootstrap to generate URLs.

milo/appengine/swarming/memoryClient.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"
 
         "github.com/golang/protobuf/proto"
         miloProto "github.com/luci/luci-go/common/proto/milo"
         "github.com/luci/luci-go/logdog/client/butlerlib/streamclient"
         "github.com/luci/luci-go/logdog/client/butlerlib/streamproto"
         "github.com/luci/luci-go/milo/appengine/logdog"
 )
 
 // In-memory datastructure to hold a fake butler client.
 type memoryStream struct {
-        *streamproto.Properties
+        props *streamproto.Properties
 
         closed     bool
         buf        bytes.Buffer
         isDatagram bool
 }
 
 func (s *memoryStream) ToLogDogStream() (*logdog.Stream, error) {
         result := &logdog.Stream{
                 Closed:     s.closed,
                 IsDatagram: s.isDatagram,
-                Path:       s.Name,
-                Prefix:     s.Prefix,
+                Path:       s.props.Name,
+                Prefix:     s.props.Prefix,
         }
 
         if s.isDatagram {
                 result.Data = &miloProto.Step{}
                 // Assume this is a miloProto.Step.
                 if err := proto.Unmarshal(s.buf.Bytes(), result.Data); err != nil {
                         return nil, err
                 }
         } else {
                 result.Text = s.buf.String()
@@ skipping 12 matching lines @@
 }
 
 func (s *memoryStream) WriteDatagram(b []byte) error {
         s.isDatagram = true
 
         s.buf.Reset()
         _, err := s.buf.Write(b)
         return err
 }
 
+func (s *memoryStream) Properties() *streamproto.Properties { return s.props.Clone() }
+
 type memoryClient struct {
         stream map[string]*memoryStream
 }
 
 func (c *memoryClient) NewStream(f streamproto.Flags) (streamclient.Stream, error) {
         props := f.Properties()
         if _, ok := c.stream[props.Name]; ok {
                 return nil, fmt.Errorf("duplicate stream, %q", props.Name)
         }
         s := memoryStream{
-                Properties: props,
+                props: props,
         }
         if c.stream == nil {
                 c.stream = map[string]*memoryStream{}
         }
-        c.stream[s.Name] = &s
+        c.stream[s.props.Name] = &s
         return &s, nil
 }
 
 func (c *memoryClient) addLogDogTextStream(s *logdog.Streams, ls *miloProto.LogdogStream) error {
         var keys []string
         for k := range c.stream {
                 keys = append(keys, k)
         }
         ms, ok := c.stream[ls.Name]
         if !ok {
@@ skipping 90 matching lines @@
                 for k := range result.Streams {
                         lk = append(lk, k)
                 }
                 return nil, fmt.Errorf(
                         "Number of streams do not match %d vs %d\nMemory:%s\nResult:%s",
                         len(c.stream), len(result.Streams), mk, lk)
         }
 
         return result, nil
 }