use a request builder

This allows specifying custom options.

Author: Stebalien

request.go

@@ -55,6 +55,15 @@ func (r *Response) Close() error {
 	return nil
 }
 
+func (r *Response) Decode(dec interface{}) error {
+	defer r.Close()
+	if r.Error != nil {
+		return r.Error
+	}
+
+	return json.NewDecoder(r.Output).Decode(dec)
+}
+
 type Error struct {
 	Command string
 	Message string

requestbuilder.go

@@ -0,0 +1,97 @@
+package shell
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+// RequestBuilder is an IPFS commands request builder.
+type RequestBuilder struct {
+	command string
+	args    []string
+	opts    map[string]string
+	headers map[string]string
+	body    io.Reader
+
+	shell *Shell
+}
+
+// Arguments adds the arguments to the args.
+func (r *RequestBuilder) Arguments(args ...string) *RequestBuilder {
+	r.args = append(r.args, args...)
+	return r
+}
+
+// BodyString sets the request body to the given string.
+func (r *RequestBuilder) BodyString(body string) *RequestBuilder {
+	return r.Body(strings.NewReader(body))
+}
+
+// BodyBytes sets the request body to the given buffer.
+func (r *RequestBuilder) BodyBytes(body []byte) *RequestBuilder {
+	return r.Body(bytes.NewReader(body))
+}
+
+// Body sets the request body to the given reader.
+func (r *RequestBuilder) Body(body io.Reader) *RequestBuilder {
+	r.body = body
+	return r
+}
+
+// Option sets the given option.
+func (r *RequestBuilder) Option(key string, value interface{}) *RequestBuilder {
+	var s string
+	switch v := value.(type) {
+	case bool:
+		s = strconv.FormatBool(v)
+	case string:
+		s = v
+	case []byte:
+		s = string(v)
+	default:
+		// slow case.
+		s = fmt.Sprint(value)
+	}
+	if r.opts == nil {
+		r.opts = make(map[string]string, 1)
+	}
+	r.opts[key] = s
+	return r
+}
+
+// Header sets the given header.
+func (r *RequestBuilder) Header(name, value string) *RequestBuilder {
+	if r.headers == nil {
+		r.headers = make(map[string]string, 1)
+	}
+	r.headers[name] = value
+	return r
+}
+
+// Send sends the request and return the response.
+func (r *RequestBuilder) Send(ctx context.Context) (*Response, error) {
+	req := r.shell.newRequest(ctx, r.command, r.args...)
+	req.Opts = r.opts
+	req.Headers = r.headers
+	req.Body = r.body
+	return req.Send(r.shell.httpcli)
+}
+
+// Exec sends the request a request and decodes the response.
+func (r *RequestBuilder) Exec(ctx context.Context, res interface{}) error {
+	httpRes, err := r.Send(ctx)
+	if err != nil {
+		return err
+	}
+
+	if res == nil {
+		httpRes.Close()
+		return httpRes.Error
+	}
+
+	return httpRes.Decode(res)
+}

requestbuilder_test.go

@@ -0,0 +1,35 @@
+package shell
+
+import (
+	"testing"
+	"time"
+
+	"github.com/cheekybits/is"
+)
+
+func TestRequestBuilder(t *testing.T) {
+	is := is.New(t)
+
+	now := time.Now()
+	r := RequestBuilder{}
+	r.Arguments("1", "2", "3")
+	r.Arguments("4")
+	r.Option("stringkey", "stringvalue")
+	r.Option("bytekey", []byte("bytevalue"))
+	r.Option("boolkey", true)
+	r.Option("otherkey", now)
+	r.Header("some-header", "header-value")
+	r.Header("some-header-2", "header-value-2")
+
+	is.Equal(r.args, []string{"1", "2", "3", "4"})
+	is.Equal(r.opts, map[string]string{
+		"stringkey": "stringvalue",
+		"bytekey":   "bytevalue",
+		"boolkey":   "true",
+		"otherkey":  now.String(),
+	})
+	is.Equal(r.headers, map[string]string{
+		"some-header":   "header-value",
+		"some-header-2": "header-value-2",
+	})
+}

shell.go

@@ -94,23 +94,12 @@ func (s *Shell) newRequest(ctx context.Context, command string, args ...string)
 	return NewRequest(ctx, s.url, command, args...)
 }
 
-func (s *Shell) Request(ctx context.Context, command string, args ...string) (*Request, *Response, error) {
-	req := s.newRequest(ctx, command, args...)
-	res, err := req.Send(s.httpcli)
-	return req, res, err
-}
-
-func (s *Shell) RequestDecode(ctx context.Context, dec interface{}, command string, args ...string) error {
-	_, res, err := s.Request(ctx, command, args...)
-	if err != nil {
-		return err
-	}
-	defer res.Close()
-	if res.Error != nil {
-		return res.Error
+func (s *Shell) Request(command string, args ...string) *RequestBuilder {
+	return &RequestBuilder{
+		command: command,
+		args:    args,
+		shell:   s,
 	}
-
-	return json.NewDecoder(res.Output).Decode(dec)
 }
 
 type IdOutput struct {
@@ -855,9 +844,9 @@ func (s *Shell) ObjectStat(key string) (*ObjectStats, error) {
 
 // ObjectStat gets stats for the DAG object named by key. It returns
 // the stats of the requested Object or an error.
-func (s *Shell) StatsBW() (*p2pmetrics.Stats, error) {
+func (s *Shell) StatsBW(ctx context.Context) (*p2pmetrics.Stats, error) {
 	v := &p2pmetrics.Stats{}
-	err := s.RequestDecode(context.TODO(), &v, "stats/bw")
+	err := s.Request("stats/bw").Exec(ctx, &v)
 	return v, err
 }
 
@@ -878,8 +867,8 @@ type SwarmConnInfos struct {
 }
 
 // SwarmPeers gets all the swarm peers
-func (s *Shell) SwarmPeers() (*SwarmConnInfos, error) {
+func (s *Shell) SwarmPeers(ctx context.Context) (*SwarmConnInfos, error) {
 	v := &SwarmConnInfos{}
-	err := s.RequestDecode(context.TODO(), &v, "swarm/peers")
+	err := s.Request("swarm/peers").Exec(ctx, &v)
 	return v, err
 }

shell_test.go

@@ -2,6 +2,7 @@ package shell
 
 import (
 	"bytes"
+	"context"
 	"crypto/md5"
 	"fmt"
 	"io"
@@ -246,13 +247,13 @@ func TestDagPut(t *testing.T) {
 func TestStatsBW(t *testing.T) {
 	is := is.New(t)
 	s := NewShell(shellUrl)
-	_, err := s.StatsBW()
+	_, err := s.StatsBW(context.Background())
 	is.Nil(err)
 }
 
 func TestSwarmPeers(t *testing.T) {
 	is := is.New(t)
 	s := NewShell(shellUrl)
-	_, err := s.SwarmPeers()
+	_, err := s.SwarmPeers(context.Background())
 	is.Nil(err)
 }