0
0
package install
import (
"cmp"
"context"
"errors"
"fmt"
"io"
"io/fs"
"os"
"path/filepath"
"sort"
"strings"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostcontract"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc/treeaudit"
)
type UninstallOptions struct {
Role hostcontract.Role
Account string
Purge bool
Force bool
Root string
Staged bool
Out io.Writer
}
func OwnsUnit(prefix, name string) bool {
if prefix != "" && prefix != RuntimePrefix {
return strings.HasPrefix(name, prefix) || name == strings.TrimSuffix(prefix, "-")+".slice"
}
return strings.HasPrefix(name, RuntimePrefix) || name == SliceUnit || strings.HasPrefix(name, RuntimeSliceTop+"-")
}
type uninstaller struct {
installer
uo UninstallOptions
}
func Uninstall(ctx context.Context, uo UninstallOptions, sys System) (Report, error) {
rep := Report{}
if uo.Account == "" {
uo.Account = DefaultAccount(uo.Role)
}
uo.Root = cmp.Or(uo.Root, "/")
recPath := filepath.Join(uo.Root, RecordPath(uo.Account))
rec, err := loadRecord(recPath)
if errors.Is(err, fs.ErrNotExist) {
return rep, fmt.Errorf("%w: %s is missing, so nothing is known to have been created by install", ErrNoRecord, RecordPath(uo.Account))
}
if err != nil {
return rep, err
}
if rec.Role != uo.Role {
return rep, fmt.Errorf("uninstall: %s was installed as a %s, not a %s", uo.Account, rec.Role, uo.Role)
}
u := &uninstaller{installer: installer{ctx: ctx, o: Options{Role: uo.Role, Account: uo.Account, StateDir: rec.StateDir, Root: uo.Root, Staged: uo.Staged, Out: uo.Out},
sys: sys, rep: &rep, rec: rec, recPath: recPath}, uo: uo}
a, ok, err := sys.LookupAccount(uo.Account)
if err != nil {
return rep, err
}
if ok {
u.acct, u.known = a, true
}
var um UserManager
if u.known {
mgRoot := uo.Root
if uo.Staged {
mgRoot = "/"
}
if _, _, notRunning := hostcontract.ManagerGroups(mgRoot, a.UID); notRunning == "" {
if um, err = sys.User(ctx, a); err != nil {
return rep, fmt.Errorf("uninstall: reaching user@%d: %w", a.UID, err)
}
defer um.Close()
}
}
var units []hostsvc.UnitStatus
if um != nil {
if units, err = um.List(ctx); err != nil {
return rep, err
}
var vms []string
for _, s := range units {
if OwnsUnit(rec.UnitPrefix, s.Name) && treeaudit.IsVMUnit(s.Name) && (s.State == hostsvc.Active || s.State == hostsvc.Activating || s.State == hostsvc.Reloading) {
vms = append(vms, s.Name)
}
}
if len(vms) > 0 && !uo.Force {
return rep, fmt.Errorf("%w: %s; stop them through their ComputeVMs first, or pass --force", ErrVMsRunning, strings.Join(vms, ", "))
}
}
if uo.Purge {
fmt.Fprintf(u.out(), "uninstall --purge removes the state dir %s (the vault, the kcp store, the keys) and, where install created it, the account %s\n",
rec.StateDir, uo.Account)
}
for _, step := range []func([]hostsvc.UnitStatus, UserManager) error{u.stopUnits, u.removeUnitFiles, u.lingerOff, u.removeDropIn,
u.removeAppArmor, u.removeSubids, u.removeKVM, u.removePassword, u.purge} {
if err := step(units, um); err != nil {
return rep, err
}
}
return rep, nil
}
func (u *uninstaller) stopUnits(units []hostsvc.UnitStatus, um UserManager) error {
if um == nil {
return nil
}
core := CoreUnits(u.rec.Role, u.rec.UnitPrefix, u.rec.Instances())
if err := u.change("disable --now "+strings.Join(core, " ")+" as "+u.uo.Account, func() error { return um.DisableStop(u.ctx, core) }); err != nil {
return err
}
isCore := map[string]bool{}
for _, c := range core {
isCore[c] = true
}
var rest []string
for _, s := range units {
if OwnsUnit(u.rec.UnitPrefix, s.Name) && !isCore[s.Name] && s.State != hostsvc.Inactive && s.State != hostsvc.NotFound {
rest = append(rest, s.Name)
}
}
sort.Slice(rest, func(i, j int) bool {
return strings.HasSuffix(rest[j], ".slice") && !strings.HasSuffix(rest[i], ".slice") || (strings.HasSuffix(rest[i], ".slice") == strings.HasSuffix(rest[j], ".slice") && rest[i] < rest[j])
})
for _, n := range rest {
if err := u.change("stop "+n, func() error { return um.Stop(u.ctx, n) }); err != nil {
return err
}
}
return nil
}
func (u *uninstaller) remove(host string) error {
full := u.path(host)
if _, err := os.Lstat(full); err != nil {
return nil
}
return u.change("remove "+host, func() error { return os.Remove(full) })
}
func isDropIn(f string) bool { return strings.HasSuffix(filepath.Dir(f), ".d") }
func isLinkDir(name string) bool {
return strings.HasSuffix(name, ".wants") || strings.HasSuffix(name, ".requires") || strings.HasSuffix(name, ".upholds")
}
func (u *uninstaller) recordedUnits() (map[string]bool, []string, []string) {
names := map[string]bool{}
var own []string
seen := map[string]bool{}
var dirs []string
add := func(d string) {
if d != "" && !seen[d] {
seen[d] = true
dirs = append(dirs, d)
}
}
for _, f := range u.rec.UnitFiles {
if isDropIn(f) || isLinkDir(filepath.Base(filepath.Dir(f))) {
continue
}
names[filepath.Base(f)] = true
add(u.path(filepath.Dir(f)))
}
own = append(own, dirs...)
if u.uo.Staged {
if c, err := os.UserConfigDir(); err == nil {
add(filepath.Join(c, "systemd", "user"))
}
if r := OwnRuntimeDir(); r != "" {
add(filepath.Join(r, "systemd", "user"))
}
}
return names, dirs, own
}
func ownedLink(p string, own []string) bool {
cur := p
for range 4 {
t, err := os.Readlink(cur)
if err != nil {
return false
}
if !filepath.IsAbs(t) {
t = filepath.Join(filepath.Dir(cur), t)
}
t = filepath.Clean(t)
for _, d := range own {
if within(t, d) {
return true
}
}
if _, err := os.Lstat(t); errors.Is(err, fs.ErrNotExist) {
return true
}
cur = t
}
return false
}
func (u *uninstaller) removeLink(p string, own []string) (bool, error) {
st, err := os.Lstat(p)
if err != nil || st.Mode()&fs.ModeSymlink == 0 || !ownedLink(p, own) {
return false, nil
}
return true, u.change("remove "+p, func() error { return os.Remove(p) })
}
func (u *uninstaller) sweepUnitLinks(names map[string]bool, dirs, own []string) (bool, error) {
swept := false
for _, dir := range dirs {
entries, err := os.ReadDir(dir)
if err != nil {
continue
}
for _, e := range entries {
p := filepath.Join(dir, e.Name())
if e.IsDir() && isLinkDir(e.Name()) {
subs, err := os.ReadDir(p)
if err != nil {
continue
}
left := len(subs)
for _, s := range subs {
if !names[s.Name()] {
continue
}
removed, err := u.removeLink(filepath.Join(p, s.Name()), own)
if err != nil {
return swept, err
}
if removed {
swept, left = true, left-1
}
}
if left == 0 && len(subs) > 0 {
os.Remove(p)
}
continue
}
if names[e.Name()] {
removed, err := u.removeLink(p, own)
if err != nil {
return swept, err
}
swept = swept || removed
}
}
}
return swept, nil
}
func (u *uninstaller) removeUnitFiles(units []hostsvc.UnitStatus, um UserManager) error {
names, dirs, own := u.recordedUnits()
for _, f := range u.rec.UnitFiles {
if filepath.Base(filepath.Dir(f)) != WantsDir && !strings.HasSuffix(filepath.Dir(f), ".d") {
link := filepath.Join(filepath.Dir(f), WantsDir, filepath.Base(f))
if _, err := os.Lstat(u.path(link)); err == nil {
if err := u.remove(link); err != nil {
return err
}
}
}
if err := u.remove(f); err != nil {
return err
}
if isDropIn(f) {
os.Remove(u.path(filepath.Dir(f)))
}
}
swept, err := u.sweepUnitLinks(names, dirs, own)
if err != nil {
return err
}
u.rec.UnitFiles = nil
if swept && um != nil {
return u.change("systemctl --user daemon-reload as "+u.uo.Account, func() error { return um.Reload(u.ctx) })
}
return nil
}
func (u *uninstaller) lingerOff(units []hostsvc.UnitStatus, um UserManager) error {
if !u.rec.created(StepLinger) || !u.known {
return nil
}
return u.change("loginctl disable-linger "+u.uo.Account, func() error { return u.sys.SetLinger(u.ctx, u.acct, false) })
}
func (u *uninstaller) removeDropIn(units []hostsvc.UnitStatus, um UserManager) error {
if !u.rec.created(StepDelegation) || u.rec.UID < 0 {
return nil
}
dir := fmt.Sprintf("/etc/systemd/system/user@%d.service.d", u.rec.UID)
if err := u.remove(filepath.Join(dir, DropInName)); err != nil {
return err
}
u.removeCreatedDirs(func(d string) bool { return d == dir })
return u.change("systemctl daemon-reload (system manager)", func() error { return u.sys.ReloadSystemManager(u.ctx) })
}
func (u *uninstaller) removeAppArmor(units []hostsvc.UnitStatus, um UserManager) error {
if !u.rec.created(StepAppArmor) {
return nil
}
if hostcontract.AppArmorProfileLoaded(u.read(AppArmorLoaded), hostcontract.AppArmorProfileName) {
if err := u.change("apparmor_parser -R "+AppArmorPath, func() error { return u.sys.UnloadAppArmor(u.path(AppArmorPath)) }); err != nil {
return err
}
}
return u.remove(AppArmorPath)
}
func (u *uninstaller) removeSubids(units []hostsvc.UnitStatus, um UserManager) error {
for _, f := range []struct{ step, host string }{{StepSubuid, "/etc/subuid"}, {StepSubgid, "/etc/subgid"}} {
line := u.rec.SubidLines[f.host]
if !u.rec.created(f.step) || line == "" {
continue
}
content := u.read(f.host)
i := strings.Index(content, line)
if i < 0 || (i > 0 && content[i-1] != '\n') {
continue
}
next := content[:i] + content[i+len(line):]
full := u.path(f.host)
mode := os.FileMode(0o644)
if st, err := os.Stat(full); err == nil {
mode = st.Mode().Perm()
}
if err := u.change("remove "+strings.TrimSpace(line)+" from "+f.host, func() error { return writeAtomic(full, []byte(next), mode) }); err != nil {
return err
}
}
return nil
}
func (u *uninstaller) removeKVM(units []hostsvc.UnitStatus, um UserManager) error {
if !u.rec.created(StepKVM) || !u.known {
return nil
}
if _, member := hostcontract.GroupMembership(u.read("/etc/group"), KVMGroup, u.uo.Account); !member {
return nil
}
return u.change("remove "+u.uo.Account+" from group "+KVMGroup, func() error { return u.sys.RemoveFromGroup(u.uo.Account, KVMGroup) })
}
func (u *uninstaller) removePassword(units []hostsvc.UnitStatus, um UserManager) error {
switch {
case u.rec.created(StepPassword):
if err := u.remove(NodePassword); err != nil {
return err
}
u.removeCreatedDirs(func(d string) bool { return strings.HasPrefix(NodePassword, d+"/") })
case u.rec.Steps[StepPassword] == OutcomeUpdated:
if prev, ok := u.rec.PrevOwner[NodePassword]; ok {
full := u.path(NodePassword)
return u.change(fmt.Sprintf("chown %d:%d %s (its owner before install)", prev[0], prev[1], NodePassword), func() error {
return u.sys.Chown(full, prev[0], prev[1])
})
}
}
return nil
}
func (u *uninstaller) removeCreatedDirs(match func(string) bool) {
dirs := append([]string(nil), u.rec.CreatedDirs...)
sort.Slice(dirs, func(i, j int) bool { return len(dirs[i]) > len(dirs[j]) })
for _, d := range dirs {
if !match(d) {
continue
}
full := u.path(d)
entries, err := os.ReadDir(full)
if err != nil || len(entries) > 0 {
continue
}
_ = u.change("remove directory "+d, func() error { return os.Remove(full) })
}
}
func (u *uninstaller) purge(units []hostsvc.UnitStatus, um UserManager) error {
if !u.uo.Purge {
kept := &Record{Role: u.rec.Role, Account: u.rec.Account, UID: u.rec.UID, StateDir: u.rec.StateDir, UnitPrefix: u.rec.UnitPrefix,
Steps: map[string]string{StepAccount: u.rec.Steps[StepAccount], StepStateDir: u.rec.Steps[StepStateDir]}}
for _, d := range u.rec.CreatedDirs {
if d == u.rec.StateDir || strings.HasPrefix(u.rec.StateDir, d+"/") {
kept.CreatedDirs = append(kept.CreatedDirs, d)
}
}
u.rec = kept
u.installer.rec = kept
return u.saveRecord()
}
if err := purgeableState(u.rec.StateDir); err != nil {
return err
}
state := u.path(u.rec.StateDir)
if _, err := os.Lstat(state); err == nil {
if err := u.change("remove the state dir "+u.rec.StateDir, func() error { return removeTree(state) }); err != nil {
return err
}
}
if u.rec.created(StepAccount) && u.known {
if err := u.change("delete account "+u.uo.Account, func() error { return u.sys.DeleteAccount(u.uo.Account) }); err != nil {
return err
}
}
u.removeCreatedDirs(func(string) bool { return true })
if err := u.change("remove the install record "+RecordPath(u.uo.Account), func() error { return os.Remove(u.recPath) }); err != nil {
return err
}
u.removeCreatedDirs(func(string) bool { return true })
return nil
}
func purgeableState(state string) error {
clean := filepath.Clean(state)
if !filepath.IsAbs(clean) || strings.Count(clean, "/") < 2 {
return fmt.Errorf("uninstall: the recorded state dir %q is not an absolute path two levels deep; --purge refuses to remove it", state)
}
if home, err := os.UserHomeDir(); err == nil && filepath.Clean(home) == clean {
return fmt.Errorf("uninstall: the recorded state dir %s is the invoking user's home; --purge refuses to remove it", state)
}
return nil
}
func writableTree(root string) {
filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
if d == nil || d.Type()&fs.ModeSymlink != 0 {
return nil
}
if st, serr := os.Lstat(p); serr == nil {
mode := st.Mode().Perm() | 0o600
if d.IsDir() {
mode |= 0o700
}
if mode != st.Mode().Perm() {
os.Chmod(p, mode)
}
}
return nil
})
}
func removeTree(root string) error {
writableTree(root)
if err := os.RemoveAll(root); err != nil {
writableTree(root)
if err := os.RemoveAll(root); err != nil {
return err
}
}
if _, err := os.Lstat(root); err == nil {
return fmt.Errorf("uninstall: %s is still there after its removal", root)
}
return nil
}