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 }