Merge pull request #262 from jbenet/cmd-ref-part1

Commands Refactor Part 1

commands/argument.go

+package commands
+
+type ArgumentType int
+
+const (
+	ArgString ArgumentType = iota
+	ArgFile
+)
+
+type Argument struct {
+	Name     string
+	Type     ArgumentType
+	Required bool
+	Variadic bool
+}

commands/cli/parse.go

 package cli
 
 import (
+	"errors"
 	"fmt"
+	"os"
 	"strings"
 
-	"github.com/jbenet/go-ipfs/commands"
+	cmds "github.com/jbenet/go-ipfs/commands"
 )
 
 // Parse parses the input commandline string (cmd, flags, and args).
 // returns the corresponding command Request object.
-func Parse(input []string, root *commands.Command) (commands.Request, error) {
-	path, input := parsePath(input, root)
-	opts, args, err := parseOptions(input)
+func Parse(input []string, roots ...*cmds.Command) (cmds.Request, *cmds.Command, error) {
+	var root, cmd *cmds.Command
+	var path, stringArgs []string
+	var opts map[string]interface{}
+
+	// use the root that matches the longest path (most accurately matches request)
+	maxLength := 0
+	for _, r := range roots {
+		p, i, c := parsePath(input, r)
+		o, s, err := parseOptions(i)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		length := len(p)
+		if length > maxLength {
+			maxLength = length
+			root = r
+			path = p
+			cmd = c
+			opts = o
+			stringArgs = s
+		}
+	}
+
+	if maxLength == 0 {
+		return nil, nil, errors.New("Not a valid subcommand")
+	}
+
+	args, err := parseArgs(stringArgs, cmd)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req := cmds.NewRequest(path, opts, args, cmd)
+
+	err = cmd.CheckArguments(req)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
-	return commands.NewRequest(path, opts, args, nil), nil
+	return req, root, nil
 }
 
-// parsePath gets the command path from the command line input
-func parsePath(input []string, root *commands.Command) ([]string, []string) {
+// parsePath separates the command path and the opts and args from a command string
+// returns command path slice, rest slice, and the corresponding *cmd.Command
+func parsePath(input []string, root *cmds.Command) ([]string, []string, *cmds.Command) {
 	cmd := root
 	i := 0
 
@@ -29,15 +66,16 @@ func parsePath(input []string, root *commands.Command) ([]string, []string) {
 			break
 		}
 
-		cmd := cmd.Subcommand(blob)
-		if cmd == nil {
+		sub := cmd.Subcommand(blob)
+		if sub == nil {
 			break
 		}
+		cmd = sub
 
 		i++
 	}
 
-	return input[:i], input[i:]
+	return input[:i], input[i:], cmd
 }
 
 // parseOptions parses the raw string values of the given options
@@ -77,3 +115,27 @@ func parseOptions(input []string) (map[string]interface{}, []string, error) {
 
 	return opts, args, nil
 }
+
+func parseArgs(stringArgs []string, cmd *cmds.Command) ([]interface{}, error) {
+	var argDef cmds.Argument
+	args := make([]interface{}, len(stringArgs))
+
+	for i, arg := range stringArgs {
+		if i < len(cmd.Arguments) {
+			argDef = cmd.Arguments[i]
+		}
+
+		if argDef.Type == cmds.ArgString {
+			args[i] = arg
+
+		} else {
+			in, err := os.Open(arg)
+			if err != nil {
+				return nil, err
+			}
+			args[i] = in
+		}
+	}
+
+	return args, nil
+}

commands/cli/parse_test.go

@@ -8,12 +8,13 @@ import (
 )
 
 func TestOptionParsing(t *testing.T) {
+	subCmd := &commands.Command{}
 	cmd := &commands.Command{
 		Options: []commands.Option{
 			commands.Option{Names: []string{"b"}, Type: commands.String},
 		},
 		Subcommands: map[string]*commands.Command{
-			"test": &commands.Command{},
+			"test": subCmd,
 		},
 	}
 
@@ -37,11 +38,14 @@ func TestOptionParsing(t *testing.T) {
 		t.Error("Should have failed (duplicate option name)")
 	}
 
-	path, args := parsePath([]string{"test", "beep", "boop"}, cmd)
+	path, args, sub := parsePath([]string{"test", "beep", "boop"}, cmd)
 	if len(path) != 1 || path[0] != "test" {
 		t.Errorf("Returned path was defferent than expected: %v", path)
 	}
 	if len(args) != 2 || args[0] != "beep" || args[1] != "boop" {
 		t.Errorf("Returned args were different than expected: %v", args)
 	}
+	if sub != subCmd {
+		t.Errorf("Returned command was different than expected")
+	}
 }

commands/command.go

@@ -3,6 +3,7 @@ package commands
 import (
 	"errors"
 	"fmt"
+	"io"
 	"strings"
 
 	u "github.com/jbenet/go-ipfs/util"
@@ -12,20 +13,35 @@ var log = u.Logger("command")
 
 // Function is the type of function that Commands use.
 // It reads from the Request, and writes results to the Response.
-type Function func(Request, Response)
+type Function func(Response, Request)
+
+// Marshaller is a function that takes in a Response, and returns a marshalled []byte
+// (or an error on failure)
+type Marshaller func(Response) ([]byte, error)
+
+// TODO: check Argument definitions when creating a Command
+//   (might need to use a Command constructor)
+//   * make sure any variadic args are at the end
+//   * make sure there aren't duplicate names
+//   * make sure optional arguments aren't followed by required arguments
 
 // Command is a runnable command, with input arguments and options (flags).
 // It can also have Subcommands, to group units of work into sets.
 type Command struct {
 	Help        string
 	Options     []Option
+	Arguments   []Argument
 	Run         Function
+	Marshallers map[EncodingType]Marshaller
+	Type        interface{}
 	Subcommands map[string]*Command
 }
 
 // ErrNotCallable signals a command that cannot be called.
 var ErrNotCallable = errors.New("This command can't be called directly. Try one of its subcommands.")
 
+var ErrNoFormatter = errors.New("This command cannot be formatted to plain text")
+
 // Call invokes the command for the given Request
 func (c *Command) Call(req Request) Response {
 	res := NewResponse(req)
@@ -42,6 +58,12 @@ func (c *Command) Call(req Request) Response {
 		return res
 	}
 
+	err = cmd.CheckArguments(req)
+	if err != nil {
+		res.SetError(err, ErrClient)
+		return res
+	}
+
 	options, err := c.GetOptions(req.Path())
 	if err != nil {
 		res.SetError(err, ErrClient)
@@ -54,7 +76,7 @@ func (c *Command) Call(req Request) Response {
 		return res
 	}
 
-	cmd.Run(req, res)
+	cmd.Run(res, req)
 
 	return res
 }
@@ -116,7 +138,72 @@ func (c *Command) GetOptions(path []string) (map[string]Option, error) {
 	return optionsMap, nil
 }
 
+func (c *Command) CheckArguments(req Request) error {
+	args := req.Arguments()
+	argDefs := c.Arguments
+
+	// if we have more arg values provided than argument definitions,
+	// and the last arg definition is not variadic (or there are no definitions), return an error
+	notVariadic := len(argDefs) == 0 || !argDefs[len(argDefs)-1].Variadic
+	if notVariadic && len(args) > len(argDefs) {
+		return fmt.Errorf("Expected %v arguments, got %v", len(argDefs), len(args))
+	}
+
+	// iterate over the arg definitions
+	for i, argDef := range c.Arguments {
+
+		// the value for this argument definition. can be nil if it wasn't provided by the caller
+		var v interface{}
+		if i < len(args) {
+			v = args[i]
+		}
+
+		err := checkArgValue(v, argDef)
+		if err != nil {
+			return err
+		}
+
+		// any additional values are for the variadic arg definition
+		if argDef.Variadic && i < len(args)-1 {
+			for _, val := range args[i+1:] {
+				err := checkArgValue(val, argDef)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
 // Subcommand returns the subcommand with the given id
 func (c *Command) Subcommand(id string) *Command {
 	return c.Subcommands[id]
 }
+
+// checkArgValue returns an error if a given arg value is not valid for the given Argument
+func checkArgValue(v interface{}, def Argument) error {
+	if v == nil {
+		if def.Required {
+			return fmt.Errorf("Argument '%s' is required", def.Name)
+		}
+
+		return nil
+	}
+
+	if def.Type == ArgFile {
+		_, ok := v.(io.Reader)
+		if !ok {
+			return fmt.Errorf("Argument '%s' isn't valid", def.Name)
+		}
+
+	} else if def.Type == ArgString {
+		_, ok := v.(string)
+		if !ok {
+			return fmt.Errorf("Argument '%s' must be a string", def.Name)
+		}
+	}
+
+	return nil
+}

commands/command_test.go

@@ -8,20 +8,13 @@ func TestOptionValidation(t *testing.T) {
 			Option{[]string{"b", "beep"}, Int},
 			Option{[]string{"B", "boop"}, String},
 		},
-		Run: func(req Request, res Response) {},
+		Run: func(res Response, req Request) {},
 	}
 
 	req := NewEmptyRequest()
-	req.SetOption("foo", 5)
-	res := cmd.Call(req)
-	if res.Error() == nil {
-		t.Error("Should have failed (unrecognized option)")
-	}
-
-	req = NewEmptyRequest()
 	req.SetOption("beep", 5)
 	req.SetOption("b", 10)
-	res = cmd.Call(req)
+	res := cmd.Call(req)
 	if res.Error() == nil {
 		t.Error("Should have failed (duplicate options)")
 	}
@@ -56,6 +49,13 @@ func TestOptionValidation(t *testing.T) {
 		t.Error("Should have passed")
 	}
 
+	req = NewEmptyRequest()
+	req.SetOption("foo", 5)
+	res = cmd.Call(req)
+	if res.Error() != nil {
+		t.Error("Should have passed")
+	}
+
 	req = NewEmptyRequest()
 	req.SetOption(EncShort, "json")
 	res = cmd.Call(req)
@@ -79,7 +79,7 @@ func TestOptionValidation(t *testing.T) {
 }
 
 func TestRegistration(t *testing.T) {
-	noop := func(req Request, res Response) {}
+	noop := func(res Response, req Request) {}
 
 	cmdA := &Command{
 		Options: []Option{

commands/http/client.go

+package http
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+
+	cmds "github.com/jbenet/go-ipfs/commands"
+)
+
+const (
+	ApiUrlFormat = "http://%s%s/%s?%s"
+	ApiPath      = "/api/v0" // TODO: make configurable
+)
+
+// Client is the commands HTTP client interface.
+type Client interface {
+	Send(req cmds.Request) (cmds.Response, error)
+}
+
+type client struct {
+	serverAddress string
+}
+
+func NewClient(address string) Client {
+	return &client{address}
+}
+
+func (c *client) Send(req cmds.Request) (cmds.Response, error) {
+	var userEncoding string
+	if enc, found := req.Option(cmds.EncShort); found {
+		userEncoding = enc.(string)
+		req.SetOption(cmds.EncShort, cmds.JSON)
+	} else {
+		enc, _ := req.Option(cmds.EncLong)
+		userEncoding = enc.(string)
+		req.SetOption(cmds.EncLong, cmds.JSON)
+	}
+
+	query, inputStream, err := getQuery(req)
+	if err != nil {
+		return nil, err
+	}
+
+	path := strings.Join(req.Path(), "/")
+	url := fmt.Sprintf(ApiUrlFormat, c.serverAddress, ApiPath, path, query)
+
+	httpRes, err := http.Post(url, "application/octet-stream", inputStream)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := getResponse(httpRes, req)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(userEncoding) > 0 {
+		req.SetOption(cmds.EncShort, userEncoding)
+		req.SetOption(cmds.EncLong, userEncoding)
+	}
+
+	return res, nil
+}
+
+func getQuery(req cmds.Request) (string, io.Reader, error) {
+	// TODO: handle multiple files with multipart
+	var inputStream io.Reader
+
+	query := url.Values{}
+	for k, v := range req.Options() {
+		query.Set(k, v.(string))
+	}
+
+	args := req.Arguments()
+	argDefs := req.Command().Arguments
+	var argDef cmds.Argument
+
+	for i, arg := range args {
+		if i < len(argDefs) {
+			argDef = argDefs[i]
+		}
+
+		if argDef.Type == cmds.ArgString {
+			query.Add("arg", arg.(string))
+
+		} else {
+			// TODO: multipart
+			if inputStream != nil {
+				return "", nil, fmt.Errorf("Currently, only one file stream is possible per request")
+			}
+			inputStream = arg.(io.Reader)
+		}
+	}
+
+	return query.Encode(), inputStream, nil
+}
+
+// getResponse decodes a http.Response to create a cmds.Response
+func getResponse(httpRes *http.Response, req cmds.Request) (cmds.Response, error) {
+	var err error
+	res := cmds.NewResponse(req)
+
+	contentType := httpRes.Header["Content-Type"][0]
+	contentType = strings.Split(contentType, ";")[0]
+
+	if contentType == "application/octet-stream" {
+		res.SetOutput(httpRes.Body)
+		return res, nil
+	}
+
+	dec := json.NewDecoder(httpRes.Body)
+
+	if httpRes.StatusCode >= http.StatusBadRequest {
+		e := cmds.Error{}
+
+		if httpRes.StatusCode == http.StatusNotFound {
+			// handle 404s
+			e.Message = "Command not found."
+			e.Code = cmds.ErrClient
+
+		} else if contentType == "text/plain" {
+			// handle non-marshalled errors
+			buf := bytes.NewBuffer(nil)
+			io.Copy(buf, httpRes.Body)
+			e.Message = string(buf.Bytes())
+			e.Code = cmds.ErrNormal
+
+		} else {
+			// handle marshalled errors
+			err = dec.Decode(&e)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		res.SetError(e, e.Code)
+
+	} else {
+		v := req.Command().Type
+		err = dec.Decode(&v)
+		if err != nil {
+			return nil, err
+		}
+
+		res.SetOutput(v)
+	}
+
+	return res, nil
+}

commands/http/handler.go

+package http
+
+import (
+	"errors"
+	"io"
+	"net/http"
+
+	cmds "github.com/jbenet/go-ipfs/commands"
+)
+
+type Handler struct {
+	ctx  cmds.Context
+	root *cmds.Command
+}
+
+var ErrNotFound = errors.New("404 page not found")
+
+var mimeTypes = map[string]string{
+	cmds.JSON: "application/json",
+	cmds.XML:  "application/xml",
+	cmds.Text: "text/plain",
+}
+
+func NewHandler(ctx cmds.Context, root *cmds.Command) *Handler {
+	return &Handler{ctx, root}
+}
+
+func (i Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	req, err := Parse(r, i.root)
+	if err != nil {
+		if err == ErrNotFound {
+			w.WriteHeader(http.StatusNotFound)
+		} else {
+			w.WriteHeader(http.StatusBadRequest)
+		}
+		w.Write([]byte(err.Error()))
+		return
+	}
+	req.SetContext(i.ctx)
+
+	// call the command
+	res := i.root.Call(req)
+
+	// set the Content-Type based on res output
+	if _, ok := res.Output().(io.Reader); ok {
+		// TODO: set based on actual Content-Type of file
+		w.Header().Set("Content-Type", "application/octet-stream")
+	} else {
+		enc, _ := req.Option(cmds.EncShort)
+		encStr, ok := enc.(string)
+		if !ok {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		mime := mimeTypes[encStr]
+		w.Header().Set("Content-Type", mime)
+	}
+
+	// if response contains an error, write an HTTP error status code
+	if e := res.Error(); e != nil {
+		if e.Code == cmds.ErrClient {
+			w.WriteHeader(http.StatusBadRequest)
+		} else {
+			w.WriteHeader(http.StatusInternalServerError)
+		}
+	}
+
+	out, err := res.Reader()
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		w.Header().Set("Content-Type", "text/plain")
+		w.Write([]byte(err.Error()))
+		return
+	}
+
+	io.Copy(w, out)
+}

commands/http/parse.go

+package http
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	cmds "github.com/jbenet/go-ipfs/commands"
+)
+
+// Parse parses the data in a http.Request and returns a command Request object
+func Parse(r *http.Request, root *cmds.Command) (cmds.Request, error) {
+	if !strings.HasPrefix(r.URL.Path, ApiPath) {
+		return nil, errors.New("Unexpected path prefix")
+	}
+	path := strings.Split(strings.TrimPrefix(r.URL.Path, ApiPath+"/"), "/")
+
+	stringArgs := make([]string, 0)
+
+	cmd, err := root.Get(path[:len(path)-1])
+	if err != nil {
+		// 404 if there is no command at that path
+		return nil, ErrNotFound
+
+	} else if sub := cmd.Subcommand(path[len(path)-1]); sub == nil {
+		if len(path) <= 1 {
+			return nil, ErrNotFound
+		}
+
+		// if the last string in the path isn't a subcommand, use it as an argument
+		// e.g. /objects/Qabc12345 (we are passing "Qabc12345" to the "objects" command)
+		stringArgs = append(stringArgs, path[len(path)-1])
+		path = path[:len(path)-1]
+
+	} else {
+		cmd = sub
+	}
+
+	opts, stringArgs2 := parseOptions(r)
+	stringArgs = append(stringArgs, stringArgs2...)
+
+	// Note that the argument handling here is dumb, it does not do any error-checking.
+	// (Arguments are further processed when the request is passed to the command to run)
+	args := make([]interface{}, 0)
+
+	for _, arg := range cmd.Arguments {
+		if arg.Type == cmds.ArgString {
+			if arg.Variadic {
+				for _, s := range stringArgs {
+					args = append(args, s)
+				}
+
+			} else if len(stringArgs) > 0 {
+				args = append(args, stringArgs[0])
+				stringArgs = stringArgs[1:]
+
+			} else {
+				break
+			}
+
+		} else {
+			// TODO: create multipart streams for file args
+			args = append(args, r.Body)
+		}
+	}
+
+	req := cmds.NewRequest(path, opts, args, cmd)
+
+	err = cmd.CheckArguments(req)
+	if err != nil {
+		return nil, err
+	}
+
+	return req, nil
+}
+
+func parseOptions(r *http.Request) (map[string]interface{}, []string) {
+	opts := make(map[string]interface{})
+	var args []string
+
+	query := r.URL.Query()
+	for k, v := range query {
+		if k == "arg" {
+			args = v
+		} else {
+			opts[k] = v[0]
+		}
+	}
+
+	// default to setting encoding to JSON
+	_, short := opts[cmds.EncShort]
+	_, long := opts[cmds.EncLong]
+	if !short && !long {
+		opts[cmds.EncShort] = cmds.JSON
+	}
+
+	return opts, args
+}

commands/request.go

@@ -2,21 +2,31 @@ package commands
 
 import (
 	"fmt"
-	"io"
 	"reflect"
 	"strconv"
+
+	"github.com/jbenet/go-ipfs/config"
+	"github.com/jbenet/go-ipfs/core"
 )
 
 type optMap map[string]interface{}
 
+type Context struct {
+	ConfigRoot string
+	Config     *config.Config
+	Node       *core.IpfsNode
+}
+
 // Request represents a call to a command from a consumer
 type Request interface {
 	Path() []string
 	Option(name string) (interface{}, bool)
+	Options() map[string]interface{}
 	SetOption(name string, val interface{})
-	Arguments() []string
-	Stream() io.Reader
-	SetStream(io.Reader)
+	Arguments() []interface{} // TODO: make argument value type instead of using interface{}
+	Context() *Context
+	SetContext(Context)
+	Command() *Command
 
 	ConvertOptions(options map[string]Option) error
 }
@@ -24,8 +34,9 @@ type Request interface {
 type request struct {
 	path      []string
 	options   optMap
-	arguments []string
-	in        io.Reader
+	arguments []interface{}
+	cmd       *Command
+	ctx       Context
 }
 
 // Path returns the command path of this request
@@ -39,24 +50,35 @@ func (r *request) Option(name string) (interface{}, bool) {
 	return val, err
 }
 
+// Options returns a copy of the option map
+func (r *request) Options() map[string]interface{} {
+	output := make(optMap)
+	for k, v := range r.options {
+		output[k] = v
+	}
+	return output
+}
+
 // SetOption sets the value of the option for given name.
 func (r *request) SetOption(name string, val interface{}) {
 	r.options[name] = val
 }
 
 // Arguments returns the arguments slice
-func (r *request) Arguments() []string {
+func (r *request) Arguments() []interface{} {
 	return r.arguments
 }
 
-// Stream returns the input stream Reader
-func (r *request) Stream() io.Reader {
-	return r.in
+func (r *request) Context() *Context {
+	return &r.ctx
+}
+
+func (r *request) SetContext(ctx Context) {
+	r.ctx = ctx
 }
 
-// SetStream sets the value of the input stream Reader
-func (r *request) SetStream(in io.Reader) {
-	r.in = in
+func (r *request) Command() *Command {
+	return r.cmd
 }
 
 type converter func(string) (interface{}, error)
@@ -85,7 +107,7 @@ func (r *request) ConvertOptions(options map[string]Option) error {
 	for k, v := range r.options {
 		opt, ok := options[k]
 		if !ok {
-			return fmt.Errorf("Unrecognized option: '%s'", k)
+			continue
 		}
 
 		kind := reflect.TypeOf(v).Kind()
@@ -129,7 +151,7 @@ func NewEmptyRequest() Request {
 }
 
 // NewRequest returns a request initialized with given arguments
-func NewRequest(path []string, opts optMap, args []string, in io.Reader) Request {
+func NewRequest(path []string, opts optMap, args []interface{}, cmd *Command) Request {
 	if path == nil {
 		path = make([]string, 0)
 	}
@@ -137,7 +159,7 @@ func NewRequest(path []string, opts optMap, args []string, in io.Reader) Request
 		opts = make(map[string]interface{})
 	}
 	if args == nil {
-		args = make([]string, 0)
+		args = make([]interface{}, 0)
 	}
-	return &request{path, opts, args, in}
+	return &request{path, opts, args, cmd, Context{}}
 }

commands/response.go

 package commands
 
 import (
+	"bytes"
 	"encoding/json"
 	"encoding/xml"
 	"fmt"
@@ -25,7 +26,7 @@ type Error struct {
 }
 
 func (e Error) Error() string {
-	return fmt.Sprintf("%d error: %s", e.Code, e.Message)
+	return e.Message
 }
 
 // EncodingType defines a supported encoding
@@ -35,16 +36,23 @@ type EncodingType string
 const (
 	JSON = "json"
 	XML  = "xml"
+	Text = "text"
 	// TODO: support more encoding types
 )
 
-// Marshaller is a function used by coding types.
-// TODO this should just be a `coding.Codec`
-type Marshaller func(v interface{}) ([]byte, error)
-
 var marshallers = map[EncodingType]Marshaller{
-	JSON: json.Marshal,
-	XML:  xml.Marshal,
+	JSON: func(res Response) ([]byte, error) {
+		if res.Error() != nil {
+			return json.Marshal(res.Error())
+		}
+		return json.Marshal(res.Output())
+	},
+	XML: func(res Response) ([]byte, error) {
+		if res.Error() != nil {
+			return xml.Marshal(res.Error())
+		}
+		return xml.Marshal(res.Output())
+	},
 }
 
 // Response is the result of a command request. Handlers write to the response,
@@ -54,44 +62,40 @@ type Response interface {
 
 	// Set/Return the response Error
 	SetError(err error, code ErrorType)
-	Error() error
+	Error() *Error
 
 	// Sets/Returns the response value
-	SetValue(interface{})
-	Value() interface{}
+	SetOutput(interface{})
+	Output() interface{}
 
 	// Marshal marshals out the response into a buffer. It uses the EncodingType
 	// on the Request to chose a Marshaller (Codec).
 	Marshal() ([]byte, error)
+
+	// Gets a io.Reader that reads the marshalled output
+	Reader() (io.Reader, error)
 }
 
 type response struct {
 	req   Request
 	err   *Error
 	value interface{}
-	out   io.Writer
+	out   io.Reader
 }
 
 func (r *response) Request() Request {
 	return r.req
 }
 
-func (r *response) Value() interface{} {
+func (r *response) Output() interface{} {
 	return r.value
 }
 
-func (r *response) SetValue(v interface{}) {
+func (r *response) SetOutput(v interface{}) {
 	r.value = v
 }
 
-func (r *response) Stream() io.Writer {
-	return r.out
-}
-
-func (r *response) Error() error {
-	if r.err == nil {
-		return nil
-	}
+func (r *response) Error() *Error {
 	return r.err
 }
 
@@ -101,24 +105,52 @@ func (r *response) SetError(err error, code ErrorType) {
 
 func (r *response) Marshal() ([]byte, error) {
 	if r.err == nil && r.value == nil {
-		return nil, fmt.Errorf("No error or value set, there is nothing to marshal")
+		return []byte{}, nil
 	}
 
-	enc, ok := r.req.Option(EncShort)
-	if !ok || enc.(string) == "" {
+	enc, found := r.req.Option(EncShort)
+	encStr, ok := enc.(string)
+	if !found || !ok || encStr == "" {
 		return nil, fmt.Errorf("No encoding type was specified")
 	}
-	encType := EncodingType(strings.ToLower(enc.(string)))
+	encType := EncodingType(strings.ToLower(encStr))
+
+	var marshaller Marshaller
+	if r.req.Command() != nil && r.req.Command().Marshallers != nil {
+		marshaller = r.req.Command().Marshallers[encType]
+	}
+	if marshaller == nil {
+		marshaller, ok = marshallers[encType]
+		if !ok {
+			return nil, fmt.Errorf("No marshaller found for encoding type '%s'", enc)
+		}
+	}
+
+	return marshaller(r)
+}
 
-	marshaller, ok := marshallers[encType]
-	if !ok {
-		return nil, fmt.Errorf("No marshaller found for encoding type '%s'", enc)
+// Reader returns an `io.Reader` representing marshalled output of this Response
+// Note that multiple calls to this will return a reference to the same io.Reader
+func (r *response) Reader() (io.Reader, error) {
+	// if command set value to a io.Reader, use that as our reader
+	if r.out == nil {
+		if out, ok := r.value.(io.Reader); ok {
+			r.out = out
+		}
 	}
 
-	if r.err != nil {
-		return marshaller(r.err)
+	if r.out == nil {
+		// no reader set, so marshal the error or value
+		marshalled, err := r.Marshal()
+		if err != nil {
+			return nil, err
+		}
+
+		// create a Reader from the marshalled data
+		r.out = bytes.NewReader(marshalled)
 	}
-	return marshaller(r.value)
+
+	return r.out, nil
 }
 
 // NewResponse returns a response to match given Request

commands/response_test.go

@@ -14,7 +14,7 @@ func TestMarshalling(t *testing.T) {
 	req := NewEmptyRequest()
 
 	res := NewResponse(req)
-	res.SetValue(TestOutput{"beep", "boop", 1337})
+	res.SetOutput(TestOutput{"beep", "boop", 1337})
 
 	// get command global options so we can set the encoding option
 	cmd := Command{}