Go 1.7 context

.travis.yml

@@ -1,7 +1,7 @@
 language: go
 
 go:
-  - 1.4
+  - tip
 
 before_install:
   - go install -a -race std

example/main.go

@@ -1,11 +1,11 @@
 package main
 
 import (
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/http"
 
+	"github.com/gorilla/mux"
 	"github.com/remind101/pkg/httpx"
 	"github.com/remind101/pkg/httpx/middleware"
 	"github.com/remind101/pkg/logger"
@@ -14,66 +14,42 @@ import (
 	"golang.org/x/net/context"
 )
 
-func ok(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
+func ok(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
 	ip, err := ip(ctx)
 	if err != nil {
-		return err
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
 	}
 
 	logger.Info(ctx, "ip address", "ip", ip)
 
-	_, err = fmt.Fprintf(w, "%s\n", ip)
-	return err
-}
-
-func bad(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
-	return &Error{ID: "bad_error", Err: errors.New("bad request")}
-}
-
-func boom(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
-	panic("boom")
-}
-
-func errorHandler(ctx context.Context, err error, w http.ResponseWriter, r *http.Request) {
-	http.Error(w, err.Error(), http.StatusInternalServerError)
+	fmt.Fprintf(w, "%s\n", ip)
 }
 
 func main() {
 	// An error reporter that will log errors to stdout.
 	r := reporter.NewLogReporter()
 
-	m := httpx.NewRouter()
+	m := mux.NewRouter()
 
 	m.HandleFunc("/ok", ok).Methods("GET")
-	m.HandleFunc("/bad", bad).Methods("GET")
-	m.HandleFunc("/boom", boom).Methods("GET")
-	m.Handle("/auth", middleware.BasicAuth(httpx.HandlerFunc(ok), "user", "pass", "realm")).Methods("GET")
+	m.Handle("/auth", middleware.BasicAuth(http.HandlerFunc(ok), "user", "pass", "realm")).Methods("GET")
 
-	var h httpx.Handler
+	var h http.Handler
 
 	// Recover from panics, and report the recovered error to the reporter.
 	h = middleware.Recover(m, r)
 
-	// Handles any errors returned from handlers in a common format.
-	h = middleware.HandleError(h, errorHandler)
-
 	// Adds a logger to the context.Context that will log to stdout,
 	// prefixed with the request id.
 	h = middleware.LogTo(h, middleware.StdoutLogger)
 
 	// Adds the request id to the context.
 	h = middleware.ExtractRequestID(h)
 
-	http.ListenAndServe(":8080", middleware.BackgroundContext(h))
-}
-
-type Error struct {
-	ID  string
-	Err error
-}
-
-func (e *Error) Error() string {
-	return fmt.Sprintf("%s: %s", e.ID, e.Err)
+	http.ListenAndServe(":8080", h)
 }
 
 // ip returns your ip.

httpx/http_service.go

@@ -2,6 +2,7 @@ package httpx
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -12,8 +13,6 @@ import (
 	"time"
 
 	"github.com/remind101/pkg/retry"
-
-	"golang.org/x/net/context"
 )
 
 type RoundTripper interface {

httpx/http_service_test.go

@@ -1,13 +1,13 @@
 package httpx
 
 import (
+	"context"
 	"io/ioutil"
 	"net/http"
 	"net/url"
 	"strings"
 	"testing"
 
-	"golang.org/x/net/context"
 	"github.com/remind101/pkg/retry"
 )
 

httpx/httpx.go

@@ -1,28 +1,6 @@
 // package httpx provides an extra layer of convenience over package http.
 package httpx
 
-import (
-	"net/http"
-
-	"golang.org/x/net/context"
-)
-
-// Handler is represents a Handler that can take a context.Context as the
-// first argument.
-type Handler interface {
-	ServeHTTPContext(context.Context, http.ResponseWriter, *http.Request) error
-}
-
-// The HandlerFunc type is an adapter to allow the use of ordinary functions as
-// httpx handlers. If f is a function with the appropriate signature,
-// HandlerFunc(f) is a Handler object that calls f.
-type HandlerFunc func(context.Context, http.ResponseWriter, *http.Request) error
-
-// ServeHTTPContext calls f(ctx, w, r)
-func (f HandlerFunc) ServeHTTPContext(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
-	return f(ctx, w, r)
-}
-
 // key used to store context values from within this package.
 type key int
 

httpx/middleware/basic_auth.go

@@ -5,21 +5,18 @@ import (
 	"fmt"
 	"net/http"
 	"strings"
-
-	"github.com/remind101/pkg/httpx"
-	"golang.org/x/net/context"
 )
 
 type BasicAuther struct {
 	User, Pass string
 	Realm      string
 
 	// The handler that will be called if the request is authorized.
-	Handler httpx.Handler
+	Handler http.Handler
 
 	// The handler that will be called if the request is not authorized. The
 	// zero value is DefaultUnauthorizedHandler
-	UnauthorizedHandler httpx.Handler
+	UnauthorizedHandler http.Handler
 }
 
 func (a *BasicAuther) authenticated(r *http.Request) bool {
@@ -40,27 +37,26 @@ func (a *BasicAuther) authenticated(r *http.Request) bool {
 	return a.User == pair[0] && a.Pass == pair[1]
 }
 
-func DefaultUnauthorizedHandler(realm string) httpx.HandlerFunc {
-	return httpx.HandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
+func DefaultUnauthorizedHandler(realm string) http.HandlerFunc {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("WWW-Authenticate", fmt.Sprintf(`Basic realm=%q`, realm))
 		http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
-		return nil
 	})
 }
 
-func (a *BasicAuther) ServeHTTPContext(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
+func (a *BasicAuther) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if a.authenticated(r) {
-		return a.Handler.ServeHTTPContext(ctx, w, r)
+		a.Handler.ServeHTTP(w, r)
 	} else {
 		u := a.UnauthorizedHandler
 		if u == nil {
 			u = DefaultUnauthorizedHandler(a.Realm)
 		}
-		return u.ServeHTTPContext(ctx, w, r)
+		u.ServeHTTP(w, r)
 	}
 }
 
-func BasicAuth(h httpx.Handler, user, pass, realm string) *BasicAuther {
+func BasicAuth(h http.Handler, user, pass, realm string) *BasicAuther {
 	return &BasicAuther{
 		User:    user,
 		Pass:    pass,

httpx/middleware/basic_auth_test.go

@@ -4,54 +4,43 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
-
-	"github.com/remind101/pkg/httpx"
-	"golang.org/x/net/context"
 )
 
 func TestBasicAuth(t *testing.T) {
-	ctx := context.Background()
 	resp := httptest.NewRecorder()
 	req, _ := http.NewRequest("GET", "/city/123.123.123.123", nil)
 	req.SetBasicAuth("user", "pass")
 
-	var h httpx.Handler
+	var h http.Handler
 
 	const test_str = "sfaftfofsfhfi"
 
-	h = httpx.HandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
+	h = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Write([]byte(test_str))
-		return nil
 	})
 
 	h = BasicAuth(h, "user", "pass", "realm")
-	if err := h.ServeHTTPContext(ctx, resp, req); err != nil {
-		t.Fatal(err)
-	}
+	h.ServeHTTP(resp, req)
 
 	if got, want := resp.Body.String(), test_str; got != want {
 		t.Fatalf("Body => %s; want %s", got, want)
 	}
 }
 
 func TestBasicAuthUnauthorized(t *testing.T) {
-	ctx := context.Background()
 	resp := httptest.NewRecorder()
 	req, _ := http.NewRequest("GET", "/city/123.123.123.123", nil)
 
-	var h httpx.Handler
+	var h http.Handler
 
 	const test_str = "sfaftfofsfhfi"
 
-	h = httpx.HandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
+	h = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Write([]byte(test_str))
-		return nil
 	})
 
 	h = BasicAuth(h, "user", "pass", "realm")
-	if err := h.ServeHTTPContext(ctx, resp, req); err != nil {
-		t.Fatal(err)
-	}
+	h.ServeHTTP(resp, req)
 
 	if resp.Code != 401 {
 		t.Fatalf("Expected code 401")