Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package podman
import (
"cmp"
"fmt"
"maps"
"net/http"
"net/url"
"os"
"path/filepath"
"slices"
"strings"
"github.com/getarcaneapp/arcane/types/v2/podman"
"github.com/spf13/cobra"
"go.getarcane.app/kit/pkg"
"github.com/getarcaneapp/arcane/cli/v2/internal/cmdutil"
"github.com/getarcaneapp/arcane/cli/v2/internal/output"
"github.com/getarcaneapp/arcane/cli/v2/internal/types"
)
func newQuadletsCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "quadlets",
Aliases: []string{"quadlet", "q"},
Short: "Manage Podman quadlets",
}
cmd.AddCommand(
newQuadletListCmd(),
newQuadletGetCmd(),
newQuadletInstallCmd(),
newQuadletDeleteCmd(),
)
for _, action := range []struct{ name, verb string }{
{name: "start", verb: "Start"},
{name: "stop", verb: "Stop"},
{name: "restart", verb: "Restart"},
} {
cmd.AddCommand(&cobra.Command{
Use: action.name + " <name>",
Short: action.verb + " a quadlet's systemd unit",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.Run(cmd, c, cmdutil.Spec[podman.UnitStatus]{
Method: http.MethodPost,
Path: types.PodmanQuadletAction(c.EnvID(), args[0], action.name),
FailureMessage: "failed to " + action.name + " quadlet",
Render: func(data podman.UnitStatus) error {
output.Success("Quadlet %s: %s completed", args[0], action.name)
output.KeyValue("Unit", data.Name)
output.KeyValue("State", output.TintStatus(data.ActiveState)+" ("+data.SubState+")")
return nil
},
})
},
})
}
return cmd
}
func newQuadletListCmd() *cobra.Command {
var opts struct {
names []string
pods []string
statuses []string
limit int
start int
all bool
}
cmd := &cobra.Command{
Use: "list",
Aliases: []string{"ls"},
Short: "List quadlets",
SilenceUsage: true,
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
query := url.Values{
"name": opts.names,
"pod": opts.pods,
"status": opts.statuses,
}.Encode()
return cmdutil.RunList(cmd, c, cmdutil.ListSpec[podman.QuadletDetail]{
Resource: "quadlets",
Endpoint: types.PodmanQuadlets(c.EnvID()) + kit.Ternary(query != "", "?"+query, ""),
Params: cmdutil.ListParams{
Resource: "quadlets",
Limit: opts.limit,
FallbackDefault: 20,
Start: opts.start,
All: opts.all,
},
Headers: []string{"NAME", "UNIT", "TYPE", "STATUS", "APP"},
Row: func(quadlet podman.QuadletDetail) []string {
return []string{
quadlet.Name,
quadlet.UnitName,
string(quadlet.Type),
output.TintStatus(quadlet.Status),
cmp.Or(quadlet.App, "-"),
}
},
})
},
}
cmd.Flags().StringArrayVar(&opts.names, "name", nil, "Filter by quadlet name")
cmd.Flags().StringArrayVar(&opts.pods, "pod", nil, "Filter by pod (Podman 6.0+)")
cmd.Flags().StringArrayVar(&opts.statuses, "status", nil, "Filter by status (Podman 6.0+)")
cmd.Flags().IntVarP(&opts.limit, "limit", "n", 20, "Number of quadlets to show")
cmd.Flags().IntVar(&opts.start, "start", 0, cmdutil.StartFlagUsage)
cmd.Flags().BoolVarP(&opts.all, "all", "a", false, cmdutil.AllFlagUsage)
cmdutil.SetScope(cmdutil.ScopeRead, cmd)
return cmd
}
func newQuadletGetCmd() *cobra.Command {
return &cobra.Command{
Use: "get <name>",
Aliases: []string{"inspect"},
Short: "Show quadlet details",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.Run(cmd, c, cmdutil.Spec[podman.QuadletDetail]{
Method: http.MethodGet,
Path: types.PodmanQuadlet(c.EnvID(), args[0]),
FailureMessage: "failed to get quadlet",
Render: func(data podman.QuadletDetail) error {
output.Header("Quadlet Details")
output.KeyValue("Name", data.Name)
output.KeyValue("Unit", data.UnitName)
output.KeyValue("Type", data.Type)
output.KeyValue("Path", data.Path)
output.KeyValue("Status", output.TintStatus(data.Status))
output.KeyValue("App", cmp.Or(data.App, "-"))
output.KeyValue("Template", kit.Ternary(data.Template, "Yes", "No"))
if data.UnitStatus != nil {
output.KeyValue("Load state", data.UnitStatus.LoadState)
output.KeyValue("Active state", output.TintStatus(data.UnitStatus.ActiveState)+" ("+data.UnitStatus.SubState+")")
}
if len(data.Containers) == 0 {
return nil
}
rows := make([][]string, len(data.Containers))
for i, container := range data.Containers {
rows[i] = []string{
container.ID[:min(len(container.ID), 12)],
strings.Join(container.Names, ", "),
container.Image,
output.TintStatus(container.State),
}
}
return cmdutil.PrintTable(cmd, []string{"ID", "NAME", "IMAGE", "STATE"}, rows)
},
})
},
}
}
func newQuadletInstallCmd() *cobra.Command {
var opts struct {
app string
extraFiles []string
}
cmd := &cobra.Command{
Use: "install <file>",
Short: "Install a quadlet file",
Long: "Install a quadlet file. The file name, including its extension (.container, .pod, .kube, .network, .volume, .image, .build), becomes the quadlet name.",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
content, err := os.ReadFile(args[0])
if err != nil {
return fmt.Errorf("failed to read quadlet file: %w", err)
}
extraFiles := make([]podman.QuadletFile, len(opts.extraFiles))
for i, extraPath := range opts.extraFiles {
extraContent, readErr := os.ReadFile(extraPath)
if readErr != nil {
return fmt.Errorf("failed to read extra file: %w", readErr)
}
extraFiles[i] = podman.QuadletFile{
Name: filepath.Base(extraPath),
Content: string(extraContent),
}
}
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.Run(cmd, c, cmdutil.Spec[podman.QuadletInstallReport]{
Method: http.MethodPost,
Path: types.PodmanQuadlets(c.EnvID()),
Body: podman.QuadletInstallRequest{
Name: filepath.Base(args[0]),
Content: string(content),
ExtraFiles: extraFiles,
App: opts.app,
},
FailureMessage: "failed to install quadlet",
Render: func(data podman.QuadletInstallReport) error {
for _, name := range slices.Sorted(maps.Keys(data.InstalledQuadlets)) {
output.Success("Installed %s at %s", name, data.InstalledQuadlets[name])
}
for _, name := range slices.Sorted(maps.Keys(data.QuadletErrors)) {
output.Warning("%s: %s", name, data.QuadletErrors[name])
}
if len(data.QuadletErrors) > 0 {
return fmt.Errorf("%d quadlet file(s) failed to install", len(data.QuadletErrors))
}
return nil
},
})
},
}
cmd.Flags().StringVar(&opts.app, "app", "", "Application the quadlet belongs to (Podman 6.1+)")
cmd.Flags().StringArrayVar(&opts.extraFiles, "extra-file", nil, "Additional file installed beside the quadlet, such as kube YAML (repeatable)")
cmdutil.SetScope(cmdutil.ScopeDestination, cmd)
return cmd
}
func newQuadletDeleteCmd() *cobra.Command {
var opts struct {
force bool
}
cmd := &cobra.Command{
Use: "delete <name>",
Aliases: []string{"rm", "remove"},
Short: "Delete a quadlet",
Args: cobra.ExactArgs(1),
SilenceUsage: true,
RunE: func(cmd *cobra.Command, args []string) error {
c, err := cmdutil.ClientFromCommand(cmd)
if err != nil {
return err
}
return cmdutil.RunDelete(cmd, c, cmdutil.DeleteSpec{
Force: opts.force,
Prompt: fmt.Sprintf("Are you sure you want to delete quadlet %s?", args[0]),
Path: types.PodmanQuadlet(c.EnvID(), args[0]),
FailureMessage: "failed to delete quadlet",
SuccessMessage: fmt.Sprintf("Quadlet %s deleted successfully", args[0]),
})
},
}
cmd.Flags().BoolVarP(&opts.force, "force", "f", false, "Force deletion without confirmation")
return cmd
}