golang persist 代码
文件路径：/src/net/http/httputil/persist.go
/ Copyright 2009 The Go Authors. All rights reserved.
/ Use of this source code is governed by a BSD-style
/ license that can be found in the LICENSE file.
package httputil
import (
"bufio"
"errors"
"io"
"net"
"net/http"
"net/textproto"
"sync"
)
var (
/ Deprecated: No longer used.
ErrPersistEOF = &http.ProtocolError{ErrorString: "persistent connection closed"}
/ Deprecated: No longer used.
ErrClosed = &http.ProtocolError{ErrorString: "connection closed by user"}
/ Deprecated: No longer used.
ErrPipeline = &http.ProtocolError{ErrorString: "pipeline error"}
)
/ This is an API usage error - the local side is closed.
/ ErrPersistEOF (above) reports that the remote side is closed.
var errClosed = errors.New("i/o operation on closed connection")
/ ServerConn is an artifact of Go's early HTTP implementation.
/ It is low-level, old, and unused by Go's current HTTP stack.
/ We should have deleted it before Go 1.
/
/ Deprecated: Use the Server in package net/http instead.
type ServerConn struct {
mu sync.Mutex / read-write protects the following fields
c net.Conn
r *bufio.Reader
re, we error / read/write errors
lastbody io.ReadCloser
nread, nwritten int
pipereq map[*http.Request]uint
pipe textproto.Pipeline
}
/ NewServerConn is an artifact of Go's early HTTP implementation.
/ It is low-level, old, and unused by Go's current HTTP stack.
/ We should have deleted it before Go 1.
/
/ Deprecated: Use the Server in package net/http instead.
func NewServerConn(c net.Conn, r *bufio.Reader) *ServerConn {
if r == nil {
r = bufio.NewReader(c)
}
return &ServerConn{c: c, r: r, pipereq: make(map[*http.Request]uint)}
}
/ Hijack detaches the ServerConn and returns the underlying connection as well
/ as the read-side bufio which may have some left over data. Hijack may be
/ 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() (net.Conn, *bufio.Reader) {
sc.mu.Lock()
defer sc.mu.Unlock()
c := sc.c
r := sc.r
sc.c = nil
sc.r = nil
return c, r
}
/ Close calls Hijack and then also closes the underlying connection.
func (sc *ServerConn) Close() error {
c, _ := sc.Hijack()
if c != nil {
return c.Close()
}
return nil
}
/ Read returns the next request on the wire. An ErrPersistEOF is returned if
/ it is gracefully determined that there are no more requests (e.g. after the
/ first request on an HTTP/1.0 connection, or after a Connection:close on a
/ HTTP/1.1 connection).
func (sc *ServerConn) Read() (*http.Request, error) {
var req *http.Request
var err error
/ Ensure ordered execution of Reads and Writes
id := sc.pipe.Next()
sc.pipe.StartRequest(id)
defer func() {
sc.pipe.EndRequest(id)
if req == nil {
sc.pipe.StartResponse(id)
sc.pipe.EndResponse(id)
} else {
/ Remember the pipeline id of this request
sc.mu.Lock()
sc.pipereq[req] = id
sc.mu.Unlock()
}
}()
sc.mu.Lock()
if sc.we != nil { / no point receiving if write-side broken or closed
defer sc.mu.Unlock()
return nil, sc.we
}
if sc.re != nil {
defer sc.mu.Unlock()
return nil, sc.re
}
if sc.r == nil { / connection closed by user in the meantime
defer sc.mu.Unlock()
return nil, errClosed
}
r := sc.r
lastbody := sc.lastbody
sc.lastbody = nil
sc.mu.Unlock()
/ Make sure body is fully consumed, even if user does not call body.Close
if lastbody != nil {
/ body.Close is assumed to be idempotent and multiple calls to
/ it should return the error that its first invocation
/ returned.
err = lastbody.Close()
if err != nil {
sc.mu.Lock()
defer sc.mu.Unlock()
sc.re = err
return nil, err
}
}
req, err = http.ReadRequest(r)
sc.mu.Lock()
defer sc.mu.Unlock()
if err != nil {
if err == io.ErrUnexpectedEOF {
/ A close from the opposing client is treated as a
/ graceful close, even if there was some unparse-able
/ data before the close.
sc.re = ErrPersistEOF
return nil, sc.re
} else {
sc.re = err
return req, err
}
}
sc.lastbody = req.Body
sc.nread++
if req.Close {
sc.re = ErrPersistEOF
return req, sc.re
}
return req, err
}
/ Pending returns the number of unanswered requests
/ that have been received on the connection.
func (sc *ServerConn) Pending() int {
sc.mu.Lock()
defer sc.mu.Unlock()
return sc.nread - sc.nwritten
}
/ Write writes resp in response to req. To close the connection gracefully, set the
/ Response.Close field to true. Write should be considered operational until
/ it returns an error, regardless of any errors returned on the Read side.
func (sc *ServerConn) Write(req *http.Request, resp *http.Response) error {
/ Retrieve the pipeline ID of this request/response pair
sc.mu.Lock()
id, ok := sc.pipereq[req]
delete(sc.pipereq, req)
if !ok {
sc.mu.Unlock()
return ErrPipeline
}
sc.mu.Unlock()
/ Ensure pipeline order
sc.pipe.StartResponse(id)
defer sc.pipe.EndResponse(id)
sc.mu.Lock()
if sc.we != nil {
defer sc.mu.Unlock()
return sc.we
}
if sc.c == nil { / connection closed by user in the meantime
defer sc.mu.Unlock()
return ErrClosed
}
c := sc.c
if sc.nread <= sc.nwritten {
defer sc.mu.Unlock()
return errors.New("persist server pipe count")
}
if resp.Close {
/ After signaling a keep-alive close, any pipelined unread
/ requests will be lost. It is up to the user to drain them
/ before signaling.
sc.re = ErrPersistEOF
}
sc.mu.Unlock()
err := resp.Write(c)
sc.mu.Lock()
defer sc.mu.Unlock()
if err != nil {
sc.we = err
return err
}
sc.nwritten++
return nil
}
/ ClientConn is an artifact of Go's early HTTP implementation.
/ It is low-level, old, and unused by Go's current HTTP stack.
/ We should have deleted it before Go 1.
/
/ Deprecated: Use Client or Transport in package net/http instead.
type ClientConn struct {
mu sync.Mutex / read-write protects the following fields
c net.Conn
r *bufio.Reader
re, we error / read/write errors
lastbody io.ReadCloser
nread, nwritten int
pipereq map[*http.Request]uint
pipe textproto.Pipeline
writeReq func(*http.Request, io.Writer) error
}
/ NewClientConn is an artifact of Go's early HTTP implementation.
/ It is low-level, old, and unused by Go's current HTTP stack.
/ We should have deleted it before Go 1.
/
/ Deprecated: Use the Client or Transport in package net/http instead.
func NewClientConn(c net.Conn, r *bufio.Reader) *ClientConn {
if r == nil {
r = bufio.NewReader(c)
}
return &ClientConn{
c: c,
r: r,
pipereq: make(map[*http.Request]uint),
writeReq: (*http.Request).Write,
}
}
/ NewProxyClientConn is an artifact of Go's early HTTP implementation.
/ It is low-level, old, and unused by Go's current HTTP stack.
/ We should have deleted it before Go 1.
/
/ Deprecated: Use the Client or Transport in package net/http instead.
func NewProxyClientConn(c net.Conn, r *bufio.Reader) *ClientConn {
cc := NewClientConn(c, r)
cc.writeReq = (*http.Request).WriteProxy
return cc
}
/ Hijack detaches the ClientConn and returns the underlying connection as well
/ as the read-side bufio which may have some left over data. Hijack may be
/ 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.mu.Lock()
defer cc.mu.Unlock()
c = cc.c
r = cc.r
cc.c = nil
cc.r = nil
return
}
/ Close calls Hijack and then also closes the underlying connection.
func (cc *ClientConn) Close() error {
c, _ := cc.Hijack()
if c != nil {
return c.Close()
}
return nil
}
/ Write writes a request. An ErrPersistEOF error is returned if the connection
/ has been closed in an HTTP keep-alive sense. If req.Close equals true, the
/ keep-alive connection is logically closed after this request and the opposing
/ server is informed. An ErrUnexpectedEOF indicates the remote closed the
/ underlying TCP connection, which is usually considered as graceful close.
func (cc *ClientConn) Write(req *http.Request) error {
var err error
/ Ensure ordered execution of Writes
id := cc.pipe.Next()
cc.pipe.StartRequest(id)
defer func() {
cc.pipe.EndRequest(id)
if err != nil {
cc.pipe.StartResponse(id)
cc.pipe.EndResponse(id)
} else {
/ Remember the pipeline id of this request
cc.mu.Lock()
cc.pipereq[req] = id
cc.mu.Unlock()
}
}()
cc.mu.Lock()
if cc.re != nil { / no point sending if read-side closed or broken
defer cc.mu.Unlock()
return cc.re
}
if cc.we != nil {
defer cc.mu.Unlock()
return cc.we
}
if cc.c == nil { / connection closed by user in the meantime
defer cc.mu.Unlock()
return errClosed
}
c := cc.c
if req.Close {
/ We write the EOF to the write-side error, because there
/ still might be some pipelined reads
cc.we = ErrPersistEOF
}
cc.mu.Unlock()
err = cc.writeReq(req, c)
cc.mu.Lock()
defer cc.mu.Unlock()
if err != nil {
cc.we = err
return err
}
cc.nwritten++
return nil
}
/ Pending returns the number of unanswered requests
/ that have been sent on the connection.
func (cc *ClientConn) Pending() int {
cc.mu.Lock()
defer cc.mu.Unlock()
return cc.nwritten - cc.nread
}
/ Read reads the next response from the wire. A valid response might be
/ returned together with an ErrPersistEOF, which means that the remote
/ requested that this be the last request serviced. Read can be called
/ 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.mu.Lock()
id, ok := cc.pipereq[req]
delete(cc.pipereq, req)
if !ok {
cc.mu.Unlock()
return nil, ErrPipeline
}
cc.mu.Unlock()
/ Ensure pipeline order
cc.pipe.StartResponse(id)
defer cc.pipe.EndResponse(id)
cc.mu.Lock()
if cc.re != nil {
defer cc.mu.Unlock()
return nil, cc.re
}
if cc.r == nil { / connection closed by user in the meantime
defer cc.mu.Unlock()
return nil, errClosed
}
r := cc.r
lastbody := cc.lastbody
cc.lastbody = nil
cc.mu.Unlock()
/ Make sure body is fully consumed, even if user does not call body.Close
if lastbody != nil {
/ body.Close is assumed to be idempotent and multiple calls to
/ it should return the error that its first invocation
/ returned.
err = lastbody.Close()
if err != nil {
cc.mu.Lock()
defer cc.mu.Unlock()
cc.re = err
return nil, err
}
}
resp, err = http.ReadResponse(r, req)
cc.mu.Lock()
defer cc.mu.Unlock()
if err != nil {
cc.re = err
return resp, err
}
cc.lastbody = resp.Body
cc.nread++
if resp.Close {
cc.re = ErrPersistEOF / don't send any more requests
return resp, cc.re
}
return resp, err
}
/ Do is convenience method that writes a request and reads a response.
func (cc *ClientConn) Do(req *http.Request) (*http.Response, error) {
err := cc.Write(req)
if err != nil {
return nil, err
}
return cc.Read(req)
}