package store import ( "context" "database/sql" "strconv" "strings" ) // SlurmUser is the Linux user llmgw makes for an active account on every // machine of the Slurm cluster (slurm.users "llmgw"). type SlurmUser struct { UserID string Email string Name string Login string UID int // SSHKeys are OpenSSH public keys, one a line. SSHKeys []string } // FirstSlurmUID is the first UID llmgw gives: far above what a // distribution or a site's own users take, and below the range systemd // keeps for its containers (524288). const FirstSlurmUID = 200000 // reservedLogins are names an account's login is never given: the // system's, Slurm's and llmgw's own. var reservedLogins = map[string]bool{ "root": true, "daemon": true, "bin": true, "sys": true, "sync": true, "games": true, "man": true, "lp": true, "mail": true, "news": true, "uucp": true, "proxy": true, "backup": true, "list": true, "irc": true, "nobody": true, "admin": true, "administrator": true, "slurm": true, "munge": true, "mysql": true, "mariadb": true, "postgres": true, "llmgw": true, "sshd": true, "ubuntu": true, "debian": true, "centos": true, "rocky": true, "ec2-user": true, "cloud-user": true, "syslog": true, "messagebus": true, "polkitd": true, "nfsnobody": true, "operator": true, "ftp": true, "adm": true, "halt": true, "shutdown": true, "www-data": true, "gnats": true, "user": true, "guest": true, } // loginFrom is an e-mail address's part before the @, as a Linux login: // lower case, letters, digits, _ and -, a letter first, 24 at most. func loginFrom(email string) string { local, _, _ := strings.Cut(strings.ToLower(email), "@") var b strings.Builder for _, r := range local { switch { case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '_', r == '-': b.WriteRune(r) case r == '.' || r == '+': b.WriteByte('_') } } l := strings.Trim(b.String(), "_-") if l == "" || l[0] < 'a' || l[0] > 'z' { l = "u" + l } if len(l) > 24 { l = l[:24] } return l } // SlurmUsers are the active accounts as Linux users, each given its login // and UID the first time it is asked for. func (s *DB) SlurmUsers(ctx context.Context) ([]SlurmUser, error) { type row struct { SlurmUser has bool } rows, err := queryAll(ctx, s.db, `SELECT u.id, u.email, u.name, COALESCE(su.login, ''), COALESCE(su.uid, 0), COALESCE(su.ssh_keys, '') FROM users u LEFT JOIN slurm_users su ON su.user_id = u.id WHERE u.state = ? ORDER BY u.created_at`, []any{string(UserActive)}, func(r *sql.Rows) (row, error) { var x row var keys string err := r.Scan(&x.UserID, &x.Email, &x.Name, &x.Login, &x.UID, &keys) x.SSHKeys, x.has = splitKeys(keys), x.Login != "" return x, err }) if err != nil { return nil, err } out := make([]SlurmUser, 0, len(rows)) for _, x := range rows { if !x.has { login, uid, err := s.giveSlurmLogin(ctx, x.UserID, x.Email) if err != nil { return nil, err } x.Login, x.UID = login, uid } out = append(out, x.SlurmUser) } return out, nil } // SlurmUserByID is one account's Linux user, given its login and UID if it // has none yet. func (s *DB) SlurmUserByID(ctx context.Context, userID string) (SlurmUser, error) { u, err := s.UserByID(ctx, userID) if err != nil { return SlurmUser{}, err } out := SlurmUser{UserID: u.ID, Email: u.Email, Name: u.Name} var keys string err = s.db.QueryRowContext(ctx, `SELECT login, uid, ssh_keys FROM slurm_users WHERE user_id = ?`, userID). Scan(&out.Login, &out.UID, &keys) switch { case err == sql.ErrNoRows: out.Login, out.UID, err = s.giveSlurmLogin(ctx, u.ID, u.Email) case err == nil: out.SSHKeys = splitKeys(keys) } return out, err } // SetSlurmSSHKeys replaces an account's SSH public keys, checked by the // caller. func (s *DB) SetSlurmSSHKeys(ctx context.Context, userID string, keys []string) error { if _, err := s.SlurmUserByID(ctx, userID); err != nil { return err } _, err := s.db.ExecContext(ctx, `UPDATE slurm_users SET ssh_keys = ? WHERE user_id = ?`, strings.Join(keys, "\n"), userID) return err } // giveSlurmLogin gives an account its login, its e-mail's local part with a // number after it if that is taken, and the next UID. func (s *DB) giveSlurmLogin(ctx context.Context, userID, email string) (string, int, error) { var login string var uid int err := s.inTx(ctx, func(c conn) error { // Another pass may have given it meanwhile. err := c.QueryRowContext(ctx, `SELECT login, uid FROM slurm_users WHERE user_id = ?`, userID).Scan(&login, &uid) if err == nil { return nil } if err != sql.ErrNoRows { return err } if err := c.QueryRowContext(ctx, `SELECT COALESCE(MAX(uid), 0) FROM slurm_users`).Scan(&uid); err != nil { return err } uid = max(uid+1, FirstSlurmUID) base := loginFrom(email) login = base for n := 2; ; n++ { if !reservedLogins[login] { var taken int if err := c.QueryRowContext(ctx, `SELECT COUNT(*) FROM slurm_users WHERE login = ?`, login).Scan(&taken); err != nil { return err } if taken == 0 { break } } login = base + strconv.Itoa(n) } _, err = c.ExecContext(ctx, `INSERT INTO slurm_users (user_id, login, uid) VALUES (?, ?, ?)`, userID, login, uid) return err }) return login, uid, err } func splitKeys(s string) []string { var out []string for _, l := range strings.Split(s, "\n") { if l = strings.TrimSpace(l); l != "" { out = append(out, l) } } return out }