Merge lp:~wallyworld/gwacl/ensure-all-roles-have-costs into lp:gwacl

[Ian Booth]

Builds on rev 239 by Kapil.
All instance types need to have costs in each region. The G series didn't and the tests needed updating to catch this.

Also, I reformatted with gofmt using standard options. A bit of noise this time, but much cleaner next time.

Builds on rev 239 by Kapil.
All instance types need to have costs in each region. The G series didn't and the tests needed updating to catch this.

Also, I reformatted with gofmt using standard options. A bit of noise this time, but much cleaner next time.

[Andrew Wilkins (axwalk)]

review: Approve

[Kapil Thangavelu (hazmat)]

Fwiw There's one more drive by associated with these type maps.. the small
to extra large names aren't used anymore we need some aliases to
a1-a4 there's a separate bug on this filed by a user.

On Monday, December 1, 2014, Andrew Wilkins <email address hidden>
wrote:

> Review: Approve
>
>
> --
>
> https://code.launchpad.net/~wallyworld/gwacl/ensure-all-roles-have-costs/+merge/243346
> Your team GWACL Hackers is subscribed to branch lp:gwacl.
>

=== modified file 'Makefile'
--- Makefile	2013-08-29 17:07:28 +0000
+++ Makefile	2014-12-02 00:40:19 +0000
@@ -18,10 +18,13 @@
 clean:
 	$(RM) $(example_binaries)
 
-# Reformat the source files to match our layout standards.
-# This includes gofmt's "simplify" option to streamline the source code.
+# Reformat source files.
 format:
-	./utilities/format -s
+	gofmt -w -l .
+
+# Reformat and simplify source files.
+simplify:
+	gofmt -w -l -s .
 
 # Build the examples (we have no tests for them).
 examples: $(example_binaries)

=== modified file 'dedent/dedent.go'
--- dedent/dedent.go	2013-03-12 17:05:36 +0000
+++ dedent/dedent.go	2014-12-02 00:40:19 +0000
@@ -4,8 +4,8 @@
 package dedent
 
 import (
-    "regexp"
-    "strings"
+	"regexp"
+	"strings"
 )
 
 const emptyString = ""
@@ -14,7 +14,7 @@
 
 // Split the given text into lines.
 func splitLines(text string) []string {
-    return reLine.FindAllString(text, -1)
+	return reLine.FindAllString(text, -1)
 }
 
 // Match leading whitespace or tabs. \p{Zs} is a Unicode character class:
@@ -23,46 +23,46 @@
 
 // Find the longest leading margin common between the given lines.
 func calculateMargin(lines []string) string {
-    var margin string
-    var first bool = true
-    for _, line := range lines {
-        indent := reLeadingWhitespace.FindString(line)
-        switch {
-        case len(indent) == len(line):
-            // The line is either empty or whitespace and will be ignored for
-            // the purposes of calculating the margin.
-        case first:
-            // This is the first line with an indent, so start from here.
-            margin = indent
-            first = false
-        case strings.HasPrefix(indent, margin):
-            // This line's indent is longer or equal to the margin. The
-            // current margin remains unalterered.
-        case strings.HasPrefix(margin, indent):
-            // This line's indent is compatible with the margin but shorter
-            // (strictly it could be equal, however that condition is handled
-            // earlier in this switch). The current indent becomes the margin.
-            margin = indent
-        default:
-            // There is no common margin so stop scanning.
-            return emptyString
-        }
-    }
-    return margin
+	var margin string
+	var first bool = true
+	for _, line := range lines {
+		indent := reLeadingWhitespace.FindString(line)
+		switch {
+		case len(indent) == len(line):
+			// The line is either empty or whitespace and will be ignored for
+			// the purposes of calculating the margin.
+		case first:
+			// This is the first line with an indent, so start from here.
+			margin = indent
+			first = false
+		case strings.HasPrefix(indent, margin):
+			// This line's indent is longer or equal to the margin. The
+			// current margin remains unalterered.
+		case strings.HasPrefix(margin, indent):
+			// This line's indent is compatible with the margin but shorter
+			// (strictly it could be equal, however that condition is handled
+			// earlier in this switch). The current indent becomes the margin.
+			margin = indent
+		default:
+			// There is no common margin so stop scanning.
+			return emptyString
+		}
+	}
+	return margin
 }
 
 // Remove a prefix from each line, if present.
 func trimPrefix(lines []string, prefix string) {
-    trim := len(prefix)
-    for i, line := range lines {
-        if strings.HasPrefix(line, prefix) {
-            lines[i] = line[trim:]
-        }
-    }
+	trim := len(prefix)
+	for i, line := range lines {
+		if strings.HasPrefix(line, prefix) {
+			lines[i] = line[trim:]
+		}
+	}
 }
 
 func Dedent(text string) string {
-    lines := splitLines(text)
-    trimPrefix(lines, calculateMargin(lines))
-    return strings.Join(lines, "\n")
+	lines := splitLines(text)
+	trimPrefix(lines, calculateMargin(lines))
+	return strings.Join(lines, "\n")
 }

=== modified file 'dedent/dedent_test.go'
--- dedent/dedent_test.go	2013-03-26 06:57:55 +0000
+++ dedent/dedent_test.go	2014-12-02 00:40:19 +0000
@@ -4,8 +4,8 @@
 package dedent
 
 import (
-    . "launchpad.net/gocheck"
-    "testing"
+	. "launchpad.net/gocheck"
+	"testing"
 )
 
 type dedentSuite struct{}
@@ -14,81 +14,81 @@
 
 // Dedent() does nothing with the empty string.
 func (suite *dedentSuite) TestEmptyString(c *C) {
-    input := ""
-    expected := input
-    observed := Dedent(input)
-    c.Check(observed, Equals, expected)
+	input := ""
+	expected := input
+	observed := Dedent(input)
+	c.Check(observed, Equals, expected)
 }
 
 // Dedent() does nothing to a single line without an indent.
 func (suite *dedentSuite) TestSingleLine(c *C) {
-    input := "This is a single line."
-    expected := input
-    observed := Dedent(input)
-    c.Check(observed, Equals, expected)
+	input := "This is a single line."
+	expected := input
+	observed := Dedent(input)
+	c.Check(observed, Equals, expected)
 }
 
 // Dedent() removes all leading whitespace from single lines.
 func (suite *dedentSuite) TestSingleLineWithIndent(c *C) {
-    input := "  This is a single line."
-    expected := "This is a single line."
-    observed := Dedent(input)
-    c.Check(observed, Equals, expected)
+	input := "  This is a single line."
+	expected := "This is a single line."
+	observed := Dedent(input)
+	c.Check(observed, Equals, expected)
 }
 
 // Dedent() does nothing when none of the lines are indented.
 func (suite *dedentSuite) TestLines(c *C) {
-    input := "One\nTwo\n"
-    expected := input
-    observed := Dedent(input)
-    c.Check(observed, Equals, expected)
+	input := "One\nTwo\n"
+	expected := input
+	observed := Dedent(input)
+	c.Check(observed, Equals, expected)
 }
 
 // Dedent() does nothing when *any* line is not indented.
 func (suite *dedentSuite) TestLinesWithSomeIndents(c *C) {
-    input := "One\n  Two\n"
-    expected := input
-    observed := Dedent(input)
-    c.Check(observed, Equals, expected)
+	input := "One\n  Two\n"
+	expected := input
+	observed := Dedent(input)
+	c.Check(observed, Equals, expected)
 }
 
 // Dedent() removes the common leading indent from each line.
 func (suite *dedentSuite) TestLinesWithIndents(c *C) {
-    input := " One\n  Two\n"
-    expected := "One\n Two\n"
-    observed := Dedent(input)
-    c.Check(observed, Equals, expected)
+	input := " One\n  Two\n"
+	expected := "One\n Two\n"
+	observed := Dedent(input)
+	c.Check(observed, Equals, expected)
 }
 
 // Dedent() ignores all-whitespace lines for the purposes of margin
 // calculation. However, the margin *is* trimmed from these lines, if they
 // begin with it.
 func (suite *dedentSuite) TestLinesWithEmptyLine(c *C) {
-    input := "  One\n    \n  Three\n"
-    expected := "One\n  \nThree\n"
-    observed := Dedent(input)
-    c.Check(observed, Equals, expected)
+	input := "  One\n    \n  Three\n"
+	expected := "One\n  \nThree\n"
+	observed := Dedent(input)
+	c.Check(observed, Equals, expected)
 }
 
 // Dedent() ignores blank lines for the purposes of margin calculation,
 // including the first line.
 func (suite *dedentSuite) TestLinesWithEmptyFirstLine(c *C) {
-    input := "\n  Two\n  Three\n"
-    expected := "\nTwo\nThree\n"
-    observed := Dedent(input)
-    c.Check(observed, Equals, expected)
+	input := "\n  Two\n  Three\n"
+	expected := "\nTwo\nThree\n"
+	observed := Dedent(input)
+	c.Check(observed, Equals, expected)
 }
 
 // Dedent() treats spaces and tabs as completely different; no number of
 // spaces is equivalent to a tab.
 func (suite *dedentSuite) TestLinesWithTabsAndSpaces(c *C) {
-    input := "\tOne\n        Two\n"
-    expected := input
-    observed := Dedent(input)
-    c.Check(observed, Equals, expected)
+	input := "\tOne\n        Two\n"
+	expected := input
+	observed := Dedent(input)
+	c.Check(observed, Equals, expected)
 }
 
 // Master loader for all tests.
 func Test(t *testing.T) {
-    TestingT(t)
+	TestingT(t)
 }

=== modified file 'deletedisk.go'
--- deletedisk.go	2013-07-16 05:48:26 +0000
+++ deletedisk.go	2014-12-02 00:40:19 +0000
@@ -18,24 +18,24 @@
 package gwacl
 
 import (
-    "fmt"
-    "regexp"
-    "time"
+	"fmt"
+	"regexp"
+	"time"
 )
 
 var deleteDiskTimeout = 30 * time.Minute
 var deleteDiskInterval = 10 * time.Second
 
 type diskDeletePoller struct {
-    api        *ManagementAPI
-    diskName   string
-    deleteBlob bool
+	api        *ManagementAPI
+	diskName   string
+	deleteBlob bool
 }
 
 var _ poller = &diskDeletePoller{}
 
 func (poller diskDeletePoller) poll() (*x509Response, error) {
-    return nil, poller.api._DeleteDisk(poller.diskName, poller.deleteBlob)
+	return nil, poller.api._DeleteDisk(poller.diskName, poller.deleteBlob)
 }
 
 // isInUseError returns whether or not the given string is of the "disk in use"
@@ -46,20 +46,20 @@
 // gwacl623yosxtppsa9577xy5, deployment gwaclmachinewes4n64f. (http
 // code 400: Bad Request)"
 func isInUseError(errString string, diskName string) bool {
-    pattern := fmt.Sprintf("BadRequest - A disk with name %s is currently in use by virtual machine.*", regexp.QuoteMeta(diskName))
-    reg := regexp.MustCompile(pattern)
-    return reg.MatchString(errString)
+	pattern := fmt.Sprintf("BadRequest - A disk with name %s is currently in use by virtual machine.*", regexp.QuoteMeta(diskName))
+	reg := regexp.MustCompile(pattern)
+	return reg.MatchString(errString)
 }
 
 func (poller diskDeletePoller) isDone(response *x509Response, pollerErr error) (bool, error) {
-    if pollerErr == nil {
-        return true, nil
-    }
-    if isInUseError(pollerErr.Error(), poller.diskName) {
-        // The error is of the "disk in use" type: continue polling.
-        return false, nil
-    }
-    // The error is *not* of the "disk in use" type: stop polling and return
-    // the error.
-    return true, pollerErr
+	if pollerErr == nil {
+		return true, nil
+	}
+	if isInUseError(pollerErr.Error(), poller.diskName) {
+		// The error is of the "disk in use" type: continue polling.
+		return false, nil
+	}
+	// The error is *not* of the "disk in use" type: stop polling and return
+	// the error.
+	return true, pollerErr
 }

=== modified file 'deletedisk_test.go'
--- deletedisk_test.go	2013-07-16 05:48:59 +0000
+++ deletedisk_test.go	2014-12-02 00:40:19 +0000
@@ -4,10 +4,10 @@
 package gwacl
 
 import (
-    "fmt"
-    . "launchpad.net/gocheck"
-    "net/http"
-    "time"
+	"fmt"
+	. "launchpad.net/gocheck"
+	"net/http"
+	"time"
 )
 
 type deleteDiskSuite struct{}
@@ -16,88 +16,88 @@
 
 // Real-world error messages and names.
 const (
-    diskInUseErrorTemplate = "BadRequest - A disk with name %s is currently in use by virtual machine gwaclrolemvo1yab running within hosted service gwacl623yosxtppsa9577xy5, deployment gwaclmachinewes4n64f. (http code 400: Bad Request)"
-    diskName               = "gwacldiske5w7lkj"
-    diskDoesNotExistError  = "DELETE request failed: ResourceNotFound - The disk with the specified name does not exist. (http code 404: Not Found)"
+	diskInUseErrorTemplate = "BadRequest - A disk with name %s is currently in use by virtual machine gwaclrolemvo1yab running within hosted service gwacl623yosxtppsa9577xy5, deployment gwaclmachinewes4n64f. (http code 400: Bad Request)"
+	diskName               = "gwacldiske5w7lkj"
+	diskDoesNotExistError  = "DELETE request failed: ResourceNotFound - The disk with the specified name does not exist. (http code 404: Not Found)"
 )
 
 func (suite *deleteDiskSuite) TestIsInUseError(c *C) {
-    var testValues = []struct {
-        errorString    string
-        diskName       string
-        expectedResult bool
-    }{
-        {fmt.Sprintf(diskInUseErrorTemplate, diskName), diskName, true},
-        {fmt.Sprintf(diskInUseErrorTemplate, diskName), "another-disk", false},
-        {"unknown error", diskName, false},
-        {diskDoesNotExistError, diskName, false},
-    }
-    for _, test := range testValues {
-        c.Check(isInUseError(test.errorString, test.diskName), Equals, test.expectedResult)
-    }
+	var testValues = []struct {
+		errorString    string
+		diskName       string
+		expectedResult bool
+	}{
+		{fmt.Sprintf(diskInUseErrorTemplate, diskName), diskName, true},
+		{fmt.Sprintf(diskInUseErrorTemplate, diskName), "another-disk", false},
+		{"unknown error", diskName, false},
+		{diskDoesNotExistError, diskName, false},
+	}
+	for _, test := range testValues {
+		c.Check(isInUseError(test.errorString, test.diskName), Equals, test.expectedResult)
+	}
 }
 
 func (suite *deleteDiskSuite) TestIsDoneReturnsTrueIfNilError(c *C) {
-    poller := diskDeletePoller{nil, "", false}
-    randomResponse := x509Response{StatusCode: http.StatusAccepted}
-    done, err := poller.isDone(&randomResponse, nil)
-    c.Check(done, Equals, true)
-    c.Check(err, IsNil)
+	poller := diskDeletePoller{nil, "", false}
+	randomResponse := x509Response{StatusCode: http.StatusAccepted}
+	done, err := poller.isDone(&randomResponse, nil)
+	c.Check(done, Equals, true)
+	c.Check(err, IsNil)
 }
 
 func (suite *deleteDiskSuite) TestIsDoneReturnsFalseIfDiskInUseError(c *C) {
-    diskName := "gwacldiske5w7lkj"
-    diskInUseError := fmt.Errorf(diskInUseErrorTemplate, diskName)
-    poller := diskDeletePoller{nil, diskName, false}
-    done, err := poller.isDone(nil, diskInUseError)
-    c.Check(done, Equals, false)
-    c.Check(err, IsNil)
+	diskName := "gwacldiske5w7lkj"
+	diskInUseError := fmt.Errorf(diskInUseErrorTemplate, diskName)
+	poller := diskDeletePoller{nil, diskName, false}
+	done, err := poller.isDone(nil, diskInUseError)
+	c.Check(done, Equals, false)
+	c.Check(err, IsNil)
 }
 
 func (suite *deleteDiskSuite) TestIsDoneReturnsTrueIfAnotherError(c *C) {
-    anotherError := fmt.Errorf("Unknown error")
-    poller := diskDeletePoller{nil, "disk-name", false}
-    done, err := poller.isDone(nil, anotherError)
-    c.Check(done, Equals, true)
-    c.Check(err, Equals, anotherError)
+	anotherError := fmt.Errorf("Unknown error")
+	poller := diskDeletePoller{nil, "disk-name", false}
+	done, err := poller.isDone(nil, anotherError)
+	c.Check(done, Equals, true)
+	c.Check(err, Equals, anotherError)
 }
 
 func (suite *deleteDiskSuite) TestPollCallsDeleteDisk(c *C) {
-    api := makeAPI(c)
-    recordedRequests := setUpDispatcher("operationID")
-    diskName := "gwacldiske5w7lkj"
-    poller := diskDeletePoller{api, diskName, false}
-
-    response, err := poller.poll()
-
-    c.Assert(response, IsNil)
-    c.Assert(err, IsNil)
-    expectedURL := api.session.composeURL("services/disks/" + diskName)
-    checkOneRequest(c, recordedRequests, expectedURL, "2012-08-01", nil, "DELETE")
+	api := makeAPI(c)
+	recordedRequests := setUpDispatcher("operationID")
+	diskName := "gwacldiske5w7lkj"
+	poller := diskDeletePoller{api, diskName, false}
+
+	response, err := poller.poll()
+
+	c.Assert(response, IsNil)
+	c.Assert(err, IsNil)
+	expectedURL := api.session.composeURL("services/disks/" + diskName)
+	checkOneRequest(c, recordedRequests, expectedURL, "2012-08-01", nil, "DELETE")
 }
 
 func (suite *deleteDiskSuite) TestManagementAPIDeleteDiskPolls(c *C) {
-    firstResponse := DispatcherResponse{
-        response:    &x509Response{},
-        errorObject: fmt.Errorf(diskInUseErrorTemplate, diskName)}
-    secondResponse := DispatcherResponse{
-        response:    &x509Response{StatusCode: http.StatusOK},
-        errorObject: nil}
-    responses := []DispatcherResponse{firstResponse, secondResponse}
-    rigPreparedResponseDispatcher(responses)
-    recordedRequests := make([]*X509Request, 0)
-    rigRecordingDispatcher(&recordedRequests)
-
-    api := makeAPI(c)
-    diskName := "gwacldiske5w7lkj"
-    poller := diskDeletePoller{api, diskName, false}
-
-    response, err := performPolling(poller, time.Nanosecond, time.Minute)
-
-    c.Assert(response, IsNil)
-    c.Assert(err, IsNil)
-    expectedURL := api.session.composeURL("services/disks/" + diskName)
-    c.Check(len(recordedRequests), Equals, 2)
-    checkRequest(c, recordedRequests[0], expectedURL, "2012-08-01", nil, "DELETE")
-    checkRequest(c, recordedRequests[1], expectedURL, "2012-08-01", nil, "DELETE")
+	firstResponse := DispatcherResponse{
+		response:    &x509Response{},
+		errorObject: fmt.Errorf(diskInUseErrorTemplate, diskName)}
+	secondResponse := DispatcherResponse{
+		response:    &x509Response{StatusCode: http.StatusOK},
+		errorObject: nil}
+	responses := []DispatcherResponse{firstResponse, secondResponse}
+	rigPreparedResponseDispatcher(responses)
+	recordedRequests := make([]*X509Request, 0)
+	rigRecordingDispatcher(&recordedRequests)
+
+	api := makeAPI(c)
+	diskName := "gwacldiske5w7lkj"
+	poller := diskDeletePoller{api, diskName, false}
+
+	response, err := performPolling(poller, time.Nanosecond, time.Minute)
+
+	c.Assert(response, IsNil)
+	c.Assert(err, IsNil)
+	expectedURL := api.session.composeURL("services/disks/" + diskName)
+	c.Check(len(recordedRequests), Equals, 2)
+	checkRequest(c, recordedRequests[0], expectedURL, "2012-08-01", nil, "DELETE")
+	checkRequest(c, recordedRequests[1], expectedURL, "2012-08-01", nil, "DELETE")
 }

=== modified file 'endpoints.go'
--- endpoints.go	2013-08-06 10:15:11 +0000
+++ endpoints.go	2014-12-02 00:40:19 +0000
@@ -4,9 +4,9 @@
 package gwacl
 
 import (
-    "fmt"
-    "net/url"
-    "strings"
+	"fmt"
+	"net/url"
+	"strings"
 )
 
 // APIEndpoint describes the base URL for accesing Windows Azure's APIs.
@@ -20,13 +20,13 @@
 // GetEndpoint returns the API endpoint for the given location.  This is
 // hard-coded, so some guesswork may be involved.
 func GetEndpoint(location string) APIEndpoint {
-    if strings.Contains(location, "China") {
-        // Mainland China is a special case.  It has its own endpoint.
-        return "https://core.chinacloudapi.cn/"
-    }
+	if strings.Contains(location, "China") {
+		// Mainland China is a special case.  It has its own endpoint.
+		return "https://core.chinacloudapi.cn/"
+	}
 
-    // The rest of the world shares a single endpoint.
-    return "https://core.windows.net/"
+	// The rest of the world shares a single endpoint.
+	return "https://core.windows.net/"
 }
 
 // prefixHost prefixes the hostname part of a URL with a subdomain.  For
@@ -35,26 +35,26 @@
 //
 // The URL must be well-formed, and contain a hostname.
 func prefixHost(host, originalURL string) string {
-    parsedURL, err := url.Parse(originalURL)
-    if err != nil {
-        panic(fmt.Errorf("failed to parse URL %s - %v", originalURL, err))
-    }
-    if parsedURL.Host == "" {
-        panic(fmt.Errorf("no hostname in URL '%s'", originalURL))
-    }
-    // Escape manually.  Strangely, turning a url.URL into a string does not
-    // do this for you.
-    parsedURL.Host = url.QueryEscape(host) + "." + parsedURL.Host
-    return parsedURL.String()
+	parsedURL, err := url.Parse(originalURL)
+	if err != nil {
+		panic(fmt.Errorf("failed to parse URL %s - %v", originalURL, err))
+	}
+	if parsedURL.Host == "" {
+		panic(fmt.Errorf("no hostname in URL '%s'", originalURL))
+	}
+	// Escape manually.  Strangely, turning a url.URL into a string does not
+	// do this for you.
+	parsedURL.Host = url.QueryEscape(host) + "." + parsedURL.Host
+	return parsedURL.String()
 }
 
 // ManagementAPI returns the URL for the endpoint's management API.
 func (endpoint APIEndpoint) ManagementAPI() string {
-    return prefixHost("management", string(endpoint))
+	return prefixHost("management", string(endpoint))
 }
 
 // BlobStorageAPI returns a URL for the endpoint's blob storage API, for
 // requests on the given account.
 func (endpoint APIEndpoint) BlobStorageAPI(account string) string {
-    return prefixHost(account, prefixHost("blob", string(endpoint)))
+	return prefixHost(account, prefixHost("blob", string(endpoint)))
 }

=== modified file 'endpoints_test.go'
--- endpoints_test.go	2013-08-06 10:12:51 +0000
+++ endpoints_test.go	2014-12-02 00:40:19 +0000
@@ -4,9 +4,9 @@
 package gwacl
 
 import (
-    "fmt"
-    . "launchpad.net/gocheck"
-    "net/url"
+	"fmt"
+	. "launchpad.net/gocheck"
+	"net/url"
 )
 
 type endpointsSuite struct{}
@@ -14,109 +14,109 @@
 var _ = Suite(&endpointsSuite{})
 
 func (*endpointsSuite) TestGetEndpointReturnsEndpointsForKnownRegions(c *C) {
-    internationalLocations := []string{
-        "West Europe",
-        "East Asia",
-        "East US 2",
-        "Southeast Asia",
-        "East US",
-        "Central US",
-        "West US",
-        "North Europe",
-    }
-    internationalEndpoint := APIEndpoint("https://core.windows.net/")
-
-    for _, location := range internationalLocations {
-        c.Check(GetEndpoint(location), Equals, internationalEndpoint)
-    }
-
-    // The mainland-China locations have a different endpoint.
-    // (Actually the East Asia data centre is said to be in Hong Kong, but it
-    // acts as international).
-    mainlandChinaLocations := []string{
-        "China East",
-        "China North",
-    }
-    mainlandChinaEndpoint := APIEndpoint("https://core.chinacloudapi.cn/")
-    for _, location := range mainlandChinaLocations {
-        c.Check(GetEndpoint(location), Equals, mainlandChinaEndpoint)
-    }
+	internationalLocations := []string{
+		"West Europe",
+		"East Asia",
+		"East US 2",
+		"Southeast Asia",
+		"East US",
+		"Central US",
+		"West US",
+		"North Europe",
+	}
+	internationalEndpoint := APIEndpoint("https://core.windows.net/")
+
+	for _, location := range internationalLocations {
+		c.Check(GetEndpoint(location), Equals, internationalEndpoint)
+	}
+
+	// The mainland-China locations have a different endpoint.
+	// (Actually the East Asia data centre is said to be in Hong Kong, but it
+	// acts as international).
+	mainlandChinaLocations := []string{
+		"China East",
+		"China North",
+	}
+	mainlandChinaEndpoint := APIEndpoint("https://core.chinacloudapi.cn/")
+	for _, location := range mainlandChinaLocations {
+		c.Check(GetEndpoint(location), Equals, mainlandChinaEndpoint)
+	}
 }
 
 func (*endpointsSuite) TestGetEndpointMakesGoodGuessesForUknownRegions(c *C) {
-    c.Check(
-        GetEndpoint("South San Marino Highlands"),
-        Equals,
-        GetEndpoint("West US"))
-    c.Check(
-        GetEndpoint("Central China West"),
-        Equals,
-        GetEndpoint("China East"))
+	c.Check(
+		GetEndpoint("South San Marino Highlands"),
+		Equals,
+		GetEndpoint("West US"))
+	c.Check(
+		GetEndpoint("Central China West"),
+		Equals,
+		GetEndpoint("China East"))
 }
 
 func (*endpointsSuite) TestPrefixHostPrefixesSubdomain(c *C) {
-    c.Check(
-        prefixHost("foo", "http://example.com"),
-        Equals,
-        "http://foo.example.com")
+	c.Check(
+		prefixHost("foo", "http://example.com"),
+		Equals,
+		"http://foo.example.com")
 }
 
 func (*endpointsSuite) TestPrefixHostPreservesOtherURLComponents(c *C) {
-    c.Check(
-        prefixHost("foo", "http://example.com/"),
-        Equals,
-        "http://foo.example.com/")
-    c.Check(
-        prefixHost("foo", "nntp://example.com"),
-        Equals,
-        "nntp://foo.example.com")
-    c.Check(
-        prefixHost("foo", "http://[e-mail]"),
-        Equals,
-        "http://[e-mail]")
-    c.Check(
-        prefixHost("foo", "http://example.com:999"),
-        Equals,
-        "http://foo.example.com:999")
-    c.Check(
-        prefixHost("foo", "http://example.com/path"),
-        Equals,
-        "http://foo.example.com/path")
+	c.Check(
+		prefixHost("foo", "http://example.com/"),
+		Equals,
+		"http://foo.example.com/")
+	c.Check(
+		prefixHost("foo", "nntp://example.com"),
+		Equals,
+		"nntp://foo.example.com")
+	c.Check(
+		prefixHost("foo", "http://[e-mail]"),
+		Equals,
+		"http://[e-mail]")
+	c.Check(
+		prefixHost("foo", "http://example.com:999"),
+		Equals,
+		"http://foo.example.com:999")
+	c.Check(
+		prefixHost("foo", "http://example.com/path"),
+		Equals,
+		"http://foo.example.com/path")
 }
 
 func (*endpointsSuite) TestPrefixHostEscapes(c *C) {
-    host := "5%=1/20?"
-    c.Check(
-        prefixHost(host, "http://example.com"),
-        Equals,
-        fmt.Sprintf("http://%s.example.com", url.QueryEscape(host)))
+	host := "5%=1/20?"
+	c.Check(
+		prefixHost(host, "http://example.com"),
+		Equals,
+		fmt.Sprintf("http://%s.example.com", url.QueryEscape(host)))
 }
 
 func (*endpointsSuite) TestManagementAPICombinesWithGetEndpoint(c *C) {
-    c.Check(
-        GetEndpoint("West US").ManagementAPI(),
-        Equals,
-        "https://management.core.windows.net/")
-    c.Check(
-        GetEndpoint("China East").ManagementAPI(),
-        Equals,
-        "https://management.core.chinacloudapi.cn/")
+	c.Check(
+		GetEndpoint("West US").ManagementAPI(),
+		Equals,
+		"https://management.core.windows.net/")
+	c.Check(
+		GetEndpoint("China East").ManagementAPI(),
+		Equals,
+		"https://management.core.chinacloudapi.cn/")
 }
 
 func (*endpointsSuite) TestBlobStorageAPIIncludesAccountName(c *C) {
-    c.Check(
-        APIEndpoint("http://example.com").BlobStorageAPI("myaccount"),
-        Equals,
-        "http://myaccount.blob.example.com")
+	c.Check(
+		APIEndpoint("http://example.com").BlobStorageAPI("myaccount"),
+		Equals,
+		"http://myaccount.blob.example.com")
 }
 
 func (*endpointsSuite) TestBlobStorageAPICombinesWithGetEndpoint(c *C) {
-    c.Check(
-        GetEndpoint("West US").BlobStorageAPI("account"),
-        Equals,
-        "https://account.blob.core.windows.net/")
-    c.Check(
-        GetEndpoint("China East").BlobStorageAPI("account"),
-        Equals,
-        "https://account.blob.core.chinacloudapi.cn/")
+	c.Check(
+		GetEndpoint("West US").BlobStorageAPI("account"),
+		Equals,
+		"https://account.blob.core.windows.net/")
+	c.Check(
+		GetEndpoint("China East").BlobStorageAPI("account"),
+		Equals,
+		"https://account.blob.core.chinacloudapi.cn/")
 }

=== modified file 'example/management/run.go'
--- example/management/run.go	2014-03-10 03:56:29 +0000
+++ example/management/run.go	2014-12-02 00:40:19 +0000
@@ -10,14 +10,14 @@
 package main
 
 import (
-    "encoding/base64"
-    "flag"
-    "fmt"
-    "launchpad.net/gwacl"
-    . "launchpad.net/gwacl/logging"
-    "math/rand"
-    "os"
-    "time"
+	"encoding/base64"
+	"flag"
+	"fmt"
+	"launchpad.net/gwacl"
+	. "launchpad.net/gwacl/logging"
+	"math/rand"
+	"os"
+	"time"
 )
 
 var certFile string
@@ -26,26 +26,26 @@
 var location string
 
 func getParams() error {
-    flag.StringVar(&certFile, "cert", "", "Name of your management certificate file (in PEM format).")
-    flag.StringVar(&subscriptionID, "subscriptionid", "", "Your Azure subscription ID.")
-    flag.BoolVar(&pause, "pause", false, "Wait for user input after the VM is brought up (useful for further testing)")
-    flag.StringVar(&location, "location", "North Europe", "Azure cloud location, e.g. 'West US' or 'China East'")
-
-    flag.Parse()
-
-    if certFile == "" {
-        return fmt.Errorf("No .pem certificate specified.  Use the -cert option.")
-    }
-    if subscriptionID == "" {
-        return fmt.Errorf("No subscription ID specified.  Use the -subscriptionid option.")
-    }
-    return nil
+	flag.StringVar(&certFile, "cert", "", "Name of your management certificate file (in PEM format).")
+	flag.StringVar(&subscriptionID, "subscriptionid", "", "Your Azure subscription ID.")
+	flag.BoolVar(&pause, "pause", false, "Wait for user input after the VM is brought up (useful for further testing)")
+	flag.StringVar(&location, "location", "North Europe", "Azure cloud location, e.g. 'West US' or 'China East'")
+
+	flag.Parse()
+
+	if certFile == "" {
+		return fmt.Errorf("No .pem certificate specified.  Use the -cert option.")
+	}
+	if subscriptionID == "" {
+		return fmt.Errorf("No subscription ID specified.  Use the -subscriptionid option.")
+	}
+	return nil
 }
 
 func checkError(err error) {
-    if err != nil {
-        panic(err)
-    }
+	if err != nil {
+		panic(err)
+	}
 }
 
 // makeRandomIdentifier creates an arbitrary identifier of the given length,
@@ -53,231 +53,231 @@
 // The identifier will start with the given prefix.  The prefix must be no
 // longer than the specified length, or there'll be trouble.
 func makeRandomIdentifier(prefix string, length int) string {
-    // Only digits and lower-case ASCII letters are accepted.
-    const chars = "abcdefghijklmnopqrstuvwxyz0123456789"
-
-    if len(prefix) > length {
-        panic(fmt.Errorf("prefix '%s' is more than the requested %d characters long", prefix, length))
-    }
-
-    id := prefix
-    for len(id) < length {
-        id += string(chars[rand.Intn(len(chars))])
-    }
-    return id
+	// Only digits and lower-case ASCII letters are accepted.
+	const chars = "abcdefghijklmnopqrstuvwxyz0123456789"
+
+	if len(prefix) > length {
+		panic(fmt.Errorf("prefix '%s' is more than the requested %d characters long", prefix, length))
+	}
+
+	id := prefix
+	for len(id) < length {
+		id += string(chars[rand.Intn(len(chars))])
+	}
+	return id
 }
 
 func main() {
-    rand.Seed(int64(time.Now().Nanosecond()))
-
-    err := getParams()
-    if err != nil {
-        Info(err)
-        os.Exit(1)
-    }
-
-    api, err := gwacl.NewManagementAPI(subscriptionID, certFile, location)
-    checkError(err)
-
-    ExerciseHostedServicesAPI(api)
-
-    Info("All done.")
+	rand.Seed(int64(time.Now().Nanosecond()))
+
+	err := getParams()
+	if err != nil {
+		Info(err)
+		os.Exit(1)
+	}
+
+	api, err := gwacl.NewManagementAPI(subscriptionID, certFile, location)
+	checkError(err)
+
+	ExerciseHostedServicesAPI(api)
+
+	Info("All done.")
 }
 
 func ExerciseHostedServicesAPI(api *gwacl.ManagementAPI) {
-    var err error
-    location := "West US"
-    release := "13.04"
-
-    affinityGroupName := gwacl.MakeRandomHostname("affinitygroup")
-    Info("Creating an affinity group...")
-    cag := gwacl.NewCreateAffinityGroup(affinityGroupName, "affinity-label", "affinity-description", location)
-    err = api.CreateAffinityGroup(&gwacl.CreateAffinityGroupRequest{
-        CreateAffinityGroup: cag})
-    checkError(err)
-    Infof("Created affinity group %s\n", affinityGroupName)
-
-    defer func() {
-        Infof("Deleting affinity group %s\n", affinityGroupName)
-        err := api.DeleteAffinityGroup(&gwacl.DeleteAffinityGroupRequest{
-            Name: affinityGroupName})
-        checkError(err)
-        Infof("Done deleting affinity group %s\n", affinityGroupName)
-    }()
-
-    virtualNetworkName := gwacl.MakeRandomVirtualNetworkName("virtual-net-")
-    Infof("Creating virtual network %s...\n", virtualNetworkName)
-    virtualNetwork := gwacl.VirtualNetworkSite{
-        Name:          virtualNetworkName,
-        AffinityGroup: affinityGroupName,
-        AddressSpacePrefixes: []string{
-            "10.0.0.0/8",
-        },
-    }
-    err = api.AddVirtualNetworkSite(&virtualNetwork)
-    checkError(err)
-    Info("Done creating virtual network")
-
-    defer func() {
-        Infof("Deleting virtual network %s...\n", virtualNetworkName)
-        err := api.RemoveVirtualNetworkSite(virtualNetworkName)
-        checkError(err)
-        Infof("Done deleting virtual network %s\n", virtualNetworkName)
-    }()
-
-    networkConfig, err := api.GetNetworkConfiguration()
-    checkError(err)
-    if networkConfig == nil {
-        Info("No network configuration is set")
-    } else {
-        xml, err := networkConfig.Serialize()
-        checkError(err)
-        Info(xml)
-    }
-
-    Infof("Getting OS Image for release '%s' and location '%s'...\n", release, location)
-    images, err := api.ListOSImages()
-    checkError(err)
-    image, err := images.GetLatestUbuntuImage(release, location)
-    checkError(err)
-    sourceImageName := image.Name
-    Infof("Got image named '%s'\n", sourceImageName)
-    Info("Done getting OS Image\n")
-
-    hostServiceName := gwacl.MakeRandomHostedServiceName("gwacl")
-    Infof("Creating a hosted service: '%s'...\n", hostServiceName)
-    createHostedService := gwacl.NewCreateHostedServiceWithLocation(hostServiceName, "testLabel", location)
-    createHostedService.AffinityGroup = affinityGroupName
-    err = api.AddHostedService(createHostedService)
-    checkError(err)
-    Info("Done creating a hosted service\n")
-
-    defer func() {
-        Info("Destroying hosted service...")
-        // FIXME: Check error
-        api.DestroyHostedService(&gwacl.DestroyHostedServiceRequest{
-            ServiceName: hostServiceName})
-        Info("Done destroying hosted service\n")
-    }()
-
-    Info("Listing hosted services...")
-    hostedServices, err := api.ListHostedServices()
-    checkError(err)
-    Infof("Got %d hosted service(s)\n", len(hostedServices))
-    if len(hostedServices) > 0 {
-        hostedService := hostedServices[0]
-        detailedHostedService, err := api.GetHostedServiceProperties(hostedService.ServiceName, true)
-        checkError(err)
-        Infof("Hosted service '%s' contains %d deployments\n", hostedService.ServiceName, len(detailedHostedService.Deployments))
-        // Do the same again with ListAllDeployments.
-        deployments, err := api.ListAllDeployments(&gwacl.ListAllDeploymentsRequest{ServiceName: hostedService.ServiceName})
-        checkError(err)
-        if len(deployments) != len(detailedHostedService.Deployments) {
-            Errorf(
-                "Mismatch in reported deployments: %d != %d",
-                len(deployments), len(detailedHostedService.Deployments))
-        }
-    }
-    Info("Done listing hosted services\n")
-
-    Info("Adding VM deployment...")
-    hostname := gwacl.MakeRandomHostname("gwaclhost")
-    // Random passwords are no use to man nor beast here if you want to
-    // test with your instance, so we'll use a fixed one.  It's not really a
-    // security hazard in such a short-lived private instance.
-    password := "Ubuntu123"
-    username := "ubuntu"
-    vhdName := gwacl.MakeRandomDiskName("gwacldisk")
-    userdata := base64.StdEncoding.EncodeToString([]byte("TEST_USER_DATA"))
-    linuxConfigurationSet := gwacl.NewLinuxProvisioningConfigurationSet(
-        hostname, username, password, userdata, "false")
-    inputendpoint := gwacl.InputEndpoint{LocalPort: 22, Name: "sshport", Port: 22, Protocol: "TCP"}
-    networkConfigurationSet := gwacl.NewNetworkConfigurationSet([]gwacl.InputEndpoint{inputendpoint}, nil)
-
-    storageAccount := makeRandomIdentifier("gwacl", 24)
-    storageLabel := makeRandomIdentifier("gwacl", 64)
-    Infof("Requesting storage account with name '%s' and label '%s'...\n", storageAccount, storageLabel)
-    cssi := gwacl.NewCreateStorageServiceInputWithLocation(storageAccount, storageLabel, location, "false")
-    err = api.AddStorageAccount(cssi)
-    checkError(err)
-    Info("Done requesting storage account\n")
-
-    defer func() {
-        Infof("Deleting storage account %s...\n", storageAccount)
-        // FIXME: Check error
-        api.DeleteStorageAccount(storageAccount)
-        Info("Done deleting storage account\n")
-    }()
-
-    mediaLink := gwacl.CreateVirtualHardDiskMediaLink(storageAccount, fmt.Sprintf("vhds/%s.vhd", vhdName))
-    diskName := makeRandomIdentifier("gwacldisk", 16)
-    diskLabel := makeRandomIdentifier("gwacl", 64)
-    vhd := gwacl.NewOSVirtualHardDisk("", diskLabel, diskName, mediaLink, sourceImageName, "Linux")
-    roleName := gwacl.MakeRandomRoleName("gwaclrole")
-    role := gwacl.NewRole("ExtraSmall", roleName, vhd,
-        []gwacl.ConfigurationSet{*linuxConfigurationSet, *networkConfigurationSet})
-    machineName := makeRandomIdentifier("gwaclmachine", 20)
-    deployment := gwacl.NewDeploymentForCreateVMDeployment(
-        machineName, "Production", machineName, []gwacl.Role{*role}, virtualNetworkName)
-    err = api.AddDeployment(deployment, hostServiceName)
-    checkError(err)
-    Info("Done adding VM deployment\n")
-
-    Info("Starting VM...")
-    err = api.StartRole(&gwacl.StartRoleRequest{hostServiceName, deployment.Name, role.RoleName})
-    checkError(err)
-    Info("Done starting VM\n")
-
-    Info("Listing VM...")
-    instances, err := api.ListInstances(&gwacl.ListInstancesRequest{hostServiceName})
-    checkError(err)
-    Infof("Got %d instance(s)\n", len(instances))
-    Info("Done listing VM\n")
-
-    Info("Getting deployment info...")
-    request := &gwacl.GetDeploymentRequest{ServiceName: hostServiceName, DeploymentName: machineName}
-    deploy, err := api.GetDeployment(request)
-    checkError(err)
-    fqdn, err := deploy.GetFQDN()
-    checkError(err)
-    Info("Got deployment info\n")
-
-    Info("Adding role input endpoint...")
-    endpoint := gwacl.InputEndpoint{
-        Name:      gwacl.MakeRandomHostname("endpoint-"),
-        Port:      1080,
-        LocalPort: 80,
-        Protocol:  "TCP",
-    }
-    err = api.AddRoleEndpoints(&gwacl.AddRoleEndpointsRequest{
-        ServiceName:    hostServiceName,
-        DeploymentName: deployment.Name,
-        RoleName:       role.RoleName,
-        InputEndpoints: []gwacl.InputEndpoint{endpoint},
-    })
-    checkError(err)
-    Info("Added role input endpoint\n")
-
-    defer func() {
-        Info("Removing role input endpoint...")
-        err := api.RemoveRoleEndpoints(&gwacl.RemoveRoleEndpointsRequest{
-            ServiceName:    hostServiceName,
-            DeploymentName: deployment.Name,
-            RoleName:       role.RoleName,
-            InputEndpoints: []gwacl.InputEndpoint{endpoint},
-        })
-        checkError(err)
-        Info("Removed role input endpoint\n")
-    }()
-
-    if pause {
-        var wait string
-        fmt.Println("host:", fqdn)
-        fmt.Println("username:", username)
-        fmt.Println("password:", password)
-        fmt.Println("")
-        fmt.Println("Pausing so you can play with the newly-created VM")
-        fmt.Println("To clear up, type something and press enter to continue")
-        fmt.Scan(&wait)
-    }
+	var err error
+	location := "West US"
+	release := "13.04"
+
+	affinityGroupName := gwacl.MakeRandomHostname("affinitygroup")
+	Info("Creating an affinity group...")
+	cag := gwacl.NewCreateAffinityGroup(affinityGroupName, "affinity-label", "affinity-description", location)
+	err = api.CreateAffinityGroup(&gwacl.CreateAffinityGroupRequest{
+		CreateAffinityGroup: cag})
+	checkError(err)
+	Infof("Created affinity group %s\n", affinityGroupName)
+
+	defer func() {
+		Infof("Deleting affinity group %s\n", affinityGroupName)
+		err := api.DeleteAffinityGroup(&gwacl.DeleteAffinityGroupRequest{
+			Name: affinityGroupName})
+		checkError(err)
+		Infof("Done deleting affinity group %s\n", affinityGroupName)
+	}()
+
+	virtualNetworkName := gwacl.MakeRandomVirtualNetworkName("virtual-net-")
+	Infof("Creating virtual network %s...\n", virtualNetworkName)
+	virtualNetwork := gwacl.VirtualNetworkSite{
+		Name:          virtualNetworkName,
+		AffinityGroup: affinityGroupName,
+		AddressSpacePrefixes: []string{
+			"10.0.0.0/8",
+		},
+	}
+	err = api.AddVirtualNetworkSite(&virtualNetwork)
+	checkError(err)
+	Info("Done creating virtual network")
+
+	defer func() {
+		Infof("Deleting virtual network %s...\n", virtualNetworkName)
+		err := api.RemoveVirtualNetworkSite(virtualNetworkName)
+		checkError(err)
+		Infof("Done deleting virtual network %s\n", virtualNetworkName)
+	}()
+
+	networkConfig, err := api.GetNetworkConfiguration()
+	checkError(err)
+	if networkConfig == nil {
+		Info("No network configuration is set")
+	} else {
+		xml, err := networkConfig.Serialize()
+		checkError(err)
+		Info(xml)
+	}
+
+	Infof("Getting OS Image for release '%s' and location '%s'...\n", release, location)
+	images, err := api.ListOSImages()
+	checkError(err)
+	image, err := images.GetLatestUbuntuImage(release, location)
+	checkError(err)
+	sourceImageName := image.Name
+	Infof("Got image named '%s'\n", sourceImageName)
+	Info("Done getting OS Image\n")
+
+	hostServiceName := gwacl.MakeRandomHostedServiceName("gwacl")
+	Infof("Creating a hosted service: '%s'...\n", hostServiceName)
+	createHostedService := gwacl.NewCreateHostedServiceWithLocation(hostServiceName, "testLabel", location)
+	createHostedService.AffinityGroup = affinityGroupName
+	err = api.AddHostedService(createHostedService)
+	checkError(err)
+	Info("Done creating a hosted service\n")
+
+	defer func() {
+		Info("Destroying hosted service...")
+		// FIXME: Check error
+		api.DestroyHostedService(&gwacl.DestroyHostedServiceRequest{
+			ServiceName: hostServiceName})
+		Info("Done destroying hosted service\n")
+	}()
+
+	Info("Listing hosted services...")
+	hostedServices, err := api.ListHostedServices()
+	checkError(err)
+	Infof("Got %d hosted service(s)\n", len(hostedServices))
+	if len(hostedServices) > 0 {
+		hostedService := hostedServices[0]
+		detailedHostedService, err := api.GetHostedServiceProperties(hostedService.ServiceName, true)
+		checkError(err)
+		Infof("Hosted service '%s' contains %d deployments\n", hostedService.ServiceName, len(detailedHostedService.Deployments))
+		// Do the same again with ListAllDeployments.
+		deployments, err := api.ListAllDeployments(&gwacl.ListAllDeploymentsRequest{ServiceName: hostedService.ServiceName})
+		checkError(err)
+		if len(deployments) != len(detailedHostedService.Deployments) {
+			Errorf(
+				"Mismatch in reported deployments: %d != %d",
+				len(deployments), len(detailedHostedService.Deployments))
+		}
+	}
+	Info("Done listing hosted services\n")
+
+	Info("Adding VM deployment...")
+	hostname := gwacl.MakeRandomHostname("gwaclhost")
+	// Random passwords are no use to man nor beast here if you want to
+	// test with your instance, so we'll use a fixed one.  It's not really a
+	// security hazard in such a short-lived private instance.
+	password := "Ubuntu123"
+	username := "ubuntu"
+	vhdName := gwacl.MakeRandomDiskName("gwacldisk")
+	userdata := base64.StdEncoding.EncodeToString([]byte("TEST_USER_DATA"))
+	linuxConfigurationSet := gwacl.NewLinuxProvisioningConfigurationSet(
+		hostname, username, password, userdata, "false")
+	inputendpoint := gwacl.InputEndpoint{LocalPort: 22, Name: "sshport", Port: 22, Protocol: "TCP"}
+	networkConfigurationSet := gwacl.NewNetworkConfigurationSet([]gwacl.InputEndpoint{inputendpoint}, nil)
+
+	storageAccount := makeRandomIdentifier("gwacl", 24)
+	storageLabel := makeRandomIdentifier("gwacl", 64)
+	Infof("Requesting storage account with name '%s' and label '%s'...\n", storageAccount, storageLabel)
+	cssi := gwacl.NewCreateStorageServiceInputWithLocation(storageAccount, storageLabel, location, "false")
+	err = api.AddStorageAccount(cssi)
+	checkError(err)
+	Info("Done requesting storage account\n")
+
+	defer func() {
+		Infof("Deleting storage account %s...\n", storageAccount)
+		// FIXME: Check error
+		api.DeleteStorageAccount(storageAccount)
+		Info("Done deleting storage account\n")
+	}()
+
+	mediaLink := gwacl.CreateVirtualHardDiskMediaLink(storageAccount, fmt.Sprintf("vhds/%s.vhd", vhdName))
+	diskName := makeRandomIdentifier("gwacldisk", 16)
+	diskLabel := makeRandomIdentifier("gwacl", 64)
+	vhd := gwacl.NewOSVirtualHardDisk("", diskLabel, diskName, mediaLink, sourceImageName, "Linux")
+	roleName := gwacl.MakeRandomRoleName("gwaclrole")
+	role := gwacl.NewRole("ExtraSmall", roleName, vhd,
+		[]gwacl.ConfigurationSet{*linuxConfigurationSet, *networkConfigurationSet})
+	machineName := makeRandomIdentifier("gwaclmachine", 20)
+	deployment := gwacl.NewDeploymentForCreateVMDeployment(
+		machineName, "Production", machineName, []gwacl.Role{*role}, virtualNetworkName)
+	err = api.AddDeployment(deployment, hostServiceName)
+	checkError(err)
+	Info("Done adding VM deployment\n")
+
+	Info("Starting VM...")
+	err = api.StartRole(&gwacl.StartRoleRequest{hostServiceName, deployment.Name, role.RoleName})
+	checkError(err)
+	Info("Done starting VM\n")
+
+	Info("Listing VM...")
+	instances, err := api.ListInstances(&gwacl.ListInstancesRequest{hostServiceName})
+	checkError(err)
+	Infof("Got %d instance(s)\n", len(instances))
+	Info("Done listing VM\n")
+
+	Info("Getting deployment info...")
+	request := &gwacl.GetDeploymentRequest{ServiceName: hostServiceName, DeploymentName: machineName}
+	deploy, err := api.GetDeployment(request)
+	checkError(err)
+	fqdn, err := deploy.GetFQDN()
+	checkError(err)
+	Info("Got deployment info\n")
+
+	Info("Adding role input endpoint...")
+	endpoint := gwacl.InputEndpoint{
+		Name:      gwacl.MakeRandomHostname("endpoint-"),
+		Port:      1080,
+		LocalPort: 80,
+		Protocol:  "TCP",
+	}
+	err = api.AddRoleEndpoints(&gwacl.AddRoleEndpointsRequest{
+		ServiceName:    hostServiceName,
+		DeploymentName: deployment.Name,
+		RoleName:       role.RoleName,
+		InputEndpoints: []gwacl.InputEndpoint{endpoint},
+	})
+	checkError(err)
+	Info("Added role input endpoint\n")
+
+	defer func() {
+		Info("Removing role input endpoint...")
+		err := api.RemoveRoleEndpoints(&gwacl.RemoveRoleEndpointsRequest{
+			ServiceName:    hostServiceName,
+			DeploymentName: deployment.Name,
+			RoleName:       role.RoleName,
+			InputEndpoints: []gwacl.InputEndpoint{endpoint},
+		})
+		checkError(err)
+		Info("Removed role input endpoint\n")
+	}()
+
+	if pause {
+		var wait string
+		fmt.Println("host:", fqdn)
+		fmt.Println("username:", username)
+		fmt.Println("password:", password)
+		fmt.Println("")
+		fmt.Println("Pausing so you can play with the newly-created VM")
+		fmt.Println("To clear up, type something and press enter to continue")
+		fmt.Scan(&wait)
+	}
 }

=== modified file 'example/storage/run.go'
--- example/storage/run.go	2013-08-19 06:05:38 +0000
+++ example/storage/run.go	2014-12-02 00:40:19 +0000
@@ -10,106 +10,106 @@
 package main
 
 import (
-    "flag"
-    "fmt"
-    "io/ioutil"
-    "launchpad.net/gwacl"
-    "os"
-    "strings"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"launchpad.net/gwacl"
+	"os"
+	"strings"
 )
 
 func badOperationError() error {
-    return fmt.Errorf("Must specify one of %v", operationNames)
+	return fmt.Errorf("Must specify one of %v", operationNames)
 }
 
 // operation is something you can instruct this program to do, by specifying
 // its name on the command line.
 type operation struct {
-    // name is the operation name as used on the command line.
-    name string
-    // description holds a description of what the operation does.
-    description string
-    // example illustrates how the operation is used.
-    example string
-    // requiredArgs lists the command-line options that are required for this
-    // operation.
-    requiredArgs []string
-    // validate is an optional callback to perform more detailed checking on
-    // the operation's arguments.
-    validate func() error
-    // implementation is a function that performs the operation.  If it fails,
-    // it just panics.
-    implementation func(gwacl.StorageContext)
+	// name is the operation name as used on the command line.
+	name string
+	// description holds a description of what the operation does.
+	description string
+	// example illustrates how the operation is used.
+	example string
+	// requiredArgs lists the command-line options that are required for this
+	// operation.
+	requiredArgs []string
+	// validate is an optional callback to perform more detailed checking on
+	// the operation's arguments.
+	validate func() error
+	// implementation is a function that performs the operation.  If it fails,
+	// it just panics.
+	implementation func(gwacl.StorageContext)
 }
 
 // operations defines what operations are available to be invoked from the
 // command line.
 var operations = []operation{
-    {
-        name:           "listcontainers",
-        description:    "Show existing storage containers",
-        example:        "listcontainers",
-        implementation: listcontainers,
-    },
-    {
-        name:           "list",
-        description:    "List files in a container",
-        example:        "-container=<container> list",
-        requiredArgs:   []string{"container"},
-        implementation: list,
-    },
-    {
-        name:         "containeracl",
-        description:  "Set access on a container",
-        example:      "-container=<container> -acl <container|blob|private> containeracl",
-        requiredArgs: []string{"container", "key", "acl"},
-        validate: func() error {
-            if acl != "container" && acl != "blob" && acl != "private" {
-                return fmt.Errorf(
-                    "Usage: containeracl -container=<container> <container|blob|private>")
-            }
-            return nil
-        },
-        implementation: containeracl,
-    },
-    {
-        name:           "getblob",
-        description:    "Get a file from a container (it's returned on stdout)",
-        example:        "-container=<container> -filename=<filename> getblob",
-        requiredArgs:   []string{"container", "filename"},
-        implementation: getblob,
-    },
-    {
-        name:           "addblock",
-        description:    "Upload a file to a block blob",
-        example:        "-container=<container> -filename=<filename> addblock",
-        requiredArgs:   []string{"key", "container", "filename"},
-        implementation: addblock,
-    },
-    {
-        name:           "deleteblob",
-        description:    "Delete a blob",
-        example:        "-container=<container> -filename=<filename> deleteblob",
-        requiredArgs:   []string{"key", "container", "filename"},
-        implementation: deleteblob,
-    },
-    {
-        name:        "putblob",
-        description: "Create an empty page blob",
-        example: "-container=<container> -blobname=<blobname> -size=<bytes> " +
-            "-blobtype=\"page\" putblob",
-        requiredArgs:   []string{"key", "blobname", "blobtype", "container", "size"},
-        implementation: putblob,
-    },
-    {
-        name: "putpage",
-        description: "Upload a file to a page blob's page.  The range parameters must " +
-            "be (modulo 512)-(modulo 512 -1), eg: -pagerange=0-511",
-        example: "-container=<container> -blobname=<blobname> -pagerange=<N-N> " +
-            "-filename=<local file> putpage",
-        requiredArgs:   []string{"key", "blobname", "container", "pagerange", "filename"},
-        implementation: putpage,
-    },
+	{
+		name:           "listcontainers",
+		description:    "Show existing storage containers",
+		example:        "listcontainers",
+		implementation: listcontainers,
+	},
+	{
+		name:           "list",
+		description:    "List files in a container",
+		example:        "-container=<container> list",
+		requiredArgs:   []string{"container"},
+		implementation: list,
+	},
+	{
+		name:         "containeracl",
+		description:  "Set access on a container",
+		example:      "-container=<container> -acl <container|blob|private> containeracl",
+		requiredArgs: []string{"container", "key", "acl"},
+		validate: func() error {
+			if acl != "container" && acl != "blob" && acl != "private" {
+				return fmt.Errorf(
+					"Usage: containeracl -container=<container> <container|blob|private>")
+			}
+			return nil
+		},
+		implementation: containeracl,
+	},
+	{
+		name:           "getblob",
+		description:    "Get a file from a container (it's returned on stdout)",
+		example:        "-container=<container> -filename=<filename> getblob",
+		requiredArgs:   []string{"container", "filename"},
+		implementation: getblob,
+	},
+	{
+		name:           "addblock",
+		description:    "Upload a file to a block blob",
+		example:        "-container=<container> -filename=<filename> addblock",
+		requiredArgs:   []string{"key", "container", "filename"},
+		implementation: addblock,
+	},
+	{
+		name:           "deleteblob",
+		description:    "Delete a blob",
+		example:        "-container=<container> -filename=<filename> deleteblob",
+		requiredArgs:   []string{"key", "container", "filename"},
+		implementation: deleteblob,
+	},
+	{
+		name:        "putblob",
+		description: "Create an empty page blob",
+		example: "-container=<container> -blobname=<blobname> -size=<bytes> " +
+			"-blobtype=\"page\" putblob",
+		requiredArgs:   []string{"key", "blobname", "blobtype", "container", "size"},
+		implementation: putblob,
+	},
+	{
+		name: "putpage",
+		description: "Upload a file to a page blob's page.  The range parameters must " +
+			"be (modulo 512)-(modulo 512 -1), eg: -pagerange=0-511",
+		example: "-container=<container> -blobname=<blobname> -pagerange=<N-N> " +
+			"-filename=<local file> putpage",
+		requiredArgs:   []string{"key", "blobname", "container", "pagerange", "filename"},
+		implementation: putpage,
+	},
 }
 
 // operationsByName maps each opeation name to an operation struct that
@@ -121,130 +121,130 @@
 var operationNames []string
 
 func init() {
-    operationsByName = make(map[string]operation, len(operations))
-    for _, op := range operations {
-        operationsByName[op.name] = op
-    }
+	operationsByName = make(map[string]operation, len(operations))
+	for _, op := range operations {
+		operationsByName[op.name] = op
+	}
 
-    operationNames = make([]string, len(operations))
-    for index, op := range operations {
-        operationNames[index] = op.name
-    }
+	operationNames = make([]string, len(operations))
+	for index, op := range operations {
+		operationNames[index] = op.name
+	}
 }
 
 // Variables set by command-line options.
 var (
-    help      bool
-    account   string
-    location  string
-    key       string
-    filename  string
-    container string
-    prefix    string
-    blobname  string
-    blobtype  string
-    size      int
-    pagerange string
-    acl       string
+	help      bool
+	account   string
+	location  string
+	key       string
+	filename  string
+	container string
+	prefix    string
+	blobname  string
+	blobtype  string
+	size      int
+	pagerange string
+	acl       string
 )
 
 // argumentGiven returns whether the named argument was specified on the
 // command line.
 func argumentGiven(name string) bool {
-    // This is stupid.  There must be a way to ask the flag module directly!
-    switch name {
-    case "account":
-        return account != ""
-    case "location":
-        return location != ""
-    case "key":
-        return key != ""
-    case "container":
-        return container != ""
-    case "filename":
-        return filename != ""
-    case "prefix":
-        return prefix != ""
-    case "blobname":
-        return blobname != ""
-    case "blobtype":
-        return blobtype != ""
-    case "size":
-        return size != 0
-    case "pagerange":
-        return pagerange != ""
-    case "acl":
-        return acl != ""
-    }
-    panic(fmt.Errorf("internal error: unknown command-line option: %s", name))
+	// This is stupid.  There must be a way to ask the flag module directly!
+	switch name {
+	case "account":
+		return account != ""
+	case "location":
+		return location != ""
+	case "key":
+		return key != ""
+	case "container":
+		return container != ""
+	case "filename":
+		return filename != ""
+	case "prefix":
+		return prefix != ""
+	case "blobname":
+		return blobname != ""
+	case "blobtype":
+		return blobtype != ""
+	case "size":
+		return size != 0
+	case "pagerange":
+		return pagerange != ""
+	case "acl":
+		return acl != ""
+	}
+	panic(fmt.Errorf("internal error: unknown command-line option: %s", name))
 }
 
 func getParams() (string, error) {
-    flag.BoolVar(&help, "h", false, "Show usage and exit")
-
-    flag.StringVar(&account, "account", "", "Storage account name")
-    flag.StringVar(&location, "location", "", "Azure location, e.g. \"West US\", \"China East\", or \"North Europe\"")
-    flag.StringVar(&key, "key", "", "A valid storage account key (base64 encoded), defaults to the empty string (i.e. anonymous access)")
-    flag.StringVar(&container, "container", "", "Name of the container to use")
-    flag.StringVar(&filename, "filename", "", "File containing blob/page to upload/download")
-    flag.StringVar(&prefix, "prefix", "", "Prefix to match when listing blobs")
-    flag.StringVar(&blobname, "blobname", "", "Name of blob in container")
-    flag.StringVar(&blobtype, "blobtype", "", "Type of blob, 'page' or 'block'")
-    flag.IntVar(&size, "size", 0, "Size of blob to create for a page 'putblob'")
-    flag.StringVar(&pagerange, "pagerange", "", "When uploading to a page blob, this specifies what range in the blob. Use the format 'start-end', e.g. -pagerange 1024-2048")
-    flag.StringVar(&acl, "acl", "", "When using 'containeracl', specify an ACL type")
-    flag.Parse()
-
-    if help {
-        return "", nil
-    }
-
-    opName := flag.Arg(0)
-    if opName == "" {
-        return "", fmt.Errorf("No operation specified")
-    }
-
-    requiredArgs := []string{"account", "location"}
-    for _, arg := range requiredArgs {
-        if !argumentGiven(arg) {
-            return "", fmt.Errorf("Must supply %q parameter.", arg)
-        }
-    }
-
-    if len(flag.Args()) != 1 {
-        return "", badOperationError()
-    }
-
-    op, isDefined := operationsByName[opName]
-    if !isDefined {
-        return "", badOperationError()
-    }
-
-    for _, arg := range op.requiredArgs {
-        if !argumentGiven(arg) {
-            return "", fmt.Errorf("%q requires these options: %v", op.name, op.requiredArgs)
-        }
-    }
-
-    if op.validate != nil {
-        err := op.validate()
-        if err != nil {
-            return "", err
-        }
-    }
-
-    return op.name, nil
+	flag.BoolVar(&help, "h", false, "Show usage and exit")
+
+	flag.StringVar(&account, "account", "", "Storage account name")
+	flag.StringVar(&location, "location", "", "Azure location, e.g. \"West US\", \"China East\", or \"North Europe\"")
+	flag.StringVar(&key, "key", "", "A valid storage account key (base64 encoded), defaults to the empty string (i.e. anonymous access)")
+	flag.StringVar(&container, "container", "", "Name of the container to use")
+	flag.StringVar(&filename, "filename", "", "File containing blob/page to upload/download")
+	flag.StringVar(&prefix, "prefix", "", "Prefix to match when listing blobs")
+	flag.StringVar(&blobname, "blobname", "", "Name of blob in container")
+	flag.StringVar(&blobtype, "blobtype", "", "Type of blob, 'page' or 'block'")
+	flag.IntVar(&size, "size", 0, "Size of blob to create for a page 'putblob'")
+	flag.StringVar(&pagerange, "pagerange", "", "When uploading to a page blob, this specifies what range in the blob. Use the format 'start-end', e.g. -pagerange 1024-2048")
+	flag.StringVar(&acl, "acl", "", "When using 'containeracl', specify an ACL type")
+	flag.Parse()
+
+	if help {
+		return "", nil
+	}
+
+	opName := flag.Arg(0)
+	if opName == "" {
+		return "", fmt.Errorf("No operation specified")
+	}
+
+	requiredArgs := []string{"account", "location"}
+	for _, arg := range requiredArgs {
+		if !argumentGiven(arg) {
+			return "", fmt.Errorf("Must supply %q parameter.", arg)
+		}
+	}
+
+	if len(flag.Args()) != 1 {
+		return "", badOperationError()
+	}
+
+	op, isDefined := operationsByName[opName]
+	if !isDefined {
+		return "", badOperationError()
+	}
+
+	for _, arg := range op.requiredArgs {
+		if !argumentGiven(arg) {
+			return "", fmt.Errorf("%q requires these options: %v", op.name, op.requiredArgs)
+		}
+	}
+
+	if op.validate != nil {
+		err := op.validate()
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return op.name, nil
 }
 
 func Usage() {
-    fmt.Fprintf(
-        os.Stderr,
-        "Usage:\n    %s [args] <%s>\n",
-        os.Args[0],
-        strings.Join(operationNames, "|"))
-    flag.PrintDefaults()
+	fmt.Fprintf(
+		os.Stderr,
+		"Usage:\n    %s [args] <%s>\n",
+		os.Args[0],
+		strings.Join(operationNames, "|"))
+	flag.PrintDefaults()
 
-    fmt.Fprintf(os.Stderr, `
+	fmt.Fprintf(os.Stderr, `
     This is an example of how to interact with the Azure storage service.
     It is not a complete example but it does give a useful way to do do some
     basic operations.
@@ -255,142 +255,142 @@
     invocation parameters:
     `)
 
-    for _, op := range operations {
-        fmt.Fprintf(os.Stderr, "\n    %s:\n        %s\n", op.description, op.example)
-    }
+	for _, op := range operations {
+		fmt.Fprintf(os.Stderr, "\n    %s:\n        %s\n", op.description, op.example)
+	}
 }
 
 func dumpError(err error) {
-    if err != nil {
-        fmt.Fprintf(os.Stderr, "ERROR:")
-        fmt.Fprintf(os.Stderr, "%s\n", err)
-    }
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "ERROR:")
+		fmt.Fprintf(os.Stderr, "%s\n", err)
+	}
 }
 
 func listcontainers(storage gwacl.StorageContext) {
-    res, e := storage.ListAllContainers()
-    if e != nil {
-        dumpError(e)
-        return
-    }
-    for _, c := range res.Containers {
-        // TODO: embellish with the other container data
-        fmt.Println(c.Name)
-    }
+	res, e := storage.ListAllContainers()
+	if e != nil {
+		dumpError(e)
+		return
+	}
+	for _, c := range res.Containers {
+		// TODO: embellish with the other container data
+		fmt.Println(c.Name)
+	}
 }
 
 func containeracl(storage gwacl.StorageContext) {
-    err := storage.SetContainerACL(&gwacl.SetContainerACLRequest{
-        Container: container,
-        Access:    acl,
-    })
-    dumpError(err)
+	err := storage.SetContainerACL(&gwacl.SetContainerACLRequest{
+		Container: container,
+		Access:    acl,
+	})
+	dumpError(err)
 }
 
 func list(storage gwacl.StorageContext) {
-    request := &gwacl.ListBlobsRequest{
-        Container: container, Prefix: prefix}
-    res, err := storage.ListAllBlobs(request)
-    if err != nil {
-        dumpError(err)
-        return
-    }
-    for _, b := range res.Blobs {
-        fmt.Printf("%s, %s, %s\n", b.ContentLength, b.LastModified, b.Name)
-    }
+	request := &gwacl.ListBlobsRequest{
+		Container: container, Prefix: prefix}
+	res, err := storage.ListAllBlobs(request)
+	if err != nil {
+		dumpError(err)
+		return
+	}
+	for _, b := range res.Blobs {
+		fmt.Printf("%s, %s, %s\n", b.ContentLength, b.LastModified, b.Name)
+	}
 }
 
 func addblock(storage gwacl.StorageContext) {
-    var err error
-    file, err := os.Open(filename)
-    if err != nil {
-        dumpError(err)
-        return
-    }
-    defer file.Close()
+	var err error
+	file, err := os.Open(filename)
+	if err != nil {
+		dumpError(err)
+		return
+	}
+	defer file.Close()
 
-    err = storage.UploadBlockBlob(container, filename, file)
-    if err != nil {
-        dumpError(err)
-        return
-    }
+	err = storage.UploadBlockBlob(container, filename, file)
+	if err != nil {
+		dumpError(err)
+		return
+	}
 }
 
 func deleteblob(storage gwacl.StorageContext) {
-    err := storage.DeleteBlob(container, filename)
-    dumpError(err)
+	err := storage.DeleteBlob(container, filename)
+	dumpError(err)
 }
 
 func getblob(storage gwacl.StorageContext) {
-    var err error
-    file, err := storage.GetBlob(container, filename)
-    if err != nil {
-        dumpError(err)
-        return
-    }
-    data, err := ioutil.ReadAll(file)
-    if err != nil {
-        dumpError(err)
-        return
-    }
-    os.Stdout.Write(data)
+	var err error
+	file, err := storage.GetBlob(container, filename)
+	if err != nil {
+		dumpError(err)
+		return
+	}
+	data, err := ioutil.ReadAll(file)
+	if err != nil {
+		dumpError(err)
+		return
+	}
+	os.Stdout.Write(data)
 }
 
 func putblob(storage gwacl.StorageContext) {
-    err := storage.PutBlob(&gwacl.PutBlobRequest{
-        Container: container,
-        BlobType:  blobtype,
-        Filename:  blobname,
-        Size:      size,
-    })
-    dumpError(err)
+	err := storage.PutBlob(&gwacl.PutBlobRequest{
+		Container: container,
+		BlobType:  blobtype,
+		Filename:  blobname,
+		Size:      size,
+	})
+	dumpError(err)
 }
 
 func putpage(storage gwacl.StorageContext) {
-    var err error
-    file, err := os.Open(filename)
-    if err != nil {
-        dumpError(err)
-        return
-    }
-    defer file.Close()
-
-    var start, end int
-    fmt.Sscanf(pagerange, "%d-%d", &start, &end)
-
-    err = storage.PutPage(&gwacl.PutPageRequest{
-        Container:  container,
-        Filename:   blobname,
-        StartRange: start,
-        EndRange:   end,
-        Data:       file,
-    })
-    if err != nil {
-        dumpError(err)
-        return
-    }
+	var err error
+	file, err := os.Open(filename)
+	if err != nil {
+		dumpError(err)
+		return
+	}
+	defer file.Close()
+
+	var start, end int
+	fmt.Sscanf(pagerange, "%d-%d", &start, &end)
+
+	err = storage.PutPage(&gwacl.PutPageRequest{
+		Container:  container,
+		Filename:   blobname,
+		StartRange: start,
+		EndRange:   end,
+		Data:       file,
+	})
+	if err != nil {
+		dumpError(err)
+		return
+	}
 }
 
 func main() {
-    flag.Usage = Usage
-    var err error
-    op, err := getParams()
-    if err != nil {
-        fmt.Fprintf(os.Stderr, "%s\n", err.Error())
-        fmt.Fprintf(os.Stderr, "Use -h for help with using this program.\n")
-        os.Exit(1)
-    }
-    if help {
-        Usage()
-        os.Exit(0)
-    }
-
-    storage := gwacl.StorageContext{
-        Account:       account,
-        Key:           key,
-        AzureEndpoint: gwacl.GetEndpoint(location),
-    }
-
-    perform := operationsByName[op].implementation
-    perform(storage)
+	flag.Usage = Usage
+	var err error
+	op, err := getParams()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%s\n", err.Error())
+		fmt.Fprintf(os.Stderr, "Use -h for help with using this program.\n")
+		os.Exit(1)
+	}
+	if help {
+		Usage()
+		os.Exit(0)
+	}
+
+	storage := gwacl.StorageContext{
+		Account:       account,
+		Key:           key,
+		AzureEndpoint: gwacl.GetEndpoint(location),
+	}
+
+	perform := operationsByName[op].implementation
+	perform(storage)
 }

=== modified file 'fork/http/chunked.go'
--- fork/http/chunked.go	2013-07-22 12:53:27 +0000
+++ fork/http/chunked.go	2014-12-02 00:40:19 +0000
@@ -10,11 +10,11 @@
 package http
 
 import (
-    "bufio"
-    "bytes"
-    "errors"
-    "io"
-    "strconv"
+	"bufio"
+	"bytes"
+	"errors"
+	"io"
+	"strconv"
 )
 
 const maxLineLength = 4096 // assumed <= bufio.defaultBufSize
@@ -28,60 +28,60 @@
 // newChunkedReader is not needed by normal applications. The http package
 // automatically decodes chunking when reading response bodies.
 func newChunkedReader(r io.Reader) io.Reader {
-    br, ok := r.(*bufio.Reader)
-    if !ok {
-        br = bufio.NewReader(r)
-    }
-    return &chunkedReader{r: br}
+	br, ok := r.(*bufio.Reader)
+	if !ok {
+		br = bufio.NewReader(r)
+	}
+	return &chunkedReader{r: br}
 }
 
 type chunkedReader struct {
-    r   *bufio.Reader
-    n   uint64 // unread bytes in chunk
-    err error
+	r   *bufio.Reader
+	n   uint64 // unread bytes in chunk
+	err error
 }
 
 func (cr *chunkedReader) beginChunk() {
-    // chunk-size CRLF
-    var line string
-    line, cr.err = readLine(cr.r)
-    if cr.err != nil {
-        return
-    }
-    cr.n, cr.err = strconv.ParseUint(line, 16, 64)
-    if cr.err != nil {
-        return
-    }
-    if cr.n == 0 {
-        cr.err = io.EOF
-    }
+	// chunk-size CRLF
+	var line string
+	line, cr.err = readLine(cr.r)
+	if cr.err != nil {
+		return
+	}
+	cr.n, cr.err = strconv.ParseUint(line, 16, 64)
+	if cr.err != nil {
+		return
+	}
+	if cr.n == 0 {
+		cr.err = io.EOF
+	}
 }
 
 func (cr *chunkedReader) Read(b []uint8) (n int, err error) {
-    if cr.err != nil {
-        return 0, cr.err
-    }
-    if cr.n == 0 {
-        cr.beginChunk()
-        if cr.err != nil {
-            return 0, cr.err
-        }
-    }
-    if uint64(len(b)) > cr.n {
-        b = b[0:cr.n]
-    }
-    n, cr.err = cr.r.Read(b)
-    cr.n -= uint64(n)
-    if cr.n == 0 && cr.err == nil {
-        // end of chunk (CRLF)
-        b := make([]byte, 2)
-        if _, cr.err = io.ReadFull(cr.r, b); cr.err == nil {
-            if b[0] != '\r' || b[1] != '\n' {
-                cr.err = errors.New("malformed chunked encoding")
-            }
-        }
-    }
-    return n, cr.err
+	if cr.err != nil {
+		return 0, cr.err
+	}
+	if cr.n == 0 {
+		cr.beginChunk()
+		if cr.err != nil {
+			return 0, cr.err
+		}
+	}
+	if uint64(len(b)) > cr.n {
+		b = b[0:cr.n]
+	}
+	n, cr.err = cr.r.Read(b)
+	cr.n -= uint64(n)
+	if cr.n == 0 && cr.err == nil {
+		// end of chunk (CRLF)
+		b := make([]byte, 2)
+		if _, cr.err = io.ReadFull(cr.r, b); cr.err == nil {
+			if b[0] != '\r' || b[1] != '\n' {
+				cr.err = errors.New("malformed chunked encoding")
+			}
+		}
+	}
+	return n, cr.err
 }
 
 // Read a line of bytes (up to \n) from b.
@@ -89,33 +89,33 @@
 // The returned bytes are a pointer into storage in
 // the bufio, so they are only valid until the next bufio read.
 func readLineBytes(b *bufio.Reader) (p []byte, err error) {
-    if p, err = b.ReadSlice('\n'); err != nil {
-        // We always know when EOF is coming.
-        // If the caller asked for a line, there should be a line.
-        if err == io.EOF {
-            err = io.ErrUnexpectedEOF
-        } else if err == bufio.ErrBufferFull {
-            err = ErrLineTooLong
-        }
-        return nil, err
-    }
-    if len(p) >= maxLineLength {
-        return nil, ErrLineTooLong
-    }
-
-    // Chop off trailing white space.
-    p = bytes.TrimRight(p, " \r\t\n")
-
-    return p, nil
+	if p, err = b.ReadSlice('\n'); err != nil {
+		// We always know when EOF is coming.
+		// If the caller asked for a line, there should be a line.
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		} else if err == bufio.ErrBufferFull {
+			err = ErrLineTooLong
+		}
+		return nil, err
+	}
+	if len(p) >= maxLineLength {
+		return nil, ErrLineTooLong
+	}
+
+	// Chop off trailing white space.
+	p = bytes.TrimRight(p, " \r\t\n")
+
+	return p, nil
 }
 
 // readLineBytes, but convert the bytes into a string.
 func readLine(b *bufio.Reader) (s string, err error) {
-    p, e := readLineBytes(b)
-    if e != nil {
-        return "", e
-    }
-    return string(p), nil
+	p, e := readLineBytes(b)
+	if e != nil {
+		return "", e
+	}
+	return string(p), nil
 }
 
 // newChunkedWriter returns a new chunkedWriter that translates writes into HTTP
@@ -128,13 +128,13 @@
 // would result in double chunking or chunking with a Content-Length
 // length, both of which are wrong.
 func newChunkedWriter(w io.Writer) io.WriteCloser {
-    return &chunkedWriter{w}
+	return &chunkedWriter{w}
 }
 
 // Writing to chunkedWriter translates to writing in HTTP chunked Transfer
 // Encoding wire format to the underlying Wire chunkedWriter.
 type chunkedWriter struct {
-    Wire io.Writer
+	Wire io.Writer
 }
 
 // Write the contents of data as one chunk to Wire.
@@ -142,29 +142,29 @@
 // a bug since it does not check for success of io.WriteString
 func (cw *chunkedWriter) Write(data []byte) (n int, err error) {
 
-    // Don't send 0-length data. It looks like EOF for chunked encoding.
-    if len(data) == 0 {
-        return 0, nil
-    }
-
-    head := strconv.FormatInt(int64(len(data)), 16) + "\r\n"
-
-    if _, err = io.WriteString(cw.Wire, head); err != nil {
-        return 0, err
-    }
-    if n, err = cw.Wire.Write(data); err != nil {
-        return
-    }
-    if n != len(data) {
-        err = io.ErrShortWrite
-        return
-    }
-    _, err = io.WriteString(cw.Wire, "\r\n")
-
-    return
+	// Don't send 0-length data. It looks like EOF for chunked encoding.
+	if len(data) == 0 {
+		return 0, nil
+	}
+
+	head := strconv.FormatInt(int64(len(data)), 16) + "\r\n"
+
+	if _, err = io.WriteString(cw.Wire, head); err != nil {
+		return 0, err
+	}
+	if n, err = cw.Wire.Write(data); err != nil {
+		return
+	}
+	if n != len(data) {
+		err = io.ErrShortWrite
+		return
+	}
+	_, err = io.WriteString(cw.Wire, "\r\n")
+
+	return
 }
 
 func (cw *chunkedWriter) Close() error {
-    _, err := io.WriteString(cw.Wire, "0\r\n")
-    return err
+	_, err := io.WriteString(cw.Wire, "0\r\n")
+	return err
 }

=== modified file 'fork/http/client.go'
--- fork/http/client.go	2013-07-22 12:53:27 +0000
+++ fork/http/client.go	2014-12-02 00:40:19 +0000
@@ -10,12 +10,12 @@
 package http
 
 import (
-    "encoding/base64"
-    "errors"
-    "fmt"
-    "io"
-    "net/url"
-    "strings"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"net/url"
+	"strings"
 )
 
 // A Client is an HTTP client. Its zero value (DefaultClient) is a usable client
@@ -25,26 +25,26 @@
 // TCP connections), so Clients should be reused instead of created as
 // needed. Clients are safe for concurrent use by multiple goroutines.
 type Client struct {
-    // Transport specifies the mechanism by which individual
-    // HTTP requests are made.
-    // If nil, DefaultTransport is used.
-    Transport RoundTripper
-
-    // CheckRedirect specifies the policy for handling redirects.
-    // If CheckRedirect is not nil, the client calls it before
-    // following an HTTP redirect. The arguments req and via
-    // are the upcoming request and the requests made already,
-    // oldest first. If CheckRedirect returns an error, the client
-    // returns that error instead of issue the Request req.
-    //
-    // If CheckRedirect is nil, the Client uses its default policy,
-    // which is to stop after 10 consecutive requests.
-    CheckRedirect func(req *Request, via []*Request) error
-
-    // Jar specifies the cookie jar.
-    // If Jar is nil, cookies are not sent in requests and ignored
-    // in responses.
-    Jar CookieJar
+	// Transport specifies the mechanism by which individual
+	// HTTP requests are made.
+	// If nil, DefaultTransport is used.
+	Transport RoundTripper
+
+	// CheckRedirect specifies the policy for handling redirects.
+	// If CheckRedirect is not nil, the client calls it before
+	// following an HTTP redirect. The arguments req and via
+	// are the upcoming request and the requests made already,
+	// oldest first. If CheckRedirect returns an error, the client
+	// returns that error instead of issue the Request req.
+	//
+	// If CheckRedirect is nil, the Client uses its default policy,
+	// which is to stop after 10 consecutive requests.
+	CheckRedirect func(req *Request, via []*Request) error
+
+	// Jar specifies the cookie jar.
+	// If Jar is nil, cookies are not sent in requests and ignored
+	// in responses.
+	Jar CookieJar
 }
 
 // DefaultClient is the default Client and is used by Get, Head, and Post.
@@ -56,20 +56,20 @@
 // A RoundTripper must be safe for concurrent use by multiple
 // goroutines.
 type RoundTripper interface {
-    // RoundTrip executes a single HTTP transaction, returning
-    // the Response for the request req.  RoundTrip should not
-    // attempt to interpret the response.  In particular,
-    // RoundTrip must return err == nil if it obtained a response,
-    // regardless of the response's HTTP status code.  A non-nil
-    // err should be reserved for failure to obtain a response.
-    // Similarly, RoundTrip should not attempt to handle
-    // higher-level protocol details such as redirects,
-    // authentication, or cookies.
-    //
-    // RoundTrip should not modify the request, except for
-    // consuming the Body.  The request's URL and Header fields
-    // are guaranteed to be initialized.
-    RoundTrip(*Request) (*Response, error)
+	// RoundTrip executes a single HTTP transaction, returning
+	// the Response for the request req.  RoundTrip should not
+	// attempt to interpret the response.  In particular,
+	// RoundTrip must return err == nil if it obtained a response,
+	// regardless of the response's HTTP status code.  A non-nil
+	// err should be reserved for failure to obtain a response.
+	// Similarly, RoundTrip should not attempt to handle
+	// higher-level protocol details such as redirects,
+	// authentication, or cookies.
+	//
+	// RoundTrip should not modify the request, except for
+	// consuming the Body.  The request's URL and Header fields
+	// are guaranteed to be initialized.
+	RoundTrip(*Request) (*Response, error)
 }
 
 // Given a string of the form "host", "host:port", or "[ipv6::address]:port",
@@ -80,8 +80,8 @@
 // bufio.Reader through which we read the response, and the underlying
 // network connection.
 type readClose struct {
-    io.Reader
-    io.Closer
+	io.Reader
+	io.Closer
 }
 
 // Do sends an HTTP request and returns an HTTP response, following
@@ -96,51 +96,51 @@
 //
 // Generally Get, Post, or PostForm will be used instead of Do.
 func (c *Client) Do(req *Request) (resp *Response, err error) {
-    if req.Method == "GET" || req.Method == "HEAD" {
-        return c.doFollowingRedirects(req)
-    }
-    return send(req, c.Transport)
+	if req.Method == "GET" || req.Method == "HEAD" {
+		return c.doFollowingRedirects(req)
+	}
+	return send(req, c.Transport)
 }
 
 // send issues an HTTP request.  Caller should close resp.Body when done reading from it.
 func send(req *Request, t RoundTripper) (resp *Response, err error) {
-    if t == nil {
-        t = DefaultTransport
-        if t == nil {
-            err = errors.New("http: no Client.Transport or DefaultTransport")
-            return
-        }
-    }
-
-    if req.URL == nil {
-        return nil, errors.New("http: nil Request.URL")
-    }
-
-    if req.RequestURI != "" {
-        return nil, errors.New("http: Request.RequestURI can't be set in client requests.")
-    }
-
-    // Most the callers of send (Get, Post, et al) don't need
-    // Headers, leaving it uninitialized.  We guarantee to the
-    // Transport that this has been initialized, though.
-    if req.Header == nil {
-        req.Header = make(Header)
-    }
-
-    if u := req.URL.User; u != nil {
-        req.Header.Set("Authorization", "Basic "+base64.URLEncoding.EncodeToString([]byte(u.String())))
-    }
-    return t.RoundTrip(req)
+	if t == nil {
+		t = DefaultTransport
+		if t == nil {
+			err = errors.New("http: no Client.Transport or DefaultTransport")
+			return
+		}
+	}
+
+	if req.URL == nil {
+		return nil, errors.New("http: nil Request.URL")
+	}
+
+	if req.RequestURI != "" {
+		return nil, errors.New("http: Request.RequestURI can't be set in client requests.")
+	}
+
+	// Most the callers of send (Get, Post, et al) don't need
+	// Headers, leaving it uninitialized.  We guarantee to the
+	// Transport that this has been initialized, though.
+	if req.Header == nil {
+		req.Header = make(Header)
+	}
+
+	if u := req.URL.User; u != nil {
+		req.Header.Set("Authorization", "Basic "+base64.URLEncoding.EncodeToString([]byte(u.String())))
+	}
+	return t.RoundTrip(req)
 }
 
 // True if the specified HTTP status code is one for which the Get utility should
 // automatically redirect.
 func shouldRedirect(statusCode int) bool {
-    switch statusCode {
-    case StatusMovedPermanently, StatusFound, StatusSeeOther, StatusTemporaryRedirect:
-        return true
-    }
-    return false
+	switch statusCode {
+	case StatusMovedPermanently, StatusFound, StatusSeeOther, StatusTemporaryRedirect:
+		return true
+	}
+	return false
 }
 
 // Get issues a GET to the specified URL.  If the response is one of the following
@@ -155,7 +155,7 @@
 //
 // Get is a wrapper around DefaultClient.Get.
 func Get(url string) (r *Response, err error) {
-    return DefaultClient.Get(url)
+	return DefaultClient.Get(url)
 }
 
 // Get issues a GET to the specified URL.  If the response is one of the
@@ -169,95 +169,95 @@
 //
 // Caller should close r.Body when done reading from it.
 func (c *Client) Get(url string) (r *Response, err error) {
-    req, err := NewRequest("GET", url, nil)
-    if err != nil {
-        return nil, err
-    }
-    return c.doFollowingRedirects(req)
+	req, err := NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	return c.doFollowingRedirects(req)
 }
 
 func (c *Client) doFollowingRedirects(ireq *Request) (r *Response, err error) {
-    // TODO: if/when we add cookie support, the redirected request shouldn't
-    // necessarily supply the same cookies as the original.
-    var base *url.URL
-    redirectChecker := c.CheckRedirect
-    if redirectChecker == nil {
-        redirectChecker = defaultCheckRedirect
-    }
-    var via []*Request
-
-    if ireq.URL == nil {
-        return nil, errors.New("http: nil Request.URL")
-    }
-
-    jar := c.Jar
-    if jar == nil {
-        jar = blackHoleJar{}
-    }
-
-    req := ireq
-    urlStr := "" // next relative or absolute URL to fetch (after first request)
-    for redirect := 0; ; redirect++ {
-        if redirect != 0 {
-            req = new(Request)
-            req.Method = ireq.Method
-            req.Header = make(Header)
-            req.URL, err = base.Parse(urlStr)
-            if err != nil {
-                break
-            }
-            if len(via) > 0 {
-                // Add the Referer header.
-                lastReq := via[len(via)-1]
-                if lastReq.URL.Scheme != "https" {
-                    req.Header.Set("Referer", lastReq.URL.String())
-                }
-
-                err = redirectChecker(req, via)
-                if err != nil {
-                    break
-                }
-            }
-        }
-
-        for _, cookie := range jar.Cookies(req.URL) {
-            req.AddCookie(cookie)
-        }
-        urlStr = req.URL.String()
-        if r, err = send(req, c.Transport); err != nil {
-            break
-        }
-        if c := r.Cookies(); len(c) > 0 {
-            jar.SetCookies(req.URL, c)
-        }
-
-        if shouldRedirect(r.StatusCode) {
-            r.Body.Close()
-            if urlStr = r.Header.Get("Location"); urlStr == "" {
-                err = errors.New(fmt.Sprintf("%d response missing Location header", r.StatusCode))
-                break
-            }
-            base = req.URL
-            via = append(via, req)
-            continue
-        }
-        return
-    }
-
-    method := ireq.Method
-    err = &url.Error{
-        Op:  method[0:1] + strings.ToLower(method[1:]),
-        URL: urlStr,
-        Err: err,
-    }
-    return
+	// TODO: if/when we add cookie support, the redirected request shouldn't
+	// necessarily supply the same cookies as the original.
+	var base *url.URL
+	redirectChecker := c.CheckRedirect
+	if redirectChecker == nil {
+		redirectChecker = defaultCheckRedirect
+	}
+	var via []*Request
+
+	if ireq.URL == nil {
+		return nil, errors.New("http: nil Request.URL")
+	}
+
+	jar := c.Jar
+	if jar == nil {
+		jar = blackHoleJar{}
+	}
+
+	req := ireq
+	urlStr := "" // next relative or absolute URL to fetch (after first request)
+	for redirect := 0; ; redirect++ {
+		if redirect != 0 {
+			req = new(Request)
+			req.Method = ireq.Method
+			req.Header = make(Header)
+			req.URL, err = base.Parse(urlStr)
+			if err != nil {
+				break
+			}
+			if len(via) > 0 {
+				// Add the Referer header.
+				lastReq := via[len(via)-1]
+				if lastReq.URL.Scheme != "https" {
+					req.Header.Set("Referer", lastReq.URL.String())
+				}
+
+				err = redirectChecker(req, via)
+				if err != nil {
+					break
+				}
+			}
+		}
+
+		for _, cookie := range jar.Cookies(req.URL) {
+			req.AddCookie(cookie)
+		}
+		urlStr = req.URL.String()
+		if r, err = send(req, c.Transport); err != nil {
+			break
+		}
+		if c := r.Cookies(); len(c) > 0 {
+			jar.SetCookies(req.URL, c)
+		}
+
+		if shouldRedirect(r.StatusCode) {
+			r.Body.Close()
+			if urlStr = r.Header.Get("Location"); urlStr == "" {
+				err = errors.New(fmt.Sprintf("%d response missing Location header", r.StatusCode))
+				break
+			}
+			base = req.URL
+			via = append(via, req)
+			continue
+		}
+		return
+	}
+
+	method := ireq.Method
+	err = &url.Error{
+		Op:  method[0:1] + strings.ToLower(method[1:]),
+		URL: urlStr,
+		Err: err,
+	}
+	return
 }
 
 func defaultCheckRedirect(req *Request, via []*Request) error {
-    if len(via) >= 10 {
-        return errors.New("stopped after 10 redirects")
-    }
-    return nil
+	if len(via) >= 10 {
+		return errors.New("stopped after 10 redirects")
+	}
+	return nil
 }
 
 // Post issues a POST to the specified URL.
@@ -266,28 +266,28 @@
 //
 // Post is a wrapper around DefaultClient.Post
 func Post(url string, bodyType string, body io.Reader) (r *Response, err error) {
-    return DefaultClient.Post(url, bodyType, body)
+	return DefaultClient.Post(url, bodyType, body)
 }
 
 // Post issues a POST to the specified URL.
 //
 // Caller should close r.Body when done reading from it.
 func (c *Client) Post(url string, bodyType string, body io.Reader) (r *Response, err error) {
-    req, err := NewRequest("POST", url, body)
-    if err != nil {
-        return nil, err
-    }
-    req.Header.Set("Content-Type", bodyType)
-    if c.Jar != nil {
-        for _, cookie := range c.Jar.Cookies(req.URL) {
-            req.AddCookie(cookie)
-        }
-    }
-    r, err = send(req, c.Transport)
-    if err == nil && c.Jar != nil {
-        c.Jar.SetCookies(req.URL, r.Cookies())
-    }
-    return r, err
+	req, err := NewRequest("POST", url, body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", bodyType)
+	if c.Jar != nil {
+		for _, cookie := range c.Jar.Cookies(req.URL) {
+			req.AddCookie(cookie)
+		}
+	}
+	r, err = send(req, c.Transport)
+	if err == nil && c.Jar != nil {
+		c.Jar.SetCookies(req.URL, r.Cookies())
+	}
+	return r, err
 }
 
 // PostForm issues a POST to the specified URL,
@@ -297,7 +297,7 @@
 //
 // PostForm is a wrapper around DefaultClient.PostForm
 func PostForm(url string, data url.Values) (r *Response, err error) {
-    return DefaultClient.PostForm(url, data)
+	return DefaultClient.PostForm(url, data)
 }
 
 // PostForm issues a POST to the specified URL,
@@ -305,7 +305,7 @@
 //
 // Caller should close r.Body when done reading from it.
 func (c *Client) PostForm(url string, data url.Values) (r *Response, err error) {
-    return c.Post(url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
+	return c.Post(url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
 }
 
 // Head issues a HEAD to the specified URL.  If the response is one of the
@@ -319,7 +319,7 @@
 //
 // Head is a wrapper around DefaultClient.Head
 func Head(url string) (r *Response, err error) {
-    return DefaultClient.Head(url)
+	return DefaultClient.Head(url)
 }
 
 // Head issues a HEAD to the specified URL.  If the response is one of the
@@ -331,9 +331,9 @@
 //    303 (See Other)
 //    307 (Temporary Redirect)
 func (c *Client) Head(url string) (r *Response, err error) {
-    req, err := NewRequest("HEAD", url, nil)
-    if err != nil {
-        return nil, err
-    }
-    return c.doFollowingRedirects(req)
+	req, err := NewRequest("HEAD", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	return c.doFollowingRedirects(req)
 }

=== modified file 'fork/http/cookie.go'
--- fork/http/cookie.go	2013-07-22 12:53:27 +0000
+++ fork/http/cookie.go	2014-12-02 00:40:19 +0000
@@ -5,11 +5,11 @@
 package http
 
 import (
-    "bytes"
-    "fmt"
-    "strconv"
-    "strings"
-    "time"
+	"bytes"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
 )
 
 // This implementation is done according to RFC 6265:
@@ -19,148 +19,148 @@
 // A Cookie represents an HTTP cookie as sent in the Set-Cookie header of an
 // HTTP response or the Cookie header of an HTTP request.
 type Cookie struct {
-    Name       string
-    Value      string
-    Path       string
-    Domain     string
-    Expires    time.Time
-    RawExpires string
+	Name       string
+	Value      string
+	Path       string
+	Domain     string
+	Expires    time.Time
+	RawExpires string
 
-    // MaxAge=0 means no 'Max-Age' attribute specified.
-    // MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
-    // MaxAge>0 means Max-Age attribute present and given in seconds
-    MaxAge   int
-    Secure   bool
-    HttpOnly bool
-    Raw      string
-    Unparsed []string // Raw text of unparsed attribute-value pairs
+	// MaxAge=0 means no 'Max-Age' attribute specified.
+	// MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
+	// MaxAge>0 means Max-Age attribute present and given in seconds
+	MaxAge   int
+	Secure   bool
+	HttpOnly bool
+	Raw      string
+	Unparsed []string // Raw text of unparsed attribute-value pairs
 }
 
 // readSetCookies parses all "Set-Cookie" values from
 // the header h and returns the successfully parsed Cookies.
 func readSetCookies(h Header) []*Cookie {
-    cookies := []*Cookie{}
-    for _, line := range h["Set-Cookie"] {
-        parts := strings.Split(strings.TrimSpace(line), ";")
-        if len(parts) == 1 && parts[0] == "" {
-            continue
-        }
-        parts[0] = strings.TrimSpace(parts[0])
-        j := strings.Index(parts[0], "=")
-        if j < 0 {
-            continue
-        }
-        name, value := parts[0][:j], parts[0][j+1:]
-        if !isCookieNameValid(name) {
-            continue
-        }
-        value, success := parseCookieValue(value)
-        if !success {
-            continue
-        }
-        c := &Cookie{
-            Name:  name,
-            Value: value,
-            Raw:   line,
-        }
-        for i := 1; i < len(parts); i++ {
-            parts[i] = strings.TrimSpace(parts[i])
-            if len(parts[i]) == 0 {
-                continue
-            }
+	cookies := []*Cookie{}
+	for _, line := range h["Set-Cookie"] {
+		parts := strings.Split(strings.TrimSpace(line), ";")
+		if len(parts) == 1 && parts[0] == "" {
+			continue
+		}
+		parts[0] = strings.TrimSpace(parts[0])
+		j := strings.Index(parts[0], "=")
+		if j < 0 {
+			continue
+		}
+		name, value := parts[0][:j], parts[0][j+1:]
+		if !isCookieNameValid(name) {
+			continue
+		}
+		value, success := parseCookieValue(value)
+		if !success {
+			continue
+		}
+		c := &Cookie{
+			Name:  name,
+			Value: value,
+			Raw:   line,
+		}
+		for i := 1; i < len(parts); i++ {
+			parts[i] = strings.TrimSpace(parts[i])
+			if len(parts[i]) == 0 {
+				continue
+			}
 
-            attr, val := parts[i], ""
-            if j := strings.Index(attr, "="); j >= 0 {
-                attr, val = attr[:j], attr[j+1:]
-            }
-            lowerAttr := strings.ToLower(attr)
-            parseCookieValueFn := parseCookieValue
-            if lowerAttr == "expires" {
-                parseCookieValueFn = parseCookieExpiresValue
-            }
-            val, success = parseCookieValueFn(val)
-            if !success {
-                c.Unparsed = append(c.Unparsed, parts[i])
-                continue
-            }
-            switch lowerAttr {
-            case "secure":
-                c.Secure = true
-                continue
-            case "httponly":
-                c.HttpOnly = true
-                continue
-            case "domain":
-                c.Domain = val
-                // TODO: Add domain parsing
-                continue
-            case "max-age":
-                secs, err := strconv.Atoi(val)
-                if err != nil || secs != 0 && val[0] == '0' {
-                    break
-                }
-                if secs <= 0 {
-                    c.MaxAge = -1
-                } else {
-                    c.MaxAge = secs
-                }
-                continue
-            case "expires":
-                c.RawExpires = val
-                exptime, err := time.Parse(time.RFC1123, val)
-                if err != nil {
-                    exptime, err = time.Parse("Mon, 02-Jan-2006 15:04:05 MST", val)
-                    if err != nil {
-                        c.Expires = time.Time{}
-                        break
-                    }
-                }
-                c.Expires = exptime.UTC()
-                continue
-            case "path":
-                c.Path = val
-                // TODO: Add path parsing
-                continue
-            }
-            c.Unparsed = append(c.Unparsed, parts[i])
-        }
-        cookies = append(cookies, c)
-    }
-    return cookies
+			attr, val := parts[i], ""
+			if j := strings.Index(attr, "="); j >= 0 {
+				attr, val = attr[:j], attr[j+1:]
+			}
+			lowerAttr := strings.ToLower(attr)
+			parseCookieValueFn := parseCookieValue
+			if lowerAttr == "expires" {
+				parseCookieValueFn = parseCookieExpiresValue
+			}
+			val, success = parseCookieValueFn(val)
+			if !success {
+				c.Unparsed = append(c.Unparsed, parts[i])
+				continue
+			}
+			switch lowerAttr {
+			case "secure":
+				c.Secure = true
+				continue
+			case "httponly":
+				c.HttpOnly = true
+				continue
+			case "domain":
+				c.Domain = val
+				// TODO: Add domain parsing
+				continue
+			case "max-age":
+				secs, err := strconv.Atoi(val)
+				if err != nil || secs != 0 && val[0] == '0' {
+					break
+				}
+				if secs <= 0 {
+					c.MaxAge = -1
+				} else {
+					c.MaxAge = secs
+				}
+				continue
+			case "expires":
+				c.RawExpires = val
+				exptime, err := time.Parse(time.RFC1123, val)
+				if err != nil {
+					exptime, err = time.Parse("Mon, 02-Jan-2006 15:04:05 MST", val)
+					if err != nil {
+						c.Expires = time.Time{}
+						break
+					}
+				}
+				c.Expires = exptime.UTC()
+				continue
+			case "path":
+				c.Path = val
+				// TODO: Add path parsing
+				continue
+			}
+			c.Unparsed = append(c.Unparsed, parts[i])
+		}
+		cookies = append(cookies, c)
+	}
+	return cookies
 }
 
 // SetCookie adds a Set-Cookie header to the provided ResponseWriter's headers.
 func SetCookie(w ResponseWriter, cookie *Cookie) {
-    w.Header().Add("Set-Cookie", cookie.String())
+	w.Header().Add("Set-Cookie", cookie.String())
 }
 
 // String returns the serialization of the cookie for use in a Cookie
 // header (if only Name and Value are set) or a Set-Cookie response
 // header (if other fields are set).
 func (c *Cookie) String() string {
-    var b bytes.Buffer
-    fmt.Fprintf(&b, "%s=%s", sanitizeName(c.Name), sanitizeValue(c.Value))
-    if len(c.Path) > 0 {
-        fmt.Fprintf(&b, "; Path=%s", sanitizeValue(c.Path))
-    }
-    if len(c.Domain) > 0 {
-        fmt.Fprintf(&b, "; Domain=%s", sanitizeValue(c.Domain))
-    }
-    if c.Expires.Unix() > 0 {
-        fmt.Fprintf(&b, "; Expires=%s", c.Expires.UTC().Format(time.RFC1123))
-    }
-    if c.MaxAge > 0 {
-        fmt.Fprintf(&b, "; Max-Age=%d", c.MaxAge)
-    } else if c.MaxAge < 0 {
-        fmt.Fprintf(&b, "; Max-Age=0")
-    }
-    if c.HttpOnly {
-        fmt.Fprintf(&b, "; HttpOnly")
-    }
-    if c.Secure {
-        fmt.Fprintf(&b, "; Secure")
-    }
-    return b.String()
+	var b bytes.Buffer
+	fmt.Fprintf(&b, "%s=%s", sanitizeName(c.Name), sanitizeValue(c.Value))
+	if len(c.Path) > 0 {
+		fmt.Fprintf(&b, "; Path=%s", sanitizeValue(c.Path))
+	}
+	if len(c.Domain) > 0 {
+		fmt.Fprintf(&b, "; Domain=%s", sanitizeValue(c.Domain))
+	}
+	if c.Expires.Unix() > 0 {
+		fmt.Fprintf(&b, "; Expires=%s", c.Expires.UTC().Format(time.RFC1123))
+	}
+	if c.MaxAge > 0 {
+		fmt.Fprintf(&b, "; Max-Age=%d", c.MaxAge)
+	} else if c.MaxAge < 0 {
+		fmt.Fprintf(&b, "; Max-Age=0")
+	}
+	if c.HttpOnly {
+		fmt.Fprintf(&b, "; HttpOnly")
+	}
+	if c.Secure {
+		fmt.Fprintf(&b, "; Secure")
+	}
+	return b.String()
 }
 
 // readCookies parses all "Cookie" values from the header h and
@@ -168,100 +168,100 @@
 //
 // if filter isn't empty, only cookies of that name are returned
 func readCookies(h Header, filter string) []*Cookie {
-    cookies := []*Cookie{}
-    lines, ok := h["Cookie"]
-    if !ok {
-        return cookies
-    }
+	cookies := []*Cookie{}
+	lines, ok := h["Cookie"]
+	if !ok {
+		return cookies
+	}
 
-    for _, line := range lines {
-        parts := strings.Split(strings.TrimSpace(line), ";")
-        if len(parts) == 1 && parts[0] == "" {
-            continue
-        }
-        // Per-line attributes
-        parsedPairs := 0
-        for i := 0; i < len(parts); i++ {
-            parts[i] = strings.TrimSpace(parts[i])
-            if len(parts[i]) == 0 {
-                continue
-            }
-            name, val := parts[i], ""
-            if j := strings.Index(name, "="); j >= 0 {
-                name, val = name[:j], name[j+1:]
-            }
-            if !isCookieNameValid(name) {
-                continue
-            }
-            if filter != "" && filter != name {
-                continue
-            }
-            val, success := parseCookieValue(val)
-            if !success {
-                continue
-            }
-            cookies = append(cookies, &Cookie{Name: name, Value: val})
-            parsedPairs++
-        }
-    }
-    return cookies
+	for _, line := range lines {
+		parts := strings.Split(strings.TrimSpace(line), ";")
+		if len(parts) == 1 && parts[0] == "" {
+			continue
+		}
+		// Per-line attributes
+		parsedPairs := 0
+		for i := 0; i < len(parts); i++ {
+			parts[i] = strings.TrimSpace(parts[i])
+			if len(parts[i]) == 0 {
+				continue
+			}
+			name, val := parts[i], ""
+			if j := strings.Index(name, "="); j >= 0 {
+				name, val = name[:j], name[j+1:]
+			}
+			if !isCookieNameValid(name) {
+				continue
+			}
+			if filter != "" && filter != name {
+				continue
+			}
+			val, success := parseCookieValue(val)
+			if !success {
+				continue
+			}
+			cookies = append(cookies, &Cookie{Name: name, Value: val})
+			parsedPairs++
+		}
+	}
+	return cookies
 }
 
 var cookieNameSanitizer = strings.NewReplacer("\n", "-", "\r", "-")
 
 func sanitizeName(n string) string {
-    return cookieNameSanitizer.Replace(n)
+	return cookieNameSanitizer.Replace(n)
 }
 
 var cookieValueSanitizer = strings.NewReplacer("\n", " ", "\r", " ", ";", " ")
 
 func sanitizeValue(v string) string {
-    return cookieValueSanitizer.Replace(v)
+	return cookieValueSanitizer.Replace(v)
 }
 
 func unquoteCookieValue(v string) string {
-    if len(v) > 1 && v[0] == '"' && v[len(v)-1] == '"' {
-        return v[1 : len(v)-1]
-    }
-    return v
+	if len(v) > 1 && v[0] == '"' && v[len(v)-1] == '"' {
+		return v[1 : len(v)-1]
+	}
+	return v
 }
 
 func isCookieByte(c byte) bool {
-    switch {
-    case c == 0x21, 0x23 <= c && c <= 0x2b, 0x2d <= c && c <= 0x3a,
-        0x3c <= c && c <= 0x5b, 0x5d <= c && c <= 0x7e:
-        return true
-    }
-    return false
+	switch {
+	case c == 0x21, 0x23 <= c && c <= 0x2b, 0x2d <= c && c <= 0x3a,
+		0x3c <= c && c <= 0x5b, 0x5d <= c && c <= 0x7e:
+		return true
+	}
+	return false
 }
 
 func isCookieExpiresByte(c byte) (ok bool) {
-    return isCookieByte(c) || c == ',' || c == ' '
+	return isCookieByte(c) || c == ',' || c == ' '
 }
 
 func parseCookieValue(raw string) (string, bool) {
-    return parseCookieValueUsing(raw, isCookieByte)
+	return parseCookieValueUsing(raw, isCookieByte)
 }
 
 func parseCookieExpiresValue(raw string) (string, bool) {
-    return parseCookieValueUsing(raw, isCookieExpiresByte)
+	return parseCookieValueUsing(raw, isCookieExpiresByte)
 }
 
 func parseCookieValueUsing(raw string, validByte func(byte) bool) (string, bool) {
-    raw = unquoteCookieValue(raw)
-    for i := 0; i < len(raw); i++ {
-        if !validByte(raw[i]) {
-            return "", false
-        }
-    }
-    return raw, true
+	raw = unquoteCookieValue(raw)
+	for i := 0; i < len(raw); i++ {
+		if !validByte(raw[i]) {
+			return "", false
+		}
+	}
+	return raw, true
 }
 
 func isCookieNameValid(raw string) bool {
-    for _, c := range raw {
-        if !isToken(byte(c)) {
-            return false
-        }
-    }
-    return true
+	for _, c := range raw {
+		if !isToken(byte(c)) {
+			return false
+		}
+	}
+	return true
 }

=== modified file 'fork/http/filetransport.go'
--- fork/http/filetransport.go	2013-07-22 12:53:27 +0000
+++ fork/http/filetransport.go	2014-12-02 00:40:19 +0000
@@ -5,13 +5,13 @@
 package http
 
 import (
-    "fmt"
-    "io"
+	"fmt"
+	"io"
 )
 
 // fileTransport implements RoundTripper for the 'file' protocol.
 type fileTransport struct {
-    fh fileHandler
+	fh fileHandler
 }
 
 // NewFileTransport returns a new RoundTripper, serving the provided
@@ -28,38 +28,38 @@
 //   res, err := c.Get("file:///etc/passwd")
 //   ...
 func NewFileTransport(fs FileSystem) RoundTripper {
-    return fileTransport{fileHandler{fs}}
+	return fileTransport{fileHandler{fs}}
 }
 
 func (t fileTransport) RoundTrip(req *Request) (resp *Response, err error) {
-    // We start ServeHTTP in a goroutine, which may take a long
-    // time if the file is large.  The newPopulateResponseWriter
-    // call returns a channel which either ServeHTTP or finish()
-    // sends our *Response on, once the *Response itself has been
-    // populated (even if the body itself is still being
-    // written to the res.Body, a pipe)
-    rw, resc := newPopulateResponseWriter()
-    go func() {
-        t.fh.ServeHTTP(rw, req)
-        rw.finish()
-    }()
-    return <-resc, nil
+	// We start ServeHTTP in a goroutine, which may take a long
+	// time if the file is large.  The newPopulateResponseWriter
+	// call returns a channel which either ServeHTTP or finish()
+	// sends our *Response on, once the *Response itself has been
+	// populated (even if the body itself is still being
+	// written to the res.Body, a pipe)
+	rw, resc := newPopulateResponseWriter()
+	go func() {
+		t.fh.ServeHTTP(rw, req)
+		rw.finish()
+	}()
+	return <-resc, nil
 }
 
 func newPopulateResponseWriter() (*populateResponse, <-chan *Response) {
-    pr, pw := io.Pipe()
-    rw := &populateResponse{
-        ch: make(chan *Response),
-        pw: pw,
-        res: &Response{
-            Proto:      "HTTP/1.0",
-            ProtoMajor: 1,
-            Header:     make(Header),
-            Close:      true,
-            Body:       pr,
-        },
-    }
-    return rw, rw.ch
+	pr, pw := io.Pipe()
+	rw := &populateResponse{
+		ch: make(chan *Response),
+		pw: pw,
+		res: &Response{
+			Proto:      "HTTP/1.0",
+			ProtoMajor: 1,
+			Header:     make(Header),
+			Close:      true,
+			Body:       pr,
+		},
+	}
+	return rw, rw.ch
 }
 
 // populateResponse is a ResponseWriter that populates the *Response
@@ -67,57 +67,57 @@
 // body. Once writes begin or finish() is called, the response is sent
 // on ch.
 type populateResponse struct {
-    res          *Response
-    ch           chan *Response
-    wroteHeader  bool
-    hasContent   bool
-    sentResponse bool
-    pw           *io.PipeWriter
+	res          *Response
+	ch           chan *Response
+	wroteHeader  bool
+	hasContent   bool
+	sentResponse bool
+	pw           *io.PipeWriter
 }
 
 func (pr *populateResponse) finish() {
-    if !pr.wroteHeader {
-        pr.WriteHeader(500)
-    }
-    if !pr.sentResponse {
-        pr.sendResponse()
-    }
-    pr.pw.Close()
+	if !pr.wroteHeader {
+		pr.WriteHeader(500)
+	}
+	if !pr.sentResponse {
+		pr.sendResponse()
+	}
+	pr.pw.Close()
 }
 
 func (pr *populateResponse) sendResponse() {
-    if pr.sentResponse {
-        return
-    }
-    pr.sentResponse = true
+	if pr.sentResponse {
+		return
+	}
+	pr.sentResponse = true
 
-    if pr.hasContent {
-        pr.res.ContentLength = -1
-    }
-    pr.ch <- pr.res
+	if pr.hasContent {
+		pr.res.ContentLength = -1
+	}
+	pr.ch <- pr.res
 }
 
 func (pr *populateResponse) Header() Header {
-    return pr.res.Header
+	return pr.res.Header
 }
 
 func (pr *populateResponse) WriteHeader(code int) {
-    if pr.wroteHeader {
-        return
-    }
-    pr.wroteHeader = true
+	if pr.wroteHeader {
+		return
+	}
+	pr.wroteHeader = true
 
-    pr.res.StatusCode = code
-    pr.res.Status = fmt.Sprintf("%d %s", code, StatusText(code))
+	pr.res.StatusCode = code
+	pr.res.Status = fmt.Sprintf("%d %s", code, StatusText(code))
 }
 
 func (pr *populateResponse) Write(p []byte) (n int, err error) {
-    if !pr.wroteHeader {
-        pr.WriteHeader(StatusOK)
-    }
-    pr.hasContent = true
-    if !pr.sentResponse {
-        pr.sendResponse()
-    }
-    return pr.pw.Write(p)
+	if !pr.wroteHeader {
+		pr.WriteHeader(StatusOK)
+	}
+	pr.hasContent = true
+	if !pr.sentResponse {
+		pr.sendResponse()
+	}
+	return pr.pw.Write(p)
 }

=== modified file 'fork/http/fs.go'
--- fork/http/fs.go	2013-07-22 12:53:27 +0000
+++ fork/http/fs.go	2014-12-02 00:40:19 +0000
@@ -7,16 +7,16 @@
 package http
 
 import (
-    "errors"
-    "fmt"
-    "io"
-    "mime"
-    "os"
-    "path"
-    "path/filepath"
-    "strconv"
-    "strings"
-    "time"
+	"errors"
+	"fmt"
+	"io"
+	"mime"
+	"os"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
 )
 
 // A Dir implements http.FileSystem using the native file
@@ -26,55 +26,55 @@
 type Dir string
 
 func (d Dir) Open(name string) (File, error) {
-    if filepath.Separator != '/' && strings.IndexRune(name, filepath.Separator) >= 0 {
-        return nil, errors.New("http: invalid character in file path")
-    }
-    dir := string(d)
-    if dir == "" {
-        dir = "."
-    }
-    f, err := os.Open(filepath.Join(dir, filepath.FromSlash(path.Clean("/"+name))))
-    if err != nil {
-        return nil, err
-    }
-    return f, nil
+	if filepath.Separator != '/' && strings.IndexRune(name, filepath.Separator) >= 0 {
+		return nil, errors.New("http: invalid character in file path")
+	}
+	dir := string(d)
+	if dir == "" {
+		dir = "."
+	}
+	f, err := os.Open(filepath.Join(dir, filepath.FromSlash(path.Clean("/"+name))))
+	if err != nil {
+		return nil, err
+	}
+	return f, nil
 }
 
 // A FileSystem implements access to a collection of named files.
 // The elements in a file path are separated by slash ('/', U+002F)
 // characters, regardless of host operating system convention.
 type FileSystem interface {
-    Open(name string) (File, error)
+	Open(name string) (File, error)
 }
 
 // A File is returned by a FileSystem's Open method and can be
 // served by the FileServer implementation.
 type File interface {
-    Close() error
-    Stat() (os.FileInfo, error)
-    Readdir(count int) ([]os.FileInfo, error)
-    Read([]byte) (int, error)
-    Seek(offset int64, whence int) (int64, error)
+	Close() error
+	Stat() (os.FileInfo, error)
+	Readdir(count int) ([]os.FileInfo, error)
+	Read([]byte) (int, error)
+	Seek(offset int64, whence int) (int64, error)
 }
 
 func dirList(w ResponseWriter, f File) {
-    w.Header().Set("Content-Type", "text/html; charset=utf-8")
-    fmt.Fprintf(w, "<pre>\n")
-    for {
-        dirs, err := f.Readdir(100)
-        if err != nil || len(dirs) == 0 {
-            break
-        }
-        for _, d := range dirs {
-            name := d.Name()
-            if d.IsDir() {
-                name += "/"
-            }
-            // TODO htmlescape
-            fmt.Fprintf(w, "<a href=\"%s\">%s</a>\n", name, name)
-        }
-    }
-    fmt.Fprintf(w, "</pre>\n")
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	fmt.Fprintf(w, "<pre>\n")
+	for {
+		dirs, err := f.Readdir(100)
+		if err != nil || len(dirs) == 0 {
+			break
+		}
+		for _, d := range dirs {
+			name := d.Name()
+			if d.IsDir() {
+				name += "/"
+			}
+			// TODO htmlescape
+			fmt.Fprintf(w, "<a href=\"%s\">%s</a>\n", name, name)
+		}
+	}
+	fmt.Fprintf(w, "</pre>\n")
 }
 
 // ServeContent replies to the request using the content in the
@@ -99,192 +99,192 @@
 //
 // Note that *os.File implements the io.ReadSeeker interface.
 func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker) {
-    size, err := content.Seek(0, os.SEEK_END)
-    if err != nil {
-        Error(w, "seeker can't seek", StatusInternalServerError)
-        return
-    }
-    _, err = content.Seek(0, os.SEEK_SET)
-    if err != nil {
-        Error(w, "seeker can't seek", StatusInternalServerError)
-        return
-    }
-    serveContent(w, req, name, modtime, size, content)
+	size, err := content.Seek(0, os.SEEK_END)
+	if err != nil {
+		Error(w, "seeker can't seek", StatusInternalServerError)
+		return
+	}
+	_, err = content.Seek(0, os.SEEK_SET)
+	if err != nil {
+		Error(w, "seeker can't seek", StatusInternalServerError)
+		return
+	}
+	serveContent(w, req, name, modtime, size, content)
 }
 
 // if name is empty, filename is unknown. (used for mime type, before sniffing)
 // if modtime.IsZero(), modtime is unknown.
 // content must be seeked to the beginning of the file.
 func serveContent(w ResponseWriter, r *Request, name string, modtime time.Time, size int64, content io.ReadSeeker) {
-    if checkLastModified(w, r, modtime) {
-        return
-    }
-
-    code := StatusOK
-
-    // If Content-Type isn't set, use the file's extension to find it.
-    if w.Header().Get("Content-Type") == "" {
-        ctype := mime.TypeByExtension(filepath.Ext(name))
-        if ctype == "" {
-            // read a chunk to decide between utf-8 text and binary
-            var buf [1024]byte
-            n, _ := io.ReadFull(content, buf[:])
-            b := buf[:n]
-            ctype = DetectContentType(b)
-            _, err := content.Seek(0, os.SEEK_SET) // rewind to output whole file
-            if err != nil {
-                Error(w, "seeker can't seek", StatusInternalServerError)
-                return
-            }
-        }
-        w.Header().Set("Content-Type", ctype)
-    }
-
-    // handle Content-Range header.
-    // TODO(adg): handle multiple ranges
-    sendSize := size
-    if size >= 0 {
-        ranges, err := parseRange(r.Header.Get("Range"), size)
-        if err == nil && len(ranges) > 1 {
-            err = errors.New("multiple ranges not supported")
-        }
-        if err != nil {
-            Error(w, err.Error(), StatusRequestedRangeNotSatisfiable)
-            return
-        }
-        if len(ranges) == 1 {
-            ra := ranges[0]
-            if _, err := content.Seek(ra.start, os.SEEK_SET); err != nil {
-                Error(w, err.Error(), StatusRequestedRangeNotSatisfiable)
-                return
-            }
-            sendSize = ra.length
-            code = StatusPartialContent
-            w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", ra.start, ra.start+ra.length-1, size))
-        }
-
-        w.Header().Set("Accept-Ranges", "bytes")
-        if w.Header().Get("Content-Encoding") == "" {
-            w.Header().Set("Content-Length", strconv.FormatInt(sendSize, 10))
-        }
-    }
-
-    w.WriteHeader(code)
-
-    if r.Method != "HEAD" {
-        if sendSize == -1 {
-            io.Copy(w, content)
-        } else {
-            io.CopyN(w, content, sendSize)
-        }
-    }
+	if checkLastModified(w, r, modtime) {
+		return
+	}
+
+	code := StatusOK
+
+	// If Content-Type isn't set, use the file's extension to find it.
+	if w.Header().Get("Content-Type") == "" {
+		ctype := mime.TypeByExtension(filepath.Ext(name))
+		if ctype == "" {
+			// read a chunk to decide between utf-8 text and binary
+			var buf [1024]byte
+			n, _ := io.ReadFull(content, buf[:])
+			b := buf[:n]
+			ctype = DetectContentType(b)
+			_, err := content.Seek(0, os.SEEK_SET) // rewind to output whole file
+			if err != nil {
+				Error(w, "seeker can't seek", StatusInternalServerError)
+				return
+			}
+		}
+		w.Header().Set("Content-Type", ctype)
+	}
+
+	// handle Content-Range header.
+	// TODO(adg): handle multiple ranges
+	sendSize := size
+	if size >= 0 {
+		ranges, err := parseRange(r.Header.Get("Range"), size)
+		if err == nil && len(ranges) > 1 {
+			err = errors.New("multiple ranges not supported")
+		}
+		if err != nil {
+			Error(w, err.Error(), StatusRequestedRangeNotSatisfiable)
+			return
+		}
+		if len(ranges) == 1 {
+			ra := ranges[0]
+			if _, err := content.Seek(ra.start, os.SEEK_SET); err != nil {
+				Error(w, err.Error(), StatusRequestedRangeNotSatisfiable)
+				return
+			}
+			sendSize = ra.length
+			code = StatusPartialContent
+			w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", ra.start, ra.start+ra.length-1, size))
+		}
+
+		w.Header().Set("Accept-Ranges", "bytes")
+		if w.Header().Get("Content-Encoding") == "" {
+			w.Header().Set("Content-Length", strconv.FormatInt(sendSize, 10))
+		}
+	}
+
+	w.WriteHeader(code)
+
+	if r.Method != "HEAD" {
+		if sendSize == -1 {
+			io.Copy(w, content)
+		} else {
+			io.CopyN(w, content, sendSize)
+		}
+	}
 }
 
 // modtime is the modification time of the resource to be served, or IsZero().
 // return value is whether this request is now complete.
 func checkLastModified(w ResponseWriter, r *Request, modtime time.Time) bool {
-    if modtime.IsZero() {
-        return false
-    }
+	if modtime.IsZero() {
+		return false
+	}
 
-    // The Date-Modified header truncates sub-second precision, so
-    // use mtime < t+1s instead of mtime <= t to check for unmodified.
-    if t, err := time.Parse(TimeFormat, r.Header.Get("If-Modified-Since")); err == nil && modtime.Before(t.Add(1*time.Second)) {
-        w.WriteHeader(StatusNotModified)
-        return true
-    }
-    w.Header().Set("Last-Modified", modtime.UTC().Format(TimeFormat))
-    return false
+	// The Date-Modified header truncates sub-second precision, so
+	// use mtime < t+1s instead of mtime <= t to check for unmodified.
+	if t, err := time.Parse(TimeFormat, r.Header.Get("If-Modified-Since")); err == nil && modtime.Before(t.Add(1*time.Second)) {
+		w.WriteHeader(StatusNotModified)
+		return true
+	}
+	w.Header().Set("Last-Modified", modtime.UTC().Format(TimeFormat))
+	return false
 }
 
 // name is '/'-separated, not filepath.Separator.
 func serveFile(w ResponseWriter, r *Request, fs FileSystem, name string, redirect bool) {
-    const indexPage = "/index.html"
-
-    // redirect .../index.html to .../
-    // can't use Redirect() because that would make the path absolute,
-    // which would be a problem running under StripPrefix
-    if strings.HasSuffix(r.URL.Path, indexPage) {
-        localRedirect(w, r, "./")
-        return
-    }
-
-    f, err := fs.Open(name)
-    if err != nil {
-        // TODO expose actual error?
-        NotFound(w, r)
-        return
-    }
-    defer f.Close()
-
-    d, err1 := f.Stat()
-    if err1 != nil {
-        // TODO expose actual error?
-        NotFound(w, r)
-        return
-    }
-
-    if redirect {
-        // redirect to canonical path: / at end of directory url
-        // r.URL.Path always begins with /
-        url := r.URL.Path
-        if d.IsDir() {
-            if url[len(url)-1] != '/' {
-                localRedirect(w, r, path.Base(url)+"/")
-                return
-            }
-        } else {
-            if url[len(url)-1] == '/' {
-                localRedirect(w, r, "../"+path.Base(url))
-                return
-            }
-        }
-    }
-
-    // use contents of index.html for directory, if present
-    if d.IsDir() {
-        if checkLastModified(w, r, d.ModTime()) {
-            return
-        }
-        index := name + indexPage
-        ff, err := fs.Open(index)
-        if err == nil {
-            defer ff.Close()
-            dd, err := ff.Stat()
-            if err == nil {
-                name = index
-                d = dd
-                f = ff
-            }
-        }
-    }
-
-    if d.IsDir() {
-        dirList(w, f)
-        return
-    }
-
-    serveContent(w, r, d.Name(), d.ModTime(), d.Size(), f)
+	const indexPage = "/index.html"
+
+	// redirect .../index.html to .../
+	// can't use Redirect() because that would make the path absolute,
+	// which would be a problem running under StripPrefix
+	if strings.HasSuffix(r.URL.Path, indexPage) {
+		localRedirect(w, r, "./")
+		return
+	}
+
+	f, err := fs.Open(name)
+	if err != nil {
+		// TODO expose actual error?
+		NotFound(w, r)
+		return
+	}
+	defer f.Close()
+
+	d, err1 := f.Stat()
+	if err1 != nil {
+		// TODO expose actual error?
+		NotFound(w, r)
+		return
+	}
+
+	if redirect {
+		// redirect to canonical path: / at end of directory url
+		// r.URL.Path always begins with /
+		url := r.URL.Path
+		if d.IsDir() {
+			if url[len(url)-1] != '/' {
+				localRedirect(w, r, path.Base(url)+"/")
+				return
+			}
+		} else {
+			if url[len(url)-1] == '/' {
+				localRedirect(w, r, "../"+path.Base(url))
+				return
+			}
+		}
+	}
+
+	// use contents of index.html for directory, if present
+	if d.IsDir() {
+		if checkLastModified(w, r, d.ModTime()) {
+			return
+		}
+		index := name + indexPage
+		ff, err := fs.Open(index)
+		if err == nil {
+			defer ff.Close()
+			dd, err := ff.Stat()
+			if err == nil {
+				name = index
+				d = dd
+				f = ff
+			}
+		}
+	}
+
+	if d.IsDir() {
+		dirList(w, f)
+		return
+	}
+
+	serveContent(w, r, d.Name(), d.ModTime(), d.Size(), f)
 }
 
 // localRedirect gives a Moved Permanently response.
 // It does not convert relative paths to absolute paths like Redirect does.
 func localRedirect(w ResponseWriter, r *Request, newPath string) {
-    if q := r.URL.RawQuery; q != "" {
-        newPath += "?" + q
-    }
-    w.Header().Set("Location", newPath)
-    w.WriteHeader(StatusMovedPermanently)
+	if q := r.URL.RawQuery; q != "" {
+		newPath += "?" + q
+	}
+	w.Header().Set("Location", newPath)
+	w.WriteHeader(StatusMovedPermanently)
 }
 
 // ServeFile replies to the request with the contents of the named file or directory.
 func ServeFile(w ResponseWriter, r *Request, name string) {
-    dir, file := filepath.Split(name)
-    serveFile(w, r, Dir(dir), file, false)
+	dir, file := filepath.Split(name)
+	serveFile(w, r, Dir(dir), file, false)
 }
 
 type fileHandler struct {
-    root FileSystem
+	root FileSystem
 }
 
 // FileServer returns a handler that serves HTTP requests
@@ -295,73 +295,73 @@
 //
 //     http.Handle("/", http.FileServer(http.Dir("/tmp")))
 func FileServer(root FileSystem) Handler {
-    return &fileHandler{root}
+	return &fileHandler{root}
 }
 
 func (f *fileHandler) ServeHTTP(w ResponseWriter, r *Request) {
-    upath := r.URL.Path
-    if !strings.HasPrefix(upath, "/") {
-        upath = "/" + upath
-        r.URL.Path = upath
-    }
-    serveFile(w, r, f.root, path.Clean(upath), true)
+	upath := r.URL.Path
+	if !strings.HasPrefix(upath, "/") {
+		upath = "/" + upath
+		r.URL.Path = upath
+	}
+	serveFile(w, r, f.root, path.Clean(upath), true)
 }
 
 // httpRange specifies the byte range to be sent to the client.
 type httpRange struct {
-    start, length int64
+	start, length int64
 }
 
 // parseRange parses a Range header string as per RFC 2616.
 func parseRange(s string, size int64) ([]httpRange, error) {
-    if s == "" {
-        return nil, nil // header not present
-    }
-    const b = "bytes="
-    if !strings.HasPrefix(s, b) {
-        return nil, errors.New("invalid range")
-    }
-    var ranges []httpRange
-    for _, ra := range strings.Split(s[len(b):], ",") {
-        i := strings.Index(ra, "-")
-        if i < 0 {
-            return nil, errors.New("invalid range")
-        }
-        start, end := ra[:i], ra[i+1:]
-        var r httpRange
-        if start == "" {
-            // If no start is specified, end specifies the
-            // range start relative to the end of the file.
-            i, err := strconv.ParseInt(end, 10, 64)
-            if err != nil {
-                return nil, errors.New("invalid range")
-            }
-            if i > size {
-                i = size
-            }
-            r.start = size - i
-            r.length = size - r.start
-        } else {
-            i, err := strconv.ParseInt(start, 10, 64)
-            if err != nil || i > size || i < 0 {
-                return nil, errors.New("invalid range")
-            }
-            r.start = i
-            if end == "" {
-                // If no end is specified, range extends to end of the file.
-                r.length = size - r.start
-            } else {
-                i, err := strconv.ParseInt(end, 10, 64)
-                if err != nil || r.start > i {
-                    return nil, errors.New("invalid range")
-                }
-                if i >= size {
-                    i = size - 1
-                }
-                r.length = i - r.start + 1
-            }
-        }
-        ranges = append(ranges, r)
-    }
-    return ranges, nil
+	if s == "" {
+		return nil, nil // header not present
+	}
+	const b = "bytes="
+	if !strings.HasPrefix(s, b) {
+		return nil, errors.New("invalid range")
+	}
+	var ranges []httpRange
+	for _, ra := range strings.Split(s[len(b):], ",") {
+		i := strings.Index(ra, "-")
+		if i < 0 {
+			return nil, errors.New("invalid range")
+		}
+		start, end := ra[:i], ra[i+1:]
+		var r httpRange
+		if start == "" {
+			// If no start is specified, end specifies the
+			// range start relative to the end of the file.
+			i, err := strconv.ParseInt(end, 10, 64)
+			if err != nil {
+				return nil, errors.New("invalid range")
+			}
+			if i > size {
+				i = size
+			}
+			r.start = size - i
+			r.length = size - r.start
+		} else {
+			i, err := strconv.ParseInt(start, 10, 64)
+			if err != nil || i > size || i < 0 {
+				return nil, errors.New("invalid range")
+			}
+			r.start = i
+			if end == "" {
+				// If no end is specified, range extends to end of the file.
+				r.length = size - r.start
+			} else {
+				i, err := strconv.ParseInt(end, 10, 64)
+				if err != nil || r.start > i {
+					return nil, errors.New("invalid range")
+				}
+				if i >= size {
+					i = size - 1
+				}
+				r.length = i - r.start + 1
+			}
+		}
+		ranges = append(ranges, r)
+	}
+	return ranges, nil
 }

=== modified file 'fork/http/header.go'
--- fork/http/header.go	2013-07-22 12:53:27 +0000
+++ fork/http/header.go	2014-12-02 00:40:19 +0000
@@ -5,11 +5,11 @@
 package http
 
 import (
-    "fmt"
-    "io"
-    "net/textproto"
-    "sort"
-    "strings"
+	"fmt"
+	"io"
+	"net/textproto"
+	"sort"
+	"strings"
 )
 
 // A Header represents the key-value pairs in an HTTP header.
@@ -18,14 +18,14 @@
 // Add adds the key, value pair to the header.
 // It appends to any existing values associated with key.
 func (h Header) Add(key, value string) {
-    textproto.MIMEHeader(h).Add(key, value)
+	textproto.MIMEHeader(h).Add(key, value)
 }
 
 // Set sets the header entries associated with key to
 // the single element value.  It replaces any existing
 // values associated with key.
 func (h Header) Set(key, value string) {
-    textproto.MIMEHeader(h).Set(key, value)
+	textproto.MIMEHeader(h).Set(key, value)
 }
 
 // Get gets the first value associated with the given key.
@@ -33,17 +33,17 @@
 // To access multiple values of a key, access the map directly
 // with CanonicalHeaderKey.
 func (h Header) Get(key string) string {
-    return textproto.MIMEHeader(h).Get(key)
+	return textproto.MIMEHeader(h).Get(key)
 }
 
 // Del deletes the values associated with key.
 func (h Header) Del(key string) {
-    textproto.MIMEHeader(h).Del(key)
+	textproto.MIMEHeader(h).Del(key)
 }
 
 // Write writes a header in wire format.
 func (h Header) Write(w io.Writer) error {
-    return h.WriteSubset(w, nil)
+	return h.WriteSubset(w, nil)
 }
 
 var headerNewlineToSpace = strings.NewReplacer("\n", " ", "\r", " ")
@@ -51,23 +51,23 @@
 // WriteSubset writes a header in wire format.
 // If exclude is not nil, keys where exclude[key] == true are not written.
 func (h Header) WriteSubset(w io.Writer, exclude map[string]bool) error {
-    keys := make([]string, 0, len(h))
-    for k := range h {
-        if exclude == nil || !exclude[k] {
-            keys = append(keys, k)
-        }
-    }
-    sort.Strings(keys)
-    for _, k := range keys {
-        for _, v := range h[k] {
-            v = headerNewlineToSpace.Replace(v)
-            v = strings.TrimSpace(v)
-            if _, err := fmt.Fprintf(w, "%s: %s\r\n", k, v); err != nil {
-                return err
-            }
-        }
-    }
-    return nil
+	keys := make([]string, 0, len(h))
+	for k := range h {
+		if exclude == nil || !exclude[k] {
+			keys = append(keys, k)
+		}
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		for _, v := range h[k] {
+			v = headerNewlineToSpace.Replace(v)
+			v = strings.TrimSpace(v)
+			if _, err := fmt.Fprintf(w, "%s: %s\r\n", k, v); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
 }
 
 // CanonicalHeaderKey returns the canonical format of the

=== modified file 'fork/http/jar.go'
--- fork/http/jar.go	2013-07-22 12:53:27 +0000
+++ fork/http/jar.go	2014-12-02 00:40:19 +0000
@@ -5,7 +5,7 @@
 package http
 
 import (
-    "net/url"
+	"net/url"
 )
 
 // A CookieJar manages storage and use of cookies in HTTP requests.
@@ -13,15 +13,15 @@
 // Implementations of CookieJar must be safe for concurrent use by multiple
 // goroutines.
 type CookieJar interface {
-    // SetCookies handles the receipt of the cookies in a reply for the
-    // given URL.  It may or may not choose to save the cookies, depending
-    // on the jar's policy and implementation.
-    SetCookies(u *url.URL, cookies []*Cookie)
+	// SetCookies handles the receipt of the cookies in a reply for the
+	// given URL.  It may or may not choose to save the cookies, depending
+	// on the jar's policy and implementation.
+	SetCookies(u *url.URL, cookies []*Cookie)
 
-    // Cookies returns the cookies to send in a request for the given URL.
-    // It is up to the implementation to honor the standard cookie use
-    // restrictions such as in RFC 6265.
-    Cookies(u *url.URL) []*Cookie
+	// Cookies returns the cookies to send in a request for the given URL.
+	// It is up to the implementation to honor the standard cookie use
+	// restrictions such as in RFC 6265.
+	Cookies(u *url.URL) []*Cookie
 }
 
 type blackHoleJar struct{}

=== modified file 'fork/http/lex.go'
--- fork/http/lex.go	2013-07-22 12:53:27 +0000
+++ fork/http/lex.go	2014-12-02 00:40:19 +0000
@@ -7,11 +7,11 @@
 // This file deals with lexical matters of HTTP
 
 func isSeparator(c byte) bool {
-    switch c {
-    case '(', ')', '<', '>', '@', ',', ';', ':', '\\', '"', '/', '[', ']', '?', '=', '{', '}', ' ', '\t':
-        return true
-    }
-    return false
+	switch c {
+	case '(', ')', '<', '>', '@', ',', ';', ':', '\\', '"', '/', '[', ']', '?', '=', '{', '}', ' ', '\t':
+		return true
+	}
+	return false
 }
 
 func isCtl(c byte) bool { return (0 <= c && c <= 31) || c == 127 }
@@ -29,108 +29,108 @@
 // characters should probably not be treated as errors by a robust (forgiving)
 // parser, so we replace them with the '?' character.
 func httpUnquotePair(b byte) byte {
-    // skip the first byte, which should always be '\'
-    switch b {
-    case 'a':
-        return '\a'
-    case 'b':
-        return '\b'
-    case 'f':
-        return '\f'
-    case 'n':
-        return '\n'
-    case 'r':
-        return '\r'
-    case 't':
-        return '\t'
-    case 'v':
-        return '\v'
-    case '\\':
-        return '\\'
-    case '\'':
-        return '\''
-    case '"':
-        return '"'
-    }
-    return '?'
+	// skip the first byte, which should always be '\'
+	switch b {
+	case 'a':
+		return '\a'
+	case 'b':
+		return '\b'
+	case 'f':
+		return '\f'
+	case 'n':
+		return '\n'
+	case 'r':
+		return '\r'
+	case 't':
+		return '\t'
+	case 'v':
+		return '\v'
+	case '\\':
+		return '\\'
+	case '\'':
+		return '\''
+	case '"':
+		return '"'
+	}
+	return '?'
 }
 
 // raw must begin with a valid quoted string. Only the first quoted string is
 // parsed and is unquoted in result. eaten is the number of bytes parsed, or -1
 // upon failure.
 func httpUnquote(raw []byte) (eaten int, result string) {
-    buf := make([]byte, len(raw))
-    if raw[0] != '"' {
-        return -1, ""
-    }
-    eaten = 1
-    j := 0 // # of bytes written in buf
-    for i := 1; i < len(raw); i++ {
-        switch b := raw[i]; b {
-        case '"':
-            eaten++
-            buf = buf[0:j]
-            return i + 1, string(buf)
-        case '\\':
-            if len(raw) < i+2 {
-                return -1, ""
-            }
-            buf[j] = httpUnquotePair(raw[i+1])
-            eaten += 2
-            j++
-            i++
-        default:
-            if isQdText(b) {
-                buf[j] = b
-            } else {
-                buf[j] = '?'
-            }
-            eaten++
-            j++
-        }
-    }
-    return -1, ""
+	buf := make([]byte, len(raw))
+	if raw[0] != '"' {
+		return -1, ""
+	}
+	eaten = 1
+	j := 0 // # of bytes written in buf
+	for i := 1; i < len(raw); i++ {
+		switch b := raw[i]; b {
+		case '"':
+			eaten++
+			buf = buf[0:j]
+			return i + 1, string(buf)
+		case '\\':
+			if len(raw) < i+2 {
+				return -1, ""
+			}
+			buf[j] = httpUnquotePair(raw[i+1])
+			eaten += 2
+			j++
+			i++
+		default:
+			if isQdText(b) {
+				buf[j] = b
+			} else {
+				buf[j] = '?'
+			}
+			eaten++
+			j++
+		}
+	}
+	return -1, ""
 }
 
 // This is a best effort parse, so errors are not returned, instead not all of
 // the input string might be parsed. result is always non-nil.
 func httpSplitFieldValue(fv string) (eaten int, result []string) {
-    result = make([]string, 0, len(fv))
-    raw := []byte(fv)
-    i := 0
-    chunk := ""
-    for i < len(raw) {
-        b := raw[i]
-        switch {
-        case b == '"':
-            eaten, unq := httpUnquote(raw[i:])
-            if eaten < 0 {
-                return i, result
-            } else {
-                i += eaten
-                chunk += unq
-            }
-        case isSeparator(b):
-            if chunk != "" {
-                result = result[0 : len(result)+1]
-                result[len(result)-1] = chunk
-                chunk = ""
-            }
-            i++
-        case isToken(b):
-            chunk += string(b)
-            i++
-        case b == '\n' || b == '\r':
-            i++
-        default:
-            chunk += "?"
-            i++
-        }
-    }
-    if chunk != "" {
-        result = result[0 : len(result)+1]
-        result[len(result)-1] = chunk
-        chunk = ""
-    }
-    return i, result
+	result = make([]string, 0, len(fv))
+	raw := []byte(fv)
+	i := 0
+	chunk := ""
+	for i < len(raw) {
+		b := raw[i]
+		switch {
+		case b == '"':
+			eaten, unq := httpUnquote(raw[i:])
+			if eaten < 0 {
+				return i, result
+			} else {
+				i += eaten
+				chunk += unq
+			}
+		case isSeparator(b):
+			if chunk != "" {
+				result = result[0 : len(result)+1]
+				result[len(result)-1] = chunk
+				chunk = ""
+			}
+			i++
+		case isToken(b):
+			chunk += string(b)
+			i++
+		case b == '\n' || b == '\r':
+			i++
+		default:
+			chunk += "?"
+			i++
+		}
+	}
+	if chunk != "" {
+		result = result[0 : len(result)+1]
+		result[len(result)-1] = chunk
+		chunk = ""
+	}
+	return i, result
 }

=== modified file 'fork/http/request.go'
--- fork/http/request.go	2013-07-22 12:53:27 +0000
+++ fork/http/request.go	2014-12-02 00:40:19 +0000
@@ -7,26 +7,26 @@
 package http
 
 import (
-    "bufio"
-    "bytes"
-    "crypto/tls"
-    "encoding/base64"
-    "errors"
-    "fmt"
-    "io"
-    "io/ioutil"
-    "mime"
-    "mime/multipart"
-    "net/textproto"
-    "net/url"
-    "strings"
+	"bufio"
+	"bytes"
+	"crypto/tls"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"mime"
+	"mime/multipart"
+	"net/textproto"
+	"net/url"
+	"strings"
 )
 
 const (
-    maxValueLength   = 4096
-    maxHeaderLines   = 1024
-    chunkSize        = 4 << 10  // 4 KB chunks
-    defaultMaxMemory = 32 << 20 // 32 MB
+	maxValueLength   = 4096
+	maxHeaderLines   = 1024
+	chunkSize        = 4 << 10  // 4 KB chunks
+	defaultMaxMemory = 32 << 20 // 32 MB
 )
 
 // ErrMissingFile is returned by FormFile when the provided file field name
@@ -35,155 +35,155 @@
 
 // HTTP request parsing errors.
 type ProtocolError struct {
-    ErrorString string
+	ErrorString string
 }
 
 func (err *ProtocolError) Error() string { return err.ErrorString }
 
 var (
-    ErrHeaderTooLong        = &ProtocolError{"header too long"}
-    ErrShortBody            = &ProtocolError{"entity body too short"}
-    ErrNotSupported         = &ProtocolError{"feature not supported"}
-    ErrUnexpectedTrailer    = &ProtocolError{"trailer header without chunked transfer encoding"}
-    ErrMissingContentLength = &ProtocolError{"missing ContentLength in HEAD response"}
-    ErrNotMultipart         = &ProtocolError{"request Content-Type isn't multipart/form-data"}
-    ErrMissingBoundary      = &ProtocolError{"no multipart boundary param Content-Type"}
+	ErrHeaderTooLong        = &ProtocolError{"header too long"}
+	ErrShortBody            = &ProtocolError{"entity body too short"}
+	ErrNotSupported         = &ProtocolError{"feature not supported"}
+	ErrUnexpectedTrailer    = &ProtocolError{"trailer header without chunked transfer encoding"}
+	ErrMissingContentLength = &ProtocolError{"missing ContentLength in HEAD response"}
+	ErrNotMultipart         = &ProtocolError{"request Content-Type isn't multipart/form-data"}
+	ErrMissingBoundary      = &ProtocolError{"no multipart boundary param Content-Type"}
 )
 
 type badStringError struct {
-    what string
-    str  string
+	what string
+	str  string
 }
 
 func (e *badStringError) Error() string { return fmt.Sprintf("%s %q", e.what, e.str) }
 
 // Headers that Request.Write handles itself and should be skipped.
 var reqWriteExcludeHeader = map[string]bool{
-    "Host":              true, // not in Header map anyway
-    "User-Agent":        true,
-    "Content-Length":    true,
-    "Transfer-Encoding": true,
-    "Trailer":           true,
+	"Host":              true, // not in Header map anyway
+	"User-Agent":        true,
+	"Content-Length":    true,
+	"Transfer-Encoding": true,
+	"Trailer":           true,
 }
 
 // A Request represents an HTTP request received by a server
 // or to be sent by a client.
 type Request struct {
-    Method string // GET, POST, PUT, etc.
-    URL    *url.URL
-
-    // The protocol version for incoming requests.
-    // Outgoing requests always use HTTP/1.1.
-    Proto      string // "HTTP/1.0"
-    ProtoMajor int    // 1
-    ProtoMinor int    // 0
-
-    // A header maps request lines to their values.
-    // If the header says
-    //
-    //	accept-encoding: gzip, deflate
-    //	Accept-Language: en-us
-    //	Connection: keep-alive
-    //
-    // then
-    //
-    //	Header = map[string][]string{
-    //		"Accept-Encoding": {"gzip, deflate"},
-    //		"Accept-Language": {"en-us"},
-    //		"Connection": {"keep-alive"},
-    //	}
-    //
-    // HTTP defines that header names are case-insensitive.
-    // The request parser implements this by canonicalizing the
-    // name, making the first character and any characters
-    // following a hyphen uppercase and the rest lowercase.
-    Header Header
-
-    // The message body.
-    Body io.ReadCloser
-
-    // ContentLength records the length of the associated content.
-    // The value -1 indicates that the length is unknown.
-    // Values >= 0 indicate that the given number of bytes may
-    // be read from Body.
-    // For outgoing requests, a value of 0 means unknown if Body is not nil.
-    ContentLength int64
-
-    // TransferEncoding lists the transfer encodings from outermost to
-    // innermost. An empty list denotes the "identity" encoding.
-    // TransferEncoding can usually be ignored; chunked encoding is
-    // automatically added and removed as necessary when sending and
-    // receiving requests.
-    TransferEncoding []string
-
-    // Close indicates whether to close the connection after
-    // replying to this request.
-    Close bool
-
-    // The host on which the URL is sought.
-    // Per RFC 2616, this is either the value of the Host: header
-    // or the host name given in the URL itself.
-    Host string
-
-    // Form contains the parsed form data, including both the URL
-    // field's query parameters and the POST or PUT form data.
-    // This field is only available after ParseForm is called.
-    // The HTTP client ignores Form and uses Body instead.
-    Form url.Values
-
-    // MultipartForm is the parsed multipart form, including file uploads.
-    // This field is only available after ParseMultipartForm is called.
-    // The HTTP client ignores MultipartForm and uses Body instead.
-    MultipartForm *multipart.Form
-
-    // Trailer maps trailer keys to values.  Like for Header, if the
-    // response has multiple trailer lines with the same key, they will be
-    // concatenated, delimited by commas.
-    // For server requests, Trailer is only populated after Body has been
-    // closed or fully consumed.
-    // Trailer support is only partially complete.
-    Trailer Header
-
-    // RemoteAddr allows HTTP servers and other software to record
-    // the network address that sent the request, usually for
-    // logging. This field is not filled in by ReadRequest and
-    // has no defined format. The HTTP server in this package
-    // sets RemoteAddr to an "IP:port" address before invoking a
-    // handler.
-    // This field is ignored by the HTTP client.
-    RemoteAddr string
-
-    // RequestURI is the unmodified Request-URI of the
-    // Request-Line (RFC 2616, Section 5.1) as sent by the client
-    // to a server. Usually the URL field should be used instead.
-    // It is an error to set this field in an HTTP client request.
-    RequestURI string
-
-    // TLS allows HTTP servers and other software to record
-    // information about the TLS connection on which the request
-    // was received. This field is not filled in by ReadRequest.
-    // The HTTP server in this package sets the field for
-    // TLS-enabled connections before invoking a handler;
-    // otherwise it leaves the field nil.
-    // This field is ignored by the HTTP client.
-    TLS *tls.ConnectionState
+	Method string // GET, POST, PUT, etc.
+	URL    *url.URL
+
+	// The protocol version for incoming requests.
+	// Outgoing requests always use HTTP/1.1.
+	Proto      string // "HTTP/1.0"
+	ProtoMajor int    // 1
+	ProtoMinor int    // 0
+
+	// A header maps request lines to their values.
+	// If the header says
+	//
+	//	accept-encoding: gzip, deflate
+	//	Accept-Language: en-us
+	//	Connection: keep-alive
+	//
+	// then
+	//
+	//	Header = map[string][]string{
+	//		"Accept-Encoding": {"gzip, deflate"},
+	//		"Accept-Language": {"en-us"},
+	//		"Connection": {"keep-alive"},
+	//	}
+	//
+	// HTTP defines that header names are case-insensitive.
+	// The request parser implements this by canonicalizing the
+	// name, making the first character and any characters
+	// following a hyphen uppercase and the rest lowercase.
+	Header Header
+
+	// The message body.
+	Body io.ReadCloser
+
+	// ContentLength records the length of the associated content.
+	// The value -1 indicates that the length is unknown.
+	// Values >= 0 indicate that the given number of bytes may
+	// be read from Body.
+	// For outgoing requests, a value of 0 means unknown if Body is not nil.
+	ContentLength int64
+
+	// TransferEncoding lists the transfer encodings from outermost to
+	// innermost. An empty list denotes the "identity" encoding.
+	// TransferEncoding can usually be ignored; chunked encoding is
+	// automatically added and removed as necessary when sending and
+	// receiving requests.
+	TransferEncoding []string
+
+	// Close indicates whether to close the connection after
+	// replying to this request.
+	Close bool
+
+	// The host on which the URL is sought.
+	// Per RFC 2616, this is either the value of the Host: header
+	// or the host name given in the URL itself.
+	Host string
+
+	// Form contains the parsed form data, including both the URL
+	// field's query parameters and the POST or PUT form data.
+	// This field is only available after ParseForm is called.
+	// The HTTP client ignores Form and uses Body instead.
+	Form url.Values
+
+	// MultipartForm is the parsed multipart form, including file uploads.
+	// This field is only available after ParseMultipartForm is called.
+	// The HTTP client ignores MultipartForm and uses Body instead.
+	MultipartForm *multipart.Form
+
+	// Trailer maps trailer keys to values.  Like for Header, if the
+	// response has multiple trailer lines with the same key, they will be
+	// concatenated, delimited by commas.
+	// For server requests, Trailer is only populated after Body has been
+	// closed or fully consumed.
+	// Trailer support is only partially complete.
+	Trailer Header
+
+	// RemoteAddr allows HTTP servers and other software to record
+	// the network address that sent the request, usually for
+	// logging. This field is not filled in by ReadRequest and
+	// has no defined format. The HTTP server in this package
+	// sets RemoteAddr to an "IP:port" address before invoking a
+	// handler.
+	// This field is ignored by the HTTP client.
+	RemoteAddr string
+
+	// RequestURI is the unmodified Request-URI of the
+	// Request-Line (RFC 2616, Section 5.1) as sent by the client
+	// to a server. Usually the URL field should be used instead.
+	// It is an error to set this field in an HTTP client request.
+	RequestURI string
+
+	// TLS allows HTTP servers and other software to record
+	// information about the TLS connection on which the request
+	// was received. This field is not filled in by ReadRequest.
+	// The HTTP server in this package sets the field for
+	// TLS-enabled connections before invoking a handler;
+	// otherwise it leaves the field nil.
+	// This field is ignored by the HTTP client.
+	TLS *tls.ConnectionState
 }
 
 // ProtoAtLeast returns whether the HTTP protocol used
 // in the request is at least major.minor.
 func (r *Request) ProtoAtLeast(major, minor int) bool {
-    return r.ProtoMajor > major ||
-        r.ProtoMajor == major && r.ProtoMinor >= minor
+	return r.ProtoMajor > major ||
+		r.ProtoMajor == major && r.ProtoMinor >= minor
 }
 
 // UserAgent returns the client's User-Agent, if sent in the request.
 func (r *Request) UserAgent() string {
-    return r.Header.Get("User-Agent")
+	return r.Header.Get("User-Agent")
 }
 
 // Cookies parses and returns the HTTP cookies sent with the request.
 func (r *Request) Cookies() []*Cookie {
-    return readCookies(r.Header, "")
+	return readCookies(r.Header, "")
 }
 
 var ErrNoCookie = errors.New("http: named cookie not present")
@@ -191,10 +191,10 @@
 // Cookie returns the named cookie provided in the request or
 // ErrNoCookie if not found.
 func (r *Request) Cookie(name string) (*Cookie, error) {
-    for _, c := range readCookies(r.Header, name) {
-        return c, nil
-    }
-    return nil, ErrNoCookie
+	for _, c := range readCookies(r.Header, name) {
+		return c, nil
+	}
+	return nil, ErrNoCookie
 }
 
 // AddCookie adds a cookie to the request.  Per RFC 6265 section 5.4,
@@ -202,12 +202,12 @@
 // means all cookies, if any, are written into the same line,
 // separated by semicolon.
 func (r *Request) AddCookie(c *Cookie) {
-    s := fmt.Sprintf("%s=%s", sanitizeName(c.Name), sanitizeValue(c.Value))
-    if c := r.Header.Get("Cookie"); c != "" {
-        r.Header.Set("Cookie", c+"; "+s)
-    } else {
-        r.Header.Set("Cookie", s)
-    }
+	s := fmt.Sprintf("%s=%s", sanitizeName(c.Name), sanitizeValue(c.Value))
+	if c := r.Header.Get("Cookie"); c != "" {
+		r.Header.Set("Cookie", c+"; "+s)
+	} else {
+		r.Header.Set("Cookie", s)
+	}
 }
 
 // Referer returns the referring URL, if sent in the request.
@@ -219,15 +219,15 @@
 // alternate (correct English) spelling req.Referrer() but cannot
 // diagnose programs that use Header["Referrer"].
 func (r *Request) Referer() string {
-    return r.Header.Get("Referer")
+	return r.Header.Get("Referer")
 }
 
 // multipartByReader is a sentinel value.
 // Its presence in Request.MultipartForm indicates that parsing of the request
 // body has been handed off to a MultipartReader instead of ParseMultipartFrom.
 var multipartByReader = &multipart.Form{
-    Value: make(map[string][]string),
-    File:  make(map[string][]*multipart.FileHeader),
+	Value: make(map[string][]string),
+	File:  make(map[string][]*multipart.FileHeader),
 }
 
 // MultipartReader returns a MIME multipart reader if this is a
@@ -235,38 +235,38 @@
 // Use this function instead of ParseMultipartForm to
 // process the request body as a stream.
 func (r *Request) MultipartReader() (*multipart.Reader, error) {
-    if r.MultipartForm == multipartByReader {
-        return nil, errors.New("http: MultipartReader called twice")
-    }
-    if r.MultipartForm != nil {
-        return nil, errors.New("http: multipart handled by ParseMultipartForm")
-    }
-    r.MultipartForm = multipartByReader
-    return r.multipartReader()
+	if r.MultipartForm == multipartByReader {
+		return nil, errors.New("http: MultipartReader called twice")
+	}
+	if r.MultipartForm != nil {
+		return nil, errors.New("http: multipart handled by ParseMultipartForm")
+	}
+	r.MultipartForm = multipartByReader
+	return r.multipartReader()
 }
 
 func (r *Request) multipartReader() (*multipart.Reader, error) {
-    v := r.Header.Get("Content-Type")
-    if v == "" {
-        return nil, ErrNotMultipart
-    }
-    d, params, err := mime.ParseMediaType(v)
-    if err != nil || d != "multipart/form-data" {
-        return nil, ErrNotMultipart
-    }
-    boundary, ok := params["boundary"]
-    if !ok {
-        return nil, ErrMissingBoundary
-    }
-    return multipart.NewReader(r.Body, boundary), nil
+	v := r.Header.Get("Content-Type")
+	if v == "" {
+		return nil, ErrNotMultipart
+	}
+	d, params, err := mime.ParseMediaType(v)
+	if err != nil || d != "multipart/form-data" {
+		return nil, ErrNotMultipart
+	}
+	boundary, ok := params["boundary"]
+	if !ok {
+		return nil, ErrMissingBoundary
+	}
+	return multipart.NewReader(r.Body, boundary), nil
 }
 
 // Return value if nonempty, def otherwise.
 func valueOrDefault(value, def string) string {
-    if value != "" {
-        return value
-    }
-    return def
+	if value != "" {
+		return value
+	}
+	return def
 }
 
 const defaultUserAgent = "Go http package"
@@ -285,7 +285,7 @@
 // hasn't been set to "identity", Write adds "Transfer-Encoding:
 // chunked" to the header. Body is closed after it is sent.
 func (r *Request) Write(w io.Writer) error {
-    return r.write(w, false, nil)
+	return r.write(w, false, nil)
 }
 
 // WriteProxy is like Write but writes the request in the form
@@ -295,145 +295,145 @@
 // In either case, WriteProxy also writes a Host header, using
 // either r.Host or r.URL.Host.
 func (r *Request) WriteProxy(w io.Writer) error {
-    return r.write(w, true, nil)
+	return r.write(w, true, nil)
 }
 
 // extraHeaders may be nil
 func (req *Request) write(w io.Writer, usingProxy bool, extraHeaders Header) error {
-    host := req.Host
-    if host == "" {
-        if req.URL == nil {
-            return errors.New("http: Request.Write on Request with no Host or URL set")
-        }
-        host = req.URL.Host
-    }
-
-    ruri := req.URL.RequestURI()
-    if usingProxy && req.URL.Scheme != "" && req.URL.Opaque == "" {
-        ruri = req.URL.Scheme + "://" + host + ruri
-    } else if req.Method == "CONNECT" && req.URL.Path == "" {
-        // CONNECT requests normally give just the host and port, not a full URL.
-        ruri = host
-    }
-    // TODO(bradfitz): escape at least newlines in ruri?
-
-    bw := bufio.NewWriter(w)
-    fmt.Fprintf(bw, "%s %s HTTP/1.1\r\n", valueOrDefault(req.Method, "GET"), ruri)
-
-    // Header lines
-    fmt.Fprintf(bw, "Host: %s\r\n", host)
-
-    // Use the defaultUserAgent unless the Header contains one, which
-    // may be blank to not send the header.
-    userAgent := defaultUserAgent
-    if req.Header != nil {
-        if ua := req.Header["User-Agent"]; len(ua) > 0 {
-            userAgent = ua[0]
-        }
-    }
-    if userAgent != "" {
-        fmt.Fprintf(bw, "User-Agent: %s\r\n", userAgent)
-    }
-
-    // Process Body,ContentLength,Close,Trailer
-    tw, err := newTransferWriter(req)
-    if err != nil {
-        return err
-    }
-    err = tw.WriteHeader(bw)
-    if err != nil {
-        return err
-    }
-
-    // TODO: split long values?  (If so, should share code with Conn.Write)
-    err = req.Header.WriteSubset(bw, reqWriteExcludeHeader)
-    if err != nil {
-        return err
-    }
-
-    if extraHeaders != nil {
-        err = extraHeaders.Write(bw)
-        if err != nil {
-            return err
-        }
-    }
-
-    io.WriteString(bw, "\r\n")
-
-    // Write body and trailer
-    err = tw.WriteBody(bw)
-    if err != nil {
-        return err
-    }
-
-    return bw.Flush()
+	host := req.Host
+	if host == "" {
+		if req.URL == nil {
+			return errors.New("http: Request.Write on Request with no Host or URL set")
+		}
+		host = req.URL.Host
+	}
+
+	ruri := req.URL.RequestURI()
+	if usingProxy && req.URL.Scheme != "" && req.URL.Opaque == "" {
+		ruri = req.URL.Scheme + "://" + host + ruri
+	} else if req.Method == "CONNECT" && req.URL.Path == "" {
+		// CONNECT requests normally give just the host and port, not a full URL.
+		ruri = host
+	}
+	// TODO(bradfitz): escape at least newlines in ruri?
+
+	bw := bufio.NewWriter(w)
+	fmt.Fprintf(bw, "%s %s HTTP/1.1\r\n", valueOrDefault(req.Method, "GET"), ruri)
+
+	// Header lines
+	fmt.Fprintf(bw, "Host: %s\r\n", host)
+
+	// Use the defaultUserAgent unless the Header contains one, which
+	// may be blank to not send the header.
+	userAgent := defaultUserAgent
+	if req.Header != nil {
+		if ua := req.Header["User-Agent"]; len(ua) > 0 {
+			userAgent = ua[0]
+		}
+	}
+	if userAgent != "" {
+		fmt.Fprintf(bw, "User-Agent: %s\r\n", userAgent)
+	}
+
+	// Process Body,ContentLength,Close,Trailer
+	tw, err := newTransferWriter(req)
+	if err != nil {
+		return err
+	}
+	err = tw.WriteHeader(bw)
+	if err != nil {
+		return err
+	}
+
+	// TODO: split long values?  (If so, should share code with Conn.Write)
+	err = req.Header.WriteSubset(bw, reqWriteExcludeHeader)
+	if err != nil {
+		return err
+	}
+
+	if extraHeaders != nil {
+		err = extraHeaders.Write(bw)
+		if err != nil {
+			return err
+		}
+	}
+
+	io.WriteString(bw, "\r\n")
+
+	// Write body and trailer
+	err = tw.WriteBody(bw)
+	if err != nil {
+		return err
+	}
+
+	return bw.Flush()
 }
 
 // Convert decimal at s[i:len(s)] to integer,
 // returning value, string position where the digits stopped,
 // and whether there was a valid number (digits, not too big).
 func atoi(s string, i int) (n, i1 int, ok bool) {
-    const Big = 1000000
-    if i >= len(s) || s[i] < '0' || s[i] > '9' {
-        return 0, 0, false
-    }
-    n = 0
-    for ; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
-        n = n*10 + int(s[i]-'0')
-        if n > Big {
-            return 0, 0, false
-        }
-    }
-    return n, i, true
+	const Big = 1000000
+	if i >= len(s) || s[i] < '0' || s[i] > '9' {
+		return 0, 0, false
+	}
+	n = 0
+	for ; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
+		n = n*10 + int(s[i]-'0')
+		if n > Big {
+			return 0, 0, false
+		}
+	}
+	return n, i, true
 }
 
 // ParseHTTPVersion parses a HTTP version string.
 // "HTTP/1.0" returns (1, 0, true).
 func ParseHTTPVersion(vers string) (major, minor int, ok bool) {
-    if len(vers) < 5 || vers[0:5] != "HTTP/" {
-        return 0, 0, false
-    }
-    major, i, ok := atoi(vers, 5)
-    if !ok || i >= len(vers) || vers[i] != '.' {
-        return 0, 0, false
-    }
-    minor, i, ok = atoi(vers, i+1)
-    if !ok || i != len(vers) {
-        return 0, 0, false
-    }
-    return major, minor, true
+	if len(vers) < 5 || vers[0:5] != "HTTP/" {
+		return 0, 0, false
+	}
+	major, i, ok := atoi(vers, 5)
+	if !ok || i >= len(vers) || vers[i] != '.' {
+		return 0, 0, false
+	}
+	minor, i, ok = atoi(vers, i+1)
+	if !ok || i != len(vers) {
+		return 0, 0, false
+	}
+	return major, minor, true
 }
 
 // NewRequest returns a new Request given a method, URL, and optional body.
 func NewRequest(method, urlStr string, body io.Reader) (*Request, error) {
-    u, err := url.Parse(urlStr)
-    if err != nil {
-        return nil, err
-    }
-    rc, ok := body.(io.ReadCloser)
-    if !ok && body != nil {
-        rc = ioutil.NopCloser(body)
-    }