persist.go

Documentation: net/http/httputil

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package httputil
		 6  
		 7  import (
		 8  	"bufio"
		 9  	"errors"
		10  	"io"
		11  	"net"
		12  	"net/http"
		13  	"net/textproto"
		14  	"sync"
		15  )
		16  
		17  var (
		18  	// Deprecated: No longer used.
		19  	ErrPersistEOF = &http.ProtocolError{ErrorString: "persistent connection closed"}
		20  
		21  	// Deprecated: No longer used.
		22  	ErrClosed = &http.ProtocolError{ErrorString: "connection closed by user"}
		23  
		24  	// Deprecated: No longer used.
		25  	ErrPipeline = &http.ProtocolError{ErrorString: "pipeline error"}
		26  )
		27  
		28  // This is an API usage error - the local side is closed.
		29  // ErrPersistEOF (above) reports that the remote side is closed.
		30  var errClosed = errors.New("i/o operation on closed connection")
		31  
		32  // ServerConn is an artifact of Go's early HTTP implementation.
		33  // It is low-level, old, and unused by Go's current HTTP stack.
		34  // We should have deleted it before Go 1.
		35  //
		36  // Deprecated: Use the Server in package net/http instead.
		37  type ServerConn struct {
		38  	mu							sync.Mutex // read-write protects the following fields
		39  	c							 net.Conn
		40  	r							 *bufio.Reader
		41  	re, we					error // read/write errors
		42  	lastbody				io.ReadCloser
		43  	nread, nwritten int
		44  	pipereq				 map[*http.Request]uint
		45  
		46  	pipe textproto.Pipeline
		47  }
		48  
		49  // NewServerConn is an artifact of Go's early HTTP implementation.
		50  // It is low-level, old, and unused by Go's current HTTP stack.
		51  // We should have deleted it before Go 1.
		52  //
		53  // Deprecated: Use the Server in package net/http instead.
		54  func NewServerConn(c net.Conn, r *bufio.Reader) *ServerConn {
		55  	if r == nil {
		56  		r = bufio.NewReader(c)
		57  	}
		58  	return &ServerConn{c: c, r: r, pipereq: make(map[*http.Request]uint)}
		59  }
		60  
		61  // Hijack detaches the ServerConn and returns the underlying connection as well
		62  // as the read-side bufio which may have some left over data. Hijack may be
		63  // called before Read has signaled the end of the keep-alive logic. The user
		64  // should not call Hijack while Read or Write is in progress.
		65  func (sc *ServerConn) Hijack() (net.Conn, *bufio.Reader) {
		66  	sc.mu.Lock()
		67  	defer sc.mu.Unlock()
		68  	c := sc.c
		69  	r := sc.r
		70  	sc.c = nil
		71  	sc.r = nil
		72  	return c, r
		73  }
		74  
		75  // Close calls Hijack and then also closes the underlying connection.
		76  func (sc *ServerConn) Close() error {
		77  	c, _ := sc.Hijack()
		78  	if c != nil {
		79  		return c.Close()
		80  	}
		81  	return nil
		82  }
		83  
		84  // Read returns the next request on the wire. An ErrPersistEOF is returned if
		85  // it is gracefully determined that there are no more requests (e.g. after the
		86  // first request on an HTTP/1.0 connection, or after a Connection:close on a
		87  // HTTP/1.1 connection).
		88  func (sc *ServerConn) Read() (*http.Request, error) {
		89  	var req *http.Request
		90  	var err error
		91  
		92  	// Ensure ordered execution of Reads and Writes
		93  	id := sc.pipe.Next()
		94  	sc.pipe.StartRequest(id)
		95  	defer func() {
		96  		sc.pipe.EndRequest(id)
		97  		if req == nil {
		98  			sc.pipe.StartResponse(id)
		99  			sc.pipe.EndResponse(id)
	 100  		} else {
	 101  			// Remember the pipeline id of this request
	 102  			sc.mu.Lock()
	 103  			sc.pipereq[req] = id
	 104  			sc.mu.Unlock()
	 105  		}
	 106  	}()
	 107  
	 108  	sc.mu.Lock()
	 109  	if sc.we != nil { // no point receiving if write-side broken or closed
	 110  		defer sc.mu.Unlock()
	 111  		return nil, sc.we
	 112  	}
	 113  	if sc.re != nil {
	 114  		defer sc.mu.Unlock()
	 115  		return nil, sc.re
	 116  	}
	 117  	if sc.r == nil { // connection closed by user in the meantime
	 118  		defer sc.mu.Unlock()
	 119  		return nil, errClosed
	 120  	}
	 121  	r := sc.r
	 122  	lastbody := sc.lastbody
	 123  	sc.lastbody = nil
	 124  	sc.mu.Unlock()
	 125  
	 126  	// Make sure body is fully consumed, even if user does not call body.Close
	 127  	if lastbody != nil {
	 128  		// body.Close is assumed to be idempotent and multiple calls to
	 129  		// it should return the error that its first invocation
	 130  		// returned.
	 131  		err = lastbody.Close()
	 132  		if err != nil {
	 133  			sc.mu.Lock()
	 134  			defer sc.mu.Unlock()
	 135  			sc.re = err
	 136  			return nil, err
	 137  		}
	 138  	}
	 139  
	 140  	req, err = http.ReadRequest(r)
	 141  	sc.mu.Lock()
	 142  	defer sc.mu.Unlock()
	 143  	if err != nil {
	 144  		if err == io.ErrUnexpectedEOF {
	 145  			// A close from the opposing client is treated as a
	 146  			// graceful close, even if there was some unparse-able
	 147  			// data before the close.
	 148  			sc.re = ErrPersistEOF
	 149  			return nil, sc.re
	 150  		} else {
	 151  			sc.re = err
	 152  			return req, err
	 153  		}
	 154  	}
	 155  	sc.lastbody = req.Body
	 156  	sc.nread++
	 157  	if req.Close {
	 158  		sc.re = ErrPersistEOF
	 159  		return req, sc.re
	 160  	}
	 161  	return req, err
	 162  }
	 163  
	 164  // Pending returns the number of unanswered requests
	 165  // that have been received on the connection.
	 166  func (sc *ServerConn) Pending() int {
	 167  	sc.mu.Lock()
	 168  	defer sc.mu.Unlock()
	 169  	return sc.nread - sc.nwritten
	 170  }
	 171  
	 172  // Write writes resp in response to req. To close the connection gracefully, set the
	 173  // Response.Close field to true. Write should be considered operational until
	 174  // it returns an error, regardless of any errors returned on the Read side.
	 175  func (sc *ServerConn) Write(req *http.Request, resp *http.Response) error {
	 176  
	 177  	// Retrieve the pipeline ID of this request/response pair
	 178  	sc.mu.Lock()
	 179  	id, ok := sc.pipereq[req]
	 180  	delete(sc.pipereq, req)
	 181  	if !ok {
	 182  		sc.mu.Unlock()
	 183  		return ErrPipeline
	 184  	}
	 185  	sc.mu.Unlock()
	 186  
	 187  	// Ensure pipeline order
	 188  	sc.pipe.StartResponse(id)
	 189  	defer sc.pipe.EndResponse(id)
	 190  
	 191  	sc.mu.Lock()
	 192  	if sc.we != nil {
	 193  		defer sc.mu.Unlock()
	 194  		return sc.we
	 195  	}
	 196  	if sc.c == nil { // connection closed by user in the meantime
	 197  		defer sc.mu.Unlock()
	 198  		return ErrClosed
	 199  	}
	 200  	c := sc.c
	 201  	if sc.nread <= sc.nwritten {
	 202  		defer sc.mu.Unlock()
	 203  		return errors.New("persist server pipe count")
	 204  	}
	 205  	if resp.Close {
	 206  		// After signaling a keep-alive close, any pipelined unread
	 207  		// requests will be lost. It is up to the user to drain them
	 208  		// before signaling.
	 209  		sc.re = ErrPersistEOF
	 210  	}
	 211  	sc.mu.Unlock()
	 212  
	 213  	err := resp.Write(c)
	 214  	sc.mu.Lock()
	 215  	defer sc.mu.Unlock()
	 216  	if err != nil {
	 217  		sc.we = err
	 218  		return err
	 219  	}
	 220  	sc.nwritten++
	 221  
	 222  	return nil
	 223  }
	 224  
	 225  // ClientConn is an artifact of Go's early HTTP implementation.
	 226  // It is low-level, old, and unused by Go's current HTTP stack.
	 227  // We should have deleted it before Go 1.
	 228  //
	 229  // Deprecated: Use Client or Transport in package net/http instead.
	 230  type ClientConn struct {
	 231  	mu							sync.Mutex // read-write protects the following fields
	 232  	c							 net.Conn
	 233  	r							 *bufio.Reader
	 234  	re, we					error // read/write errors
	 235  	lastbody				io.ReadCloser
	 236  	nread, nwritten int
	 237  	pipereq				 map[*http.Request]uint
	 238  
	 239  	pipe		 textproto.Pipeline
	 240  	writeReq func(*http.Request, io.Writer) error
	 241  }
	 242  
	 243  // NewClientConn is an artifact of Go's early HTTP implementation.
	 244  // It is low-level, old, and unused by Go's current HTTP stack.
	 245  // We should have deleted it before Go 1.
	 246  //
	 247  // Deprecated: Use the Client or Transport in package net/http instead.
	 248  func NewClientConn(c net.Conn, r *bufio.Reader) *ClientConn {
	 249  	if r == nil {
	 250  		r = bufio.NewReader(c)
	 251  	}
	 252  	return &ClientConn{
	 253  		c:				c,
	 254  		r:				r,
	 255  		pipereq:	make(map[*http.Request]uint),
	 256  		writeReq: (*http.Request).Write,
	 257  	}
	 258  }
	 259  
	 260  // NewProxyClientConn is an artifact of Go's early HTTP implementation.
	 261  // It is low-level, old, and unused by Go's current HTTP stack.
	 262  // We should have deleted it before Go 1.
	 263  //
	 264  // Deprecated: Use the Client or Transport in package net/http instead.
	 265  func NewProxyClientConn(c net.Conn, r *bufio.Reader) *ClientConn {
	 266  	cc := NewClientConn(c, r)
	 267  	cc.writeReq = (*http.Request).WriteProxy
	 268  	return cc
	 269  }
	 270  
	 271  // Hijack detaches the ClientConn and returns the underlying connection as well
	 272  // as the read-side bufio which may have some left over data. Hijack may be
	 273  // called before the user or Read have signaled the end of the keep-alive
	 274  // logic. The user should not call Hijack while Read or Write is in progress.
	 275  func (cc *ClientConn) Hijack() (c net.Conn, r *bufio.Reader) {
	 276  	cc.mu.Lock()
	 277  	defer cc.mu.Unlock()
	 278  	c = cc.c
	 279  	r = cc.r
	 280  	cc.c = nil
	 281  	cc.r = nil
	 282  	return
	 283  }
	 284  
	 285  // Close calls Hijack and then also closes the underlying connection.
	 286  func (cc *ClientConn) Close() error {
	 287  	c, _ := cc.Hijack()
	 288  	if c != nil {
	 289  		return c.Close()
	 290  	}
	 291  	return nil
	 292  }
	 293  
	 294  // Write writes a request. An ErrPersistEOF error is returned if the connection
	 295  // has been closed in an HTTP keep-alive sense. If req.Close equals true, the
	 296  // keep-alive connection is logically closed after this request and the opposing
	 297  // server is informed. An ErrUnexpectedEOF indicates the remote closed the
	 298  // underlying TCP connection, which is usually considered as graceful close.
	 299  func (cc *ClientConn) Write(req *http.Request) error {
	 300  	var err error
	 301  
	 302  	// Ensure ordered execution of Writes
	 303  	id := cc.pipe.Next()
	 304  	cc.pipe.StartRequest(id)
	 305  	defer func() {
	 306  		cc.pipe.EndRequest(id)
	 307  		if err != nil {
	 308  			cc.pipe.StartResponse(id)
	 309  			cc.pipe.EndResponse(id)
	 310  		} else {
	 311  			// Remember the pipeline id of this request
	 312  			cc.mu.Lock()
	 313  			cc.pipereq[req] = id
	 314  			cc.mu.Unlock()
	 315  		}
	 316  	}()
	 317  
	 318  	cc.mu.Lock()
	 319  	if cc.re != nil { // no point sending if read-side closed or broken
	 320  		defer cc.mu.Unlock()
	 321  		return cc.re
	 322  	}
	 323  	if cc.we != nil {
	 324  		defer cc.mu.Unlock()
	 325  		return cc.we
	 326  	}
	 327  	if cc.c == nil { // connection closed by user in the meantime
	 328  		defer cc.mu.Unlock()
	 329  		return errClosed
	 330  	}
	 331  	c := cc.c
	 332  	if req.Close {
	 333  		// We write the EOF to the write-side error, because there
	 334  		// still might be some pipelined reads
	 335  		cc.we = ErrPersistEOF
	 336  	}
	 337  	cc.mu.Unlock()
	 338  
	 339  	err = cc.writeReq(req, c)
	 340  	cc.mu.Lock()
	 341  	defer cc.mu.Unlock()
	 342  	if err != nil {
	 343  		cc.we = err
	 344  		return err
	 345  	}
	 346  	cc.nwritten++
	 347  
	 348  	return nil
	 349  }
	 350  
	 351  // Pending returns the number of unanswered requests
	 352  // that have been sent on the connection.
	 353  func (cc *ClientConn) Pending() int {
	 354  	cc.mu.Lock()
	 355  	defer cc.mu.Unlock()
	 356  	return cc.nwritten - cc.nread
	 357  }
	 358  
	 359  // Read reads the next response from the wire. A valid response might be
	 360  // returned together with an ErrPersistEOF, which means that the remote
	 361  // requested that this be the last request serviced. Read can be called
	 362  // concurrently with Write, but not with another Read.
	 363  func (cc *ClientConn) Read(req *http.Request) (resp *http.Response, err error) {
	 364  	// Retrieve the pipeline ID of this request/response pair
	 365  	cc.mu.Lock()
	 366  	id, ok := cc.pipereq[req]
	 367  	delete(cc.pipereq, req)
	 368  	if !ok {
	 369  		cc.mu.Unlock()
	 370  		return nil, ErrPipeline
	 371  	}
	 372  	cc.mu.Unlock()
	 373  
	 374  	// Ensure pipeline order
	 375  	cc.pipe.StartResponse(id)
	 376  	defer cc.pipe.EndResponse(id)
	 377  
	 378  	cc.mu.Lock()
	 379  	if cc.re != nil {
	 380  		defer cc.mu.Unlock()
	 381  		return nil, cc.re
	 382  	}
	 383  	if cc.r == nil { // connection closed by user in the meantime
	 384  		defer cc.mu.Unlock()
	 385  		return nil, errClosed
	 386  	}
	 387  	r := cc.r
	 388  	lastbody := cc.lastbody
	 389  	cc.lastbody = nil
	 390  	cc.mu.Unlock()
	 391  
	 392  	// Make sure body is fully consumed, even if user does not call body.Close
	 393  	if lastbody != nil {
	 394  		// body.Close is assumed to be idempotent and multiple calls to
	 395  		// it should return the error that its first invocation
	 396  		// returned.
	 397  		err = lastbody.Close()
	 398  		if err != nil {
	 399  			cc.mu.Lock()
	 400  			defer cc.mu.Unlock()
	 401  			cc.re = err
	 402  			return nil, err
	 403  		}
	 404  	}
	 405  
	 406  	resp, err = http.ReadResponse(r, req)
	 407  	cc.mu.Lock()
	 408  	defer cc.mu.Unlock()
	 409  	if err != nil {
	 410  		cc.re = err
	 411  		return resp, err
	 412  	}
	 413  	cc.lastbody = resp.Body
	 414  
	 415  	cc.nread++
	 416  
	 417  	if resp.Close {
	 418  		cc.re = ErrPersistEOF // don't send any more requests
	 419  		return resp, cc.re
	 420  	}
	 421  	return resp, err
	 422  }
	 423  
	 424  // Do is convenience method that writes a request and reads a response.
	 425  func (cc *ClientConn) Do(req *http.Request) (*http.Response, error) {
	 426  	err := cc.Write(req)
	 427  	if err != nil {
	 428  		return nil, err
	 429  	}
	 430  	return cc.Read(req)
	 431  }
	 432
View as plain text