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.
843 lines
15 KiB
Go
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
|
|
}
|