CI / test (push) Failing after 7m1s
slurm.shared mounts the site's NFS export, has an llmgw node export the path over NFS to the Slurm machines alone (2049 in the firewall), or looks for a file system the site mounts. slurm.users "llmgw" makes each active account a Linux user on every Slurm machine: login from its e-mail, a UID from 200000 kept in slurm_users and never reused, its home on the shared path, its SSH keys from the portal's Profile (or ctl slurm users keys) read by sshd from /etc/llmgw/ssh-keys. server init --slurm chooses /shared from the first machine and llmgw's users; --slurm-shared and --slurm-users change that. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
175 lines
5.3 KiB
Go
175 lines
5.3 KiB
Go
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
|
|
}
|