...
Run Format

Source file 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 keepalive sense. If req.Close equals true, the
  // keepalive 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)
  }
  

View as plain text