Skip to content
quarry Artifact [7a958c3b60]
Login

Artifact [7a958c3b60]

Artifact 7a958c3b60397c9fee4b39d745d4162bdb2b0e4448c802da626085dfb9e33574:


package install

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"net/url"
	"path"
	"strings"
)

// Uninstall is `quarry-runner uninstall [--keep-work] S|URL`: stop the
// unit, retire the token, then remove what the manifest lists and
// nothing else.
func Uninstall(ctx context.Context, e Env, args []string) error {
	fs := flag.NewFlagSet("uninstall", flag.ContinueOnError)
	keepWork := fs.Bool("keep-work", false, "leave the work directory")
	pos, err := parseArgs(fs, args)
	if err != nil {
		return err
	}
	s := e.Sys
	if len(pos) == 1 && !strings.Contains(pos[0], "://") && pos[0] == "" {
		return &ExitError{Code: 2, Msg: "name the runner"}
	}
	name, err := target(s, pos)
	if err != nil {
		return err
	}
	if s.Geteuid() != 0 {
		return errors.New("uninstall as root: run it with sudo")
	}
	m, err := loadManifest(s, name)
	if err != nil {
		return fmt.Errorf("no manifest, so nothing is known to remove: %w", err)
	}
	// The manifest is read as root and removed with RemoveAll: what it
	// names must look like what install makes.
	for _, p := range m.Paths {
		if !safePath(p) {
			return fmt.Errorf("%s lists %q, which is not a path an install makes; refusing", manifestPath(name), p)
		}
	}

	// Stopping lets running jobs be handed back (SIGTERM, then the unit's
	// TimeoutStopSec).
	if _, err := s.Run(ctx, "systemctl", "disable", "--now", m.unit()); err != nil {
		fmt.Fprintf(e.Out, "could not stop %s: %v\n", m.unit(), err)
	}

	var retireErr error
	token := ""
	if raw, err := s.ReadFile(m.envFile()); err == nil {
		token = envToken(raw)
	}
	if token != "" {
		if u, err := url.Parse(m.URL); err == nil {
			host, _ := s.Hostname()
			err := postJSON(ctx, e.client(), u.Scheme+"://"+u.Host+"/api/v1/r/"+url.PathEscape(m.Repo)+"/ci/worker-tokens/retire", "",
				map[string]string{"token": token, "host": host}, nil)
			var se *statusError
			if err != nil && !(errors.As(err, &se) && se.Code == 404) { // 404: already retired
				retireErr = err
			}
		}
	}

	for _, p := range m.Paths {
		if *keepWork && (p == m.work() || p == m.home()) {
			continue
		}
		if err := s.RemoveAll(p); err != nil {
			return err
		}
	}
	s.Run(ctx, "systemctl", "daemon-reload")
	for _, u := range m.Users {
		if s.UserExists(u) {
			if err := s.DelUser(u); err != nil {
				return err
			}
		}
	}
	for _, g := range m.Groups {
		if s.GroupExists(g) {
			if err := s.DelGroup(g); err != nil {
				return err
			}
		}
	}
	if err := s.Remove(manifestPath(name)); err != nil {
		return err
	}
	// The directories and the program are shared with other runners:
	// they go with the last one.
	if rest, _ := s.ReadDir(confDir); !hasManifest(rest) {
		if m.Program != "" && safePath(m.Program) {
			s.Remove(m.Program)
		}
		s.Remove(path.Dir(m.Program))
	}
	s.Remove(confDir)
	s.Remove(stateDir)
	if retireErr != nil {
		return fmt.Errorf("removed, but the forge did not retire the worker token (id %s): %v; revoke it in the repository's Settings, Worker tokens", m.TokenID, retireErr)
	}
	fmt.Fprintf(e.Out, "uninstalled %s\n", name)
	return nil
}

func hasManifest(names []string) bool {
	for _, n := range names {
		if strings.HasSuffix(n, ".json") {
			return true
		}
	}
	return false
}

// safePath is whether a manifest path is one an install makes: clean,
// absolute and at least three deep, so "/" and "/etc" are never removed.
func safePath(p string) bool {
	return path.IsAbs(p) && path.Clean(p) == p && strings.Count(p, "/") >= 3
}