Butler stream servers can generate client address.

logdog/client/butler/streamserver/base.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 streamserver
 
 import (
         "fmt"
         "io"
         "net"
@@ skipping 14 matching lines @@
         rc io.ReadCloser
         // Negotiated stream properties.
         properties *streamproto.Properties
 }
 
 // listenerStreamServer is the class for Listener-based stream server
 // implementations.
 type listenerStreamServer struct {
         context.Context
 
+        // address is the string returned by the Address method.
+        address string
+
         // gen is a generator function that is called to produce the stream server's
         // Listener. On success, it returns the instantiated Listener, which will be
         // closed when the stream server is closed.
         gen   func() (net.Listener, error)
         l     net.Listener
         laddr string
 
         streamParamsC   chan *streamParams
         closedC         chan struct{}
         acceptFinishedC chan struct{}
 
         // closed is an atomically-protected integer. If its value is 1, the stream
         // server has been closed.
         closed int32
 
         // discardC is a testing channel. If not nil, failed client connections will
         // be written here.
         discardC chan *streamClient
 }
 
 var _ StreamServer = (*listenerStreamServer)(nil)
 
 func (s *listenerStreamServer) String() string {
         return fmt.Sprintf("%T(%s)", s, s.laddr)
 }
 
+func (s *listenerStreamServer) Address() string { return s.address }
+
 func (s *listenerStreamServer) Listen() error {
         // Create a listener (OS-specific).
         var err error
         s.l, err = s.gen()
         if err != nil {
                 return err
         }
 
         s.laddr = s.l.Addr().String()
         s.streamParamsC = make(chan *streamParams)
@@ skipping 180 matching lines @@
 
 // Decouples the active connection, returning it and setting the connection to
 // nil.
 func (c *streamClient) decoupleConn() (conn net.Conn) {
         c.decoupleMu.Lock()
         defer c.decoupleMu.Unlock()
 
         conn, c.conn = c.conn, nil
         return
 }