649 lines
20 KiB
Go
649 lines
20 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"crypto/ed25519"
|
|
"crypto/rand"
|
|
"crypto/sha256"
|
|
"database/sql"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"errors"
|
|
"log"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type FederationInstance struct {
|
|
ID int64
|
|
UUID string
|
|
CampusUUID string
|
|
FQDN string
|
|
Fingerprint string
|
|
Status string
|
|
LastSeenAt int64
|
|
CreatedAt int64
|
|
}
|
|
|
|
type CampusToken struct {
|
|
ID int64
|
|
CampusUUID string
|
|
Label string
|
|
Revoked bool
|
|
CreatedAt int64
|
|
LastUsedAt int64
|
|
}
|
|
|
|
func (s *Store) ApplyManagedCampusSnapshot(
|
|
campus Campus,
|
|
domains []Domain,
|
|
localInstanceFQDN string,
|
|
transport string,
|
|
) (resultErr error) {
|
|
defer func() { resultErr = s.sqlError("ApplyManagedCampusSnapshot", resultErr) }()
|
|
if s.ReadOnly {
|
|
return ErrReadOnly
|
|
}
|
|
if campus.UUID == "" || campus.FQDN == "" {
|
|
return namespaceValidationError("invalid managed campus snapshot")
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
|
defer cancel()
|
|
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
if err = s.lockFederationWrite(ctx, tx); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.Exec(`UPDATE federation_manifest_state SET applied_at=applied_at WHERE campus_uuid=`+s.sqlParam(1)+``, campus.UUID); err != nil {
|
|
return err
|
|
}
|
|
var pinned int
|
|
if err := tx.QueryRow(`SELECT COUNT(*) FROM federation_manifest_state WHERE campus_uuid=`+s.sqlParam(1)+``, campus.UUID).Scan(&pinned); err != nil {
|
|
return err
|
|
}
|
|
if pinned != 0 {
|
|
return namespaceValidationError("unsigned snapshot rejected for a pinned Campus")
|
|
}
|
|
if err := s.applyManagedCampusSnapshotTx(tx, campus, domains, localInstanceFQDN, transport); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
// applyManagedCampusSnapshotTx never commits independently: signed manifests,
|
|
// their checkpoint and the inherited administrator projection share one commit.
|
|
func (s *Store) applyManagedCampusSnapshotTx(tx *sql.Tx, campus Campus, domains []Domain, localInstanceFQDN, transport string) error {
|
|
if campus.UUID == "" || campus.FQDN == "" {
|
|
return namespaceValidationError("invalid managed campus snapshot")
|
|
}
|
|
var authority string
|
|
err := tx.QueryRow(`SELECT authority_mode FROM campuses WHERE uuid=`+s.sqlParam(1)+``, campus.UUID).Scan(&authority)
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return err
|
|
}
|
|
if err == nil && authority != "managed" {
|
|
return namespaceValidationError("managed Campus snapshot cannot replace a local authority")
|
|
}
|
|
seen := make(map[string]bool, len(domains))
|
|
for _, domain := range domains {
|
|
if domain.UUID == "" || domain.CampusUUID != campus.UUID || seen[domain.UUID] {
|
|
return namespaceValidationError("invalid managed domain snapshot")
|
|
}
|
|
seen[domain.UUID] = true
|
|
var owner string
|
|
err := tx.QueryRow(`SELECT campus_uuid FROM domains WHERE uuid=`+s.sqlParam(1)+``, domain.UUID).Scan(&owner)
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return err
|
|
}
|
|
if err == nil && owner != campus.UUID {
|
|
return namespaceValidationError("managed Campus snapshot cannot claim another Campus Domain")
|
|
}
|
|
}
|
|
now := time.Now().Unix()
|
|
_, err = tx.Exec(`
|
|
INSERT INTO campuses (
|
|
uuid, name, title, default_lang, authority_mode,
|
|
fqdn, controller_transport, last_contact_at,
|
|
last_contact_error, enabled, created_at
|
|
)
|
|
VALUES (`+s.sqlParam(1)+`, `+s.sqlParam(2)+`, `+s.sqlParam(3)+`, `+s.sqlParam(4)+`, 'managed', `+s.sqlParam(5)+`, `+s.sqlParam(6)+`, `+s.sqlParam(7)+`, '', 1, `+s.sqlParam(8)+`)
|
|
ON CONFLICT(uuid) DO UPDATE SET
|
|
name = excluded.name,
|
|
title = excluded.title,
|
|
default_lang = excluded.default_lang,
|
|
authority_mode = 'managed',
|
|
fqdn = excluded.fqdn,
|
|
controller_transport = excluded.controller_transport,
|
|
last_contact_at = excluded.last_contact_at,
|
|
last_contact_error = '',
|
|
enabled = 1
|
|
`, campus.UUID, campus.Name, campus.Title, campus.DefaultLang,
|
|
campus.FQDN, transport, now, now)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err = tx.Exec(`
|
|
UPDATE domains SET enabled = 0 WHERE campus_uuid = `+s.sqlParam(1)+`
|
|
`, campus.UUID); err != nil {
|
|
return err
|
|
}
|
|
hasConfigTable := 1
|
|
if s.sqlBackend == storeSQLite {
|
|
if err := tx.QueryRow(`
|
|
SELECT count(*) FROM sqlite_master
|
|
WHERE type = 'table' AND name = 'config'
|
|
`).Scan(&hasConfigTable); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, domain := range domains {
|
|
if domain.UUID == "" || domain.CampusUUID != campus.UUID {
|
|
return namespaceValidationError("invalid managed domain snapshot")
|
|
}
|
|
placement := "remote"
|
|
if normalizeDomainHost(domain.InstanceFQDN) ==
|
|
normalizeDomainHost(localInstanceFQDN) {
|
|
placement = "local"
|
|
}
|
|
_, err = tx.Exec(`
|
|
INSERT INTO domains (
|
|
uuid, name, title, domain, enabled, created_at,
|
|
campus_uuid, placement, instance_fqdn,
|
|
instance_fingerprint
|
|
)
|
|
VALUES (`+s.sqlParam(1)+`, `+s.sqlParam(2)+`, `+s.sqlParam(3)+`, `+s.sqlParam(4)+`, `+s.sqlParam(5)+`, `+s.sqlParam(6)+`, `+s.sqlParam(7)+`, `+s.sqlParam(8)+`, `+s.sqlParam(9)+`, `+s.sqlParam(10)+`)
|
|
ON CONFLICT(uuid) DO UPDATE SET
|
|
name = excluded.name,
|
|
title = excluded.title,
|
|
domain = excluded.domain,
|
|
enabled = excluded.enabled,
|
|
campus_uuid = excluded.campus_uuid,
|
|
placement = excluded.placement,
|
|
instance_fqdn = excluded.instance_fqdn,
|
|
instance_fingerprint = excluded.instance_fingerprint
|
|
`, domain.UUID, domain.Name, domain.Title, domain.Domain,
|
|
boolToInt(domain.Enabled), domain.CreatedAt, campus.UUID,
|
|
placement, domain.InstanceFQDN,
|
|
domain.InstanceFingerprint)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if hasConfigTable != 0 {
|
|
if _, err = tx.Exec(`
|
|
INSERT INTO config (domain_uuid, key, value, updated_at)
|
|
VALUES (
|
|
`+s.sqlParam(1)+`, 'locale',
|
|
CASE
|
|
WHEN lower(`+s.sqlParam(2)+`) LIKE 'ja%' THEN 'ja'
|
|
ELSE 'en'
|
|
END,
|
|
`+s.sqlParam(3)+`
|
|
)
|
|
ON CONFLICT(domain_uuid, key) DO NOTHING
|
|
`, domain.UUID, campus.DefaultLang, now); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
if err = s.projectCampusAdminMembershipsContext(context.Background(), tx); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func boolToInt(value bool) int {
|
|
if value {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (s *Store) RecordCampusContact(
|
|
campusUUID string,
|
|
contactError string,
|
|
) (resultErr error) {
|
|
defer func() { resultErr = s.sqlError("RecordCampusContact", resultErr) }()
|
|
if s.ReadOnly {
|
|
return ErrReadOnly
|
|
}
|
|
lastContactAt := time.Now().Unix()
|
|
if contactError != "" {
|
|
lastContactAt = 0
|
|
}
|
|
_, err := s.DB.Exec(`
|
|
UPDATE campuses
|
|
SET last_contact_at = `+s.sqlParam(1)+`, last_contact_error = `+s.sqlParam(2)+`
|
|
WHERE uuid = `+s.sqlParam(3)+` AND authority_mode = 'managed'
|
|
`, lastContactAt, contactError, campusUUID)
|
|
return err
|
|
}
|
|
|
|
func (s *Store) deleteManagedCampusTx(ctx context.Context, tx *sql.Tx, id int64) error {
|
|
var err error
|
|
var campusUUID string
|
|
if err := tx.QueryRowContext(ctx, `
|
|
SELECT uuid FROM campuses
|
|
WHERE id = `+s.sqlParam(1)+` AND authority_mode = 'managed'
|
|
`, id).Scan(&campusUUID); err != nil {
|
|
return err
|
|
}
|
|
configTable := 1
|
|
if s.sqlBackend == storeSQLite {
|
|
if err := tx.QueryRowContext(ctx, `
|
|
SELECT count(*) FROM sqlite_master
|
|
WHERE type = 'table' AND name = 'config'
|
|
`).Scan(&configTable); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if configTable > 0 {
|
|
if _, err := tx.ExecContext(ctx, `
|
|
DELETE FROM config
|
|
WHERE domain_uuid IN (
|
|
SELECT uuid FROM domains WHERE campus_uuid = `+s.sqlParam(1)+`
|
|
)
|
|
`, campusUUID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
DELETE FROM paths
|
|
WHERE domain_uuid IN (
|
|
SELECT uuid FROM domains WHERE campus_uuid = `+s.sqlParam(1)+`
|
|
)
|
|
`, campusUUID); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
DELETE FROM domains WHERE campus_uuid = `+s.sqlParam(1)+`
|
|
`, campusUUID); err != nil {
|
|
return err
|
|
}
|
|
if err := s.deleteFederationCampusTx(ctx, tx, campusUUID); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
DELETE FROM campuses WHERE id = `+s.sqlParam(1)+`
|
|
`, id); err != nil {
|
|
return err
|
|
}
|
|
if err = s.projectCampusAdminMembershipsContext(ctx, tx); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) EnsureFederationSchema() error {
|
|
if s.sqlBackend == storePostgreSQL {
|
|
return s.ensurePostgreSQLFederation(context.Background())
|
|
}
|
|
_, err := s.DB.Exec(`
|
|
CREATE TABLE IF NOT EXISTS campus_tokens (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
campus_uuid TEXT NOT NULL,
|
|
token_hash TEXT NOT NULL UNIQUE,
|
|
label TEXT NOT NULL DEFAULT '',
|
|
revoked INTEGER NOT NULL DEFAULT 0,
|
|
created_at INTEGER NOT NULL,
|
|
last_used_at INTEGER NOT NULL DEFAULT 0
|
|
);
|
|
CREATE TABLE IF NOT EXISTS federation_instances (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
uuid TEXT NOT NULL UNIQUE,
|
|
campus_uuid TEXT NOT NULL,
|
|
fqdn TEXT NOT NULL,
|
|
fingerprint TEXT NOT NULL,
|
|
status TEXT NOT NULL DEFAULT 'pending',
|
|
last_seen_at INTEGER NOT NULL,
|
|
created_at INTEGER NOT NULL,
|
|
UNIQUE(campus_uuid, fqdn, fingerprint)
|
|
);
|
|
CREATE INDEX IF NOT EXISTS idx_federation_instances_campus
|
|
ON federation_instances(campus_uuid, status, fqdn);
|
|
CREATE TABLE IF NOT EXISTS federation_instance_capabilities (
|
|
instance_uuid TEXT PRIMARY KEY, manifest_version INTEGER NOT NULL
|
|
);
|
|
CREATE TABLE IF NOT EXISTS federation_manifest_versions (
|
|
campus_uuid TEXT PRIMARY KEY,
|
|
revision INTEGER NOT NULL,
|
|
manifest_hash TEXT NOT NULL,
|
|
updated_at INTEGER NOT NULL
|
|
);
|
|
CREATE TABLE IF NOT EXISTS federation_manifest_state (
|
|
campus_uuid TEXT PRIMARY KEY,
|
|
controller_public_key TEXT NOT NULL,
|
|
controller_fingerprint TEXT NOT NULL,
|
|
applied_revision INTEGER NOT NULL,
|
|
manifest_json TEXT NOT NULL,
|
|
applied_at INTEGER NOT NULL
|
|
);
|
|
`)
|
|
return err
|
|
}
|
|
|
|
func (s *Store) IssueCampusToken(campusUUID, label string) (_ string, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("IssueCampusToken", resultErr) }()
|
|
if s.ReadOnly {
|
|
return "", ErrReadOnly
|
|
}
|
|
raw := make([]byte, 32)
|
|
if _, err := rand.Read(raw); err != nil {
|
|
return "", err
|
|
}
|
|
token := "pwc_" + base64.RawURLEncoding.EncodeToString(raw)
|
|
hash := sha256.Sum256([]byte(token))
|
|
err := s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
|
|
var mode string
|
|
if err := tx.QueryRowContext(ctx, `SELECT authority_mode FROM campuses WHERE uuid=`+s.sqlParam(1)+` AND enabled=1`, campusUUID).Scan(&mode); err != nil {
|
|
return err
|
|
}
|
|
if mode != "controller" {
|
|
return namespaceValidationError("campus is not a controller")
|
|
}
|
|
_, err := tx.ExecContext(ctx, `
|
|
INSERT INTO campus_tokens (
|
|
campus_uuid, token_hash, label, created_at
|
|
)
|
|
VALUES (`+s.sqlParam(1)+`, `+s.sqlParam(2)+`, `+s.sqlParam(3)+`, `+s.sqlParam(4)+`)
|
|
`, campusUUID, hex.EncodeToString(hash[:]), strings.TrimSpace(label), time.Now().Unix())
|
|
return err
|
|
})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return token, nil
|
|
}
|
|
|
|
func (s *Store) ListCampusTokens() (_ []CampusToken, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("ListCampusTokens", resultErr) }()
|
|
rows, err := s.DB.Query(`
|
|
SELECT id, campus_uuid, label, revoked, created_at, last_used_at
|
|
FROM campus_tokens
|
|
ORDER BY created_at DESC, id DESC
|
|
`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var out []CampusToken
|
|
for rows.Next() {
|
|
var token CampusToken
|
|
var revoked int
|
|
if err := rows.Scan(
|
|
&token.ID, &token.CampusUUID, &token.Label, &revoked,
|
|
&token.CreatedAt, &token.LastUsedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
token.Revoked = revoked != 0
|
|
out = append(out, token)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func (s *Store) RevokeCampusToken(id int64) (resultErr error) {
|
|
defer func() { resultErr = s.sqlError("RevokeCampusToken", resultErr) }()
|
|
if s.ReadOnly {
|
|
return ErrReadOnly
|
|
}
|
|
return s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
|
|
result, err := tx.ExecContext(ctx, `UPDATE campus_tokens SET revoked=1 WHERE id=`+s.sqlParam(1), id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
n, err := result.RowsAffected()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n != 1 {
|
|
return sql.ErrNoRows
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func (s *Store) RegisterFederationInstance(
|
|
token, fqdn, fingerprint, publicKeyRaw, signatureRaw string,
|
|
capabilities ...FederationCapabilities,
|
|
) (_ *Campus, _ *FederationInstance, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("RegisterFederationInstance", resultErr) }()
|
|
if s.ReadOnly {
|
|
return nil, nil, ErrReadOnly
|
|
}
|
|
fqdn = normalizeDomainHost(fqdn)
|
|
fingerprint = strings.ToLower(strings.TrimSpace(fingerprint))
|
|
if fqdn == "" || fingerprint == "" {
|
|
return nil, nil, namespaceValidationError("FQDN and fingerprint are required")
|
|
}
|
|
publicKey, err := base64.RawStdEncoding.DecodeString(publicKeyRaw)
|
|
if err != nil || len(publicKey) != ed25519.PublicKeySize {
|
|
return nil, nil, namespaceValidationError("invalid instance public key")
|
|
}
|
|
publicHash := sha256.Sum256(publicKey)
|
|
expectedFingerprint := "sha256:" + hex.EncodeToString(publicHash[:])
|
|
if fingerprint != expectedFingerprint {
|
|
return nil, nil, namespaceValidationError("instance fingerprint does not match public key")
|
|
}
|
|
version := 1
|
|
if len(capabilities) > 1 {
|
|
return nil, nil, namespaceValidationError("invalid capabilities")
|
|
}
|
|
if len(capabilities) == 1 {
|
|
c := capabilities[0]
|
|
if c.ManifestVersion != 0 && c.ManifestVersion != 1 && c.ManifestVersion != 2 {
|
|
return nil, nil, namespaceValidationError("unsupported manifest capability")
|
|
}
|
|
if c.ManifestVersion == 2 {
|
|
proof, e := base64.RawStdEncoding.DecodeString(c.Signature)
|
|
if e != nil || !ed25519.Verify(publicKey, []byte(FederationCapabilityMessage(fqdn, token)), proof) {
|
|
return nil, nil, namespaceValidationError("invalid capability signature")
|
|
}
|
|
version = 2
|
|
}
|
|
}
|
|
signature, err := base64.RawStdEncoding.DecodeString(signatureRaw)
|
|
if err != nil || !ed25519.Verify(
|
|
ed25519.PublicKey(publicKey),
|
|
[]byte(fqdn+"\n"+strings.TrimSpace(token)),
|
|
signature,
|
|
) {
|
|
return nil, nil, namespaceValidationError("invalid instance proof-of-possession")
|
|
}
|
|
hash := sha256.Sum256([]byte(strings.TrimSpace(token)))
|
|
tokenHash := hex.EncodeToString(hash[:])
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
|
defer cancel()
|
|
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
defer tx.Rollback()
|
|
if err = s.lockFederationWrite(ctx, tx); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
var campusUUID string
|
|
err = tx.QueryRow(`
|
|
SELECT campus_tokens.campus_uuid
|
|
FROM campus_tokens
|
|
JOIN campuses
|
|
ON campuses.uuid = campus_tokens.campus_uuid
|
|
AND campuses.authority_mode = 'controller' AND campuses.enabled=1
|
|
WHERE campus_tokens.token_hash = `+s.sqlParam(1)+`
|
|
AND campus_tokens.revoked = 0
|
|
`, tokenHash).Scan(&campusUUID)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, nil, namespaceValidationError("invalid or revoked campus token")
|
|
}
|
|
return nil, nil, err
|
|
}
|
|
|
|
now := time.Now().Unix()
|
|
var exactIdentityCount, otherFingerprintCount int
|
|
if err := tx.QueryRow(`
|
|
SELECT
|
|
COALESCE(sum(CASE WHEN fingerprint = `+s.sqlParam(1)+` THEN 1 ELSE 0 END), 0),
|
|
COALESCE(sum(CASE WHEN fingerprint != `+s.sqlParam(2)+` THEN 1 ELSE 0 END), 0)
|
|
FROM federation_instances
|
|
WHERE campus_uuid = `+s.sqlParam(3)+` AND fqdn = `+s.sqlParam(4)+`
|
|
`, fingerprint, fingerprint, campusUUID, fqdn).Scan(
|
|
&exactIdentityCount,
|
|
&otherFingerprintCount,
|
|
); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if exactIdentityCount == 0 && otherFingerprintCount > 0 {
|
|
log.Printf(
|
|
"WARNING federation instance fingerprint changed: campus=%s fqdn=%s new_fingerprint=%s",
|
|
campusUUID,
|
|
fqdn,
|
|
fingerprint,
|
|
)
|
|
}
|
|
|
|
if _, err = tx.Exec(`
|
|
UPDATE campus_tokens SET last_used_at = `+s.sqlParam(1)+` WHERE token_hash = `+s.sqlParam(2)+`
|
|
`, now, tokenHash); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if _, err = tx.Exec(`
|
|
INSERT INTO federation_instances (
|
|
uuid, campus_uuid, fqdn, fingerprint, status,
|
|
last_seen_at, created_at
|
|
)
|
|
VALUES (`+s.sqlParam(1)+`, `+s.sqlParam(2)+`, `+s.sqlParam(3)+`, `+s.sqlParam(4)+`, 'pending', `+s.sqlParam(5)+`, `+s.sqlParam(6)+`)
|
|
ON CONFLICT(campus_uuid, fqdn, fingerprint)
|
|
DO UPDATE SET last_seen_at = excluded.last_seen_at
|
|
`, uuid.NewString(), campusUUID, fqdn, fingerprint, now, now); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if _, err = tx.Exec(`INSERT INTO federation_instance_capabilities(instance_uuid,manifest_version) SELECT uuid,`+s.sqlParam(1)+` FROM federation_instances WHERE campus_uuid=`+s.sqlParam(2)+` AND fqdn=`+s.sqlParam(3)+` AND fingerprint=`+s.sqlParam(4)+` ON CONFLICT(instance_uuid) DO UPDATE SET manifest_version=excluded.manifest_version`, version, campusUUID, fqdn, fingerprint); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if err = tx.Commit(); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
campus, err := s.GetCampusByUUID(campusUUID)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
instance, err := s.GetFederationInstance(campusUUID, fqdn, fingerprint)
|
|
return campus, instance, err
|
|
}
|
|
|
|
type FederationCapabilities struct {
|
|
ManifestVersion int
|
|
Signature string
|
|
}
|
|
|
|
func FederationCapabilityMessage(fqdn, token string) string {
|
|
return normalizeDomainHost(fqdn) + "\n" + strings.TrimSpace(token) + "\nmanifest=2"
|
|
}
|
|
|
|
func (s *Store) GetFederationInstance(
|
|
campusUUID, fqdn, fingerprint string,
|
|
) (_ *FederationInstance, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("GetFederationInstance", resultErr) }()
|
|
row := s.DB.QueryRow(`
|
|
SELECT id, uuid, campus_uuid, fqdn, fingerprint, status,
|
|
last_seen_at, created_at
|
|
FROM federation_instances
|
|
WHERE campus_uuid = `+s.sqlParam(1)+` AND fqdn = `+s.sqlParam(2)+` AND fingerprint = `+s.sqlParam(3)+`
|
|
`, campusUUID, fqdn, fingerprint)
|
|
var instance FederationInstance
|
|
err := row.Scan(
|
|
&instance.ID, &instance.UUID, &instance.CampusUUID,
|
|
&instance.FQDN, &instance.Fingerprint, &instance.Status,
|
|
&instance.LastSeenAt, &instance.CreatedAt,
|
|
)
|
|
return &instance, err
|
|
}
|
|
|
|
func (s *Store) ListFederationInstances(
|
|
campusUUID string,
|
|
approvedOnly bool,
|
|
) (_ []FederationInstance, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("ListFederationInstances", resultErr) }()
|
|
query := `
|
|
SELECT id, uuid, campus_uuid, fqdn, fingerprint, status,
|
|
last_seen_at, created_at
|
|
FROM federation_instances
|
|
WHERE campus_uuid = ` + s.sqlParam(1) + ``
|
|
if approvedOnly {
|
|
query += ` AND status = 'approved'`
|
|
}
|
|
query += ` ORDER BY fqdn, created_at`
|
|
rows, err := s.DB.Query(query, campusUUID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var out []FederationInstance
|
|
for rows.Next() {
|
|
var instance FederationInstance
|
|
if err := rows.Scan(
|
|
&instance.ID, &instance.UUID, &instance.CampusUUID,
|
|
&instance.FQDN, &instance.Fingerprint, &instance.Status,
|
|
&instance.LastSeenAt, &instance.CreatedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, instance)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
func (s *Store) SetFederationInstanceStatus(id int64, status string) (resultErr error) {
|
|
defer func() { resultErr = s.sqlError("SetFederationInstanceStatus", resultErr) }()
|
|
if s.ReadOnly {
|
|
return ErrReadOnly
|
|
}
|
|
if status != "approved" && status != "revoked" {
|
|
return namespaceValidationError("invalid instance status")
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
|
defer cancel()
|
|
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
if err = s.lockFederationWrite(ctx, tx); err != nil {
|
|
return err
|
|
}
|
|
result, err := tx.Exec(`
|
|
UPDATE federation_instances SET status = `+s.sqlParam(1)+` WHERE id = `+s.sqlParam(2)+`
|
|
`, status, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
affected, err := result.RowsAffected()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if affected == 0 {
|
|
return sql.ErrNoRows
|
|
}
|
|
if status == "revoked" {
|
|
if _, err := tx.Exec(`
|
|
UPDATE domains
|
|
SET enabled = 0
|
|
WHERE (campus_uuid, instance_fqdn, instance_fingerprint) = (
|
|
SELECT campus_uuid, fqdn, fingerprint
|
|
FROM federation_instances
|
|
WHERE id = `+s.sqlParam(1)+`
|
|
)
|
|
`, id); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return tx.Commit()
|
|
}
|