perf(schema): compile compose-spec schema once

Validate rebuilt a jsonschema Compiler and recompiled the embedded
compose-spec schema (including loading and resolving the draft 2020-12
meta-schema) on every call. Compile it once behind a sync.Once instead,
which keeps Validate cheap on the loader hot path and makes it safe to
call concurrently without sharing any mutable compiler state.

Switch MustCompile to Compile so a schema compilation failure is
returned as an error instead of panicking. Add a concurrent Validate
test (run with -race) as a regression guard.

Relates to docker/compose#13866

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>

Author: 2 people

schema/schema.go

@@ -24,6 +24,7 @@ import (
 	"fmt"
 	"slices"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/santhosh-tekuri/jsonschema/v6"
@@ -46,22 +47,45 @@ func durationFormatChecker(input any) error {
 //go:embed compose-spec.json
 var Schema string
 
+// compiledSchema is the compose-spec schema compiled once and reused across
+// every Validate call. Compiling the schema (which loads and resolves the
+// draft 2020-12 meta-schema) is expensive and was previously redone on every
+// call; doing it once behind a sync.Once keeps Validate cheap and makes it
+// safe to call from several goroutines without sharing any mutable compiler
+// state. see https://github.com/docker/compose/issues/13866
+var (
+	compiledSchema     *jsonschema.Schema
+	compiledSchemaErr  error
+	compiledSchemaOnce sync.Once
+)
+
+func compileSchema() (*jsonschema.Schema, error) {
+	compiledSchemaOnce.Do(func() {
+		compiler := jsonschema.NewCompiler()
+		shema, err := jsonschema.UnmarshalJSON(strings.NewReader(Schema))
+		if err != nil {
+			compiledSchemaErr = err
+			return
+		}
+		if err := compiler.AddResource("compose-spec.json", shema); err != nil {
+			compiledSchemaErr = err
+			return
+		}
+		compiler.RegisterFormat(&jsonschema.Format{
+			Name:     "duration",
+			Validate: durationFormatChecker,
+		})
+		compiledSchema, compiledSchemaErr = compiler.Compile("compose-spec.json")
+	})
+	return compiledSchema, compiledSchemaErr
+}
+
 // Validate uses the jsonschema to validate the configuration
 func Validate(config map[string]interface{}) error {
-	compiler := jsonschema.NewCompiler()
-	shema, err := jsonschema.UnmarshalJSON(strings.NewReader(Schema))
+	schema, err := compileSchema()
 	if err != nil {
 		return err
 	}
-	err = compiler.AddResource("compose-spec.json", shema)
-	if err != nil {
-		return err
-	}
-	compiler.RegisterFormat(&jsonschema.Format{
-		Name:     "duration",
-		Validate: durationFormatChecker,
-	})
-	schema := compiler.MustCompile("compose-spec.json")
 
 	// santhosh-tekuri doesn't allow derived types
 	// see https://github.com/santhosh-tekuri/jsonschema/pull/240

schema/schema_test.go

@@ -19,6 +19,7 @@ package schema
 import (
 	"os"
 	"strings"
+	"sync"
 	"testing"
 
 	"github.com/santhosh-tekuri/jsonschema/v6"
@@ -250,6 +251,30 @@ func TestValidateVariables(t *testing.T) {
 	assert.NilError(t, Validate(config))
 }
 
+// TestValidateConcurrent ensures Validate can safely be called from several
+// goroutines at once. Run with -race to catch the regression reported in
+// https://github.com/docker/compose/issues/13866 ("concurrent map iteration
+// and map write" while compiling the schema).
+func TestValidateConcurrent(t *testing.T) {
+	config := map[string]any{
+		"services": map[string]any{
+			"foo": map[string]any{
+				"image": "busybox",
+			},
+		},
+	}
+
+	var wg sync.WaitGroup
+	for i := 0; i < 50; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			assert.NilError(t, Validate(config))
+		}()
+	}
+	wg.Wait()
+}
+
 func TestSchema(t *testing.T) {
 	compiler := jsonschema.NewCompiler()
 	json, err := jsonschema.UnmarshalJSON(strings.NewReader(Schema))