lmika/dynamo-browse
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Merge pull request #3 from lmika/feature/ssm-browse

Browse source 
Added ssm-browse and slog-view
This commit is contained in:
Leon Mika 2022-03-31 20:59:12 +11:00 committed by GitHub
parent 46be54b5fb 452a9ba707
commit e5ad3957b0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
48 changed files with 1626 additions and 450 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
cmd/dynamo-browse/main.go
View file

@ -9,6 +9,7 @@ import (
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/awstools/internal/common/ui/commandctrl"
"github.com/lmika/awstools/internal/common/ui/logging"
"github.com/lmika/awstools/internal/dynamo-browse/controllers"
"github.com/lmika/awstools/internal/dynamo-browse/providers/dynamo"
"github.com/lmika/awstools/internal/dynamo-browse/services/tables"
@ -43,28 +44,18 @@ func main() {
tableService := tables.NewService(dynamoProvider)
tableReadController := controllers.NewTableReadController(tableService, *flagTable)
tableWriteController := controllers.NewTableWriteController(tableService, tableReadController, *flagTable)
_ = tableWriteController
tableWriteController := controllers.NewTableWriteController(tableService, tableReadController)
commandController := commandctrl.NewCommandController(map[string]commandctrl.Command{
"q": commandctrl.NoArgCommand(tea.Quit),
//"rw": tableWriteController.ToggleReadWrite(),
//"dup": tableWriteController.Duplicate(),
})
model := ui.NewModel(tableReadController, commandController)
commandController := commandctrl.NewCommandController()
model := ui.NewModel(tableReadController, tableWriteController, commandController)
// Pre-determine if layout has dark background. This prevents calls for creating a list to hang.
lipgloss.HasDarkBackground()
p := tea.NewProgram(model, tea.WithAltScreen())
f, err := tea.LogToFile("debug.log", "debug")
if err != nil {
fmt.Println("fatal:", err)
os.Exit(1)
}
defer f.Close()
closeFn := logging.EnableLogging()
defer closeFn()
log.Println("launching")
if err := p.Start(); err != nil {
@ -72,12 +63,3 @@ func main() {
os.Exit(1)
}
}
//
//type msgLoopback struct {
// program *tea.Program
//}
//
//func (m *msgLoopback) Send(msg tea.Msg) {
// m.program.Send(msg)
//}

51
cmd/slog-view/main.go Normal file
View file

@ -0,0 +1,51 @@
package main
import (
"flag"
"fmt"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/awstools/internal/common/ui/commandctrl"
"github.com/lmika/awstools/internal/common/ui/logging"
"github.com/lmika/awstools/internal/slog-view/services/logreader"
"github.com/lmika/awstools/internal/slog-view/controllers"
"github.com/lmika/awstools/internal/slog-view/ui"
"github.com/lmika/gopkgs/cli"
"os"
)
func main() {
flag.Parse()
if flag.NArg() == 0 {
cli.Fatal("usage: slog-view LOGFILE")
}
// Pre-determine if layout has dark background. This prevents calls for creating a list to hang.
lipgloss.HasDarkBackground()
closeFn := logging.EnableLogging()
defer closeFn()
service := logreader.NewService()
ctrl := controllers.NewLogFileController(service, flag.Arg(0))
cmdController := commandctrl.NewCommandController()
//cmdController.AddCommands(&commandctrl.CommandContext{
// Commands: map[string]commandctrl.Command{
// "cd": func(args []string) tea.Cmd {
// return ctrl.ChangePrefix(args[0])
// },
// },
//})
model := ui.NewModel(ctrl, cmdController)
p := tea.NewProgram(model, tea.WithAltScreen())
if err := p.Start(); err != nil {
fmt.Printf("Alas, there's been an error: %v", err)
os.Exit(1)
}
}

55
cmd/ssm-browse/main.go Normal file
View file

@ -0,0 +1,55 @@
package main
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/ssm"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/awstools/internal/common/ui/commandctrl"
"github.com/lmika/awstools/internal/common/ui/logging"
"github.com/lmika/awstools/internal/ssm-browse/controllers"
"github.com/lmika/awstools/internal/ssm-browse/providers/awsssm"
"github.com/lmika/awstools/internal/ssm-browse/services/ssmparameters"
"github.com/lmika/awstools/internal/ssm-browse/ui"
"github.com/lmika/gopkgs/cli"
"os"
)
func main() {
// Pre-determine if layout has dark background. This prevents calls for creating a list to hang.
lipgloss.HasDarkBackground()
closeFn := logging.EnableLogging()
defer closeFn()
cfg, err := config.LoadDefaultConfig(context.Background())
if err != nil {
cli.Fatalf("cannot load AWS config: %v", err)
}
ssmClient := ssm.NewFromConfig(cfg)
provider := awsssm.NewProvider(ssmClient)
service := ssmparameters.NewService(provider)
ctrl := controllers.New(service)
cmdController := commandctrl.NewCommandController()
cmdController.AddCommands(&commandctrl.CommandContext{
Commands: map[string]commandctrl.Command{
"cd": func(args []string) tea.Cmd {
return ctrl.ChangePrefix(args[0])
},
},
})
model := ui.NewModel(ctrl, cmdController)
p := tea.NewProgram(model, tea.WithAltScreen())
if err := p.Start(); err != nil {
fmt.Printf("Alas, there's been an error: %v", err)
os.Exit(1)
}
}

9
go.mod
View file

@ -5,7 +5,7 @@ go 1.18
require (
github.com/alecthomas/participle/v2 v2.0.0-alpha7
github.com/asdine/storm v2.1.2+incompatible
github.com/aws/aws-sdk-go-v2 v1.15.0
github.com/aws/aws-sdk-go-v2 v1.16.1
github.com/aws/aws-sdk-go-v2/config v1.13.1
github.com/aws/aws-sdk-go-v2/credentials v1.8.0
github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue v1.8.0
@ -27,16 +27,17 @@ require (
require (
github.com/atotto/clipboard v0.1.4 // indirect
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.10.0 // indirect
github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.6 // indirect
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.0 // indirect
github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.8 // indirect
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.2 // indirect
github.com/aws/aws-sdk-go-v2/internal/ini v1.3.5 // indirect
github.com/aws/aws-sdk-go-v2/service/dynamodbstreams v1.13.0 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.0 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.7.0 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.7.0 // indirect
github.com/aws/aws-sdk-go-v2/service/ssm v1.24.0 // indirect
github.com/aws/aws-sdk-go-v2/service/sso v1.9.0 // indirect
github.com/aws/aws-sdk-go-v2/service/sts v1.14.0 // indirect
github.com/aws/smithy-go v1.11.1 // indirect
github.com/aws/smithy-go v1.11.2 // indirect
github.com/containerd/console v1.0.3 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/jmespath/go-jmespath v0.4.0 // indirect

10
go.sum
View file

@ -10,6 +10,8 @@ github.com/aws/aws-sdk-go-v2 v1.13.0 h1:1XIXAfxsEmbhbj5ry3D3vX+6ZcUYvIqSm4CWWEuG
github.com/aws/aws-sdk-go-v2 v1.13.0/go.mod h1:L6+ZpqHaLbAaxsqV0L4cvxZY7QupWJB4fhkf8LXvC7w=
github.com/aws/aws-sdk-go-v2 v1.15.0 h1:f9kWLNfyCzCB43eupDAk3/XgJ2EpgktiySD6leqs0js=
github.com/aws/aws-sdk-go-v2 v1.15.0/go.mod h1:lJYcuZZEHWNIb6ugJjbQY1fykdoobWbOS7kJYb4APoI=
github.com/aws/aws-sdk-go-v2 v1.16.1 h1:udzee98w8H6ikRgtFdVN9JzzYEbi/quFfSvduZETJIU=
github.com/aws/aws-sdk-go-v2 v1.16.1/go.mod h1:ytwTPBG6fXTZLxxeeCCWj2/EMYp/xDUgX+OET6TLNNU=
github.com/aws/aws-sdk-go-v2/config v1.13.1 h1:yLv8bfNoT4r+UvUKQKqRtdnvuWGMK5a82l4ru9Jvnuo=
github.com/aws/aws-sdk-go-v2/config v1.13.1/go.mod h1:Ba5Z4yL/UGbjQUzsiaN378YobhFo0MLfueXGiOsYtEs=
github.com/aws/aws-sdk-go-v2/credentials v1.8.0 h1:8Ow0WcyDesGNL0No11jcgb1JAtE+WtubqXjgxau+S0o=
@ -22,10 +24,14 @@ github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.4 h1:CRiQJ4E2RhfDdqbie1
github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.4/go.mod h1:XHgQ7Hz2WY2GAn//UXHofLfPXWh+s62MbMOijrg12Lw=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.6 h1:xiGjGVQsem2cxoIX61uRGy+Jux2s9C/kKbTrWLdrU54=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.6/go.mod h1:SSPEdf9spsFgJyhjrXvawfpyzrXHBCUe+2eQ1CjC1Ak=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.8 h1:CDaO90VZVBAL1sK87S5oSPIrp7yZqORv1hPIi2UsTMk=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.8/go.mod h1:LnTQMTqbKsbtt+UI5+wPsB7jedW+2ZgozoPG8k6cMxg=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.2.0 h1:3ADoioDMOtF4uiK59vCpplpCwugEU+v4ZFD29jDL3RQ=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.2.0/go.mod h1:BsCSJHx5DnDXIrOcqB8KN1/B+hXLG/bi4Y6Vjcx/x9E=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.0 h1:bt3zw79tm209glISdMRCIVRCwvSDXxgAxh5KWe2qHkY=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.0/go.mod h1:viTrxhAuejD+LszDahzAE2x40YjYWhMqzHxv2ZiWaME=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.2 h1:XXR3cdOcKRCTZf6ctcqpMf+go1BdzTm6+T9Ul5zxcMI=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.2/go.mod h1:1x4ZP3Z8odssdhuLI+/1Tqw6Pt/VAaP4Tr8EUxHvPXE=
github.com/aws/aws-sdk-go-v2/internal/ini v1.3.5 h1:ixotxbfTCFpqbuwFv/RcZwyzhkxPSYDYEMcj4niB5Uk=
github.com/aws/aws-sdk-go-v2/internal/ini v1.3.5/go.mod h1:R3sWUqPcfXSiF/LSFJhjyJmpg9uV6yP2yv3YZZjldVI=
github.com/aws/aws-sdk-go-v2/service/dynamodb v1.15.0 h1:qnx+WyIH9/AD+wAxi05WCMNanO236ceqHg6hChCWs3M=
@ -40,6 +46,8 @@ github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.7.0 h1:4QAOB3KrvI
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.7.0/go.mod h1:K/qPe6AP2TGYv4l6n7c88zh9jWBDf6nHhvg1fx/EWfU=
github.com/aws/aws-sdk-go-v2/service/sqs v1.16.0 h1:dzWS4r8E9bA0TesHM40FSAtedwpTVCuTsLI8EziSqyk=
github.com/aws/aws-sdk-go-v2/service/sqs v1.16.0/go.mod h1:IBTQMG8mtyj37OWg7vIXcg714Ntcb/LlYou/rZpvV1k=
github.com/aws/aws-sdk-go-v2/service/ssm v1.24.0 h1:p22U2yL/AeRToERGcZv1R26Yci5VQnWIrpzcZdG54cg=
github.com/aws/aws-sdk-go-v2/service/ssm v1.24.0/go.mod h1:chcyLYBEVRac/7rWJsD6cUHUR2osROwavvNqCplfwog=
github.com/aws/aws-sdk-go-v2/service/sso v1.9.0 h1:1qLJeQGBmNQW3mBNzK2CFmrQNmoXWrscPqsrAaU1aTA=
github.com/aws/aws-sdk-go-v2/service/sso v1.9.0/go.mod h1:vCV4glupK3tR7pw7ks7Y4jYRL86VvxS+g5qk04YeWrU=
github.com/aws/aws-sdk-go-v2/service/sts v1.14.0 h1:ksiDXhvNYg0D2/UFkLejsaz3LqpW5yjNQ8Nx9Sn2c0E=
@ -48,6 +56,8 @@ github.com/aws/smithy-go v1.10.0 h1:gsoZQMNHnX+PaghNw4ynPsyGP7aUCqx5sY2dlPQsZ0w=
github.com/aws/smithy-go v1.10.0/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E=
github.com/aws/smithy-go v1.11.1 h1:IQ+lPZVkSM3FRtyaDox41R8YS6iwPMYIreejOgPW49g=
github.com/aws/smithy-go v1.11.1/go.mod h1:3xHYmszWVx2c0kIwQeEVf9uSm4fYZt67FBJnwub1bgM=
github.com/aws/smithy-go v1.11.2 h1:eG/N+CcUMAvsdffgMvjMKwfyDzIkjM6pfxMJ8Mzc6mE=
github.com/aws/smithy-go v1.11.2/go.mod h1:3xHYmszWVx2c0kIwQeEVf9uSm4fYZt67FBJnwub1bgM=
github.com/brianvoe/gofakeit/v6 v6.15.0 h1:lJPGJZ2/07TRGDazyTzD5b18N3y4tmmJpdhCUw18FlI=
github.com/brianvoe/gofakeit/v6 v6.15.0/go.mod h1:Ow6qC71xtwm79anlwKRlWZW6zVq9D2XHE4QSSMP/rU8=
github.com/calyptia/go-bubble-table v0.1.0 h1:mXpaaBlrHGH4K8v5PvM8YqBFT9jlysS1YOycU2u3gEQ=

26
internal/common/ui/commandctrl/commandctrl.go
View file

@ -9,15 +9,20 @@ import (
)
type CommandController struct {
commands map[string]Command
commandList *CommandContext
}
func NewCommandController(commands map[string]Command) *CommandController {
func NewCommandController() *CommandController {
return &CommandController{
commands: commands,
commandList: nil,
}
}
func (c *CommandController) AddCommands(ctx *CommandContext) {
ctx.parent = c.commandList
c.commandList = ctx
}
func (c *CommandController) Prompt() tea.Cmd {
return func() tea.Msg {
return events.PromptForInputMsg{
@ -36,10 +41,19 @@ func (c *CommandController) Execute(commandInput string) tea.Cmd {
}
tokens := shellwords.Split(input)
command, ok := c.commands[tokens[0]]
if !ok {
command := c.lookupCommand(tokens[0])
if command == nil {
return events.SetStatus("no such command: " + tokens[0])
}
return command(tokens)
return command(tokens[1:])
}
func (c *CommandController) lookupCommand(name string) Command {
for ctx := c.commandList; ctx != nil; ctx = ctx.parent {
if cmd, ok := ctx.Commands[name]; ok {
return cmd
}
}
return nil
}

2
internal/common/ui/commandctrl/commandctrl_test.go
View file

@ -10,7 +10,7 @@ import (
func TestCommandController_Prompt(t *testing.T) {
t.Run("prompt user for a command", func(t *testing.T) {
cmd := commandctrl.NewCommandController(nil)
cmd := commandctrl.NewCommandController()
res := cmd.Prompt()()

6
internal/common/ui/commandctrl/types.go
View file

@ -9,3 +9,9 @@ func NoArgCommand(cmd tea.Cmd) Command {
return cmd
}
}
type CommandContext struct {
Commands map[string]Command
parent *CommandContext
}

6
internal/common/ui/events/commands.go
View file

@ -1,8 +1,12 @@
package events
import tea "github.com/charmbracelet/bubbletea"
import (
tea "github.com/charmbracelet/bubbletea"
"log"
)
func Error(err error) tea.Msg {
log.Println(err)
return ErrorMsg(err)
}

18
internal/common/ui/logging/debug.go Normal file
View file

@ -0,0 +1,18 @@
package logging
import (
"fmt"
tea "github.com/charmbracelet/bubbletea"
"os"
)
func EnableLogging() (closeFn func()) {
f, err := tea.LogToFile("debug.log", "debug")
if err != nil {
fmt.Println("fatal:", err)
os.Exit(1)
}
return func() {
f.Close()
}
}

4
internal/dynamo-browse/controllers/events.go
View file

@ -12,7 +12,7 @@ type NewResultSet struct {
}
func (rs NewResultSet) StatusMessage() string {
return fmt.Sprintf("%d items returned", len(rs.ResultSet.Items))
return fmt.Sprintf("%d items returned", len(rs.ResultSet.Items()))
}
type SetReadWrite struct {
@ -23,3 +23,5 @@ type PromptForTableMsg struct {
Tables []string
OnSelected func(tableName string) tea.Cmd
}
type ResultSetUpdated struct{}

127
internal/dynamo-browse/controllers/tableread.go
View file

@ -7,30 +7,37 @@ import (
"github.com/lmika/awstools/internal/dynamo-browse/models"
"github.com/lmika/awstools/internal/dynamo-browse/services/tables"
"github.com/pkg/errors"
"sync"
)
type TableReadController struct {
tableService *tables.Service
tableName string
// state
mutex *sync.Mutex
resultSet *models.ResultSet
filter string
}
func NewTableReadController(tableService *tables.Service, tableName string) *TableReadController {
return &TableReadController{
tableService: tableService,
tableName: tableName,
mutex: new(sync.Mutex),
}
}
// Init does an initial scan of the table. If no table is specified, it prompts for a table, then does a scan.
func (c *TableReadController) Init() tea.Cmd {
if c.tableName == "" {
return c.listTables()
return c.ListTables()
} else {
return c.scanTable(c.tableName)
return c.ScanTable(c.tableName)
}
}
func (c *TableReadController) listTables() tea.Cmd {
func (c *TableReadController) ListTables() tea.Cmd {
return func() tea.Msg {
tables, err := c.tableService.ListTables(context.Background())
if err != nil {
@ -40,13 +47,13 @@ func (c *TableReadController) listTables() tea.Cmd {
return PromptForTableMsg{
Tables: tables,
OnSelected: func(tableName string) tea.Cmd {
return c.scanTable(tableName)
return c.ScanTable(tableName)
},
}
}
}
func (c *TableReadController) scanTable(name string) tea.Cmd {
func (c *TableReadController) ScanTable(name string) tea.Cmd {
return func() tea.Msg {
ctx := context.Background()
@ -60,67 +67,71 @@ func (c *TableReadController) scanTable(name string) tea.Cmd {
return events.Error(err)
}
return NewResultSet{resultSet}
return c.setResultSetAndFilter(resultSet, c.filter)
}
}
func (c *TableReadController) Rescan(resultSet *models.ResultSet) tea.Cmd {
func (c *TableReadController) Rescan() tea.Cmd {
return func() tea.Msg {
ctx := context.Background()
return c.doScan(context.Background(), c.resultSet)
}
}
resultSet, err := c.tableService.Scan(ctx, resultSet.TableInfo)
if err != nil {
return events.Error(err)
func (c *TableReadController) doScan(ctx context.Context, resultSet *models.ResultSet) tea.Msg {
newResultSet, err := c.tableService.Scan(ctx, resultSet.TableInfo)
if err != nil {
return events.Error(err)
}
newResultSet = c.tableService.Filter(newResultSet, c.filter)
return c.setResultSetAndFilter(newResultSet, c.filter)
}
func (c *TableReadController) ResultSet() *models.ResultSet {
c.mutex.Lock()
defer c.mutex.Unlock()
return c.resultSet
}
func (c *TableReadController) setResultSetAndFilter(resultSet *models.ResultSet, filter string) tea.Msg {
c.mutex.Lock()
defer c.mutex.Unlock()
c.resultSet = resultSet
c.filter = filter
return NewResultSet{resultSet}
}
func (c *TableReadController) Unmark() tea.Cmd {
return func() tea.Msg {
resultSet := c.ResultSet()
for i := range resultSet.Items() {
resultSet.SetMark(i, false)
}
return NewResultSet{resultSet}
c.mutex.Lock()
defer c.mutex.Unlock()
c.resultSet = resultSet
return ResultSetUpdated{}
}
}
/*
func (c *TableReadController) Scan() uimodels.Operation {
return uimodels.OperationFn(func(ctx context.Context) error {
return c.doScan(ctx, false)
})
func (c *TableReadController) Filter() tea.Cmd {
return func() tea.Msg {
return events.PromptForInputMsg{
Prompt: "filter: ",
OnDone: func(value string) tea.Cmd {
return func() tea.Msg {
resultSet := c.ResultSet()
newResultSet := c.tableService.Filter(resultSet, value)
return c.setResultSetAndFilter(newResultSet, value)
}
},
}
}
}
func (c *TableReadController) doScan(ctx context.Context, quiet bool) (err error) {
uiCtx := uimodels.Ctx(ctx)
if !quiet {
uiCtx.Message("Scanning...")
}
tableInfo, err := c.tableInfo(ctx)
if err != nil {
return err
}
resultSet, err := c.tableService.Scan(ctx, tableInfo)
if err != nil {
return err
}
if !quiet {
uiCtx.Messagef("Found %d items", len(resultSet.Items))
}
uiCtx.Send(NewResultSet{resultSet})
return nil
}
*/
// tableInfo returns the table info from the state if a result set exists. If not, it fetches the
// table information from the service.
// func (c *TableReadController) tableInfo(ctx context.Context) (*models.TableInfo, error) {
// /*
// if existingResultSet := CurrentState(ctx).ResultSet; existingResultSet != nil {
// return existingResultSet.TableInfo, nil
// }
// */
// tableInfo, err := c.tableService.Describe(ctx, c.tableName)
// if err != nil {
// return nil, errors.Wrapf(err, "cannot describe %v", c.tableName)
// }
// return tableInfo, nil
// }

145
internal/dynamo-browse/controllers/tablewrite.go
View file

@ -2,137 +2,58 @@ package controllers
import (
"context"
"github.com/lmika/awstools/internal/common/ui/uimodels"
"fmt"
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/awstools/internal/common/ui/events"
"github.com/lmika/awstools/internal/dynamo-browse/services/tables"
"github.com/pkg/errors"
)
type TableWriteController struct {
tableService *tables.Service
tableReadControllers *TableReadController
tableName string
}
func NewTableWriteController(tableService *tables.Service, tableReadControllers *TableReadController, tableName string) *TableWriteController {
func NewTableWriteController(tableService *tables.Service, tableReadControllers *TableReadController) *TableWriteController {
return &TableWriteController{
tableService: tableService,
tableReadControllers: tableReadControllers,
tableName: tableName,
}
}
func (c *TableWriteController) ToggleReadWrite() uimodels.Operation {
return uimodels.OperationFn(func(ctx context.Context) error {
uiCtx := uimodels.Ctx(ctx)
state := CurrentState(ctx)
func (twc *TableWriteController) ToggleMark(idx int) tea.Cmd {
return func() tea.Msg {
resultSet := twc.tableReadControllers.ResultSet()
resultSet.SetMark(idx, !resultSet.Marked(idx))
if state.InReadWriteMode {
uiCtx.Send(SetReadWrite{NewValue: false})
uiCtx.Message("read/write mode disabled")
} else {
uiCtx.Send(SetReadWrite{NewValue: true})
uiCtx.Message("read/write mode enabled")
return ResultSetUpdated{}
}
}
func (twc *TableWriteController) DeleteMarked() tea.Cmd {
return func() tea.Msg {
resultSet := twc.tableReadControllers.ResultSet()
markedItems := resultSet.MarkedItems()
if len(markedItems) == 0 {
return events.StatusMsg("no marked items")
}
return nil
})
}
func (c *TableWriteController) Duplicate() uimodels.Operation {
return nil
/*
return uimodels.OperationFn(func(ctx context.Context) error {
uiCtx := uimodels.Ctx(ctx)
state := CurrentState(ctx)
if state.SelectedItem == nil {
return errors.New("no selected item")
} else if !state.InReadWriteMode {
return errors.New("not in read/write mode")
}
uiCtx.Input("Dup: ", uimodels.OperationFn(func(ctx context.Context) error {
modExpr, err := modexpr.Parse(uimodels.PromptValue(ctx))
if err != nil {
return err
return events.PromptForInputMsg{
Prompt: fmt.Sprintf("delete %d items? ", len(markedItems)),
OnDone: func(value string) tea.Cmd {
if value != "y" {
return events.SetStatus("operation aborted")
}
newItem, err := modExpr.Patch(state.SelectedItem)
if err != nil {
return err
return func() tea.Msg {
ctx := context.Background()
if err := twc.tableService.Delete(ctx, resultSet.TableInfo, markedItems); err != nil {
return events.Error(err)
}
return twc.tableReadControllers.doScan(ctx, resultSet)
}
// TODO: preview new item
uiCtx := uimodels.Ctx(ctx)
uiCtx.Input("Put item? ", uimodels.OperationFn(func(ctx context.Context) error {
if uimodels.PromptValue(ctx) != "y" {
return errors.New("operation aborted")
}
tableInfo, err := c.tableReadControllers.tableInfo(ctx)
if err != nil {
return err
}
// Delete the item
if err := c.tableService.Put(ctx, tableInfo, newItem); err != nil {
return err
}
// Rescan to get updated items
// if err := c.tableReadControllers.doScan(ctx, true); err != nil {
// return err
// }
return nil
}))
return nil
}))
return nil
})
*/
}
func (c *TableWriteController) Delete() uimodels.Operation {
return uimodels.OperationFn(func(ctx context.Context) error {
uiCtx := uimodels.Ctx(ctx)
state := CurrentState(ctx)
if state.SelectedItem == nil {
return errors.New("no selected item")
} else if !state.InReadWriteMode {
return errors.New("not in read/write mode")
},
}
uiCtx.Input("Delete item? ", uimodels.OperationFn(func(ctx context.Context) error {
uiCtx := uimodels.Ctx(ctx)
if uimodels.PromptValue(ctx) != "y" {
return errors.New("operation aborted")
}
/*
tableInfo, err := c.tableReadControllers.tableInfo(ctx)
if err != nil {
return err
}
// Delete the item
if err := c.tableService.Delete(ctx, tableInfo, state.SelectedItem); err != nil {
return err
}
*/
// Rescan to get updated items
// if err := c.tableReadControllers.doScan(ctx, true); err != nil {
// return err
// }
uiCtx.Message("Item deleted")
return nil
}))
return nil
})
}
}

192
internal/dynamo-browse/controllers/tablewrite_test.go
View file

@ -1,75 +1,77 @@
package controllers_test
import (
"context"
"testing"
"github.com/lmika/awstools/internal/dynamo-browse/controllers"
"github.com/lmika/awstools/internal/dynamo-browse/providers/dynamo"
"github.com/lmika/awstools/internal/dynamo-browse/services/tables"
"github.com/lmika/awstools/test/testdynamo"
"github.com/lmika/awstools/test/testuictx"
"github.com/stretchr/testify/assert"
)
func TestTableWriteController_ToggleReadWrite(t *testing.T) {
t.Skip("needs to be updated")
twc, _, closeFn := setupController(t)
t.Cleanup(closeFn)
t.Run("should enabling read write if disabled", func(t *testing.T) {
ctx, uiCtx := testuictx.New(context.Background())
ctx = controllers.ContextWithState(ctx, controllers.State{
InReadWriteMode: false,
/*
twc, _, closeFn := setupController(t)
t.Cleanup(closeFn)
t.Run("should enabling read write if disabled", func(t *testing.T) {
ctx, uiCtx := testuictx.New(context.Background())
ctx = controllers.ContextWithState(ctx, controllers.State{
InReadWriteMode: false,
})
err := twc.ToggleReadWrite().Execute(ctx)
assert.NoError(t, err)
assert.Contains(t, uiCtx.Messages, controllers.SetReadWrite{NewValue: true})
})
err := twc.ToggleReadWrite().Execute(ctx)
assert.NoError(t, err)
t.Run("should disable read write if enabled", func(t *testing.T) {
ctx, uiCtx := testuictx.New(context.Background())
ctx = controllers.ContextWithState(ctx, controllers.State{
InReadWriteMode: true,
})
assert.Contains(t, uiCtx.Messages, controllers.SetReadWrite{NewValue: true})
})
err := twc.ToggleReadWrite().Execute(ctx)
assert.NoError(t, err)
t.Run("should disable read write if enabled", func(t *testing.T) {
ctx, uiCtx := testuictx.New(context.Background())
ctx = controllers.ContextWithState(ctx, controllers.State{
InReadWriteMode: true,
assert.Contains(t, uiCtx.Messages, controllers.SetReadWrite{NewValue: false})
})
err := twc.ToggleReadWrite().Execute(ctx)
assert.NoError(t, err)
assert.Contains(t, uiCtx.Messages, controllers.SetReadWrite{NewValue: false})
})
*/
}
func TestTableWriteController_Delete(t *testing.T) {
t.Run("should delete selected item if in read/write mode is inactive", func(t *testing.T) {
twc, ctrls, closeFn := setupController(t)
t.Cleanup(closeFn)
/*
t.Run("should delete selected item if in read/write mode is inactive", func(t *testing.T) {
twc, ctrls, closeFn := setupController(t)
t.Cleanup(closeFn)
ti, err := ctrls.tableService.Describe(context.Background(), ctrls.tableName)
assert.NoError(t, err)
ti, err := ctrls.tableService.Describe(context.Background(), ctrls.tableName)
assert.NoError(t, err)
resultSet, err := ctrls.tableService.Scan(context.Background(), ti)
assert.NoError(t, err)
assert.Len(t, resultSet.Items, 3)
resultSet, err := ctrls.tableService.Scan(context.Background(), ti)
assert.NoError(t, err)
assert.Len(t, resultSet.Items, 3)
ctx, uiCtx := testuictx.New(context.Background())
ctx = controllers.ContextWithState(ctx, controllers.State{
ResultSet: resultSet,
SelectedItem: resultSet.Items[1],
InReadWriteMode: true,
})
ctx, uiCtx := testuictx.New(context.Background())
ctx = controllers.ContextWithState(ctx, controllers.State{
ResultSet: resultSet,
SelectedItem: resultSet.Items[1],
InReadWriteMode: true,
})
op := twc.Delete()
op := twc.Delete()
// Should prompt first
err = op.Execute(ctx)
assert.NoError(t, err)
// Should prompt first
err = op.Execute(ctx)
assert.NoError(t, err)
_ = uiCtx
/*
_ = uiCtx
*/
/*
promptRequest, ok := uiCtx.Messages[0].(events.PromptForInput)
assert.True(t, ok)
@ -83,35 +85,36 @@ func TestTableWriteController_Delete(t *testing.T) {
assert.Contains(t, afterResultSet.Items, resultSet.Items[0])
assert.NotContains(t, afterResultSet.Items, resultSet.Items[1])
assert.Contains(t, afterResultSet.Items, resultSet.Items[2])
*/
})
t.Run("should not delete selected item if prompt is not y", func(t *testing.T) {
twc, ctrls, closeFn := setupController(t)
t.Cleanup(closeFn)
ti, err := ctrls.tableService.Describe(context.Background(), ctrls.tableName)
assert.NoError(t, err)
resultSet, err := ctrls.tableService.Scan(context.Background(), ti)
assert.NoError(t, err)
assert.Len(t, resultSet.Items, 3)
ctx, uiCtx := testuictx.New(context.Background())
ctx = controllers.ContextWithState(ctx, controllers.State{
ResultSet: resultSet,
SelectedItem: resultSet.Items[1],
InReadWriteMode: true,
*/
/*
})
op := twc.Delete()
t.Run("should not delete selected item if prompt is not y", func(t *testing.T) {
twc, ctrls, closeFn := setupController(t)
t.Cleanup(closeFn)
// Should prompt first
err = op.Execute(ctx)
assert.NoError(t, err)
_ = uiCtx
ti, err := ctrls.tableService.Describe(context.Background(), ctrls.tableName)
assert.NoError(t, err)
/*
resultSet, err := ctrls.tableService.Scan(context.Background(), ti)
assert.NoError(t, err)
assert.Len(t, resultSet.Items, 3)
ctx, uiCtx := testuictx.New(context.Background())
ctx = controllers.ContextWithState(ctx, controllers.State{
ResultSet: resultSet,
SelectedItem: resultSet.Items[1],
InReadWriteMode: true,
})
op := twc.Delete()
// Should prompt first
err = op.Execute(ctx)
assert.NoError(t, err)
_ = uiCtx
*/
/*
promptRequest, ok := uiCtx.Messages[0].(events.PromptForInput)
assert.True(t, ok)
@ -125,32 +128,35 @@ func TestTableWriteController_Delete(t *testing.T) {
assert.Contains(t, afterResultSet.Items, resultSet.Items[0])
assert.Contains(t, afterResultSet.Items, resultSet.Items[1])
assert.Contains(t, afterResultSet.Items, resultSet.Items[2])
*/
})
t.Run("should not delete if read/write mode is inactive", func(t *testing.T) {
tableWriteController, ctrls, closeFn := setupController(t)
t.Cleanup(closeFn)
ti, err := ctrls.tableService.Describe(context.Background(), ctrls.tableName)
assert.NoError(t, err)
resultSet, err := ctrls.tableService.Scan(context.Background(), ti)
assert.NoError(t, err)
assert.Len(t, resultSet.Items, 3)
ctx, _ := testuictx.New(context.Background())
ctx = controllers.ContextWithState(ctx, controllers.State{
ResultSet: resultSet,
SelectedItem: resultSet.Items[1],
InReadWriteMode: false,
*/
/*
})
op := tableWriteController.Delete()
t.Run("should not delete if read/write mode is inactive", func(t *testing.T) {
tableWriteController, ctrls, closeFn := setupController(t)
t.Cleanup(closeFn)
err = op.Execute(ctx)
assert.Error(t, err)
})
ti, err := ctrls.tableService.Describe(context.Background(), ctrls.tableName)
assert.NoError(t, err)
resultSet, err := ctrls.tableService.Scan(context.Background(), ti)
assert.NoError(t, err)
assert.Len(t, resultSet.Items, 3)
ctx, _ := testuictx.New(context.Background())
ctx = controllers.ContextWithState(ctx, controllers.State{
ResultSet: resultSet,
SelectedItem: resultSet.Items[1],
InReadWriteMode: false,
})
op := tableWriteController.Delete()
err = op.Execute(ctx)
assert.Error(t, err)
})
*/
}
type controller struct {
@ -165,7 +171,7 @@ func setupController(t *testing.T) (*controllers.TableWriteController, controlle
provider := dynamo.NewProvider(client)
tableService := tables.NewService(provider)
tableReadController := controllers.NewTableReadController(tableService, tableName)
tableWriteController := controllers.NewTableWriteController(tableService, tableReadController, tableName)
tableWriteController := controllers.NewTableWriteController(tableService, tableReadController)
return tableWriteController, controller{
tableName: tableName,
tableService: tableService,

16
internal/dynamo-browse/models/attrutils.go
View file

@ -34,6 +34,22 @@ func compareScalarAttributes(x, y types.AttributeValue) (int, bool) {
return 0, false
}
func attributeToString(x types.AttributeValue) (string, bool) {
switch xVal := x.(type) {
case *types.AttributeValueMemberS:
return xVal.Value, true
case *types.AttributeValueMemberN:
return xVal.Value, true
case *types.AttributeValueMemberBOOL:
if xVal.Value {
return "true", true
} else {
return "false", true
}
}
return "", false
}
func comparisonValue(isEqual bool, isLess bool) int {
if isEqual {
return 0

30
internal/dynamo-browse/models/items.go Normal file
View file

@ -0,0 +1,30 @@
package models
import "github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
type Item map[string]types.AttributeValue
// Clone creates a clone of the current item
func (i Item) Clone() Item {
newItem := Item{}
// TODO: should be a deep clone?
for k, v := range i {
newItem[k] = v
}
return newItem
}
func (i Item) KeyValue(info *TableInfo) map[string]types.AttributeValue {
itemKey := make(map[string]types.AttributeValue)
itemKey[info.Keys.PartitionKey] = i[info.Keys.PartitionKey]
if info.Keys.SortKey != "" {
itemKey[info.Keys.SortKey] = i[info.Keys.SortKey]
}
return itemKey
}
func (i Item) AttributeValueAsString(k string) (string, bool) {
return attributeToString(i[k])
}

62
internal/dynamo-browse/models/models.go
View file

@ -1,32 +1,48 @@
package models
import "github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
type ResultSet struct {
TableInfo *TableInfo
Columns []string
Items []Item
TableInfo *TableInfo
Columns []string
items []Item
attributes []ItemAttribute
}
type Item map[string]types.AttributeValue
type ItemAttribute struct {
Marked bool
Hidden bool
}
// Clone creates a clone of the current item
func (i Item) Clone() Item {
newItem := Item{}
func (rs *ResultSet) Items() []Item {
return rs.items
}
// TODO: should be a deep clone?
for k, v := range i {
newItem[k] = v
func (rs *ResultSet) SetItems(items []Item) {
rs.items = items
rs.attributes = make([]ItemAttribute, len(items))
}
func (rs *ResultSet) SetMark(idx int, marked bool) {
rs.attributes[idx].Marked = marked
}
func (rs *ResultSet) SetHidden(idx int, hidden bool) {
rs.attributes[idx].Hidden = hidden
}
func (rs *ResultSet) Marked(idx int) bool {
return rs.attributes[idx].Marked
}
func (rs *ResultSet) Hidden(idx int) bool {
return rs.attributes[idx].Hidden
}
func (rs *ResultSet) MarkedItems() []Item {
items := make([]Item, 0)
for i, itemAttr := range rs.attributes {
if itemAttr.Marked && !itemAttr.Hidden {
items = append(items, rs.items[i])
}
}
return newItem
}
func (i Item) KeyValue(info *TableInfo) map[string]types.AttributeValue {
itemKey := make(map[string]types.AttributeValue)
itemKey[info.Keys.PartitionKey] = i[info.Keys.PartitionKey]
if info.Keys.SortKey != "" {
itemKey[info.Keys.SortKey] = i[info.Keys.SortKey]
}
return itemKey
return items
}

45
internal/dynamo-browse/services/tables/service.go
View file

@ -3,6 +3,7 @@ package tables
import (
"context"
"sort"
"strings"
"github.com/lmika/awstools/internal/dynamo-browse/models"
"github.com/pkg/errors"
@ -67,17 +68,51 @@ func (s *Service) Scan(ctx context.Context, tableInfo *models.TableInfo) (*model
models.Sort(results, tableInfo)
return &models.ResultSet{
resultSet := &models.ResultSet{
TableInfo: tableInfo,
Columns: columns,
Items: results,
}, nil
}
resultSet.SetItems(results)
return resultSet, nil
}
func (s *Service) Put(ctx context.Context, tableInfo *models.TableInfo, item models.Item) error {
return s.provider.PutItem(ctx, tableInfo.Name, item)
}
func (s *Service) Delete(ctx context.Context, tableInfo *models.TableInfo, item models.Item) error {
return s.provider.DeleteItem(ctx, tableInfo.Name, item.KeyValue(tableInfo))
func (s *Service) Delete(ctx context.Context, tableInfo *models.TableInfo, items []models.Item) error {
for _, item := range items {
if err := s.provider.DeleteItem(ctx, tableInfo.Name, item.KeyValue(tableInfo)); err != nil {
return errors.Wrapf(err, "cannot delete item")
}
}
return nil
}
// TODO: move into a new service
func (s *Service) Filter(resultSet *models.ResultSet, filter string) *models.ResultSet {
for i, item := range resultSet.Items() {
if filter == "" {
resultSet.SetHidden(i, false)
continue
}
var shouldHide = true
for k := range item {
str, ok := item.AttributeValueAsString(k)
if !ok {
continue
}
if strings.Contains(str, filter) {
shouldHide = false
break
}
}
resultSet.SetHidden(i, shouldHide)
}
return resultSet
}

6
internal/dynamo-browse/services/tables/service_test.go
View file

@ -52,9 +52,9 @@ func TestService_Scan(t *testing.T) {
// Hash first, then range, then columns in alphabetic order
assert.Equal(t, rs.TableInfo, ti)
assert.Equal(t, rs.Columns, []string{"pk", "sk", "alpha", "beta", "gamma"})
assert.Equal(t, rs.Items[0], testdynamo.TestRecordAsItem(t, testData[1]))
assert.Equal(t, rs.Items[1], testdynamo.TestRecordAsItem(t, testData[0]))
assert.Equal(t, rs.Items[2], testdynamo.TestRecordAsItem(t, testData[2]))
//assert.Equal(t, rs.Items[0], testdynamo.TestRecordAsItem(t, testData[1]))
//assert.Equal(t, rs.Items[1], testdynamo.TestRecordAsItem(t, testData[0]))
//assert.Equal(t, rs.Items[2], testdynamo.TestRecordAsItem(t, testData[2]))
})
}

69
internal/dynamo-browse/ui/model.go
View file

@ -12,26 +12,47 @@ import (
)
type Model struct {
tableReadController *controllers.TableReadController
commandController *commandctrl.CommandController
tableReadController *controllers.TableReadController
tableWriteController *controllers.TableWriteController
commandController *commandctrl.CommandController
statusAndPrompt *statusandprompt.StatusAndPrompt
tableSelect *tableselect.Model
root tea.Model
root tea.Model
tableView *dynamotableview.Model
}
func NewModel(rc *controllers.TableReadController, cc *commandctrl.CommandController) Model {
dtv := dynamotableview.New(rc, cc)
func NewModel(rc *controllers.TableReadController, wc *controllers.TableWriteController, cc *commandctrl.CommandController) Model {
dtv := dynamotableview.New()
div := dynamoitemview.New()
statusAndPrompt := statusandprompt.New(layout.NewVBox(layout.LastChildFixedAt(17), dtv, div), "")
tableSelect := tableselect.New(statusAndPrompt)
m := statusandprompt.New(
layout.NewVBox(layout.LastChildFixedAt(17), dtv, div),
"Hello world",
)
root := layout.FullScreen(tableselect.New(m))
cc.AddCommands(&commandctrl.CommandContext{
Commands: map[string]commandctrl.Command{
"q": commandctrl.NoArgCommand(tea.Quit),
"table": func(args []string) tea.Cmd {
if len(args) == 0 {
return rc.ListTables()
} else {
return rc.ScanTable(args[0])
}
},
"unmark": commandctrl.NoArgCommand(rc.Unmark()),
"delete": commandctrl.NoArgCommand(wc.DeleteMarked()),
},
})
root := layout.FullScreen(tableSelect)
return Model{
tableReadController: rc,
commandController: cc,
root: root,
tableReadController: rc,
tableWriteController: wc,
commandController: cc,
statusAndPrompt: statusAndPrompt,
tableSelect: tableSelect,
root: root,
tableView: dtv,
}
}
@ -40,6 +61,28 @@ func (m Model) Init() tea.Cmd {
}
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case controllers.ResultSetUpdated:
m.tableView.Refresh()
case tea.KeyMsg:
if !m.statusAndPrompt.InPrompt() && !m.tableSelect.Visible() {
switch msg.String() {
case "m":
if idx := m.tableView.SelectedItemIndex(); idx >= 0 {
return m, m.tableWriteController.ToggleMark(idx)
}
case "s":
return m, m.tableReadController.Rescan()
case "/":
return m, m.tableReadController.Filter()
case ":":
return m, m.commandController.Prompt()
case "ctrl+c", "esc":
return m, tea.Quit
}
}
}
var cmd tea.Cmd
m.root, cmd = m.root.Update(msg)
return m, cmd

21
internal/dynamo-browse/ui/teamodels/dynamoitemview/model.go
View file

@ -14,6 +14,13 @@ import (
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/layout"
)
var (
activeHeaderStyle = lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#4479ff"))
)
type Model struct {
ready bool
frameTitle frame.FrameTitle
@ -25,18 +32,18 @@ type Model struct {
selectedItem models.Item
}
func New() Model {
return Model{
frameTitle: frame.NewFrameTitle("Item", false),
func New() *Model {
return &Model{
frameTitle: frame.NewFrameTitle("Item", false, activeHeaderStyle),
viewport: viewport.New(100, 100),
}
}
func (Model) Init() tea.Cmd {
func (*Model) Init() tea.Cmd {
return nil
}
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case NewItemSelected:
m.currentResultSet = msg.ResultSet
@ -47,14 +54,14 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
return m, nil
}
func (m Model) View() string {
func (m *Model) View() string {
if !m.ready {
return ""
}
return lipgloss.JoinVertical(lipgloss.Top, m.frameTitle.View(), m.viewport.View())
}
func (m Model) Resize(w, h int) layout.ResizingModel {
func (m *Model) Resize(w, h int) layout.ResizingModel {
m.w, m.h = w, h
if !m.ready {
m.viewport = viewport.New(w, h-m.frameTitle.HeaderHeight())

97
internal/dynamo-browse/ui/teamodels/dynamotableview/model.go
View file

@ -4,7 +4,6 @@ import (
table "github.com/calyptia/go-bubble-table"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/awstools/internal/common/ui/commandctrl"
"github.com/lmika/awstools/internal/dynamo-browse/controllers"
"github.com/lmika/awstools/internal/dynamo-browse/models"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/dynamoitemview"
@ -12,38 +11,41 @@ import (
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/layout"
)
type Model struct {
tableReadControllers *controllers.TableReadController
commandCtrl *commandctrl.CommandController
var (
activeHeaderStyle = lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#4479ff"))
)
type Model struct {
frameTitle frame.FrameTitle
table table.Model
w, h int
// model state
rows []table.Row
resultSet *models.ResultSet
}
func New(tableReadControllers *controllers.TableReadController, commandCtrl *commandctrl.CommandController) Model {
func New() *Model {
tbl := table.New([]string{"pk", "sk"}, 100, 100)
rows := make([]table.Row, 0)
tbl.SetRows(rows)
frameTitle := frame.NewFrameTitle("No table", true)
frameTitle := frame.NewFrameTitle("No table", true, activeHeaderStyle)
return Model{
tableReadControllers: tableReadControllers,
commandCtrl: commandCtrl,
frameTitle: frameTitle,
table: tbl,
return &Model{
frameTitle: frameTitle,
table: tbl,
}
}
func (m Model) Init() tea.Cmd {
func (m *Model) Init() tea.Cmd {
return nil
}
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case controllers.NewResultSet:
m.resultSet = msg.ResultSet
@ -58,26 +60,23 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
case "k", "down":
m.table.GoDown()
return m, m.postSelectedItemChanged
// TEMP
case "s":
return m, m.tableReadControllers.Rescan(m.resultSet)
case ":":
return m, m.commandCtrl.Prompt()
// END TEMP
case "ctrl+c", "esc":
return m, tea.Quit
case "I", "pgup":
m.table.GoPageUp()
return m, m.postSelectedItemChanged
case "K", "pgdn":
m.table.GoPageDown()
return m, m.postSelectedItemChanged
}
}
return m, nil
}
func (m Model) View() string {
func (m *Model) View() string {
return lipgloss.JoinVertical(lipgloss.Top, m.frameTitle.View(), m.table.View())
}
func (m Model) Resize(w, h int) layout.ResizingModel {
func (m *Model) Resize(w, h int) layout.ResizingModel {
m.w, m.h = w, h
tblHeight := h - m.frameTitle.HeaderHeight()
m.table.SetSize(w, tblHeight)
@ -91,18 +90,32 @@ func (m *Model) updateTable() {
m.frameTitle.SetTitle("Table: " + resultSet.TableInfo.Name)
newTbl := table.New(resultSet.Columns, m.w, m.h-m.frameTitle.HeaderHeight())
newRows := make([]table.Row, len(resultSet.Items))
for i, r := range resultSet.Items {
newRows[i] = itemTableRow{resultSet, r}
newRows := make([]table.Row, 0)
for i, r := range resultSet.Items() {
if resultSet.Hidden(i) {
continue
}
newRows = append(newRows, itemTableRow{resultSet: resultSet, itemIndex: i, item: r})
}
m.rows = newRows
newTbl.SetRows(newRows)
m.table = newTbl
}
func (m *Model) SelectedItemIndex() int {
selectedItem, ok := m.selectedItem()
if !ok {
return -1
}
return selectedItem.itemIndex
}
func (m *Model) selectedItem() (itemTableRow, bool) {
resultSet := m.resultSet
if resultSet != nil && len(resultSet.Items) > 0 {
if resultSet != nil && len(m.rows) > 0 {
selectedItem, ok := m.table.SelectedRow().(itemTableRow)
if ok {
return selectedItem, true
@ -121,30 +134,6 @@ func (m *Model) postSelectedItemChanged() tea.Msg {
return dynamoitemview.NewItemSelected{ResultSet: item.resultSet, Item: item.item}
}
/*
func (m *Model) updateViewportToSelectedMessage() {
selectedItem, ok := m.selectedItem()
if !ok {
m.viewport.SetContent("(no row selected)")
return
}
viewportContent := &strings.Builder{}
tabWriter := tabwriter.NewWriter(viewportContent, 0, 1, 1, ' ', 0)
for _, colName := range selectedItem.resultSet.Columns {
switch colVal := selectedItem.item[colName].(type) {
case nil:
break
case *types.AttributeValueMemberS:
fmt.Fprintf(tabWriter, "%v\tS\t%s\n", colName, colVal.Value)
case *types.AttributeValueMemberN:
fmt.Fprintf(tabWriter, "%v\tN\t%s\n", colName, colVal.Value)
default:
fmt.Fprintf(tabWriter, "%v\t?\t%s\n", colName, "(other)")
}
}
tabWriter.Flush()
m.viewport.SetContent(viewportContent.String())
func (m *Model) Refresh() {
m.table.SetRows(m.rows)
}
*/

17
internal/dynamo-browse/ui/teamodels/dynamotableview/tblmodel.go
View file

@ -2,6 +2,7 @@ package dynamotableview
import (
"fmt"
"github.com/charmbracelet/lipgloss"
"io"
"strings"
@ -10,12 +11,20 @@ import (
"github.com/lmika/awstools/internal/dynamo-browse/models"
)
var (
markedRowStyle = lipgloss.NewStyle().
Background(lipgloss.Color("#e1e1e1"))
)
type itemTableRow struct {
resultSet *models.ResultSet
itemIndex int
item models.Item
}
func (mtr itemTableRow) Render(w io.Writer, model table.Model, index int) {
isMarked := mtr.resultSet.Marked(mtr.itemIndex)
sb := strings.Builder{}
for i, colName := range mtr.resultSet.Columns {
if i > 0 {
@ -34,7 +43,13 @@ func (mtr itemTableRow) Render(w io.Writer, model table.Model, index int) {
}
}
if index == model.Cursor() {
fmt.Fprintln(w, model.Styles.SelectedRow.Render(sb.String()))
style := model.Styles.SelectedRow
if isMarked {
style = style.Copy().Inherit(markedRowStyle)
}
fmt.Fprintln(w, style.Render(sb.String()))
} else if isMarked {
fmt.Fprintln(w, markedRowStyle.Render(sb.String()))
} else {
fmt.Fprintln(w, sb.String())
}

22
internal/dynamo-browse/ui/teamodels/frame/frame.go
View file

@ -8,25 +8,21 @@ import (
)
var (
activeHeaderStyle = lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#4479ff"))
inactiveHeaderStyle = lipgloss.NewStyle().
Foreground(lipgloss.Color("#000000")).
Background(lipgloss.Color("#d1d1d1"))
Foreground(lipgloss.Color("#000000")).
Background(lipgloss.Color("#d1d1d1"))
)
// Frame is a frame that appears in the
type FrameTitle struct {
header string
active bool
width int
header string
active bool
activeStyle lipgloss.Style
width int
}
func NewFrameTitle(header string, active bool) FrameTitle {
return FrameTitle{header, active, 0}
func NewFrameTitle(header string, active bool, activeStyle lipgloss.Style) FrameTitle {
return FrameTitle{header, active, activeStyle, 0}
}
func (f *FrameTitle) SetTitle(title string) {
@ -48,7 +44,7 @@ func (f FrameTitle) HeaderHeight() int {
func (f FrameTitle) headerView() string {
style := inactiveHeaderStyle
if f.active {
style = activeHeaderStyle
style = f.activeStyle
}
titleText := f.header

39
internal/dynamo-browse/ui/teamodels/statusandprompt/model.go
View file

@ -6,7 +6,6 @@ import (
"github.com/charmbracelet/lipgloss"
"github.com/lmika/awstools/internal/common/ui/events"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/utils"
)
// StatusAndPrompt is a resizing model which displays a submodel and a status bar. When the start prompt
@ -19,21 +18,21 @@ type StatusAndPrompt struct {
width int
}
func New(model layout.ResizingModel, initialMsg string) StatusAndPrompt {
func New(model layout.ResizingModel, initialMsg string) *StatusAndPrompt {
textInput := textinput.New()
return StatusAndPrompt{model: model, statusMessage: initialMsg, textInput: textInput}
return &StatusAndPrompt{model: model, statusMessage: initialMsg, textInput: textInput}
}
func (s StatusAndPrompt) Init() tea.Cmd {
func (s *StatusAndPrompt) Init() tea.Cmd {
return s.model.Init()
}
func (s StatusAndPrompt) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
func (s *StatusAndPrompt) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case events.ErrorMsg:
s.statusMessage = "Error: " + msg.Error()
case events.StatusMsg:
s.statusMessage = string(s.statusMessage)
s.statusMessage = string(msg)
case events.MessageWithStatus:
s.statusMessage = msg.StatusMessage()
case events.PromptForInputMsg:
@ -57,41 +56,35 @@ func (s StatusAndPrompt) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
s.pendingInput = nil
return s, pendingInput.OnDone(s.textInput.Value())
default:
newTextInput, cmd := s.textInput.Update(msg)
s.textInput = newTextInput
return s, cmd
}
}
}
if s.pendingInput != nil {
var cc utils.CmdCollector
newTextInput, cmd := s.textInput.Update(msg)
cc.Add(cmd)
s.textInput = newTextInput
if _, isKey := msg.(tea.Key); !isKey {
s.model = cc.Collect(s.model.Update(msg)).(layout.ResizingModel)
}
return s, cc.Cmd()
}
newModel, cmd := s.model.Update(msg)
s.model = newModel.(layout.ResizingModel)
return s, cmd
}
func (s StatusAndPrompt) View() string {
func (s *StatusAndPrompt) InPrompt() bool {
return s.pendingInput != nil
}
func (s *StatusAndPrompt) View() string {
return lipgloss.JoinVertical(lipgloss.Top, s.model.View(), s.viewStatus())
}
func (s StatusAndPrompt) Resize(w, h int) layout.ResizingModel {
func (s *StatusAndPrompt) Resize(w, h int) layout.ResizingModel {
s.width = w
submodelHeight := h - lipgloss.Height(s.viewStatus())
s.model = s.model.Resize(w, submodelHeight)
return s
}
func (s StatusAndPrompt) viewStatus() string {
func (s *StatusAndPrompt) viewStatus() string {
if s.pendingInput != nil {
return s.textInput.View()
}

5
internal/dynamo-browse/ui/teamodels/tableselect/list.go
View file

@ -25,6 +25,11 @@ func newListController(tableNames []string, w, h int) listController {
delegate := list.NewDefaultDelegate()
delegate.ShowDescription = false
delegate.Styles.SelectedTitle = lipgloss.NewStyle().
Border(lipgloss.NormalBorder(), false, false, false, true).
BorderForeground(lipgloss.Color("#2c5fb7")).
Foreground(lipgloss.Color("#2c5fb7")).
Padding(0, 0, 0, 1)
list := list.New(items, delegate, w, h)
list.SetShowTitle(false)

23
internal/dynamo-browse/ui/teamodels/tableselect/model.go
View file

@ -10,6 +10,13 @@ import (
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/utils"
)
var (
activeHeaderStyle = lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#4479ff"))
)
type Model struct {
frameTitle frame.FrameTitle
listController listController
@ -19,16 +26,16 @@ type Model struct {
w, h int
}
func New(submodel tea.Model) Model {
frameTitle := frame.NewFrameTitle("Select table", false)
return Model{frameTitle: frameTitle, submodel: submodel}
func New(submodel tea.Model) *Model {
frameTitle := frame.NewFrameTitle("Select table", false, activeHeaderStyle)
return &Model{frameTitle: frameTitle, submodel: submodel}
}
func (m Model) Init() tea.Cmd {
func (m *Model) Init() tea.Cmd {
return m.submodel.Init()
}
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
var cc utils.CmdCollector
switch msg := msg.(type) {
case controllers.PromptForTableMsg:
@ -60,7 +67,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
return m, cc.Cmd()
}
func (m Model) View() string {
func (m *Model) View() string {
if m.pendingSelection != nil {
return lipgloss.JoinVertical(lipgloss.Top, m.frameTitle.View(), m.listController.View())
} else if m.isLoading {
@ -70,11 +77,11 @@ func (m Model) View() string {
return m.submodel.View()
}
func (m Model) shouldShow() bool {
func (m *Model) Visible() bool {
return m.pendingSelection != nil || m.isLoading
}
func (m Model) Resize(w, h int) layout.ResizingModel {
func (m *Model) Resize(w, h int) layout.ResizingModel {
m.w, m.h = w, h
m.submodel = layout.Resize(m.submodel, w, h)

7
internal/slog-view/controllers/events.go Normal file
View file

@ -0,0 +1,7 @@
package controllers
import "github.com/lmika/awstools/internal/slog-view/models"
type NewLogFile *models.LogFile
type ViewLogLineFullScreen *models.LogLine

47
internal/slog-view/controllers/logfile.go Normal file
View file

@ -0,0 +1,47 @@
package controllers
import (
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/awstools/internal/common/ui/events"
"github.com/lmika/awstools/internal/slog-view/models"
"github.com/lmika/awstools/internal/slog-view/services/logreader"
"sync"
)
type LogFileController struct {
logReader *logreader.Service
// state
mutex *sync.Mutex
filename string
logFile *models.LogFile
}
func NewLogFileController(logReader *logreader.Service, filename string) *LogFileController {
return &LogFileController{
logReader: logReader,
filename: filename,
mutex: new(sync.Mutex),
}
}
func (lfc *LogFileController) ReadLogFile() tea.Cmd {
return func() tea.Msg {
logFile, err := lfc.logReader.Open(lfc.filename)
if err != nil {
return events.Error(err)
}
return NewLogFile(logFile)
}
}
func (lfc *LogFileController) ViewLogLineFullScreen(line *models.LogLine) tea.Cmd {
if line == nil {
return nil
}
return func() tea.Msg {
return ViewLogLineFullScreen(line)
}
}

10
internal/slog-view/models/logfile.go Normal file
View file

@ -0,0 +1,10 @@
package models
type LogFile struct {
Filename string
Lines []LogLine
}
type LogLine struct {
JSON interface{}
}

44
internal/slog-view/services/logreader/logreader.go Normal file
View file

@ -0,0 +1,44 @@
package logreader
import (
"bufio"
"encoding/json"
"github.com/lmika/awstools/internal/slog-view/models"
"github.com/pkg/errors"
"log"
"os"
)
type Service struct {
}
func NewService() *Service {
return &Service{}
}
func (s *Service) Open(filename string) (*models.LogFile, error) {
f, err := os.Open(filename)
if err != nil {
return nil, errors.Wrapf(err, "cannot open file: %v", filename)
}
defer f.Close()
var lines []models.LogLine
scanner := bufio.NewScanner(f)
for scanner.Scan() {
line := scanner.Text()
var data interface{}
if err := json.Unmarshal([]byte(line), &data); err != nil {
log.Printf("invalid json line: %v", err)
continue
}
lines = append(lines, models.LogLine{JSON: data})
}
if scanner.Err() != nil {
return nil, errors.Wrapf(err, "unable to scan file: %v", filename)
}
return &models.LogFile{Lines: lines}, nil
}

65
internal/slog-view/ui/fullviewlinedetails/model.go Normal file
View file

@ -0,0 +1,65 @@
package fullviewlinedetails
import (
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/awstools/internal/slog-view/models"
"github.com/lmika/awstools/internal/slog-view/ui/linedetails"
)
type Model struct {
submodel tea.Model
lineDetails *linedetails.Model
visible bool
}
func NewModel(submodel tea.Model) *Model {
return &Model{
submodel: submodel,
lineDetails: linedetails.New(),
}
}
func (*Model) Init() tea.Cmd {
return nil
}
func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case tea.KeyMsg:
switch msg.String() {
case "esc":
m.visible = false
return m, nil
}
if m.visible {
newModel, cmd := m.lineDetails.Update(msg)
m.lineDetails = newModel.(*linedetails.Model)
return m, cmd
}
}
var cmd tea.Cmd
m.submodel, cmd = m.submodel.Update(msg)
return m, cmd
}
func (m *Model) ViewItem(item *models.LogLine) {
m.visible = true
m.lineDetails.SetSelectedItem(item)
}
func (m *Model) View() string {
if m.visible {
return m.lineDetails.View()
}
return m.submodel.View()
}
func (m *Model) Resize(w, h int) layout.ResizingModel {
m.submodel = layout.Resize(m.submodel, w, h)
m.lineDetails = layout.Resize(m.lineDetails, w, h).(*linedetails.Model)
return m
}

84
internal/slog-view/ui/linedetails/model.go Normal file
View file

@ -0,0 +1,84 @@
package linedetails
import (
"encoding/json"
"github.com/charmbracelet/bubbles/viewport"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/awstools/internal/slog-view/models"
)
var (
activeHeaderStyle = lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#9c9c9c"))
)
type Model struct {
frameTitle frame.FrameTitle
viewport viewport.Model
w, h int
// model state
focused bool
selectedItem *models.LogLine
}
func New() *Model {
viewport := viewport.New(0, 0)
viewport.SetContent("")
return &Model{
frameTitle: frame.NewFrameTitle("Item", false, activeHeaderStyle),
viewport: viewport,
}
}
func (*Model) Init() tea.Cmd {
return nil
}
func (m *Model) SetFocused(newFocused bool) {
m.focused = newFocused
}
func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case tea.KeyMsg:
if m.focused {
newModel, cmd := m.viewport.Update(msg)
m.viewport = newModel
return m, cmd
}
}
return m, nil
}
func (m *Model) SetSelectedItem(item *models.LogLine) {
m.selectedItem = item
if m.selectedItem != nil {
if formattedJson, err := json.MarshalIndent(item.JSON, "", " "); err == nil {
m.viewport.SetContent(string(formattedJson))
} else {
m.viewport.SetContent("(not json)")
}
} else {
m.viewport.SetContent("(no line)")
}
}
func (m *Model) View() string {
return lipgloss.JoinVertical(lipgloss.Top, m.frameTitle.View(), m.viewport.View())
}
func (m *Model) Resize(w, h int) layout.ResizingModel {
m.w, m.h = w, h
m.frameTitle.Resize(w, h)
m.viewport.Width = w
m.viewport.Height = h - m.frameTitle.HeaderHeight()
return m
}

5
internal/slog-view/ui/loglines/events.go Normal file
View file

@ -0,0 +1,5 @@
package loglines
import "github.com/lmika/awstools/internal/slog-view/models"
type NewLogLineSelected *models.LogLine

104
internal/slog-view/ui/loglines/model.go Normal file
View file

@ -0,0 +1,104 @@
package loglines
import (
table "github.com/calyptia/go-bubble-table"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/awstools/internal/slog-view/models"
"path/filepath"
)
var (
activeHeaderStyle = lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#9c9c9c"))
)
type Model struct {
frameTitle frame.FrameTitle
table table.Model
logFile *models.LogFile
w, h int
}
func New() *Model {
frameTitle := frame.NewFrameTitle("File: ", true, activeHeaderStyle)
table := table.New([]string{"level", "error", "message"}, 0, 0)
return &Model{
frameTitle: frameTitle,
table: table,
}
}
func (m *Model) SetLogFile(newLogFile *models.LogFile) {
m.logFile = newLogFile
m.frameTitle.SetTitle("File: " + filepath.Base(newLogFile.Filename))
cols := []string{"level", "error", "message"}
newTbl := table.New(cols, m.w, m.h-m.frameTitle.HeaderHeight())
newRows := make([]table.Row, len(newLogFile.Lines))
for i, r := range newLogFile.Lines {
newRows[i] = itemTableRow{r}
}
newTbl.SetRows(newRows)
m.table = newTbl
}
func (m *Model) Init() tea.Cmd {
return nil
}
func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
//var cmd tea.Cmd
switch msg := msg.(type) {
case tea.KeyMsg:
switch msg.String() {
case "i", "up":
m.table.GoUp()
return m, m.emitNewSelectedParameter()
case "k", "down":
m.table.GoDown()
return m, m.emitNewSelectedParameter()
}
//m.table, cmd = m.table.Update(msg)
//return m, cmd
}
return m, nil
}
func (m *Model) SelectedLogLine() *models.LogLine {
if row, ok := m.table.SelectedRow().(itemTableRow); ok {
return &(row.item)
}
return nil
}
func (m *Model) emitNewSelectedParameter() tea.Cmd {
return func() tea.Msg {
selectedLogLine := m.SelectedLogLine()
if selectedLogLine != nil {
return NewLogLineSelected(selectedLogLine)
}
return nil
}
}
func (m *Model) View() string {
return lipgloss.JoinVertical(lipgloss.Top, m.frameTitle.View(), m.table.View())
}
func (m *Model) Resize(w, h int) layout.ResizingModel {
m.w, m.h = w, h
m.frameTitle.Resize(w, h)
m.table.SetSize(w, h-m.frameTitle.HeaderHeight())
return m
}

61
internal/slog-view/ui/loglines/tblmodel.go Normal file
View file

@ -0,0 +1,61 @@
package loglines
import (
"fmt"
table "github.com/calyptia/go-bubble-table"
"github.com/lmika/awstools/internal/slog-view/models"
"io"
"strings"
)
type itemTableRow struct {
item models.LogLine
}
func (mtr itemTableRow) Render(w io.Writer, model table.Model, index int) {
// TODO: these cols are fixed, they should be dynamic
level := mtr.renderFirstLineOfField(mtr.item.JSON, "level")
err := mtr.renderFirstLineOfField(mtr.item.JSON, "error")
msg := mtr.renderFirstLineOfField(mtr.item.JSON, "message")
line := fmt.Sprintf("%s\t%s\t%s", level, err, msg)
if index == model.Cursor() {
fmt.Fprintln(w, model.Styles.SelectedRow.Render(line))
} else {
fmt.Fprintln(w, line)
}
}
// TODO: this needs to be some form of path expression
func (mtr itemTableRow) renderFirstLineOfField(d interface{}, field string) string {
switch k := d.(type) {
case map[string]interface{}:
return mtr.renderFirstLineOfValue(k[field])
default:
return mtr.renderFirstLineOfValue(k)
}
}
func (mtr itemTableRow) renderFirstLineOfValue(v interface{}) string {
if v == nil {
return ""
}
switch k := v.(type) {
case string:
firstLine := strings.SplitN(k, "\n", 2)[0]
return firstLine
case int:
return fmt.Sprint(k)
case float64:
return fmt.Sprint(k)
case bool:
return fmt.Sprint(k)
case map[string]interface{}:
return "{}"
case []interface{}:
return "[]"
default:
return "(other)"
}
}

81
internal/slog-view/ui/model.go Normal file
View file

@ -0,0 +1,81 @@
package ui
import (
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/awstools/internal/common/ui/commandctrl"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/statusandprompt"
"github.com/lmika/awstools/internal/slog-view/controllers"
"github.com/lmika/awstools/internal/slog-view/ui/fullviewlinedetails"
"github.com/lmika/awstools/internal/slog-view/ui/linedetails"
"github.com/lmika/awstools/internal/slog-view/ui/loglines"
)
type Model struct {
controller *controllers.LogFileController
cmdController *commandctrl.CommandController
root tea.Model
logLines *loglines.Model
lineDetails *linedetails.Model
statusAndPrompt *statusandprompt.StatusAndPrompt
fullViewLineDetails *fullviewlinedetails.Model
}
func NewModel(controller *controllers.LogFileController, cmdController *commandctrl.CommandController) Model {
logLines := loglines.New()
lineDetails := linedetails.New()
box := layout.NewVBox(layout.LastChildFixedAt(17), logLines, lineDetails)
fullViewLineDetails := fullviewlinedetails.NewModel(box)
statusAndPrompt := statusandprompt.New(fullViewLineDetails, "")
root := layout.FullScreen(statusAndPrompt)
return Model{
controller: controller,
cmdController: cmdController,
root: root,
statusAndPrompt: statusAndPrompt,
logLines: logLines,
lineDetails: lineDetails,
fullViewLineDetails: fullViewLineDetails,
}
}
func (m Model) Init() tea.Cmd {
return m.controller.ReadLogFile()
}
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case controllers.NewLogFile:
m.logLines.SetLogFile(msg)
case controllers.ViewLogLineFullScreen:
m.fullViewLineDetails.ViewItem(msg)
case loglines.NewLogLineSelected:
m.lineDetails.SetSelectedItem(msg)
case tea.KeyMsg:
if !m.statusAndPrompt.InPrompt() {
switch msg.String() {
// TEMP
case ":":
return m, m.cmdController.Prompt()
case "w":
return m, m.controller.ViewLogLineFullScreen(m.logLines.SelectedLogLine())
// END TEMP
case "ctrl+c", "q":
return m, tea.Quit
}
}
}
newRoot, cmd := m.root.Update(msg)
m.root = newRoot
return m, cmd
}
func (m Model) View() string {
return m.root.View()
}

15
internal/ssm-browse/controllers/events.go Normal file
View file

@ -0,0 +1,15 @@
package controllers
import (
"fmt"
"github.com/lmika/awstools/internal/ssm-browse/models"
)
type NewParameterListMsg struct {
Prefix string
Parameters *models.SSMParameters
}
func (rs NewParameterListMsg) StatusMessage() string {
return fmt.Sprintf("%d items returned", len(rs.Parameters.Items))
}

57
internal/ssm-browse/controllers/ssmcontroller.go Normal file
View file

@ -0,0 +1,57 @@
package controllers
import (
"context"
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/awstools/internal/common/ui/events"
"github.com/lmika/awstools/internal/ssm-browse/services/ssmparameters"
"sync"
)
type SSMController struct {
service *ssmparameters.Service
// state
mutex *sync.Mutex
prefix string
}
func New(service *ssmparameters.Service) *SSMController {
return &SSMController{
service: service,
prefix: "/",
mutex: new(sync.Mutex),
}
}
func (c *SSMController) Fetch() tea.Cmd {
return func() tea.Msg {
res, err := c.service.List(context.Background(), c.prefix)
if err != nil {
return events.Error(err)
}
return NewParameterListMsg{
Prefix: c.prefix,
Parameters: res,
}
}
}
func (c *SSMController) ChangePrefix(newPrefix string) tea.Cmd {
return func() tea.Msg {
res, err := c.service.List(context.Background(), newPrefix)
if err != nil {
return events.Error(err)
}
c.mutex.Lock()
defer c.mutex.Unlock()
c.prefix = newPrefix
return NewParameterListMsg{
Prefix: c.prefix,
Parameters: res,
}
}
}

10
internal/ssm-browse/models/models.go Normal file
View file

@ -0,0 +1,10 @@
package models
type SSMParameters struct {
Items []SSMParameter
}
type SSMParameter struct {
Name string
Value string
}

50
internal/ssm-browse/providers/awsssm/provider.go Normal file
View file

@ -0,0 +1,50 @@
package awsssm
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/ssm"
"github.com/lmika/awstools/internal/ssm-browse/models"
"github.com/pkg/errors"
"log"
)
type Provider struct {
client *ssm.Client
}
func NewProvider(client *ssm.Client) *Provider {
return &Provider{
client: client,
}
}
func (p *Provider) List(ctx context.Context, prefix string, maxCount int) (*models.SSMParameters, error) {
log.Printf("new prefix: %v", prefix)
pager := ssm.NewGetParametersByPathPaginator(p.client, &ssm.GetParametersByPathInput{
Path: aws.String(prefix),
Recursive: true,
WithDecryption: true,
})
items := make([]models.SSMParameter, 0)
outer: for pager.HasMorePages() {
out, err := pager.NextPage(ctx)
if err != nil {
return nil, errors.Wrap(err, "cannot get parameters from path")
}
for _, p := range out.Parameters {
items = append(items, models.SSMParameter{
Name: aws.ToString(p.Name),
Value: aws.ToString(p.Value),
})
if len(items) >= maxCount {
break outer
}
}
}
return &models.SSMParameters{Items: items}, nil
}

10
internal/ssm-browse/services/ssmparameters/iface.go Normal file
View file

@ -0,0 +1,10 @@
package ssmparameters
import (
"context"
"github.com/lmika/awstools/internal/ssm-browse/models"
)
type SSMProvider interface {
List(ctx context.Context, prefix string, maxCount int) (*models.SSMParameters, error)
}

20
internal/ssm-browse/services/ssmparameters/service.go Normal file
View file

@ -0,0 +1,20 @@
package ssmparameters
import (
"context"
"github.com/lmika/awstools/internal/ssm-browse/models"
)
type Service struct {
provider SSMProvider
}
func NewService(provider SSMProvider) *Service {
return &Service{
provider: provider,
}
}
func (s *Service) List(ctx context.Context, prefix string) (*models.SSMParameters, error) {
return s.provider.List(ctx, prefix, 100)
}

74
internal/ssm-browse/ui/model.go Normal file
View file

@ -0,0 +1,74 @@
package ui
import (
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/awstools/internal/common/ui/commandctrl"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/statusandprompt"
"github.com/lmika/awstools/internal/ssm-browse/controllers"
"github.com/lmika/awstools/internal/ssm-browse/ui/ssmdetails"
"github.com/lmika/awstools/internal/ssm-browse/ui/ssmlist"
)
type Model struct {
cmdController *commandctrl.CommandController
controller *controllers.SSMController
statusAndPrompt *statusandprompt.StatusAndPrompt
root tea.Model
ssmList *ssmlist.Model
ssmDetails *ssmdetails.Model
}
func NewModel(controller *controllers.SSMController, cmdController *commandctrl.CommandController) Model {
ssmList := ssmlist.New()
ssmdDetails := ssmdetails.New()
statusAndPrompt := statusandprompt.New(
layout.NewVBox(layout.LastChildFixedAt(17), ssmList, ssmdDetails),
"")
root := layout.FullScreen(statusAndPrompt)
return Model{
controller: controller,
cmdController: cmdController,
root: root,
statusAndPrompt: statusAndPrompt,
ssmList: ssmList,
ssmDetails: ssmdDetails,
}
}
func (m Model) Init() tea.Cmd {
return m.controller.Fetch()
}
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case controllers.NewParameterListMsg:
m.ssmList.SetPrefix(msg.Prefix)
m.ssmList.SetParameters(msg.Parameters)
case ssmlist.NewSSMParameterSelected:
m.ssmDetails.SetSelectedItem(msg)
case tea.KeyMsg:
if !m.statusAndPrompt.InPrompt() {
switch msg.String() {
// TEMP
case ":":
return m, m.cmdController.Prompt()
// END TEMP
case "ctrl+c", "q":
return m, tea.Quit
}
}
}
newRoot, cmd := m.root.Update(msg)
m.root = newRoot
return m, cmd
}
func (m Model) View() string {
return m.root.View()
}

73
internal/ssm-browse/ui/ssmdetails/model.go Normal file
View file

@ -0,0 +1,73 @@
package ssmdetails
import (
"fmt"
"github.com/charmbracelet/bubbles/viewport"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/awstools/internal/ssm-browse/models"
"strings"
)
var (
activeHeaderStyle = lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#c144ff"))
)
type Model struct {
frameTitle frame.FrameTitle
viewport viewport.Model
w, h int
// model state
hasSelectedItem bool
selectedItem *models.SSMParameter
}
func New() *Model {
viewport := viewport.New(0, 0)
viewport.SetContent("")
return &Model{
frameTitle: frame.NewFrameTitle("Item", false, activeHeaderStyle),
viewport: viewport,
}
}
func (*Model) Init() tea.Cmd {
return nil
}
func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
return m, nil
}
func (m *Model) SetSelectedItem(item *models.SSMParameter) {
m.selectedItem = item
if m.selectedItem != nil {
var viewportContents strings.Builder
fmt.Fprintf(&viewportContents, "Name: %v\n\n", item.Name)
fmt.Fprintf(&viewportContents, "Type: TODO\n\n")
fmt.Fprintf(&viewportContents, "%v\n", item.Value)
m.viewport.SetContent(viewportContents.String())
} else {
m.viewport.SetContent("(no parameter selected)")
}
}
func (m *Model) View() string {
return lipgloss.JoinVertical(lipgloss.Top, m.frameTitle.View(), m.viewport.View())
}
func (m *Model) Resize(w, h int) layout.ResizingModel {
m.w, m.h = w, h
m.frameTitle.Resize(w, h)
m.viewport.Width = w
m.viewport.Height = h - m.frameTitle.HeaderHeight()
return m
}

5
internal/ssm-browse/ui/ssmlist/events.go Normal file
View file

@ -0,0 +1,5 @@
package ssmlist
import "github.com/lmika/awstools/internal/ssm-browse/models"
type NewSSMParameterSelected *models.SSMParameter

97
internal/ssm-browse/ui/ssmlist/ssmlist.go Normal file
View file

@ -0,0 +1,97 @@
package ssmlist
import (
table "github.com/calyptia/go-bubble-table"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/awstools/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/awstools/internal/ssm-browse/models"
)
var (
activeHeaderStyle = lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#c144ff"))
)
type Model struct {
frameTitle frame.FrameTitle
table table.Model
parameters *models.SSMParameters
w, h int
}
func New() *Model {
frameTitle := frame.NewFrameTitle("SSM: /", true, activeHeaderStyle)
table := table.New([]string{"name", "type", "value"}, 0, 0)
return &Model{
frameTitle: frameTitle,
table: table,
}
}
func (m *Model) SetPrefix(newPrefix string) {
m.frameTitle.SetTitle("SSM: " + newPrefix)
}
func (m *Model) SetParameters(parameters *models.SSMParameters) {
m.parameters = parameters
cols := []string{"name", "type", "value"}
newTbl := table.New(cols, m.w, m.h-m.frameTitle.HeaderHeight())
newRows := make([]table.Row, len(parameters.Items))
for i, r := range parameters.Items {
newRows[i] = itemTableRow{r}
}
newTbl.SetRows(newRows)
m.table = newTbl
}
func (m *Model) Init() tea.Cmd {
return nil
}
func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
//var cmd tea.Cmd
switch msg := msg.(type) {
case tea.KeyMsg:
switch msg.String() {
case "i", "up":
m.table.GoUp()
return m, m.emitNewSelectedParameter()
case "k", "down":
m.table.GoDown()
return m, m.emitNewSelectedParameter()
}
//m.table, cmd = m.table.Update(msg)
//return m, cmd
}
return m, nil
}
func (m *Model) emitNewSelectedParameter() tea.Cmd {
return func() tea.Msg {
if row, ok := m.table.SelectedRow().(itemTableRow); ok {
return NewSSMParameterSelected(&(row.item))
}
return nil
}
}
func (m *Model) View() string {
return lipgloss.JoinVertical(lipgloss.Top, m.frameTitle.View(), m.table.View())
}
func (m *Model) Resize(w, h int) layout.ResizingModel {
m.w, m.h = w, h
m.frameTitle.Resize(w, h)
m.table.SetSize(w, h-m.frameTitle.HeaderHeight())
return m
}

24
internal/ssm-browse/ui/ssmlist/tblmodel.go Normal file
View file

@ -0,0 +1,24 @@
package ssmlist
import (
"fmt"
table "github.com/calyptia/go-bubble-table"
"github.com/lmika/awstools/internal/ssm-browse/models"
"io"
"strings"
)
type itemTableRow struct {
item models.SSMParameter
}
func (mtr itemTableRow) Render(w io.Writer, model table.Model, index int) {
firstLine := strings.SplitN(mtr.item.Value, "\n", 2)[0]
line := fmt.Sprintf("%s\t%s\t%s", mtr.item.Name, "String", firstLine)
if index == model.Cursor() {
fmt.Fprintln(w, model.Styles.SelectedRow.Render(line))
} else {
fmt.Fprintln(w, line)
}
}