Run Format

Source file src/pkg/net/http/filetransport.go

     1	// Copyright 2011 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 http
     6	
     7	import (
     8		"fmt"
     9		"io"
    10	)
    11	
    12	// fileTransport implements RoundTripper for the 'file' protocol.
    13	type fileTransport struct {
    14		fh fileHandler
    15	}
    16	
    17	// NewFileTransport returns a new RoundTripper, serving the provided
    18	// FileSystem. The returned RoundTripper ignores the URL host in its
    19	// incoming requests, as well as most other properties of the
    20	// request.
    21	//
    22	// The typical use case for NewFileTransport is to register the "file"
    23	// protocol with a Transport, as in:
    24	//
    25	//   t := &http.Transport{}
    26	//   t.RegisterProtocol("file", http.NewFileTransport(http.Dir("/")))
    27	//   c := &http.Client{Transport: t}
    28	//   res, err := c.Get("file:///etc/passwd")
    29	//   ...
    30	func NewFileTransport(fs FileSystem) RoundTripper {
    31		return fileTransport{fileHandler{fs}}
    32	}
    33	
    34	func (t fileTransport) RoundTrip(req *Request) (resp *Response, err error) {
    35		// We start ServeHTTP in a goroutine, which may take a long
    36		// time if the file is large.  The newPopulateResponseWriter
    37		// call returns a channel which either ServeHTTP or finish()
    38		// sends our *Response on, once the *Response itself has been
    39		// populated (even if the body itself is still being
    40		// written to the res.Body, a pipe)
    41		rw, resc := newPopulateResponseWriter()
    42		go func() {
    43			t.fh.ServeHTTP(rw, req)
    44			rw.finish()
    45		}()
    46		return <-resc, nil
    47	}
    48	
    49	func newPopulateResponseWriter() (*populateResponse, <-chan *Response) {
    50		pr, pw := io.Pipe()
    51		rw := &populateResponse{
    52			ch: make(chan *Response),
    53			pw: pw,
    54			res: &Response{
    55				Proto:      "HTTP/1.0",
    56				ProtoMajor: 1,
    57				Header:     make(Header),
    58				Close:      true,
    59				Body:       pr,
    60			},
    61		}
    62		return rw, rw.ch
    63	}
    64	
    65	// populateResponse is a ResponseWriter that populates the *Response
    66	// in res, and writes its body to a pipe connected to the response
    67	// body. Once writes begin or finish() is called, the response is sent
    68	// on ch.
    69	type populateResponse struct {
    70		res          *Response
    71		ch           chan *Response
    72		wroteHeader  bool
    73		hasContent   bool
    74		sentResponse bool
    75		pw           *io.PipeWriter
    76	}
    77	
    78	func (pr *populateResponse) finish() {
    79		if !pr.wroteHeader {
    80			pr.WriteHeader(500)
    81		}
    82		if !pr.sentResponse {
    83			pr.sendResponse()
    84		}
    85		pr.pw.Close()
    86	}
    87	
    88	func (pr *populateResponse) sendResponse() {
    89		if pr.sentResponse {
    90			return
    91		}
    92		pr.sentResponse = true
    93	
    94		if pr.hasContent {
    95			pr.res.ContentLength = -1
    96		}
    97		pr.ch <- pr.res
    98	}
    99	
   100	func (pr *populateResponse) Header() Header {
   101		return pr.res.Header
   102	}
   103	
   104	func (pr *populateResponse) WriteHeader(code int) {
   105		if pr.wroteHeader {
   106			return
   107		}
   108		pr.wroteHeader = true
   109	
   110		pr.res.StatusCode = code
   111		pr.res.Status = fmt.Sprintf("%d %s", code, StatusText(code))
   112	}
   113	
   114	func (pr *populateResponse) Write(p []byte) (n int, err error) {
   115		if !pr.wroteHeader {
   116			pr.WriteHeader(StatusOK)
   117		}
   118		pr.hasContent = true
   119		if !pr.sentResponse {
   120			pr.sendResponse()
   121		}
   122		return pr.pw.Write(p)
   123	}

View as plain text