Files
pages/internal/store/automatic_publication.go
T
2026-11-15 05:47:14 +09:00

333 lines
11 KiB
Go

package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"time"
)
type autoPublicationRule struct {
Kind, ID, Mode, Scope, Actor string
Version int64
}
func autoContains(scope, path string) bool { return scope == path || cityPathContains(scope, path) }
type AutoPublication struct {
Mode string `json:"mode"`
Version int64 `json:"version"`
Epoch int64 `json:"epoch"`
TopologyVersion int64 `json:"topology_version"`
CanAutomatic bool `json:"can_automatic"`
Active bool `json:"active"`
PreviewComplete bool `json:"preview_complete"`
Impact LocalityPublication `json:"impact"`
}
type AutoPublicationChange struct {
Mode string `json:"mode"`
Version int64 `json:"version"`
Epoch int64 `json:"epoch"`
TopologyVersion int64 `json:"topology_version"`
Confirm bool `json:"confirm"`
ImpactToken string `json:"impact_token"`
}
func (s *Store) autoScope(ctx context.Context, tx *sql.Tx, domain, kind, id string) (string, error) {
if kind == "domain" {
if id != domain {
return "", ErrGovernanceInvalid
}
return "/", nil
}
table := "zones"
if kind == "spot" {
table = "spots"
}
var scope string
err := tx.QueryRowContext(ctx, `SELECT path_prefix FROM `+table+` WHERE domain_uuid=`+s.sqlParam(1)+` AND uuid=`+s.sqlParam(2)+` AND state!='archived'`, domain, id).Scan(&scope)
return scope, err
}
func (s *Store) autoRules(ctx context.Context, tx *sql.Tx, domain string) ([]autoPublicationRule, error) {
rows, err := tx.QueryContext(ctx, `SELECT node_kind,node_uuid,mode,scope_path,actor_uuid,version FROM locality_auto_publication WHERE domain_uuid=`+s.sqlParam(1)+` ORDER BY node_kind,node_uuid LIMIT 129`, domain)
if err != nil {
return nil, err
}
defer rows.Close()
out := []autoPublicationRule{}
for rows.Next() {
var p autoPublicationRule
if err = rows.Scan(&p.Kind, &p.ID, &p.Mode, &p.Scope, &p.Actor, &p.Version); err != nil {
return nil, err
}
out = append(out, p)
}
if len(out) > 128 {
return nil, ErrNavigationBudget
}
return out, rows.Err()
}
func (s *Store) requireManualPublication(ctx context.Context, tx *sql.Tx, domain, actor, kind, id string) error {
scope, err := s.autoScope(ctx, tx, domain, kind, id)
if err != nil {
return err
}
_, err = tx.ExecContext(ctx, `INSERT INTO locality_auto_publication VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,'required',`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,1) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET mode='required',scope_path=excluded.scope_path,actor_uuid=excluded.actor_uuid,version=locality_auto_publication.version+1`, domain, kind, id, scope, actor)
return err
}
func (s *Store) AutoPublication(ctx context.Context, domain, actor, kind, id string, change *AutoPublicationChange) (_ AutoPublication, resultErr error) {
defer func() { resultErr = s.sqlError("AutoPublication", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
state := AutoPublication{Mode: "inherit"}
options := s.policyReadOptions()
if change != nil {
options = &sql.TxOptions{Isolation: sql.LevelReadCommitted}
}
tx, err := s.DB.BeginTx(ctx, options)
if err != nil {
return state, err
}
defer tx.Rollback()
if change != nil {
if err = s.lockPolicyWrite(ctx, tx); err != nil {
return state, err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs VALUES(`+s.sqlParam(1)+`,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=city_governance_epochs.version`, domain); err != nil {
return state, err
}
}
g, err := s.governanceSnapshot(ctx, tx, domain, actor, kind, id)
if err != nil {
return state, err
}
scope, err := s.autoScope(ctx, tx, domain, kind, id)
if err != nil {
return state, err
}
rules, err := s.autoRules(ctx, tx, domain)
if err != nil {
return state, err
}
state.Epoch, state.TopologyVersion = g.Epoch, g.TopologyVersion
state.CanAutomatic = (kind == "street" || kind == "spot") && g.DraftEffectivePublic && PublicSemanticPath(scope)
blockedScopes := []string{}
for _, rule := range rules {
if rule.Kind == kind && rule.ID == id {
state.Mode, state.Version = rule.Mode, rule.Version
state.Active = rule.Mode == "automatic" && rule.Scope == scope
if state.Active && rule.Actor != actor {
_, e := s.governanceSnapshot(ctx, tx, domain, rule.Actor, kind, id)
if errors.Is(e, sql.ErrNoRows) || errors.Is(e, ErrAccessDenied) {
state.Active = false
} else if e != nil {
return state, e
}
}
}
if rule.Mode == "required" && !(rule.Kind == kind && rule.ID == id) {
parent, e := s.autoScope(ctx, tx, domain, rule.Kind, rule.ID)
if e != nil && !errors.Is(e, sql.ErrNoRows) {
return state, e
}
if e == nil {
blockedScopes = append(blockedScopes, parent)
if autoContains(parent, scope) {
state.CanAutomatic = false
}
}
}
}
state.Active = state.Active && state.CanAutomatic
if change != nil && (change.Epoch != state.Epoch || change.TopologyVersion != state.TopologyVersion || change.Version != state.Version) {
return state, ErrGovernanceConflict
}
if change == nil || change.Mode != "required" {
state.Impact, err = s.publicationImpact(ctx, tx, domain, actor, kind, id, g)
if err != nil {
if change == nil && errors.Is(err, ErrPublicationImpact) {
state.CanAutomatic = false
return state, nil
}
return state, err
}
state.PreviewComplete = true
visible := []PublicationEntry{}
for _, entry := range state.Impact.Entries {
blocked := false
for _, scope := range blockedScopes {
if autoContains(scope, entry.Path) {
blocked = true
break
}
}
if blocked {
state.Impact.Excluded = append(state.Impact.Excluded, entry.Path)
} else {
visible = append(visible, entry)
}
}
state.Impact.Entries = visible
input, _ := json.Marshal(struct {
Impact string
Rules []autoPublicationRule
}{state.Impact.ImpactToken, rules})
hash := sha256.Sum256(input)
state.Impact.ImpactToken = hex.EncodeToString(hash[:])
}
if change == nil {
return state, nil
}
if change.Mode != "automatic" && change.Mode != "required" && change.Mode != "inherit" {
return state, ErrGovernanceInvalid
}
if change.Mode == "automatic" {
if !state.CanAutomatic {
return state, ErrGovernanceCeiling
}
if !change.Confirm || change.ImpactToken == "" || change.ImpactToken != state.Impact.ImpactToken {
return state, ErrPublicationImpact
}
if err = s.installPublicationGuards(ctx, tx); err != nil {
return state, err
}
}
if change.Mode == "inherit" && (!change.Confirm || change.ImpactToken == "" || change.ImpactToken != state.Impact.ImpactToken) {
return state, ErrPublicationImpact
}
before, _ := json.Marshal(state)
_, err = tx.ExecContext(ctx, `INSERT INTO locality_auto_publication VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,1) ON CONFLICT(domain_uuid,node_kind,node_uuid) DO UPDATE SET mode=excluded.mode,scope_path=excluded.scope_path,actor_uuid=excluded.actor_uuid,version=locality_auto_publication.version+1`, domain, kind, id, change.Mode, scope, actor)
if err != nil {
return state, err
}
state.Mode = change.Mode
state.Version++
state.Active = change.Mode == "automatic"
state.Impact.ImpactToken = ""
after, _ := json.Marshal(state)
_, 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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`)`, domain, g.Epoch, actor, kind, id, string(before), string(after), time.Now().UnixMilli())
if err != nil {
return state, err
}
return state, tx.Commit()
}
// Evaluate live heads, audience, publisher authority and literal Path boundaries
// in one read transaction. No request mutates approval manifests or source content.
func (s *Store) automaticPublicPages(ctx context.Context, domain, onlyPath string) ([]PublishedNavigationPage, error) {
tx, err := s.DB.BeginTx(ctx, s.policyReadOptions())
if err != nil {
return nil, err
}
defer tx.Rollback()
return s.automaticPublicPagesTx(ctx, tx, domain, onlyPath)
}
func (s *Store) automaticPublicPagesTx(ctx context.Context, tx *sql.Tx, domain, onlyPath string) ([]PublishedNavigationPage, error) {
var err error
var live bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domains d JOIN campuses c ON c.uuid=d.campus_uuid JOIN config cfg ON cfg.domain_uuid=d.uuid AND cfg.key='authorization_mode' AND cfg.value='enforcing' WHERE d.uuid=`+s.sqlParam(1)+` AND d.enabled=1 AND c.enabled=1)`, domain).Scan(&live); err != nil {
return nil, err
}
if !live {
return nil, nil
}
rules, err := s.autoRules(ctx, tx, domain)
if err != nil {
return nil, err
}
blocked := []string{}
for _, rule := range rules {
if rule.Mode == "required" {
scope, e := s.autoScope(ctx, tx, domain, rule.Kind, rule.ID)
if errors.Is(e, sql.ErrNoRows) {
continue
}
if e != nil {
return nil, e
}
blocked = append(blocked, scope)
}
}
deny := func(p string) bool {
for _, scope := range blocked {
if autoContains(scope, p) {
return true
}
}
return false
}
if onlyPath != "" && deny(onlyPath) {
return nil, nil
}
entries := map[string]PublicationEntry{}
for _, rule := range rules {
if rule.Mode != "automatic" || (rule.Kind != "street" && rule.Kind != "spot") {
continue
}
if onlyPath != "" && !autoContains(rule.Scope, onlyPath) {
continue
}
g, e := s.governanceSnapshot(ctx, tx, domain, rule.Actor, rule.Kind, rule.ID)
if errors.Is(e, sql.ErrNoRows) || errors.Is(e, ErrAccessDenied) || errors.Is(e, ErrGovernanceInvalid) {
continue
}
if e != nil {
return nil, e
}
current, e := s.autoScope(ctx, tx, domain, rule.Kind, rule.ID)
if e != nil {
return nil, e
}
if current != rule.Scope || !g.DraftEffectivePublic || deny(current) {
continue
}
p, e := s.publicationImpactBounded(ctx, tx, domain, rule.Actor, rule.Kind, rule.ID, g, MaxNavigationEntries, onlyPath)
if errors.Is(e, ErrAccessDenied) {
continue
}
if e != nil {
return nil, e
}
for _, entry := range p.Entries {
if !deny(entry.Path) {
entries[entry.Revision] = entry
}
if len(entries) > MaxNavigationEntries {
return nil, ErrNavigationBudget
}
}
}
if len(entries) == 0 {
return nil, nil
}
args := []any{}
for id := range entries {
args = append(args, id)
}
rows, err := tx.QueryContext(ctx, `SELECT uuid,object_uuid,document_hash,COALESCE(NULLIF(lang,''),'und'),COALESCE(NULLIF(content_type,''),'text/html; charset=utf-8'),COALESCE(filename,''),created_at_ms FROM revisions WHERE uuid IN (`+s.sqlValues(len(args))+`) ORDER BY created_at_ms DESC,uuid`, args...)
if err != nil {
return nil, err
}
defer rows.Close()
out := []PublishedNavigationPage{}
size := 0
for rows.Next() {
var p PublishedNavigationPage
v := &p.Revision
if err = rows.Scan(&v.UUID, &v.ObjectUUID, &v.DocumentHash, &v.Language, &v.ContentType, &v.Filename, &v.CreatedAtMS); err != nil {
return nil, err
}
p.Path = entries[v.UUID].Path
size += len(p.Path) + len(v.Filename) + len(v.ContentType)
if size > 4<<20 {
return nil, ErrNavigationBudget
}
out = append(out, p)
}
return out, rows.Err()
}