Documentation
¶
Index ¶
- Variables
- type BufferPool
- type ClientConn
- func (cc *ClientConn) Close() error
- func (cc *ClientConn) Do(req *http.Request) (resp *http.Response, err error)
- func (cc *ClientConn) Hijack() (c net.Conn, r *bufio.Reader)
- func (cc *ClientConn) Pending() int
- func (cc *ClientConn) Read(req *http.Request) (resp *http.Response, err error)
- func (cc *ClientConn) Write(req *http.Request) (err error)
- type ReverseProxy
- type ServerConn
Examples ¶
Constants ¶
This section is empty.
Variables ¶
var ( ErrPersistEOF = &http.ProtocolError{ErrorString: "persistent connection closed"} ErrClosed = &http.ProtocolError{ErrorString: "connection closed by user"} ErrPipeline = &http.ProtocolError{ErrorString: "pipeline error"} )
var ErrHandled = errors.New("request handled")
Functions ¶
This section is empty.
Types ¶
type BufferPool ¶
A BufferPool is an interface for getting and returning temporary byte slices for use by io.CopyBuffer.
type ClientConn ¶
type ClientConn struct {
// contains filtered or unexported fields
}
A ClientConn sends request and receives headers over an underlying connection, while respecting the HTTP keepalive logic. ClientConn supports hijacking the connection calling Hijack to regain control of the underlying net.Conn and deal with it as desired.
ClientConn is low-level and old. Applications should instead use Client or Transport in the net/http package.
func NewClientConn ¶
func NewClientConn(c net.Conn, r *bufio.Reader) *ClientConn
NewClientConn returns a new ClientConn reading and writing c. If r is not nil, it is the buffer to use when reading c.
ClientConn is low-level and old. Applications should use Client or Transport in the net/http package.
func NewProxyClientConn ¶
func NewProxyClientConn(c net.Conn, r *bufio.Reader) *ClientConn
NewProxyClientConn works like NewClientConn but writes Requests using Request's WriteProxy method.
New code should not use NewProxyClientConn. See Client or Transport in the net/http package instead.
func (*ClientConn) Close ¶
func (cc *ClientConn) Close() error
Close calls Hijack and then also closes the underlying connection
func (*ClientConn) Hijack ¶
func (cc *ClientConn) Hijack() (c net.Conn, r *bufio.Reader)
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 (*ClientConn) Pending ¶
func (cc *ClientConn) Pending() int
Pending returns the number of unanswered requests that have been sent on the connection.
func (*ClientConn) Read ¶
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 (*ClientConn) Write ¶
func (cc *ClientConn) Write(req *http.Request) (err error)
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.
type ReverseProxy ¶
type ReverseProxy struct {
// Proxy is a function that either handles the request
// by sending back data or modifies request to be
// sent. In the former case, ErrHandled must be returned.
Proxy func(http.ResponseWriter, *http.Request) error
// The transport used to perform proxy requests.
// If nil, http.DefaultTransport is used.
Transport http.RoundTripper
// FlushInterval specifies the flush interval
// to flush to the client while copying the
// response body.
// If zero, no periodic flushing is done.
FlushInterval time.Duration
// ErrorLog specifies an optional logger for errors
// that occur when attempting to proxy the request.
// If nil, logging goes to os.Stderr via the log package's
// standard logger.
ErrorLog *log.Logger
// BufferPool optionally specifies a buffer pool to
// get byte slices for use by io.CopyBuffer when
// copying HTTP response bodies.
BufferPool BufferPool
// Output additional debug logging
Debug bool
}
ReverseProxy is an HTTP Handler that takes an incoming request and sends it to another server, proxying the response back to the client.
Example ¶
package main
import (
"fmt"
"io/ioutil"
"log"
"net/http"
"net/http/httptest"
"net/http/httputil"
"net/url"
)
func main() {
backendServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "this call was relayed by the reverse proxy")
}))
defer backendServer.Close()
rpURL, err := url.Parse(backendServer.URL)
if err != nil {
log.Fatal(err)
}
frontendProxy := httptest.NewServer(httputil.NewSingleHostReverseProxy(rpURL))
defer frontendProxy.Close()
resp, err := http.Get(frontendProxy.URL)
if err != nil {
log.Fatal(err)
}
b, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s", b)
}
Output: this call was relayed by the reverse proxy
func (*ReverseProxy) ServeHTTP ¶
func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request)
type ServerConn ¶
type ServerConn struct {
// contains filtered or unexported fields
}
A ServerConn reads requests and sends responses over an underlying connection, until the HTTP keepalive logic commands an end. ServerConn also allows hijacking the underlying connection by calling Hijack to regain control over the connection. ServerConn supports pipe-lining, i.e. requests can be read out of sync (but in the same order) while the respective responses are sent.
ServerConn is low-level and old. Applications should instead use Server in the net/http package.
func NewServerConn ¶
func NewServerConn(c net.Conn, r *bufio.Reader) *ServerConn
NewServerConn returns a new ServerConn reading and writing c. If r is not nil, it is the buffer to use when reading c.
ServerConn is low-level and old. Applications should instead use Server in the net/http package.
func (*ServerConn) Close ¶
func (sc *ServerConn) Close() error
Close calls Hijack and then also closes the underlying connection
func (*ServerConn) Hijack ¶
func (sc *ServerConn) Hijack() (c net.Conn, r *bufio.Reader)
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 (*ServerConn) Pending ¶
func (sc *ServerConn) Pending() int
Pending returns the number of unanswered requests that have been received on the connection.
func (*ServerConn) Read ¶
func (sc *ServerConn) Read() (req *http.Request, err error)
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).
Source Files