From: Brad Fitzpatrick Date: Thu, 31 Mar 2016 07:31:58 +0000 (-0700) Subject: net/http, net/http/httputil: rename lk to mu X-Git-Tag: go1.7beta1~974 X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=e55896b9f421aeb6c33056a7cf6d7f90f8e36365;p=gostls13.git net/http, net/http/httputil: rename lk to mu The conventional name for a sync.Mutex is "mu". These "lk" names date back to a time before conventions. Change-Id: Iee57f9f4423d04269e1125b5d82455c453aac26f Reviewed-on: https://go-review.googlesource.com/21361 Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot Reviewed-by: Emmanuel Odeke Reviewed-by: Brad Fitzpatrick --- diff --git a/src/net/http/httputil/persist.go b/src/net/http/httputil/persist.go index 4cb110b716..37171f0e03 100644 --- a/src/net/http/httputil/persist.go +++ b/src/net/http/httputil/persist.go @@ -34,7 +34,7 @@ var errClosed = errors.New("i/o operation on closed connection") // ServerConn is low-level and old. Applications should instead use Server // in the net/http package. type ServerConn struct { - lk sync.Mutex // read-write protects the following fields + mu sync.Mutex // read-write protects the following fields c net.Conn r *bufio.Reader re, we error // read/write errors @@ -62,8 +62,8 @@ func NewServerConn(c net.Conn, r *bufio.Reader) *ServerConn { // called before Read has signaled the end of the keep-alive logic. The user // should not call Hijack while Read or Write is in progress. func (sc *ServerConn) Hijack() (c net.Conn, r *bufio.Reader) { - sc.lk.Lock() - defer sc.lk.Unlock() + sc.mu.Lock() + defer sc.mu.Unlock() c = sc.c r = sc.r sc.c = nil @@ -96,29 +96,29 @@ func (sc *ServerConn) Read() (req *http.Request, err error) { sc.pipe.EndResponse(id) } else { // Remember the pipeline id of this request - sc.lk.Lock() + sc.mu.Lock() sc.pipereq[req] = id - sc.lk.Unlock() + sc.mu.Unlock() } }() - sc.lk.Lock() + sc.mu.Lock() if sc.we != nil { // no point receiving if write-side broken or closed - defer sc.lk.Unlock() + defer sc.mu.Unlock() return nil, sc.we } if sc.re != nil { - defer sc.lk.Unlock() + defer sc.mu.Unlock() return nil, sc.re } if sc.r == nil { // connection closed by user in the meantime - defer sc.lk.Unlock() + defer sc.mu.Unlock() return nil, errClosed } r := sc.r lastbody := sc.lastbody sc.lastbody = nil - sc.lk.Unlock() + sc.mu.Unlock() // Make sure body is fully consumed, even if user does not call body.Close if lastbody != nil { @@ -127,16 +127,16 @@ func (sc *ServerConn) Read() (req *http.Request, err error) { // returned. err = lastbody.Close() if err != nil { - sc.lk.Lock() - defer sc.lk.Unlock() + sc.mu.Lock() + defer sc.mu.Unlock() sc.re = err return nil, err } } req, err = http.ReadRequest(r) - sc.lk.Lock() - defer sc.lk.Unlock() + sc.mu.Lock() + defer sc.mu.Unlock() if err != nil { if err == io.ErrUnexpectedEOF { // A close from the opposing client is treated as a @@ -161,8 +161,8 @@ func (sc *ServerConn) Read() (req *http.Request, err error) { // Pending returns the number of unanswered requests // that have been received on the connection. func (sc *ServerConn) Pending() int { - sc.lk.Lock() - defer sc.lk.Unlock() + sc.mu.Lock() + defer sc.mu.Unlock() return sc.nread - sc.nwritten } @@ -172,31 +172,31 @@ func (sc *ServerConn) Pending() int { func (sc *ServerConn) Write(req *http.Request, resp *http.Response) error { // Retrieve the pipeline ID of this request/response pair - sc.lk.Lock() + sc.mu.Lock() id, ok := sc.pipereq[req] delete(sc.pipereq, req) if !ok { - sc.lk.Unlock() + sc.mu.Unlock() return ErrPipeline } - sc.lk.Unlock() + sc.mu.Unlock() // Ensure pipeline order sc.pipe.StartResponse(id) defer sc.pipe.EndResponse(id) - sc.lk.Lock() + sc.mu.Lock() if sc.we != nil { - defer sc.lk.Unlock() + defer sc.mu.Unlock() return sc.we } if sc.c == nil { // connection closed by user in the meantime - defer sc.lk.Unlock() + defer sc.mu.Unlock() return ErrClosed } c := sc.c if sc.nread <= sc.nwritten { - defer sc.lk.Unlock() + defer sc.mu.Unlock() return errors.New("persist server pipe count") } if resp.Close { @@ -205,11 +205,11 @@ func (sc *ServerConn) Write(req *http.Request, resp *http.Response) error { // before signaling. sc.re = ErrPersistEOF } - sc.lk.Unlock() + sc.mu.Unlock() err := resp.Write(c) - sc.lk.Lock() - defer sc.lk.Unlock() + sc.mu.Lock() + defer sc.mu.Unlock() if err != nil { sc.we = err return err @@ -227,7 +227,7 @@ func (sc *ServerConn) Write(req *http.Request, resp *http.Response) error { // ClientConn is low-level and old. Applications should instead use // Client or Transport in the net/http package. type ClientConn struct { - lk sync.Mutex // read-write protects the following fields + mu sync.Mutex // read-write protects the following fields c net.Conn r *bufio.Reader re, we error // read/write errors @@ -272,8 +272,8 @@ func NewProxyClientConn(c net.Conn, r *bufio.Reader) *ClientConn { // called before the user or Read have signaled the end of the keep-alive // logic. The user should not call Hijack while Read or Write is in progress. func (cc *ClientConn) Hijack() (c net.Conn, r *bufio.Reader) { - cc.lk.Lock() - defer cc.lk.Unlock() + cc.mu.Lock() + defer cc.mu.Unlock() c = cc.c r = cc.r cc.c = nil @@ -307,23 +307,23 @@ func (cc *ClientConn) Write(req *http.Request) (err error) { cc.pipe.EndResponse(id) } else { // Remember the pipeline id of this request - cc.lk.Lock() + cc.mu.Lock() cc.pipereq[req] = id - cc.lk.Unlock() + cc.mu.Unlock() } }() - cc.lk.Lock() + cc.mu.Lock() if cc.re != nil { // no point sending if read-side closed or broken - defer cc.lk.Unlock() + defer cc.mu.Unlock() return cc.re } if cc.we != nil { - defer cc.lk.Unlock() + defer cc.mu.Unlock() return cc.we } if cc.c == nil { // connection closed by user in the meantime - defer cc.lk.Unlock() + defer cc.mu.Unlock() return errClosed } c := cc.c @@ -332,11 +332,11 @@ func (cc *ClientConn) Write(req *http.Request) (err error) { // still might be some pipelined reads cc.we = ErrPersistEOF } - cc.lk.Unlock() + cc.mu.Unlock() err = cc.writeReq(req, c) - cc.lk.Lock() - defer cc.lk.Unlock() + cc.mu.Lock() + defer cc.mu.Unlock() if err != nil { cc.we = err return err @@ -349,8 +349,8 @@ func (cc *ClientConn) Write(req *http.Request) (err error) { // Pending returns the number of unanswered requests // that have been sent on the connection. func (cc *ClientConn) Pending() int { - cc.lk.Lock() - defer cc.lk.Unlock() + cc.mu.Lock() + defer cc.mu.Unlock() return cc.nwritten - cc.nread } @@ -360,32 +360,32 @@ func (cc *ClientConn) Pending() int { // concurrently with Write, but not with another Read. func (cc *ClientConn) Read(req *http.Request) (resp *http.Response, err error) { // Retrieve the pipeline ID of this request/response pair - cc.lk.Lock() + cc.mu.Lock() id, ok := cc.pipereq[req] delete(cc.pipereq, req) if !ok { - cc.lk.Unlock() + cc.mu.Unlock() return nil, ErrPipeline } - cc.lk.Unlock() + cc.mu.Unlock() // Ensure pipeline order cc.pipe.StartResponse(id) defer cc.pipe.EndResponse(id) - cc.lk.Lock() + cc.mu.Lock() if cc.re != nil { - defer cc.lk.Unlock() + defer cc.mu.Unlock() return nil, cc.re } if cc.r == nil { // connection closed by user in the meantime - defer cc.lk.Unlock() + defer cc.mu.Unlock() return nil, errClosed } r := cc.r lastbody := cc.lastbody cc.lastbody = nil - cc.lk.Unlock() + cc.mu.Unlock() // Make sure body is fully consumed, even if user does not call body.Close if lastbody != nil { @@ -394,16 +394,16 @@ func (cc *ClientConn) Read(req *http.Request) (resp *http.Response, err error) { // returned. err = lastbody.Close() if err != nil { - cc.lk.Lock() - defer cc.lk.Unlock() + cc.mu.Lock() + defer cc.mu.Unlock() cc.re = err return nil, err } } resp, err = http.ReadResponse(r, req) - cc.lk.Lock() - defer cc.lk.Unlock() + cc.mu.Lock() + defer cc.mu.Unlock() if err != nil { cc.re = err return resp, err diff --git a/src/net/http/httputil/reverseproxy.go b/src/net/http/httputil/reverseproxy.go index 26a668b6df..ecee0f242a 100644 --- a/src/net/http/httputil/reverseproxy.go +++ b/src/net/http/httputil/reverseproxy.go @@ -285,13 +285,13 @@ type maxLatencyWriter struct { dst writeFlusher latency time.Duration - lk sync.Mutex // protects Write + Flush + mu sync.Mutex // protects Write + Flush done chan bool } func (m *maxLatencyWriter) Write(p []byte) (int, error) { - m.lk.Lock() - defer m.lk.Unlock() + m.mu.Lock() + defer m.mu.Unlock() return m.dst.Write(p) } @@ -306,9 +306,9 @@ func (m *maxLatencyWriter) flushLoop() { } return case <-t.C: - m.lk.Lock() + m.mu.Lock() m.dst.Flush() - m.lk.Unlock() + m.mu.Unlock() } } } diff --git a/src/net/http/transport.go b/src/net/http/transport.go index b6a1b33014..06ac939bd5 100644 --- a/src/net/http/transport.go +++ b/src/net/http/transport.go @@ -1015,7 +1015,7 @@ type persistConn struct { // whether or not a connection can be reused. Issue 7569. writeErrCh chan error - lk sync.Mutex // guards following fields + mu sync.Mutex // guards following fields numExpectedResponses int closed error // set non-nil when conn is closed, before closech is closed broken bool // an error has happened on this connection; marked broken so it's not reused. @@ -1029,30 +1029,30 @@ type persistConn struct { // isBroken reports whether this connection is in a known broken state. func (pc *persistConn) isBroken() bool { - pc.lk.Lock() + pc.mu.Lock() b := pc.broken - pc.lk.Unlock() + pc.mu.Unlock() return b } // isCanceled reports whether this connection was closed due to CancelRequest. func (pc *persistConn) isCanceled() bool { - pc.lk.Lock() - defer pc.lk.Unlock() + pc.mu.Lock() + defer pc.mu.Unlock() return pc.canceled } // isReused reports whether this connection is in a known broken state. func (pc *persistConn) isReused() bool { - pc.lk.Lock() + pc.mu.Lock() r := pc.reused - pc.lk.Unlock() + pc.mu.Unlock() return r } func (pc *persistConn) cancelRequest() { - pc.lk.Lock() - defer pc.lk.Unlock() + pc.mu.Lock() + defer pc.mu.Unlock() pc.canceled = true pc.closeLocked(errRequestCanceled) } @@ -1087,13 +1087,13 @@ func (pc *persistConn) readLoop() { err = beforeRespHeaderError{err} } - pc.lk.Lock() + pc.mu.Lock() if pc.numExpectedResponses == 0 { pc.readLoopPeekFailLocked(err) - pc.lk.Unlock() + pc.mu.Unlock() return } - pc.lk.Unlock() + pc.mu.Unlock() rc := <-pc.reqch @@ -1121,9 +1121,9 @@ func (pc *persistConn) readLoop() { return } - pc.lk.Lock() + pc.mu.Lock() pc.numExpectedResponses-- - pc.lk.Unlock() + pc.mu.Unlock() hasBody := rc.req.Method != "HEAD" && resp.ContentLength != 0 @@ -1412,10 +1412,10 @@ func (pc *persistConn) roundTrip(req *transportRequest) (resp *Response, err err pc.t.putOrCloseIdleConn(pc) return nil, errRequestCanceled } - pc.lk.Lock() + pc.mu.Lock() pc.numExpectedResponses++ headerFn := pc.mutateHeaderFunc - pc.lk.Unlock() + pc.mu.Unlock() if headerFn != nil { headerFn(req.extraHeaders()) @@ -1531,17 +1531,17 @@ WaitResponse: // It differs from close in that it doesn't close the underlying // connection for use when it's still being read. func (pc *persistConn) markBroken() { - pc.lk.Lock() - defer pc.lk.Unlock() + pc.mu.Lock() + defer pc.mu.Unlock() pc.broken = true } // markReused marks this connection as having been successfully used for a // request and response. func (pc *persistConn) markReused() { - pc.lk.Lock() + pc.mu.Lock() pc.reused = true - pc.lk.Unlock() + pc.mu.Unlock() } // close closes the underlying TCP connection and closes @@ -1550,8 +1550,8 @@ func (pc *persistConn) markReused() { // The provided err is only for testing and debugging; in normal // circumstances it should never be seen by users. func (pc *persistConn) close(err error) { - pc.lk.Lock() - defer pc.lk.Unlock() + pc.mu.Lock() + defer pc.mu.Unlock() pc.closeLocked(err) }