Files
llmgw/internal/store/slurm_users.go
T
Ilker ManapandClaude Opus 5.5 d8ce573bdb
CI / test (push) Failing after 7m1s
Slurm's shared files and users: one path everywhere, accounts as Linux users
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>
2026-11-12 21:34:34 +01:00

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
}