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.
348 lines
16 KiB
Go
348 lines
16 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
ErrGovernanceConflict = errors.New("city.governance.conflict")
|
|
ErrGovernanceInvalid = errors.New("city.governance.invalid")
|
|
ErrGovernanceCeiling = errors.New("city.governance.ceiling_error")
|
|
ErrGovernanceConfirm = errors.New("city.governance.confirm_error")
|
|
)
|
|
|
|
type LocalityPolicy struct {
|
|
Kind string `json:"kind"`
|
|
UUID string `json:"uuid"`
|
|
Policy string `json:"policy"`
|
|
}
|
|
|
|
type LocalityOwner struct {
|
|
MembershipUUID string `json:"membership_uuid"`
|
|
Username string `json:"username"`
|
|
DisplayName string `json:"display_name"`
|
|
Active bool `json:"active"`
|
|
}
|
|
|
|
type CityGovernance struct {
|
|
PublicationVersion int64 `json:"publication_version"`
|
|
Kind string `json:"kind"`
|
|
UUID string `json:"uuid"`
|
|
Epoch int64 `json:"epoch"`
|
|
TopologyVersion int64 `json:"topology_version"`
|
|
Policy string `json:"policy"`
|
|
Chain []LocalityPolicy `json:"chain"`
|
|
Owners []LocalityOwner `json:"owners"`
|
|
CanAppoint bool `json:"can_appoint"`
|
|
SuperiorAllowsPublic bool `json:"superior_allows_public"`
|
|
DraftEffectivePublic bool `json:"draft_effective_public"`
|
|
PublicationEnabled bool `json:"publication_enabled"` // This node's separately approved manifest only.
|
|
ImpactComplete bool `json:"impact_complete"` // This endpoint does not enumerate Page impact; use /publication.
|
|
}
|
|
|
|
type CityGovernanceChange struct {
|
|
Epoch int64 `json:"epoch"`
|
|
TopologyVersion int64 `json:"topology_version"`
|
|
Policy *string `json:"policy,omitempty"`
|
|
Owners *[]string `json:"owners,omitempty"`
|
|
ConfirmRelaxation bool `json:"confirm_relaxation"`
|
|
}
|
|
|
|
func (s *Store) ensureCityGovernanceSchema() error {
|
|
for _, query := range []string{
|
|
`CREATE TABLE IF NOT EXISTS city_governance_epochs(domain_uuid TEXT PRIMARY KEY,version INTEGER NOT NULL DEFAULT 0)`,
|
|
`CREATE TABLE IF NOT EXISTS locality_publication_policies(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL CHECK(node_kind IN ('domain','quartier','street','spot')),node_uuid TEXT NOT NULL,policy TEXT NOT NULL CHECK(policy IN ('inherit','public','authenticated_acl')),actor_uuid TEXT NOT NULL,updated_at_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid))`,
|
|
`CREATE TABLE IF NOT EXISTS city_owner_bindings(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL CHECK(node_kind IN ('quartier','spot')),node_uuid TEXT NOT NULL,membership_uuid TEXT NOT NULL,actor_uuid TEXT NOT NULL,created_at_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,node_kind,node_uuid,membership_uuid))`,
|
|
`CREATE INDEX IF NOT EXISTS idx_city_owner_member ON city_owner_bindings(domain_uuid,membership_uuid,node_kind,node_uuid)`,
|
|
`CREATE TABLE IF NOT EXISTS city_governance_events(id INTEGER PRIMARY KEY AUTOINCREMENT,domain_uuid TEXT NOT NULL,epoch INTEGER NOT NULL,actor_uuid TEXT NOT NULL,node_kind TEXT NOT NULL,node_uuid TEXT NOT NULL,before_json TEXT NOT NULL,after_json TEXT NOT NULL,created_at_ms INTEGER NOT NULL)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_city_governance_events ON city_governance_events(domain_uuid,epoch)`,
|
|
} {
|
|
if _, err := s.DB.Exec(query); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return s.ensurePublicationSchema()
|
|
}
|
|
|
|
// EvaluateLocalityPublication combines ceilings with intent. A public Domain
|
|
// merely allows publication: it never publishes its root or arbitrary Pages.
|
|
func EvaluateLocalityPublication(chain []LocalityPolicy) (allows, published bool) {
|
|
allows = true
|
|
for i, p := range chain {
|
|
if i == 0 && p.Policy == "inherit" {
|
|
return false, false
|
|
}
|
|
switch p.Policy {
|
|
case "authenticated_acl":
|
|
allows = false
|
|
case "public":
|
|
if i > 0 {
|
|
published = true
|
|
}
|
|
case "inherit":
|
|
default:
|
|
return false, false
|
|
}
|
|
}
|
|
return allows, allows && published
|
|
}
|
|
|
|
// All authority, parentage and policy reads use this one snapshot. Mutation
|
|
// callers acquire SQLite's write reservation before entering this function.
|
|
func governanceSnapshot(ctx context.Context, tx *sql.Tx, domain, actor, kind, id string) (g CityGovernance, err error) {
|
|
g = CityGovernance{Kind: kind, UUID: id, Owners: []LocalityOwner{}}
|
|
var membership string
|
|
err = tx.QueryRowContext(ctx, `SELECT m.uuid FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' JOIN domains d ON d.uuid=m.domain_uuid AND d.enabled=1 WHERE m.domain_uuid=? AND m.principal_uuid=? AND m.state='active'`, domain, actor).Scan(&membership)
|
|
if err == sql.ErrNoRows {
|
|
return g, ErrAccessDenied
|
|
}
|
|
if err != nil {
|
|
return g, err
|
|
}
|
|
var admin bool
|
|
err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid WHERE g.domain_uuid=? AND g.builtin_key='domain_admin' AND g.state='active' AND gm.membership_uuid=? AND gm.member_role IN ('owner','manager'))`, domain, membership).Scan(&admin)
|
|
if err != nil {
|
|
return g, err
|
|
}
|
|
var q, street, parent, nodePath, streetPath, quartierPath string
|
|
switch kind {
|
|
case "domain":
|
|
if id != domain {
|
|
return g, sql.ErrNoRows
|
|
}
|
|
case "quartier", "street":
|
|
err = tx.QueryRowContext(ctx, `SELECT COALESCE(parent_uuid,''),path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND kind=? AND state!='archived'`, id, domain, kind).Scan(&parent, &nodePath)
|
|
if kind == "quartier" {
|
|
q = id
|
|
if parent != "" {
|
|
return g, ErrGovernanceInvalid
|
|
}
|
|
} else {
|
|
q = parent
|
|
street = id
|
|
streetPath = nodePath
|
|
}
|
|
case "spot":
|
|
err = tx.QueryRowContext(ctx, `SELECT st.uuid,st.parent_uuid,s.path_prefix,st.path_prefix FROM spots s JOIN street_spots ss ON ss.spot_uuid=s.uuid JOIN zones st ON st.uuid=ss.street_uuid AND st.domain_uuid=s.domain_uuid AND st.kind='street' AND st.state!='archived' WHERE s.uuid=? AND s.domain_uuid=? AND s.state!='archived'`, id, domain).Scan(&street, &q, &nodePath, &streetPath)
|
|
default:
|
|
return g, ErrGovernanceInvalid
|
|
}
|
|
if err != nil {
|
|
return g, err
|
|
}
|
|
if q != "" {
|
|
if err = tx.QueryRowContext(ctx, `SELECT path_prefix FROM zones WHERE uuid=? AND domain_uuid=? AND kind='quartier' AND state!='archived' AND COALESCE(parent_uuid,'')=''`, q, domain).Scan(&quartierPath); err != nil {
|
|
return g, err
|
|
}
|
|
}
|
|
if kind != "domain" && (q == "" || quartierPath == "" || nodePath == "" || (street != "" && (streetPath == "" || !cityPathContains(quartierPath, streetPath))) || (kind == "spot" && !cityPathContains(streetPath, nodePath))) {
|
|
return g, ErrGovernanceInvalid
|
|
}
|
|
var qOwner, own bool
|
|
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM city_owner_bindings WHERE domain_uuid=? AND node_kind='quartier' AND node_uuid=? AND membership_uuid=?), EXISTS(SELECT 1 FROM city_owner_bindings WHERE domain_uuid=? AND node_kind=? AND node_uuid=? AND membership_uuid=?)`, domain, q, membership, domain, kind, id, membership).Scan(&qOwner, &own); err != nil {
|
|
return g, err
|
|
}
|
|
if !admin && !qOwner && !(kind == "spot" && own) {
|
|
return g, ErrAccessDenied
|
|
}
|
|
g.CanAppoint = (kind == "quartier" && admin) || (kind == "spot" && (admin || qOwner))
|
|
g.Chain = []LocalityPolicy{{Kind: "domain", UUID: domain, Policy: "authenticated_acl"}}
|
|
if q != "" {
|
|
g.Chain = append(g.Chain, LocalityPolicy{Kind: "quartier", UUID: q, Policy: "inherit"})
|
|
}
|
|
if street != "" {
|
|
g.Chain = append(g.Chain, LocalityPolicy{Kind: "street", UUID: street, Policy: "inherit"})
|
|
}
|
|
if kind == "spot" {
|
|
g.Chain = append(g.Chain, LocalityPolicy{Kind: "spot", UUID: id, Policy: "inherit"})
|
|
}
|
|
for i := range g.Chain {
|
|
p := &g.Chain[i]
|
|
err = tx.QueryRowContext(ctx, `SELECT policy FROM locality_publication_policies WHERE domain_uuid=? AND node_kind=? AND node_uuid=?`, domain, p.Kind, p.UUID).Scan(&p.Policy)
|
|
if err != nil && err != sql.ErrNoRows {
|
|
return g, err
|
|
}
|
|
if p.Policy != "public" && p.Policy != "authenticated_acl" && p.Policy != "inherit" || p.Kind == "domain" && p.Policy == "inherit" {
|
|
return g, ErrGovernanceInvalid
|
|
}
|
|
}
|
|
g.Policy = g.Chain[len(g.Chain)-1].Policy
|
|
g.SuperiorAllowsPublic, _ = EvaluateLocalityPublication(g.Chain[:len(g.Chain)-1])
|
|
_, g.DraftEffectivePublic = EvaluateLocalityPublication(g.Chain)
|
|
if err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT version FROM city_governance_epochs WHERE domain_uuid=?),0),COALESCE((SELECT version FROM domain_topology_versions WHERE domain_uuid=?),1)`, domain, domain).Scan(&g.Epoch, &g.TopologyVersion); err != nil {
|
|
return g, err
|
|
}
|
|
if err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT version FROM locality_publication_versions WHERE domain_uuid=? AND node_kind=? AND node_uuid=?),0)`, domain, kind, id).Scan(&g.PublicationVersion); err != nil {
|
|
return g, err
|
|
}
|
|
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM locality_publication_manifests m WHERE domain_uuid=? AND node_kind=? AND node_uuid=? AND epoch=? AND topology_version=? AND EXISTS(SELECT 1 FROM locality_publication_entries e WHERE e.domain_uuid=m.domain_uuid AND e.node_kind=m.node_kind AND e.node_uuid=m.node_uuid))`, domain, kind, id, g.Epoch, g.TopologyVersion).Scan(&g.PublicationEnabled); err != nil {
|
|
return g, err
|
|
}
|
|
rows, err := tx.QueryContext(ctx, `SELECT m.uuid,COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' LIMIT 1),p.uuid),p.display_name,(p.state='active' AND m.state='active') FROM city_owner_bindings b JOIN domain_memberships m ON m.uuid=b.membership_uuid AND m.domain_uuid=b.domain_uuid JOIN principals p ON p.uuid=m.principal_uuid WHERE b.domain_uuid=? AND b.node_kind=? AND b.node_uuid=? ORDER BY m.uuid LIMIT 33`, domain, kind, id)
|
|
if err != nil {
|
|
return g, err
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var o LocalityOwner
|
|
if err = rows.Scan(&o.MembershipUUID, &o.Username, &o.DisplayName, &o.Active); err != nil {
|
|
return g, err
|
|
}
|
|
g.Owners = append(g.Owners, o)
|
|
}
|
|
if len(g.Owners) > 32 {
|
|
return g, ErrGovernanceInvalid
|
|
}
|
|
return g, rows.Err()
|
|
}
|
|
|
|
func (s *Store) CityGovernance(ctx context.Context, domain, actor, kind, id string) (CityGovernance, error) {
|
|
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
|
|
defer cancel()
|
|
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
|
|
if err != nil {
|
|
return CityGovernance{}, err
|
|
}
|
|
defer tx.Rollback()
|
|
return governanceSnapshot(ctx, tx, domain, actor, kind, id)
|
|
}
|
|
|
|
// Candidate lookup exposes only active local display identities, never emails,
|
|
// credentials or foreign memberships. It is scoped to appointment authority.
|
|
func (s *Store) CityGovernanceMembers(ctx context.Context, domain, actor, kind, id, search string) ([]LocalityOwner, error) {
|
|
if len(search) > 80 {
|
|
return nil, ErrGovernanceInvalid
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
|
|
defer cancel()
|
|
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer tx.Rollback()
|
|
g, err := governanceSnapshot(ctx, tx, domain, actor, kind, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !g.CanAppoint {
|
|
return nil, ErrAccessDenied
|
|
}
|
|
rows, err := tx.QueryContext(ctx, `SELECT m.uuid,COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' LIMIT 1),p.uuid) username,p.display_name FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' WHERE m.domain_uuid=? AND m.state='active' AND (?='' OR instr(lower(p.display_name),?)>0 OR EXISTS(SELECT 1 FROM principal_identities i WHERE i.principal_uuid=p.uuid AND i.provider_type='password' AND instr(lower(i.subject),?)>0)) ORDER BY p.display_name,m.uuid LIMIT 30`, domain, search, strings.ToLower(search), strings.ToLower(search))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
result := []LocalityOwner{}
|
|
for rows.Next() {
|
|
o := LocalityOwner{Active: true}
|
|
if err = rows.Scan(&o.MembershipUUID, &o.Username, &o.DisplayName); err != nil {
|
|
return nil, err
|
|
}
|
|
result = append(result, o)
|
|
}
|
|
return result, rows.Err()
|
|
}
|
|
|
|
func (s *Store) ChangeCityGovernance(ctx context.Context, domain, actor, kind, id string, change CityGovernanceChange, preview bool) (CityGovernance, error) {
|
|
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
|
|
defer cancel()
|
|
tx, err := s.DB.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return CityGovernance{}, err
|
|
}
|
|
defer tx.Rollback()
|
|
// Reserve the writer before authority reads: revocation cannot commit
|
|
// between validation and mutation. Preview rolls back this short reservation.
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs(domain_uuid,version) VALUES(?,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=version`, domain); err != nil {
|
|
return CityGovernance{}, err
|
|
}
|
|
g, err := governanceSnapshot(ctx, tx, domain, actor, kind, id)
|
|
if err != nil {
|
|
return g, err
|
|
}
|
|
if change.Epoch != g.Epoch || change.TopologyVersion != g.TopologyVersion {
|
|
return g, ErrGovernanceConflict
|
|
}
|
|
before, _ := json.Marshal(g)
|
|
if change.Policy == nil && change.Owners == nil {
|
|
return g, ErrGovernanceInvalid
|
|
}
|
|
if change.Policy != nil {
|
|
p := *change.Policy
|
|
if p != "inherit" && p != "public" && p != "authenticated_acl" || (kind == "domain" && p == "inherit") {
|
|
return g, ErrGovernanceInvalid
|
|
}
|
|
if p == "public" && !g.SuperiorAllowsPublic {
|
|
return g, ErrGovernanceCeiling
|
|
}
|
|
if p != g.Policy && (p == "public" || g.Policy == "authenticated_acl") && !change.ConfirmRelaxation && !preview {
|
|
return g, ErrGovernanceConfirm
|
|
}
|
|
g.Policy = p
|
|
g.Chain[len(g.Chain)-1].Policy = p
|
|
_, g.DraftEffectivePublic = EvaluateLocalityPublication(g.Chain)
|
|
}
|
|
if change.Owners != nil {
|
|
if !g.CanAppoint {
|
|
return g, ErrAccessDenied
|
|
}
|
|
if len(*change.Owners) > 32 {
|
|
return g, ErrGovernanceInvalid
|
|
}
|
|
seen := map[string]bool{}
|
|
proposed := []LocalityOwner{}
|
|
for _, member := range *change.Owners {
|
|
if seen[member] {
|
|
return g, ErrGovernanceInvalid
|
|
}
|
|
seen[member] = true
|
|
o := LocalityOwner{MembershipUUID: member, Active: true}
|
|
err = tx.QueryRowContext(ctx, `SELECT COALESCE((SELECT subject FROM principal_identities WHERE principal_uuid=p.uuid AND provider_type='password' LIMIT 1),p.uuid),p.display_name FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state='active' WHERE m.uuid=? AND m.domain_uuid=? AND m.state='active'`, member, domain).Scan(&o.Username, &o.DisplayName)
|
|
if err == sql.ErrNoRows {
|
|
return g, ErrGovernanceInvalid
|
|
}
|
|
if err != nil {
|
|
return g, err
|
|
}
|
|
proposed = append(proposed, o)
|
|
}
|
|
g.Owners = proposed
|
|
}
|
|
if preview {
|
|
return g, nil
|
|
}
|
|
now := time.Now().UnixMilli()
|
|
if change.Policy != nil {
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_publication_policies(domain_uuid,node_kind,node_uuid,policy,actor_uuid,updated_at_ms) VALUES(?,?,?,?,?,?) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET policy=excluded.policy,actor_uuid=excluded.actor_uuid,updated_at_ms=excluded.updated_at_ms`, domain, kind, id, g.Policy, actor, now); err != nil {
|
|
return g, err
|
|
}
|
|
}
|
|
if change.Owners != nil {
|
|
if _, err = tx.ExecContext(ctx, `DELETE FROM city_owner_bindings WHERE domain_uuid=? AND node_kind=? AND node_uuid=?`, domain, kind, id); err != nil {
|
|
return g, err
|
|
}
|
|
for _, member := range *change.Owners {
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO city_owner_bindings VALUES(?,?,?,?,?,?)`, domain, kind, id, member, actor, now); err != nil {
|
|
return g, err
|
|
}
|
|
}
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `UPDATE city_governance_epochs SET version=version+1 WHERE domain_uuid=?`, domain); err != nil {
|
|
return g, err
|
|
}
|
|
g, err = governanceSnapshot(ctx, tx, domain, actor, kind, id)
|
|
if err != nil {
|
|
return g, err
|
|
}
|
|
after, _ := json.Marshal(g)
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_events(domain_uuid,epoch,actor_uuid,node_kind,node_uuid,before_json,after_json,created_at_ms) VALUES(?,?,?,?,?,?,?,?)`, domain, g.Epoch, actor, kind, id, string(before), string(after), now); err != nil {
|
|
return g, err
|
|
}
|
|
return g, tx.Commit()
|
|
}
|