func runTail(ctx *cli.Context) {
var duration time.Duration
var err error
if ctx.String("duration") != "" {
duration, err = time.ParseDuration(ctx.String("duration"))
if err != nil {
panic(err)
}
}
k, err := kinesumer.NewDefault(
ctx.String("stream"),
duration,
)
if err != nil {
panic(err)
}
k.Options.ErrHandler = kinesumer.ErrHandler(errHandler)
if redisURL := ctx.String(fRedisURL); len(redisURL) > 0 {
pool, err := redispool.NewRedisPool(redisURL)
if err != nil {
panic(err)
}
cp, err := redischeckpointer.New(&redischeckpointer.Options{
ReadOnly: true,
RedisPool: pool,
RedisPrefix: ctx.String(fRedisPrefix),
})
if err != nil {
panic(err)
}
k.Checkpointer = cp
}
_, err = k.Begin()
if err != nil {
panic(err)
}
defer k.End()
r := kinesumer.NewReader(k.Records())
io.Copy(os.Stdout, r)
}
func (s *kinesisLogsStreamer) StreamLogs(app *App, w io.Writer) error {
k, err := kinesumer.NewDefault(app.ID)
if err != nil {
return err
}
_, err = k.Begin()
if err != nil {
return err
}
defer k.End()
for {
rec := <-k.Records()
msg := append(rec.Data(), '\n')
if _, err := w.Write(msg); err != nil {
return err
}
}
}
func (s *KinesisLogsStreamer) StreamLogs(app *App, w io.Writer, duration time.Duration) error {
k, err := kinesumer.NewDefault(app.ID, duration)
if err != nil {
return fmt.Errorf("error initializing kinesumer: %v", err)
}
_, err = k.Begin()
if err != nil {
return fmt.Errorf("error starting kinesumer: %v", err)
}
defer k.End()
for {
rec := <-k.Records()
msg := append(rec.Data(), '\n')
if _, err := w.Write(msg); err != nil {
return fmt.Errorf("error writing kinesis record to log stream: %v", err)
}
}
}
func runTail(ctx *cli.Context) {
k, err := kinesumer.NewDefault(
ctx.String("stream"),
)
if err != nil {
panic(err)
}
k.Options.ErrHandler = ErrHandler
if redisURL := ctx.String(fRedisURL); len(redisURL) > 0 {
pool, err := redispool.NewRedisPool(redisURL)
if err != nil {
panic(err)
}
cp, err := redischeckpointer.New(&redischeckpointer.Options{
ReadOnly: true,
RedisPool: pool,
RedisPrefix: ctx.String(fRedisPrefix),
})
if err != nil {
panic(err)
}
k.Checkpointer = cp
}
_, err = k.Begin()
if err != nil {
panic(err)
}
defer k.End()
for {
rec := <-k.Records()
fmt.Println(string(rec.Data()))
}
}
func runStatus(ctx *cli.Context) {
k, err := kinesumer.NewDefault(
getStream(ctx),
time.Duration(0),
)
if err != nil {
panic(err)
}
var prov *redisprovisioner.Provisioner
var cp *redischeckpointer.Checkpointer
redis := false
if redisURL := ctx.String(fRedisURL); len(redisURL) > 0 {
pool, err := redispool.NewRedisPool(redisURL)
if err != nil {
panic(err)
}
prefix := ctx.String(fRedisPrefix)
prov, err = redisprovisioner.New(&redisprovisioner.Options{
TTL: time.Second,
RedisPool: pool,
RedisPrefix: prefix,
})
if err != nil {
panic(err)
}
cp, err = redischeckpointer.New(&redischeckpointer.Options{
ReadOnly: true,
RedisPool: pool,
RedisPrefix: prefix,
})
err = cp.Begin()
if err != nil {
panic(err)
}
defer cp.End()
redis = true
}
table := NewTable()
header := table.AddRowWith("Shard ID", "Status")
header.Header = true
if redis {
header.AddCellWithf("Worker")
header.AddCellWithf("Sequence Number")
}
shards, err := k.GetShards()
if err != nil {
panic(err)
}
for _, shard := range shards {
row := table.AddRow()
row.AddCellWithf("%s", *shard.ShardId)
if shard.SequenceNumberRange.EndingSequenceNumber == nil {
row.AddCellWithf("OPEN").Color = color.New(color.FgGreen)
} else {
row.AddCellWithf("CLOSED").Color = color.New(color.FgRed)
}
if redis {
cell := row.AddCell()
lock, err := prov.Check(*shard.ShardId)
if err != nil {
lock = err.Error()
cell.Color = color.New(color.FgRed)
}
cell.Printf("%s", lock)
seqStart := StrShorten(cp.GetStartSequence(*shard.ShardId), 8, 8)
cell = row.AddCell()
if len(seqStart) == 0 {
seqStart = "???"
cell.Color = color.New(color.FgRed)
}
cell.Printf("%s", seqStart)
}
}
table.Done()
}
func runShards(ctx *cli.Context) {
stream := getStream(ctx)
k, err := kinesumer.NewDefault(
stream,
time.Duration(0),
)
if err != nil {
panic(err)
}
shards, err := k.GetShards()
if err != nil {
panic(err)
}
if len(shards) == 0 {
fmt.Printf("No shards found on stream %s\n", stream)
}
keys := make(ShardHashEndpoints, 0)
for _, shard := range shards {
begin := &big.Int{}
begin.SetString(*shard.HashKeyRange.StartingHashKey, 10)
keys = append(keys, begin)
end := &big.Int{}
end.SetString(*shard.HashKeyRange.EndingHashKey, 10)
end.Add(end, big.NewInt(1))
keys = append(keys, end)
}
keys.UniqSort()
// Only support < 100 shards for now
maxShardIdLen := 0
for _, shard := range shards {
if maxShardIdLen < len(*shard.ShardId) {
maxShardIdLen = len(*shard.ShardId)
}
}
fmt.Printf("SHARD ID%s ", strings.Repeat(" ", maxShardIdLen-len("SHARD ID")))
for i := 0; i < len(keys); i++ {
if i < 10 {
fmt.Printf("%d ", i)
} else {
fmt.Printf("%d ", i)
}
}
fmt.Println()
for _, shard := range shards {
fmt.Printf("%s%s ", *shard.ShardId, strings.Repeat(" ", maxShardIdLen-len(*shard.ShardId)))
for _, key := range keys {
begin := &big.Int{}
begin.SetString(*shard.HashKeyRange.StartingHashKey, 10)
if key.Cmp(begin) < 0 {
fmt.Printf(" ")
continue
}
end := &big.Int{}
end.SetString(*shard.HashKeyRange.EndingHashKey, 10)
end.Add(end, big.NewInt(1))
if key.Cmp(end) < 0 {
fmt.Printf("o--")
} else {
fmt.Printf("o\n")
break
}
}
}
fmt.Printf("\nHash keys:\n")
for i, key := range keys {
fmt.Printf("%d: %s\n", i, key.String())
}
}
