ability to dump http response for debugging

example/main.go

@@ -16,6 +16,7 @@ import (
 	"github.com/drone/go-login/login/github"
 	"github.com/drone/go-login/login/gitlab"
 	"github.com/drone/go-login/login/gogs"
+	"github.com/drone/go-login/login/logger"
 	"github.com/drone/go-login/login/stash"
 )
 
@@ -28,6 +29,7 @@ var (
 	consumerRsa  = flag.String("consumer-private-key", "", "")
 	redirectURL  = flag.String("redirect-url", "http://localhost:8080/login", "")
 	address      = flag.String("address", ":8080", "")
+	dump         = flag.Bool("dump", false, "")
 	help         = flag.Bool("help", false, "")
 )
 
@@ -40,6 +42,11 @@ func main() {
 		os.Exit(0)
 	}
 
+	dumper := logger.DiscardDumper()
+	if *dump {
+		dumper = logger.StandardDumper()
+	}
+
 	var middleware login.Middleware
 	switch *provider {
 	case "gogs", "gitea":
@@ -60,6 +67,7 @@ func main() {
 			ClientSecret: *clientSecret,
 			Server:       *providerURL,
 			Scope:        []string{"repo", "user", "read:org"},
+			Dumper:       dumper,
 		}
 	case "bitbucket":
 		middleware = &bitbucket.Config{
@@ -80,6 +88,8 @@ func main() {
 		}
 	}
 
+	log.Printf("Staring server at %s", *address)
+
 	// handles the authorization flow and displays the
 	// authorization results at completion.
 	http.Handle("/login/form", http.HandlerFunc(form))

login/github/github.go

@@ -23,6 +23,7 @@ type Config struct {
 	Server       string
 	Scope        []string
 	Logger       logger.Logger
+	Dumper       logger.Dumper
 }
 
 // Handler returns a http.Handler that runs h at the
@@ -40,6 +41,7 @@ func (c *Config) Handler(h http.Handler) http.Handler {
 		AuthorizationURL: server + "/login/oauth/authorize",
 		Scope:            c.Scope,
 		Logger:           c.Logger,
+		Dumper:           c.Dumper,
 	})
 }
 

login/internal/oauth2/config.go

@@ -59,6 +59,10 @@ type Config struct {
 	// Logger is used to log errors. If nil the provider
 	// use the default noop logger.
 	Logger logger.Logger
+
+	// Dumper is used to dump the http.Request and
+	// http.Response for debug purposes.
+	Dumper logger.Dumper
 }
 
 // authorizeRedirect returns a client authorization
@@ -103,19 +107,27 @@ func (c *Config) exchange(code, state string) (*token, error) {
 	if err != nil {
 		return nil, err
 	}
+	req.Header.Set("Accept", "application/json")
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 
 	if !c.BasicAuthOff {
 		req.SetBasicAuth(c.ClientID, c.ClientSecret)
 	}
 
-	req.Header.Set("Accept", "application/json")
+	if c.Dumper != nil {
+		c.Dumper.DumpRequest(req)
+	}
+
 	res, err := c.client().Do(req)
 	if err != nil {
 		return nil, err
 	}
 	defer res.Body.Close()
 
+	if c.Dumper != nil {
+		c.Dumper.DumpResponse(res)
+	}
+
 	if res.StatusCode > 299 {
 		err := new(Error)
 		json.NewDecoder(res.Body).Decode(err)

login/logger/dumper.go

@@ -0,0 +1,45 @@
+// Copyright 2017 Drone.IO Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logger
+
+import (
+	"net/http"
+	"net/http/httputil"
+	"os"
+)
+
+// Dumper dumps the http.Request and http.Response
+// message payload for debugging purposes.
+type Dumper interface {
+	DumpRequest(*http.Request)
+	DumpResponse(*http.Response)
+}
+
+// DiscardDumper returns a no-op dumper.
+func DiscardDumper() Dumper {
+	return new(discardDumper)
+}
+
+type discardDumper struct{}
+
+func (*discardDumper) DumpRequest(*http.Request)   {}
+func (*discardDumper) DumpResponse(*http.Response) {}
+
+// StandardDumper returns a standard dumper.
+func StandardDumper() Dumper {
+	return new(standardDumper)
+}
+
+type standardDumper struct{}
+
+func (*standardDumper) DumpRequest(req *http.Request) {
+	dump, _ := httputil.DumpRequestOut(req, true)
+	os.Stdout.Write(dump)
+}
+
+func (*standardDumper) DumpResponse(res *http.Response) {
+	dump, _ := httputil.DumpResponse(res, true)
+	os.Stdout.Write(dump)
+}

login/logger/logger.go

@@ -24,7 +24,7 @@ type Logger interface {
 	Warnln(args ...interface{})
 }
 
-// Discard returns a no-op logger
+// Discard returns a no-op logger.
 func Discard() Logger {
 	return &discard{}
 }