etcdctlv3: unify txn interactive mode input with get/put/delete

etcdctlv3/command/txn_command.go

@@ -18,21 +18,31 @@ import (
 	"bufio"
 	"fmt"
 	"os"
+	"regexp"
 	"strconv"
 	"strings"
 
 	"github.com/coreos/etcd/Godeps/_workspace/src/github.com/spf13/cobra"
 	"github.com/coreos/etcd/Godeps/_workspace/src/golang.org/x/net/context"
 	"github.com/coreos/etcd/clientv3"
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+)
+
+var (
+	txnInteractive bool
+	txnHex         bool
 )
 
 // NewTxnCommand returns the cobra command for "txn".
 func NewTxnCommand() *cobra.Command {
-	return &cobra.Command{
-		Use:   "txn",
+	cmd := &cobra.Command{
+		Use:   "txn [options]",
 		Short: "Txn processes all the requests in one transaction.",
 		Run:   txnCommandFunc,
 	}
+	cmd.Flags().BoolVarP(&txnInteractive, "interactive", "i", false, "input transaction in interactive mode")
+	cmd.Flags().BoolVar(&txnHex, "hex", false, "print out key-values as hex encoded strings")
+	return cmd
 }
 
 // txnCommandFunc executes the "txn" command.
@@ -41,25 +51,26 @@ func txnCommandFunc(cmd *cobra.Command, args []string) {
 		ExitWithError(ExitBadArgs, fmt.Errorf("txn command does not accept argument."))
 	}
 
+	if !txnInteractive {
+		ExitWithError(ExitBadFeature, fmt.Errorf("txn command only supports interactive mode"))
+	}
+
 	reader := bufio.NewReader(os.Stdin)
 
 	txn := clientv3.NewKV(mustClientFromCmd(cmd)).Txn(context.Background())
-	fmt.Println("entry comparison[key target expected_result compare_value] (end with empty line):")
+	fmt.Println("compares:")
 	txn.If(readCompares(reader)...)
-	fmt.Println("entry success request[method key value(end_range)] (end with empty line):")
+	fmt.Println("success requests (get, put, delete):")
 	txn.Then(readOps(reader)...)
-	fmt.Println("entry failure request[method key value(end_range)] (end with empty line):")
+	fmt.Println("failure requests (get, put, delete):")
 	txn.Else(readOps(reader)...)
 
 	resp, err := txn.Commit()
 	if err != nil {
 		ExitWithError(ExitError, err)
 	}
-	if resp.Succeeded {
-		fmt.Println("executed success request list")
-	} else {
-		fmt.Println("executed failure request list")
-	}
+
+	printTxnResponse(*resp, txnHex)
 }
 
 func readCompares(r *bufio.Reader) (cmps []clientv3.Cmp) {
@@ -106,51 +117,65 @@ func readOps(r *bufio.Reader) (ops []clientv3.Op) {
 	return ops
 }
 
+func argify(s string) []string {
+	r := regexp.MustCompile("'.+'|\".+\"|\\S+")
+	return r.FindAllString(s, -1)
+}
+
 func parseRequestUnion(line string) (*clientv3.Op, error) {
-	parts := strings.Split(line, " ")
-	if len(parts) < 2 {
+	args := argify(line)
+	if len(args) < 2 {
 		return nil, fmt.Errorf("invalid txn compare request: %s", line)
 	}
 
-	op := &clientv3.Op{}
-	key := parts[1]
-	switch parts[0] {
-	case "r", "range":
-		if len(parts) == 3 {
-			*op = clientv3.OpGet(key, clientv3.WithRange(parts[2]))
-		} else {
-			*op = clientv3.OpGet(key)
-		}
-	case "p", "put":
-		*op = clientv3.OpPut(key, parts[2])
-	case "d", "deleteRange":
-		if len(parts) == 3 {
-			*op = clientv3.OpDelete(key, clientv3.WithRange(parts[2]))
-		} else {
-			*op = clientv3.OpDelete(key)
-		}
-	default:
+	opc := make(chan clientv3.Op, 1)
+
+	put := NewPutCommand()
+	put.Run = func(cmd *cobra.Command, args []string) {
+		key, value, opts := getPutOp(cmd, args)
+		opc <- clientv3.OpPut(key, value, opts...)
+	}
+	get := NewGetCommand()
+	get.Run = func(cmd *cobra.Command, args []string) {
+		key, opts := getGetOp(cmd, args)
+		opc <- clientv3.OpGet(key, opts...)
+	}
+	del := NewDelCommand()
+	del.Run = func(cmd *cobra.Command, args []string) {
+		key, opts := getDelOp(cmd, args)
+		opc <- clientv3.OpDelete(key, opts...)
+	}
+	cmds := &cobra.Command{SilenceErrors: true}
+	cmds.AddCommand(put, get, del)
+
+	cmds.SetArgs(args)
+	if err := cmds.Execute(); err != nil {
 		return nil, fmt.Errorf("invalid txn request: %s", line)
 	}
-	return op, nil
+
+	op := <-opc
+	return &op, nil
 }
 
 func parseCompare(line string) (*clientv3.Cmp, error) {
-	parts := strings.Split(line, " ")
-	if len(parts) != 4 {
-		return nil, fmt.Errorf("invalid txn compare request: %s", line)
+	var (
+		key string
+		op  string
+		val string
+	)
+
+	lparenSplit := strings.SplitN(line, "(", 2)
+	if len(lparenSplit) != 2 {
+		return nil, fmt.Errorf("malformed comparison: %s", line)
 	}
 
-	cmpType := ""
-	switch parts[2] {
-	case "g", "greater":
-		cmpType = ">"
-	case "e", "equal":
-		cmpType = "="
-	case "l", "less":
-		cmpType = "<"
-	default:
-		return nil, fmt.Errorf("invalid txn compare request: %s", line)
+	target := lparenSplit[0]
+	n, serr := fmt.Sscanf(lparenSplit[1], "%q) %s %q", &key, &op, &val)
+	if n != 3 {
+		return nil, fmt.Errorf("malformed comparison: %s; got %s(%q) %s %q", line, target, key, op, val)
+	}
+	if serr != nil {
+		return nil, fmt.Errorf("malformed comparison: %s (%v)", line, serr)
 	}
 
 	var (
@@ -158,23 +183,23 @@ func parseCompare(line string) (*clientv3.Cmp, error) {
 		err error
 		cmp clientv3.Cmp
 	)
-
-	key := parts[0]
-	switch parts[1] {
+	switch target {
 	case "ver", "version":
-		if v, err = strconv.ParseInt(parts[3], 10, 64); err != nil {
-			cmp = clientv3.Compare(clientv3.Version(key), cmpType, v)
+		if v, err = strconv.ParseInt(val, 10, 64); err == nil {
+			cmp = clientv3.Compare(clientv3.Version(key), op, v)
 		}
 	case "c", "create":
-		if v, err = strconv.ParseInt(parts[3], 10, 64); err != nil {
-			cmp = clientv3.Compare(clientv3.CreatedRevision(key), cmpType, v)
+		if v, err = strconv.ParseInt(val, 10, 64); err == nil {
+			cmp = clientv3.Compare(clientv3.CreatedRevision(key), op, v)
 		}
 	case "m", "mod":
-		if v, err = strconv.ParseInt(parts[3], 10, 64); err != nil {
-			cmp = clientv3.Compare(clientv3.ModifiedRevision(key), cmpType, v)
+		if v, err = strconv.ParseInt(val, 10, 64); err == nil {
+			cmp = clientv3.Compare(clientv3.ModifiedRevision(key), op, v)
 		}
 	case "val", "value":
-		cmp = clientv3.Compare(clientv3.Value(key), cmpType, parts[3])
+		cmp = clientv3.Compare(clientv3.Value(key), op, val)
+	default:
+		return nil, fmt.Errorf("malformed comparison: %s (unknown target %s)", line, target)
 	}
 
 	if err != nil {
@@ -183,3 +208,25 @@ func parseCompare(line string) (*clientv3.Cmp, error) {
 
 	return &cmp, nil
 }
+
+func printTxnResponse(resp clientv3.TxnResponse, isHex bool) {
+	if resp.Succeeded {
+		fmt.Println("SUCCESS")
+	} else {
+		fmt.Println("FAILURE")
+	}
+
+	for _, r := range resp.Responses {
+		fmt.Println("")
+		switch v := r.Response.(type) {
+		case *pb.ResponseUnion_ResponseDeleteRange:
+			printDeleteResponse((clientv3.DeleteResponse)(*v.ResponseDeleteRange))
+		case *pb.ResponseUnion_ResponsePut:
+			printPutResponse((clientv3.PutResponse)(*v.ResponsePut))
+		case *pb.ResponseUnion_ResponseRange:
+			printGetResponse(((clientv3.GetResponse)(*v.ResponseRange)), isHex)
+		default:
+			fmt.Printf("unexpected response %+v\n", r)
+		}
+	}
+}