Beispiel #1
0
func receivedCmd(client receivedClient) *hadfield.Command {
	var page int

	cmd := &hadfield.Command{
		Usage: "received [options]",
		Short: "lists received messages",
		Long: `
  Received displays a list of received messages.

    --page NUM       # Display given page
`,
		Run: func(cmd *hadfield.Command, args []string) {
			resp, err := client.Received()
			if err != nil {
				log.Fatal(err)
			}

			pretty.PrettyPrint(resp.Messages)
		},
	}

	cmd.Flag.IntVar(&page, "page", 0, "")

	return cmd
}
Beispiel #2
0
func sentCmd(client sentClient) *hadfield.Command {
	var page int

	cmd := &hadfield.Command{
		Usage: "sent [options]",
		Short: "lists sent messages",
		Long: `
  Sent displays a list of sent messages.

    --page NUM       # Display given page
`,
		Run: func(cmd *hadfield.Command, args []string) {
			resp, err := client.Sent(pageOpts(page))
			if err != nil {
				log.Fatal(err)
			}

			pretty.PrettyPrint(resp.Messages)
		},
	}

	cmd.Flag.IntVar(&page, "page", 1, "")

	return cmd
}
Beispiel #3
0
func accountsCmd(client *xesende.Client) *hadfield.Command {
	return &hadfield.Command{
		Usage: "accounts",
		Short: "list accounts",
		Long: `
  List accounts available to the user.
`,
		Run: func(cmd *hadfield.Command, args []string) {
			resp, err := client.Accounts()
			if err != nil {
				log.Fatal(err)
			}

			pretty.PrettyPrint(resp.Accounts)
		},
	}
}
Beispiel #4
0
func messageCmd(client *xesende.Client) *hadfield.Command {
	return &hadfield.Command{
		Usage: "message MESSAGEID",
		Short: "displays a message",
		Long: `
  Message displays the details for a message.
`,
		Run: func(cmd *hadfield.Command, args []string) {
			if len(args) < 1 {
				log.Fatal("Require MESSAGEID parameter")
			}

			resp, err := client.Message(args[0])
			if err != nil {
				log.Fatal(err)
			}

			pretty.PrettyPrint(resp)
		},
	}
}
Beispiel #5
0
func sendCmd(client *xesende.AccountClient) *hadfield.Command {
	return &hadfield.Command{
		Usage: "send TO BODY",
		Short: "send messages",
		Long: `
  Send a single sms message.
`,
		Run: func(cmd *hadfield.Command, args []string) {
			resp, err := client.Send([]xesende.Message{
				{
					To:   args[0],
					Body: args[1],
				},
			})

			if err != nil {
				log.Fatal(err)
			}

			pretty.PrettyPrint(resp)
		},
	}
}
Beispiel #6
0
func main() {
	env := flag.String("env", "", "select environment/profile")
	debug := flag.Bool("debug", false, "enable/disable debug mode")
	prompt := flag.Bool("prompt", true, "enable/disable prompt")

	flag.Parse()

	var nextKey dynago.AttributeNameValue

	config := ReadConfig(CONFIG_FILE, *env)
	selected := config.Dynago.Profile
	profile := config.Profile[selected]
	if profile == nil {
		log.Fatal("no profile for ", selected)
	}

	if *debug {
		httpclient.StartLogging(true, true)
	}

	if len(profile.URL) > 0 {
		db.SetRegionAndURL(profile.Region, profile.URL)
	} else if len(profile.Region) > 0 {
		db.SetRegion(profile.Region)
	}

	if len(profile.AccessKey) > 0 {
		db.SetCredentials(profile.AccessKey, profile.SecretKey)
	}

	commander := &cmd.Cmd{HistoryFile: HISTORY_FILE, Complete: CompletionFunction, EnableShell: true}
	if *prompt {
		commander.Prompt = "dynagosh> "
	} else {
		commander.Prompt = "\n"
	}

	commander.Init()

	commander.Add(cmd.Command{"config",
		`
		config : display current configuration
		`,
		func(string) (stop bool) {
			pretty.PrettyPrint(config)
			return
		},
		nil})

	commander.Add(cmd.Command{"list",
		`
                list : display list of available tables
                `,
		func(string) (stop bool) {
			tables, err := db.ListTables()

			if err != nil {
				fmt.Println(err)
				return
			}

			if len(tables) > 0 {
				fmt.Println("Available tables")

				for _, tableName := range tables {
					fmt.Println("  ", tableName)
				}

				table_list = tables
			} else {
				fmt.Println("No available tables")
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"describe",
		`
                describe {table} : display table configuration
                `,
		func(line string) (stop bool) {
			var tableName string

			if len(line) > 0 {
				tableName = line
			} else if selected_table != nil {
				tableName = selected_table.Name
			} else {
				fmt.Println("nothing to describe")
				return
			}

			if table, err := db.DescribeTable(tableName); err != nil {
				fmt.Println(err)
			} else {
				pretty.PrettyPrint(table)
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"use",
		`
                use {table} : select table for queries
                `,
		func(line string) (stop bool) {
			if len(line) > 0 {
				tableName := line
				table, err := db.GetTable(tableName)
				if err != nil {
					fmt.Println(err)
				} else {
					selected_table = table
					if *prompt {
						commander.Prompt = "dynagosh: " + tableName + "> "
					}
				}
			}

			if selected_table != nil {
				fmt.Println("using", selected_table.Name)
			} else {
				fmt.Println("no table selected")
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"create",
		`
		create --table=name --hash=name:type [--range=name:type] [--attrs=name:type,name:type] [--rc=readCapacity] [--wc=writeCapacity] [--streams=streamView]
		`,
		func(line string) (stop bool) {
			flags := args.NewFlags("create")

			tableName := flags.String("table", "", "table name")
			hashKey := flags.String("hash", "", "hash key name")
			rangeKey := flags.String("range", "", "range key name")
			rc := flags.Int("rc", 1, "read capacity")
			wc := flags.Int("wc", 1, "write capacity")
			streamView := flags.String("streams", "no", "stream view (all|new|old|keys|no)")

			attributes := AttrDefinitions{attrs: []dynago.AttributeDefinition{}}
			flags.Var(&attributes, "attrs", "attributes definition")

			keys := []string{}

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			if len(*tableName) == 0 {
				fmt.Println("missing table name")
				return
			}

			if len(*hashKey) == 0 {
				fmt.Println("missing hash key")
				return
			}

			keys = append(keys, *hashKey)

			if len(*rangeKey) == 0 {
				keys = append(keys, *rangeKey)
			}

			switch *streamView {
			case "old":
				*streamView = dynago.STREAM_VIEW_OLD
			case "new":
				*streamView = dynago.STREAM_VIEW_NEW
			case "all":
				*streamView = dynago.STREAM_VIEW_ALL
			case "keys":
				*streamView = dynago.STREAM_VIEW_KEYS
			case "no", "":
				*streamView = dynago.STREAM_VIEW_DISABLED
			}

			if table, err := db.CreateTable(*tableName,
				attributes.attrs,
				keys,
				*rc, *wc, *streamView); err != nil {
				fmt.Println(err)
			} else {
				pretty.PrettyPrint(table)
				addTable(*tableName)
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"drop",
		`
                drop {table} : delete table
                `,
		func(line string) (stop bool) {
			tableName := line
			table, err := db.DeleteTable(tableName)
			if err != nil {
				fmt.Println(err)
			} else {
				pretty.PrettyPrint(table)
				removeTable(tableName)
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"updateTable",
		`
		updateTable {tablename} readCapacity writeCapacity streamView
		`,
		func(line string) (stop bool) {
			flags := args.NewFlags("updateTable")

			tableName := flags.String("table", "", "table name")
			rc := flags.Int("rc", 0, "read capacity")
			wc := flags.Int("wc", 0, "write capacity")
			streamView := flags.String("streams", "no", "stream view (all|new|old|keys|no)")

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			if len(*tableName) == 0 {
				fmt.Println("missing table name")
				return
			}

			switch *streamView {
			case "old":
				*streamView = dynago.STREAM_VIEW_OLD
			case "new":
				*streamView = dynago.STREAM_VIEW_NEW
			case "all":
				*streamView = dynago.STREAM_VIEW_ALL
			case "keys":
				*streamView = dynago.STREAM_VIEW_KEYS
			case "no", "":
				*streamView = dynago.STREAM_VIEW_DISABLED
			}

			if *rc <= 0 && *wc <= 0 && len(*streamView) == 0 {
				fmt.Println("no valid value for rc, wc or streamView")
				return
			}

			if *rc <= 0 {
				*rc = 0 // table.ProvisionedThroughput.ReadCapacityUnits
			}

			if *wc <= 0 {
				*wc = 0 // table.ProvisionedThroughput.WriteCapacityUnits
			}

			if table, err := db.UpdateTable(*tableName, *rc, *wc, *streamView); err != nil {
				fmt.Println(err)
			} else {
				pretty.PrettyPrint(table)
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"put",
		`
                put [--table=tablename] [--condition={condition-expression} [--names={expression-names}] [--values={expression-values}]] {item}
                `,
		func(line string) (stop bool) {
			flags := args.NewFlags("put")
			tableName := flags.String("table", "", "table name")
			condition := flags.String("condition", "", "condition expression")
			names := flags.String("names", "", `attribute names (json: {"x.y.x": "#n"}`)
			values := flags.String("values", "", `expression values (json: {":name": value})`)

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			args := flags.Args()

			if len(args) != 1 {
				fmt.Println("one parameter (javascript object) required")
				return
			}

			table := getTable(*tableName)
			if table == nil {
				return
			}

			var item map[string]interface{}
			var nlist map[string]string
			var vlist map[string]interface{}

			if len(*names) > 0 {
				if err := json.Unmarshal([]byte(*names), &nlist); err != nil {
					fmt.Printf("can't parse %q %v\n", *names, err)
					return
				}
			}

			if len(*values) > 0 {
				if err := json.Unmarshal([]byte(*values), &vlist); err != nil {
					fmt.Printf("can't parse %q %v\n", *values, err)
					return
				}
			}

			if err := json.Unmarshal([]byte(args[0]), &item); err != nil {
				fmt.Printf("can't parse %q %v\n", args[0], err)
				return
			}

			if item, consumed, err := table.PutItem(
				dynago.Item(item),
				dynago.ConditionExpression(*condition),
				dynago.ExpressionAttributeNames(nlist),
				dynago.ExpressionAttributeValues(vlist),
				dynago.ReturnValues(dynago.RETURN_ALL_OLD),
				dynago.ReturnConsumed(dynago.RETURN_TOTAL_CONSUMED)); err != nil {
				fmt.Println(err)
			} else {
				pretty.PrettyPrint(item)
				fmt.Println("consumed:", consumed)
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"remove",
		`
		remove [--table=tablename] --hash=hashKey [--range=rangeKey]
		`,
		func(line string) (stop bool) {
			flags := args.NewFlags("remove")
			tableName := flags.String("table", "", "table name")
			hashKey := flags.String("hash", "", "hash key")
			rangeKey := flags.String("range", "", "range key")

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			table := getTable(*tableName)
			if table == nil {
				return
			}

			if len(*hashKey) == 0 {
				fmt.Println("hash key is required")
				return
			}

			if table.HashRange() {
				if len(*rangeKey) == 0 {
					fmt.Println("range key is required")
					return
				}
			} else {
				*rangeKey = ""
			}

			if item, consumed, err := table.DeleteItem(
				*hashKey,
				*rangeKey,
				dynago.ReturnValues(dynago.RETURN_ALL_OLD),
				dynago.ReturnConsumed(dynago.RETURN_TOTAL_CONSUMED)); err != nil {
				fmt.Println(err)
			} else {
				pretty.PrettyPrint(item)
				fmt.Println("consumed:", consumed)
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"update",
		`
		update [--table=tablename] --hash=hashKey [--range=rangeKey] [--condition={condition-expression} [--names={expression-names}]] [--values={expression-values}] {update-expression} 
		`,
		func(line string) (stop bool) {
			flags := args.NewFlags("remove")
			tableName := flags.String("table", "", "table name")
			hashKey := flags.String("hash", "", "hash key")
			rangeKey := flags.String("range", "", "range key")
			condition := flags.String("condition", "", "condition expression")
			names := flags.String("names", "", `attribute names (json: {"x.y.x": "#n"}`)
			values := flags.String("values", "", `expression values (json: {":name": value})`)

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			table := getTable(*tableName)
			if table == nil {
				return
			}

			if len(*hashKey) == 0 {
				fmt.Println("hash key is required")
				return
			}

			if table.HashRange() {
				if len(*rangeKey) == 0 {
					fmt.Println("range key is required")
					return
				}
			} else {
				*rangeKey = ""
			}

			var nlist map[string]string
			var vlist map[string]interface{}

			if len(*names) > 0 {
				if err := json.Unmarshal([]byte(*names), &nlist); err != nil {
					fmt.Printf("can't parse %q %v\n", *names, err)
					return
				}
			}

			if len(*values) > 0 {
				if err := json.Unmarshal([]byte(*values), &vlist); err != nil {
					fmt.Printf("can't parse %q %v\n", *values, err)
					return
				}
			}

			args := flags.Args()

			updates := args[0]

			if item, consumed, err := table.UpdateItem(
				*hashKey,
				*rangeKey,
				updates,
				dynago.ConditionExpression(*condition),
				dynago.ExpressionAttributeNames(nlist),
				dynago.ExpressionAttributeValues(vlist),
				dynago.ReturnValues(dynago.RETURN_ALL_OLD),
				dynago.ReturnConsumed(dynago.RETURN_TOTAL_CONSUMED)); err != nil {
				fmt.Println(err)
			} else {
				pretty.PrettyPrint(item)
				fmt.Println("consumed:", consumed)
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"get",
		`
		get [--table=tablename] --hash=hashKey [--range=rangeKey] [attributes]
		`,
		func(line string) (stop bool) {
			flags := args.NewFlags("remove")
			tableName := flags.String("table", "", "table name")
			hashKey := flags.String("hash", "", "hash key")
			rangeKey := flags.String("range", "", "range key")

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			table := getTable(*tableName)
			if table == nil {
				return
			}

			if len(*hashKey) == 0 {
				fmt.Println("hash key is required")
				return
			}

			if table.HashRange() {
				if len(*rangeKey) == 0 {
					fmt.Println("range key is required")
					return
				}
			} else {
				*rangeKey = ""
			}

			attributes := flags.Args()

			if item, consumed, err := table.GetItem(*hashKey, *rangeKey, attributes, false, true); err != nil {
				fmt.Println(err)
			} else if len(attributes) > 0 {
				for _, n := range attributes {
					fmt.Print(" ", item[n])
				}
				fmt.Println()
			} else {
				pretty.PrettyPrint(item)
				fmt.Println("consumed:", consumed)
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"query",
		`
		query [--table=tablename] [--limit=pagesize] [--next] [--count] [--consumed] --hash hash-key-value [--range[-rangeop] range-key-value]
		`,
		func(line string) (stop bool) {
			flags := args.NewFlags("query")

			tableName := flags.String("table", "", "table name")
			limit := flags.Int("limit", 0, "maximum number of items per page")
			count := flags.Bool("count", false, "only return item count")
			next := flags.Bool("next", false, "get next page")
			consumed := flags.Bool("consumed", false, "return consumed capacity")
			filter := flags.String("filter", "", "filter expression")
			projection := flags.String("projection", "", "projection expression")

			hashKey := flags.String("hash", "", "hash-key value")

			var rangeCond RangeCondition

			flags.Var(&RangeParam{"EQ", &rangeCond, false}, "range", "range-key value")
			flags.Var(&RangeParam{"EQ", &rangeCond, false}, "range-eq", "range-key equal value")
			flags.Var(&RangeParam{"NE", &rangeCond, false}, "range-ne", "range-key not-equal value")
			flags.Var(&RangeParam{"LE", &rangeCond, false}, "range-le", "range-key less-or-equal value")
			flags.Var(&RangeParam{"LT", &rangeCond, false}, "range-lt", "range-key less-than value")
			flags.Var(&RangeParam{"GE", &rangeCond, false}, "range-ge", "range-key less-or-equal value")
			flags.Var(&RangeParam{"GT", &rangeCond, false}, "range-gt", "range-key less-than value")
			flags.Var(&RangeParam{"CONTAINS", &rangeCond, false}, "range-contains", "range-key contains value")
			flags.Var(&RangeParam{"NOT_CONTAINS", &rangeCond, false}, "range-not-contains", "range-key not-contains value")
			flags.Var(&RangeParam{"BEGINS_WITH", &rangeCond, false}, "range-begins-with", "range-key begins-with value")
			flags.Var(&RangeParam{"NULL", &rangeCond, true}, "range-null", "range-key is null")
			flags.Var(&RangeParam{"NOT_NULL", &rangeCond, true}, "range-not-null", "range-key is-not null")

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			args := flags.Args()

			table := getTable(*tableName)
			if table == nil {
				return
			}

			if len(*hashKey) < 1 {
				if len(args) < 1 {
					fmt.Println("not enough arguments")
					return
				}

				*hashKey = args[0]

				if len(rangeCond.Operator) < 1 && len(args) > 1 {
					rangeCond.Operator = "EQ"
					rangeCond.Value = args[1]
				}
			}

			query := table.Query(*hashKey)

			if len(rangeCond.Operator) > 0 {
				switch rangeCond.Operator {
				case "NULL", "NOT_NULL":
					query.SetAttrCondition(table.RangeKey().Condition(rangeCond.Operator))
				default:
					query.SetAttrCondition(table.RangeKey().Condition(rangeCond.Operator, rangeCond.Value))
				}
			}

			query.SetFilterExpression(*filter)
			query.SetProjectionExpression(*projection)

			if *limit > 0 {
				query.SetLimit(*limit)
			}

			if *count {
				query.SetSelect(dynago.SELECT_COUNT)
			}

			if *next {
				query.SetStartKey(nextKey)
			}

			if *consumed {
				query.SetConsumed(true)
			}

			if items, lastKey, consumed, err := query.Exec(nil); err != nil {
				fmt.Println(err)
			} else {
				pretty.PrettyPrint(items)
				fmt.Println("consumed:", consumed)

				nextKey = lastKey
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"scan",
		`
		scan [--table=tablename] [--limit=pagesize] [--next] [--count] [--consumed] [--format=pretty|compact|json] [--segment=n --total=m]
		`,
		func(line string) (stop bool) {
			flags := args.NewFlags("scan")

			tableName := flags.String("table", "", "table name")
			limit := flags.Int("limit", 0, "maximum number of items per page")
			count := flags.Bool("count", false, "only return item count")
			cons := flags.Bool("consumed", false, "return consumed capacity")
			segment := flags.Int("segment", 0, "segment number")
			total := flags.Int("total", 0, "total segment")
			delay := flags.Duration("delay", 0, "delay (as duration string) between scan requests")
			format := flags.String("format", "pretty", "output format: pretty, compact or json")
			max := flags.Int("max", 0, "maximum number of items to fetch - 0: one page, -1: all items")
			next := flags.Bool("next", false, "get next page")
			start := flags.String("start", "", "start from this key")
			projection := flags.String("projection", "", "projection expression")
			filter := flags.String("filter", "", "filter expression")
			names := flags.String("names", "", `attribute names (json: {"x.y.x": "#n"}`)
			values := flags.String("values", "", `expression values (json: {":name": value})`)

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			table := getTable(*tableName)
			if table == nil {
				return
			}

			scan := dynago.ScanTable(table)

			scan.SetFilterExpression(*filter)
			scan.SetProjectionExpression(*projection)

			if len(*names) > 0 {
				var nlist map[string]string
				if err := json.Unmarshal([]byte(*names), &nlist); err != nil {
					fmt.Printf("can't parse %q %v\n", *names, err)
					return
				}

				scan.SetAttributeNames(nlist)
			}

			if len(*values) > 0 {
				var vlist map[string]interface{}
				if err := json.Unmarshal([]byte(*values), &vlist); err != nil {
					fmt.Printf("can't parse %q %v\n", *values, err)
					return
				}

				scan.SetAttributeValues(vlist)
			}

			if *segment != 0 || *total != 0 {
				scan.SetSegment(*segment, *total)
			}

			if *limit > 0 {
				scan.SetLimit(*limit)
			}

			if *cons {
				scan.SetConsumed(true)
			}

			if *count {
				if totalCount, scanCount, consumed, err := scan.CountWithDelay(db, *delay); err != nil {
					log.Println(err)
				} else {
					fmt.Println("count:", totalCount)
					fmt.Println("scan count:", scanCount)
					if *cons {
						fmt.Println("consumed:", consumed)
					}
				}

				return
			}

			if *max != 0 { // if fetching multiple pages
				*next = true
			}

			if len(*start) > 0 {
				if *debug {
					log.Println("start from", *start)
				}

				if err := json.Unmarshal([]byte(*start), &nextKey); err != nil {
					fmt.Printf("can't parse %q %v\n", *start, err)
					return
				}
			}

			remaining := *max
			errors := 0

			for {
				if *next {
					scan.SetStartKey(nextKey)
				}

				if *debug {
					log.Printf("request: %#v\n", scan)
				}

				items, lastKey, consumed, err := scan.Exec(db)
				if err != nil {
					log.Printf("%T %#v", err, err)

					if !networkError(err) {
						break
					} else {
						errors += 1
						if errors > 10 {
							break
						}
					}
				} else {
					errors = 0

					if *format == "compact" {
						p := &pretty.Pretty{Indent: "", Out: os.Stdout, NilString: "null"}
						for _, i := range items {
							p.Println(i)
						}
					} else if *format == "json" {
						for _, i := range items {
							fmt.Println(jsonString(i))
						}
					} else {
						pretty.PrettyPrint(items)
					}

					if *cons {
						log.Println("count:", len(items))
						log.Println("consumed:", consumed)
					}

					if remaining > 0 {
						if len(items) > remaining {
							remaining = 0
						} else {
							remaining -= len(items)
						}
					}

					nextKey = lastKey

					if (remaining == 0) || len(nextKey) == 0 {
						break
					}
				}

				if *delay > 0 {
					if *debug {
						log.Println(jsonString(nextKey), consumed)
					}

					time.Sleep(*delay)
				}
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"listStreams",
		`
                listStreams : display list of available streams
                `,
		func(line string) (stop bool) {
			flags := args.NewFlags("listStreams")

			tableName := flags.String("table", "", "table name")
			limit := flags.Int("limit", 0, "maximum number of items per page")

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			options := []dynago.ListStreamsOption{}

			if len(*tableName) > 0 {
				options = append(options, dynago.LsTable(*tableName))
			}

			if *limit > 0 {
				options = append(options, dynago.LsLimit(*limit))
			}

			streams, err := db.ListStreams(options...)

			if err != nil {
				fmt.Println(err)
				return
			}

			if len(streams) > 0 {
				fmt.Println("Available streams")

				for i, s := range streams {
					fmt.Println(i, s)
				}

				stream_list = streams
			} else {
				fmt.Println("No available streams")
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"describeStream",
		`
                describeStream {streamId} : display stream information
                `,
		func(line string) (stop bool) {
			flags := args.NewFlags("describeStream")

			start := flags.String("start", "", "start from this shard id")
			limit := flags.Int("limit", 0, "maximum number of items per page")

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			args := flags.Args()
			if len(args) != 1 {
				fmt.Println("one argument required")
				return
			}

			streamId := getStream(args[0])

			options := []dynago.DescribeStreamOption{}

			if len(*start) > 0 {
				options = append(options, dynago.DsStart(*start))
			}

			if *limit > 0 {
				options = append(options, dynago.DsLimit(*limit))
			}

			stream, err := db.DescribeStream(streamId, options...)
			if err != nil {
				fmt.Println(err)
				return
			} else {
				pretty.PrettyPrint(stream)
			}

			return
		},
		nil})

	commander.Add(cmd.Command{"streamRecords",
		`
                streamRecords {streamId} : display stream records
                `,
		func(line string) (stop bool) {
			flags := args.NewFlags("streamRecords")

			limit := flags.Int("limit", 0, "maximum number of items per page")
			itype := flags.String("type", "last", "shard iterator type (last, latest, at, after)")
			iseq := flags.String("seq", "", "sequence number")
			verbose := flags.Bool("verbose", false, "display full records")

			//follow := flags.Bool("follow", false, "follow iterator")
			//wait := flags.Duration("wait", time.Second, "time to wait if --follow and no new records")
			//iter := flags.String("iter", "", "use this shard iterator")
			//shardId := flags.String("shard", "", "shard id")

			if err := args.ParseFlags(flags, line); err != nil {
				return
			}

			switch *itype {
			case "at":
				*itype = dynago.AT_SEQUENCE
			case "after":
				*itype = dynago.AFTER_SEQUENCE
			case "last":
				*itype = dynago.LAST
			case "latest":
				*itype = dynago.LATEST
			}

			args := flags.Args()
			if len(args) == 0 {
				fmt.Println("missing stream id")
				return
			}

			streamId := getStream(args[0])
			stream, err := db.DescribeStream(streamId)
			if err != nil {
				fmt.Println(err)
				return
			}

			for _, shard := range stream.Shards {
				last := len(shard.SequenceNumberRange.EndingSequenceNumber) == 0

				iterator, err := db.GetShardIterator(streamId, shard.ShardId, *itype, *iseq)
				if err != nil {
					fmt.Println(err)
					return
				}

				for {
					records, err := db.GetRecords(iterator, *limit)
					if err != nil {
						fmt.Println(err)
						return
					} else {
						if *verbose {
							pretty.PrettyPrint(records)
						} else {
							for _, r := range records.Records {
								op := r.EventName
								values := r.Dynamodb
								s := values.SequenceNumber

								switch values.StreamViewType {
								case dynago.STREAM_VIEW_OLD:
									if len(values.OldImage) > 0 {
										fmt.Println(s, op, pretty.PrettyFormat(values.OldImage))
									} else {
										fmt.Println(s, op, "key", pretty.PrettyFormat(values.Keys))
									}

								case dynago.STREAM_VIEW_NEW:
									if len(values.NewImage) > 0 {
										fmt.Println(s, op, pretty.PrettyFormat(values.NewImage))
									} else {
										fmt.Println(s, op, "key", pretty.PrettyFormat(values.Keys))
									}

								case dynago.STREAM_VIEW_KEYS:
									fmt.Println(s, op, pretty.PrettyFormat(values.Keys))

								case dynago.STREAM_VIEW_ALL:
									fmt.Println(s, op,
										"old", pretty.PrettyFormat(values.OldImage),
										"new", pretty.PrettyFormat(values.NewImage))
								}

							}

						}

						iterator = records.NextShardIterator
					}

					if len(iterator) == 0 || last {
						break
					}
				}
			}

			return
		},
		nil})

	commander.Commands["modify"] = commander.Commands["updateTable"]
	commander.Commands["dt"] = commander.Commands["describe"]
	commander.Commands["ls"] = commander.Commands["list"]
	commander.Commands["rm"] = commander.Commands["remove"]
	commander.Commands["lss"] = commander.Commands["listStreams"]
	commander.Commands["ds"] = commander.Commands["describeStream"]
	commander.Commands["lsr"] = commander.Commands["streamRecords"]

	commander.CmdLoop()
}