cloud/pages
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
iceBear67
2026-08-15 07:13:00 +00:00
commit dd50674fdc
114 changed files with 26865 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/clicmd/deployment.go
+357
View File
@@ -0,0 +1,357 @@
package clicmd
import (
"context"
"flag"
"fmt"
"maps"
"slices"
"strconv"
"github.com/iceBear67/simplepages/api"
"github.com/iceBear67/simplepages/internal/client"
"github.com/iceBear67/simplepages/internal/cliutil"
)
func deploymentCmd(g *Globals) *cliutil.Command {
return &cliutil.Command{
Name: "deployment",
Short: "Inspect, roll back and remove deployments",
Long: "Every deployment a project has ever finished is kept until retention\n" +
"drops it, which is what makes a rollback one command rather than a\n" +
"rebuild. A project key may manage only its own project's deployments.",
Sub: []*cliutil.Command{
deploymentListCmd(g),
deploymentShowCmd(g),
deploymentActivateCmd(g),
deploymentDeleteCmd(g),
},
}
}
func deploymentListCmd(g *Globals) *cliutil.Command {
var (
state string
limit int
)
return &cliutil.Command{
Name: "list",
Short: "List a project's deployments",
Long: "Newest first. The one marked active is what the site is serving, and\n" +
"is the one to roll back from; any other ready deployment can be rolled\n" +
"back to with \"pages deployment activate\".",
Flags: func(fs *flag.FlagSet) {
fs.StringVar(&state, "state", "", "show only deployments in this `state`: pending, uploading, ready, failed or deleting")
fs.IntVar(&limit, "limit", 0, "stop after this many deployments; 0 lists them all")
},
Exec: func(ctx context.Context, args []string) error {
if err := exactArgs(args, 0, "no arguments"); err != nil {
return err
}
project, err := g.ProjectName()
if err != nil {
return err
}
c, err := g.Client()
if err != nil {
return err
}
deps, err := listDeployments(ctx, c, project, state, limit)
if err != nil {
return err
}
p, err := g.Printer()
if err != nil {
return err
}
// The API's own shape, so -o json is the same document whether it came
// from here or from curl, and an empty listing prints as [] not null.
out := api.DeploymentList{Deployments: deps}
if out.Deployments == nil {
out.Deployments = []api.Deployment{}
}
return p.Print(out, func() *cliutil.Table {
t := cliutil.NewTable("ID", "STATE", "ACTIVE", "FILES", "SIZE", "CREATED", "COMMIT")
for _, d := range deps {
t.Row(d.ID, d.State, cliutil.Bool(d.Active),
strconv.Itoa(d.FileCount), cliutil.Bytes(d.TotalBytes),
cliutil.Time(d.CreatedAt),
cliutil.Str(cliutil.Truncate(d.Meta["git_sha"], 12)))
}
return t
})
},
}
}
// listDeployments follows the cursor, stopping at limit when one was given.
// Paging on the caller's behalf matters here for the same reason it does for
// projects: a listing that silently showed the first page would be a lie, and
// this one is read to decide which deployment to roll back to.
func listDeployments(ctx context.Context, c *client.Client, project, state string, limit int) ([]api.Deployment, error) {
opts := client.DeploymentListOptions{State: state}
opts.Limit = 500
if limit > 0 && limit < opts.Limit {
opts.Limit = limit
}
var all []api.Deployment
for {
page, err := c.ListDeployments(ctx, project, opts)
if err != nil {
return nil, err
}
all = append(all, page.Deployments...)
if limit > 0 && len(all) >= limit {
return all[:limit], nil
}
if page.NextCursor == "" || len(page.Deployments) == 0 {
return all, nil
}
opts.Cursor = page.NextCursor
}
}
func deploymentShowCmd(g *Globals) *cliutil.Command {
var files bool
return &cliutil.Command{
Name: "show",
Args: "<id>",
Short: "Show one deployment",
Long: "With --files, also lists the manifest: every path, its size and the\n" +
"digest of its content. That is one line per file, so it is a lot of\n" +
"output for a large site.",
Flags: func(fs *flag.FlagSet) {
fs.BoolVar(&files, "files", false, "also list the deployment's files")
},
Exec: func(ctx context.Context, args []string) error {
if err := exactArgs(args, 1, "one deployment id"); err != nil {
return err
}
project, err := g.ProjectName()
if err != nil {
return err
}
c, err := g.Client()
if err != nil {
return err
}
d, err := c.GetDeployment(ctx, project, args[0], files)
if err != nil {
return err
}
p, err := g.Printer()
if err != nil {
return err
}
return p.Print(d, func() *cliutil.Table {
t := cliutil.NewTable()
t.Row("id", d.ID)
t.Row("project", d.Project)
t.Row("state", d.State)
t.Row("active", cliutil.Bool(d.Active))
t.Row("files", strconv.Itoa(d.FileCount))
t.Row("total_bytes", cliutil.Bytes(d.TotalBytes))
t.Row("created_at", cliutil.Time(d.CreatedAt))
t.Row("finalized_at", cliutil.TimePtr(d.FinalizedAt))
t.Row("activated_at", cliutil.TimePtr(d.ActivatedAt))
if d.URL != "" {
t.Row("url", d.URL)
}
if d.Error != "" {
t.Row("error", d.Error)
}
for _, k := range sortedKeys(d.Meta) {
t.Row("meta."+k, d.Meta[k])
}
for _, f := range d.Files {
t.Row(f.Path, fmt.Sprintf("%s %s",
cliutil.Bytes(f.Size), cliutil.Truncate(f.Digest, 12)))
}
return t
})
},
}
}
// sortedKeys gives map-backed output a stable order, so two runs of the same
// command produce the same lines and a diff of them means something.
func sortedKeys(m map[string]string) []string {
return slices.Sorted(maps.Keys(m))
}
func deploymentActivateCmd(g *Globals) *cliutil.Command {
return &cliutil.Command{
Name: "activate",
Args: "<id>",
Short: "Switch the site to a deployment",
Long: "This is how a rollback is done: name an older deployment and the\n" +
"project serves it again. The switch is atomic and costs nothing —\n" +
"the content is still on disk — so it takes effect immediately.",
Exec: func(ctx context.Context, args []string) error {
if err := exactArgs(args, 1, "one deployment id"); err != nil {
return err
}
project, err := g.ProjectName()
if err != nil {
return err
}
c, err := g.Client()
if err != nil {
return err
}
d, err := c.Activate(ctx, project, args[0])
if err != nil {
return err
}
p, err := g.Printer()
if err != nil {
return err
}
return p.Print(d, func() *cliutil.Table {
t := cliutil.NewTable()
t.Row("deployment", d.ID)
t.Row("project", project)
t.Row("state", d.State)
t.Row("active", cliutil.Bool(d.Active))
t.Row("files", strconv.Itoa(d.FileCount))
t.Row("url", cliutil.Str(d.URL))
return t
})
},
}
}
func deploymentDeleteCmd(g *Globals) *cliutil.Command {
var yes bool
return &cliutil.Command{
Name: "delete",
Args: "<id>",
Short: "Delete a deployment",
Long: "The deployment the project is serving cannot be deleted; activate\n" +
"another one first. Content no other deployment references is\n" +
"reclaimed by the next garbage collection, not immediately.",
Flags: func(fs *flag.FlagSet) {
fs.BoolVar(&yes, "yes", false, "do not ask for confirmation")
},
Exec: func(ctx context.Context, args []string) error {
if err := exactArgs(args, 1, "one deployment id"); err != nil {
return err
}
id := args[0]
project, err := g.ProjectName()
if err != nil {
return err
}
if !yes {
if err := cliutil.Confirm(g.In, g.Err,
fmt.Sprintf("Delete deployment %s of project %q?", id, project)); err != nil {
return err
}
}
c, err := g.Client()
if err != nil {
return err
}
if err := c.DeleteDeployment(ctx, project, id); err != nil {
return err
}
p, err := g.Printer()
if err != nil {
return err
}
p.Printf("deleted deployment %s\n", id)
return nil
},
}
}
// ------------------------------------------------------------------ upkeep
//
// These two are server-wide rather than per-project, which is why they sit
// under "pages system" next to "system info" and not under "deployment".
func systemGCCmd(g *Globals) *cliutil.Command {
var dryRun bool
return &cliutil.Command{
Name: "gc",
Short: "Run a garbage collection pass now",
Long: "The server collects on a timer anyway; this is for an operator who\n" +
"wants the disk back sooner. --dry-run reports what would be deleted\n" +
"without deleting it, though it cannot count the content the listed\n" +
"deployments hold — nothing was deleted, so it is all still in use.\n" +
"Requires an admin key.",
Flags: func(fs *flag.FlagSet) {
fs.BoolVar(&dryRun, "dry-run", false, "report what would be deleted without deleting it")
},
Exec: func(ctx context.Context, args []string) error {
if err := exactArgs(args, 0, "no arguments"); err != nil {
return err
}
c, err := g.Client()
if err != nil {
return err
}
stats, err := c.Collect(ctx, dryRun)
if err != nil {
return err
}
p, err := g.Printer()
if err != nil {
return err
}
return p.Print(stats, func() *cliutil.Table {
t := cliutil.NewTable()
t.Row("dry_run", cliutil.Bool(stats.DryRun))
t.Row("deployments_deleted", strconv.Itoa(stats.DeploymentsDeleted))
t.Row("blobs_deleted", strconv.Itoa(stats.BlobsDeleted))
t.Row("bytes_freed", cliutil.Bytes(stats.BytesFreed))
return t
})
},
}
}
func systemFsckCmd(g *Globals) *cliutil.Command {
var repair bool
return &cliutil.Command{
Name: "fsck",
Short: "Check the stored reference counts against the manifests",
Long: "On a healthy server this always reports no drift: the counts are\n" +
"maintained by database triggers. It is for the cases outside normal\n" +
"operation — a restored backup, a database edited by hand — because a\n" +
"count that reads low is content the collector will delete while a\n" +
"deployment still needs it. --repair rewrites the counts from the\n" +
"manifests. Requires an admin key.",
Flags: func(fs *flag.FlagSet) {
fs.BoolVar(&repair, "repair", false, "correct the counts that disagree")
},
Exec: func(ctx context.Context, args []string) error {
if err := exactArgs(args, 0, "no arguments"); err != nil {
return err
}
c, err := g.Client()
if err != nil {
return err
}
rep, err := c.Fsck(ctx, repair)
if err != nil {
return err
}
p, err := g.Printer()
if err != nil {
return err
}
return p.Print(rep, func() *cliutil.Table {
t := cliutil.NewTable()
t.Row("blobs", strconv.FormatInt(rep.Blobs, 10))
t.Row("drift", strconv.Itoa(rep.DriftCount))
t.Row("repaired", strconv.Itoa(rep.Repaired))
for _, d := range rep.Drift {
t.Row(cliutil.Truncate(d.Digest, 12),
fmt.Sprintf("stored %d, actual %d", d.Stored, d.Actual))
}
return t
})
},
}
}