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

Removed the other tools and fixed the README.md file

Browse source
This commit is contained in:
Leon Mika 2023-02-23 21:45:50 +11:00
parent ab309084c5
commit 937af987e6
41 changed files with 12 additions and 2006 deletions
Download patch file Download diff file Expand all files Collapse all files

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

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

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

@ -1,47 +0,0 @@
package controllers
import (
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/audax/internal/common/ui/events"
"github.com/lmika/audax/internal/slog-view/models"
"github.com/lmika/audax/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
View file

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

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

@ -1,44 +0,0 @@
package logreader
import (
"bufio"
"encoding/json"
"github.com/lmika/audax/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
}

29
internal/slog-view/styles/styles.go
View file

@ -1,29 +0,0 @@
package styles
import (
"github.com/charmbracelet/lipgloss"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/statusandprompt"
)
type Styles struct {
Frames frame.Style
StatusAndPrompt statusandprompt.Style
}
var DefaultStyles = Styles{
Frames: frame.Style{
ActiveTitle: lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#000000")).
Background(lipgloss.Color("#d1d1d1")),
InactiveTitle: lipgloss.NewStyle().
Foreground(lipgloss.Color("#000000")).
Background(lipgloss.Color("#d1d1d1")),
},
StatusAndPrompt: statusandprompt.Style{
ModeLine: lipgloss.NewStyle().
Foreground(lipgloss.Color("#000000")).
Background(lipgloss.Color("#d1d1d1")),
},
}

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

@ -1,67 +0,0 @@
package fullviewlinedetails
import (
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/audax/internal/slog-view/models"
"github.com/lmika/audax/internal/slog-view/ui/linedetails"
)
type Model struct {
submodel tea.Model
lineDetails *linedetails.Model
visible bool
}
func NewModel(submodel tea.Model, style frame.Style) *Model {
return &Model{
submodel: submodel,
lineDetails: linedetails.New(style),
}
}
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)
m.lineDetails.SetFocused(true)
}
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
}

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

@ -1,77 +0,0 @@
package linedetails
import (
"encoding/json"
"github.com/charmbracelet/bubbles/viewport"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/audax/internal/slog-view/models"
)
type Model struct {
frameTitle frame.FrameTitle
viewport viewport.Model
w, h int
// model state
focused bool
selectedItem *models.LogLine
}
func New(style frame.Style) *Model {
viewport := viewport.New(0, 0)
viewport.SetContent("")
return &Model{
frameTitle: frame.NewFrameTitle("Item", false, style),
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
View file

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

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

@ -1,97 +0,0 @@
package loglines
import (
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/audax/internal/slog-view/models"
table "github.com/lmika/go-bubble-table"
"path/filepath"
)
type Model struct {
frameTitle frame.FrameTitle
table table.Model
logFile *models.LogFile
w, h int
}
func New(style frame.Style) *Model {
frameTitle := frame.NewFrameTitle("File: ", true, style)
table := table.New(table.SimpleColumns{"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 := table.SimpleColumns{"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
View file

@ -1,61 +0,0 @@
package loglines
import (
"fmt"
table "github.com/lmika/go-bubble-table"
"github.com/lmika/audax/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)"
}
}

83
internal/slog-view/ui/model.go
View file

@ -1,83 +0,0 @@
package ui
import (
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/audax/internal/common/ui/commandctrl"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/statusandprompt"
"github.com/lmika/audax/internal/slog-view/controllers"
"github.com/lmika/audax/internal/slog-view/styles"
"github.com/lmika/audax/internal/slog-view/ui/fullviewlinedetails"
"github.com/lmika/audax/internal/slog-view/ui/linedetails"
"github.com/lmika/audax/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 {
defaultStyles := styles.DefaultStyles
logLines := loglines.New(defaultStyles.Frames)
lineDetails := linedetails.New(defaultStyles.Frames)
box := layout.NewVBox(layout.LastChildFixedAt(17), logLines, lineDetails)
fullViewLineDetails := fullviewlinedetails.NewModel(box, defaultStyles.Frames)
statusAndPrompt := statusandprompt.New(fullViewLineDetails, "", defaultStyles.StatusAndPrompt)
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, func() tea.Msg { return 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()
}

40
internal/sqs-browse/controllers/forward.go
View file

@ -1,40 +0,0 @@
package controllers
import (
"context"
"github.com/lmika/audax/internal/common/ui/uimodels"
"github.com/lmika/audax/internal/sqs-browse/models"
"github.com/lmika/audax/internal/sqs-browse/services/messages"
"github.com/pkg/errors"
)
type MessageSendingController struct {
messageService *messages.Service
targetQueue string
}
func NewMessageSendingController(messageService *messages.Service, targetQueue string) *MessageSendingController {
return &MessageSendingController{
messageService: messageService,
targetQueue: targetQueue,
}
}
func (msh *MessageSendingController) ForwardMessage(message models.Message) uimodels.Operation {
return uimodels.OperationFn(func(ctx context.Context) error {
uiCtx := uimodels.Ctx(ctx)
if msh.targetQueue == "" {
return errors.New("target queue not set")
}
messageId, err := msh.messageService.SendTo(ctx, message, msh.targetQueue)
if err != nil {
return errors.Wrapf(err, "cannot send message to %v", msh.targetQueue)
}
uiCtx.Message("Message sent to " + msh.targetQueue + ", id = " + messageId)
return nil
})
}

11
internal/sqs-browse/models/message.go
View file

@ -1,11 +0,0 @@
package models
import "time"
type Message struct {
ID uint64 `storm:"id,increment"`
ExtID string `storm:"unique"`
Queue string `storm:"index"`
Received time.Time
Data string
}

78
internal/sqs-browse/providers/sqs/provider.go
View file

@ -1,78 +0,0 @@
package sqs
import (
"context"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/sqs"
"github.com/aws/aws-sdk-go-v2/service/sqs/types"
"github.com/lmika/audax/internal/sqs-browse/models"
"github.com/pkg/errors"
)
type Provider struct {
client *sqs.Client
}
func NewProvider(client *sqs.Client) *Provider {
return &Provider{client: client}
}
func (p *Provider) SendMessage(ctx context.Context, msg models.Message, queue string) (string, error) {
// TEMP :: queue URL
out, err := p.client.SendMessage(ctx, &sqs.SendMessageInput{
QueueUrl: aws.String(queue),
MessageBody: aws.String(msg.Data),
})
if err != nil {
return "", errors.Wrapf(err, "unable to send message to %v", queue)
}
return aws.ToString(out.MessageId), nil
}
func (p *Provider) PollForNewMessages(ctx context.Context, queue string) ([]*models.Message, error) {
out, err := p.client.ReceiveMessage(ctx, &sqs.ReceiveMessageInput{
QueueUrl: aws.String(queue),
MaxNumberOfMessages: 10,
WaitTimeSeconds: 20,
})
if err != nil {
return nil, errors.Wrapf(err, "unable to receive messages from queue %v", queue)
}
if len(out.Messages) == 0 {
return nil, nil
}
messagesToReturn := make([]*models.Message, 0, len(out.Messages))
messagesToDelete := make([]types.DeleteMessageBatchRequestEntry, 0, len(out.Messages))
for _, msg := range out.Messages {
newLocalMessage := &models.Message{
Queue: queue,
ExtID: aws.ToString(msg.MessageId),
Received: time.Now(),
Data: aws.ToString(msg.Body),
}
messagesToReturn = append(messagesToReturn, newLocalMessage)
// Pull the message from the queue
// TODO: should this be determined by the caller?
messagesToDelete = append(messagesToDelete, types.DeleteMessageBatchRequestEntry{
Id: msg.MessageId,
ReceiptHandle: msg.ReceiptHandle,
})
}
if _, err := p.client.DeleteMessageBatch(ctx, &sqs.DeleteMessageBatchInput{
QueueUrl: aws.String(queue),
Entries: messagesToDelete,
}); err != nil {
log.Printf("error deleting messages from queue: %v", err)
}
return messagesToReturn, nil
}

31
internal/sqs-browse/providers/stormstore/memstore.go
View file

@ -1,31 +0,0 @@
package stormstore
import (
"context"
"github.com/asdine/storm"
"github.com/lmika/audax/internal/sqs-browse/models"
"github.com/pkg/errors"
)
type Store struct {
db *storm.DB
}
// TODO: should probably be a workspace provider
func NewStore(filename string) (*Store, error) {
db, err := storm.Open(filename)
if err != nil {
return nil, errors.Wrapf(err, "cannot open store %v", filename)
}
return &Store{db: db}, nil
}
func (s *Store) Close() {
s.db.Close()
}
func (s *Store) Save(ctx context.Context, msg *models.Message) error {
return s.db.Save(msg)
}

11
internal/sqs-browse/services/messages/iface.go
View file

@ -1,11 +0,0 @@
package messages
import (
"context"
"github.com/lmika/audax/internal/sqs-browse/models"
)
type MessageSender interface {
SendMessage(ctx context.Context, msg models.Message, queue string) (string, error)
}

26
internal/sqs-browse/services/messages/service.go
View file

@ -1,26 +0,0 @@
package messages
import (
"context"
"github.com/lmika/audax/internal/sqs-browse/models"
"github.com/pkg/errors"
)
type Service struct {
messageSender MessageSender
}
func NewService(messageSender MessageSender) *Service {
return &Service{
messageSender: messageSender,
}
}
func (s *Service) SendTo(ctx context.Context, msg models.Message, destQueue string) (string, error) {
messageId, err := s.messageSender.SendMessage(ctx, msg, destQueue)
if err != nil {
return "", errors.Wrapf(err, "cannot send message to %v", destQueue)
}
return messageId, nil
}

15
internal/sqs-browse/services/pollmessage/iface.go
View file

@ -1,15 +0,0 @@
package pollmessage
import (
"context"
"github.com/lmika/audax/internal/sqs-browse/models"
)
type MessageStore interface {
Save(ctx context.Context, msg *models.Message) error
}
type MessagePoller interface {
PollForNewMessages(ctx context.Context, queue string) ([]*models.Message, error)
}

46
internal/sqs-browse/services/pollmessage/service.go
View file

@ -1,46 +0,0 @@
package pollmessage
import (
"context"
"log"
"github.com/lmika/events"
"github.com/pkg/errors"
)
type Service struct {
store MessageStore
poller MessagePoller
queue string
bus *events.Bus
}
func NewService(store MessageStore, poller MessagePoller, queue string, bus *events.Bus) *Service {
return &Service{
store: store,
poller: poller,
queue: queue,
bus: bus,
}
}
// Poll starts polling for new messages and adding them to the message store
func (s *Service) Poll(ctx context.Context) error {
for ctx.Err() == nil {
log.Printf("polling for new messages: %v", s.queue)
newMsgs, err := s.poller.PollForNewMessages(ctx, s.queue)
if err != nil {
return errors.Wrap(err, "unable to poll for messages")
}
for _, msg := range newMsgs {
if err := s.store.Save(ctx, msg); err != nil {
log.Printf("warn: unable to save new message %v", err)
continue
}
}
s.bus.Fire("new-messages", newMsgs)
}
return nil
}

29
internal/sqs-browse/styles/styles.go
View file

@ -1,29 +0,0 @@
package styles
import (
"github.com/charmbracelet/lipgloss"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/statusandprompt"
)
type Styles struct {
Frames frame.Style
StatusAndPrompt statusandprompt.Style
}
var DefaultStyles = Styles{
Frames: frame.Style{
ActiveTitle: lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#4479ff")),
InactiveTitle: lipgloss.NewStyle().
Foreground(lipgloss.Color("#000000")).
Background(lipgloss.Color("#d1d1d1")),
},
StatusAndPrompt: statusandprompt.Style{
ModeLine: lipgloss.NewStyle().
Foreground(lipgloss.Color("#000000")).
Background(lipgloss.Color("#d1d1d1")),
},
}

5
internal/sqs-browse/ui/events.go
View file

@ -1,5 +0,0 @@
package ui
import "github.com/lmika/audax/internal/sqs-browse/models"
type NewMessagesEvent []*models.Message

232
internal/sqs-browse/ui/model.go
View file

@ -1,232 +0,0 @@
package ui
import (
"bytes"
"context"
"encoding/json"
"log"
"strings"
"github.com/charmbracelet/bubbles/textinput"
"github.com/charmbracelet/bubbles/viewport"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/audax/internal/common/ui/dispatcher"
"github.com/lmika/audax/internal/common/ui/events"
"github.com/lmika/audax/internal/sqs-browse/controllers"
"github.com/lmika/audax/internal/sqs-browse/models"
table "github.com/lmika/go-bubble-table"
)
var (
activeHeaderStyle = lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#eac610"))
inactiveHeaderStyle = lipgloss.NewStyle().
Foreground(lipgloss.Color("#000000")).
Background(lipgloss.Color("#d1d1d1"))
)
type uiModel struct {
table table.Model
viewport viewport.Model
ready bool
tableRows []table.Row
message string
pendingInput *events.PromptForInputMsg
textInput textinput.Model
dispatcher *dispatcher.Dispatcher
msgSendingHandlers *controllers.MessageSendingController
}
func NewModel(dispatcher *dispatcher.Dispatcher, msgSendingHandlers *controllers.MessageSendingController) tea.Model {
tbl := table.New(table.SimpleColumns{"seq", "message"}, 100, 20)
rows := make([]table.Row, 0)
tbl.SetRows(rows)
textInput := textinput.New()
model := uiModel{
table: tbl,
tableRows: rows,
message: "",
textInput: textInput,
msgSendingHandlers: msgSendingHandlers,
dispatcher: dispatcher,
}
return model
}
func (m uiModel) Init() tea.Cmd {
return nil
}
func (m *uiModel) updateViewportToSelectedMessage() {
if message, ok := m.selectedMessage(); ok {
// TODO: not all messages are JSON
formattedJson := new(bytes.Buffer)
if err := json.Indent(formattedJson, []byte(message.Data), "", " "); err == nil {
m.viewport.SetContent(formattedJson.String())
} else {
m.viewport.SetContent(message.Data)
}
} else {
m.viewport.SetContent("(no message selected)")
}
}
func (m uiModel) selectedMessage() (models.Message, bool) {
if m.ready && len(m.tableRows) > 0 {
if message, ok := m.table.SelectedRow().(messageTableRow); ok {
return models.Message(message), true
}
}
return models.Message{}, false
}
func (m uiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
var textInputCommands tea.Cmd
switch msg := msg.(type) {
// Shared messages
case events.ErrorMsg:
m.message = "Error: " + msg.Error()
case events.StatusMsg:
m.message = string(msg)
case events.PromptForInputMsg:
// TODO
//m.textInput.Focus()
//m.textInput.SetValue("")
//m.pendingInput = &msg
// Local messages
case NewMessagesEvent:
for _, newMsg := range msg {
m.tableRows = append(m.tableRows, messageTableRow(*newMsg))
}
m.table.SetRows(m.tableRows)
m.updateViewportToSelectedMessage()
case tea.WindowSizeMsg:
fixedViewsHeight := lipgloss.Height(m.headerView()) + lipgloss.Height(m.splitterView()) + lipgloss.Height(m.footerView())
if !m.ready {
tableHeight := msg.Height / 2
m.table.SetSize(msg.Width, tableHeight)
m.viewport = viewport.New(msg.Width, msg.Height-tableHeight-fixedViewsHeight)
m.viewport.SetContent("(no message selected)")
m.ready = true
log.Println("Viewport is now ready")
} else {
tableHeight := msg.Height / 2
m.table.SetSize(msg.Width, tableHeight)
m.viewport.Width = msg.Width
m.viewport.Height = msg.Height - tableHeight - fixedViewsHeight
}
m.textInput.Width = msg.Width
m.textInput, textInputCommands = m.textInput.Update(msg)
case tea.KeyMsg:
// If text input in focus, allow that to accept input messages
if m.pendingInput != nil {
switch msg.String() {
case "ctrl+c", "esc":
m.pendingInput = nil
case "enter":
//m.dispatcher.Start(uimodels.WithPromptValue(context.Background(), m.textInput.Value()), m.pendingInput.OnDone)
m.pendingInput = nil
default:
m.textInput, textInputCommands = m.textInput.Update(msg)
}
break
}
// Normal focus
switch msg.String() {
case "ctrl+c", "q":
return m, tea.Quit
case "up", "i":
m.table.GoUp()
m.updateViewportToSelectedMessage()
case "down", "k":
m.table.GoDown()
m.updateViewportToSelectedMessage()
// TODO: these should be moved somewhere else
case "f":
if selectedMessage, ok := m.selectedMessage(); ok {
m.dispatcher.Start(context.Background(), m.msgSendingHandlers.ForwardMessage(selectedMessage))
}
}
default:
m.textInput, textInputCommands = m.textInput.Update(msg)
}
updatedTable, tableMsgs := m.table.Update(msg)
updatedViewport, viewportMsgs := m.viewport.Update(msg)
m.table = updatedTable
m.viewport = updatedViewport
return m, tea.Batch(textInputCommands, tableMsgs, viewportMsgs)
}
func (m uiModel) View() string {
if !m.ready {
return "Initializing"
}
if m.pendingInput != nil {
return lipgloss.JoinVertical(lipgloss.Top,
m.headerView(),
m.table.View(),
m.splitterView(),
m.viewport.View(),
m.textInput.View(),
)
}
return lipgloss.JoinVertical(lipgloss.Top,
m.headerView(),
m.table.View(),
m.splitterView(),
m.viewport.View(),
m.footerView(),
)
}
func (m uiModel) headerView() string {
title := activeHeaderStyle.Render("Queue: XXX")
line := activeHeaderStyle.Render(strings.Repeat(" ", max(0, m.viewport.Width-lipgloss.Width(title))))
return lipgloss.JoinHorizontal(lipgloss.Left, title, line)
}
func (m uiModel) splitterView() string {
title := inactiveHeaderStyle.Render("Message")
line := inactiveHeaderStyle.Render(strings.Repeat(" ", max(0, m.viewport.Width-lipgloss.Width(title))))
return lipgloss.JoinHorizontal(lipgloss.Left, title, line)
}
func (m uiModel) footerView() string {
title := m.message
line := strings.Repeat(" ", max(0, m.viewport.Width-lipgloss.Width(title)))
return lipgloss.JoinHorizontal(lipgloss.Left, title, line)
}
func max(a, b int) int {
if a > b {
return a
}
return b
}

27
internal/sqs-browse/ui/tblmodel.go
View file

@ -1,27 +0,0 @@
package ui
import (
"fmt"
"io"
"strings"
table "github.com/lmika/go-bubble-table"
"github.com/lmika/audax/internal/sqs-browse/models"
)
type messageTableRow models.Message
func (mtr messageTableRow) Render(w io.Writer, model table.Model, index int) {
firstLine := strings.SplitN(string(mtr.Data), "\n", 2)[0]
sb := strings.Builder{}
sb.WriteString(fmt.Sprintf("%d", mtr.ID))
sb.WriteString("\t")
sb.WriteString(firstLine)
if index == model.Cursor() {
fmt.Fprintln(w, model.Styles.SelectedRow.Render(sb.String()))
} else {
fmt.Fprintln(w, sb.String())
}
}

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

@ -1,15 +0,0 @@
package controllers
import (
"fmt"
"github.com/lmika/audax/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))
}

96
internal/ssm-browse/controllers/ssmcontroller.go
View file

@ -1,96 +0,0 @@
package controllers
import (
"context"
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/audax/internal/common/ui/events"
"github.com/lmika/audax/internal/ssm-browse/models"
"github.com/lmika/audax/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.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,
}
}
func (c *SSMController) Clone(param models.SSMParameter) tea.Msg {
return events.PromptForInput("New key: ", nil, func(value string) tea.Msg {
return func() tea.Msg {
ctx := context.Background()
if err := c.service.Clone(ctx, param, value); err != nil {
return events.Error(err)
}
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) DeleteParameter(param models.SSMParameter) tea.Msg {
return events.ConfirmYes("delete parameter? ", func() tea.Msg {
ctx := context.Background()
if err := c.service.Delete(ctx, param); err != nil {
return events.Error(err)
}
res, err := c.service.List(context.Background(), c.prefix)
if err != nil {
return events.Error(err)
}
return NewParameterListMsg{
Prefix: c.prefix,
Parameters: res,
}
})
}

13
internal/ssm-browse/models/models.go
View file

@ -1,13 +0,0 @@
package models
import "github.com/aws/aws-sdk-go-v2/service/ssm/types"
type SSMParameters struct {
Items []SSMParameter
}
type SSMParameter struct {
Name string
Type types.ParameterType
Value string
}

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

@ -1,84 +0,0 @@
package awsssm
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/ssm"
"github.com/aws/aws-sdk-go-v2/service/ssm/types"
"github.com/lmika/audax/internal/ssm-browse/models"
"github.com/pkg/errors"
"log"
)
const defaultKMSKeyIDForSecureStrings = "alias/aws/ssm"
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),
Type: p.Type,
Value: aws.ToString(p.Value),
})
if len(items) >= maxCount {
break outer
}
}
}
return &models.SSMParameters{Items: items}, nil
}
func (p *Provider) Put(ctx context.Context, param models.SSMParameter, override bool) error {
in := &ssm.PutParameterInput{
Name: aws.String(param.Name),
Type: param.Type,
Value: aws.String(param.Value),
Overwrite: override,
}
if param.Type == types.ParameterTypeSecureString {
in.KeyId = aws.String(defaultKMSKeyIDForSecureStrings)
}
_, err := p.client.PutParameter(ctx, in)
if err != nil {
return errors.Wrap(err, "unable to put new SSM parameter")
}
return nil
}
func (p *Provider) Delete(ctx context.Context, param models.SSMParameter) error {
_, err := p.client.DeleteParameter(ctx, &ssm.DeleteParameterInput{
Name: aws.String(param.Name),
})
if err != nil {
return errors.Wrap(err, "unable to delete SSM parameter")
}
return nil
}

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

@ -1,12 +0,0 @@
package ssmparameters
import (
"context"
"github.com/lmika/audax/internal/ssm-browse/models"
)
type SSMProvider interface {
List(ctx context.Context, prefix string, maxCount int) (*models.SSMParameters, error)
Put(ctx context.Context, param models.SSMParameter, override bool) error
Delete(ctx context.Context, param models.SSMParameter) error
}

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

@ -1,33 +0,0 @@
package ssmparameters
import (
"context"
"github.com/lmika/audax/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)
}
func (s *Service) Clone(ctx context.Context, param models.SSMParameter, newName string) error {
newParam := models.SSMParameter{
Name: newName,
Type: param.Type,
Value: param.Value,
}
return s.provider.Put(ctx, newParam, false)
}
func (s *Service) Delete(ctx context.Context, param models.SSMParameter) error {
return s.provider.Delete(ctx, param)
}

29
internal/ssm-browse/styles/styles.go
View file

@ -1,29 +0,0 @@
package styles
import (
"github.com/charmbracelet/lipgloss"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/statusandprompt"
)
type Styles struct {
Frames frame.Style
StatusAndPrompt statusandprompt.Style
}
var DefaultStyles = Styles{
Frames: frame.Style{
ActiveTitle: lipgloss.NewStyle().
Bold(true).
Foreground(lipgloss.Color("#ffffff")).
Background(lipgloss.Color("#c144ff")),
InactiveTitle: lipgloss.NewStyle().
Foreground(lipgloss.Color("#000000")).
Background(lipgloss.Color("#d1d1d1")),
},
StatusAndPrompt: statusandprompt.Style{
ModeLine: lipgloss.NewStyle().
Foreground(lipgloss.Color("#000000")).
Background(lipgloss.Color("#d1d1d1")),
},
}

94
internal/ssm-browse/ui/model.go
View file

@ -1,94 +0,0 @@
package ui
import (
tea "github.com/charmbracelet/bubbletea"
"github.com/lmika/audax/internal/common/ui/commandctrl"
"github.com/lmika/audax/internal/common/ui/events"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/statusandprompt"
"github.com/lmika/audax/internal/ssm-browse/controllers"
"github.com/lmika/audax/internal/ssm-browse/styles"
"github.com/lmika/audax/internal/ssm-browse/ui/ssmdetails"
"github.com/lmika/audax/internal/ssm-browse/ui/ssmlist"
"github.com/pkg/errors"
)
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 {
defaultStyles := styles.DefaultStyles
ssmList := ssmlist.New(defaultStyles.Frames)
ssmdDetails := ssmdetails.New(defaultStyles.Frames)
statusAndPrompt := statusandprompt.New(
layout.NewVBox(layout.LastChildFixedAt(17), ssmList, ssmdDetails), "", defaultStyles.StatusAndPrompt)
cmdController.AddCommands(&commandctrl.CommandList{
Commands: map[string]commandctrl.Command{
"clone": func(ec commandctrl.ExecContext, args []string) tea.Msg {
if currentParam := ssmList.CurrentParameter(); currentParam != nil {
return controller.Clone(*currentParam)
}
return events.Error(errors.New("no parameter selected"))
},
"delete": func(ec commandctrl.ExecContext, args []string) tea.Msg {
if currentParam := ssmList.CurrentParameter(); currentParam != nil {
return controller.DeleteParameter(*currentParam)
}
return events.Error(errors.New("no parameter selected"))
},
},
})
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, func() tea.Msg { return 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()
}

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

@ -1,66 +0,0 @@
package ssmdetails
import (
"fmt"
"github.com/charmbracelet/bubbles/viewport"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/audax/internal/ssm-browse/models"
"strings"
)
type Model struct {
frameTitle frame.FrameTitle
viewport viewport.Model
w, h int
// model state
hasSelectedItem bool
selectedItem *models.SSMParameter
}
func New(style frame.Style) *Model {
viewport := viewport.New(0, 0)
viewport.SetContent("")
return &Model{
frameTitle: frame.NewFrameTitle("Item", false, style),
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
View file

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

98
internal/ssm-browse/ui/ssmlist/ssmlist.go
View file

@ -1,98 +0,0 @@
package ssmlist
import (
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/lipgloss"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/frame"
"github.com/lmika/audax/internal/dynamo-browse/ui/teamodels/layout"
"github.com/lmika/audax/internal/ssm-browse/models"
table "github.com/lmika/go-bubble-table"
)
type Model struct {
frameTitle frame.FrameTitle
table table.Model
parameters *models.SSMParameters
w, h int
}
func New(style frame.Style) *Model {
frameTitle := frame.NewFrameTitle("SSM: /", true, style)
table := table.New(table.SimpleColumns{"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 := table.SimpleColumns{"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) CurrentParameter() *models.SSMParameter {
if row, ok := m.table.SelectedRow().(itemTableRow); ok {
return &(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
View file

@ -1,24 +0,0 @@
package ssmlist
import (
"fmt"
table "github.com/lmika/go-bubble-table"
"github.com/lmika/audax/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, mtr.item.Type, firstLine)
if index == model.Cursor() {
fmt.Fprintln(w, model.Styles.SelectedRow.Render(line))
} else {
fmt.Fprintln(w, line)
}
}