feat(storage): add native PostgreSQL runtime and verified offline application import
Build and publish container images / images (push) Failing after 12m29s
Build and publish container images / images (push) Failing after 12m29s
This commit is contained in:
1 parent
96065d1e89
commit
0ba1dcfef0
243 files changed
+21441
-3090
No files matched your search
+274
-166
@@ -1,7 +1,10 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"regexp"
|
||||
"strings"
|
||||
"time"
|
||||
@@ -40,12 +43,24 @@ func normalizeGroupName(name string) (string, error) {
|
||||
}
|
||||
|
||||
func (s *Store) EnsureBuiltinAdminGroups() error {
|
||||
now := time.Now().UnixMilli()
|
||||
var hasDomains int
|
||||
if err := s.DB.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='domains'`).Scan(&hasDomains); err != nil || hasDomains == 0 {
|
||||
return err
|
||||
return s.EnsureBuiltinAdminGroupsContext(context.Background())
|
||||
}
|
||||
|
||||
func (s *Store) EnsureBuiltinAdminGroupsContext(ctx context.Context) error {
|
||||
// Legacy SQLite fixtures can initialize authentication without namespaces.
|
||||
if s.sqlBackend == storeSQLite {
|
||||
var present bool
|
||||
if err := s.DB.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='domains')`).Scan(&present); err != nil || !present {
|
||||
return err
|
||||
}
|
||||
}
|
||||
rows, err := s.DB.Query(`SELECT uuid FROM domains`)
|
||||
return s.groupWrite(ctx, s.ensureBuiltinAdminGroupsContext)
|
||||
}
|
||||
|
||||
// The caller holds the namespace writer lock, including when creating a Domain.
|
||||
func (s *Store) ensureBuiltinAdminGroupsContext(ctx context.Context, tx *sql.Tx) error {
|
||||
now := time.Now().UnixMilli()
|
||||
rows, err := tx.QueryContext(ctx, `SELECT uuid FROM domains ORDER BY uuid`)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -58,70 +73,105 @@ func (s *Store) EnsureBuiltinAdminGroups() error {
|
||||
}
|
||||
domains = append(domains, id)
|
||||
}
|
||||
rows.Close()
|
||||
tx, err := s.DB.Begin()
|
||||
if err != nil {
|
||||
if err := rows.Err(); err != nil {
|
||||
rows.Close()
|
||||
return err
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
for _, domainUUID := range domains {
|
||||
for _, key := range []string{"campus_admin", "domain_admin"} {
|
||||
_, err = tx.Exec(`INSERT INTO groups(uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,'members','active',?,?,?,?) ON CONFLICT(domain_uuid,name) DO UPDATE SET builtin_key=excluded.builtin_key`, uuid.NewString(), domainUUID, key, strings.ReplaceAll(key, "_", " "), "Built-in administrative group", key, key == "campus_admin", now, now)
|
||||
inherit := 0
|
||||
if key == "campus_admin" {
|
||||
inherit = 1
|
||||
}
|
||||
_, err = tx.ExecContext(ctx, fmt.Sprintf(`INSERT INTO groups(uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms) VALUES(%s,%s,%s,%s,%s,'members','active',%s,%s,%s,%s) ON CONFLICT(domain_uuid,name) DO UPDATE SET builtin_key=excluded.builtin_key`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4), s.sqlParam(5), s.sqlParam(6), s.sqlParam(7), s.sqlParam(8), s.sqlParam(9)), uuid.NewString(), domainUUID, key, strings.ReplaceAll(key, "_", " "), "Built-in administrative group", key, inherit, now, now)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
_, err = tx.Exec(`INSERT OR IGNORE INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) SELECT g.uuid,m.uuid,'owner','migration',? 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 JOIN auth_capability_grants c ON c.role_uuid=r.uuid AND c.capability='manage' AND c.target_type='domain' WHERE g.domain_uuid=? AND g.builtin_key='domain_admin'`, now, domainUUID)
|
||||
_, err = tx.ExecContext(ctx, fmt.Sprintf(`INSERT INTO group_members
|
||||
(group_uuid,membership_uuid,member_role,source,created_at_ms)
|
||||
SELECT g.uuid,m.uuid,'owner','migration',%s 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.domain_uuid=%s AND g.builtin_key='domain_admin'
|
||||
ON CONFLICT(group_uuid,membership_uuid) DO NOTHING`, s.sqlParam(1), s.sqlParam(2)), now, domainUUID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err = seedCampusAdminRoleGrantsTx(tx, now); err != nil {
|
||||
if err = s.seedCampusAdminRoleGrantsContext(ctx, tx, now); err != nil {
|
||||
return err
|
||||
}
|
||||
if err = projectCampusAdminMembershipsTx(tx); err != nil {
|
||||
return err
|
||||
}
|
||||
return tx.Commit()
|
||||
return s.projectCampusAdminMembershipsContext(ctx, tx)
|
||||
}
|
||||
|
||||
func (s *Store) IsBuiltinGroupAdmin(domainUUID, principalUUID, key string) bool {
|
||||
var allowed int
|
||||
_ = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM groups g JOIN domains d ON d.uuid=g.domain_uuid AND d.enabled=1 JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE g.domain_uuid=? AND g.builtin_key=? AND g.state='active' AND m.principal_uuid=? AND m.state='active' AND p.state='active' AND gm.member_role IN ('owner','manager'))`, domainUUID, key, principalUUID).Scan(&allowed)
|
||||
return allowed != 0
|
||||
allowed, err := s.IsBuiltinGroupAdminContext(context.Background(), domainUUID, principalUUID, key)
|
||||
return err == nil && allowed
|
||||
}
|
||||
|
||||
// Error-aware callers can distinguish unavailable authorization storage from a
|
||||
// denial. Legacy bool callers remain fail-closed on every storage error.
|
||||
func (s *Store) IsBuiltinGroupAdminContext(ctx context.Context, domainUUID, principalUUID, key string) (bool, error) {
|
||||
if domainUUID == "" || principalUUID == "" || (key != "campus_admin" && key != "domain_admin") {
|
||||
return false, nil
|
||||
}
|
||||
var allowed bool
|
||||
err := s.DB.QueryRowContext(ctx, fmt.Sprintf(`SELECT EXISTS(SELECT 1 FROM groups g JOIN domains d ON d.uuid=g.domain_uuid AND d.enabled=1 JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE g.domain_uuid=%s AND g.builtin_key=%s AND g.state='active' AND m.principal_uuid=%s AND m.state='active' AND p.state='active' AND gm.member_role IN ('owner','manager'))`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), domainUUID, key, principalUUID).Scan(&allowed)
|
||||
return err == nil && allowed, s.sqlError("builtin group authorization", err)
|
||||
}
|
||||
|
||||
func (s *Store) IsCampusAdmin(campusUUID, principalUUID string) bool {
|
||||
var allowed int
|
||||
_ = s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM groups g JOIN domains d ON d.uuid=g.domain_uuid AND d.enabled=1 JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE d.campus_uuid=? AND g.builtin_key='campus_admin' AND g.state='active' AND m.principal_uuid=? AND m.state='active' AND p.state='active' AND gm.member_role IN ('owner','manager'))`, campusUUID, principalUUID).Scan(&allowed)
|
||||
return allowed != 0
|
||||
allowed, err := s.IsCampusAdminContext(context.Background(), campusUUID, principalUUID)
|
||||
return err == nil && allowed
|
||||
}
|
||||
|
||||
func (s *Store) IsCampusAdminContext(ctx context.Context, campusUUID, principalUUID string) (bool, error) {
|
||||
if campusUUID == "" || principalUUID == "" {
|
||||
return false, nil
|
||||
}
|
||||
var allowed bool
|
||||
err := s.DB.QueryRowContext(ctx, fmt.Sprintf(`SELECT EXISTS(SELECT 1 FROM groups g JOIN domains d ON d.uuid=g.domain_uuid AND d.enabled=1 JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE d.campus_uuid=%s AND g.builtin_key='campus_admin' AND g.state='active' AND m.principal_uuid=%s AND m.state='active' AND p.state='active' AND gm.member_role IN ('owner','manager'))`, s.sqlParam(1), s.sqlParam(2)), campusUUID, principalUUID).Scan(&allowed)
|
||||
return err == nil && allowed, s.sqlError("campus authorization", err)
|
||||
}
|
||||
|
||||
func (s *Store) SetCampusAdminInheritance(groupUUID string, enabled bool) error {
|
||||
return s.SetCampusAdminInheritanceContext(context.Background(), groupUUID, enabled)
|
||||
}
|
||||
|
||||
func (s *Store) SetCampusAdminInheritanceContext(ctx context.Context, groupUUID string, enabled bool) error {
|
||||
value := 0
|
||||
if enabled {
|
||||
value = 1
|
||||
}
|
||||
tx, err := s.DB.Begin()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
result, err := tx.Exec(`UPDATE groups SET inherit_members=?,updated_at_ms=? WHERE uuid=? AND builtin_key='campus_admin'`, value, time.Now().UnixMilli(), groupUUID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
changed, _ := result.RowsAffected()
|
||||
if changed != 1 {
|
||||
return errors.New("campus_admin group not found")
|
||||
}
|
||||
if err = projectCampusAdminMembershipsTx(tx); err != nil {
|
||||
return err
|
||||
}
|
||||
return tx.Commit()
|
||||
return s.groupWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
|
||||
result, err := tx.ExecContext(ctx, fmt.Sprintf(`UPDATE groups SET inherit_members=%s,updated_at_ms=%s WHERE uuid=%s AND builtin_key='campus_admin'`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), value, time.Now().UnixMilli(), groupUUID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
changed, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if changed != 1 {
|
||||
return namespaceValidationError("campus_admin group not found")
|
||||
}
|
||||
return s.projectCampusAdminMembershipsContext(ctx, tx)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Store) CreateGroup(domainUUID, ownerPrincipalUUID, name, displayName, description, visibility string) (*Group, error) {
|
||||
return s.CreateGroupContext(context.Background(), domainUUID, ownerPrincipalUUID, name, displayName, description, visibility)
|
||||
}
|
||||
|
||||
func (s *Store) CreateGroupContext(ctx context.Context, domainUUID, ownerPrincipalUUID, name, displayName, description, visibility string) (*Group, error) {
|
||||
name, err := normalizeGroupName(name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@@ -134,127 +184,156 @@ func (s *Store) CreateGroup(domainUUID, ownerPrincipalUUID, name, displayName, d
|
||||
}
|
||||
now := time.Now().UnixMilli()
|
||||
group := &Group{UUID: uuid.NewString(), DomainUUID: domainUUID, Name: name, DisplayName: strings.TrimSpace(displayName), Description: strings.TrimSpace(description), Visibility: visibility, State: "active", CreatedAtMS: now, UpdatedAtMS: now}
|
||||
tx, err := s.DB.Begin()
|
||||
err = s.groupWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
|
||||
var membershipUUID string
|
||||
if err := tx.QueryRowContext(ctx, fmt.Sprintf(`SELECT m.uuid FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' WHERE m.domain_uuid=%s AND m.principal_uuid=%s AND m.state='active'`, s.sqlParam(1), s.sqlParam(2)), domainUUID, ownerPrincipalUUID).Scan(&membershipUUID); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx, `INSERT INTO groups(uuid,domain_uuid,name,display_name,description,visibility,state,created_at_ms,updated_at_ms) VALUES(`+s.sqlValues(9)+`)`, group.UUID, domainUUID, group.Name, group.DisplayName, group.Description, group.Visibility, group.State, now, now); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx, fmt.Sprintf(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) VALUES(%s,%s,'owner','local',%s)`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), group.UUID, membershipUUID, now); err != nil {
|
||||
return err
|
||||
}
|
||||
// An independent ownership grant adopts an inherited-only membership.
|
||||
_, err := tx.ExecContext(ctx, `DELETE FROM campus_admin_membership_origins WHERE membership_uuid=`+s.sqlParam(1), membershipUUID)
|
||||
return err
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
var membershipUUID string
|
||||
if err := tx.QueryRow(`SELECT uuid FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=? AND state='active'`, domainUUID, ownerPrincipalUUID).Scan(&membershipUUID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err = tx.Exec(`INSERT INTO groups(uuid,domain_uuid,name,display_name,description,visibility,state,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,?,?,?,?)`, group.UUID, domainUUID, group.Name, group.DisplayName, group.Description, group.Visibility, group.State, now, now); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err = tx.Exec(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) VALUES(?,?, 'owner','local',?)`, group.UUID, membershipUUID, now); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return group, tx.Commit()
|
||||
return group, nil
|
||||
}
|
||||
|
||||
func (s *Store) GroupByName(domainUUID, name string) (*Group, error) {
|
||||
return s.GroupByNameContext(context.Background(), domainUUID, name)
|
||||
}
|
||||
|
||||
func (s *Store) GroupByNameContext(ctx context.Context, domainUUID, name string) (*Group, error) {
|
||||
var group Group
|
||||
err := s.DB.QueryRow(`SELECT uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms FROM groups WHERE domain_uuid=? AND name=? AND state!='archived'`, domainUUID, strings.ToLower(strings.TrimSpace(name))).Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS)
|
||||
return &group, err
|
||||
err := s.DB.QueryRowContext(ctx, fmt.Sprintf(`SELECT uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms FROM groups WHERE domain_uuid=%s AND name=%s AND state!='archived'`, s.sqlParam(1), s.sqlParam(2)), domainUUID, strings.ToLower(strings.TrimSpace(name))).Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS)
|
||||
return &group, s.sqlError("read group by name", err)
|
||||
}
|
||||
|
||||
func (s *Store) GroupByUUID(domainUUID, groupUUID string) (*Group, error) {
|
||||
return s.GroupByUUIDContext(context.Background(), domainUUID, groupUUID)
|
||||
}
|
||||
|
||||
func (s *Store) GroupByUUIDContext(ctx context.Context, domainUUID, groupUUID string) (*Group, error) {
|
||||
var group Group
|
||||
err := s.DB.QueryRow(`SELECT uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms FROM groups WHERE domain_uuid=? AND uuid=?`, domainUUID, groupUUID).Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS)
|
||||
return &group, err
|
||||
err := s.DB.QueryRowContext(ctx, fmt.Sprintf(`SELECT uuid,domain_uuid,name,display_name,description,visibility,state,builtin_key,inherit_members,created_at_ms,updated_at_ms FROM groups WHERE domain_uuid=%s AND uuid=%s`, s.sqlParam(1), s.sqlParam(2)), domainUUID, groupUUID).Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS)
|
||||
return &group, s.sqlError("read group by UUID", err)
|
||||
}
|
||||
|
||||
func (s *Store) ListGroups(domainUUID, principalUUID string) ([]Group, error) {
|
||||
rows, err := s.DB.Query(`SELECT DISTINCT g.uuid,g.domain_uuid,g.name,g.display_name,g.description,g.visibility,g.state,g.builtin_key,g.inherit_members,g.created_at_ms,g.updated_at_ms FROM groups g LEFT JOIN group_members gm ON gm.group_uuid=g.uuid LEFT JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.principal_uuid=? WHERE g.domain_uuid=? AND g.state!='archived' AND (g.visibility='public' OR (?!='' AND g.visibility='domain') OR m.uuid IS NOT NULL) ORDER BY lower(g.display_name),g.name`, principalUUID, domainUUID, principalUUID)
|
||||
return s.ListGroupsContext(context.Background(), domainUUID, principalUUID)
|
||||
}
|
||||
|
||||
func (s *Store) ListGroupsContext(ctx context.Context, domainUUID, principalUUID string) ([]Group, error) {
|
||||
// EXISTS avoids duplicate rows and PostgreSQL's DISTINCT/ORDER BY mismatch.
|
||||
// A nonempty global Principal UUID alone is not Domain membership.
|
||||
rows, err := s.DB.QueryContext(ctx, fmt.Sprintf(`SELECT g.uuid,g.domain_uuid,g.name,g.display_name,g.description,g.visibility,g.state,g.builtin_key,g.inherit_members,g.created_at_ms,g.updated_at_ms
|
||||
FROM groups g WHERE g.domain_uuid=%s AND g.state!='archived'
|
||||
AND (g.visibility='public' OR EXISTS(
|
||||
SELECT 1 FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid
|
||||
WHERE m.domain_uuid=g.domain_uuid AND m.principal_uuid=%s AND m.state='active'
|
||||
AND p.state IN ('active','readonly')
|
||||
AND (g.visibility='domain' OR EXISTS(SELECT 1 FROM group_members gm WHERE gm.group_uuid=g.uuid AND gm.membership_uuid=m.uuid))))
|
||||
ORDER BY lower(g.display_name),g.name,g.uuid`, s.sqlParam(1), s.sqlParam(2)), domainUUID, principalUUID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return nil, s.sqlError("list groups", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var groups []Group
|
||||
for rows.Next() {
|
||||
var group Group
|
||||
if err := rows.Scan(&group.UUID, &group.DomainUUID, &group.Name, &group.DisplayName, &group.Description, &group.Visibility, &group.State, &group.BuiltinKey, &group.InheritMembers, &group.CreatedAtMS, &group.UpdatedAtMS); err != nil {
|
||||
return nil, err
|
||||
return nil, s.sqlError("scan group", err)
|
||||
}
|
||||
groups = append(groups, group)
|
||||
}
|
||||
return groups, rows.Err()
|
||||
return groups, s.sqlError("list groups", rows.Err())
|
||||
}
|
||||
|
||||
func (s *Store) GroupMemberRole(groupUUID, principalUUID string) string {
|
||||
var role string
|
||||
_ = s.DB.QueryRow(`SELECT gm.member_role FROM group_members gm JOIN domain_memberships m ON m.uuid=gm.membership_uuid WHERE gm.group_uuid=? AND m.principal_uuid=? AND m.state='active'`, groupUUID, principalUUID).Scan(&role)
|
||||
_ = s.DB.QueryRow(fmt.Sprintf(`SELECT gm.member_role FROM group_members gm JOIN groups g ON g.uuid=gm.group_uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid WHERE gm.group_uuid=%s AND m.principal_uuid=%s AND m.state='active'`, s.sqlParam(1), s.sqlParam(2)), groupUUID, principalUUID).Scan(&role)
|
||||
return role
|
||||
}
|
||||
|
||||
func (s *Store) GroupMemberRoleByMembership(groupUUID, membershipUUID string) string {
|
||||
var role string
|
||||
_ = s.DB.QueryRow(`SELECT member_role FROM group_members WHERE group_uuid=? AND membership_uuid=?`, groupUUID, membershipUUID).Scan(&role)
|
||||
_ = s.DB.QueryRow(fmt.Sprintf(`SELECT gm.member_role FROM group_members gm JOIN groups g ON g.uuid=gm.group_uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid WHERE gm.group_uuid=%s AND gm.membership_uuid=%s`, s.sqlParam(1), s.sqlParam(2)), groupUUID, membershipUUID).Scan(&role)
|
||||
return role
|
||||
}
|
||||
|
||||
func (s *Store) ListGroupMembers(groupUUID string) ([]GroupMember, error) {
|
||||
rows, err := s.DB.Query(`SELECT m.uuid,p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' LIMIT 1),p.uuid),p.display_name,gm.member_role,gm.source FROM group_members gm JOIN domain_memberships m ON m.uuid=gm.membership_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE gm.group_uuid=? ORDER BY CASE gm.member_role WHEN 'owner' THEN 0 WHEN 'manager' THEN 1 ELSE 2 END,lower(p.display_name)`, groupUUID)
|
||||
return s.ListGroupMembersContext(context.Background(), groupUUID)
|
||||
}
|
||||
|
||||
func (s *Store) ListGroupMembersContext(ctx context.Context, groupUUID string) ([]GroupMember, error) {
|
||||
rows, err := s.DB.QueryContext(ctx, `SELECT m.uuid,p.uuid,COALESCE((SELECT subject FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' ORDER BY i.subject,i.uuid LIMIT 1),p.uuid),p.display_name,gm.member_role,gm.source FROM group_members gm JOIN groups g ON g.uuid=gm.group_uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE gm.group_uuid=`+s.sqlParam(1)+` ORDER BY CASE gm.member_role WHEN 'owner' THEN 0 WHEN 'manager' THEN 1 ELSE 2 END,lower(p.display_name),m.uuid`, groupUUID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return nil, s.sqlError("list group members", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var members []GroupMember
|
||||
for rows.Next() {
|
||||
var member GroupMember
|
||||
if err := rows.Scan(&member.MembershipUUID, &member.PrincipalUUID, &member.Username, &member.DisplayName, &member.MemberRole, &member.Source); err != nil {
|
||||
return nil, err
|
||||
return nil, s.sqlError("scan group member", err)
|
||||
}
|
||||
members = append(members, member)
|
||||
}
|
||||
return members, rows.Err()
|
||||
return members, s.sqlError("list group members", rows.Err())
|
||||
}
|
||||
|
||||
func (s *Store) AddGroupMemberByUsername(domainUUID, groupUUID, username, role string) error {
|
||||
return s.AddGroupMemberByUsernameContext(context.Background(), domainUUID, groupUUID, username, role)
|
||||
}
|
||||
|
||||
func (s *Store) AddGroupMemberByUsernameContext(ctx context.Context, domainUUID, groupUUID, username, role string) error {
|
||||
if role != "owner" && role != "manager" && role != "member" {
|
||||
return errors.New("invalid group member role")
|
||||
}
|
||||
tx, err := s.DB.Begin()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
// Serialize before the identity lookup as well as the ownership check.
|
||||
if _, err = tx.Exec(`UPDATE groups SET updated_at_ms=updated_at_ms WHERE uuid=? AND domain_uuid=?`, groupUUID, domainUUID); err != nil {
|
||||
return err
|
||||
}
|
||||
var membershipUUID, builtinKey string
|
||||
err = tx.QueryRow(`SELECT m.uuid,g.builtin_key FROM domain_memberships m JOIN principal_identities i ON i.principal_uuid=m.principal_uuid AND i.provider_type='password' JOIN groups g ON g.uuid=? AND g.domain_uuid=m.domain_uuid WHERE m.domain_uuid=? AND i.subject=? AND m.state='active'`, groupUUID, domainUUID, strings.ToLower(strings.TrimSpace(username))).Scan(&membershipUUID, &builtinKey)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Ordinary add/update is not an ownership-transfer API. Keep this check in
|
||||
// the write itself, including when another request just promoted the member.
|
||||
result, err := tx.Exec(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) VALUES(?,?,?,'local',?) ON CONFLICT(group_uuid,membership_uuid) DO UPDATE SET member_role=excluded.member_role,source=excluded.source WHERE group_members.member_role!='owner' OR excluded.member_role='owner'`, groupUUID, membershipUUID, role, time.Now().UnixMilli())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if count, err := result.RowsAffected(); err != nil {
|
||||
return err
|
||||
} else if count == 0 {
|
||||
return errors.New("owner role cannot be downgraded by a member update")
|
||||
}
|
||||
if builtinKey == "campus_admin" {
|
||||
if _, err = tx.Exec(`DELETE FROM campus_admin_grants WHERE group_uuid=? AND membership_uuid=? AND substr(source,1,21)!='campus_admin_inherit:'`, groupUUID, membershipUUID); err != nil {
|
||||
return s.groupWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
|
||||
// Serialize before the identity lookup as well as the ownership check.
|
||||
if _, err := tx.ExecContext(ctx, fmt.Sprintf(`UPDATE groups SET updated_at_ms=updated_at_ms WHERE uuid=%s AND domain_uuid=%s`, s.sqlParam(1), s.sqlParam(2)), groupUUID, domainUUID); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err = tx.Exec(`INSERT INTO campus_admin_grants(group_uuid,membership_uuid,source,member_role,created_at_ms) VALUES(?,?,'local',?,?)`, groupUUID, membershipUUID, role, time.Now().UnixMilli()); err != nil {
|
||||
var membershipUUID, builtinKey string
|
||||
err := tx.QueryRowContext(ctx, fmt.Sprintf(`SELECT m.uuid,g.builtin_key FROM domain_memberships m JOIN principal_identities i ON i.principal_uuid=m.principal_uuid AND i.provider_type='password' JOIN groups g ON g.uuid=%s AND g.domain_uuid=m.domain_uuid WHERE m.domain_uuid=%s AND i.subject=%s AND m.state='active'`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), groupUUID, domainUUID, strings.ToLower(strings.TrimSpace(username))).Scan(&membershipUUID, &builtinKey)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err = projectCampusAdminMembershipsTx(tx); err != nil {
|
||||
// Ordinary add/update is not an ownership-transfer API. Keep this check in
|
||||
// the write itself, including when another request just promoted the member.
|
||||
result, err := tx.ExecContext(ctx, fmt.Sprintf(`INSERT INTO group_members(group_uuid,membership_uuid,member_role,source,created_at_ms) VALUES(%s,%s,%s,'local',%s) ON CONFLICT(group_uuid,membership_uuid) DO UPDATE SET member_role=excluded.member_role,source=excluded.source WHERE group_members.member_role!='owner' OR excluded.member_role='owner'`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4)), groupUUID, membershipUUID, role, time.Now().UnixMilli())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
// An explicit local grant adopts a previously projected Domain membership.
|
||||
if _, err = tx.Exec(`DELETE FROM campus_admin_membership_origins WHERE membership_uuid=?`, membershipUUID); err != nil {
|
||||
return err
|
||||
}
|
||||
return tx.Commit()
|
||||
if count, err := result.RowsAffected(); err != nil {
|
||||
return err
|
||||
} else if count == 0 {
|
||||
return namespaceValidationError("owner role cannot be downgraded by a member update")
|
||||
}
|
||||
if builtinKey == "campus_admin" {
|
||||
if _, err = tx.ExecContext(ctx, fmt.Sprintf(`DELETE FROM campus_admin_grants WHERE group_uuid=%s AND membership_uuid=%s AND substr(source,1,21)!='campus_admin_inherit:'`, s.sqlParam(1), s.sqlParam(2)), groupUUID, membershipUUID); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err = tx.ExecContext(ctx, fmt.Sprintf(`INSERT INTO campus_admin_grants(group_uuid,membership_uuid,source,member_role,created_at_ms) VALUES(%s,%s,'local',%s,%s)`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4)), groupUUID, membershipUUID, role, time.Now().UnixMilli()); err != nil {
|
||||
return err
|
||||
}
|
||||
if err = s.projectCampusAdminMembershipsContext(ctx, tx); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
// An explicit local grant adopts a previously projected Domain membership.
|
||||
if _, err = tx.ExecContext(ctx, `DELETE FROM campus_admin_membership_origins WHERE membership_uuid=`+s.sqlParam(1), membershipUUID); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Store) RemoveGroupMember(groupUUID, membershipUUID string) error {
|
||||
@@ -262,66 +341,73 @@ func (s *Store) RemoveGroupMember(groupUUID, membershipUUID string) error {
|
||||
}
|
||||
|
||||
func (s *Store) RemoveGroupMemberWithAuthority(groupUUID, membershipUUID string, ownerAuthority bool) error {
|
||||
tx, err := s.DB.Begin()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
if _, err = tx.Exec(`UPDATE groups SET updated_at_ms=updated_at_ms WHERE uuid=?`, groupUUID); err != nil {
|
||||
return err
|
||||
}
|
||||
var builtinKey string
|
||||
if err = tx.QueryRow(`SELECT builtin_key FROM groups WHERE uuid=?`, groupUUID).Scan(&builtinKey); err != nil {
|
||||
return err
|
||||
}
|
||||
if builtinKey == "campus_admin" {
|
||||
// Inherited-only entries can only be revoked at their source. Inherited
|
||||
// owners do not satisfy the guard for removing the last independent owner.
|
||||
var allowed int
|
||||
if err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM campus_admin_grants grant
|
||||
WHERE grant.group_uuid=? AND grant.membership_uuid=?
|
||||
AND substr(grant.source,1,21)!='campus_admin_inherit:'
|
||||
AND (? OR NOT EXISTS(SELECT 1 FROM group_members gm WHERE gm.group_uuid=grant.group_uuid
|
||||
AND gm.membership_uuid=grant.membership_uuid AND gm.member_role!='member'))
|
||||
AND (NOT EXISTS(SELECT 1 FROM campus_admin_grants mine WHERE mine.group_uuid=grant.group_uuid
|
||||
AND mine.membership_uuid=grant.membership_uuid AND mine.member_role='owner'
|
||||
return s.RemoveGroupMemberWithAuthorityContext(context.Background(), groupUUID, membershipUUID, ownerAuthority)
|
||||
}
|
||||
|
||||
func (s *Store) RemoveGroupMemberWithAuthorityContext(ctx context.Context, groupUUID, membershipUUID string, ownerAuthority bool) error {
|
||||
return s.groupWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
|
||||
if _, err := tx.ExecContext(ctx, `UPDATE groups SET updated_at_ms=updated_at_ms WHERE uuid=`+s.sqlParam(1), groupUUID); err != nil {
|
||||
return err
|
||||
}
|
||||
var builtinKey string
|
||||
if err := tx.QueryRowContext(ctx, `SELECT builtin_key FROM groups WHERE uuid=`+s.sqlParam(1), groupUUID).Scan(&builtinKey); err != nil {
|
||||
return err
|
||||
}
|
||||
if builtinKey == "campus_admin" {
|
||||
// Inherited-only entries can only be revoked at their source. Inherited
|
||||
// owners do not satisfy the guard for removing the last independent owner.
|
||||
var allowed bool
|
||||
if err := tx.QueryRowContext(ctx, fmt.Sprintf(`SELECT EXISTS(SELECT 1 FROM campus_admin_grants gr
|
||||
WHERE gr.group_uuid=%s AND gr.membership_uuid=%s
|
||||
AND substr(gr.source,1,21)!='campus_admin_inherit:'
|
||||
AND (%s OR NOT EXISTS(SELECT 1 FROM group_members gm WHERE gm.group_uuid=gr.group_uuid
|
||||
AND gm.membership_uuid=gr.membership_uuid AND gm.member_role!='member'))
|
||||
AND (NOT EXISTS(SELECT 1 FROM campus_admin_grants mine WHERE mine.group_uuid=gr.group_uuid
|
||||
AND mine.membership_uuid=gr.membership_uuid AND mine.member_role='owner'
|
||||
AND substr(mine.source,1,21)!='campus_admin_inherit:')
|
||||
OR EXISTS(SELECT 1 FROM campus_admin_grants other WHERE other.group_uuid=grant.group_uuid
|
||||
AND other.membership_uuid!=grant.membership_uuid AND other.member_role='owner'
|
||||
OR EXISTS(SELECT 1 FROM campus_admin_grants other
|
||||
JOIN groups og ON og.uuid=other.group_uuid
|
||||
JOIN domain_memberships om ON om.uuid=other.membership_uuid AND om.domain_uuid=og.domain_uuid
|
||||
WHERE other.group_uuid=gr.group_uuid
|
||||
AND other.membership_uuid!=gr.membership_uuid AND other.member_role='owner'
|
||||
AND substr(other.source,1,21)!='campus_admin_inherit:'))
|
||||
)`, groupUUID, membershipUUID, ownerAuthority).Scan(&allowed); err != nil {
|
||||
return err
|
||||
)`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), groupUUID, membershipUUID, ownerAuthority).Scan(&allowed); err != nil {
|
||||
return err
|
||||
}
|
||||
if !allowed {
|
||||
return namespaceValidationError("member removal requires a local grant, sufficient authority, and at least one remaining local owner; inherited grants must be revoked at their source")
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx, fmt.Sprintf(`DELETE FROM campus_admin_grants WHERE group_uuid=%s AND membership_uuid=%s AND substr(source,1,21)!='campus_admin_inherit:'`, s.sqlParam(1), s.sqlParam(2)), groupUUID, membershipUUID); err != nil {
|
||||
return err
|
||||
}
|
||||
return s.projectCampusAdminMembershipsContext(ctx, tx)
|
||||
}
|
||||
if allowed == 0 {
|
||||
return errors.New("member removal requires a local grant, sufficient authority, and at least one remaining local owner; inherited grants must be revoked at their source")
|
||||
}
|
||||
if _, err = tx.Exec(`DELETE FROM campus_admin_grants WHERE group_uuid=? AND membership_uuid=? AND substr(source,1,21)!='campus_admin_inherit:'`, groupUUID, membershipUUID); err != nil {
|
||||
return err
|
||||
}
|
||||
if err = projectCampusAdminMembershipsTx(tx); err != nil {
|
||||
return err
|
||||
}
|
||||
return tx.Commit()
|
||||
}
|
||||
// A single SQLite write serializes the check and deletion. A manager cannot
|
||||
// delete a member concurrently promoted to owner/manager by another request.
|
||||
result, err := tx.Exec(`DELETE FROM group_members WHERE group_uuid=? AND membership_uuid=?
|
||||
AND (? OR member_role='member')
|
||||
// A single SQLite write serializes the check and deletion. A manager cannot
|
||||
// delete a member concurrently promoted to owner/manager by another request.
|
||||
result, err := tx.ExecContext(ctx, fmt.Sprintf(`DELETE FROM group_members WHERE group_uuid=%s AND membership_uuid=%s
|
||||
AND (%s OR member_role='member')
|
||||
AND (member_role!='owner' OR EXISTS (
|
||||
SELECT 1 FROM group_members other WHERE other.group_uuid=? AND other.membership_uuid!=? AND other.member_role='owner'
|
||||
))`, groupUUID, membershipUUID, ownerAuthority, groupUUID, membershipUUID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if count, err := result.RowsAffected(); err != nil {
|
||||
return err
|
||||
} else if count == 0 {
|
||||
return errors.New("member removal requires sufficient authority and at least one remaining owner")
|
||||
}
|
||||
return tx.Commit()
|
||||
SELECT 1 FROM group_members other JOIN groups og ON og.uuid=other.group_uuid
|
||||
JOIN domain_memberships om ON om.uuid=other.membership_uuid AND om.domain_uuid=og.domain_uuid
|
||||
WHERE other.group_uuid=%s AND other.membership_uuid!=%s AND other.member_role='owner'
|
||||
))`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4), s.sqlParam(5)), groupUUID, membershipUUID, ownerAuthority, groupUUID, membershipUUID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if count, err := result.RowsAffected(); err != nil {
|
||||
return err
|
||||
} else if count == 0 {
|
||||
return namespaceValidationError("member removal requires sufficient authority and at least one remaining owner")
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Store) SetGroupPermission(groupUUID, scopePath, permission string) error {
|
||||
return s.SetGroupPermissionContext(context.Background(), groupUUID, scopePath, permission)
|
||||
}
|
||||
|
||||
func (s *Store) SetGroupPermissionContext(ctx context.Context, groupUUID, scopePath, permission string) error {
|
||||
permission, err := NormalizeGroupPermission(permission)
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -330,45 +416,67 @@ func (s *Store) SetGroupPermission(groupUUID, scopePath, permission string) erro
|
||||
if scopePath == "//" {
|
||||
scopePath = "/"
|
||||
}
|
||||
_, err = s.DB.Exec(`INSERT INTO group_permissions(uuid,group_uuid,scope_path,permission,created_at_ms) VALUES(?,?,?,?,?) ON CONFLICT(group_uuid,scope_path) DO UPDATE SET permission=excluded.permission`, uuid.NewString(), groupUUID, scopePath, permission, time.Now().UnixMilli())
|
||||
return err
|
||||
return s.groupWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
|
||||
result, err := tx.ExecContext(ctx, fmt.Sprintf(`INSERT INTO group_permissions(uuid,group_uuid,scope_path,permission,created_at_ms)
|
||||
SELECT %s,uuid,%s,%s,%s FROM groups WHERE uuid=%s
|
||||
ON CONFLICT(group_uuid,scope_path) DO UPDATE SET permission=excluded.permission`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3), s.sqlParam(4), s.sqlParam(5)), uuid.NewString(), scopePath, permission, time.Now().UnixMilli(), groupUUID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
count, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if count != 1 {
|
||||
return sql.ErrNoRows
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Store) ListGroupPermissions(groupUUID string) ([]GroupPermission, error) {
|
||||
rows, err := s.DB.Query(`SELECT uuid,group_uuid,scope_path,permission FROM group_permissions WHERE group_uuid=? ORDER BY scope_path`, groupUUID)
|
||||
return s.ListGroupPermissionsContext(context.Background(), groupUUID)
|
||||
}
|
||||
|
||||
func (s *Store) ListGroupPermissionsContext(ctx context.Context, groupUUID string) ([]GroupPermission, error) {
|
||||
rows, err := s.DB.QueryContext(ctx, `SELECT uuid,group_uuid,scope_path,permission FROM group_permissions WHERE group_uuid=`+s.sqlParam(1)+` ORDER BY scope_path`, groupUUID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return nil, s.sqlError("list group permissions", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var out []GroupPermission
|
||||
for rows.Next() {
|
||||
var item GroupPermission
|
||||
if err := rows.Scan(&item.UUID, &item.GroupUUID, &item.ScopePath, &item.Permission); err != nil {
|
||||
return nil, err
|
||||
return nil, s.sqlError("scan group permission", err)
|
||||
}
|
||||
out = append(out, item)
|
||||
}
|
||||
return out, rows.Err()
|
||||
return out, s.sqlError("list group permissions", rows.Err())
|
||||
}
|
||||
|
||||
func (s *Store) groupPermissionAllows(domainUUID, principalUUID, capability, targetPath string) (bool, error) {
|
||||
return groupPermissionAllowsFrom(s.DB, domainUUID, principalUUID, capability, targetPath)
|
||||
return s.groupPermissionAllowsContext(context.Background(), s.DB, domainUUID, principalUUID, capability, targetPath)
|
||||
}
|
||||
|
||||
func groupPermissionAllowsFrom(q pathQueryer, domainUUID, principalUUID, capability, targetPath string) (bool, error) {
|
||||
rows, err := q.Query(`SELECT gp.scope_path,gp.permission FROM group_permissions gp JOIN groups g ON g.uuid=gp.group_uuid AND g.domain_uuid=? AND g.state='active' JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.principal_uuid=? AND m.state='active' JOIN principals p ON p.uuid=m.principal_uuid AND (p.state='active' OR (p.state='readonly' AND ?='read'))`, domainUUID, principalUUID, capability)
|
||||
type groupPermissionQueryer interface {
|
||||
QueryContext(context.Context, string, ...any) (*sql.Rows, error)
|
||||
}
|
||||
|
||||
func (s *Store) groupPermissionAllowsContext(ctx context.Context, q groupPermissionQueryer, domainUUID, principalUUID, capability, targetPath string) (bool, error) {
|
||||
rows, err := q.QueryContext(ctx, fmt.Sprintf(`SELECT gp.scope_path,gp.permission FROM group_permissions gp JOIN groups g ON g.uuid=gp.group_uuid AND g.domain_uuid=%s AND g.state='active' JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid AND m.principal_uuid=%s AND m.state='active' JOIN principals p ON p.uuid=m.principal_uuid AND (p.state='active' OR (p.state='readonly' AND %s='read'))`, s.sqlParam(1), s.sqlParam(2), s.sqlParam(3)), domainUUID, principalUUID, capability)
|
||||
if err != nil {
|
||||
return false, err
|
||||
return false, s.sqlError("group permission evaluation", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var scope, permission string
|
||||
if err := rows.Scan(&scope, &permission); err != nil {
|
||||
return false, err
|
||||
return false, s.sqlError("scan group permission evaluation", err)
|
||||
}
|
||||
if schutzaria.GroupPermissionAllows(scope, permission, capability, targetPath) {
|
||||
return true, nil
|
||||
}
|
||||
}
|
||||
return false, rows.Err()
|
||||
return false, s.sqlError("group permission evaluation", rows.Err())
|
||||
}
|
||||
Reference in new issue
Block a user