Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming. Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
187 lines
9.6 KiB
Go
187 lines
9.6 KiB
Go
package store
|
|
|
|
import (
|
|
"database/sql"
|
|
"time"
|
|
)
|
|
|
|
// campusAdminInheritancePrefix is deliberately not a LIKE pattern: underscore
|
|
// is a wildcard in SQL LIKE. Derived grants must never become projection roots.
|
|
const campusAdminInheritancePrefix = "campus_admin_inherit:"
|
|
|
|
func (s *Store) ensureCampusAdminInheritanceSchema() error {
|
|
tx, err := s.DB.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
for _, statement := range []string{
|
|
`CREATE TABLE IF NOT EXISTS campus_admin_grants (
|
|
group_uuid TEXT NOT NULL, membership_uuid TEXT NOT NULL,
|
|
source TEXT NOT NULL, member_role TEXT NOT NULL,
|
|
created_at_ms INTEGER NOT NULL,
|
|
PRIMARY KEY(group_uuid,membership_uuid,source))`,
|
|
`CREATE INDEX IF NOT EXISTS campus_admin_grants_membership ON campus_admin_grants(membership_uuid)`,
|
|
`CREATE TABLE IF NOT EXISTS campus_admin_membership_origins (
|
|
membership_uuid TEXT PRIMARY KEY, domain_uuid TEXT NOT NULL,
|
|
principal_uuid TEXT NOT NULL, UNIQUE(domain_uuid,principal_uuid))`,
|
|
`CREATE TABLE IF NOT EXISTS campus_admin_migrations (key TEXT PRIMARY KEY)`,
|
|
} {
|
|
if _, err = tx.Exec(statement); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
// Only the old direct grants are authoritative. Copying old inherited rows
|
|
// would perpetuate cycles from the former insert-only implementation. Do not
|
|
// infer ownership of old Domain memberships: their origin was not recorded.
|
|
if _, err = tx.Exec(`INSERT OR IGNORE INTO campus_admin_grants
|
|
(group_uuid,membership_uuid,source,member_role,created_at_ms)
|
|
SELECT gm.group_uuid,gm.membership_uuid,gm.source,gm.member_role,gm.created_at_ms
|
|
FROM group_members gm JOIN groups g ON g.uuid=gm.group_uuid
|
|
WHERE g.builtin_key='campus_admin' AND substr(gm.source,1,21)!='campus_admin_inherit:'
|
|
AND NOT EXISTS(SELECT 1 FROM campus_admin_migrations WHERE key='direct-grants-v1')`); err != nil {
|
|
return err
|
|
}
|
|
if _, err = tx.Exec(`INSERT OR IGNORE INTO campus_admin_migrations(key) VALUES('direct-grants-v1')`); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
// seedCampusAdminRoleGrantsTx is the one-time migration of each independent
|
|
// Domain administrator binding. A later explicit group removal must not be
|
|
// undone by restarting the server or creating another Domain.
|
|
func seedCampusAdminRoleGrantsTx(tx *sql.Tx, now int64) error {
|
|
const candidates = `SELECT DISTINCT g.uuid AS group_uuid,m.uuid AS membership_uuid
|
|
FROM groups g JOIN domain_memberships m ON m.domain_uuid=g.domain_uuid
|
|
JOIN auth_role_bindings b ON b.membership_uuid=m.uuid
|
|
JOIN auth_roles r ON r.uuid=b.role_uuid AND r.domain_uuid=m.domain_uuid
|
|
JOIN auth_capability_grants c ON c.role_uuid=r.uuid
|
|
AND c.capability='manage' AND c.target_type='domain'
|
|
AND (c.target_id=m.domain_uuid OR c.target_id='*')
|
|
WHERE g.builtin_key='campus_admin'`
|
|
if _, err := tx.Exec(`INSERT OR IGNORE INTO campus_admin_grants
|
|
(group_uuid,membership_uuid,source,member_role,created_at_ms)
|
|
SELECT group_uuid,membership_uuid,'migration','owner',? FROM (`+candidates+`)
|
|
WHERE NOT EXISTS(SELECT 1 FROM campus_admin_migrations
|
|
WHERE key='role:'||group_uuid||':'||membership_uuid)`, now); err != nil {
|
|
return err
|
|
}
|
|
_, err := tx.Exec(`INSERT OR IGNORE INTO campus_admin_migrations(key)
|
|
SELECT 'role:'||group_uuid||':'||membership_uuid FROM (` + candidates + `)`)
|
|
return err
|
|
}
|
|
|
|
func (s *Store) ProjectCampusAdminMemberships() error {
|
|
tx, err := s.DB.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
if err = projectCampusAdminMembershipsTx(tx); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
// projectCampusAdminMembershipsTx materializes effective group membership from
|
|
// independent roots, never from its own output. The caller's mutation and this
|
|
// reconciliation commit together, so revocation has no observable stale window.
|
|
func projectCampusAdminMembershipsTx(tx *sql.Tx) error {
|
|
var hasDomains int
|
|
if err := tx.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='domains'`).Scan(&hasDomains); err != nil || hasDomains == 0 {
|
|
return err
|
|
}
|
|
now := time.Now().UnixMilli()
|
|
// These statements also obtain a write lock before reading projection input.
|
|
if _, err := tx.Exec(`DELETE FROM campus_admin_grants WHERE substr(source,1,21)='campus_admin_inherit:'`); err != nil {
|
|
return err
|
|
}
|
|
const roots = `SELECT src.uuid AS source_group_uuid,origin.uuid AS source_domain_uuid,
|
|
origin.campus_uuid,srcm.principal_uuid,MIN(grant.created_at_ms) AS created_at_ms,
|
|
CASE MAX(CASE grant.member_role WHEN 'owner' THEN 3 WHEN 'manager' THEN 2 ELSE 1 END)
|
|
WHEN 3 THEN 'owner' WHEN 2 THEN 'manager' ELSE 'member' END AS member_role
|
|
FROM campus_admin_grants grant
|
|
JOIN groups src ON src.uuid=grant.group_uuid AND src.builtin_key='campus_admin'
|
|
AND src.state='active' AND src.inherit_members=1
|
|
JOIN domains origin ON origin.uuid=src.domain_uuid AND origin.enabled=1
|
|
JOIN domain_memberships srcm ON srcm.uuid=grant.membership_uuid
|
|
AND srcm.domain_uuid=src.domain_uuid AND srcm.state='active'
|
|
JOIN principals p ON p.uuid=srcm.principal_uuid AND p.state='active'
|
|
WHERE substr(grant.source,1,21)!='campus_admin_inherit:'
|
|
GROUP BY src.uuid,origin.uuid,origin.campus_uuid,srcm.principal_uuid`
|
|
// Record exactly the memberships this projection creates. Existing local
|
|
// memberships (including deliberately suspended ones) are never reactivated.
|
|
if _, err := tx.Exec(`INSERT OR IGNORE INTO campus_admin_membership_origins
|
|
(membership_uuid,domain_uuid,principal_uuid)
|
|
SELECT lower(hex(randomblob(4)))||'-'||lower(hex(randomblob(2)))||'-4'||substr(lower(hex(randomblob(2))),2)||'-a'||substr(lower(hex(randomblob(2))),2)||'-'||lower(hex(randomblob(6))),domain_uuid,principal_uuid FROM (
|
|
SELECT DISTINCT dst.uuid AS domain_uuid,root.principal_uuid FROM (` + roots + `) root
|
|
JOIN domains dst ON dst.campus_uuid=root.campus_uuid AND dst.uuid!=root.source_domain_uuid AND dst.enabled=1
|
|
JOIN groups dstg ON dstg.domain_uuid=dst.uuid AND dstg.builtin_key='campus_admin' AND dstg.state='active'
|
|
WHERE NOT EXISTS(SELECT 1 FROM domain_memberships m
|
|
WHERE m.domain_uuid=dst.uuid AND m.principal_uuid=root.principal_uuid))`); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.Exec(`INSERT OR IGNORE INTO domain_memberships
|
|
(uuid,domain_uuid,principal_uuid,state,created_at_ms)
|
|
SELECT membership_uuid,domain_uuid,principal_uuid,'active',?
|
|
FROM campus_admin_membership_origins`, now); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.Exec(`INSERT INTO campus_admin_grants
|
|
(group_uuid,membership_uuid,source,member_role,created_at_ms)
|
|
SELECT dstg.uuid,dstm.uuid,'campus_admin_inherit:'||root.source_group_uuid,root.member_role,root.created_at_ms
|
|
FROM (` + roots + `) root
|
|
JOIN domains dst ON dst.campus_uuid=root.campus_uuid AND dst.uuid!=root.source_domain_uuid AND dst.enabled=1
|
|
JOIN groups dstg ON dstg.domain_uuid=dst.uuid AND dstg.builtin_key='campus_admin' AND dstg.state='active'
|
|
JOIN domain_memberships dstm ON dstm.domain_uuid=dst.uuid AND dstm.principal_uuid=root.principal_uuid
|
|
AND dstm.state='active'`); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.Exec(`DELETE FROM group_members WHERE
|
|
group_uuid IN (SELECT uuid FROM groups WHERE builtin_key='campus_admin')
|
|
OR substr(source,1,21)='campus_admin_inherit:'`); err != nil {
|
|
return err
|
|
}
|
|
// The strongest remaining grant wins. Prefer the independent local source
|
|
// on ties; weaker local grants remain in provenance and reappear on revoke.
|
|
if _, err := tx.Exec(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms)
|
|
SELECT group_uuid,membership_uuid,member_role,source,created_at_ms FROM (
|
|
SELECT grant.*,ROW_NUMBER() OVER(PARTITION BY grant.group_uuid,grant.membership_uuid
|
|
ORDER BY CASE grant.member_role WHEN 'owner' THEN 3 WHEN 'manager' THEN 2 ELSE 1 END DESC,
|
|
CASE WHEN substr(grant.source,1,21)='campus_admin_inherit:' THEN 1 ELSE 0 END,
|
|
grant.source) AS rank
|
|
FROM campus_admin_grants grant JOIN groups g ON g.uuid=grant.group_uuid
|
|
JOIN domains d ON d.uuid=g.domain_uuid
|
|
JOIN domain_memberships m ON m.uuid=grant.membership_uuid AND m.domain_uuid=g.domain_uuid
|
|
) WHERE rank=1`); err != nil {
|
|
return err
|
|
}
|
|
// A newly added independent group/role grant adopts an inherited membership
|
|
// as local. Revocation must not delete that membership, binding, or session.
|
|
if _, err := tx.Exec(`DELETE FROM campus_admin_membership_origins WHERE
|
|
EXISTS(SELECT 1 FROM auth_role_bindings b WHERE b.membership_uuid=campus_admin_membership_origins.membership_uuid)
|
|
OR EXISTS(SELECT 1 FROM group_members gm WHERE gm.membership_uuid=campus_admin_membership_origins.membership_uuid
|
|
AND substr(gm.source,1,21)!='campus_admin_inherit:')
|
|
OR EXISTS(SELECT 1 FROM campus_admin_grants grant WHERE grant.membership_uuid=campus_admin_membership_origins.membership_uuid
|
|
AND substr(grant.source,1,21)!='campus_admin_inherit:')`); err != nil {
|
|
return err
|
|
}
|
|
const noGrants = `NOT EXISTS(SELECT 1 FROM group_members gm
|
|
WHERE gm.membership_uuid=origin.membership_uuid)
|
|
AND NOT EXISTS(SELECT 1 FROM auth_role_bindings b WHERE b.membership_uuid=origin.membership_uuid)`
|
|
if _, err := tx.Exec(`UPDATE auth_sessions SET revoked_at_ms=? WHERE revoked_at_ms=0 AND EXISTS(
|
|
SELECT 1 FROM campus_admin_membership_origins origin
|
|
WHERE origin.domain_uuid=auth_sessions.domain_uuid AND origin.principal_uuid=auth_sessions.principal_uuid
|
|
AND `+noGrants+`)`, now); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.Exec(`DELETE FROM domain_memberships WHERE uuid IN (
|
|
SELECT origin.membership_uuid FROM campus_admin_membership_origins origin WHERE ` + noGrants + `)`); err != nil {
|
|
return err
|
|
}
|
|
_, err := tx.Exec(`DELETE FROM campus_admin_membership_origins WHERE
|
|
NOT EXISTS(SELECT 1 FROM domain_memberships m WHERE m.uuid=campus_admin_membership_origins.membership_uuid)`)
|
|
return err
|
|
}
|