Files
pages/internal/store/domains.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
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.
2026-09-27 14:44:43 +09:00

843 lines
15 KiB
Go

package store
import (
"database/sql"
"errors"
"strings"
"time"
"github.com/google/uuid"
)
type Domain struct {
ID int64
UUID string
CampusUUID string
Name string
Title string
Domain string
Placement string
InstanceFQDN string
InstanceFingerprint string
Enabled bool
CreatedAt int64
}
func (s *Store) EnsureDomainsSchema() error {
var legacyTable int
var domainsTable int
if err := s.DB.QueryRow(`
SELECT count(*)
FROM sqlite_master
WHERE type = 'table'
AND name = 'districts'
`).Scan(&legacyTable); err != nil {
return err
}
if err := s.DB.QueryRow(`
SELECT count(*)
FROM sqlite_master
WHERE type = 'table'
AND name = 'domains'
`).Scan(&domainsTable); err != nil {
return err
}
if legacyTable > 0 && domainsTable == 0 {
if _, err := s.DB.Exec(`
ALTER TABLE districts RENAME TO domains
`); err != nil {
return err
}
} else if legacyTable > 0 {
if _, err := s.DB.Exec(`
INSERT OR IGNORE INTO domains (
id,
uuid,
name,
title,
domain,
enabled,
created_at
)
SELECT
id,
uuid,
name,
title,
domain,
enabled,
created_at
FROM districts
`); err != nil {
return err
}
}
_, err := s.DB.Exec(`
CREATE TABLE IF NOT EXISTS domains (
id INTEGER PRIMARY KEY AUTOINCREMENT,
uuid TEXT NOT NULL UNIQUE,
name TEXT NOT NULL UNIQUE,
title TEXT NOT NULL,
domain TEXT NOT NULL DEFAULT '',
enabled INTEGER NOT NULL DEFAULT 1,
created_at INTEGER NOT NULL,
campus_uuid TEXT,
placement TEXT NOT NULL DEFAULT 'local',
instance_fqdn TEXT NOT NULL DEFAULT '',
instance_fingerprint TEXT NOT NULL DEFAULT ''
)
`)
if err != nil {
return err
}
_, _ = s.DB.Exec(`ALTER TABLE domains ADD COLUMN placement TEXT NOT NULL DEFAULT 'local'`)
_, _ = s.DB.Exec(`ALTER TABLE domains ADD COLUMN instance_fqdn TEXT NOT NULL DEFAULT ''`)
_, _ = s.DB.Exec(`ALTER TABLE domains ADD COLUMN instance_fingerprint TEXT NOT NULL DEFAULT ''`)
// Keep the default title aligned with the current terminology while
// preserving titles that users have customized.
if _, err := s.DB.Exec(`
UPDATE domains
SET title = 'Default Domain'
WHERE name = 'default'
AND title = 'Default District'
`); err != nil {
return err
}
return s.EnsureAtLeastOneDomain()
}
func (s *Store) EnsureAtLeastOneDomain() error {
var count int
err := s.DB.QueryRow(`
SELECT count(*)
FROM domains
`).Scan(&count)
if err != nil {
return err
}
if count > 0 {
return nil
}
_, err = s.DB.Exec(`
INSERT INTO domains (
uuid,
name,
title,
domain,
enabled,
created_at
)
VALUES (?, 'default', 'Default Domain', '', 1, ?)
`,
uuid.NewString(),
time.Now().Unix(),
)
return err
}
func (s *Store) GetDefaultDomain() (*Domain, error) {
row := s.DB.QueryRow(`
SELECT
id,
uuid,
name,
title,
domain,
enabled,
created_at,
COALESCE(campus_uuid, ''),
COALESCE(placement, 'local'),
COALESCE(instance_fqdn, ''),
COALESCE(instance_fingerprint, '')
FROM domains
WHERE enabled = 1
ORDER BY
CASE WHEN name = 'default' THEN 0 ELSE 1 END,
id
LIMIT 1
`)
return scanDomain(row)
}
func (s *Store) GetDomainByHost(
host string,
) (*Domain, error) {
host =
normalizeDomainHost(
host,
)
row := s.DB.QueryRow(`
SELECT
d.id,
d.uuid,
d.name,
d.title,
d.domain,
d.enabled,
d.created_at,
COALESCE(d.campus_uuid, ''),
COALESCE(d.placement, 'local'),
COALESCE(d.instance_fqdn, ''),
COALESCE(d.instance_fingerprint, '')
FROM domains d
JOIN campuses c ON c.uuid = d.campus_uuid
WHERE d.enabled = 1
AND c.enabled = 1
AND lower(
CASE
WHEN d.domain = '' THEN c.fqdn
WHEN instr(d.domain, '.') > 0 THEN d.domain
ELSE d.domain || '.' || c.fqdn
END
) = ?
ORDER BY d.id
LIMIT 1
`, host)
return scanDomain(row)
}
func (s *Store) GetDomainByUUID(domainUUID string) (*Domain, error) {
row := s.DB.QueryRow(`
SELECT
id, uuid, name, title, domain, enabled, created_at,
COALESCE(campus_uuid, ''),
COALESCE(placement, 'local'),
COALESCE(instance_fqdn, ''),
COALESCE(instance_fingerprint, '')
FROM domains
WHERE uuid = ?
LIMIT 1
`, domainUUID)
return scanDomain(row)
}
func (s *Store) GetDomainEffectiveHost(domainUUID string) (string, error) {
var host string
err := s.DB.QueryRow(`
SELECT lower(
CASE
WHEN d.domain = '' THEN c.fqdn
WHEN instr(d.domain, '.') > 0 THEN d.domain
ELSE d.domain || '.' || c.fqdn
END
)
FROM domains d
JOIN campuses c ON c.uuid = d.campus_uuid
WHERE d.uuid = ?
`, domainUUID).Scan(&host)
return host, err
}
func (s *Store) ListDomains() ([]Domain, error) {
rows, err := s.DB.Query(`
SELECT
id,
uuid,
name,
title,
domain,
enabled,
created_at,
COALESCE(campus_uuid, ''),
COALESCE(placement, 'local'),
COALESCE(instance_fqdn, ''),
COALESCE(instance_fingerprint, '')
FROM domains
ORDER BY
CASE WHEN name = 'default' THEN 0 ELSE 1 END,
name,
id
`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []Domain
for rows.Next() {
d, err :=
scanDomain(
rows,
)
if err != nil {
return nil, err
}
out = append(
out,
*d,
)
}
return out, rows.Err()
}
func (s *Store) CreateDomain(
campusUUID string,
name string,
title string,
domain string,
placement string,
instanceFQDN string,
instanceFingerprint string,
enabled bool,
) error {
name =
normalizeDomainName(
name,
)
title =
strings.TrimSpace(
title,
)
domain =
normalizeDomainHost(
domain,
)
if name == "" {
return errors.New("domain name is required")
}
if title == "" {
title = name
}
if err := s.ensureCampusExists(campusUUID); err != nil {
return err
}
placement, err := normalizeDomainPlacement(placement)
if err != nil {
return err
}
instanceFQDN, instanceFingerprint, err = s.normalizeDomainInstance(
campusUUID,
instanceFQDN,
instanceFingerprint,
)
if err != nil {
return err
}
if err := s.ensureDomainUnique(0, campusUUID, name, domain); err != nil {
return err
}
enabledValue := 0
if enabled {
enabledValue = 1
}
domainUUID := uuid.NewString()
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
_, err = tx.Exec(`
INSERT INTO domains (
uuid,
name,
title,
domain,
enabled,
created_at,
campus_uuid,
placement,
instance_fqdn,
instance_fingerprint
)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`,
domainUUID,
name,
title,
domain,
enabledValue,
time.Now().Unix(),
campusUUID,
placement,
instanceFQDN,
instanceFingerprint,
)
if err != nil {
return err
}
var hasConfigTable int
if err := tx.QueryRow(`
SELECT count(*) FROM sqlite_master
WHERE type = 'table' AND name = 'config'
`).Scan(&hasConfigTable); err != nil {
return err
}
if hasConfigTable != 0 {
if _, err := tx.Exec(`
INSERT INTO config (domain_uuid, key, value, updated_at)
SELECT ?, 'locale',
CASE
WHEN lower(default_lang) LIKE 'ja%' THEN 'ja'
ELSE 'en'
END,
strftime('%s','now')
FROM campuses
WHERE uuid = ?
ON CONFLICT(domain_uuid, key) DO NOTHING
`, domainUUID, campusUUID); err != nil {
return err
}
}
if err := tx.Commit(); err != nil {
return err
}
return s.EnsureBuiltinAdminGroups()
}
func (s *Store) UpdateDomain(
id int64,
campusUUID string,
name string,
title string,
domain string,
placement string,
instanceFQDN string,
instanceFingerprint string,
enabled bool,
) error {
name =
normalizeDomainName(
name,
)
title =
strings.TrimSpace(
title,
)
domain =
normalizeDomainHost(
domain,
)
if id <= 0 {
return errors.New("domain id is required")
}
if name == "" {
return errors.New("domain name is required")
}
if title == "" {
title = name
}
if err := s.ensureCampusExists(campusUUID); err != nil {
return err
}
placement, err := normalizeDomainPlacement(placement)
if err != nil {
return err
}
instanceFQDN, instanceFingerprint, err = s.normalizeDomainInstance(
campusUUID,
instanceFQDN,
instanceFingerprint,
)
if err != nil {
return err
}
if placement == "remote" {
var pathCount int
if err := s.DB.QueryRow(`
SELECT count(*)
FROM paths
WHERE domain_uuid = (
SELECT uuid FROM domains WHERE id = ?
)
`, id).Scan(&pathCount); err != nil {
return err
}
if pathCount > 0 {
return errors.New("domain with local paths cannot become remote")
}
}
if err := s.ensureDomainUnique(id, campusUUID, name, domain); err != nil {
return err
}
enabledValue := 0
if enabled {
enabledValue = 1
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
_, err = tx.Exec(`
UPDATE domains
SET
name = ?,
title = ?,
domain = ?,
enabled = ?,
campus_uuid = ?,
placement = ?,
instance_fqdn = ?,
instance_fingerprint = ?
WHERE id = ?
`,
name,
title,
domain,
enabledValue,
campusUUID,
placement,
instanceFQDN,
instanceFingerprint,
id,
)
if err != nil {
return err
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) CountDomains() (int, error) {
var count int
err := s.DB.QueryRow(`
SELECT count(*)
FROM domains
`).Scan(&count)
return count, err
}
func (s *Store) DeleteDomain(
id int64,
) error {
var authorityMode string
if err := s.DB.QueryRow(`
SELECT c.authority_mode
FROM domains d
JOIN campuses c ON c.uuid = d.campus_uuid
WHERE d.id = ?
`, id).Scan(&authorityMode); err != nil {
return err
}
if authorityMode == "managed" {
return errors.New("managed campus topology is read-only")
}
count, err :=
s.CountDomains()
if err != nil {
return err
}
if count <= 1 {
return sql.ErrNoRows
}
var pathCount int
if err := s.DB.QueryRow(`
SELECT count(*)
FROM paths
WHERE domain_uuid = (
SELECT uuid FROM domains WHERE id = ?
)
`, id).Scan(&pathCount); err != nil {
return err
}
if pathCount > 0 {
return errors.New("domain is referenced by paths")
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
if _, err = tx.Exec(`
DELETE FROM config
WHERE domain_uuid = (SELECT uuid FROM domains WHERE id = ?)
`, id); err != nil {
return err
}
if _, err = tx.Exec(`DELETE FROM domains WHERE id = ?`, id); err != nil {
return err
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
return err
}
return tx.Commit()
}
func scanDomain(row interface {
Scan(dest ...any) error
}) (*Domain, error) {
var d Domain
var enabled int
err := row.Scan(
&d.ID,
&d.UUID,
&d.Name,
&d.Title,
&d.Domain,
&enabled,
&d.CreatedAt,
&d.CampusUUID,
&d.Placement,
&d.InstanceFQDN,
&d.InstanceFingerprint,
)
if err != nil {
return nil, err
}
d.Enabled = enabled != 0
return &d, nil
}
func normalizeDomainPlacement(placement string) (string, error) {
placement = strings.ToLower(strings.TrimSpace(placement))
if placement == "" {
placement = "local"
}
switch placement {
case "local":
case "remote":
default:
return "", errors.New("invalid domain placement")
}
return placement, nil
}
func (s *Store) normalizeDomainInstance(
campusUUID string,
instanceFQDN string,
instanceFingerprint string,
) (string, string, error) {
var authorityMode, campusFQDN string
if err := s.DB.QueryRow(`
SELECT authority_mode, fqdn
FROM campuses
WHERE uuid = ?
`, campusUUID).Scan(&authorityMode, &campusFQDN); err != nil {
return "", "", err
}
instanceFQDN = normalizeDomainHost(instanceFQDN)
if instanceFQDN == "" {
if authorityMode == "controller" {
return "", "", errors.New(
"controller campus domain requires an instance FQDN",
)
}
instanceFQDN = campusFQDN
}
if !strings.Contains(instanceFQDN, ".") &&
instanceFQDN != "localhost" {
return "", "", errors.New("invalid instance FQDN")
}
instanceFingerprint = strings.ToLower(strings.TrimSpace(instanceFingerprint))
if authorityMode == "controller" {
var count int
if err := s.DB.QueryRow(`
SELECT count(*) FROM federation_instances
WHERE campus_uuid = ?
AND fqdn = ?
AND fingerprint = ?
AND status = 'approved'
`, campusUUID, instanceFQDN, instanceFingerprint).Scan(&count); err != nil {
return "", "", err
}
if count == 0 {
return "", "", errors.New(
"controller domain requires an approved instance fingerprint",
)
}
}
return instanceFQDN, instanceFingerprint, nil
}
func (s *Store) ensureCampusExists(campusUUID string) error {
if strings.TrimSpace(campusUUID) == "" {
return errors.New("campus UUID is required")
}
var authorityMode string
err := s.DB.QueryRow(`
SELECT COALESCE(authority_mode, 'standalone')
FROM campuses
WHERE uuid = ?
`, campusUUID).Scan(&authorityMode)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return errors.New("campus does not exist")
}
return err
}
if authorityMode == "managed" {
return errors.New("managed campus topology is read-only")
}
return nil
}
func (s *Store) ensureLocalDomain(domainUUID string) error {
var placement string
err := s.DB.QueryRow(`
SELECT COALESCE(placement, 'local')
FROM domains
WHERE uuid = ? AND enabled = 1
`, domainUUID).Scan(&placement)
if err != nil {
return err
}
if placement != "local" {
return errors.New("remote domain has no local path namespace")
}
return nil
}
func normalizeDomainName(
name string,
) string {
name =
strings.TrimSpace(
strings.ToLower(
name,
),
)
name =
strings.ReplaceAll(
name,
" ",
"-",
)
return name
}
func normalizeDomainHost(
host string,
) string {
host =
strings.TrimSpace(
strings.ToLower(
host,
),
)
if host == "" {
return ""
}
if i := strings.IndexByte(host, ':'); i > 0 {
host = host[:i]
}
return strings.Trim(
host,
".",
)
}
func (s *Store) ensureDomainUnique(
excludeID int64,
campusUUID string,
name string,
domain string,
) error {
var campusFQDN string
if err := s.DB.QueryRow(`
SELECT fqdn FROM campuses WHERE uuid = ?
`, campusUUID).Scan(&campusFQDN); err != nil {
return err
}
effectiveHost := domain
if effectiveHost == "" {
effectiveHost = campusFQDN
} else if !strings.Contains(effectiveHost, ".") {
effectiveHost += "." + campusFQDN
}
var count int
err := s.DB.QueryRow(`
SELECT count(*)
FROM domains d
JOIN campuses c ON c.uuid = d.campus_uuid
WHERE d.id != ?
AND (
lower(d.name) = ?
OR lower(
CASE
WHEN d.domain = '' THEN c.fqdn
WHEN instr(d.domain, '.') > 0 THEN d.domain
ELSE d.domain || '.' || c.fqdn
END
) = ?
)
`,
excludeID,
name,
effectiveHost,
).Scan(&count)
if err != nil {
return err
}
if count > 0 {
return errors.New("domain name or host already exists")
}
return nil
}