switch to using Request internally

Author: Stebalien

bootstrap.go

@@ -2,70 +2,26 @@ package shell
 
 import (
 	"context"
-	"encoding/json"
 )
 
-func (s *Shell) BootstrapAdd(peers []string) ([]string, error) {
-	resp, err := s.newRequest(context.Background(), "bootstrap/add", peers...).Send(s.httpcli)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Close()
-
-	if resp.Error != nil {
-		return nil, resp.Error
-	}
-
-	addOutput := &struct {
-		Peers []string
-	}{}
-
-	err = json.NewDecoder(resp.Output).Decode(addOutput)
-	if err != nil {
-		return nil, err
-	}
+type PeersList struct {
+	Peers []string
+}
 
-	return addOutput.Peers, nil
+func (s *Shell) BootstrapAdd(peers []string) ([]string, error) {
+	var addOutput PeersList
+	err := s.Request("bootstrap/add", peers...).Exec(context.Background(), &addOutput)
+	return addOutput.Peers, err
 }
 
 func (s *Shell) BootstrapAddDefault() ([]string, error) {
-	resp, err := s.newRequest(context.Background(), "bootstrap/add/default").Send(s.httpcli)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Close()
-
-	if resp.Error != nil {
-		return nil, resp.Error
-	}
-
-	addOutput := &struct {
-		Peers []string
-	}{}
-
-	err = json.NewDecoder(resp.Output).Decode(addOutput)
-	if err != nil {
-		return nil, err
-	}
-
-	return addOutput.Peers, nil
+	var addOutput PeersList
+	err := s.Request("bootstrap/add/default").Exec(context.Background(), &addOutput)
+	return addOutput.Peers, err
 }
 
 func (s *Shell) BootstrapRmAll() ([]string, error) {
-	resp, err := s.newRequest(context.Background(), "bootstrap/rm/all").Send(s.httpcli)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Close()
-
-	rmAllOutput := &struct {
-		Peers []string
-	}{}
-
-	err = json.NewDecoder(resp.Output).Decode(rmAllOutput)
-	if err != nil {
-		return nil, err
-	}
-
-	return rmAllOutput.Peers, nil
+	var rmAllOutput PeersList
+	err := s.Request("bootstrap/rm/all").Exec(context.Background(), &rmAllOutput)
+	return rmAllOutput.Peers, err
 }

dag.go

@@ -3,7 +3,6 @@ package shell
 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -13,29 +12,10 @@ import (
 )
 
 func (s *Shell) DagGet(ref string, out interface{}) error {
-	req := s.newRequest(context.Background(), "dag/get")
-	req.Args = []string{ref}
-
-	resp, err := req.Send(s.httpcli)
-	if err != nil {
-		return err
-	}
-	defer resp.Close()
-
-	if resp.Error != nil {
-		return resp.Error
-	}
-
-	return json.NewDecoder(resp.Output).Decode(out)
+	return s.Request("dag/get", ref).Exec(context.Background(), out)
 }
 
 func (s *Shell) DagPut(data interface{}, ienc, kind string) (string, error) {
-	req := s.newRequest(context.Background(), "dag/put")
-	req.Opts = map[string]string{
-		"input-enc": ienc,
-		"format":    kind,
-	}
-
 	var r io.Reader
 	switch data := data.(type) {
 	case string:
@@ -47,31 +27,22 @@ func (s *Shell) DagPut(data interface{}, ienc, kind string) (string, error) {
 	default:
 		return "", fmt.Errorf("cannot current handle putting values of type %T", data)
 	}
+
 	rc := ioutil.NopCloser(r)
 	fr := files.NewReaderFile("", "", rc, nil)
 	slf := files.NewSliceFile("", "", []files.File{fr})
 	fileReader := files.NewMultiFileReader(slf, true)
-	req.Body = fileReader
-
-	resp, err := req.Send(s.httpcli)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Close()
-
-	if resp.Error != nil {
-		return "", resp.Error
-	}
 
 	var out struct {
 		Cid struct {
 			Target string `json:"/"`
 		}
 	}
-	err = json.NewDecoder(resp.Output).Decode(&out)
-	if err != nil {
-		return "", err
-	}
 
-	return out.Cid.Target, nil
+	return out.Cid.Target, s.
+		Request("dag/put").
+		Option("input-enc", ienc).
+		Option("format", kind).
+		Body(fileReader).
+		Exec(context.Background(), &out)
 }

ipns.go

@@ -1,10 +1,7 @@
 package shell
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
-	"strconv"
 	"time"
 )
 
@@ -15,79 +12,44 @@ type PublishResponse struct {
 
 // Publish updates a mutable name to point to a given value
 func (s *Shell) Publish(node string, value string) error {
-	args := []string{value}
+	var pubResp PublishResponse
+	req := s.Request("name/publish")
 	if node != "" {
-		args = []string{node, value}
+		req.Arguments(node)
 	}
+	req.Arguments(value)
 
-	resp, err := s.newRequest(context.Background(), "name/publish", args...).Send(s.httpcli)
-	if err != nil {
-		return err
-	}
-	defer resp.Close()
-
-	if resp.Error != nil {
-		return resp.Error
-	}
-
-	return nil
+	return req.Exec(context.Background(), &pubResp)
 }
 
 // PublishWithDetails is used for fine grained control over record publishing
 func (s *Shell) PublishWithDetails(contentHash, key string, lifetime, ttl time.Duration, resolve bool) (*PublishResponse, error) {
-
-	args := []string{contentHash}
-	req := s.newRequest(context.Background(), "name/publish", args...)
-	if key == "" {
-		key = "self"
+	var pubResp PublishResponse
+	req := s.Request("name/publish", contentHash).Option("resolve", resolve)
+	if key != "" {
+		req.Option("key", key)
 	}
-	req.Opts["key"] = key
-	if lifetime.Seconds() > 0 {
-		req.Opts["lifetime"] = lifetime.String()
+	if lifetime != 0 {
+		req.Option("lifetime", lifetime)
 	}
 	if ttl.Seconds() > 0 {
-		req.Opts["ttl"] = ttl.String()
+		req.Option("ttl", ttl)
 	}
-	req.Opts["resolve"] = strconv.FormatBool(resolve)
-	resp, err := req.Send(s.httpcli)
+	err := req.Exec(context.Background(), &pubResp)
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Close()
-	if resp.Error != nil {
-		return nil, resp.Error
-	}
-	buf := new(bytes.Buffer)
-	buf.ReadFrom(resp.Output)
-	var pubResp PublishResponse
-	json.Unmarshal(buf.Bytes(), &pubResp)
 	return &pubResp, nil
 }
 
 // Resolve gets resolves the string provided to an /ipns/[name]. If asked to
 // resolve an empty string, resolve instead resolves the node's own /ipns value.
 func (s *Shell) Resolve(id string) (string, error) {
-	var resp *Response
-	var err error
+	req := s.Request("name/resolve")
 	if id != "" {
-		resp, err = s.newRequest(context.Background(), "name/resolve", id).Send(s.httpcli)
-	} else {
-		resp, err = s.newRequest(context.Background(), "name/resolve").Send(s.httpcli)
-	}
-	if err != nil {
-		return "", err
-	}
-	defer resp.Close()
-
-	if resp.Error != nil {
-		return "", resp.Error
+		req.Arguments(id)
 	}
-
 	var out struct{ Path string }
-	err = json.NewDecoder(resp.Output).Decode(&out)
-	if err != nil {
-		return "", err
-	}
-
-	return out.Path, nil
+	err := req.Exec(context.Background(), &out)
+	return out.Path, err
 }

requestbuilder.go

@@ -74,7 +74,7 @@ func (r *RequestBuilder) Header(name, value string) *RequestBuilder {
 
 // 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 := NewRequest(ctx, r.shell.url, r.command, r.args...)
 	req.Opts = r.opts
 	req.Headers = r.headers
 	req.Body = r.body