Fix race conditions in concurrent server publishing (#528)

## Summary

Fixes race conditions in concurrent server publishing that could result
in data integrity violations:
- Multiple versions marked as `isLatest=true` for the same server
- Duplicate (serverId, version) combinations
- Same server name assigned different serverIDs

## Solution

Uses two complementary approaches for correctness:

### 1. PostgreSQL Advisory Locks
- Serializes concurrent publishes per server name using
`pg_advisory_xact_lock`
- Uses FNV-1a hash to convert server name to lock ID
- Transaction-scoped locks auto-release on commit/rollback
- **Required after #465**: The serverId introduction means concurrent
publishes must atomically coordinate whether to reuse an existing
serverId (for additional versions) or generate a new one (for first
version). Without locks, race conditions would assign different
serverIDs to versions of the same server.

### 2. Unique Constraints (Migration 007)
Two new indexes provide data integrity guarantees:
- **idx_unique_server_version**: Ensures (serverId, version) is unique
across all versions
- **idx_unique_latest_version**: Partial index ensuring only one version
per serverId has `isLatest=true`

These constraints serve as defense-in-depth safety nets. Even if lock
logic had a bug, the database would reject integrity violations.

Also drops redundant `idx_servers_version_id` since `version_id` is
already the primary key.

## Why WithPublishLock validation is needed after #465

The `ctx.Err()` check at the start of `WithPublishLock` is critical
because:
1. After #465 introduced serverId, the publish flow must atomically
check existing versions and assign/reuse serverId
2. If the context is cancelled during lock acquisition, we could
deadlock
3. Checking ctx validity before acquiring locks prevents these deadlocks

## Testing

Added `TestPublishConcurrentVersionsNoRace` with 100 concurrent
goroutines publishing different versions of the same server. All succeed
with:
- Exactly one version marked as latest
- All versions sharing the same serverId
- No duplicate (serverId, version) combinations

NB: this only covers the in memory db, not the postgres db. It'd be nice
to write tests for this one as well, but our current setup is a bit
annoying for this. Separately looking into ways to easily run all our
tests with real postgres and ideally scrap memory.go completely.
This commit is contained in:
adam jones 2025-09-22 12:16:05 +01:00 • committed by GitHub
commit 60c801c0c2
No known key found for this signature in database
GPG key ID: B5690EEEBB952194

View file

@ -3,6 +3,8 @@ package service
import (
"context"
"fmt"
"sync"
"testing"
"github.com/modelcontextprotocol/registry/internal/config"
@ -377,3 +379,52 @@ func TestGetAllVersionsByServerID(t *testing.T) {
})
}
}
func TestPublishConcurrentVersionsNoRace(t *testing.T) {
memDB := database.NewMemoryDB()
service := NewRegistryService(memDB, &config.Config{EnableRegistryValidation: false})
const concurrency = 100
results := make([]*apiv0.ServerJSON, concurrency)
errors := make([]error, concurrency)
var wg sync.WaitGroup
for i := range concurrency {
wg.Add(1)
go func(idx int) {
defer wg.Done()
result, err := service.Publish(apiv0.ServerJSON{
Name: "com.example/test-concurrent",
Description: fmt.Sprintf("Version %d", idx),
Version: fmt.Sprintf("1.0.%d", idx),
})
results[idx] = result
errors[idx] = err
}(i)
}
wg.Wait()
for i, err := range errors {
assert.NoError(t, err, "publish %d failed", i)
}
var sharedServerID string
for i, result := range results {
if result != nil && result.Meta != nil && result.Meta.Official != nil {
if sharedServerID == "" {
sharedServerID = result.Meta.Official.ServerID
}
assert.Equal(t, sharedServerID, result.Meta.Official.ServerID,
"version %d has different serverID", i)
}
}
latestCount := 0
for _, result := range results {
if result != nil && result.Meta != nil && result.Meta.Official != nil &&
result.Meta.Official.IsLatest {
latestCount++
}
}
assert.Equal(t, 1, latestCount, "should have exactly one latest version")
}