187 lines
7.5 KiB
Go
187 lines
7.5 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"time"
|
|
)
|
|
|
|
var ErrManifestCapability = namespaceValidationError("all approved Campus instances must announce manifest v2 support before saving entry settings")
|
|
|
|
func (s *Store) CampusLegacyManifestPeers() (_ map[string]int, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("CampusLegacyManifestPeers", resultErr) }()
|
|
rows, err := s.DB.Query(`SELECT i.campus_uuid,count(*) FROM federation_instances i LEFT JOIN federation_instance_capabilities c ON c.instance_uuid=i.uuid WHERE i.status='approved' AND COALESCE(c.manifest_version,1)<2 GROUP BY i.campus_uuid`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := map[string]int{}
|
|
for rows.Next() {
|
|
var id string
|
|
var n int
|
|
if err = rows.Scan(&id, &n); err != nil {
|
|
return nil, err
|
|
}
|
|
out[id] = n
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// A deliberately narrow allowlist; never federate arbitrary config or secrets.
|
|
type DomainEntrySettings struct {
|
|
Layout string `json:"layout"`
|
|
DiaryEnabled bool `json:"diary_enabled"`
|
|
DiaryPrefix string `json:"diary_prefix"`
|
|
BlogEnabled bool `json:"blog_enabled"`
|
|
BlogPrefix string `json:"blog_prefix"`
|
|
}
|
|
|
|
func (e DomainEntrySettings) valid() bool {
|
|
switch e.Layout {
|
|
case "classic", "search", "directory", "diary", "blog":
|
|
default:
|
|
return false
|
|
}
|
|
if e.Layout == "diary" && !e.DiaryEnabled || e.Layout == "blog" && !e.BlogEnabled {
|
|
return false
|
|
}
|
|
for _, prefix := range []string{e.DiaryPrefix, e.BlogPrefix} {
|
|
if _, err := PeriodicalPath(prefix, "2000-01-01", ""); err != nil {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (s *Store) ListDomainEntrySettings() (_ map[string]DomainEntrySettings, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("ListDomainEntrySettings", resultErr) }()
|
|
rows, err := s.DB.Query(`SELECT domain_uuid,settings_json FROM domain_entry_settings`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
out := map[string]DomainEntrySettings{}
|
|
for rows.Next() {
|
|
var id, raw string
|
|
if err = rows.Scan(&id, &raw); err != nil {
|
|
return nil, err
|
|
}
|
|
var e DomainEntrySettings
|
|
if err = json.Unmarshal([]byte(raw), &e); err != nil {
|
|
return nil, err
|
|
}
|
|
out[id] = e
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func (s *Store) DomainEntryControlled(domain string) (_ bool, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("DomainEntryControlled", resultErr) }()
|
|
var exists bool
|
|
err := s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM domain_entry_settings WHERE domain_uuid=`+s.sqlParam(1)+`)`, domain).Scan(&exists)
|
|
return exists, err
|
|
}
|
|
|
|
// Populate the dialog with effective local values before control is first enabled.
|
|
// One metadata query avoids issuing five config reads for every Domain row.
|
|
func (s *Store) DomainEntryOptions() (_ map[string]DomainEntrySettings, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("DomainEntryOptions", resultErr) }()
|
|
entries, err := s.ListDomainEntrySettings()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rows, err := s.DB.Query(`SELECT d.uuid,COALESCE(c.value,'classic'),COALESCE(ds.enabled,0),COALESCE(dp.prefix,'/diary'),COALESCE(bs.enabled,0),COALESCE(bp.prefix,'/blog') FROM domains d LEFT JOIN config c ON c.domain_uuid=d.uuid AND c.key='home_layout' LEFT JOIN periodical_settings ds ON ds.domain_uuid=d.uuid AND ds.kind='diary' LEFT JOIN periodical_settings bs ON bs.domain_uuid=d.uuid AND bs.kind='blog' LEFT JOIN periodical_prefixes dp ON dp.domain_uuid=d.uuid AND dp.kind='diary' LEFT JOIN periodical_prefixes bp ON bp.domain_uuid=d.uuid AND bp.kind='blog'`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var id string
|
|
var e DomainEntrySettings
|
|
if err = rows.Scan(&id, &e.Layout, &e.DiaryEnabled, &e.DiaryPrefix, &e.BlogEnabled, &e.BlogPrefix); err != nil {
|
|
return nil, err
|
|
}
|
|
if _, ok := entries[id]; !ok {
|
|
entries[id] = e
|
|
}
|
|
}
|
|
return entries, rows.Err()
|
|
}
|
|
|
|
func (s *Store) saveDomainEntryTx(tx *sql.Tx, domain string, e DomainEntrySettings, apply bool) error {
|
|
if !e.valid() {
|
|
return ErrPeriodicalInvalid
|
|
}
|
|
raw, _ := json.Marshal(e)
|
|
if _, err := tx.Exec(`INSERT INTO domain_entry_settings(domain_uuid,settings_json) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`) ON CONFLICT(domain_uuid) DO UPDATE SET settings_json=excluded.settings_json`, domain, string(raw)); err != nil {
|
|
return err
|
|
}
|
|
if !apply {
|
|
return nil
|
|
}
|
|
if _, err := tx.Exec(`INSERT INTO config(domain_uuid,key,value,updated_at) VALUES(`+s.sqlParam(1)+`,'home_layout',`+s.sqlParam(2)+`,`+s.sqlParam(3)+`) ON CONFLICT(domain_uuid,key) DO UPDATE SET value=excluded.value,updated_at=excluded.updated_at`, domain, e.Layout, time.Now().Unix()); err != nil {
|
|
return err
|
|
}
|
|
for _, item := range []struct {
|
|
kind, prefix string
|
|
enabled bool
|
|
}{{"diary", e.DiaryPrefix, e.DiaryEnabled}, {"blog", e.BlogPrefix, e.BlogEnabled}} {
|
|
if _, err := tx.Exec(`INSERT INTO periodical_settings(domain_uuid,kind,enabled) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`) ON CONFLICT(domain_uuid,kind) DO UPDATE SET enabled=excluded.enabled`, domain, item.kind, boolToInt(item.enabled)); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.Exec(`INSERT INTO periodical_prefixes(domain_uuid,kind,prefix) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`) ON CONFLICT(domain_uuid,kind) DO UPDATE SET prefix=excluded.prefix`, domain, item.kind, item.prefix); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) SetDomainEntry(ctx context.Context, id int64, actor string, e DomainEntrySettings) (resultErr error) {
|
|
defer func() { resultErr = s.sqlError("SetDomainEntry", resultErr) }()
|
|
if !e.valid() {
|
|
return ErrPeriodicalInvalid
|
|
}
|
|
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
|
|
defer cancel()
|
|
tx, err := s.DB.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
if err = s.lockFederationWrite(context.Background(), tx); err != nil {
|
|
return err
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `UPDATE domains SET title=title WHERE id=`+s.sqlParam(1)+``, id); err != nil {
|
|
return err
|
|
}
|
|
var domain, campus, mode, placement string
|
|
if err = tx.QueryRowContext(ctx, `SELECT d.uuid,d.campus_uuid,c.authority_mode,d.placement FROM domains d JOIN campuses c ON c.uuid=d.campus_uuid WHERE d.id=`+s.sqlParam(1)+``, id).Scan(&domain, &campus, &mode, &placement); err != nil {
|
|
return err
|
|
}
|
|
if mode == "managed" {
|
|
return ErrAccessDenied
|
|
}
|
|
var allowed bool
|
|
err = tx.QueryRowContext(ctx, `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.sqlParam(1)+` AND g.builtin_key='campus_admin' AND g.state='active' AND m.principal_uuid=`+s.sqlParam(2)+` AND m.state='active' AND p.state='active' AND gm.member_role IN ('owner','manager'))`, campus, actor).Scan(&allowed)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !allowed {
|
|
return ErrAccessDenied
|
|
}
|
|
// Campus manifests are shared with every approved instance, not just the
|
|
// selected Domain destination. Do not strand an older peer on a v2 payload.
|
|
var incompatible bool
|
|
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM federation_instances i LEFT JOIN federation_instance_capabilities c ON c.instance_uuid=i.uuid WHERE i.campus_uuid=`+s.sqlParam(1)+` AND i.status='approved' AND COALESCE(c.manifest_version,1)<2)`, campus).Scan(&incompatible); err != nil {
|
|
return err
|
|
}
|
|
if incompatible {
|
|
return ErrManifestCapability
|
|
}
|
|
if err = s.saveDomainEntryTx(tx, domain, e, placement == "local"); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
}
|