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

646 lines
14 KiB
Go

package store
import (
"context"
"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 {
if s.sqlBackend == storePostgreSQL {
if err := s.ensurePostgreSQLNamespaces(context.Background()); err != nil {
return err
}
return s.EnsureAtLeastOneDomain()
}
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 {
return s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
_, err := tx.ExecContext(ctx, `INSERT INTO domains(uuid,name,title,domain,enabled,created_at)
SELECT `+s.sqlParam(1)+`,'default','Default Domain','',1,`+s.sqlParam(2)+` WHERE NOT EXISTS(SELECT 1 FROM domains)`, uuid.NewString(), time.Now().Unix())
return err
})
}
func (s *Store) GetDefaultDomain() (*Domain, error) {
return s.GetDefaultDomainContext(context.Background())
}
func (s *Store) GetDefaultDomainContext(ctx context.Context) (*Domain, error) {
row := s.DB.QueryRowContext(ctx, `
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
`)
d, err := scanDomain(row)
return d, s.sqlError("read default domain", err)
}
func (s *Store) GetDomainByHost(
host string,
) (*Domain, error) {
return s.GetDomainByHostContext(context.Background(), host)
}
func (s *Store) GetDomainByHostContext(ctx context.Context, host string) (*Domain, error) {
host =
normalizeDomainHost(
host,
)
row := s.DB.QueryRowContext(ctx, `
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 `+s.sqlHasDot("d.domain")+` THEN d.domain
ELSE d.domain || '.' || c.fqdn
END
) = `+s.sqlParam(1)+`
ORDER BY d.id
LIMIT 1
`, host)
d, err := scanDomain(row)
return d, s.sqlError("resolve domain host", err)
}
func (s *Store) GetDomainByUUID(domainUUID string) (*Domain, error) {
return s.GetDomainByUUIDContext(context.Background(), domainUUID)
}
func (s *Store) GetDomainByUUIDContext(ctx context.Context, domainUUID string) (*Domain, error) {
row := s.DB.QueryRowContext(ctx, `
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 = `+s.sqlParam(1)+`
LIMIT 1
`, domainUUID)
d, err := scanDomain(row)
return d, s.sqlError("read domain", err)
}
func (s *Store) GetDomainEffectiveHost(domainUUID string) (string, error) {
return s.GetDomainEffectiveHostContext(context.Background(), domainUUID)
}
func (s *Store) GetDomainEffectiveHostContext(ctx context.Context, domainUUID string) (string, error) {
var host string
err := s.DB.QueryRowContext(ctx, `
SELECT lower(
CASE
WHEN d.domain = '' THEN c.fqdn
WHEN `+s.sqlHasDot("d.domain")+` THEN d.domain
ELSE d.domain || '.' || c.fqdn
END
)
FROM domains d
JOIN campuses c ON c.uuid = d.campus_uuid
WHERE d.uuid = `+s.sqlParam(1)+`
`, domainUUID).Scan(&host)
return host, s.sqlError("read domain host", err)
}
func (s *Store) ListDomains() ([]Domain, error) {
return s.ListDomainsContext(context.Background())
}
func (s *Store) ListDomainsContext(ctx context.Context) ([]Domain, error) {
rows, err := s.DB.QueryContext(ctx, `
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, s.sqlError("list domains", err)
}
defer rows.Close()
var out []Domain
for rows.Next() {
d, err :=
scanDomain(
rows,
)
if err != nil {
return nil, s.sqlError("decode domain list", err)
}
out = append(
out,
*d,
)
}
return out, s.sqlError("list domains", rows.Err())
}
func (s *Store) CreateDomain(
campusUUID string,
name string,
title string,
domain string,
placement string,
instanceFQDN string,
instanceFingerprint string,
enabled bool,
) error {
return s.writeDomain(context.Background(), 0, false, campusUUID, name, title, domain, placement, instanceFQDN, instanceFingerprint, enabled)
}
func (s *Store) UpdateDomain(
id int64,
campusUUID string,
name string,
title string,
domain string,
placement string,
instanceFQDN string,
instanceFingerprint string,
enabled bool,
) error {
return s.writeDomain(context.Background(), id, true, campusUUID, name, title, domain, placement, instanceFQDN, instanceFingerprint, enabled)
}
func (s *Store) CountDomains() (int, error) {
return s.CountDomainsContext(context.Background())
}
func (s *Store) CountDomainsContext(ctx context.Context) (int, error) {
var count int
err := s.DB.QueryRowContext(ctx, `
SELECT count(*)
FROM domains
`).Scan(&count)
return count, s.sqlError("count domains", err)
}
func (s *Store) DeleteDomain(
id int64,
) error {
if s.ReadOnly {
return ErrReadOnly
}
return s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
var err error
var authorityMode string
if err := tx.QueryRowContext(ctx, `
SELECT c.authority_mode
FROM domains d
JOIN campuses c ON c.uuid = d.campus_uuid
WHERE d.id = `+s.sqlParam(1)+`
`, id).Scan(&authorityMode); err != nil {
return err
}
if authorityMode == "managed" {
return namespaceValidationError("managed campus topology is read-only")
}
var count int
err = tx.QueryRowContext(ctx, `SELECT count(*) FROM domains`).Scan(&count)
if err != nil {
return err
}
if count <= 1 {
return sql.ErrNoRows
}
var pathCount int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM paths
WHERE domain_uuid = (
SELECT uuid FROM domains WHERE id = `+s.sqlParam(1)+`
)
`, id).Scan(&pathCount); err != nil {
return err
}
if pathCount > 0 {
return namespaceValidationError("domain is referenced by paths")
}
if _, err = tx.ExecContext(ctx, `
DELETE FROM config
WHERE domain_uuid = (SELECT uuid FROM domains WHERE id = `+s.sqlParam(1)+`)
`, id); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `DELETE FROM domains WHERE id = `+s.sqlParam(1)+``, id); err != nil {
return err
}
if err = s.projectCampusAdminMembershipsContext(ctx, tx); err != nil {
return err
}
return nil
})
}
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 "", namespaceValidationError("invalid domain placement")
}
return placement, nil
}
func (s *Store) normalizeDomainInstance(
ctx context.Context, q interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
},
campusUUID string,
instanceFQDN string,
instanceFingerprint string,
) (string, string, error) {
var authorityMode, campusFQDN string
if err := q.QueryRowContext(ctx, `
SELECT authority_mode, fqdn
FROM campuses
WHERE uuid = `+s.sqlParam(1)+`
`, campusUUID).Scan(&authorityMode, &campusFQDN); err != nil {
return "", "", err
}
instanceFQDN = normalizeDomainHost(instanceFQDN)
if instanceFQDN == "" {
if authorityMode == "controller" {
return "", "", namespaceValidationError(
"controller campus domain requires an instance FQDN",
)
}
instanceFQDN = campusFQDN
}
if !strings.Contains(instanceFQDN, ".") &&
instanceFQDN != "localhost" {
return "", "", namespaceValidationError("invalid instance FQDN")
}
instanceFingerprint = strings.ToLower(strings.TrimSpace(instanceFingerprint))
if authorityMode == "controller" {
var count int
if err := q.QueryRowContext(ctx, `
SELECT count(*) FROM federation_instances
WHERE campus_uuid = `+s.sqlParam(1)+`
AND fqdn = `+s.sqlParam(2)+`
AND fingerprint = `+s.sqlParam(3)+`
AND status = 'approved'
`, campusUUID, instanceFQDN, instanceFingerprint).Scan(&count); err != nil {
return "", "", err
}
if count == 0 {
return "", "", namespaceValidationError(
"controller domain requires an approved instance fingerprint",
)
}
}
return instanceFQDN, instanceFingerprint, nil
}
func (s *Store) ensureCampusExists(ctx context.Context, q interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
}, campusUUID string) error {
if strings.TrimSpace(campusUUID) == "" {
return namespaceValidationError("campus UUID is required")
}
var authorityMode string
err := q.QueryRowContext(ctx, `
SELECT COALESCE(authority_mode, 'standalone')
FROM campuses
WHERE uuid = `+s.sqlParam(1)+`
`, campusUUID).Scan(&authorityMode)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return namespaceValidationError("campus does not exist")
}
return err
}
if authorityMode == "managed" {
return namespaceValidationError("managed campus topology is read-only")
}
return nil
}
func (s *Store) ensureLocalDomain(domainUUID string) error {
return s.ensureLocalDomainContext(context.Background(), domainUUID)
}
func (s *Store) ensureLocalDomainContext(ctx context.Context, domainUUID string) error {
var placement string
err := s.DB.QueryRowContext(ctx, `
SELECT COALESCE(placement, 'local')
FROM domains
WHERE uuid = `+s.sqlParam(1)+` AND enabled = 1
`, domainUUID).Scan(&placement)
if err != nil {
return s.sqlError("read domain placement", err)
}
if placement != "local" {
return namespaceValidationError("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(
ctx context.Context, q interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
},
excludeID int64,
campusUUID string,
name string,
domain string,
) error {
var campusFQDN string
if err := q.QueryRowContext(ctx, `
SELECT fqdn FROM campuses WHERE uuid = `+s.sqlParam(1)+`
`, campusUUID).Scan(&campusFQDN); err != nil {
return err
}
effectiveHost := domain
if effectiveHost == "" {
effectiveHost = campusFQDN
} else if !strings.Contains(effectiveHost, ".") {
effectiveHost += "." + campusFQDN
}
var count int
err := q.QueryRowContext(ctx, `
SELECT count(*)
FROM domains d
JOIN campuses c ON c.uuid = d.campus_uuid
WHERE d.id != `+s.sqlParam(1)+`
AND (
lower(d.name) = `+s.sqlParam(2)+`
OR lower(
CASE
WHEN d.domain = '' THEN c.fqdn
WHEN `+s.sqlHasDot("d.domain")+` THEN d.domain
ELSE d.domain || '.' || c.fqdn
END
) = `+s.sqlParam(3)+`
)
`,
excludeID,
name,
effectiveHost,
).Scan(&count)
if err != nil {
return err
}
if count > 0 {
return namespaceValidationError("domain name or host already exists")
}
return nil
}