gpt-load/internal/catalog/client.go

package catalog

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"
	"unicode"

	"gpt-load/internal/platform/httpclient"
)

const (
	modelsDevEndpoint   = "https://models.dev/api.json"
	maxCatalogBodyBytes = int64(32 * 1024 * 1024)
)

// Client conditionally downloads and validates the fixed Models.dev catalog.
type Client struct {
	httpClient    *http.Client
	clientManager *httpclient.HTTPClientManager
	proxyProvider httpclient.OutboundProxyProvider
	httpConfig    httpclient.Config
	endpoint      string
	now           func() time.Time
}

// NewClient constructs the production Models.dev client from the shared HTTP
// client manager. The endpoint is intentionally not an argument.
func NewClient(
	manager *httpclient.HTTPClientManager,
	proxyProvider httpclient.OutboundProxyProvider,
) *Client {
	if manager == nil {
		manager = httpclient.NewHTTPClientManager()
	}
	return &Client{
		clientManager: manager,
		proxyProvider: proxyProvider,
		httpConfig: httpclient.Config{
			ConnectTimeout:        15 * time.Second,
			RequestTimeout:        30 * time.Second,
			IdleConnTimeout:       90 * time.Second,
			MaxIdleConns:          10,
			MaxIdleConnsPerHost:   2,
			ResponseHeaderTimeout: 30 * time.Second,
			DisableCompression:    false,
			ForceAttemptHTTP2:     true,
			TLSHandshakeTimeout:   10 * time.Second,
			ExpectContinueTimeout: time.Second,
		},
		endpoint: modelsDevEndpoint,
		now:      time.Now,
	}
}

func newClientForTest(httpClient *http.Client, endpoint string, now func() time.Time) *Client {
	return &Client{httpClient: httpClient, endpoint: endpoint, now: now}
}

func (client *Client) httpClientForSync() (*http.Client, error) {
	if client.httpClient != nil {
		return client.httpClient, nil
	}
	if client.clientManager == nil {
		return nil, fmt.Errorf("catalog HTTP client is unavailable")
	}
	if client.proxyProvider != nil {
		httpClient, err := client.clientManager.NewClientForOutboundProxy(
			&client.httpConfig,
			client.proxyProvider(),
		)
		if err != nil {
			return nil, fmt.Errorf("initialize catalog outbound proxy: %w", err)
		}
		return httpClient, nil
	}
	return client.clientManager.GetClient(&client.httpConfig), nil
}

// Sync performs one conditional fetch. It never publishes or writes cache
// state; a 200 result is returned only after the raw document fully validates.
func (client *Client) Sync(ctx context.Context, previous Metadata) (SyncResult, error) {
	if client == nil || client.endpoint == "" || client.now == nil {
		return SyncResult{}, fmt.Errorf("catalog client is not initialized")
	}
	httpClient, err := client.httpClientForSync()
	if err != nil {
		return SyncResult{}, err
	}
	request, err := http.NewRequestWithContext(ctx, http.MethodGet, client.endpoint, nil)
	if err != nil {
		return SyncResult{}, fmt.Errorf("create Models.dev request: %w", err)
	}
	request.Header.Set("Accept", "application/json")
	if previous.ETag != "" {
		request.Header.Set("If-None-Match", previous.ETag)
	}
	if previous.LastModified != "" {
		request.Header.Set("If-Modified-Since", previous.LastModified)
	}

	response, err := httpClient.Do(request)
	if err != nil {
		return SyncResult{}, fmt.Errorf("request Models.dev catalog: %w", err)
	}
	defer func() {
		_ = response.Body.Close()
	}()

	checkedAt := client.now().UnixMilli()
	switch response.StatusCode {
	case http.StatusNotModified:
		metadata := previous
		metadata.CheckedAtMillis = checkedAt
		return SyncResult{Metadata: metadata, NotModified: true}, nil
	case http.StatusOK:
	default:
		return SyncResult{}, fmt.Errorf("Models.dev catalog returned HTTP %d", response.StatusCode)
	}

	if response.ContentLength > maxCatalogBodyBytes {
		return SyncResult{}, fmt.Errorf("Models.dev catalog exceeds 32 MiB limit")
	}
	raw, err := io.ReadAll(io.LimitReader(response.Body, maxCatalogBodyBytes+1))
	if err != nil {
		return SyncResult{}, fmt.Errorf("read Models.dev catalog: %w", err)
	}
	if int64(len(raw)) > maxCatalogBodyBytes {
		return SyncResult{}, fmt.Errorf("Models.dev catalog exceeds 32 MiB limit")
	}
	modelsDevSnapshot, err := Parse(bytes.NewReader(raw))
	if err != nil {
		return SyncResult{}, fmt.Errorf("parse Models.dev catalog: %w", err)
	}
	snapshot, err := MergeOfficial(modelsDevSnapshot)
	if err != nil {
		return SyncResult{}, err
	}
	metadata := Metadata{
		ETag:                    response.Header.Get("ETag"),
		LastModified:            response.Header.Get("Last-Modified"),
		CheckedAtMillis:         checkedAt,
		SuccessfulFetchAtMillis: checkedAt,
	}
	if err := validateMetadata(metadata, true); err != nil {
		return SyncResult{}, err
	}
	return SyncResult{
		Metadata: metadata,
		RawJSON:  append([]byte(nil), raw...),
		Snapshot: snapshot,
	}, nil
}

func validateMetadata(metadata Metadata, requireSuccessfulFetch bool) error {
	if requireSuccessfulFetch && metadata.SuccessfulFetchAtMillis <= 0 {
		return fmt.Errorf("successful fetch timestamp must be positive")
	}
	if metadata.CheckedAtMillis < 0 {
		return fmt.Errorf("checked timestamp must be non-negative")
	}
	for name, value := range map[string]string{
		"ETag":          metadata.ETag,
		"Last-Modified": metadata.LastModified,
	} {
		if len(value) > 8*1024 {
			return fmt.Errorf("%s validator is too large", name)
		}
		for _, character := range value {
			if unicode.IsControl(character) || strings.ContainsRune("\r\n", character) {
				return fmt.Errorf("%s validator contains control characters", name)
			}
		}
	}
	return nil
}