package vendor import ( "encoding/json" "fmt" "io" "os" "path/filepath" "sort" "github.com/m3tam3re/agent-lib/internal/discovery" "github.com/m3tam3re/agent-lib/internal/gitsource" "github.com/m3tam3re/agent-lib/internal/labels" "github.com/m3tam3re/agent-lib/internal/lockfile" ) // RenameOptions parameterize vendor rename. type RenameOptions struct { // Set maps upstream ids to new deployed names. Mapping an id onto itself // is the same as resetting it. Set map[string]string // Reset drops existing renames so the items deploy under their upstream id. Reset []string } // Rename changes the deployed names of a vendored source's items after the // fact — without advancing the pinned revision or touching the selection. // Ids are validated against the pinned upstream, collisions re-run, and the // external area is rewritten atomically. With no options it only lists the // current renames. func Rename(workDir, name string, opts RenameOptions, stdout io.Writer) error { lockPath := filepath.Join(workDir, lockfile.FileName) lf, err := lockfile.Load(lockPath) if err != nil { return err } src, ok := lf.Sources[name] if !ok { return fmt.Errorf("source %q is not in the lockfile", name) } if len(opts.Set) == 0 && len(opts.Reset) == 0 { printRenames(stdout, name, src.Renames) return nil } newRenames := map[string]string{} for k, v := range src.Renames { newRenames[k] = v } for _, id := range opts.Reset { if _, ok := newRenames[id]; !ok { return fmt.Errorf("source %q: --reset %q has no rename to reset", name, id) } delete(newRenames, id) } for up, dep := range opts.Set { if up == dep { delete(newRenames, up) continue } newRenames[up] = dep } repo, err := gitsource.Clone(src.URL, src.Ref) if err != nil { return err } pinned, err := repo.Pin(src.Rev) if err != nil { return fmt.Errorf("%w — run vendor update to re-pin", err) } tree, err := pinned.Tree() if err != nil { return err } items, err := discovery.Scan(tree, discovery.FromLockfileDiscovery(derefDiscovery(src))) if err != nil { return err } ids := append(sortedKeys(boolSet(keysOf(opts.Set))), opts.Reset...) if err := checkIDEntries(items, ids, name, "rename"); err != nil { return err } types := map[string]string{} for _, it := range items { if !it.Skipped { types[it.UpstreamID] = it.Type } } for up, dep := range opts.Set { if up == dep { continue } if err := validateRenameTarget(types[up], up, dep); err != nil { return fmt.Errorf("source %q: %w", name, err) } } selected := applySelection(items, src.Selection) if err := checkCollisions(workDir, lf, name, selected, newRenames); err != nil { return err } cleanupStaleStaging(workDir) staging := filepath.Join(workDir, externalDir, ".staging-"+name) if err := os.RemoveAll(staging); err != nil { return err } if err := materializeTree(tree, selected, newRenames, staging); err != nil { os.RemoveAll(staging) return err } oldDir := filepath.Join(workDir, externalDir, name) if err := os.RemoveAll(oldDir); err != nil { return fmt.Errorf("replacing %s: %w", oldDir, err) } if err := os.Rename(staging, oldDir); err != nil { return fmt.Errorf("swapping in new external area: %w", err) } oldRenames := src.Renames if len(newRenames) == 0 { newRenames = nil } src.Renames = newRenames src.Inventory = inventoryOf(selected) src.Warnings = dedupe(warningsOf(items)) if err := lf.Save(lockPath); err != nil { return err } renamed := map[string]string{} for _, id := range ids { if before, after := deployedName(id, oldRenames), deployedName(id, newRenames); before != after { renamed[before] = after } } if n, err := renameLabelEntries(workDir, renamed); err != nil { fmt.Fprintf(stdout, "warning: %s not updated: %v — fix the entries by hand\n", labels.FileName, err) } else if n > 0 { fmt.Fprintf(stdout, "%s: %d entries renamed so the items keep their labels\n", labels.FileName, n) } inSelection := idSet(selected) fmt.Fprintf(stdout, "source %s: renames updated at pinned rev %s\n", name, short(src.Rev)) for _, id := range ids { before := deployedName(id, oldRenames) after := deployedName(id, newRenames) note := "" if !inSelection[types[id]][id] { note = " (not selected — applies once added)" } if before == after { fmt.Fprintf(stdout, " %s %s: unchanged (%s)%s\n", types[id], id, after, note) continue } fmt.Fprintf(stdout, " %s %s: %s → %s%s\n", types[id], id, before, after, note) } return nil } func printRenames(w io.Writer, name string, renames map[string]string) { if len(renames) == 0 { fmt.Fprintf(w, "source %s: no renames\n", name) return } fmt.Fprintf(w, "source %s renames (upstream → deployed):\n", name) ups := make([]string, 0, len(renames)) for up := range renames { ups = append(ups, up) } sort.Strings(ups) for _, up := range ups { fmt.Fprintf(w, " %s → %s\n", up, renames[up]) } } func keysOf(m map[string]string) []string { out := make([]string, 0, len(m)) for k := range m { out = append(out, k) } return out } func boolSet(ids []string) map[string]bool { out := map[string]bool{} for _, id := range ids { out[id] = true } return out } // renameLabelEntries rewrites labels-file entries from old to new deployed // names. Without it a rename would silently drop an item's labels and widen // its delivery to every client. Returns how many entries changed; a missing // file is not an error. func renameLabelEntries(workDir string, renamed map[string]string) (int, error) { if len(renamed) == 0 { return 0, nil } path := filepath.Join(workDir, labels.FileName) data, err := os.ReadFile(path) if os.IsNotExist(err) { return 0, nil } if err != nil { return 0, err } file, err := labels.Parse(data) if err != nil { return 0, err } changed := 0 for label, names := range file.Labels { for i, n := range names { if to, ok := renamed[n]; ok { file.Labels[label][i] = to changed++ } } } if changed == 0 { return 0, nil } out, err := json.MarshalIndent(struct { Version int `json:"version"` Labels map[string][]string `json:"labels"` }{file.Version, file.Labels}, "", " ") if err != nil { return 0, err } return changed, os.WriteFile(path, append(out, '\n'), 0o644) }