Slurm's shared files and users: one path everywhere, accounts as Linux users
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>
This commit is contained in:
Ilker ManapandClaude Opus 5.5 committed 2026-11-12 21:34:34 +01:00
1 parent b9d20e7bba
commit d8ce573bdb
45 files changed
+2505 -79

No files matched your search

+1
View File
@@ -29,6 +29,7 @@ var copyOrder = []string{
"user_excluded_licences",
// After users, which it points at.
"user_directory",
"slurm_users",
"preset_state",
"api_keys",
"key_claims",
@@ -0,0 +1,12 @@
-- Ported from the SQLite migration of the same number.
-- The Linux user llmgw makes for an account on every machine of the Slurm
-- cluster, when slurm.users is "llmgw": its login and UID (also its group's
-- GID), given once and never again to another, and the SSH public keys it
-- logs in with. No reference to users: a deleted account's row stays, so its
-- login and UID, still on the files it left, are not handed to someone else.
CREATE TABLE slurm_users (
user_id TEXT PRIMARY KEY,
login TEXT NOT NULL UNIQUE,
uid INTEGER NOT NULL UNIQUE,
ssh_keys TEXT NOT NULL DEFAULT ''
);
@@ -0,0 +1,11 @@
-- The Linux user llmgw makes for an account on every machine of the Slurm
-- cluster, when slurm.users is "llmgw": its login and UID (also its group's
-- GID), given once and never again to another, and the SSH public keys it
-- logs in with. No reference to users: a deleted account's row stays, so its
-- login and UID, still on the files it left, are not handed to someone else.
CREATE TABLE slurm_users (
user_id TEXT PRIMARY KEY,
login TEXT NOT NULL UNIQUE,
uid INTEGER NOT NULL UNIQUE,
ssh_keys TEXT NOT NULL DEFAULT ''
);
+174
View File
@@ -0,0 +1,174 @@
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
}
+57
View File
@@ -0,0 +1,57 @@
package store
import (
"context"
"testing"
"time"
)
func TestSlurmUsersGetLoginsAndUIDsOnce(t *testing.T) {
ctx := context.Background()
db := openDB(t)
for i, e := range []string{"ayse@a.test", "Ayse@b.test", "root@c.test", "9lives@d.test", "ali.veli@e.test"} {
id := "u" + string(rune('0'+i))
if err := db.CreateUser(ctx, User{ID: id, Email: e, Name: e, PasswordHash: "x", State: UserActive,
CreatedAt: time.Unix(int64(i), 0)}); err != nil {
t.Fatal(err)
}
}
if err := db.CreateUser(ctx, User{ID: "p", Email: "pending@x.test", PasswordHash: "x", State: UserPending,
CreatedAt: time.Unix(9, 0)}); err != nil {
t.Fatal(err)
}
us, err := db.SlurmUsers(ctx)
if err != nil {
t.Fatal(err)
}
want := []struct {
login string
uid int
}{{"ayse", 200000}, {"ayse2", 200001}, {"root2", 200002}, {"u9lives", 200003}, {"ali_veli", 200004}}
if len(us) != len(want) {
t.Fatalf("%d users: %+v", len(us), us)
}
for i, w := range want {
if us[i].Login != w.login || us[i].UID != w.uid {
t.Errorf("%s: %s %d, want %s %d", us[i].Email, us[i].Login, us[i].UID, w.login, w.uid)
}
}
if err := db.SetSlurmSSHKeys(ctx, "u0", []string{"ssh-ed25519 AAAA a", "ssh-ed25519 BBBB b"}); err != nil {
t.Fatal(err)
}
again, _ := db.SlurmUsers(ctx)
if again[0].UID != 200000 || len(again[0].SSHKeys) != 2 {
t.Fatalf("asked again: %+v", again[0])
}
// A deleted account's UID is not given again.
if _, err := db.raw.ExecContext(ctx, `DELETE FROM users WHERE id = 'u4'`); err != nil {
t.Fatal(err)
}
if err := db.ApproveUser(ctx, "p", "", "admin", time.Now()); err != nil {
t.Fatal(err)
}
u, err := db.SlurmUserByID(ctx, "p")
if err != nil || u.UID != 200005 || u.Login != "pending" {
t.Fatalf("%+v %v", u, err)
}
}