646 lines
14 KiB
Go
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
|
|
}
|