606 lines
14 KiB
Go
606 lines
14 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"golang.org/x/text/language"
|
|
)
|
|
|
|
type Campus struct {
|
|
ID int64
|
|
UUID string
|
|
Name string
|
|
Title string
|
|
DefaultLang string
|
|
AuthorityMode string
|
|
FQDN string
|
|
Transport string
|
|
LastContactAt int64
|
|
LastContactError string
|
|
Enabled bool
|
|
CreatedAt int64
|
|
}
|
|
|
|
func (s *Store) EnsureCampusesSchema() error {
|
|
if s.sqlBackend == storePostgreSQL {
|
|
return s.ensurePostgreSQLCampusDefaults(context.Background())
|
|
}
|
|
_, err := s.DB.Exec(`
|
|
CREATE TABLE IF NOT EXISTS campuses (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
uuid TEXT NOT NULL UNIQUE,
|
|
name TEXT NOT NULL UNIQUE,
|
|
title TEXT NOT NULL,
|
|
default_lang TEXT NOT NULL DEFAULT 'en',
|
|
authority_mode TEXT NOT NULL DEFAULT 'standalone',
|
|
fqdn TEXT NOT NULL DEFAULT 'localhost',
|
|
controller_transport TEXT NOT NULL DEFAULT 'https',
|
|
last_contact_at INTEGER NOT NULL DEFAULT 0,
|
|
last_contact_error TEXT NOT NULL DEFAULT '',
|
|
enabled INTEGER NOT NULL DEFAULT 1,
|
|
created_at INTEGER NOT NULL
|
|
)
|
|
`)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, _ = s.DB.Exec(`ALTER TABLE campuses ADD COLUMN authority_mode TEXT NOT NULL DEFAULT 'standalone'`)
|
|
_, _ = s.DB.Exec(`ALTER TABLE campuses ADD COLUMN fqdn TEXT NOT NULL DEFAULT ''`)
|
|
_, _ = s.DB.Exec(`ALTER TABLE campuses ADD COLUMN controller_transport TEXT NOT NULL DEFAULT 'https'`)
|
|
_, _ = s.DB.Exec(`ALTER TABLE campuses ADD COLUMN last_contact_at INTEGER NOT NULL DEFAULT 0`)
|
|
_, _ = s.DB.Exec(`ALTER TABLE campuses ADD COLUMN last_contact_error TEXT NOT NULL DEFAULT ''`)
|
|
_, _ = s.DB.Exec(`
|
|
UPDATE campuses
|
|
SET fqdn = lower(trim(
|
|
replace(replace(replace(controller_url, 'https://', ''), 'http://', ''), '/', '')
|
|
))
|
|
WHERE fqdn = '' AND controller_url != ''
|
|
`)
|
|
_, _ = s.DB.Exec(`
|
|
UPDATE campuses
|
|
SET fqdn = CASE
|
|
WHEN id = (
|
|
SELECT id FROM campuses
|
|
WHERE enabled = 1
|
|
ORDER BY
|
|
CASE WHEN name = 'default' THEN 0 ELSE 1 END,
|
|
id
|
|
LIMIT 1
|
|
)
|
|
THEN 'localhost'
|
|
ELSE name || '.localhost'
|
|
END
|
|
WHERE fqdn = ''
|
|
`)
|
|
|
|
var count int
|
|
if err := s.DB.QueryRow(`
|
|
SELECT count(*)
|
|
FROM campuses
|
|
`).Scan(&count); err != nil {
|
|
return err
|
|
}
|
|
|
|
if count == 0 {
|
|
_, err = s.DB.Exec(`
|
|
INSERT INTO campuses (
|
|
uuid,
|
|
name,
|
|
title,
|
|
default_lang,
|
|
enabled,
|
|
created_at
|
|
)
|
|
VALUES (?, 'default', 'Default Campus', 'en', 1, ?)
|
|
`,
|
|
uuid.NewString(),
|
|
time.Now().Unix(),
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
_, _ = s.DB.Exec(`
|
|
ALTER TABLE domains
|
|
ADD COLUMN campus_uuid TEXT
|
|
`)
|
|
|
|
defaultCampus, err := s.GetDefaultCampus()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = s.DB.Exec(`
|
|
UPDATE domains
|
|
SET campus_uuid = ?
|
|
WHERE campus_uuid IS NULL
|
|
OR campus_uuid = ''
|
|
OR campus_uuid NOT IN (
|
|
SELECT uuid
|
|
FROM campuses
|
|
WHERE enabled = 1
|
|
)
|
|
`, defaultCampus.UUID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = s.DB.Exec(`
|
|
CREATE INDEX IF NOT EXISTS idx_domains_campus_uuid
|
|
ON domains(campus_uuid)
|
|
`)
|
|
|
|
return err
|
|
}
|
|
|
|
func (s *Store) GetDefaultCampus() (*Campus, error) {
|
|
return s.GetDefaultCampusContext(context.Background())
|
|
}
|
|
|
|
func (s *Store) GetDefaultCampusContext(ctx context.Context) (*Campus, error) {
|
|
row := s.DB.QueryRowContext(ctx, `
|
|
SELECT
|
|
id,
|
|
uuid,
|
|
name,
|
|
title,
|
|
default_lang,
|
|
authority_mode,
|
|
fqdn,
|
|
controller_transport,
|
|
last_contact_at,
|
|
last_contact_error,
|
|
enabled,
|
|
created_at
|
|
FROM campuses
|
|
WHERE enabled = 1
|
|
ORDER BY
|
|
CASE WHEN name = 'default' THEN 0 ELSE 1 END,
|
|
id
|
|
LIMIT 1
|
|
`)
|
|
|
|
c, err := scanCampus(row)
|
|
return c, s.sqlError("read default campus", err)
|
|
}
|
|
|
|
func (s *Store) GetCampusByUUID(
|
|
campusUUID string,
|
|
) (*Campus, error) {
|
|
return s.GetCampusByUUIDContext(context.Background(), campusUUID)
|
|
}
|
|
|
|
func (s *Store) GetCampusByUUIDContext(ctx context.Context, campusUUID string) (*Campus, error) {
|
|
row := s.DB.QueryRowContext(ctx, `
|
|
SELECT
|
|
id,
|
|
uuid,
|
|
name,
|
|
title,
|
|
default_lang,
|
|
authority_mode,
|
|
fqdn,
|
|
controller_transport,
|
|
last_contact_at,
|
|
last_contact_error,
|
|
enabled,
|
|
created_at
|
|
FROM campuses
|
|
WHERE uuid = `+s.sqlParam(1)+`
|
|
AND enabled = 1
|
|
LIMIT 1
|
|
`, campusUUID)
|
|
|
|
c, err := scanCampus(row)
|
|
return c, s.sqlError("read campus", err)
|
|
}
|
|
|
|
func (s *Store) ListCampuses() ([]Campus, error) {
|
|
return s.ListCampusesContext(context.Background())
|
|
}
|
|
|
|
func (s *Store) ListCampusesContext(ctx context.Context) ([]Campus, error) {
|
|
rows, err := s.DB.QueryContext(ctx, `
|
|
SELECT
|
|
id,
|
|
uuid,
|
|
name,
|
|
title,
|
|
default_lang,
|
|
authority_mode,
|
|
fqdn,
|
|
controller_transport,
|
|
last_contact_at,
|
|
last_contact_error,
|
|
enabled,
|
|
created_at
|
|
FROM campuses
|
|
ORDER BY
|
|
CASE WHEN name = 'default' THEN 0 ELSE 1 END,
|
|
name,
|
|
id
|
|
`)
|
|
if err != nil {
|
|
return nil, s.sqlError("list campuses", err)
|
|
}
|
|
defer rows.Close()
|
|
|
|
var campuses []Campus
|
|
for rows.Next() {
|
|
campus, err := scanCampus(rows)
|
|
if err != nil {
|
|
return nil, s.sqlError("decode campus list", err)
|
|
}
|
|
campuses = append(campuses, *campus)
|
|
}
|
|
|
|
return campuses, s.sqlError("list campuses", rows.Err())
|
|
}
|
|
|
|
func (s *Store) CreateCampus(
|
|
name string,
|
|
title string,
|
|
defaultLang string,
|
|
authorityMode string,
|
|
fqdn string,
|
|
enabled bool,
|
|
) error {
|
|
name = normalizeCampusName(name)
|
|
title = strings.TrimSpace(title)
|
|
if name == "" {
|
|
return namespaceValidationError("campus name is required")
|
|
}
|
|
if title == "" {
|
|
title = name
|
|
}
|
|
|
|
defaultLang, err :=
|
|
normalizeCampusLanguage(
|
|
defaultLang,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
authorityMode, fqdn, err = normalizeCampusAuthority(
|
|
authorityMode,
|
|
fqdn,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if authorityMode == "managed" {
|
|
return namespaceValidationError(
|
|
"managed campus must be added through controller enrollment",
|
|
)
|
|
}
|
|
enabledValue := 0
|
|
if enabled {
|
|
enabledValue = 1
|
|
}
|
|
|
|
return s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
|
|
if err := s.ensureCampusFQDNAvailableFrom(ctx, tx, 0, fqdn); err != nil {
|
|
return err
|
|
}
|
|
_, err := tx.ExecContext(ctx, `INSERT INTO campuses(uuid,name,title,default_lang,authority_mode,fqdn,enabled,created_at) VALUES (`+s.sqlValues(8)+`)`, uuid.NewString(), name, title, defaultLang, authorityMode, fqdn, enabledValue, time.Now().Unix())
|
|
return err
|
|
})
|
|
}
|
|
|
|
func (s *Store) UpdateCampus(
|
|
id int64,
|
|
name string,
|
|
title string,
|
|
defaultLang string,
|
|
authorityMode string,
|
|
fqdn string,
|
|
enabled bool,
|
|
) error {
|
|
if id <= 0 {
|
|
return namespaceValidationError("campus id is required")
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
|
defer cancel()
|
|
var existingMode string
|
|
if err := s.DB.QueryRowContext(ctx, `
|
|
SELECT authority_mode FROM campuses WHERE id = `+s.sqlParam(1)+`
|
|
`, id).Scan(&existingMode); err != nil {
|
|
return s.sqlError("read campus authority", err)
|
|
}
|
|
if existingMode == "managed" {
|
|
return namespaceValidationError("managed campus settings are inherited")
|
|
}
|
|
|
|
name = normalizeCampusName(name)
|
|
title = strings.TrimSpace(title)
|
|
if name == "" {
|
|
return namespaceValidationError("campus name is required")
|
|
}
|
|
if title == "" {
|
|
title = name
|
|
}
|
|
|
|
defaultLang, err :=
|
|
normalizeCampusLanguage(
|
|
defaultLang,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
authorityMode, fqdn, err = normalizeCampusAuthority(
|
|
authorityMode,
|
|
fqdn,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.namespaceWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
|
|
// Re-read inherited status under the same lock as the mutation.
|
|
if err := tx.QueryRowContext(ctx, `SELECT authority_mode FROM campuses WHERE id=`+s.sqlParam(1), id).Scan(&existingMode); err != nil {
|
|
return err
|
|
}
|
|
if existingMode == "managed" {
|
|
return namespaceValidationError("managed campus settings are inherited")
|
|
}
|
|
if err := s.ensureCampusFQDNAvailableFrom(ctx, tx, id, fqdn); err != nil {
|
|
return err
|
|
}
|
|
if !enabled {
|
|
var domainCount int
|
|
if err := tx.QueryRowContext(ctx, `
|
|
SELECT count(*)
|
|
FROM domains
|
|
WHERE campus_uuid = (
|
|
SELECT uuid
|
|
FROM campuses
|
|
WHERE id = `+s.sqlParam(1)+`
|
|
)
|
|
`, id).Scan(&domainCount); err != nil {
|
|
return err
|
|
}
|
|
if domainCount > 0 {
|
|
return namespaceValidationError("campus is referenced by domains")
|
|
}
|
|
|
|
var enabledCount int
|
|
if err := tx.QueryRowContext(ctx, `
|
|
SELECT count(*)
|
|
FROM campuses
|
|
WHERE enabled = 1
|
|
AND id != `+s.sqlParam(1)+`
|
|
`, id).Scan(&enabledCount); err != nil {
|
|
return err
|
|
}
|
|
if enabledCount == 0 {
|
|
return namespaceValidationError("at least one enabled campus is required")
|
|
}
|
|
}
|
|
|
|
enabledValue := 0
|
|
if enabled {
|
|
enabledValue = 1
|
|
}
|
|
|
|
_, err = tx.ExecContext(ctx, `
|
|
UPDATE campuses
|
|
SET
|
|
name = `+s.sqlParam(1)+`,
|
|
title = `+s.sqlParam(2)+`,
|
|
default_lang = `+s.sqlParam(3)+`,
|
|
authority_mode = `+s.sqlParam(4)+`,
|
|
fqdn = `+s.sqlParam(5)+`,
|
|
enabled = `+s.sqlParam(6)+`
|
|
WHERE id = `+s.sqlParam(7)+`
|
|
`,
|
|
name,
|
|
title,
|
|
defaultLang,
|
|
authorityMode,
|
|
fqdn,
|
|
enabledValue,
|
|
id,
|
|
)
|
|
|
|
return err
|
|
})
|
|
}
|
|
|
|
func (s *Store) DeleteCampus(
|
|
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 targetEnabled int
|
|
var authorityMode string
|
|
if err := tx.QueryRowContext(ctx, `
|
|
SELECT enabled, authority_mode
|
|
FROM campuses
|
|
WHERE id = `+s.sqlParam(1)+`
|
|
`, id).Scan(&targetEnabled, &authorityMode); err != nil {
|
|
return err
|
|
}
|
|
var count int
|
|
if err := tx.QueryRowContext(ctx, `
|
|
SELECT count(*)
|
|
FROM campuses
|
|
`).Scan(&count); err != nil {
|
|
return err
|
|
}
|
|
if count <= 1 {
|
|
return namespaceValidationError("at least one campus is required")
|
|
}
|
|
|
|
if targetEnabled != 0 {
|
|
var enabledCount int
|
|
if err := tx.QueryRowContext(ctx, `
|
|
SELECT count(*)
|
|
FROM campuses
|
|
WHERE enabled = 1
|
|
AND id != `+s.sqlParam(1)+`
|
|
`, id).Scan(&enabledCount); err != nil {
|
|
return err
|
|
}
|
|
if enabledCount == 0 {
|
|
return namespaceValidationError("at least one enabled campus is required")
|
|
}
|
|
}
|
|
if authorityMode == "managed" {
|
|
return s.deleteManagedCampusTx(ctx, tx, id)
|
|
}
|
|
|
|
var domainCount int
|
|
if err := tx.QueryRowContext(ctx, `
|
|
SELECT count(*)
|
|
FROM domains
|
|
WHERE campus_uuid = (
|
|
SELECT uuid
|
|
FROM campuses
|
|
WHERE id = `+s.sqlParam(1)+`
|
|
)
|
|
`, id).Scan(&domainCount); err != nil {
|
|
return err
|
|
}
|
|
if domainCount > 0 {
|
|
return namespaceValidationError("campus is referenced by domains")
|
|
}
|
|
|
|
var campusUUID string
|
|
if err := tx.QueryRowContext(ctx, `
|
|
SELECT uuid FROM campuses WHERE id = `+s.sqlParam(1)+`
|
|
`, id).Scan(&campusUUID); err != nil {
|
|
return err
|
|
}
|
|
if err := s.deleteFederationCampusTx(ctx, tx, campusUUID); err != nil {
|
|
return err
|
|
}
|
|
result, err := tx.ExecContext(ctx, `
|
|
DELETE FROM campuses WHERE id = `+s.sqlParam(1)+`
|
|
`, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
affected, err := result.RowsAffected()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if affected == 0 {
|
|
return sql.ErrNoRows
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func normalizeCampusName(name string) string {
|
|
name = strings.TrimSpace(strings.ToLower(name))
|
|
return strings.ReplaceAll(name, " ", "-")
|
|
}
|
|
|
|
func normalizeCampusLanguage(raw string) (string, error) {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
raw = "en"
|
|
}
|
|
tag, err := language.Parse(raw)
|
|
if err != nil {
|
|
return "", namespaceValidationError("invalid campus default language")
|
|
}
|
|
return tag.String(), nil
|
|
}
|
|
|
|
func normalizeCampusAuthority(mode, fqdn string) (string, string, error) {
|
|
mode = strings.ToLower(strings.TrimSpace(mode))
|
|
fqdn = normalizeDomainHost(fqdn)
|
|
if mode == "" {
|
|
mode = "standalone"
|
|
}
|
|
switch mode {
|
|
case "standalone", "controller":
|
|
case "managed":
|
|
default:
|
|
return "", "", namespaceValidationError("invalid campus authority mode")
|
|
}
|
|
if fqdn == "" {
|
|
return "", "", namespaceValidationError("campus FQDN is required")
|
|
}
|
|
if !strings.Contains(fqdn, ".") && fqdn != "localhost" {
|
|
return "", "", namespaceValidationError("invalid campus FQDN")
|
|
}
|
|
return mode, fqdn, nil
|
|
}
|
|
|
|
func (s *Store) ensureCampusFQDNAvailableFrom(ctx context.Context, q interface {
|
|
QueryRowContext(context.Context, string, ...any) *sql.Row
|
|
}, id int64, fqdn string) error {
|
|
var count int
|
|
if err := q.QueryRowContext(ctx, `
|
|
SELECT count(*) FROM campuses
|
|
WHERE id != `+s.sqlParam(1)+` AND lower(fqdn) = lower(`+s.sqlParam(2)+`)
|
|
`, id, fqdn).Scan(&count); err != nil {
|
|
return err
|
|
}
|
|
if count > 0 {
|
|
return namespaceValidationError("campus FQDN already exists")
|
|
}
|
|
|
|
if err := q.QueryRowContext(ctx, `
|
|
WITH effective_hosts AS (
|
|
SELECT lower(
|
|
CASE
|
|
WHEN d.domain = '' THEN
|
|
CASE WHEN c.id = `+s.sqlParam(1)+` THEN `+s.sqlParam(2)+` ELSE c.fqdn END
|
|
WHEN `+s.sqlHasDot("d.domain")+` THEN d.domain
|
|
ELSE d.domain || '.' ||
|
|
CASE WHEN c.id = `+s.sqlParam(3)+` THEN `+s.sqlParam(4)+` ELSE c.fqdn END
|
|
END
|
|
) AS host
|
|
FROM domains d
|
|
JOIN campuses c ON c.uuid = d.campus_uuid
|
|
)
|
|
SELECT count(*) FROM (
|
|
SELECT host FROM effective_hosts
|
|
GROUP BY host HAVING count(*) > 1
|
|
) AS duplicate_hosts
|
|
`, id, fqdn, id, fqdn).Scan(&count); err != nil {
|
|
return err
|
|
}
|
|
if count > 0 {
|
|
return namespaceValidationError("campus FQDN conflicts with a domain host")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func scanCampus(row interface {
|
|
Scan(dest ...any) error
|
|
}) (*Campus, error) {
|
|
var campus Campus
|
|
var enabled int
|
|
err := row.Scan(
|
|
&campus.ID,
|
|
&campus.UUID,
|
|
&campus.Name,
|
|
&campus.Title,
|
|
&campus.DefaultLang,
|
|
&campus.AuthorityMode,
|
|
&campus.FQDN,
|
|
&campus.Transport,
|
|
&campus.LastContactAt,
|
|
&campus.LastContactError,
|
|
&enabled,
|
|
&campus.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
campus.Enabled = enabled != 0
|
|
return &campus, nil
|
|
}
|