feat(storage): add native PostgreSQL runtime and verified offline application import
Build and publish container images / images (push) Failing after 12m29s

This commit is contained in:
Anya Tokugawa committed 2026-11-15 05:47:14 +09:00
1 parent 96065d1e89
commit 0ba1dcfef0
243 files changed
+21441 -3090

No files matched your search

+162 -109
View File
@@ -1,6 +1,7 @@
package store
import (
"context"
"crypto/ed25519"
"crypto/rand"
"crypto/sha256"
@@ -40,26 +41,35 @@ func (s *Store) ApplyManagedCampusSnapshot(
domains []Domain,
localInstanceFQDN string,
transport string,
) error {
if campus.UUID == "" || campus.FQDN == "" {
return errors.New("invalid managed campus snapshot")
) (resultErr error) {
defer func() { resultErr = s.sqlError("ApplyManagedCampusSnapshot", resultErr) }()
if s.ReadOnly {
return ErrReadOnly
}
tx, err := s.DB.Begin()
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 := tx.Exec(`UPDATE federation_manifest_state SET applied_at=applied_at WHERE campus_uuid=?`, campus.UUID); err != nil {
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=?`, campus.UUID).Scan(&pinned); err != nil {
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 errors.New("unsigned snapshot rejected for a pinned Campus")
return namespaceValidationError("unsigned snapshot rejected for a pinned Campus")
}
if err := applyManagedCampusSnapshotTx(tx, campus, domains, localInstanceFQDN, transport); err != nil {
if err := s.applyManagedCampusSnapshotTx(tx, campus, domains, localInstanceFQDN, transport); err != nil {
return err
}
return tx.Commit()
@@ -67,31 +77,31 @@ func (s *Store) ApplyManagedCampusSnapshot(
// applyManagedCampusSnapshotTx never commits independently: signed manifests,
// their checkpoint and the inherited administrator projection share one commit.
func applyManagedCampusSnapshotTx(tx *sql.Tx, campus Campus, domains []Domain, localInstanceFQDN, transport string) error {
func (s *Store) applyManagedCampusSnapshotTx(tx *sql.Tx, campus Campus, domains []Domain, localInstanceFQDN, transport string) error {
if campus.UUID == "" || campus.FQDN == "" {
return errors.New("invalid managed campus snapshot")
return namespaceValidationError("invalid managed campus snapshot")
}
var authority string
err := tx.QueryRow(`SELECT authority_mode FROM campuses WHERE uuid=?`, campus.UUID).Scan(&authority)
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 errors.New("managed Campus snapshot cannot replace a local authority")
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 errors.New("invalid managed domain snapshot")
return namespaceValidationError("invalid managed domain snapshot")
}
seen[domain.UUID] = true
var owner string
err := tx.QueryRow(`SELECT campus_uuid FROM domains WHERE uuid=?`, domain.UUID).Scan(&owner)
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 errors.New("managed Campus snapshot cannot claim another Campus Domain")
return namespaceValidationError("managed Campus snapshot cannot claim another Campus Domain")
}
}
now := time.Now().Unix()
@@ -101,7 +111,7 @@ func applyManagedCampusSnapshotTx(tx *sql.Tx, campus Campus, domains []Domain, l
fqdn, controller_transport, last_contact_at,
last_contact_error, enabled, created_at
)
VALUES (?, ?, ?, ?, 'managed', ?, ?, ?, '', 1, ?)
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,
@@ -118,20 +128,22 @@ func applyManagedCampusSnapshotTx(tx *sql.Tx, campus Campus, domains []Domain, l
return err
}
if _, err = tx.Exec(`
UPDATE domains SET enabled = 0 WHERE campus_uuid = ?
UPDATE domains SET enabled = 0 WHERE campus_uuid = `+s.sqlParam(1)+`
`, campus.UUID); err != nil {
return err
}
var hasConfigTable int
if err := tx.QueryRow(`
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
return err
}
}
for _, domain := range domains {
if domain.UUID == "" || domain.CampusUUID != campus.UUID {
return errors.New("invalid managed domain snapshot")
return namespaceValidationError("invalid managed domain snapshot")
}
placement := "remote"
if normalizeDomainHost(domain.InstanceFQDN) ==
@@ -144,7 +156,7 @@ func applyManagedCampusSnapshotTx(tx *sql.Tx, campus Campus, domains []Domain, l
campus_uuid, placement, instance_fqdn,
instance_fingerprint
)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
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,
@@ -165,20 +177,20 @@ func applyManagedCampusSnapshotTx(tx *sql.Tx, campus Campus, domains []Domain, l
if _, err = tx.Exec(`
INSERT INTO config (domain_uuid, key, value, updated_at)
VALUES (
?, 'locale',
`+s.sqlParam(1)+`, 'locale',
CASE
WHEN lower(?) LIKE 'ja%' THEN 'ja'
WHEN lower(`+s.sqlParam(2)+`) LIKE 'ja%' THEN 'ja'
ELSE 'en'
END,
strftime('%s','now')
`+s.sqlParam(3)+`
)
ON CONFLICT(domain_uuid, key) DO NOTHING
`, domain.UUID, campus.DefaultLang); err != nil {
`, domain.UUID, campus.DefaultLang, now); err != nil {
return err
}
}
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
if err = s.projectCampusAdminMembershipsContext(context.Background(), tx); err != nil {
return err
}
return nil
@@ -194,74 +206,82 @@ func boolToInt(value bool) int {
func (s *Store) RecordCampusContact(
campusUUID string,
contactError string,
) error {
) (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 = ?, last_contact_error = ?
WHERE uuid = ? AND authority_mode = 'managed'
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) deleteManagedCampus(id int64) error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
func (s *Store) deleteManagedCampusTx(ctx context.Context, tx *sql.Tx, id int64) error {
var err error
var campusUUID string
if err := tx.QueryRow(`
if err := tx.QueryRowContext(ctx, `
SELECT uuid FROM campuses
WHERE id = ? AND authority_mode = 'managed'
WHERE id = `+s.sqlParam(1)+` AND authority_mode = 'managed'
`, id).Scan(&campusUUID); err != nil {
return err
}
var configTable int
if err := tx.QueryRow(`
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
return err
}
}
if configTable > 0 {
if _, err := tx.Exec(`
if _, err := tx.ExecContext(ctx, `
DELETE FROM config
WHERE domain_uuid IN (
SELECT uuid FROM domains WHERE campus_uuid = ?
SELECT uuid FROM domains WHERE campus_uuid = `+s.sqlParam(1)+`
)
`, campusUUID); err != nil {
return err
}
}
if _, err := tx.Exec(`
if _, err := tx.ExecContext(ctx, `
DELETE FROM paths
WHERE domain_uuid IN (
SELECT uuid FROM domains WHERE campus_uuid = ?
SELECT uuid FROM domains WHERE campus_uuid = `+s.sqlParam(1)+`
)
`, campusUUID); err != nil {
return err
}
if _, err := tx.Exec(`
DELETE FROM domains WHERE campus_uuid = ?
if _, err := tx.ExecContext(ctx, `
DELETE FROM domains WHERE campus_uuid = `+s.sqlParam(1)+`
`, campusUUID); err != nil {
return err
}
if _, err := tx.Exec(`
DELETE FROM campuses WHERE id = ?
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 = projectCampusAdminMembershipsTx(tx); err != nil {
if err = s.projectCampusAdminMembershipsContext(ctx, tx); err != nil {
return err
}
return tx.Commit()
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,
@@ -306,13 +326,10 @@ func (s *Store) EnsureFederationSchema() error {
return err
}
func (s *Store) IssueCampusToken(campusUUID, label string) (string, error) {
campus, err := s.GetCampusByUUID(campusUUID)
if err != nil {
return "", err
}
if campus.AuthorityMode != "controller" {
return "", errors.New("campus is not a controller")
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 {
@@ -320,19 +337,30 @@ func (s *Store) IssueCampusToken(campusUUID, label string) (string, error) {
}
token := "pwc_" + base64.RawURLEncoding.EncodeToString(raw)
hash := sha256.Sum256([]byte(token))
_, err = s.DB.Exec(`
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 (?, ?, ?, ?)
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, error) {
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
@@ -358,54 +386,62 @@ func (s *Store) ListCampusTokens() ([]CampusToken, error) {
return out, rows.Err()
}
func (s *Store) RevokeCampusToken(id int64) error {
result, err := s.DB.Exec(`
UPDATE campus_tokens SET revoked = 1 WHERE id = ?
`, id)
if err != nil {
return err
func (s *Store) RevokeCampusToken(id int64) (resultErr error) {
defer func() { resultErr = s.sqlError("RevokeCampusToken", resultErr) }()
if s.ReadOnly {
return ErrReadOnly
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return sql.ErrNoRows
}
return nil
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, error) {
) (_ *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, errors.New("FQDN and fingerprint are required")
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, errors.New("invalid instance public key")
return nil, nil, namespaceValidationError("invalid instance public key")
}
publicHash := sha256.Sum256(publicKey)
expectedFingerprint := "sha256:" + hex.EncodeToString(publicHash[:])
if fingerprint != expectedFingerprint {
return nil, nil, errors.New("instance fingerprint does not match public key")
return nil, nil, namespaceValidationError("instance fingerprint does not match public key")
}
version := 1
if len(capabilities) > 1 {
return nil, nil, errors.New("invalid capabilities")
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, errors.New("unsupported manifest capability")
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, errors.New("invalid capability signature")
return nil, nil, namespaceValidationError("invalid capability signature")
}
version = 2
}
@@ -416,36 +452,46 @@ func (s *Store) RegisterFederationInstance(
[]byte(fqdn+"\n"+strings.TrimSpace(token)),
signature,
) {
return nil, nil, errors.New("invalid instance proof-of-possession")
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 = s.DB.QueryRow(`
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'
WHERE campus_tokens.token_hash = ?
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, errors.New("invalid or revoked campus token")
return nil, nil, namespaceValidationError("invalid or revoked campus token")
}
return nil, nil, err
}
now := time.Now().Unix()
var exactIdentityCount, otherFingerprintCount int
if err := s.DB.QueryRow(`
if err := tx.QueryRow(`
SELECT
COALESCE(sum(CASE WHEN fingerprint = ? THEN 1 ELSE 0 END), 0),
COALESCE(sum(CASE WHEN fingerprint != ? THEN 1 ELSE 0 END), 0)
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 = ? AND fqdn = ?
WHERE campus_uuid = `+s.sqlParam(3)+` AND fqdn = `+s.sqlParam(4)+`
`, fingerprint, fingerprint, campusUUID, fqdn).Scan(
&exactIdentityCount,
&otherFingerprintCount,
@@ -460,13 +506,9 @@ func (s *Store) RegisterFederationInstance(
fingerprint,
)
}
tx, err := s.DB.Begin()
if err != nil {
return nil, nil, err
}
defer tx.Rollback()
if _, err = tx.Exec(`
UPDATE campus_tokens SET last_used_at = ? WHERE token_hash = ?
UPDATE campus_tokens SET last_used_at = `+s.sqlParam(1)+` WHERE token_hash = `+s.sqlParam(2)+`
`, now, tokenHash); err != nil {
return nil, nil, err
}
@@ -475,13 +517,13 @@ func (s *Store) RegisterFederationInstance(
uuid, campus_uuid, fqdn, fingerprint, status,
last_seen_at, created_at
)
VALUES (?, ?, ?, ?, 'pending', ?, ?)
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,? FROM federation_instances WHERE campus_uuid=? AND fqdn=? AND fingerprint=? ON CONFLICT(instance_uuid) DO UPDATE SET manifest_version=excluded.manifest_version`, version, campusUUID, fqdn, fingerprint); err != nil {
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 {
@@ -507,12 +549,13 @@ func FederationCapabilityMessage(fqdn, token string) string {
func (s *Store) GetFederationInstance(
campusUUID, fqdn, fingerprint string,
) (*FederationInstance, error) {
) (_ *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 = ? AND fqdn = ? AND fingerprint = ?
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(
@@ -526,12 +569,13 @@ func (s *Store) GetFederationInstance(
func (s *Store) ListFederationInstances(
campusUUID string,
approvedOnly bool,
) ([]FederationInstance, error) {
) (_ []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 = ?`
WHERE campus_uuid = ` + s.sqlParam(1) + ``
if approvedOnly {
query += ` AND status = 'approved'`
}
@@ -556,17 +600,26 @@ func (s *Store) ListFederationInstances(
return out, rows.Err()
}
func (s *Store) SetFederationInstanceStatus(id int64, status string) error {
if status != "approved" && status != "revoked" {
return errors.New("invalid instance status")
func (s *Store) SetFederationInstanceStatus(id int64, status string) (resultErr error) {
defer func() { resultErr = s.sqlError("SetFederationInstanceStatus", resultErr) }()
if s.ReadOnly {
return ErrReadOnly
}
tx, err := s.DB.Begin()
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 = ? WHERE id = ?
UPDATE federation_instances SET status = `+s.sqlParam(1)+` WHERE id = `+s.sqlParam(2)+`
`, status, id)
if err != nil {
return err
@@ -585,7 +638,7 @@ func (s *Store) SetFederationInstanceStatus(id int64, status string) error {
WHERE (campus_uuid, instance_fqdn, instance_fingerprint) = (
SELECT campus_uuid, fqdn, fingerprint
FROM federation_instances
WHERE id = ?
WHERE id = `+s.sqlParam(1)+`
)
`, id); err != nil {
return err