601 lines
14 KiB
Go
601 lines
14 KiB
Go
package app
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"slices"
|
|
"sort"
|
|
"strings"
|
|
|
|
"coopcloud.tech/abra/cli/internal"
|
|
appPkg "coopcloud.tech/abra/pkg/app"
|
|
"coopcloud.tech/abra/pkg/autocomplete"
|
|
"coopcloud.tech/abra/pkg/i18n"
|
|
"coopcloud.tech/abra/pkg/log"
|
|
"coopcloud.tech/abra/pkg/recipe"
|
|
"coopcloud.tech/tagcmp"
|
|
"github.com/charmbracelet/bubbles/key"
|
|
"github.com/charmbracelet/bubbles/spinner"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
"github.com/evertras/bubble-table/table"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
type appStatus struct {
|
|
Server string `json:"server"`
|
|
Recipe string `json:"recipe"`
|
|
AppName string `json:"appName"`
|
|
Domain string `json:"domain"`
|
|
Status string `json:"status"`
|
|
Chaos string `json:"chaos"`
|
|
ChaosVersion string `json:"chaosVersion"`
|
|
AutoUpdate string `json:"autoUpdate"`
|
|
Version string `json:"version"`
|
|
Upgrade string `json:"upgrade"`
|
|
}
|
|
|
|
type serverStatus struct {
|
|
Apps []appStatus `json:"apps"`
|
|
AppCount int `json:"appCount"`
|
|
VersionCount int `json:"versionCount"`
|
|
UnversionedCount int `json:"unversionedCount"`
|
|
LatestCount int `json:"latestCount"`
|
|
UpgradeCount int `json:"upgradeCount"`
|
|
}
|
|
|
|
// translators: `abra app list` aliases. use a comma separated list of aliases with
|
|
// no spaces in between
|
|
var appListAliases = i18n.G("ls")
|
|
|
|
var AppListCommand = &cobra.Command{
|
|
// translators: `app list` command
|
|
Use: i18n.G("list [flags]"),
|
|
Aliases: strings.Split(appListAliases, ","),
|
|
// translators: Short description for `app list` command
|
|
Short: i18n.G("List all managed apps"),
|
|
Long: i18n.G(`Generate a report of all managed apps.
|
|
|
|
Use "--status/-S" flag to query all servers for the live deployment status.`),
|
|
Example: i18n.G(` # list apps of all servers without live status
|
|
abra app ls
|
|
|
|
# list apps of a specific server with live status
|
|
abra app ls -s 1312.net -S
|
|
|
|
# list apps of all servers which match a specific recipe
|
|
abra app ls -r gitea`),
|
|
Args: cobra.NoArgs,
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
appFiles, err := appPkg.LoadAppFiles(listAppServer)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
apps, err := appPkg.GetApps(appFiles, recipeFilter)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
sort.Sort(appPkg.ByServerAndRecipe(apps))
|
|
|
|
statuses := make(map[string]map[string]string)
|
|
if status && internal.MachineReadable {
|
|
alreadySeen := make(map[string]bool)
|
|
for _, app := range apps {
|
|
if _, ok := alreadySeen[app.Server]; !ok {
|
|
alreadySeen[app.Server] = true
|
|
}
|
|
}
|
|
|
|
statuses, err = appPkg.GetAppStatuses(apps, internal.MachineReadable)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
var totalServersCount int
|
|
var totalAppsCount int
|
|
allStats := make(map[string]serverStatus)
|
|
for _, app := range apps {
|
|
var stats serverStatus
|
|
var ok bool
|
|
if stats, ok = allStats[app.Server]; !ok {
|
|
stats = serverStatus{}
|
|
if recipeFilter == "" {
|
|
// count server, no filtering
|
|
totalServersCount++
|
|
}
|
|
}
|
|
|
|
if app.Recipe.Name == recipeFilter || recipeFilter == "" {
|
|
if recipeFilter != "" {
|
|
// only count server if matches filter
|
|
totalServersCount++
|
|
}
|
|
|
|
appStats := appStatus{}
|
|
stats.AppCount++
|
|
totalAppsCount++
|
|
|
|
if status && internal.MachineReadable {
|
|
status := i18n.G("unknown")
|
|
version := i18n.G("unknown")
|
|
chaos := i18n.G("unknown")
|
|
chaosVersion := i18n.G("unknown")
|
|
autoUpdate := i18n.G("unknown")
|
|
if statusMeta, ok := statuses[app.StackName()]; ok {
|
|
if currentVersion, exists := statusMeta["version"]; exists {
|
|
if currentVersion != "" {
|
|
version = currentVersion
|
|
}
|
|
}
|
|
if chaosDeploy, exists := statusMeta["chaos"]; exists {
|
|
chaos = chaosDeploy
|
|
}
|
|
if chaosDeployVersion, exists := statusMeta["chaosVersion"]; exists {
|
|
chaosVersion = chaosDeployVersion
|
|
}
|
|
if autoUpdateState, exists := statusMeta["autoUpdate"]; exists {
|
|
autoUpdate = autoUpdateState
|
|
}
|
|
if statusMeta["status"] != "" {
|
|
status = statusMeta["status"]
|
|
}
|
|
stats.VersionCount++
|
|
} else {
|
|
stats.UnversionedCount++
|
|
}
|
|
|
|
appStats.Status = status
|
|
appStats.Chaos = chaos
|
|
appStats.ChaosVersion = chaosVersion
|
|
appStats.Version = version
|
|
appStats.AutoUpdate = autoUpdate
|
|
|
|
var newUpdates []string
|
|
if version != "unknown" && chaos == "false" {
|
|
if err := app.Recipe.EnsureExists(); err != nil {
|
|
log.Fatal(i18n.G("unable to clone %s: %s", app.Name, err))
|
|
}
|
|
|
|
updates, err := app.Recipe.Tags()
|
|
if err != nil {
|
|
log.Fatal(i18n.G("unable to retrieve tags for %s: %s", app.Name, err))
|
|
}
|
|
|
|
parsedVersion, err := tagcmp.Parse(version)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
for _, update := range updates {
|
|
if ok := tagcmp.IsParsable(update); !ok {
|
|
log.Debug(i18n.G("unable to parse %s, skipping as upgrade option", update))
|
|
continue
|
|
}
|
|
|
|
parsedUpdate, err := tagcmp.Parse(update)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
if update != version && parsedUpdate.IsGreaterThan(parsedVersion) {
|
|
newUpdates = append(newUpdates, update)
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(newUpdates) == 0 {
|
|
if version == "unknown" {
|
|
appStats.Upgrade = i18n.G("unknown")
|
|
} else {
|
|
appStats.Upgrade = i18n.G("latest")
|
|
stats.LatestCount++
|
|
}
|
|
} else {
|
|
newUpdates = internal.SortVersionsDesc(newUpdates)
|
|
appStats.Upgrade = strings.Join(newUpdates, "\n")
|
|
stats.UpgradeCount++
|
|
}
|
|
}
|
|
|
|
appStats.Server = app.Server
|
|
appStats.Recipe = app.Recipe.Name
|
|
appStats.AppName = app.Name
|
|
appStats.Domain = app.Domain
|
|
|
|
stats.Apps = append(stats.Apps, appStats)
|
|
}
|
|
allStats[app.Server] = stats
|
|
}
|
|
|
|
if internal.MachineReadable {
|
|
jsonstring, err := json.Marshal(allStats)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
} else {
|
|
fmt.Println(string(jsonstring))
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
if err := runTable(apps); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
},
|
|
}
|
|
|
|
var (
|
|
status bool
|
|
recipeFilter string
|
|
listAppServer string
|
|
)
|
|
|
|
func init() {
|
|
AppListCommand.Flags().BoolVarP(
|
|
&status,
|
|
i18n.G("status"),
|
|
i18n.G("S"),
|
|
false,
|
|
i18n.G("show app deployment status"),
|
|
)
|
|
|
|
AppListCommand.Flags().StringVarP(
|
|
&recipeFilter,
|
|
i18n.G("recipe"),
|
|
i18n.G("r"),
|
|
"",
|
|
i18n.G("show apps of a specific recipe"),
|
|
)
|
|
|
|
AppListCommand.RegisterFlagCompletionFunc(
|
|
i18n.G("recipe"),
|
|
func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
|
|
return autocomplete.RecipeNameComplete()
|
|
},
|
|
)
|
|
|
|
AppListCommand.Flags().BoolVarP(
|
|
&internal.MachineReadable,
|
|
i18n.G("machine"),
|
|
i18n.G("m"),
|
|
false,
|
|
i18n.G("print machine-readable output"),
|
|
)
|
|
|
|
AppListCommand.Flags().StringVarP(
|
|
&listAppServer,
|
|
i18n.G("server"),
|
|
i18n.G("s"),
|
|
"",
|
|
i18n.G("show apps of a specific server"),
|
|
)
|
|
|
|
AppListCommand.RegisterFlagCompletionFunc(
|
|
i18n.G("server"),
|
|
func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
|
|
return autocomplete.ServerNameComplete()
|
|
},
|
|
)
|
|
}
|
|
|
|
func getNumServersAndRecipes(apps []appPkg.App) (int, int) {
|
|
var (
|
|
servers []string
|
|
recipes []string
|
|
)
|
|
|
|
for _, app := range apps {
|
|
if !slices.Contains(servers, app.Server) {
|
|
servers = append(servers, app.Server)
|
|
}
|
|
if !slices.Contains(recipes, app.Recipe.Name) {
|
|
recipes = append(recipes, app.Recipe.Name)
|
|
}
|
|
}
|
|
|
|
return len(servers), len(recipes)
|
|
}
|
|
|
|
type errorMsg struct{ err error }
|
|
|
|
func (e errorMsg) Error() string { return e.err.Error() }
|
|
|
|
type appsDeployStatusMsg map[string]map[string]string
|
|
|
|
func getAppsDeployStatus(m model) tea.Msg {
|
|
var apps []appPkg.App
|
|
|
|
for _, row := range m.table.GetVisibleRows() {
|
|
apps = append(apps, row.Data["app"].(appPkg.App))
|
|
}
|
|
|
|
statuses, err := appPkg.GetAppStatuses(apps, true)
|
|
if err != nil {
|
|
return errorMsg{err}
|
|
}
|
|
|
|
catl, err := recipe.ReadRecipeCatalogue(true)
|
|
if err != nil {
|
|
return errorMsg{err}
|
|
}
|
|
|
|
for _, app := range apps {
|
|
var newUpdates []string
|
|
if status, ok := statuses[app.StackName()]; ok {
|
|
if version, ok := status["version"]; ok {
|
|
updates, err := recipe.GetRecipeCatalogueVersions(app.Recipe.Name, catl)
|
|
if err != nil {
|
|
return errorMsg{err}
|
|
}
|
|
|
|
parsedVersion, err := tagcmp.Parse(version)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
for _, update := range updates {
|
|
parsedUpdate, err := tagcmp.Parse(update)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
if update != version && parsedUpdate.IsGreaterThan(parsedVersion) {
|
|
newUpdates = append(newUpdates, update)
|
|
}
|
|
}
|
|
|
|
if len(newUpdates) != 0 {
|
|
statuses[app.StackName()]["updates"] = strings.Join(newUpdates, "\n")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return appsDeployStatusMsg(statuses)
|
|
}
|
|
|
|
func renderAppsDeployStatus(m *model, appStatuses appsDeployStatusMsg) table.Model {
|
|
for _, row := range m.table.GetVisibleRows() {
|
|
app := row.Data["app"].(appPkg.App)
|
|
appStatus := appStatuses[app.StackName()]
|
|
var (
|
|
version = appStatus["version"]
|
|
updates = appStatus["updates"]
|
|
status = appStatus["status"]
|
|
chaos = appStatus["chaos"]
|
|
chaosVersion = appStatus["chaosVersion"]
|
|
autoUpdate = appStatus["autoUpdate"]
|
|
)
|
|
|
|
if status != "" {
|
|
row.Data["status"] = status
|
|
}
|
|
|
|
if version != "" {
|
|
row.Data["version"] = version
|
|
row.Data["updates"] = updates
|
|
}
|
|
|
|
if chaos != "" {
|
|
if chaosVersion != "" {
|
|
row.Data["chaos-version"] = chaosVersion
|
|
}
|
|
}
|
|
|
|
if autoUpdate != "" {
|
|
row.Data["autoUpdate"] = autoUpdate
|
|
}
|
|
}
|
|
return m.table
|
|
}
|
|
|
|
type initTableMsg struct{ table table.Model }
|
|
|
|
func initTable(m model) tea.Msg {
|
|
var rows []table.Row
|
|
|
|
for _, app := range m.apps {
|
|
rows = append(rows, table.NewRow(table.RowData{
|
|
"domain": app.Domain,
|
|
"server": app.Server,
|
|
"recipe": app.Recipe.Name,
|
|
"app": app,
|
|
}))
|
|
}
|
|
|
|
colStyle := lipgloss.NewStyle().Align(lipgloss.Left)
|
|
columns := []table.Column{
|
|
table.NewFlexColumn("domain", "DOMAIN", 2).WithFiltered(true).WithStyle(colStyle),
|
|
table.NewFlexColumn("server", "SERVER", 1).WithFiltered(true).WithStyle(colStyle),
|
|
table.NewFlexColumn("recipe", "RECIPE", 1).WithFiltered(true).WithStyle(colStyle),
|
|
table.NewFlexColumn("status", "STATUS", 1).WithFiltered(true).WithStyle(colStyle),
|
|
table.NewFlexColumn("version", "VERSION", 1).WithFiltered(true).WithStyle(colStyle),
|
|
table.NewFlexColumn("updates", "UPDATES", 1).WithFiltered(true).WithStyle(colStyle),
|
|
table.NewFlexColumn("chaos-version", "CHAOS", 1).WithFiltered(true).WithStyle(colStyle),
|
|
table.NewFlexColumn("auto-update", "AUTO-UPDATE", 1).WithFiltered(true).WithStyle(colStyle),
|
|
}
|
|
|
|
keymap := table.DefaultKeyMap()
|
|
keymap.Filter = key.NewBinding(key.WithKeys("/", "f"))
|
|
keymap.PageDown = key.NewBinding(key.WithKeys("right", "l", "pgdown", "ctrl+d"))
|
|
keymap.PageUp = key.NewBinding(key.WithKeys("left", "h", "pgup", "ctrl+u"))
|
|
|
|
t := table.
|
|
New(columns).
|
|
Filtered(true).
|
|
Focused(true).
|
|
WithRows([]table.Row(rows)).
|
|
WithKeyMap(keymap).
|
|
WithMultiline(true).
|
|
WithFuzzyFilter().
|
|
SortByAsc("domain").
|
|
WithNoPagination().
|
|
WithMissingDataIndicatorStyled(table.StyledCell{
|
|
Style: lipgloss.NewStyle().Foreground(lipgloss.Color("#faa")),
|
|
Data: "-",
|
|
})
|
|
|
|
return initTableMsg{table: t}
|
|
}
|
|
|
|
type model struct {
|
|
apps []appPkg.App
|
|
|
|
numApps int
|
|
numServers int
|
|
numRecipes int
|
|
|
|
numFilteredApps int
|
|
numFilteredServers int
|
|
numFilteredRecipes int
|
|
|
|
initStatusGather bool
|
|
|
|
table table.Model
|
|
spinner spinner.Model
|
|
pollingStatus bool
|
|
|
|
width int
|
|
height int
|
|
|
|
err error
|
|
}
|
|
|
|
func (m model) getFilteredApps() []appPkg.App {
|
|
var servers []appPkg.App
|
|
for _, row := range m.table.GetVisibleRows() {
|
|
servers = append(servers, row.Data["app"].(appPkg.App))
|
|
}
|
|
return servers
|
|
}
|
|
|
|
func (m *model) updateCount() {
|
|
if m.table.GetIsFilterActive() {
|
|
apps := m.getFilteredApps()
|
|
m.numFilteredApps = len(apps)
|
|
m.numFilteredServers, m.numFilteredRecipes = getNumServersAndRecipes(apps)
|
|
} else {
|
|
m.numFilteredApps = m.numApps
|
|
m.numFilteredServers = m.numServers
|
|
m.numFilteredRecipes = m.numRecipes
|
|
}
|
|
}
|
|
|
|
func (m model) Init() tea.Cmd {
|
|
return tea.Batch(
|
|
func() tea.Msg { return initTable(m) },
|
|
m.spinner.Tick,
|
|
)
|
|
}
|
|
|
|
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
var cmd tea.Cmd
|
|
var cmds []tea.Cmd
|
|
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
m.updateCount()
|
|
|
|
switch msg.String() {
|
|
case "q":
|
|
return m, tea.Quit
|
|
case "s":
|
|
if !m.table.GetIsFilterInputFocused() {
|
|
m.pollingStatus = true
|
|
return m, func() tea.Msg { return getAppsDeployStatus(m) }
|
|
}
|
|
}
|
|
case initTableMsg:
|
|
m.table = msg.table
|
|
|
|
m.table = m.table.WithTargetWidth(m.width)
|
|
m.table = m.table.WithPageSize(calculateHeight(m))
|
|
|
|
if m.initStatusGather {
|
|
m.pollingStatus = true
|
|
return m, func() tea.Msg { return getAppsDeployStatus(m) }
|
|
}
|
|
case appsDeployStatusMsg:
|
|
m.pollingStatus = false
|
|
m.table = renderAppsDeployStatus(&m, msg)
|
|
case tea.WindowSizeMsg:
|
|
m.width = msg.Width
|
|
m.height = msg.Height
|
|
|
|
m.table = m.table.WithTargetWidth(m.width)
|
|
m.table = m.table.WithPageSize(calculateHeight(m))
|
|
case errorMsg:
|
|
m.err = msg
|
|
}
|
|
|
|
m.table, cmd = m.table.Update(msg)
|
|
cmds = append(cmds, cmd)
|
|
|
|
m.spinner, cmd = m.spinner.Update(msg)
|
|
cmds = append(cmds, cmd)
|
|
|
|
return m, tea.Batch(cmds...)
|
|
}
|
|
|
|
func calculateHeight(m model) int {
|
|
return m.height/2 - 5
|
|
}
|
|
|
|
func (m model) View() string {
|
|
if m.err != nil {
|
|
return fmt.Sprintf("FATA: %v", m.err)
|
|
}
|
|
|
|
body := strings.Builder{}
|
|
|
|
body.WriteString(m.table.View() + "\n")
|
|
|
|
stats := fmt.Sprintf(
|
|
"[servers] %v • [apps] %v • [recipes] %v",
|
|
m.numFilteredServers, m.numFilteredApps, m.numFilteredRecipes,
|
|
)
|
|
|
|
help := "[q] quit • [/] filter • [s] status • [ctrl+u/d] page up/down"
|
|
|
|
body.WriteString(lipgloss.JoinHorizontal(lipgloss.Center, stats, " | ", help))
|
|
|
|
if m.pollingStatus {
|
|
body.WriteString(fmt.Sprintf(" | %s querying app status", m.spinner.View()))
|
|
} else {
|
|
body.WriteString(" | -")
|
|
}
|
|
|
|
return body.String()
|
|
}
|
|
|
|
func runTable(apps []appPkg.App) error {
|
|
s := spinner.New()
|
|
s.Spinner = spinner.Dot
|
|
s.Style = lipgloss.NewStyle().Foreground(lipgloss.Color("205"))
|
|
|
|
numServers, numRecipes := getNumServersAndRecipes(apps)
|
|
numApps := len(apps)
|
|
|
|
m := model{
|
|
apps: apps,
|
|
numApps: numApps,
|
|
numServers: numServers,
|
|
numRecipes: numRecipes,
|
|
numFilteredApps: numApps,
|
|
numFilteredServers: numServers,
|
|
numFilteredRecipes: numRecipes,
|
|
spinner: s,
|
|
initStatusGather: status,
|
|
}
|
|
|
|
p := tea.NewProgram(m, tea.WithAltScreen())
|
|
if _, err := p.Run(); err != nil {
|
|
return fmt.Errorf("oops, app list tui exploded: %s", err)
|
|
}
|
|
|
|
return nil
|
|
}
|