+1 -1

.env.appview.example

reviewed

··· 66 66 # ============================================================================== 67 67 68 68 # Log level: debug, info, warn, error (default: info) 69 69 - # ATCR_LOG_LEVEL=info 69 69 + ATCR_LOG_LEVEL=debug 70 70 71 71 # Log formatter: text, json (default: text) 72 72 # ATCR_LOG_FORMATTER=text

+10

.env.hold.example

reviewed

··· 110 110 # - Skips OAuth if records exist 111 111 # 112 112 HOLD_OWNER=did:plc:your-did-here 113 113 + 114 114 + # ============================================================================== 115 115 + # Logging Configuration 116 116 + # ============================================================================== 117 117 + 118 118 + # Log level: debug, info, warn, error (default: info) 119 119 + ATCR_LOG_LEVEL=debug 120 120 + 121 121 + # Log formatter: text, json (default: text) 122 122 + # ATCR_LOG_FORMATTER=text

+102 -151

cmd/appview/serve.go

reviewed

··· 6 6 "encoding/json" 7 7 "fmt" 8 8 "html/template" 9 9 + "log/slog" 9 10 "net/http" 10 11 "os" 11 12 "os/signal" ··· 14 15 "time" 15 16 16 17 "github.com/bluesky-social/indigo/atproto/syntax" 17 17 - "github.com/distribution/distribution/v3/configuration" 18 18 "github.com/distribution/distribution/v3/registry" 19 19 "github.com/distribution/distribution/v3/registry/handlers" 20 20 "github.com/spf13/cobra" ··· 59 59 } 60 60 61 61 func serveRegistry(cmd *cobra.Command, args []string) error { 62 62 - // Initialize structured logging 63 63 - logging.InitLogger(appview.GetLogLevel()) 64 64 - 65 62 // Load configuration from environment variables 66 66 - fmt.Println("Loading configuration from environment variables...") 67 67 - config, err := appview.LoadConfigFromEnv() 63 63 + cfg, err := appview.LoadConfigFromEnv() 68 64 if err != nil { 69 65 return fmt.Errorf("failed to load config from environment: %w", err) 70 66 } 71 71 - fmt.Println("Configuration loaded successfully from environment") 67 67 + 68 68 + // Initialize structured logging 69 69 + logging.InitLogger(cfg.LogLevel) 70 70 + 71 71 + slog.Info("Configuration loaded successfully from environment") 72 72 73 73 // Initialize UI database first (required for all stores) 74 74 - fmt.Println("Initializing UI database...") 75 75 - uiEnabled := appview.GetUIEnabled() 76 76 - dbPath := appview.GetUIDatabasePath() 77 77 - uiDatabase, uiReadOnlyDB, uiSessionStore := db.InitializeDatabase(uiEnabled, dbPath) 74 74 + slog.Info("Initializing UI database", "path", cfg.UI.DatabasePath) 75 75 + uiDatabase, uiReadOnlyDB, uiSessionStore := db.InitializeDatabase(cfg.UI.Enabled, cfg.UI.DatabasePath) 78 76 if uiDatabase == nil { 79 77 return fmt.Errorf("failed to initialize UI database - required for session storage") 80 78 } 81 79 82 80 // Initialize hold health checker 83 83 - fmt.Println("Initializing hold health checker...") 84 84 - cacheTTL := appview.GetHealthCacheTTL() 85 85 - healthChecker := holdhealth.NewChecker(cacheTTL) 81 81 + slog.Info("Initializing hold health checker", "cache_ttl", cfg.Health.CacheTTL) 82 82 + healthChecker := holdhealth.NewChecker(cfg.Health.CacheTTL) 86 83 87 84 // Initialize README cache 88 88 - fmt.Println("Initializing README cache...") 89 89 - readmeCacheTTL := appview.GetReadmeCacheTTL() 90 90 - readmeCache := readme.NewCache(uiDatabase, readmeCacheTTL) 85 85 + slog.Info("Initializing README cache", "cache_ttl", cfg.Health.ReadmeCacheTTL) 86 86 + readmeCache := readme.NewCache(uiDatabase, cfg.Health.ReadmeCacheTTL) 91 87 92 88 // Start background health check worker 93 93 - refreshInterval := appview.GetHealthCheckInterval() 94 89 startupDelay := 5 * time.Second // Wait for hold services to start (Docker compose) 95 90 dbAdapter := holdhealth.NewDBAdapter(uiDatabase) 96 96 - healthWorker := holdhealth.NewWorkerWithStartupDelay(healthChecker, dbAdapter, refreshInterval, startupDelay) 91 91 + healthWorker := holdhealth.NewWorkerWithStartupDelay(healthChecker, dbAdapter, cfg.Health.CheckInterval, startupDelay) 97 92 98 93 // Create context for worker lifecycle management 99 94 workerCtx, workerCancel := context.WithCancel(context.Background()) 100 95 defer workerCancel() // Ensure context is cancelled on all exit paths 101 96 healthWorker.Start(workerCtx) 102 102 - fmt.Printf("Hold health worker started (5s startup delay, %s refresh interval, %s cache TTL)\n", refreshInterval, cacheTTL) 97 97 + slog.Info("Hold health worker started", "startup_delay", startupDelay, "refresh_interval", cfg.Health.CheckInterval, "cache_ttl", cfg.Health.CacheTTL) 103 98 104 99 // Initialize OAuth components 105 105 - fmt.Println("Initializing OAuth components...") 100 100 + slog.Info("Initializing OAuth components") 106 101 107 102 // Create OAuth session storage (SQLite-backed) 108 103 oauthStore := db.NewOAuthStore(uiDatabase) 109 109 - fmt.Println("Using SQLite for OAuth session storage") 104 104 + slog.Info("Using SQLite for OAuth session storage") 110 105 111 106 // Create device store (SQLite-backed) 112 107 deviceStore := db.NewDeviceStore(uiDatabase) 113 113 - fmt.Println("Using SQLite for device storage") 114 114 - 115 115 - // Get base URL from config or environment 116 116 - baseURL := appview.GetBaseURL(config.HTTP.Addr) 117 117 - fmt.Printf("DEBUG: Base URL for OAuth: %s\n", baseURL) 108 108 + slog.Info("Using SQLite for device storage") 118 109 119 119 - // Extract default hold DID for OAuth server and backfill worker 120 120 - // This is used to create sailor profiles on first login and cache captain records 121 121 - // Expected format: "did:web:hold01.atcr.io" 122 122 - // To find a hold's DID, visit: https://hold01.atcr.io/.well-known/did.json 123 123 - // The extraction function normalizes URLs to DIDs for consistency 124 124 - defaultHoldDID := appview.ExtractDefaultHoldDID(config) 110 110 + // Get base URL and default hold DID from config 111 111 + baseURL := cfg.Server.BaseURL 112 112 + defaultHoldDID := cfg.Server.DefaultHoldDID 113 113 + testMode := cfg.Server.TestMode 125 114 126 126 - // Extract test mode from config (needed for OAuth scope configuration) 127 127 - testMode := appview.ExtractTestMode(config) 115 115 + slog.Debug("Base URL for OAuth", "base_url", baseURL) 128 116 if testMode { 129 129 - fmt.Println("TEST_MODE enabled - will use HTTP for local DID resolution and transition:generic scope") 117 117 + slog.Info("TEST_MODE enabled - will use HTTP for local DID resolution and transition:generic scope") 130 118 } 131 119 132 120 // Create OAuth app (indigo client) ··· 135 123 return fmt.Errorf("failed to create OAuth app: %w", err) 136 124 } 137 125 if testMode { 138 138 - fmt.Println("Using OAuth scopes with transition:generic (test mode)") 126 126 + slog.Info("Using OAuth scopes with transition:generic (test mode)") 139 127 } else { 140 140 - fmt.Println("Using OAuth scopes with RPC scope (production mode)") 128 128 + slog.Info("Using OAuth scopes with RPC scope (production mode)") 141 129 } 142 130 143 131 // Invalidate sessions with mismatched scopes on startup ··· 145 133 desiredScopes := oauth.GetDefaultScopes(defaultHoldDID, testMode) 146 134 invalidatedCount, err := oauthStore.InvalidateSessionsWithMismatchedScopes(context.Background(), desiredScopes) 147 135 if err != nil { 148 148 - fmt.Printf("Warning: Failed to invalidate sessions with mismatched scopes: %v\n", err) 136 136 + slog.Warn("Failed to invalidate sessions with mismatched scopes", "error", err) 149 137 } else if invalidatedCount > 0 { 150 150 - fmt.Printf("Invalidated %d OAuth session(s) due to scope changes\n", invalidatedCount) 138 138 + slog.Info("Invalidated OAuth sessions due to scope changes", "count", invalidatedCount) 151 139 } 152 140 153 141 // Create oauth token refresher ··· 168 156 // Create RemoteHoldAuthorizer for hold authorization with caching 169 157 holdAuthorizer := auth.NewRemoteHoldAuthorizer(uiDatabase, testMode) 170 158 middleware.SetGlobalAuthorizer(holdAuthorizer) 171 171 - fmt.Println("Hold authorizer initialized with database caching") 159 159 + slog.Info("Hold authorizer initialized with database caching") 172 160 173 161 // Set global readme cache for middleware 174 162 middleware.SetGlobalReadmeCache(readmeCache) 175 175 - fmt.Println("README cache initialized for manifest push refresh") 163 163 + slog.Info("README cache initialized for manifest push refresh") 164 164 + 165 165 + // Initialize Jetstream workers (background services before HTTP routes) 166 166 + initializeJetstream(uiDatabase, &cfg.Jetstream, defaultHoldDID, testMode) 176 167 177 168 // Initialize UI routes with OAuth app, refresher, device store, health checker, and readme cache 178 178 - uiTemplates, uiRouter := initializeUIRoutes(uiDatabase, uiReadOnlyDB, uiSessionStore, oauthApp, oauthStore, refresher, baseURL, deviceStore, defaultHoldDID, healthChecker, readmeCache) 169 169 + uiTemplates, uiRouter := initializeUIRoutes(cfg.UI.Enabled, uiDatabase, uiReadOnlyDB, uiSessionStore, oauthApp, oauthStore, refresher, baseURL, deviceStore, healthChecker, readmeCache) 179 170 180 171 // Create OAuth server 181 172 oauthServer := oauth.NewServer(oauthApp) ··· 189 180 // Register OAuth post-auth callback for AppView business logic 190 181 // This decouples the OAuth package from AppView-specific dependencies 191 182 oauthServer.SetPostAuthCallback(func(ctx context.Context, did, handle, pdsEndpoint, sessionID string) error { 192 192 - fmt.Printf("DEBUG [appview/callback]: OAuth post-auth callback for DID=%s\n", did) 183 183 + slog.Debug("OAuth post-auth callback", "component", "appview/callback", "did", did) 193 184 194 185 // Parse DID for session resume 195 186 didParsed, err := syntax.ParseDID(did) 196 187 if err != nil { 197 197 - fmt.Printf("WARNING [appview/callback]: Failed to parse DID %s: %v\n", did, err) 188 188 + slog.Warn("Failed to parse DID", "component", "appview/callback", "did", did, "error", err) 198 189 return nil // Non-fatal 199 190 } 200 191 201 192 // Resume OAuth session to get authenticated client 202 193 session, err := oauthApp.ResumeSession(ctx, didParsed, sessionID) 203 194 if err != nil { 204 204 - fmt.Printf("WARNING [appview/callback]: Failed to resume session for DID=%s: %v\n", did, err) 195 195 + slog.Warn("Failed to resume session", "component", "appview/callback", "did", did, "error", err) 205 196 // Fallback: update user without avatar 206 197 _ = db.UpsertUser(uiDatabase, &db.User{ 207 198 DID: did, ··· 217 208 client := atproto.NewClientWithIndigoClient(pdsEndpoint, did, session.APIClient()) 218 209 219 210 // Ensure sailor profile exists (creates with default hold if configured) 220 220 - fmt.Printf("DEBUG [appview/callback]: Ensuring profile exists for %s (defaultHold=%s)\n", did, defaultHoldDID) 211 211 + slog.Debug("Ensuring profile exists", "component", "appview/callback", "did", did, "default_hold_did", defaultHoldDID) 221 212 if err := storage.EnsureProfile(ctx, client, defaultHoldDID); err != nil { 222 222 - fmt.Printf("WARNING [appview/callback]: Failed to ensure profile for %s: %v\n", did, err) 213 213 + slog.Warn("Failed to ensure profile", "component", "appview/callback", "did", did, "error", err) 223 214 // Continue anyway - profile creation is not critical for avatar fetch 224 215 } else { 225 225 - fmt.Printf("DEBUG [appview/callback]: Profile ensured for %s\n", did) 216 216 + slog.Debug("Profile ensured", "component", "appview/callback", "did", did) 226 217 } 227 218 228 219 // Fetch user's profile record from PDS (contains blob references) 229 220 profileRecord, err := client.GetProfileRecord(ctx, did) 230 221 if err != nil { 231 231 - fmt.Printf("WARNING [appview/callback]: Failed to fetch profile record for DID=%s: %v\n", did, err) 222 222 + slog.Warn("Failed to fetch profile record", "component", "appview/callback", "did", did, "error", err) 232 223 // Still update user without avatar 233 224 _ = db.UpsertUser(uiDatabase, &db.User{ 234 225 DID: did, ··· 244 235 var avatarURL string 245 236 if profileRecord.Avatar != nil && profileRecord.Avatar.Ref.Link != "" { 246 237 avatarURL = atproto.BlobCDNURL(did, profileRecord.Avatar.Ref.Link) 247 247 - fmt.Printf("DEBUG [appview/callback]: Constructed avatar URL: %s\n", avatarURL) 238 238 + slog.Debug("Constructed avatar URL", "component", "appview/callback", "avatar_url", avatarURL) 248 239 } 249 240 250 241 // Store user with avatar in database ··· 256 247 LastSeen: time.Now(), 257 248 }) 258 249 if err != nil { 259 259 - fmt.Printf("WARNING [appview/callback]: Failed to store user in database: %v\n", err) 250 250 + slog.Warn("Failed to store user in database", "component", "appview/callback", "error", err) 260 251 return nil // Non-fatal 261 252 } 262 253 263 263 - fmt.Printf("DEBUG [appview/callback]: Stored user with avatar for DID=%s\n", did) 254 254 + slog.Debug("Stored user with avatar", "component", "appview/callback", "did", did) 264 255 265 256 // Migrate profile URL→DID if needed 266 257 profile, err := storage.GetProfile(ctx, client) 267 258 if err != nil { 268 268 - fmt.Printf("WARNING [appview/callback]: Failed to get profile for %s: %v\n", did, err) 259 259 + slog.Warn("Failed to get profile", "component", "appview/callback", "did", did, "error", err) 269 260 return nil // Non-fatal 270 261 } 271 262 ··· 273 264 if profile != nil && profile.DefaultHold != "" { 274 265 // Check if defaultHold is a URL (needs migration) 275 266 if strings.HasPrefix(profile.DefaultHold, "http://") || strings.HasPrefix(profile.DefaultHold, "https://") { 276 276 - fmt.Printf("DEBUG [appview/callback]: Migrating hold URL to DID for %s: %s\n", did, profile.DefaultHold) 267 267 + slog.Debug("Migrating hold URL to DID", "component", "appview/callback", "did", did, "hold_url", profile.DefaultHold) 277 268 278 269 // Resolve URL to DID 279 270 holdDID := atproto.ResolveHoldDIDFromURL(profile.DefaultHold) ··· 281 272 // Update profile with DID 282 273 profile.DefaultHold = holdDID 283 274 if err := storage.UpdateProfile(ctx, client, profile); err != nil { 284 284 - fmt.Printf("WARNING [appview/callback]: Failed to update profile with hold DID for %s: %v\n", did, err) 275 275 + slog.Warn("Failed to update profile with hold DID", "component", "appview/callback", "did", did, "error", err) 285 276 } else { 286 286 - fmt.Printf("DEBUG [appview/callback]: Updated profile with hold DID: %s\n", holdDID) 277 277 + slog.Debug("Updated profile with hold DID", "component", "appview/callback", "hold_did", holdDID) 287 278 } 288 288 - fmt.Printf("DEBUG [oauth/server]: Attempting crew registration for %s at hold %s\n", did, holdDID) 279 279 + slog.Debug("Attempting crew registration", "component", "oauth/server", "did", did, "hold_did", holdDID) 289 280 storage.EnsureCrewMembership(ctx, client, refresher, holdDID) 290 281 } else { 291 282 // Already a DID - use it 292 283 holdDID = profile.DefaultHold 293 284 } 294 285 // Register crew regardless of migration (outside the migration block) 295 295 - fmt.Printf("DEBUG [appview/callback]: Attempting crew registration for %s at hold %s\n", did, holdDID) 286 286 + slog.Debug("Attempting crew registration", "component", "appview/callback", "did", did, "hold_did", holdDID) 296 287 storage.EnsureCrewMembership(ctx, client, refresher, holdDID) 297 288 298 289 } ··· 300 291 return nil // All errors are non-fatal, logged for debugging 301 292 }) 302 293 303 303 - // Initialize auth keys and create token issuer 294 294 + // Create token issuer (also initializes auth keys if needed) 304 295 var issuer *token.Issuer 305 305 - if config.Auth["token"] != nil { 306 306 - if err := initializeAuthKeys(config); err != nil { 307 307 - return fmt.Errorf("failed to initialize auth keys: %w", err) 308 308 - } 309 309 - 310 310 - // Create token issuer for auth handlers 311 311 - issuer, err = createTokenIssuer(config) 296 296 + if cfg.Distribution.Auth["token"] != nil { 297 297 + issuer, err = createTokenIssuer(cfg) 312 298 if err != nil { 313 299 return fmt.Errorf("failed to create token issuer: %w", err) 314 300 } 301 301 + 302 302 + // Log successful initialization 303 303 + slog.Info("Auth keys initialized", "path", cfg.Auth.KeyPath) 315 304 } 316 305 317 306 // Create registry app (returns http.Handler) 318 307 ctx := context.Background() 319 319 - app := handlers.NewApp(ctx, config) 308 308 + app := handlers.NewApp(ctx, cfg.Distribution) 320 309 321 310 // Create main HTTP mux 322 311 mux := http.NewServeMux() ··· 332 321 // Mount UI routes directly at root level 333 322 mux.Handle("/", uiRouter) 334 323 335 335 - fmt.Printf("UI enabled:\n") 336 336 - fmt.Printf(" - Home: /\n") 337 337 - fmt.Printf(" - Settings: /settings\n") 324 324 + slog.Info("UI enabled", "home", "/", "settings", "/settings") 338 325 } 339 326 340 327 // Mount OAuth endpoints ··· 363 350 // Register token post-auth callback for profile management 364 351 // This decouples the token package from AppView-specific dependencies 365 352 tokenHandler.SetPostAuthCallback(func(ctx context.Context, did, handle, pdsEndpoint, accessToken string) error { 366 366 - fmt.Printf("DEBUG [appview/callback]: Token post-auth callback for DID=%s\n", did) 353 353 + slog.Debug("Token post-auth callback", "component", "appview/callback", "did", did) 367 354 368 355 // Create ATProto client with validated token 369 356 atprotoClient := atproto.NewClient(pdsEndpoint, did, accessToken) ··· 371 358 // Ensure profile exists (will create with default hold if not exists and default is configured) 372 359 if err := storage.EnsureProfile(ctx, atprotoClient, defaultHoldDID); err != nil { 373 360 // Log error but don't fail auth - profile management is not critical 374 374 - fmt.Printf("WARNING [appview/callback]: Failed to ensure profile for %s: %v\n", did, err) 361 361 + slog.Warn("Failed to ensure profile", "component", "appview/callback", "did", did, "error", err) 375 362 } else { 376 376 - fmt.Printf("DEBUG [appview/callback]: Profile ensured for %s with default hold %s\n", did, defaultHoldDID) 363 363 + slog.Debug("Profile ensured with default hold", "component", "appview/callback", "did", did, "default_hold_did", defaultHoldDID) 377 364 } 378 365 379 366 return nil // All errors are non-fatal ··· 390 377 Store: deviceStore, 391 378 }) 392 379 393 393 - fmt.Printf("Auth endpoints enabled:\n") 394 394 - fmt.Printf(" - Basic Auth: /auth/token (device secrets + app passwords)\n") 395 395 - fmt.Printf(" - Device Auth: /auth/device/code\n") 396 396 - fmt.Printf(" - Device Auth: /auth/device/token\n") 397 397 - fmt.Printf(" - OAuth: /auth/oauth/authorize\n") 398 398 - fmt.Printf(" - OAuth: /auth/oauth/callback\n") 399 399 - fmt.Printf(" - OAuth Meta: /client-metadata.json\n") 380 380 + slog.Info("Auth endpoints enabled", 381 381 + "basic_auth", "/auth/token", 382 382 + "device_code", "/auth/device/code", 383 383 + "device_token", "/auth/device/token", 384 384 + "oauth_authorize", "/auth/oauth/authorize", 385 385 + "oauth_callback", "/auth/oauth/callback", 386 386 + "oauth_metadata", "/client-metadata.json") 400 387 } 401 388 402 389 // Create HTTP server 403 390 server := &http.Server{ 404 404 - Addr: config.HTTP.Addr, 391 391 + Addr: cfg.Server.Addr, 405 392 Handler: mux, 406 393 } 407 394 ··· 412 399 // Start server in goroutine 413 400 errChan := make(chan error, 1) 414 401 go func() { 415 415 - fmt.Printf("Starting registry server on %s\n", config.HTTP.Addr) 402 402 + slog.Info("Starting registry server", "addr", cfg.Server.Addr) 416 403 if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed { 417 404 errChan <- err 418 405 } ··· 421 408 // Wait for shutdown signal or error 422 409 select { 423 410 case <-stop: 424 424 - fmt.Println("Shutting down registry server...") 411 411 + slog.Info("Shutting down registry server") 425 412 426 413 // Stop health worker first 427 427 - fmt.Println("Stopping hold health worker...") 414 414 + slog.Info("Stopping hold health worker") 428 415 healthWorker.Stop() 429 416 430 417 shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second) ··· 442 429 return nil 443 430 } 444 431 445 445 - // initializeAuthKeys creates the auth keys if they don't exist 446 446 - func initializeAuthKeys(config *configuration.Configuration) error { 447 447 - tokenParams, ok := config.Auth["token"] 448 448 - if !ok { 449 449 - return nil 450 450 - } 451 451 - 452 452 - privateKeyPath := appview.GetStringParam(tokenParams, "privatekey", "/var/lib/atcr/auth/private-key.pem") 453 453 - issuerName := appview.GetStringParam(tokenParams, "issuer", "atcr.io") 454 454 - service := appview.GetStringParam(tokenParams, "service", "atcr.io") 455 455 - expirationSecs := appview.GetIntParam(tokenParams, "expiration", 300) 456 456 - 457 457 - // Create issuer (this will generate the key if it doesn't exist) 458 458 - _, err := token.NewIssuer( 459 459 - privateKeyPath, 460 460 - issuerName, 461 461 - service, 462 462 - time.Duration(expirationSecs)*time.Second, 463 463 - ) 464 464 - if err != nil { 465 465 - return fmt.Errorf("failed to initialize token issuer: %w", err) 466 466 - } 467 467 - 468 468 - fmt.Printf("Auth keys initialized at %s\n", privateKeyPath) 469 469 - return nil 470 470 - } 471 471 - 472 432 // createTokenIssuer creates a token issuer for auth handlers 473 473 - func createTokenIssuer(config *configuration.Configuration) (*token.Issuer, error) { 474 474 - tokenParams, ok := config.Auth["token"] 475 475 - if !ok { 476 476 - return nil, fmt.Errorf("token auth not configured") 477 477 - } 478 478 - 479 479 - privateKeyPath := appview.GetStringParam(tokenParams, "privatekey", "/var/lib/atcr/auth/private-key.pem") 480 480 - issuerName := appview.GetStringParam(tokenParams, "issuer", "atcr.io") 481 481 - service := appview.GetStringParam(tokenParams, "service", "atcr.io") 482 482 - expirationSecs := appview.GetIntParam(tokenParams, "expiration", 300) 483 483 - 433 433 + func createTokenIssuer(cfg *appview.Config) (*token.Issuer, error) { 484 434 return token.NewIssuer( 485 485 - privateKeyPath, 486 486 - issuerName, 487 487 - service, 488 488 - time.Duration(expirationSecs)*time.Second, 435 435 + cfg.Auth.KeyPath, 436 436 + cfg.Auth.ServiceName, // issuer 437 437 + cfg.Auth.ServiceName, // service 438 438 + cfg.Auth.TokenExpiration, 489 439 ) 490 440 } 491 441 492 442 // initializeUIRoutes initializes the web UI routes 443 443 + // uiEnabled: whether UI is enabled (from Config.UI.Enabled) 493 444 // database: read-write connection for auth and writes 494 445 // readOnlyDB: read-only connection for public queries (search, user pages, etc.) 495 495 - // defaultHoldDID: DID of the default hold service (e.g., "did:web:hold01.atcr.io") 496 446 // healthChecker: hold endpoint health checker 497 497 - func initializeUIRoutes(database *sql.DB, readOnlyDB *sql.DB, sessionStore *db.SessionStore, oauthApp *oauth.App, oauthStore *db.OAuthStore, refresher *oauth.Refresher, baseURL string, deviceStore *db.DeviceStore, defaultHoldDID string, healthChecker *holdhealth.Checker, readmeCache *readme.Cache) (*template.Template, *mux.Router) { 447 447 + // readmeCache: README cache for repository pages 448 448 + func initializeUIRoutes(uiEnabled bool, database *sql.DB, readOnlyDB *sql.DB, sessionStore *db.SessionStore, oauthApp *oauth.App, oauthStore *db.OAuthStore, refresher *oauth.Refresher, baseURL string, deviceStore *db.DeviceStore, healthChecker *holdhealth.Checker, readmeCache *readme.Cache) (*template.Template, *mux.Router) { 498 449 // Check if UI is enabled 499 499 - if !appview.GetUIEnabled() { 450 450 + if !uiEnabled { 500 451 return nil, nil 501 452 } 502 453 503 454 // Load templates 504 455 templates, err := appview.Templates() 505 456 if err != nil { 506 506 - fmt.Printf("Warning: Failed to load UI templates: %v\n", err) 457 457 + slog.Warn("Failed to load UI templates", "error", err) 507 458 return nil, nil 508 459 } 509 460 ··· 682 633 OAuthStore: oauthStore, 683 634 }).Methods("GET", "POST") 684 635 636 636 + return templates, router 637 637 + } 638 638 + 639 639 + // initializeJetstream initializes the Jetstream workers for real-time events and backfill 640 640 + func initializeJetstream(database *sql.DB, jetstreamCfg *appview.JetstreamConfig, defaultHoldDID string, testMode bool) { 685 641 // Start Jetstream worker 686 686 - jetstreamURL := appview.GetJetstreamURL() 642 642 + jetstreamURL := jetstreamCfg.URL 687 643 688 644 // Start real-time Jetstream worker with cursor tracking for reconnects 689 645 go func() { ··· 693 649 if err := worker.Start(context.Background()); err != nil { 694 650 // Save cursor from this connection for next reconnect 695 651 lastCursor = worker.GetLastCursor() 696 696 - fmt.Printf("Jetstream: Real-time worker error: %v, reconnecting in 10s...\n", err) 652 652 + slog.Warn("Jetstream real-time worker error, reconnecting", "component", "jetstream", "error", err, "reconnect_delay", "10s") 697 653 time.Sleep(10 * time.Second) 698 654 } 699 655 } 700 656 }() 701 701 - fmt.Println("Jetstream: Real-time worker started") 657 657 + slog.Info("Jetstream real-time worker started", "component", "jetstream") 702 658 703 659 // Start backfill worker (enabled by default, set ATCR_BACKFILL_ENABLED=false to disable) 704 704 - if appview.GetBackfillEnabled() { 660 660 + if jetstreamCfg.BackfillEnabled { 705 661 // Get relay endpoint for sync API (defaults to Bluesky's relay) 706 706 - relayEndpoint := appview.GetRelayEndpoint() 707 707 - 708 708 - // Check test mode 709 709 - testMode := appview.GetTestMode() 662 662 + relayEndpoint := jetstreamCfg.RelayEndpoint 710 663 711 664 backfillWorker, err := jetstream.NewBackfillWorker(database, relayEndpoint, defaultHoldDID, testMode) 712 665 if err != nil { 713 713 - fmt.Printf("Warning: Failed to create backfill worker: %v\n", err) 666 666 + slog.Warn("Failed to create backfill worker", "component", "jetstream/backfill", "error", err) 714 667 } else { 715 668 // Run initial backfill with startup delay for Docker compose 716 669 go func() { 717 670 // Wait for hold service to be ready (Docker startup race condition) 718 671 startupDelay := 5 * time.Second 719 719 - fmt.Printf("Backfill: Waiting %s for services to be ready...\n", startupDelay) 672 672 + slog.Info("Waiting for services to be ready", "component", "jetstream/backfill", "startup_delay", startupDelay) 720 673 time.Sleep(startupDelay) 721 674 722 722 - fmt.Printf("Backfill: Starting sync-based backfill from %s...\n", relayEndpoint) 675 675 + slog.Info("Starting sync-based backfill", "component", "jetstream/backfill", "relay_endpoint", relayEndpoint) 723 676 if err := backfillWorker.Start(context.Background()); err != nil { 724 724 - fmt.Printf("Backfill: Finished with error: %v\n", err) 677 677 + slog.Warn("Backfill finished with error", "component", "jetstream/backfill", "error", err) 725 678 } else { 726 726 - fmt.Println("Backfill: Completed successfully!") 679 679 + slog.Info("Backfill completed successfully", "component", "jetstream/backfill") 727 680 } 728 681 }() 729 682 730 683 // Start periodic backfill scheduler 731 731 - interval := appview.GetBackfillInterval() 684 684 + interval := jetstreamCfg.BackfillInterval 732 685 733 686 go func() { 734 687 ticker := time.NewTicker(interval) 735 688 defer ticker.Stop() 736 689 737 690 for range ticker.C { 738 738 - fmt.Printf("Backfill: Starting periodic backfill (runs every %s)...\n", interval) 691 691 + slog.Info("Starting periodic backfill", "component", "jetstream/backfill", "interval", interval) 739 692 if err := backfillWorker.Start(context.Background()); err != nil { 740 740 - fmt.Printf("Backfill: Periodic backfill finished with error: %v\n", err) 693 693 + slog.Warn("Periodic backfill finished with error", "component", "jetstream/backfill", "error", err) 741 694 } else { 742 742 - fmt.Println("Backfill: Periodic backfill completed successfully!") 695 695 + slog.Info("Periodic backfill completed successfully", "component", "jetstream/backfill") 743 696 } 744 697 } 745 698 }() 746 746 - fmt.Printf("Backfill: Periodic scheduler started (interval: %s)\n", interval) 699 699 + slog.Info("Periodic backfill scheduler started", "component", "jetstream/backfill", "interval", interval) 747 700 } 748 701 } 749 749 - 750 750 - return templates, router 751 702 }

+1 -1

deploy/.env.prod.template

reviewed

··· 161 161 162 162 # Log level: debug, info, warn, error 163 163 # Default: info 164 164 - ATCR_LOG_LEVEL=info 164 164 + ATCR_LOG_LEVEL=debug 165 165 166 166 # Log formatter: text, json 167 167 # Default: text

+4

deploy/docker-compose.prod.yml

reviewed

··· 114 114 S3_ENDPOINT: ${S3_ENDPOINT:-} 115 115 S3_REGION_ENDPOINT: ${S3_REGION_ENDPOINT:-} 116 116 117 117 + # Logging 118 118 + ATCR_LOG_LEVEL: ${ATCR_LOG_LEVEL:-debug} 119 119 + ATCR_LOG_FORMATTER: ${ATCR_LOG_FORMATTER:-text} 120 120 + 117 121 # Optional: Filesystem storage (comment out S3 vars above) 118 122 # STORAGE_DRIVER: filesystem 119 123 # STORAGE_ROOT_DIR: /var/lib/atcr/hold

+3 -1

docker-compose.yml

reviewed

··· 20 20 # Test mode - fallback to default hold when user's hold is unreachable 21 21 TEST_MODE: true 22 22 # Logging 23 23 - ATCR_LOG_LEVEL: info 23 23 + ATCR_LOG_LEVEL: debug 24 24 volumes: 25 25 # Auth keys (JWT signing keys) 26 26 # - atcr-auth:/var/lib/atcr/auth ··· 50 50 # STORAGE_ROOT_DIR: /var/lib/atcr/hold 51 51 TEST_MODE: true 52 52 # DISABLE_PRESIGNED_URLS: true 53 53 + # Logging 54 54 + ATCR_LOG_LEVEL: debug 53 55 # Storage config comes from env_file (STORAGE_DRIVER, AWS_*, S3_*) 54 56 build: 55 57 context: .

+191 -266

pkg/appview/config.go

reviewed

··· 17 17 "github.com/distribution/distribution/v3/configuration" 18 18 ) 19 19 20 20 + // Config represents the AppView service configuration 21 21 + type Config struct { 22 22 + Version string `yaml:"version"` 23 23 + LogLevel string `yaml:"log_level"` 24 24 + Server ServerConfig `yaml:"server"` 25 25 + UI UIConfig `yaml:"ui"` 26 26 + Health HealthConfig `yaml:"health"` 27 27 + Jetstream JetstreamConfig `yaml:"jetstream"` 28 28 + Auth AuthConfig `yaml:"auth"` 29 29 + Distribution *configuration.Configuration `yaml:"-"` // Wrapped distribution config for compatibility 30 30 + } 31 31 + 32 32 + // ServerConfig defines server settings 33 33 + type ServerConfig struct { 34 34 + // Addr is the HTTP listen address (from env: ATCR_HTTP_ADDR, default: ":5000") 35 35 + Addr string `yaml:"addr"` 36 36 + 37 37 + // BaseURL is the public URL for OAuth/JWT realm (from env: ATCR_BASE_URL) 38 38 + // Auto-detected from Addr if not set 39 39 + BaseURL string `yaml:"base_url"` 40 40 + 41 41 + // DefaultHoldDID is the default hold DID for blob storage (from env: ATCR_DEFAULT_HOLD_DID) 42 42 + // REQUIRED - e.g., "did:web:hold01.atcr.io" 43 43 + DefaultHoldDID string `yaml:"default_hold_did"` 44 44 + 45 45 + // TestMode enables HTTP for local DID resolution and transition:generic scope (from env: TEST_MODE) 46 46 + TestMode bool `yaml:"test_mode"` 47 47 + 48 48 + // DebugAddr is the debug/pprof HTTP listen address (from env: ATCR_DEBUG_ADDR, default: ":5001") 49 49 + DebugAddr string `yaml:"debug_addr"` 50 50 + } 51 51 + 52 52 + // UIConfig defines web UI settings 53 53 + type UIConfig struct { 54 54 + // Enabled controls whether the web UI is enabled (from env: ATCR_UI_ENABLED, default: true) 55 55 + Enabled bool `yaml:"enabled"` 56 56 + 57 57 + // DatabasePath is the path to the UI SQLite database (from env: ATCR_UI_DATABASE_PATH, default: "/var/lib/atcr/ui.db") 58 58 + DatabasePath string `yaml:"database_path"` 59 59 + } 60 60 + 61 61 + // HealthConfig defines health check and cache settings 62 62 + type HealthConfig struct { 63 63 + // CacheTTL is the hold health check cache TTL (from env: ATCR_HEALTH_CACHE_TTL, default: 15m) 64 64 + CacheTTL time.Duration `yaml:"cache_ttl"` 65 65 + 66 66 + // CheckInterval is the hold health check refresh interval (from env: ATCR_HEALTH_CHECK_INTERVAL, default: 15m) 67 67 + CheckInterval time.Duration `yaml:"check_interval"` 68 68 + 69 69 + // ReadmeCacheTTL is the README cache TTL (from env: ATCR_README_CACHE_TTL, default: 1h) 70 70 + ReadmeCacheTTL time.Duration `yaml:"readme_cache_ttl"` 71 71 + } 72 72 + 73 73 + // JetstreamConfig defines ATProto Jetstream settings 74 74 + type JetstreamConfig struct { 75 75 + // URL is the Jetstream WebSocket URL (from env: JETSTREAM_URL, default: wss://jetstream2.us-west.bsky.network/subscribe) 76 76 + URL string `yaml:"url"` 77 77 + 78 78 + // BackfillEnabled controls whether backfill is enabled (from env: ATCR_BACKFILL_ENABLED, default: true) 79 79 + BackfillEnabled bool `yaml:"backfill_enabled"` 80 80 + 81 81 + // BackfillInterval is the backfill interval (from env: ATCR_BACKFILL_INTERVAL, default: 1h) 82 82 + BackfillInterval time.Duration `yaml:"backfill_interval"` 83 83 + 84 84 + // RelayEndpoint is the relay endpoint for sync API (from env: ATCR_RELAY_ENDPOINT, default: https://relay1.us-east.bsky.network) 85 85 + RelayEndpoint string `yaml:"relay_endpoint"` 86 86 + } 87 87 + 88 88 + // AuthConfig defines authentication settings 89 89 + type AuthConfig struct { 90 90 + // KeyPath is the JWT signing key path (from env: ATCR_AUTH_KEY_PATH, default: "/var/lib/atcr/auth/private-key.pem") 91 91 + KeyPath string `yaml:"key_path"` 92 92 + 93 93 + // CertPath is the JWT certificate path (from env: ATCR_AUTH_CERT_PATH, default: "/var/lib/atcr/auth/private-key.crt") 94 94 + CertPath string `yaml:"cert_path"` 95 95 + 96 96 + // TokenExpiration is the JWT expiration duration (from env: ATCR_TOKEN_EXPIRATION, default: 300s) 97 97 + TokenExpiration time.Duration `yaml:"token_expiration"` 98 98 + 99 99 + // ServiceName is the service name used for JWT issuer and service fields 100 100 + // Derived from ATCR_SERVICE_NAME env var or extracted from base URL (e.g., "atcr.io") 101 101 + ServiceName string `yaml:"service_name"` 102 102 + } 103 103 + 20 104 // LoadConfigFromEnv builds a complete configuration from environment variables 21 105 // This follows the same pattern as the hold service (no config files, only env vars) 22 22 - func LoadConfigFromEnv() (*configuration.Configuration, error) { 23 23 - config := &configuration.Configuration{} 106 106 + func LoadConfigFromEnv() (*Config, error) { 107 107 + cfg := &Config{ 108 108 + Version: "0.1", 109 109 + } 24 110 25 25 - // Version 26 26 - config.Version = configuration.MajorMinorVersion(0, 1) 111 111 + // Logging configuration 112 112 + cfg.LogLevel = getEnvOrDefault("ATCR_LOG_LEVEL", "info") 27 113 28 28 - // Logging 29 29 - config.Log = buildLogConfig() 114 114 + // Server configuration 115 115 + cfg.Server.Addr = getEnvOrDefault("ATCR_HTTP_ADDR", ":5000") 116 116 + cfg.Server.DebugAddr = getEnvOrDefault("ATCR_DEBUG_ADDR", ":5001") 117 117 + cfg.Server.DefaultHoldDID = os.Getenv("ATCR_DEFAULT_HOLD_DID") 118 118 + if cfg.Server.DefaultHoldDID == "" { 119 119 + return nil, fmt.Errorf("ATCR_DEFAULT_HOLD_DID is required") 120 120 + } 121 121 + cfg.Server.TestMode = os.Getenv("TEST_MODE") == "true" 30 122 31 31 - // HTTP server 32 32 - httpConfig, err := buildHTTPConfig() 33 33 - if err != nil { 34 34 - return nil, fmt.Errorf("failed to build HTTP config: %w", err) 123 123 + // Auto-detect base URL if not explicitly set 124 124 + cfg.Server.BaseURL = os.Getenv("ATCR_BASE_URL") 125 125 + if cfg.Server.BaseURL == "" { 126 126 + cfg.Server.BaseURL = autoDetectBaseURL(cfg.Server.Addr) 35 127 } 36 36 - config.HTTP = httpConfig 128 128 + 129 129 + // UI configuration 130 130 + cfg.UI.Enabled = os.Getenv("ATCR_UI_ENABLED") != "false" 131 131 + cfg.UI.DatabasePath = getEnvOrDefault("ATCR_UI_DATABASE_PATH", "/var/lib/atcr/ui.db") 37 132 38 38 - // Storage (fake in-memory placeholder - all real storage is proxied) 39 39 - config.Storage = buildStorageConfig() 133 133 + // Health and cache configuration 134 134 + cfg.Health.CacheTTL = getDurationOrDefault("ATCR_HEALTH_CACHE_TTL", 15*time.Minute) 135 135 + cfg.Health.CheckInterval = getDurationOrDefault("ATCR_HEALTH_CHECK_INTERVAL", 15*time.Minute) 136 136 + cfg.Health.ReadmeCacheTTL = getDurationOrDefault("ATCR_README_CACHE_TTL", 1*time.Hour) 137 137 + 138 138 + // Jetstream configuration 139 139 + cfg.Jetstream.URL = getEnvOrDefault("JETSTREAM_URL", "wss://jetstream2.us-west.bsky.network/subscribe") 140 140 + cfg.Jetstream.BackfillEnabled = os.Getenv("ATCR_BACKFILL_ENABLED") != "false" 141 141 + cfg.Jetstream.BackfillInterval = getDurationOrDefault("ATCR_BACKFILL_INTERVAL", 1*time.Hour) 142 142 + cfg.Jetstream.RelayEndpoint = getEnvOrDefault("ATCR_RELAY_ENDPOINT", "https://relay1.us-east.bsky.network") 40 143 41 41 - // Get base URL for error messages and auth config 42 42 - baseURL := GetBaseURL(httpConfig.Addr) 144 144 + // Auth configuration 145 145 + cfg.Auth.KeyPath = getEnvOrDefault("ATCR_AUTH_KEY_PATH", "/var/lib/atcr/auth/private-key.pem") 146 146 + cfg.Auth.CertPath = getEnvOrDefault("ATCR_AUTH_CERT_PATH", "/var/lib/atcr/auth/private-key.crt") 43 147 44 44 - // Middleware (ATProto resolver) 45 45 - defaultHoldDID := os.Getenv("ATCR_DEFAULT_HOLD_DID") 46 46 - if defaultHoldDID == "" { 47 47 - return nil, fmt.Errorf("ATCR_DEFAULT_HOLD_DID is required") 148 148 + // Parse token expiration (default: 300 seconds = 5 minutes) 149 149 + expirationStr := getEnvOrDefault("ATCR_TOKEN_EXPIRATION", "300") 150 150 + expirationSecs, err := strconv.Atoi(expirationStr) 151 151 + if err != nil { 152 152 + return nil, fmt.Errorf("invalid ATCR_TOKEN_EXPIRATION: %w", err) 48 153 } 49 49 - config.Middleware = buildMiddlewareConfig(defaultHoldDID, baseURL) 154 154 + cfg.Auth.TokenExpiration = time.Duration(expirationSecs) * time.Second 155 155 + 156 156 + // Derive service name from base URL or env var (used for JWT issuer and service) 157 157 + cfg.Auth.ServiceName = getServiceName(cfg.Server.BaseURL) 50 158 51 51 - // Auth 52 52 - authConfig, err := buildAuthConfig(baseURL) 159 159 + // Build distribution configuration for compatibility with distribution library 160 160 + distConfig, err := buildDistributionConfig(cfg) 53 161 if err != nil { 54 54 - return nil, fmt.Errorf("failed to build auth config: %w", err) 162 162 + return nil, fmt.Errorf("failed to build distribution config: %w", err) 55 163 } 56 56 - config.Auth = authConfig 57 57 - 58 58 - // Health checks 59 59 - config.Health = buildHealthConfig() 164 164 + cfg.Distribution = distConfig 60 165 61 61 - return config, nil 166 166 + return cfg, nil 62 167 } 63 168 64 64 - // buildLogConfig creates logging configuration from environment variables 65 65 - func buildLogConfig() configuration.Log { 66 66 - level := GetEnvOrDefault("ATCR_LOG_LEVEL", "info") 67 67 - formatter := GetEnvOrDefault("ATCR_LOG_FORMATTER", "text") 169 169 + // buildDistributionConfig creates a distribution Configuration from our Config 170 170 + // This maintains compatibility with the distribution library 171 171 + func buildDistributionConfig(cfg *Config) (*configuration.Configuration, error) { 172 172 + distConfig := &configuration.Configuration{} 68 173 69 69 - return configuration.Log{ 70 70 - Level: configuration.Loglevel(level), 71 71 - Formatter: formatter, 174 174 + // Version 175 175 + distConfig.Version = configuration.MajorMinorVersion(0, 1) 176 176 + 177 177 + // Logging 178 178 + distConfig.Log = configuration.Log{ 179 179 + Level: configuration.Loglevel(cfg.LogLevel), 180 180 + Formatter: getEnvOrDefault("ATCR_LOG_FORMATTER", "text"), 72 181 Fields: map[string]any{ 73 182 "service": "atcr-appview", 74 183 }, 75 184 } 76 76 - } 77 185 78 78 - // buildHTTPConfig creates HTTP server configuration from environment variables 79 79 - func buildHTTPConfig() (configuration.HTTP, error) { 80 80 - addr := GetEnvOrDefault("ATCR_HTTP_ADDR", ":5000") 81 81 - debugAddr := GetEnvOrDefault("ATCR_DEBUG_ADDR", ":5001") 82 82 - 83 83 - // HTTP secret - only needed for multipart uploads in distribution's storage driver 84 84 - // Since AppView is stateless and routes all storage through middleware, this isn't 85 85 - // actually used, but we generate a random secret for defense in depth 186 186 + // HTTP server 86 187 httpSecret := os.Getenv("REGISTRY_HTTP_SECRET") 87 188 if httpSecret == "" { 88 189 // Generate a random 32-byte secret 89 190 randomBytes := make([]byte, 32) 90 191 if _, err := rand.Read(randomBytes); err != nil { 91 91 - return configuration.HTTP{}, fmt.Errorf("failed to generate random secret: %w", err) 192 192 + return nil, fmt.Errorf("failed to generate random secret: %w", err) 92 193 } 93 194 httpSecret = hex.EncodeToString(randomBytes) 94 195 } 95 196 96 96 - return configuration.HTTP{ 97 97 - Addr: addr, 197 197 + distConfig.HTTP = configuration.HTTP{ 198 198 + Addr: cfg.Server.Addr, 98 199 Secret: httpSecret, 99 200 Headers: map[string][]string{ 100 201 "X-Content-Type-Options": {"nosniff"}, 101 202 }, 102 203 Debug: configuration.Debug{ 103 103 - Addr: debugAddr, 204 204 + Addr: cfg.Server.DebugAddr, 205 205 + }, 206 206 + } 207 207 + 208 208 + // Storage (fake in-memory placeholder - all real storage is proxied) 209 209 + distConfig.Storage = buildStorageConfig() 210 210 + 211 211 + // Middleware (ATProto resolver) 212 212 + distConfig.Middleware = buildMiddlewareConfig(cfg.Server.DefaultHoldDID, cfg.Server.BaseURL) 213 213 + 214 214 + // Auth (use values from cfg.Auth) 215 215 + realm := cfg.Server.BaseURL + "/auth/token" 216 216 + 217 217 + distConfig.Auth = configuration.Auth{ 218 218 + "token": configuration.Parameters{ 219 219 + "realm": realm, 220 220 + "service": cfg.Auth.ServiceName, 221 221 + "issuer": cfg.Auth.ServiceName, 222 222 + "rootcertbundle": cfg.Auth.CertPath, 223 223 + "privatekey": cfg.Auth.KeyPath, 224 224 + "expiration": int(cfg.Auth.TokenExpiration.Seconds()), 104 225 }, 105 105 - }, nil 226 226 + } 227 227 + 228 228 + // Health checks 229 229 + distConfig.Health = buildHealthConfig() 230 230 + 231 231 + return distConfig, nil 232 232 + } 233 233 + 234 234 + // autoDetectBaseURL determines the base URL for the service from the HTTP address 235 235 + func autoDetectBaseURL(httpAddr string) string { 236 236 + // Auto-detect from HTTP addr 237 237 + if httpAddr[0] == ':' { 238 238 + // Just a port, assume localhost 239 239 + return fmt.Sprintf("http://127.0.0.1%s", httpAddr) 240 240 + } 241 241 + 242 242 + // Full address provided 243 243 + return fmt.Sprintf("http://%s", httpAddr) 106 244 } 107 245 108 246 // buildStorageConfig creates a fake in-memory storage config ··· 148 286 } 149 287 } 150 288 151 151 - // buildAuthConfig creates authentication configuration from environment variables 152 152 - func buildAuthConfig(baseURL string) (configuration.Auth, error) { 153 153 - // Token configuration 154 154 - privateKeyPath := GetEnvOrDefault("ATCR_AUTH_KEY_PATH", "/var/lib/atcr/auth/private-key.pem") 155 155 - certPath := GetEnvOrDefault("ATCR_AUTH_CERT_PATH", "/var/lib/atcr/auth/private-key.crt") 156 156 - 157 157 - // Token expiration in seconds (default: 5 minutes) 158 158 - expirationStr := GetEnvOrDefault("ATCR_TOKEN_EXPIRATION", "300") 159 159 - expiration, err := strconv.Atoi(expirationStr) 160 160 - if err != nil { 161 161 - return configuration.Auth{}, fmt.Errorf("invalid ATCR_TOKEN_EXPIRATION: %w", err) 162 162 - } 163 163 - 164 164 - // Auto-derive service name from base URL or use env var 165 165 - serviceName := getServiceName(baseURL) 166 166 - 167 167 - // Auto-derive realm from base URL 168 168 - realm := baseURL + "/auth/token" 169 169 - 170 170 - return configuration.Auth{ 171 171 - "token": configuration.Parameters{ 172 172 - "realm": realm, 173 173 - "service": serviceName, 174 174 - "issuer": serviceName, 175 175 - "rootcertbundle": certPath, 176 176 - "privatekey": privateKeyPath, 177 177 - "expiration": expiration, 178 178 - }, 179 179 - }, nil 180 180 - } 181 181 - 182 289 // buildHealthConfig creates health check configuration 183 290 func buildHealthConfig() configuration.Health { 184 291 return configuration.Health{ ··· 190 297 } 191 298 } 192 299 193 193 - // GetBaseURL determines the base URL for the service 194 194 - // Priority: ATCR_BASE_URL env var, then derived from HTTP addr 195 195 - func GetBaseURL(httpAddr string) string { 196 196 - baseURL := os.Getenv("ATCR_BASE_URL") 197 197 - if baseURL != "" { 198 198 - return baseURL 199 199 - } 200 200 - 201 201 - // Auto-detect from HTTP addr 202 202 - if httpAddr[0] == ':' { 203 203 - // Just a port, assume localhost 204 204 - return fmt.Sprintf("http://127.0.0.1%s", httpAddr) 205 205 - } 206 206 - 207 207 - // Full address provided 208 208 - return fmt.Sprintf("http://%s", httpAddr) 209 209 - } 210 210 - 211 300 // getServiceName extracts service name from base URL or uses env var 212 301 func getServiceName(baseURL string) string { 213 302 // Check env var first ··· 232 321 return "atcr.io" 233 322 } 234 323 235 235 - // GetEnvOrDefault gets an environment variable or returns a default value 236 236 - func GetEnvOrDefault(key, defaultValue string) string { 324 324 + // getEnvOrDefault gets an environment variable or returns a default value 325 325 + func getEnvOrDefault(key, defaultValue string) string { 237 326 if val := os.Getenv(key); val != "" { 238 327 return val 239 328 } 240 329 return defaultValue 241 330 } 242 331 243 243 - // GetLogLevel returns the configured log level from environment 244 244 - // Centralizes ATCR_LOG_LEVEL env var reading 245 245 - func GetLogLevel() string { 246 246 - return GetEnvOrDefault("ATCR_LOG_LEVEL", "info") 247 247 - } 248 248 - 249 249 - // GetStringParam extracts a string parameter from configuration.Parameters 250 250 - func GetStringParam(params configuration.Parameters, key, defaultValue string) string { 251 251 - if v, ok := params[key]; ok { 252 252 - if s, ok := v.(string); ok { 253 253 - return s 254 254 - } 255 255 - } 256 256 - return defaultValue 257 257 - } 258 258 - 259 259 - // GetIntParam extracts an int parameter from configuration.Parameters 260 260 - func GetIntParam(params configuration.Parameters, key string, defaultValue int) int { 261 261 - if v, ok := params[key]; ok { 262 262 - if i, ok := v.(int); ok { 263 263 - return i 264 264 - } 265 265 - } 266 266 - return defaultValue 267 267 - } 268 268 - 269 269 - // ExtractDefaultHoldDID extracts the default hold DID from middleware config 270 270 - // Returns a DID (e.g., "did:web:hold01.atcr.io") 271 271 - // To find a hold's DID, visit: https://hold-url/.well-known/did.json 272 272 - func ExtractDefaultHoldDID(config *configuration.Configuration) string { 273 273 - // Navigate through: middleware.registry[].options.default_hold_did 274 274 - registryMiddleware, ok := config.Middleware["registry"] 275 275 - if !ok { 276 276 - return "" 277 277 - } 278 278 - 279 279 - // Find atproto-resolver middleware 280 280 - for _, mw := range registryMiddleware { 281 281 - // Check if this is the atproto-resolver 282 282 - if mw.Name != "atproto-resolver" { 283 283 - continue 284 284 - } 285 285 - 286 286 - // Extract options - options is configuration.Parameters which is map[string]any 287 287 - if mw.Options != nil { 288 288 - if holdDID, ok := mw.Options["default_hold_did"].(string); ok { 289 289 - return holdDID 290 290 - } 291 291 - } 292 292 - } 293 293 - 294 294 - return "" 295 295 - } 296 296 - 297 297 - // ExtractTestMode extracts the test_mode flag from middleware config 298 298 - // Returns true if TEST_MODE=true, false otherwise 299 299 - func ExtractTestMode(config *configuration.Configuration) bool { 300 300 - // Navigate through: middleware.registry[].options.test_mode 301 301 - registryMiddleware, ok := config.Middleware["registry"] 302 302 - if !ok { 303 303 - return false 304 304 - } 305 305 - 306 306 - // Find atproto-resolver middleware 307 307 - for _, mw := range registryMiddleware { 308 308 - // Check if this is the atproto-resolver 309 309 - if mw.Name != "atproto-resolver" { 310 310 - continue 311 311 - } 312 312 - 313 313 - // Extract options - options is configuration.Parameters which is map[string]any 314 314 - if mw.Options != nil { 315 315 - if testMode, ok := mw.Options["test_mode"].(bool); ok { 316 316 - return testMode 317 317 - } 318 318 - } 319 319 - } 320 320 - 321 321 - return false 322 322 - } 323 323 - 324 324 - // GetDurationOrDefault parses a duration from environment variable or returns default 332 332 + // getDurationOrDefault parses a duration from environment variable or returns default 325 333 // Logs a warning if parsing fails 326 326 - func GetDurationOrDefault(envKey string, defaultValue time.Duration) time.Duration { 334 334 + func getDurationOrDefault(envKey string, defaultValue time.Duration) time.Duration { 327 335 envVal := os.Getenv(envKey) 328 336 if envVal == "" { 329 337 return defaultValue ··· 337 345 338 346 return parsed 339 347 } 340 340 - 341 341 - // GetBoolOrDefault returns a boolean from environment variable or returns default 342 342 - // Treats "false" as false, everything else (including empty) as the default value 343 343 - func GetBoolOrDefault(envKey string, defaultValue bool) bool { 344 344 - envVal := os.Getenv(envKey) 345 345 - if envVal == "" { 346 346 - return defaultValue 347 347 - } 348 348 - 349 349 - // Explicit false check 350 350 - if envVal == "false" { 351 351 - return false 352 352 - } 353 353 - 354 354 - // Explicit true check 355 355 - if envVal == "true" { 356 356 - return true 357 357 - } 358 358 - 359 359 - // For any other value, return default 360 360 - return defaultValue 361 361 - } 362 362 - 363 363 - // UI Configuration 364 364 - 365 365 - // GetUIEnabled returns whether the UI is enabled (default: true) 366 366 - func GetUIEnabled() bool { 367 367 - // UI is enabled unless explicitly set to "false" 368 368 - return os.Getenv("ATCR_UI_ENABLED") != "false" 369 369 - } 370 370 - 371 371 - // GetUIDatabasePath returns the path to the UI database (default: /var/lib/atcr/ui.db) 372 372 - func GetUIDatabasePath() string { 373 373 - return GetEnvOrDefault("ATCR_UI_DATABASE_PATH", "/var/lib/atcr/ui.db") 374 374 - } 375 375 - 376 376 - // Health & Cache Configuration 377 377 - 378 378 - // GetHealthCacheTTL returns the hold health check cache TTL (default: 15m) 379 379 - func GetHealthCacheTTL() time.Duration { 380 380 - return GetDurationOrDefault("ATCR_HEALTH_CACHE_TTL", 15*time.Minute) 381 381 - } 382 382 - 383 383 - // GetReadmeCacheTTL returns the README cache TTL (default: 1h) 384 384 - func GetReadmeCacheTTL() time.Duration { 385 385 - return GetDurationOrDefault("ATCR_README_CACHE_TTL", 1*time.Hour) 386 386 - } 387 387 - 388 388 - // GetHealthCheckInterval returns the hold health check refresh interval (default: 15m) 389 389 - func GetHealthCheckInterval() time.Duration { 390 390 - return GetDurationOrDefault("ATCR_HEALTH_CHECK_INTERVAL", 15*time.Minute) 391 391 - } 392 392 - 393 393 - // Jetstream Configuration 394 394 - 395 395 - // GetJetstreamURL returns the Jetstream WebSocket URL (default: wss://jetstream2.us-west.bsky.network/subscribe) 396 396 - func GetJetstreamURL() string { 397 397 - return GetEnvOrDefault("JETSTREAM_URL", "wss://jetstream2.us-west.bsky.network/subscribe") 398 398 - } 399 399 - 400 400 - // GetBackfillEnabled returns whether backfill is enabled (default: true) 401 401 - func GetBackfillEnabled() bool { 402 402 - // Backfill is enabled unless explicitly set to "false" 403 403 - return os.Getenv("ATCR_BACKFILL_ENABLED") != "false" 404 404 - } 405 405 - 406 406 - // GetRelayEndpoint returns the relay endpoint for sync API (default: https://relay1.us-east.bsky.network) 407 407 - func GetRelayEndpoint() string { 408 408 - return GetEnvOrDefault("ATCR_RELAY_ENDPOINT", "https://relay1.us-east.bsky.network") 409 409 - } 410 410 - 411 411 - // GetBackfillInterval returns the backfill interval (default: 1h) 412 412 - func GetBackfillInterval() time.Duration { 413 413 - return GetDurationOrDefault("ATCR_BACKFILL_INTERVAL", 1*time.Hour) 414 414 - } 415 415 - 416 416 - // Test Mode Configuration 417 417 - 418 418 - // GetTestMode returns whether test mode is enabled (default: false) 419 419 - // Test mode enables HTTP for local DID resolution and transition:generic scope 420 420 - func GetTestMode() bool { 421 421 - return os.Getenv("TEST_MODE") == "true" 422 422 - }

+24 -1331

pkg/appview/config_test.go

reviewed

··· 4 4 "os" 5 5 "testing" 6 6 "time" 7 7 - 8 8 - "github.com/distribution/distribution/v3/configuration" 9 7 ) 10 8 11 11 - func TestGetEnvOrDefault(t *testing.T) { 12 12 - tests := []struct { 13 13 - name string 14 14 - key string 15 15 - defaultValue string 16 16 - envValue string 17 17 - setEnv bool 18 18 - want string 19 19 - }{ 20 20 - { 21 21 - name: "env var not set", 22 22 - key: "TEST_VAR_NOT_SET", 23 23 - defaultValue: "default", 24 24 - setEnv: false, 25 25 - want: "default", 26 26 - }, 27 27 - { 28 28 - name: "env var set to value", 29 29 - key: "TEST_VAR_SET", 30 30 - defaultValue: "default", 31 31 - envValue: "custom", 32 32 - setEnv: true, 33 33 - want: "custom", 34 34 - }, 35 35 - { 36 36 - name: "env var set to empty string", 37 37 - key: "TEST_VAR_EMPTY", 38 38 - defaultValue: "default", 39 39 - envValue: "", 40 40 - setEnv: true, 41 41 - want: "default", 42 42 - }, 43 43 - } 44 44 - 45 45 - for _, tt := range tests { 46 46 - t.Run(tt.name, func(t *testing.T) { 47 47 - if tt.setEnv { 48 48 - t.Setenv(tt.key, tt.envValue) 49 49 - } 50 50 - 51 51 - got := GetEnvOrDefault(tt.key, tt.defaultValue) 52 52 - if got != tt.want { 53 53 - t.Errorf("GetEnvOrDefault() = %v, want %v", got, tt.want) 54 54 - } 55 55 - }) 56 56 - } 57 57 - } 58 58 - 59 59 - func TestGetBaseURL(t *testing.T) { 60 60 - tests := []struct { 61 61 - name string 62 62 - httpAddr string 63 63 - envBaseURL string 64 64 - setEnv bool 65 65 - want string 66 66 - }{ 67 67 - { 68 68 - name: "env var set", 69 69 - httpAddr: ":5000", 70 70 - envBaseURL: "https://registry.example.com", 71 71 - setEnv: true, 72 72 - want: "https://registry.example.com", 73 73 - }, 74 74 - { 75 75 - name: "port only - auto detect localhost", 76 76 - httpAddr: ":5000", 77 77 - setEnv: false, 78 78 - want: "http://127.0.0.1:5000", 79 79 - }, 80 80 - { 81 81 - name: "full address", 82 82 - httpAddr: "0.0.0.0:5000", 83 83 - setEnv: false, 84 84 - want: "http://0.0.0.0:5000", 85 85 - }, 86 86 - { 87 87 - name: "custom port", 88 88 - httpAddr: ":8080", 89 89 - setEnv: false, 90 90 - want: "http://127.0.0.1:8080", 91 91 - }, 92 92 - } 93 93 - 94 94 - for _, tt := range tests { 95 95 - t.Run(tt.name, func(t *testing.T) { 96 96 - if tt.setEnv { 97 97 - t.Setenv("ATCR_BASE_URL", tt.envBaseURL) 98 98 - } else { 99 99 - os.Unsetenv("ATCR_BASE_URL") 100 100 - } 101 101 - 102 102 - got := GetBaseURL(tt.httpAddr) 103 103 - if got != tt.want { 104 104 - t.Errorf("GetBaseURL() = %v, want %v", got, tt.want) 105 105 - } 106 106 - }) 107 107 - } 108 108 - } 109 109 - 110 9 func Test_getServiceName(t *testing.T) { 111 10 tests := []struct { 112 11 name string ··· 170 69 } 171 70 } 172 71 173 173 - func TestBuildLogConfig(t *testing.T) { 174 174 - tests := []struct { 175 175 - name string 176 176 - envLevel string 177 177 - envFormatter string 178 178 - setLevel bool 179 179 - setFormatter bool 180 180 - wantLevel configuration.Loglevel 181 181 - wantFormatter string 182 182 - }{ 183 183 - { 184 184 - name: "defaults", 185 185 - setLevel: false, 186 186 - setFormatter: false, 187 187 - wantLevel: "info", 188 188 - wantFormatter: "text", 189 189 - }, 190 190 - { 191 191 - name: "custom level", 192 192 - envLevel: "debug", 193 193 - setLevel: true, 194 194 - setFormatter: false, 195 195 - wantLevel: "debug", 196 196 - wantFormatter: "text", 197 197 - }, 198 198 - { 199 199 - name: "custom formatter", 200 200 - envLevel: "info", 201 201 - envFormatter: "json", 202 202 - setLevel: true, 203 203 - setFormatter: true, 204 204 - wantLevel: "info", 205 205 - wantFormatter: "json", 206 206 - }, 207 207 - } 72 72 + // TestBuildLogConfig removed - buildLogConfig is now an internal function 208 73 209 209 - for _, tt := range tests { 210 210 - t.Run(tt.name, func(t *testing.T) { 211 211 - if tt.setLevel { 212 212 - t.Setenv("ATCR_LOG_LEVEL", tt.envLevel) 213 213 - } else { 214 214 - os.Unsetenv("ATCR_LOG_LEVEL") 215 215 - } 216 216 - 217 217 - if tt.setFormatter { 218 218 - t.Setenv("ATCR_LOG_FORMATTER", tt.envFormatter) 219 219 - } else { 220 220 - os.Unsetenv("ATCR_LOG_FORMATTER") 221 221 - } 222 222 - 223 223 - got := buildLogConfig() 224 224 - if got.Level != tt.wantLevel { 225 225 - t.Errorf("buildLogConfig().Level = %v, want %v", got.Level, tt.wantLevel) 226 226 - } 227 227 - if got.Formatter != tt.wantFormatter { 228 228 - t.Errorf("buildLogConfig().Formatter = %v, want %v", got.Formatter, tt.wantFormatter) 229 229 - } 230 230 - if got.Fields["service"] != "atcr-appview" { 231 231 - t.Errorf("buildLogConfig().Fields[service] = %v, want atcr-appview", got.Fields["service"]) 232 232 - } 233 233 - }) 234 234 - } 235 235 - } 236 236 - 237 237 - func TestBuildHTTPConfig(t *testing.T) { 238 238 - tests := []struct { 239 239 - name string 240 240 - envAddr string 241 241 - envDebugAddr string 242 242 - envSecret string 243 243 - setAddr bool 244 244 - setDebugAddr bool 245 245 - setSecret bool 246 246 - wantAddr string 247 247 - wantDebug string 248 248 - wantSecret string // empty means "should be generated" 249 249 - }{ 250 250 - { 251 251 - name: "defaults", 252 252 - setAddr: false, 253 253 - wantAddr: ":5000", 254 254 - wantDebug: ":5001", 255 255 - wantSecret: "", // generated 256 256 - }, 257 257 - { 258 258 - name: "custom addr", 259 259 - envAddr: ":8080", 260 260 - setAddr: true, 261 261 - setDebugAddr: false, 262 262 - wantAddr: ":8080", 263 263 - wantDebug: ":5001", 264 264 - wantSecret: "", 265 265 - }, 266 266 - { 267 267 - name: "custom debug addr", 268 268 - envDebugAddr: ":9001", 269 269 - setAddr: false, 270 270 - setDebugAddr: true, 271 271 - wantAddr: ":5000", 272 272 - wantDebug: ":9001", 273 273 - wantSecret: "", 274 274 - }, 275 275 - { 276 276 - name: "custom secret", 277 277 - envSecret: "my-custom-secret", 278 278 - setAddr: false, 279 279 - setSecret: true, 280 280 - wantAddr: ":5000", 281 281 - wantDebug: ":5001", 282 282 - wantSecret: "my-custom-secret", 283 283 - }, 284 284 - } 285 285 - 286 286 - for _, tt := range tests { 287 287 - t.Run(tt.name, func(t *testing.T) { 288 288 - if tt.setAddr { 289 289 - t.Setenv("ATCR_HTTP_ADDR", tt.envAddr) 290 290 - } else { 291 291 - os.Unsetenv("ATCR_HTTP_ADDR") 292 292 - } 293 293 - 294 294 - if tt.setDebugAddr { 295 295 - t.Setenv("ATCR_DEBUG_ADDR", tt.envDebugAddr) 296 296 - } else { 297 297 - os.Unsetenv("ATCR_DEBUG_ADDR") 298 298 - } 299 299 - 300 300 - if tt.setSecret { 301 301 - t.Setenv("REGISTRY_HTTP_SECRET", tt.envSecret) 302 302 - } else { 303 303 - os.Unsetenv("REGISTRY_HTTP_SECRET") 304 304 - } 305 305 - 306 306 - got, err := buildHTTPConfig() 307 307 - if err != nil { 308 308 - t.Fatalf("buildHTTPConfig() error = %v", err) 309 309 - } 310 310 - 311 311 - if got.Addr != tt.wantAddr { 312 312 - t.Errorf("buildHTTPConfig().Addr = %v, want %v", got.Addr, tt.wantAddr) 313 313 - } 314 314 - 315 315 - if got.Debug.Addr != tt.wantDebug { 316 316 - t.Errorf("buildHTTPConfig().Debug.Addr = %v, want %v", got.Debug.Addr, tt.wantDebug) 317 317 - } 318 318 - 319 319 - if tt.wantSecret == "" { 320 320 - // Should be generated (64 hex chars = 32 bytes) 321 321 - if len(got.Secret) != 64 { 322 322 - t.Errorf("buildHTTPConfig().Secret length = %v, want 64", len(got.Secret)) 323 323 - } 324 324 - } else { 325 325 - if got.Secret != tt.wantSecret { 326 326 - t.Errorf("buildHTTPConfig().Secret = %v, want %v", got.Secret, tt.wantSecret) 327 327 - } 328 328 - } 329 329 - 330 330 - // Verify headers 331 331 - if got.Headers["X-Content-Type-Options"][0] != "nosniff" { 332 332 - t.Error("buildHTTPConfig() missing X-Content-Type-Options header") 333 333 - } 334 334 - }) 335 335 - } 336 336 - } 74 74 + // TestBuildHTTPConfig removed - buildHTTPConfig is now an internal function 337 75 338 76 func TestBuildStorageConfig(t *testing.T) { 339 77 got := buildStorageConfig() ··· 430 168 } 431 169 } 432 170 433 433 - func TestBuildAuthConfig(t *testing.T) { 434 434 - tests := []struct { 435 435 - name string 436 436 - baseURL string 437 437 - envKeyPath string 438 438 - envCertPath string 439 439 - envExpiration string 440 440 - setKeyPath bool 441 441 - setCertPath bool 442 442 - setExpiration bool 443 443 - wantKeyPath string 444 444 - wantCertPath string 445 445 - wantExpiration int 446 446 - wantRealm string 447 447 - wantService string 448 448 - wantError bool 449 449 - }{ 450 450 - { 451 451 - name: "defaults", 452 452 - baseURL: "http://127.0.0.1:5000", 453 453 - setKeyPath: false, 454 454 - setCertPath: false, 455 455 - setExpiration: false, 456 456 - wantKeyPath: "/var/lib/atcr/auth/private-key.pem", 457 457 - wantCertPath: "/var/lib/atcr/auth/private-key.crt", 458 458 - wantExpiration: 300, 459 459 - wantRealm: "http://127.0.0.1:5000/auth/token", 460 460 - wantService: "atcr.io", 461 461 - wantError: false, 462 462 - }, 463 463 - { 464 464 - name: "custom values", 465 465 - baseURL: "https://registry.example.com", 466 466 - envKeyPath: "/custom/key.pem", 467 467 - envCertPath: "/custom/cert.crt", 468 468 - envExpiration: "600", 469 469 - setKeyPath: true, 470 470 - setCertPath: true, 471 471 - setExpiration: true, 472 472 - wantKeyPath: "/custom/key.pem", 473 473 - wantCertPath: "/custom/cert.crt", 474 474 - wantExpiration: 600, 475 475 - wantRealm: "https://registry.example.com/auth/token", 476 476 - wantService: "registry.example.com", 477 477 - wantError: false, 478 478 - }, 479 479 - { 480 480 - name: "invalid expiration", 481 481 - baseURL: "http://127.0.0.1:5000", 482 482 - envExpiration: "not-a-number", 483 483 - setExpiration: true, 484 484 - wantError: true, 485 485 - }, 486 486 - } 487 487 - 488 488 - for _, tt := range tests { 489 489 - t.Run(tt.name, func(t *testing.T) { 490 490 - if tt.setKeyPath { 491 491 - t.Setenv("ATCR_AUTH_KEY_PATH", tt.envKeyPath) 492 492 - } else { 493 493 - os.Unsetenv("ATCR_AUTH_KEY_PATH") 494 494 - } 495 495 - 496 496 - if tt.setCertPath { 497 497 - t.Setenv("ATCR_AUTH_CERT_PATH", tt.envCertPath) 498 498 - } else { 499 499 - os.Unsetenv("ATCR_AUTH_CERT_PATH") 500 500 - } 501 501 - 502 502 - if tt.setExpiration { 503 503 - t.Setenv("ATCR_TOKEN_EXPIRATION", tt.envExpiration) 504 504 - } else { 505 505 - os.Unsetenv("ATCR_TOKEN_EXPIRATION") 506 506 - } 507 507 - 508 508 - // Clear service name env var 509 509 - os.Unsetenv("ATCR_SERVICE_NAME") 510 510 - 511 511 - got, err := buildAuthConfig(tt.baseURL) 512 512 - if (err != nil) != tt.wantError { 513 513 - t.Errorf("buildAuthConfig() error = %v, wantError %v", err, tt.wantError) 514 514 - return 515 515 - } 516 516 - 517 517 - if tt.wantError { 518 518 - return 519 519 - } 520 520 - 521 521 - tokenParams, ok := got["token"] 522 522 - if !ok { 523 523 - t.Fatal("buildAuthConfig() missing token params") 524 524 - } 525 525 - 526 526 - if tokenParams["privatekey"] != tt.wantKeyPath { 527 527 - t.Errorf("privatekey = %v, want %v", tokenParams["privatekey"], tt.wantKeyPath) 528 528 - } 529 529 - 530 530 - if tokenParams["rootcertbundle"] != tt.wantCertPath { 531 531 - t.Errorf("rootcertbundle = %v, want %v", tokenParams["rootcertbundle"], tt.wantCertPath) 532 532 - } 533 533 - 534 534 - if tokenParams["expiration"] != tt.wantExpiration { 535 535 - t.Errorf("expiration = %v, want %v", tokenParams["expiration"], tt.wantExpiration) 536 536 - } 537 537 - 538 538 - if tokenParams["realm"] != tt.wantRealm { 539 539 - t.Errorf("realm = %v, want %v", tokenParams["realm"], tt.wantRealm) 540 540 - } 541 541 - 542 542 - if tokenParams["service"] != tt.wantService { 543 543 - t.Errorf("service = %v, want %v", tokenParams["service"], tt.wantService) 544 544 - } 545 545 - 546 546 - if tokenParams["issuer"] != tt.wantService { 547 547 - t.Errorf("issuer = %v, want %v", tokenParams["issuer"], tt.wantService) 548 548 - } 549 549 - }) 550 550 - } 551 551 - } 552 552 - 553 171 func TestBuildHealthConfig(t *testing.T) { 554 172 got := buildHealthConfig() 555 173 ··· 566 184 } 567 185 } 568 186 569 569 - func TestGetStringParam(t *testing.T) { 570 570 - tests := []struct { 571 571 - name string 572 572 - params configuration.Parameters 573 573 - key string 574 574 - defaultValue string 575 575 - want string 576 576 - }{ 577 577 - { 578 578 - name: "string value exists", 579 579 - params: configuration.Parameters{ 580 580 - "foo": "bar", 581 581 - }, 582 582 - key: "foo", 583 583 - defaultValue: "default", 584 584 - want: "bar", 585 585 - }, 586 586 - { 587 587 - name: "key does not exist", 588 588 - params: configuration.Parameters{}, 589 589 - key: "foo", 590 590 - defaultValue: "default", 591 591 - want: "default", 592 592 - }, 593 593 - { 594 594 - name: "value is not a string", 595 595 - params: configuration.Parameters{ 596 596 - "foo": 123, 597 597 - }, 598 598 - key: "foo", 599 599 - defaultValue: "default", 600 600 - want: "default", 601 601 - }, 602 602 - { 603 603 - name: "empty string value", 604 604 - params: configuration.Parameters{ 605 605 - "foo": "", 606 606 - }, 607 607 - key: "foo", 608 608 - defaultValue: "default", 609 609 - want: "", 610 610 - }, 611 611 - } 612 612 - 613 613 - for _, tt := range tests { 614 614 - t.Run(tt.name, func(t *testing.T) { 615 615 - got := GetStringParam(tt.params, tt.key, tt.defaultValue) 616 616 - if got != tt.want { 617 617 - t.Errorf("GetStringParam() = %v, want %v", got, tt.want) 618 618 - } 619 619 - }) 620 620 - } 621 621 - } 622 622 - 623 623 - func TestGetIntParam(t *testing.T) { 624 624 - tests := []struct { 625 625 - name string 626 626 - params configuration.Parameters 627 627 - key string 628 628 - defaultValue int 629 629 - want int 630 630 - }{ 631 631 - { 632 632 - name: "int value exists", 633 633 - params: configuration.Parameters{ 634 634 - "foo": 42, 635 635 - }, 636 636 - key: "foo", 637 637 - defaultValue: 100, 638 638 - want: 42, 639 639 - }, 640 640 - { 641 641 - name: "key does not exist", 642 642 - params: configuration.Parameters{}, 643 643 - key: "foo", 644 644 - defaultValue: 100, 645 645 - want: 100, 646 646 - }, 647 647 - { 648 648 - name: "value is not an int", 649 649 - params: configuration.Parameters{ 650 650 - "foo": "not-an-int", 651 651 - }, 652 652 - key: "foo", 653 653 - defaultValue: 100, 654 654 - want: 100, 655 655 - }, 656 656 - { 657 657 - name: "zero value", 658 658 - params: configuration.Parameters{ 659 659 - "foo": 0, 660 660 - }, 661 661 - key: "foo", 662 662 - defaultValue: 100, 663 663 - want: 0, 664 664 - }, 665 665 - } 666 666 - 667 667 - for _, tt := range tests { 668 668 - t.Run(tt.name, func(t *testing.T) { 669 669 - got := GetIntParam(tt.params, tt.key, tt.defaultValue) 670 670 - if got != tt.want { 671 671 - t.Errorf("GetIntParam() = %v, want %v", got, tt.want) 672 672 - } 673 673 - }) 674 674 - } 675 675 - } 676 676 - 677 677 - func TestExtractDefaultHoldDID(t *testing.T) { 678 678 - tests := []struct { 679 679 - name string 680 680 - config *configuration.Configuration 681 681 - want string 682 682 - }{ 683 683 - { 684 684 - name: "valid config with hold DID", 685 685 - config: &configuration.Configuration{ 686 686 - Middleware: map[string][]configuration.Middleware{ 687 687 - "registry": { 688 688 - { 689 689 - Name: "atproto-resolver", 690 690 - Options: configuration.Parameters{ 691 691 - "default_hold_did": "did:web:hold01.atcr.io", 692 692 - }, 693 693 - }, 694 694 - }, 695 695 - }, 696 696 - }, 697 697 - want: "did:web:hold01.atcr.io", 698 698 - }, 699 699 - { 700 700 - name: "no registry middleware", 701 701 - config: &configuration.Configuration{ 702 702 - Middleware: map[string][]configuration.Middleware{}, 703 703 - }, 704 704 - want: "", 705 705 - }, 706 706 - { 707 707 - name: "no atproto-resolver middleware", 708 708 - config: &configuration.Configuration{ 709 709 - Middleware: map[string][]configuration.Middleware{ 710 710 - "registry": { 711 711 - { 712 712 - Name: "other-middleware", 713 713 - Options: configuration.Parameters{ 714 714 - "foo": "bar", 715 715 - }, 716 716 - }, 717 717 - }, 718 718 - }, 719 719 - }, 720 720 - want: "", 721 721 - }, 722 722 - { 723 723 - name: "atproto-resolver without default_hold_did", 724 724 - config: &configuration.Configuration{ 725 725 - Middleware: map[string][]configuration.Middleware{ 726 726 - "registry": { 727 727 - { 728 728 - Name: "atproto-resolver", 729 729 - Options: configuration.Parameters{ 730 730 - "other_option": "value", 731 731 - }, 732 732 - }, 733 733 - }, 734 734 - }, 735 735 - }, 736 736 - want: "", 737 737 - }, 738 738 - { 739 739 - name: "default_hold_did is not a string", 740 740 - config: &configuration.Configuration{ 741 741 - Middleware: map[string][]configuration.Middleware{ 742 742 - "registry": { 743 743 - { 744 744 - Name: "atproto-resolver", 745 745 - Options: configuration.Parameters{ 746 746 - "default_hold_did": 123, 747 747 - }, 748 748 - }, 749 749 - }, 750 750 - }, 751 751 - }, 752 752 - want: "", 753 753 - }, 754 754 - { 755 755 - name: "nil options", 756 756 - config: &configuration.Configuration{ 757 757 - Middleware: map[string][]configuration.Middleware{ 758 758 - "registry": { 759 759 - { 760 760 - Name: "atproto-resolver", 761 761 - Options: nil, 762 762 - }, 763 763 - }, 764 764 - }, 765 765 - }, 766 766 - want: "", 767 767 - }, 768 768 - } 769 769 - 770 770 - for _, tt := range tests { 771 771 - t.Run(tt.name, func(t *testing.T) { 772 772 - got := ExtractDefaultHoldDID(tt.config) 773 773 - if got != tt.want { 774 774 - t.Errorf("ExtractDefaultHoldDID() = %v, want %v", got, tt.want) 775 775 - } 776 776 - }) 777 777 - } 778 778 - } 779 779 - 780 780 - func TestExtractTestMode(t *testing.T) { 781 781 - tests := []struct { 782 782 - name string 783 783 - config *configuration.Configuration 784 784 - want bool 785 785 - }{ 786 786 - { 787 787 - name: "test mode enabled", 788 788 - config: &configuration.Configuration{ 789 789 - Middleware: map[string][]configuration.Middleware{ 790 790 - "registry": { 791 791 - { 792 792 - Name: "atproto-resolver", 793 793 - Options: configuration.Parameters{ 794 794 - "test_mode": true, 795 795 - }, 796 796 - }, 797 797 - }, 798 798 - }, 799 799 - }, 800 800 - want: true, 801 801 - }, 802 802 - { 803 803 - name: "test mode disabled", 804 804 - config: &configuration.Configuration{ 805 805 - Middleware: map[string][]configuration.Middleware{ 806 806 - "registry": { 807 807 - { 808 808 - Name: "atproto-resolver", 809 809 - Options: configuration.Parameters{ 810 810 - "test_mode": false, 811 811 - }, 812 812 - }, 813 813 - }, 814 814 - }, 815 815 - }, 816 816 - want: false, 817 817 - }, 818 818 - { 819 819 - name: "no registry middleware", 820 820 - config: &configuration.Configuration{ 821 821 - Middleware: map[string][]configuration.Middleware{}, 822 822 - }, 823 823 - want: false, 824 824 - }, 825 825 - { 826 826 - name: "no atproto-resolver middleware", 827 827 - config: &configuration.Configuration{ 828 828 - Middleware: map[string][]configuration.Middleware{ 829 829 - "registry": { 830 830 - { 831 831 - Name: "other-middleware", 832 832 - Options: configuration.Parameters{ 833 833 - "foo": "bar", 834 834 - }, 835 835 - }, 836 836 - }, 837 837 - }, 838 838 - }, 839 839 - want: false, 840 840 - }, 841 841 - { 842 842 - name: "atproto-resolver without test_mode", 843 843 - config: &configuration.Configuration{ 844 844 - Middleware: map[string][]configuration.Middleware{ 845 845 - "registry": { 846 846 - { 847 847 - Name: "atproto-resolver", 848 848 - Options: configuration.Parameters{ 849 849 - "other_option": "value", 850 850 - }, 851 851 - }, 852 852 - }, 853 853 - }, 854 854 - }, 855 855 - want: false, 856 856 - }, 857 857 - { 858 858 - name: "test_mode is not a bool", 859 859 - config: &configuration.Configuration{ 860 860 - Middleware: map[string][]configuration.Middleware{ 861 861 - "registry": { 862 862 - { 863 863 - Name: "atproto-resolver", 864 864 - Options: configuration.Parameters{ 865 865 - "test_mode": "true", 866 866 - }, 867 867 - }, 868 868 - }, 869 869 - }, 870 870 - }, 871 871 - want: false, 872 872 - }, 873 873 - { 874 874 - name: "nil options", 875 875 - config: &configuration.Configuration{ 876 876 - Middleware: map[string][]configuration.Middleware{ 877 877 - "registry": { 878 878 - { 879 879 - Name: "atproto-resolver", 880 880 - Options: nil, 881 881 - }, 882 882 - }, 883 883 - }, 884 884 - }, 885 885 - want: false, 886 886 - }, 887 887 - } 888 888 - 889 889 - for _, tt := range tests { 890 890 - t.Run(tt.name, func(t *testing.T) { 891 891 - got := ExtractTestMode(tt.config) 892 892 - if got != tt.want { 893 893 - t.Errorf("ExtractTestMode() = %v, want %v", got, tt.want) 894 894 - } 895 895 - }) 896 896 - } 897 897 - } 898 898 - 899 187 func TestLoadConfigFromEnv(t *testing.T) { 900 188 tests := []struct { 901 189 name string ··· 939 227 } 940 228 941 229 // Verify config structure 942 942 - if got.Version.Major() != 0 || got.Version.Minor() != 1 { 230 230 + if got.Version != "0.1" { 943 231 t.Errorf("version = %v, want 0.1", got.Version) 944 232 } 945 233 946 946 - if got.Log.Level != "info" { 947 947 - t.Errorf("log level = %v, want info", got.Log.Level) 234 234 + if got.LogLevel != "info" { 235 235 + t.Errorf("log level = %v, want info", got.LogLevel) 948 236 } 949 237 950 950 - if got.HTTP.Addr != ":5000" { 951 951 - t.Errorf("HTTP addr = %v, want :5000", got.HTTP.Addr) 238 238 + if got.Server.Addr != ":5000" { 239 239 + t.Errorf("HTTP addr = %v, want :5000", got.Server.Addr) 952 240 } 953 241 954 954 - if _, ok := got.Storage["inmemory"]; !ok { 955 955 - t.Error("storage missing inmemory driver") 242 242 + if got.Server.DefaultHoldDID != tt.envHoldDID { 243 243 + t.Errorf("default hold DID = %v, want %v", got.Server.DefaultHoldDID, tt.envHoldDID) 956 244 } 957 245 958 958 - if _, ok := got.Middleware["registry"]; !ok { 959 959 - t.Error("middleware missing registry") 246 246 + if got.UI.DatabasePath != "/var/lib/atcr/ui.db" { 247 247 + t.Errorf("UI database path = %v, want /var/lib/atcr/ui.db", got.UI.DatabasePath) 960 248 } 961 249 962 962 - if _, ok := got.Auth["token"]; !ok { 963 963 - t.Error("auth missing token config") 250 250 + if got.Health.CacheTTL != 15*time.Minute { 251 251 + t.Errorf("health cache TTL = %v, want 15m", got.Health.CacheTTL) 964 252 } 965 253 966 966 - if !got.Health.StorageDriver.Enabled { 967 967 - t.Error("health storage driver not enabled") 254 254 + if got.Jetstream.URL != "wss://jetstream2.us-west.bsky.network/subscribe" { 255 255 + t.Errorf("jetstream URL = %v, want default", got.Jetstream.URL) 968 256 } 969 969 - }) 970 970 - } 971 971 - } 972 257 973 973 - func TestGetDurationOrDefault(t *testing.T) { 974 974 - tests := []struct { 975 975 - name string 976 976 - envKey string 977 977 - envValue string 978 978 - setEnv bool 979 979 - defaultValue string 980 980 - want string 981 981 - }{ 982 982 - { 983 983 - name: "env var not set", 984 984 - envKey: "TEST_DURATION", 985 985 - setEnv: false, 986 986 - defaultValue: "5m", 987 987 - want: "5m", 988 988 - }, 989 989 - { 990 990 - name: "env var set to valid duration", 991 991 - envKey: "TEST_DURATION", 992 992 - envValue: "10m", 993 993 - setEnv: true, 994 994 - defaultValue: "5m", 995 995 - want: "10m", 996 996 - }, 997 997 - { 998 998 - name: "env var set to invalid duration", 999 999 - envKey: "TEST_DURATION", 1000 1000 - envValue: "invalid", 1001 1001 - setEnv: true, 1002 1002 - defaultValue: "5m", 1003 1003 - want: "5m", // Falls back to default 1004 1004 - }, 1005 1005 - { 1006 1006 - name: "env var set to empty string", 1007 1007 - envKey: "TEST_DURATION", 1008 1008 - envValue: "", 1009 1009 - setEnv: true, 1010 1010 - defaultValue: "15m", 1011 1011 - want: "15m", 1012 1012 - }, 1013 1013 - } 1014 1014 - 1015 1015 - for _, tt := range tests { 1016 1016 - t.Run(tt.name, func(t *testing.T) { 1017 1017 - if tt.setEnv { 1018 1018 - t.Setenv(tt.envKey, tt.envValue) 1019 1019 - } else { 1020 1020 - os.Unsetenv(tt.envKey) 258 258 + // Verify distribution config was built 259 259 + if got.Distribution == nil { 260 260 + t.Error("distribution config is nil") 1021 261 } 1022 262 1023 1023 - defaultDur := parseDuration(t, tt.defaultValue) 1024 1024 - wantDur := parseDuration(t, tt.want) 1025 1025 - 1026 1026 - got := GetDurationOrDefault(tt.envKey, defaultDur) 1027 1027 - if got != wantDur { 1028 1028 - t.Errorf("GetDurationOrDefault() = %v, want %v", got, wantDur) 263 263 + if _, ok := got.Distribution.Storage["inmemory"]; !ok { 264 264 + t.Error("distribution storage missing inmemory driver") 1029 265 } 1030 1030 - }) 1031 1031 - } 1032 1032 - } 1033 266 1034 1034 - func TestGetBoolOrDefault(t *testing.T) { 1035 1035 - tests := []struct { 1036 1036 - name string 1037 1037 - envKey string 1038 1038 - envValue string 1039 1039 - setEnv bool 1040 1040 - defaultValue bool 1041 1041 - want bool 1042 1042 - }{ 1043 1043 - { 1044 1044 - name: "env var not set - default true", 1045 1045 - envKey: "TEST_BOOL", 1046 1046 - setEnv: false, 1047 1047 - defaultValue: true, 1048 1048 - want: true, 1049 1049 - }, 1050 1050 - { 1051 1051 - name: "env var not set - default false", 1052 1052 - envKey: "TEST_BOOL", 1053 1053 - setEnv: false, 1054 1054 - defaultValue: false, 1055 1055 - want: false, 1056 1056 - }, 1057 1057 - { 1058 1058 - name: "env var set to true", 1059 1059 - envKey: "TEST_BOOL", 1060 1060 - envValue: "true", 1061 1061 - setEnv: true, 1062 1062 - defaultValue: false, 1063 1063 - want: true, 1064 1064 - }, 1065 1065 - { 1066 1066 - name: "env var set to false", 1067 1067 - envKey: "TEST_BOOL", 1068 1068 - envValue: "false", 1069 1069 - setEnv: true, 1070 1070 - defaultValue: true, 1071 1071 - want: false, 1072 1072 - }, 1073 1073 - { 1074 1074 - name: "env var set to invalid value - use default true", 1075 1075 - envKey: "TEST_BOOL", 1076 1076 - envValue: "invalid", 1077 1077 - setEnv: true, 1078 1078 - defaultValue: true, 1079 1079 - want: true, 1080 1080 - }, 1081 1081 - { 1082 1082 - name: "env var set to invalid value - use default false", 1083 1083 - envKey: "TEST_BOOL", 1084 1084 - envValue: "invalid", 1085 1085 - setEnv: true, 1086 1086 - defaultValue: false, 1087 1087 - want: false, 1088 1088 - }, 1089 1089 - { 1090 1090 - name: "env var set to empty string - use default", 1091 1091 - envKey: "TEST_BOOL", 1092 1092 - envValue: "", 1093 1093 - setEnv: true, 1094 1094 - defaultValue: true, 1095 1095 - want: true, 1096 1096 - }, 1097 1097 - } 1098 1098 - 1099 1099 - for _, tt := range tests { 1100 1100 - t.Run(tt.name, func(t *testing.T) { 1101 1101 - if tt.setEnv { 1102 1102 - t.Setenv(tt.envKey, tt.envValue) 1103 1103 - } else { 1104 1104 - os.Unsetenv(tt.envKey) 267 267 + if _, ok := got.Distribution.Middleware["registry"]; !ok { 268 268 + t.Error("distribution middleware missing registry") 1105 269 } 1106 270 1107 1107 - got := GetBoolOrDefault(tt.envKey, tt.defaultValue) 1108 1108 - if got != tt.want { 1109 1109 - t.Errorf("GetBoolOrDefault() = %v, want %v", got, tt.want) 271 271 + if _, ok := got.Distribution.Auth["token"]; !ok { 272 272 + t.Error("distribution auth missing token config") 1110 273 } 1111 274 }) 1112 275 } 1113 276 } 1114 1114 - 1115 1115 - func TestGetUIEnabled(t *testing.T) { 1116 1116 - tests := []struct { 1117 1117 - name string 1118 1118 - envValue string 1119 1119 - setEnv bool 1120 1120 - want bool 1121 1121 - }{ 1122 1122 - { 1123 1123 - name: "env var not set - enabled by default", 1124 1124 - setEnv: false, 1125 1125 - want: true, 1126 1126 - }, 1127 1127 - { 1128 1128 - name: "env var set to false", 1129 1129 - envValue: "false", 1130 1130 - setEnv: true, 1131 1131 - want: false, 1132 1132 - }, 1133 1133 - { 1134 1134 - name: "env var set to true", 1135 1135 - envValue: "true", 1136 1136 - setEnv: true, 1137 1137 - want: true, 1138 1138 - }, 1139 1139 - { 1140 1140 - name: "env var set to empty string - enabled by default", 1141 1141 - envValue: "", 1142 1142 - setEnv: true, 1143 1143 - want: true, 1144 1144 - }, 1145 1145 - { 1146 1146 - name: "env var set to any other value - enabled", 1147 1147 - envValue: "yes", 1148 1148 - setEnv: true, 1149 1149 - want: true, 1150 1150 - }, 1151 1151 - } 1152 1152 - 1153 1153 - for _, tt := range tests { 1154 1154 - t.Run(tt.name, func(t *testing.T) { 1155 1155 - if tt.setEnv { 1156 1156 - t.Setenv("ATCR_UI_ENABLED", tt.envValue) 1157 1157 - } else { 1158 1158 - os.Unsetenv("ATCR_UI_ENABLED") 1159 1159 - } 1160 1160 - 1161 1161 - got := GetUIEnabled() 1162 1162 - if got != tt.want { 1163 1163 - t.Errorf("GetUIEnabled() = %v, want %v", got, tt.want) 1164 1164 - } 1165 1165 - }) 1166 1166 - } 1167 1167 - } 1168 1168 - 1169 1169 - func TestGetUIDatabasePath(t *testing.T) { 1170 1170 - tests := []struct { 1171 1171 - name string 1172 1172 - envValue string 1173 1173 - setEnv bool 1174 1174 - want string 1175 1175 - }{ 1176 1176 - { 1177 1177 - name: "env var not set - use default", 1178 1178 - setEnv: false, 1179 1179 - want: "/var/lib/atcr/ui.db", 1180 1180 - }, 1181 1181 - { 1182 1182 - name: "env var set to custom path", 1183 1183 - envValue: "/custom/path/ui.db", 1184 1184 - setEnv: true, 1185 1185 - want: "/custom/path/ui.db", 1186 1186 - }, 1187 1187 - { 1188 1188 - name: "env var set to empty string - use default", 1189 1189 - envValue: "", 1190 1190 - setEnv: true, 1191 1191 - want: "/var/lib/atcr/ui.db", 1192 1192 - }, 1193 1193 - } 1194 1194 - 1195 1195 - for _, tt := range tests { 1196 1196 - t.Run(tt.name, func(t *testing.T) { 1197 1197 - if tt.setEnv { 1198 1198 - t.Setenv("ATCR_UI_DATABASE_PATH", tt.envValue) 1199 1199 - } else { 1200 1200 - os.Unsetenv("ATCR_UI_DATABASE_PATH") 1201 1201 - } 1202 1202 - 1203 1203 - got := GetUIDatabasePath() 1204 1204 - if got != tt.want { 1205 1205 - t.Errorf("GetUIDatabasePath() = %v, want %v", got, tt.want) 1206 1206 - } 1207 1207 - }) 1208 1208 - } 1209 1209 - } 1210 1210 - 1211 1211 - func TestGetHealthCacheTTL(t *testing.T) { 1212 1212 - tests := []struct { 1213 1213 - name string 1214 1214 - envValue string 1215 1215 - setEnv bool 1216 1216 - want string 1217 1217 - }{ 1218 1218 - { 1219 1219 - name: "env var not set - use default 15m", 1220 1220 - setEnv: false, 1221 1221 - want: "15m", 1222 1222 - }, 1223 1223 - { 1224 1224 - name: "env var set to custom duration", 1225 1225 - envValue: "30m", 1226 1226 - setEnv: true, 1227 1227 - want: "30m", 1228 1228 - }, 1229 1229 - { 1230 1230 - name: "env var set to invalid duration - use default", 1231 1231 - envValue: "invalid", 1232 1232 - setEnv: true, 1233 1233 - want: "15m", 1234 1234 - }, 1235 1235 - } 1236 1236 - 1237 1237 - for _, tt := range tests { 1238 1238 - t.Run(tt.name, func(t *testing.T) { 1239 1239 - if tt.setEnv { 1240 1240 - t.Setenv("ATCR_HEALTH_CACHE_TTL", tt.envValue) 1241 1241 - } else { 1242 1242 - os.Unsetenv("ATCR_HEALTH_CACHE_TTL") 1243 1243 - } 1244 1244 - 1245 1245 - wantDur := parseDuration(t, tt.want) 1246 1246 - got := GetHealthCacheTTL() 1247 1247 - if got != wantDur { 1248 1248 - t.Errorf("GetHealthCacheTTL() = %v, want %v", got, wantDur) 1249 1249 - } 1250 1250 - }) 1251 1251 - } 1252 1252 - } 1253 1253 - 1254 1254 - func TestGetReadmeCacheTTL(t *testing.T) { 1255 1255 - tests := []struct { 1256 1256 - name string 1257 1257 - envValue string 1258 1258 - setEnv bool 1259 1259 - want string 1260 1260 - }{ 1261 1261 - { 1262 1262 - name: "env var not set - use default 1h", 1263 1263 - setEnv: false, 1264 1264 - want: "1h", 1265 1265 - }, 1266 1266 - { 1267 1267 - name: "env var set to custom duration", 1268 1268 - envValue: "2h", 1269 1269 - setEnv: true, 1270 1270 - want: "2h", 1271 1271 - }, 1272 1272 - { 1273 1273 - name: "env var set to invalid duration - use default", 1274 1274 - envValue: "invalid", 1275 1275 - setEnv: true, 1276 1276 - want: "1h", 1277 1277 - }, 1278 1278 - } 1279 1279 - 1280 1280 - for _, tt := range tests { 1281 1281 - t.Run(tt.name, func(t *testing.T) { 1282 1282 - if tt.setEnv { 1283 1283 - t.Setenv("ATCR_README_CACHE_TTL", tt.envValue) 1284 1284 - } else { 1285 1285 - os.Unsetenv("ATCR_README_CACHE_TTL") 1286 1286 - } 1287 1287 - 1288 1288 - wantDur := parseDuration(t, tt.want) 1289 1289 - got := GetReadmeCacheTTL() 1290 1290 - if got != wantDur { 1291 1291 - t.Errorf("GetReadmeCacheTTL() = %v, want %v", got, wantDur) 1292 1292 - } 1293 1293 - }) 1294 1294 - } 1295 1295 - } 1296 1296 - 1297 1297 - func TestGetHealthCheckInterval(t *testing.T) { 1298 1298 - tests := []struct { 1299 1299 - name string 1300 1300 - envValue string 1301 1301 - setEnv bool 1302 1302 - want string 1303 1303 - }{ 1304 1304 - { 1305 1305 - name: "env var not set - use default 15m", 1306 1306 - setEnv: false, 1307 1307 - want: "15m", 1308 1308 - }, 1309 1309 - { 1310 1310 - name: "env var set to custom interval", 1311 1311 - envValue: "5m", 1312 1312 - setEnv: true, 1313 1313 - want: "5m", 1314 1314 - }, 1315 1315 - { 1316 1316 - name: "env var set to invalid duration - use default", 1317 1317 - envValue: "invalid", 1318 1318 - setEnv: true, 1319 1319 - want: "15m", 1320 1320 - }, 1321 1321 - } 1322 1322 - 1323 1323 - for _, tt := range tests { 1324 1324 - t.Run(tt.name, func(t *testing.T) { 1325 1325 - if tt.setEnv { 1326 1326 - t.Setenv("ATCR_HEALTH_CHECK_INTERVAL", tt.envValue) 1327 1327 - } else { 1328 1328 - os.Unsetenv("ATCR_HEALTH_CHECK_INTERVAL") 1329 1329 - } 1330 1330 - 1331 1331 - wantDur := parseDuration(t, tt.want) 1332 1332 - got := GetHealthCheckInterval() 1333 1333 - if got != wantDur { 1334 1334 - t.Errorf("GetHealthCheckInterval() = %v, want %v", got, wantDur) 1335 1335 - } 1336 1336 - }) 1337 1337 - } 1338 1338 - } 1339 1339 - 1340 1340 - func TestGetJetstreamURL(t *testing.T) { 1341 1341 - tests := []struct { 1342 1342 - name string 1343 1343 - envValue string 1344 1344 - setEnv bool 1345 1345 - want string 1346 1346 - }{ 1347 1347 - { 1348 1348 - name: "env var not set - use default", 1349 1349 - setEnv: false, 1350 1350 - want: "wss://jetstream2.us-west.bsky.network/subscribe", 1351 1351 - }, 1352 1352 - { 1353 1353 - name: "env var set to custom URL", 1354 1354 - envValue: "wss://custom-jetstream.example.com/subscribe", 1355 1355 - setEnv: true, 1356 1356 - want: "wss://custom-jetstream.example.com/subscribe", 1357 1357 - }, 1358 1358 - { 1359 1359 - name: "env var set to empty string - use default", 1360 1360 - envValue: "", 1361 1361 - setEnv: true, 1362 1362 - want: "wss://jetstream2.us-west.bsky.network/subscribe", 1363 1363 - }, 1364 1364 - } 1365 1365 - 1366 1366 - for _, tt := range tests { 1367 1367 - t.Run(tt.name, func(t *testing.T) { 1368 1368 - if tt.setEnv { 1369 1369 - t.Setenv("JETSTREAM_URL", tt.envValue) 1370 1370 - } else { 1371 1371 - os.Unsetenv("JETSTREAM_URL") 1372 1372 - } 1373 1373 - 1374 1374 - got := GetJetstreamURL() 1375 1375 - if got != tt.want { 1376 1376 - t.Errorf("GetJetstreamURL() = %v, want %v", got, tt.want) 1377 1377 - } 1378 1378 - }) 1379 1379 - } 1380 1380 - } 1381 1381 - 1382 1382 - func TestGetBackfillEnabled(t *testing.T) { 1383 1383 - tests := []struct { 1384 1384 - name string 1385 1385 - envValue string 1386 1386 - setEnv bool 1387 1387 - want bool 1388 1388 - }{ 1389 1389 - { 1390 1390 - name: "env var not set - enabled by default", 1391 1391 - setEnv: false, 1392 1392 - want: true, 1393 1393 - }, 1394 1394 - { 1395 1395 - name: "env var set to false", 1396 1396 - envValue: "false", 1397 1397 - setEnv: true, 1398 1398 - want: false, 1399 1399 - }, 1400 1400 - { 1401 1401 - name: "env var set to true", 1402 1402 - envValue: "true", 1403 1403 - setEnv: true, 1404 1404 - want: true, 1405 1405 - }, 1406 1406 - { 1407 1407 - name: "env var set to empty string - enabled by default", 1408 1408 - envValue: "", 1409 1409 - setEnv: true, 1410 1410 - want: true, 1411 1411 - }, 1412 1412 - { 1413 1413 - name: "env var set to any other value - enabled", 1414 1414 - envValue: "yes", 1415 1415 - setEnv: true, 1416 1416 - want: true, 1417 1417 - }, 1418 1418 - } 1419 1419 - 1420 1420 - for _, tt := range tests { 1421 1421 - t.Run(tt.name, func(t *testing.T) { 1422 1422 - if tt.setEnv { 1423 1423 - t.Setenv("ATCR_BACKFILL_ENABLED", tt.envValue) 1424 1424 - } else { 1425 1425 - os.Unsetenv("ATCR_BACKFILL_ENABLED") 1426 1426 - } 1427 1427 - 1428 1428 - got := GetBackfillEnabled() 1429 1429 - if got != tt.want { 1430 1430 - t.Errorf("GetBackfillEnabled() = %v, want %v", got, tt.want) 1431 1431 - } 1432 1432 - }) 1433 1433 - } 1434 1434 - } 1435 1435 - 1436 1436 - func TestGetRelayEndpoint(t *testing.T) { 1437 1437 - tests := []struct { 1438 1438 - name string 1439 1439 - envValue string 1440 1440 - setEnv bool 1441 1441 - want string 1442 1442 - }{ 1443 1443 - { 1444 1444 - name: "env var not set - use default", 1445 1445 - setEnv: false, 1446 1446 - want: "https://relay1.us-east.bsky.network", 1447 1447 - }, 1448 1448 - { 1449 1449 - name: "env var set to custom endpoint", 1450 1450 - envValue: "https://custom-relay.example.com", 1451 1451 - setEnv: true, 1452 1452 - want: "https://custom-relay.example.com", 1453 1453 - }, 1454 1454 - { 1455 1455 - name: "env var set to empty string - use default", 1456 1456 - envValue: "", 1457 1457 - setEnv: true, 1458 1458 - want: "https://relay1.us-east.bsky.network", 1459 1459 - }, 1460 1460 - } 1461 1461 - 1462 1462 - for _, tt := range tests { 1463 1463 - t.Run(tt.name, func(t *testing.T) { 1464 1464 - if tt.setEnv { 1465 1465 - t.Setenv("ATCR_RELAY_ENDPOINT", tt.envValue) 1466 1466 - } else { 1467 1467 - os.Unsetenv("ATCR_RELAY_ENDPOINT") 1468 1468 - } 1469 1469 - 1470 1470 - got := GetRelayEndpoint() 1471 1471 - if got != tt.want { 1472 1472 - t.Errorf("GetRelayEndpoint() = %v, want %v", got, tt.want) 1473 1473 - } 1474 1474 - }) 1475 1475 - } 1476 1476 - } 1477 1477 - 1478 1478 - func TestGetBackfillInterval(t *testing.T) { 1479 1479 - tests := []struct { 1480 1480 - name string 1481 1481 - envValue string 1482 1482 - setEnv bool 1483 1483 - want string 1484 1484 - }{ 1485 1485 - { 1486 1486 - name: "env var not set - use default 1h", 1487 1487 - setEnv: false, 1488 1488 - want: "1h", 1489 1489 - }, 1490 1490 - { 1491 1491 - name: "env var set to custom interval", 1492 1492 - envValue: "30m", 1493 1493 - setEnv: true, 1494 1494 - want: "30m", 1495 1495 - }, 1496 1496 - { 1497 1497 - name: "env var set to invalid duration - use default", 1498 1498 - envValue: "invalid", 1499 1499 - setEnv: true, 1500 1500 - want: "1h", 1501 1501 - }, 1502 1502 - } 1503 1503 - 1504 1504 - for _, tt := range tests { 1505 1505 - t.Run(tt.name, func(t *testing.T) { 1506 1506 - if tt.setEnv { 1507 1507 - t.Setenv("ATCR_BACKFILL_INTERVAL", tt.envValue) 1508 1508 - } else { 1509 1509 - os.Unsetenv("ATCR_BACKFILL_INTERVAL") 1510 1510 - } 1511 1511 - 1512 1512 - wantDur := parseDuration(t, tt.want) 1513 1513 - got := GetBackfillInterval() 1514 1514 - if got != wantDur { 1515 1515 - t.Errorf("GetBackfillInterval() = %v, want %v", got, wantDur) 1516 1516 - } 1517 1517 - }) 1518 1518 - } 1519 1519 - } 1520 1520 - 1521 1521 - func TestGetTestMode(t *testing.T) { 1522 1522 - tests := []struct { 1523 1523 - name string 1524 1524 - envValue string 1525 1525 - setEnv bool 1526 1526 - want bool 1527 1527 - }{ 1528 1528 - { 1529 1529 - name: "env var not set - disabled by default", 1530 1530 - setEnv: false, 1531 1531 - want: false, 1532 1532 - }, 1533 1533 - { 1534 1534 - name: "env var set to true", 1535 1535 - envValue: "true", 1536 1536 - setEnv: true, 1537 1537 - want: true, 1538 1538 - }, 1539 1539 - { 1540 1540 - name: "env var set to false", 1541 1541 - envValue: "false", 1542 1542 - setEnv: true, 1543 1543 - want: false, 1544 1544 - }, 1545 1545 - { 1546 1546 - name: "env var set to empty string - disabled", 1547 1547 - envValue: "", 1548 1548 - setEnv: true, 1549 1549 - want: false, 1550 1550 - }, 1551 1551 - { 1552 1552 - name: "env var set to any other value - disabled", 1553 1553 - envValue: "yes", 1554 1554 - setEnv: true, 1555 1555 - want: false, 1556 1556 - }, 1557 1557 - } 1558 1558 - 1559 1559 - for _, tt := range tests { 1560 1560 - t.Run(tt.name, func(t *testing.T) { 1561 1561 - if tt.setEnv { 1562 1562 - t.Setenv("TEST_MODE", tt.envValue) 1563 1563 - } else { 1564 1564 - os.Unsetenv("TEST_MODE") 1565 1565 - } 1566 1566 - 1567 1567 - got := GetTestMode() 1568 1568 - if got != tt.want { 1569 1569 - t.Errorf("GetTestMode() = %v, want %v", got, tt.want) 1570 1570 - } 1571 1571 - }) 1572 1572 - } 1573 1573 - } 1574 1574 - 1575 1575 - // parseDuration is a helper function to parse duration strings in tests 1576 1576 - func parseDuration(t *testing.T, s string) time.Duration { 1577 1577 - t.Helper() 1578 1578 - d, err := time.ParseDuration(s) 1579 1579 - if err != nil { 1580 1580 - t.Fatalf("parseDuration(%q) failed: %v", s, err) 1581 1581 - } 1582 1582 - return d 1583 1583 - }

+2 -1

pkg/hold/oci/http_helpers.go

reviewed

··· 6 6 import ( 7 7 "encoding/json" 8 8 "fmt" 9 9 + "log/slog" 9 10 "net/http" 10 11 ) 11 12 ··· 25 26 if err := json.NewEncoder(w).Encode(v); err != nil { 26 27 // If encoding fails, we can't do much since headers are already sent 27 28 // Log the error but don't try to send another response 28 28 - fmt.Printf("ERROR: failed to encode JSON response: %v\n", err) 29 29 + slog.Error("Failed to encode JSON response", "error", err) 29 30 } 30 31 } 31 32

+59 -21

pkg/hold/oci/multipart.go

reviewed

··· 5 5 "crypto/sha256" 6 6 "encoding/hex" 7 7 "fmt" 8 8 - "log" 8 8 + "log/slog" 9 9 "sort" 10 10 "strings" 11 11 "sync" ··· 97 97 now := time.Now() 98 98 for uploadID, session := range m.sessions { 99 99 if now.Sub(session.LastActivity) > 24*time.Hour { 100 100 - log.Printf("Cleaning up expired multipart session: uploadID=%s, age=%v", uploadID, now.Sub(session.CreatedAt)) 100 100 + slog.Debug("Cleaning up expired multipart session", 101 101 + "uploadID", uploadID, 102 102 + "age", now.Sub(session.CreatedAt)) 101 103 delete(m.sessions, uploadID) 102 104 } 103 105 } ··· 121 123 m.sessions[uploadID] = session 122 124 m.mu.Unlock() 123 125 124 124 - log.Printf("Created multipart session: uploadID=%s, digest=%s, mode=%v", uploadID, digest, mode) 126 126 + slog.Debug("Created multipart session", 127 127 + "uploadID", uploadID, 128 128 + "digest", digest, 129 129 + "mode", mode) 125 130 return session 126 131 } 127 132 ··· 144 149 defer m.mu.Unlock() 145 150 146 151 delete(m.sessions, uploadID) 147 147 - log.Printf("Deleted multipart session: uploadID=%s", uploadID) 152 152 + slog.Debug("Deleted multipart session", "uploadID", uploadID) 148 153 } 149 154 150 155 // StorePart stores a part in the session (for Buffered mode) ··· 167 172 s.Parts[partNumber] = part 168 173 s.LastActivity = time.Now() 169 174 170 170 - log.Printf("Stored part: uploadID=%s, part=%d, size=%d bytes, etag=%s", s.UploadID, partNumber, len(data), etag) 175 175 + slog.Debug("Stored part", 176 176 + "uploadID", s.UploadID, 177 177 + "part", partNumber, 178 178 + "size", len(data), 179 179 + "etag", etag) 171 180 return etag 172 181 } 173 182 ··· 205 214 assembled = append(assembled, part.Data...) 206 215 } 207 216 208 208 - log.Printf("Assembled buffered parts: uploadID=%s, parts=%d, totalSize=%d bytes", s.UploadID, maxPart, totalSize) 217 217 + slog.Debug("Assembled buffered parts", 218 218 + "uploadID", s.UploadID, 219 219 + "parts", maxPart, 220 220 + "totalSize", totalSize) 209 221 return assembled, totalSize, nil 210 222 } 211 223 ··· 214 226 func (h *XRPCHandler) StartMultipartUploadWithManager(ctx context.Context, digest string) (string, MultipartMode, error) { 215 227 // Check if presigned URLs are disabled for testing 216 228 if h.disablePresignedURLs { 217 217 - log.Printf("Presigned URLs disabled (DISABLE_PRESIGNED_URLS=true), using buffered mode") 229 229 + slog.Debug("Presigned URLs disabled, using buffered mode", "reason", "DISABLE_PRESIGNED_URLS=true") 218 230 session := h.MultipartMgr.CreateSession(digest, Buffered, "") 219 219 - log.Printf("Started buffered multipart: uploadID=%s", session.UploadID) 231 231 + slog.Debug("Started buffered multipart", "uploadID", session.UploadID) 220 232 return session.UploadID, Buffered, nil 221 233 } 222 234 ··· 239 251 s3UploadID := *result.UploadId 240 252 // S3 native multipart succeeded 241 253 session := h.MultipartMgr.CreateSession(digest, S3Native, s3UploadID) 242 242 - log.Printf("Started S3 native multipart: digest=%s, uploadID=%s, s3UploadID=%s", digest, session.UploadID, s3UploadID) 254 254 + slog.Debug("Started S3 native multipart", 255 255 + "digest", digest, 256 256 + "uploadID", session.UploadID, 257 257 + "s3UploadID", s3UploadID) 243 258 return session.UploadID, S3Native, nil 244 259 } 245 245 - log.Printf("S3 native multipart failed, falling back to buffered mode: %v", err) 260 260 + slog.Warn("S3 native multipart failed, falling back to buffered mode", "error", err) 246 261 } 247 262 248 263 // Fallback to buffered mode 249 264 session := h.MultipartMgr.CreateSession(digest, Buffered, "") 250 250 - log.Printf("Started buffered multipart: uploadID=%s", session.UploadID) 265 265 + slog.Debug("Started buffered multipart", "uploadID", session.UploadID) 251 266 return session.UploadID, Buffered, nil 252 267 } 253 268 ··· 283 298 return nil, err 284 299 } 285 300 286 286 - log.Printf("Generated part presigned URL: digest=%s, uploadID=%s, part=%d", session.Digest, uploadID, partNumber) 301 301 + slog.Debug("Generated part presigned URL", 302 302 + "digest", session.Digest, 303 303 + "uploadID", uploadID, 304 304 + "part", partNumber) 287 305 288 306 return &PartUploadInfo{ 289 307 URL: url, ··· 350 368 if err != nil { 351 369 return fmt.Errorf("failed to complete multipart upload: digest=%s, uploadID=%s, err=%v", session.Digest, uploadID, err) 352 370 } 353 353 - log.Printf("Completed S3 native multipart at temp location: digest=%s, uploadID=%s, parts=%d", session.Digest, session.UploadID, len(s3Parts)) 371 371 + slog.Info("Completed S3 native multipart at temp location", 372 372 + "digest", session.Digest, 373 373 + "uploadID", session.UploadID, 374 374 + "parts", len(s3Parts)) 354 375 355 376 // Verify the blob exists at temp location before moving 356 377 destPath := blobPath(finalDigest) 357 357 - log.Printf("[DEBUG] About to move: source=%s, dest=%s", sourcePath, destPath) 378 378 + slog.Debug("About to move blob", 379 379 + "source", sourcePath, 380 380 + "dest", destPath) 358 381 359 382 if _, err := h.driver.Stat(ctx, sourcePath); err != nil { 360 360 - log.Printf("[ERROR] Source blob not found after multipart complete: path=%s, err=%v", sourcePath, err) 383 383 + slog.Error("Source blob not found after multipart complete", 384 384 + "path", sourcePath, 385 385 + "error", err) 361 386 return fmt.Errorf("source blob not found after multipart complete: %w", err) 362 387 } 363 363 - log.Printf("[DEBUG] Source blob verified at: %s", sourcePath) 388 388 + slog.Debug("Source blob verified", "path", sourcePath) 364 389 365 390 // Move from temp to final digest location using driver 366 391 // Driver handles path management correctly (including S3 prefix) 367 392 if err := h.driver.Move(ctx, sourcePath, destPath); err != nil { 368 368 - log.Printf("[ERROR] Failed to move blob: source=%s, dest=%s, err=%v", sourcePath, destPath, err) 393 393 + slog.Error("Failed to move blob", 394 394 + "source", sourcePath, 395 395 + "dest", destPath, 396 396 + "error", err) 369 397 return fmt.Errorf("failed to move blob to final location: %w", err) 370 398 } 371 399 372 372 - log.Printf("Moved blob to final location: %s → %s (driver paths: %s → %s)", session.Digest, finalDigest, sourcePath, destPath) 400 400 + slog.Info("Moved blob to final location", 401 401 + "from", session.Digest, 402 402 + "to", finalDigest, 403 403 + "sourcePath", sourcePath, 404 404 + "destPath", destPath) 373 405 return nil 374 406 } 375 407 ··· 396 428 return fmt.Errorf("failed to commit blob: %w", err) 397 429 } 398 430 399 399 - log.Printf("Completed buffered multipart: uploadID=%s, finalDigest=%s, size=%d bytes, written=%d", session.UploadID, finalDigest, size, written) 431 431 + slog.Info("Completed buffered multipart", 432 432 + "uploadID", session.UploadID, 433 433 + "finalDigest", finalDigest, 434 434 + "size", size, 435 435 + "written", written) 400 436 return nil 401 437 } 402 438 ··· 427 463 if err != nil { 428 464 return fmt.Errorf("failed to abort multipart upload: digest=%s, uploadID=%s, err=%v", session.Digest, uploadID, err) 429 465 } 430 430 - log.Printf("Aborted S3 native multipart: digest=%s, uploadID=%s", session.Digest, session.UploadID) 466 466 + slog.Debug("Aborted S3 native multipart", 467 467 + "digest", session.Digest, 468 468 + "uploadID", session.UploadID) 431 469 return nil 432 470 } 433 471 434 472 // Buffered mode: just delete the session (parts are in memory) 435 435 - log.Printf("Aborted buffered multipart: uploadID=%s", session.UploadID) 473 473 + slog.Debug("Aborted buffered multipart", "uploadID", session.UploadID) 436 474 return nil 437 475 } 438 476

+3 -2

pkg/hold/oci/xrpc.go

reviewed

··· 3 3 import ( 4 4 "fmt" 5 5 "io" 6 6 + "log/slog" 6 7 "net/http" 7 8 "strconv" 8 9 ··· 268 269 269 270 _, _, err := h.pds.CreateLayerRecord(ctx, record) 270 271 if err != nil { 271 271 - fmt.Printf("Failed to create layer record: %v\n", err) 272 272 + slog.Error("Failed to create layer record", "error", err) 272 273 // Continue creating other records 273 274 } else { 274 275 layersCreated++ ··· 302 303 totalSize, 303 304 ) 304 305 if err != nil { 305 305 - fmt.Printf("Failed to create manifest post: %v\n", err) 306 306 + slog.Error("Failed to create manifest post", "error", err) 306 307 } else { 307 308 postCreated = true 308 309 }

+3 -3

pkg/hold/pds/auth.go

reviewed

··· 6 6 "encoding/json" 7 7 "fmt" 8 8 "io" 9 9 - "log" 9 9 + "log/slog" 10 10 "net/http" 11 11 "slices" 12 12 "strings" ··· 426 426 return nil, fmt.Errorf("missing token") 427 427 } 428 428 429 429 - log.Printf("[ValidateServiceToken] Validating service token for hold %s", holdDID) 429 429 + slog.Debug("Validating service token", "holdDID", holdDID) 430 430 431 431 // Manually parse JWT (bypass golang-jwt since it doesn't support ES256K algorithm used by ATProto) 432 432 // Split token: header.payload.signature ··· 493 493 return nil, fmt.Errorf("signature verification failed: %w", err) 494 494 } 495 495 496 496 - log.Printf("[ValidateServiceToken] Successfully validated service token for user %s", issuerDID) 496 496 + slog.Debug("Successfully validated service token", "userDID", issuerDID) 497 497 498 498 // Return validated user 499 499 return &ValidatedUser{

+4 -1

pkg/hold/pds/captain.go

reviewed

··· 3 3 import ( 4 4 "context" 5 5 "fmt" 6 6 + "log/slog" 6 7 "time" 7 8 8 9 "atcr.io/pkg/atproto" ··· 32 33 return cid.Undef, fmt.Errorf("failed to create captain record: %w", err) 33 34 } 34 35 35 35 - fmt.Printf("Created captain record at %s, cid: %s\n", recordPath, recordCID) 36 36 + slog.Info("Created captain record", 37 37 + "path", recordPath, 38 38 + "cid", recordCID.String()) 36 39 return recordCID, nil 37 40 } 38 41

+37 -27

pkg/hold/pds/events.go

reviewed

··· 6 6 "database/sql" 7 7 "encoding/json" 8 8 "fmt" 9 9 - "log" 9 9 + "log/slog" 10 10 "strings" 11 11 "sync" 12 12 "time" ··· 79 79 // Initialize database connection and schema 80 80 if dbPath != "" && dbPath != ":memory:" { 81 81 if err := broadcaster.initDatabase(); err != nil { 82 82 - log.Printf("Warning: Failed to initialize event database: %v", err) 83 83 - log.Printf("Events will not persist across restarts") 82 82 + slog.Warn("Failed to initialize event database", "error", err) 83 83 + slog.Warn("Events will not persist across restarts") 84 84 } 85 85 } 86 86 ··· 127 127 var lastSeq sql.NullInt64 128 128 err = db.QueryRow("SELECT MAX(seq) FROM firehose_events").Scan(&lastSeq) 129 129 if err != nil { 130 130 - log.Printf("Warning: Failed to load last event sequence: %v", err) 130 130 + slog.Warn("Failed to load last event sequence", "error", err) 131 131 } else if lastSeq.Valid { 132 132 b.eventSeq = lastSeq.Int64 133 133 - log.Printf("Loaded event sequence from database: seq=%d", b.eventSeq) 133 133 + slog.Info("Loaded event sequence from database", "seq", b.eventSeq) 134 134 } else { 135 135 // Database is empty but might have existing repo records 136 136 // This happens on first deployment after adding persistent events 137 137 - log.Printf("No events in database - will bootstrap from repo if needed") 137 137 + slog.Info("No events in database - will bootstrap from repo if needed") 138 138 } 139 139 140 140 return nil ··· 185 185 } 186 186 187 187 if count > 0 { 188 188 - log.Printf("Database already has %d events, skipping bootstrap", count) 188 188 + slog.Info("Database already has events, skipping bootstrap", "count", count) 189 189 return nil 190 190 } 191 191 ··· 200 200 head, err := pds.carstore.GetUserRepoHead(ctx, pds.uid) 201 201 if err != nil || !head.Defined() { 202 202 // Empty repo, nothing to bootstrap 203 203 - log.Printf("Empty repo, no events to bootstrap") 203 203 + slog.Info("Empty repo, no events to bootstrap") 204 204 return nil 205 205 } 206 206 ··· 215 215 return fmt.Errorf("failed to get repo rev: %w", err) 216 216 } 217 217 218 218 - log.Printf("Bootstrapping firehose events from current repo state (head=%s, rev=%s)", head.String(), rev) 218 218 + slog.Info("Bootstrapping firehose events from current repo state", 219 219 + "head", head.String(), 220 220 + "rev", rev) 219 221 220 222 var recordCount int64 221 223 ··· 224 226 // Get record value 225 227 _, recBytes, err := repoHandle.GetRecordBytes(ctx, path) 226 228 if err != nil { 227 227 - log.Printf("Warning: failed to get record bytes for %s: %v", path, err) 229 229 + slog.Warn("Failed to get record bytes", "path", path, "error", err) 228 230 return nil // Skip this record but continue 229 231 } 230 232 231 233 recordValue, err := lexutil.CborDecodeValue(*recBytes) 232 234 if err != nil { 233 233 - log.Printf("Warning: failed to decode record %s: %v", path, err) 235 235 + slog.Warn("Failed to decode record", "path", path, "error", err) 234 236 return nil 235 237 } 236 238 ··· 265 267 Version: 1, 266 268 } 267 269 if err := car.WriteHeader(carHeader, &carBuf); err != nil { 268 268 - log.Printf("Warning: failed to write CAR header: %v", err) 270 270 + slog.Warn("Failed to write CAR header", "error", err) 269 271 return nil 270 272 } 271 273 272 274 // Write the record block 273 275 if err := carutil.LdWrite(&carBuf, recordCID.Bytes(), *recBytes); err != nil { 274 274 - log.Printf("Warning: failed to write record block: %v", err) 276 276 + slog.Warn("Failed to write record block", "error", err) 275 277 return nil 276 278 } 277 279 ··· 311 313 return fmt.Errorf("failed to walk repo: %w", err) 312 314 } 313 315 314 314 - log.Printf("✅ Bootstrapped %d events from repo (seq now at %d)", recordCount, b.eventSeq) 316 316 + slog.Info("Bootstrapped events from repo", 317 317 + "recordCount", recordCount, 318 318 + "seq", b.eventSeq) 315 319 return nil 316 320 } 317 321 ··· 349 353 } else if cursor > currentSeq { 350 354 // Relay has cursor ahead of us - server was restarted 351 355 // Database should have the events if we had them before 352 352 - log.Printf("Relay cursor %d > currentSeq %d (server restarted), attempting database backfill", cursor, currentSeq) 356 356 + slog.Info("Relay cursor ahead of current seq, attempting database backfill", 357 357 + "cursor", cursor, 358 358 + "currentSeq", currentSeq) 353 359 go b.backfillSubscriber(sub, cursor) 354 360 } 355 361 // else cursor == currentSeq: relay is caught up, just stream new events ··· 387 393 // Persist event to database 388 394 if b.db != nil { 389 395 if err := b.persistEvent(commitEvent); err != nil { 390 390 - log.Printf("Warning: Failed to persist event seq=%d to database: %v", seq, err) 396 396 + slog.Warn("Failed to persist event to database", 397 397 + "seq", seq, 398 398 + "error", err) 391 399 } 392 400 } 393 401 ··· 401 409 // Sent successfully 402 410 default: 403 411 // Subscriber's buffer is full, skip (they'll get disconnected for being too slow) 404 404 - log.Printf("Warning: subscriber buffer full, skipping event seq=%d", seq) 412 412 + slog.Warn("Subscriber buffer full, skipping event", "seq", seq) 405 413 } 406 414 } 407 415 } ··· 488 496 // If database is available, use it for backfill 489 497 if b.db != nil { 490 498 if err := b.backfillFromDatabase(sub, cursor); err != nil { 491 491 - log.Printf("Database backfill failed, falling back to in-memory: %v", err) 499 499 + slog.Warn("Database backfill failed, falling back to in-memory", "error", err) 492 500 b.backfillFromMemory(sub, cursor) 493 501 } 494 502 return ··· 527 535 ) 528 536 529 537 if err := rows.Scan(&seq, &commitCID, &rev, &sinceRev, &repoSlice, &opsJSON, &createdAt); err != nil { 530 530 - log.Printf("Error scanning event row: %v", err) 538 538 + slog.Error("Error scanning event row", "error", err) 531 539 continue 532 540 } 533 541 534 542 // Deserialize ops from JSON 535 543 var ops []*atproto.SyncSubscribeRepos_RepoOp 536 544 if err := json.Unmarshal(opsJSON, &ops); err != nil { 537 537 - log.Printf("Error unmarshaling ops for seq=%d: %v", seq, err) 545 545 + slog.Error("Error unmarshaling ops", "seq", seq, "error", err) 538 546 continue 539 547 } 540 548 ··· 562 570 // Sent successfully 563 571 case <-time.After(5 * time.Second): 564 572 // Timeout, subscriber too slow 565 565 - log.Printf("Backfill timeout for subscriber at seq=%d", seq) 573 573 + slog.Warn("Backfill timeout for subscriber", "seq", seq) 566 574 return nil 567 575 } 568 576 } ··· 582 590 // Sent 583 591 case <-time.After(5 * time.Second): 584 592 // Timeout, subscriber too slow 585 585 - log.Printf("Backfill timeout for subscriber at seq=%d", he.Seq) 593 593 + slog.Warn("Backfill timeout for subscriber", "seq", he.Seq) 586 594 return 587 595 } 588 596 } ··· 606 614 // Get a writer for this message 607 615 wc, err := sub.conn.NextWriter(websocket.BinaryMessage) 608 616 if err != nil { 609 609 - log.Printf("Failed to get websocket writer: %v", err) 617 617 + slog.Error("Failed to get websocket writer", "error", err) 610 618 return 611 619 } 612 620 613 621 // Write header as CBOR 614 622 if err := header.MarshalCBOR(wc); err != nil { 615 615 - log.Printf("Failed to write event header: %v", err) 623 623 + slog.Error("Failed to write event header", "error", err) 616 624 wc.Close() 617 625 return 618 626 } ··· 623 631 // Write the event as CBOR 624 632 var obj lexutil.CBOR = indigoEvent 625 633 if err := obj.MarshalCBOR(wc); err != nil { 626 626 - log.Printf("Failed to write event body: %v", err) 634 634 + slog.Error("Failed to write event body", "error", err) 627 635 wc.Close() 628 636 return 629 637 } 630 638 631 639 // Close the writer to flush the message 632 640 if err := wc.Close(); err != nil { 633 633 - log.Printf("Failed to close websocket writer: %v", err) 641 641 + slog.Error("Failed to close websocket writer", "error", err) 634 642 return 635 643 } 636 644 ··· 645 653 // Parse commit CID string to cid.Cid, then convert to LexLink 646 654 commitCID, err := cid.Decode(event.Commit) 647 655 if err != nil { 648 648 - log.Printf("Warning: failed to parse commit CID %s: %v", event.Commit, err) 656 656 + slog.Warn("Failed to parse commit CID", 657 657 + "cid", event.Commit, 658 658 + "error", err) 649 659 // Create an empty CID as fallback 650 660 commitCID = cid.Undef 651 661 }

+4 -3

pkg/hold/pds/keys.go

reviewed

··· 2 2 3 3 import ( 4 4 "fmt" 5 5 + "log/slog" 5 6 "os" 6 7 "path/filepath" 7 8 ··· 42 43 return nil, fmt.Errorf("failed to write key file: %w", err) 43 44 } 44 45 45 45 - fmt.Printf("Generated new K-256 signing key at %s\n", keyPath) 46 46 + slog.Info("Generated new K-256 signing key", "path", keyPath) 46 47 return privateKey, nil 47 48 } 48 49 ··· 59 60 if err != nil { 60 61 // Check if this is an old P-256 PEM key (migration) 61 62 if isPEMFormat(keyBytes) { 62 62 - fmt.Printf("⚠️ Detected old P-256 key, replacing with K-256...\n") 63 63 + slog.Warn("Detected old P-256 key, replacing with K-256") 63 64 // Generate new K-256 key (overwrites old P-256) 64 65 return generateKey(keyPath) 65 66 } ··· 67 68 return nil, fmt.Errorf("failed to parse private key: %w", err) 68 69 } 69 70 70 70 - fmt.Printf("Loaded existing K-256 signing key from %s\n", keyPath) 71 71 + slog.Info("Loaded existing K-256 signing key", "path", keyPath) 71 72 return privateKey, nil 72 73 } 73 74

+4 -1

pkg/hold/pds/manifest_post.go

reviewed

··· 3 3 import ( 4 4 "context" 5 5 "fmt" 6 6 + "log/slog" 6 7 "strings" 7 8 "time" 8 9 ··· 55 56 // Build ATProto URI for the post 56 57 postURI := fmt.Sprintf("at://%s/app.bsky.feed.post/%s", p.did, rkey) 57 58 58 58 - fmt.Printf("Created manifest post: %s (cid: %s)\n", postURI, recordCID) 59 59 + slog.Info("Created manifest post", 60 60 + "uri", postURI, 61 61 + "cid", recordCID.String()) 59 62 60 63 return postURI, nil 61 64 }

+12 -5

pkg/hold/pds/profile.go

reviewed

··· 6 6 "crypto/sha256" 7 7 "fmt" 8 8 "io" 9 9 + "log/slog" 9 10 "net/http" 10 11 "time" 11 12 ··· 137 138 138 139 // Download and upload avatar if URL is provided 139 140 if avatarURL != "" { 140 140 - fmt.Printf("Downloading avatar from %s\n", avatarURL) 141 141 + slog.Debug("Downloading avatar", "url", avatarURL) 141 142 imageData, mimeType, err := downloadImage(ctx, avatarURL) 142 143 if err != nil { 143 144 return cid.Undef, fmt.Errorf("failed to download avatar: %w", err) 144 145 } 145 146 146 146 - fmt.Printf("Uploading avatar blob (%d bytes, %s)\n", len(imageData), mimeType) 147 147 + slog.Debug("Uploading avatar blob", 148 148 + "size", len(imageData), 149 149 + "mimeType", mimeType) 147 150 avatarBlob, err := uploadBlobToStorage(ctx, storageDriver, p.did, imageData, mimeType) 148 151 if err != nil { 149 152 return cid.Undef, fmt.Errorf("failed to upload avatar blob: %w", err) 150 153 } 151 154 152 155 profile.Avatar = avatarBlob 153 153 - fmt.Printf("Avatar uploaded successfully: %s\n", avatarBlob.Ref.String()) 156 156 + slog.Info("Avatar uploaded successfully", "ref", avatarBlob.Ref.String()) 154 157 } 155 158 156 159 // Use repomgr.PutRecord - creates with explicit rkey, fails if already exists ··· 159 162 return cid.Undef, fmt.Errorf("failed to create profile record: %w", err) 160 163 } 161 164 162 162 - fmt.Printf("Created profile record at %s, cid: %s\n", recordPath, recordCID) 165 165 + slog.Info("Created profile record", 166 166 + "path", recordPath, 167 167 + "cid", recordCID.String()) 163 168 return recordCID, nil 164 169 } 165 170 ··· 200 205 return cid.Undef, fmt.Errorf("failed to create tangled profile record: %w", err) 201 206 } 202 207 203 203 - fmt.Printf("Created tangled profile record at %s, cid: %s\n", recordPath, recordCID) 208 208 + slog.Info("Created tangled profile record", 209 209 + "path", recordPath, 210 210 + "cid", recordCID.String()) 204 211 return recordCID, nil 205 212 } 206 213

+16 -9

pkg/hold/pds/server.go

reviewed

··· 3 3 import ( 4 4 "context" 5 5 "fmt" 6 6 + "log/slog" 6 7 "os" 7 8 "path/filepath" 8 9 "strings" ··· 92 93 // Initialize empty repo with first commit 93 94 // RepoManager requires at least one commit to exist 94 95 // We'll create this by doing a dummy operation in Bootstrap 95 95 - fmt.Printf("New hold repo - will be initialized in Bootstrap\n") 96 96 + slog.Info("New hold repo - will be initialized in Bootstrap") 96 97 } 97 98 98 99 return &HoldPDS{ ··· 134 135 135 136 if captainExists { 136 137 // Captain record exists, skip captain/crew setup but still create profile if needed 137 137 - fmt.Printf("✅ Captain record exists, skipping captain/crew setup\n") 138 138 + slog.Info("Captain record exists, skipping captain/crew setup") 138 139 } else { 139 139 - fmt.Printf("🚀 Bootstrapping hold PDS with owner: %s\n", ownerDID) 140 140 + slog.Info("Bootstrapping hold PDS", "owner", ownerDID) 140 141 } 141 142 142 143 if !captainExists { ··· 151 152 if err != nil { 152 153 return fmt.Errorf("failed to initialize repo: %w", err) 153 154 } 154 154 - fmt.Printf("✅ Initialized empty repo\n") 155 155 + slog.Info("Initialized empty repo") 155 156 } 156 157 157 158 // Create captain record (hold ownership and settings) ··· 160 161 return fmt.Errorf("failed to create captain record: %w", err) 161 162 } 162 163 163 163 - fmt.Printf("✅ Created captain record (public=%v, allowAllCrew=%v, enableBlueskyPosts=%v)\n", public, allowAllCrew, p.enableBlueskyPosts) 164 164 + slog.Info("Created captain record", 165 165 + "public", public, 166 166 + "allowAllCrew", allowAllCrew, 167 167 + "enableBlueskyPosts", p.enableBlueskyPosts) 164 168 165 169 // Add hold owner as first crew member with admin role 166 170 _, err = p.AddCrewMember(ctx, ownerDID, "admin", []string{"blob:read", "blob:write", "crew:admin"}) ··· 168 172 return fmt.Errorf("failed to add owner as crew member: %w", err) 169 173 } 170 174 171 171 - fmt.Printf("✅ Added %s as hold admin\n", ownerDID) 175 175 + slog.Info("Added owner as hold admin", "did", ownerDID) 172 176 } else { 173 177 // Captain record exists, check if we need to sync settings from env vars 174 178 _, existingCaptain, err := p.GetCaptainRecord(ctx) ··· 184 188 if err != nil { 185 189 return fmt.Errorf("failed to update captain record: %w", err) 186 190 } 187 187 - fmt.Printf("✅ Synced captain record with env vars (public=%v, allowAllCrew=%v, enableBlueskyPosts=%v)\n", public, allowAllCrew, p.enableBlueskyPosts) 191 191 + slog.Info("Synced captain record with env vars", 192 192 + "public", public, 193 193 + "allowAllCrew", allowAllCrew, 194 194 + "enableBlueskyPosts", p.enableBlueskyPosts) 188 195 } 189 196 } 190 197 } ··· 203 210 if err != nil { 204 211 return fmt.Errorf("failed to create bluesky profile record: %w", err) 205 212 } 206 206 - fmt.Printf("✅ Created Bluesky profile record (displayName=%s)\n", displayName) 213 213 + slog.Info("Created Bluesky profile record", "displayName", displayName) 207 214 } else { 208 208 - fmt.Printf("✅ Bluesky profile record already exists, skipping\n") 215 215 + slog.Info("Bluesky profile record already exists, skipping") 209 216 } 210 217 } 211 218

+7 -2

pkg/hold/pds/status.go

reviewed

··· 3 3 import ( 4 4 "context" 5 5 "fmt" 6 6 + "log/slog" 6 7 "time" 7 8 8 9 bsky "github.com/bluesky-social/indigo/api/bsky" ··· 19 20 func (p *HoldPDS) SetStatus(ctx context.Context, status string) error { 20 21 // Check if Bluesky posts are enabled 21 22 if !p.enableBlueskyPosts { 22 22 - fmt.Printf("Bluesky posts disabled, skipping status post: %s\n", status) 23 23 + slog.Debug("Bluesky posts disabled, skipping status post", "status", status) 23 24 return nil 24 25 } 25 26 ··· 51 52 return fmt.Errorf("failed to create status post: %w", err) 52 53 } 53 54 54 54 - fmt.Printf("Created status post at %s/%s (rkey: %s), cid: %s, text: %s\n", StatusPostCollection, rkey, rkey, recordCID, text) 55 55 + slog.Info("Created status post", 56 56 + "collection", StatusPostCollection, 57 57 + "rkey", rkey, 58 58 + "cid", recordCID.String(), 59 59 + "text", text) 55 60 return nil 56 61 }

+56 -27

pkg/hold/pds/xrpc.go

reviewed

··· 20 20 21 21 "crypto/sha256" 22 22 "io" 23 23 - "log" 23 23 + "log/slog" 24 24 "net/http" 25 25 "strconv" 26 26 "strings" ··· 827 827 if err != nil { 828 828 // Error already written to response by ReadRepo streaming 829 829 // Log it but don't try to write another HTTP error 830 830 - fmt.Printf("Error streaming repo CAR: %v\n", err) 830 830 + slog.Error("Error streaming repo CAR", "error", err) 831 831 return 832 832 } 833 833 } ··· 865 865 // Upgrade to WebSocket 866 866 conn, err := upgrader.Upgrade(w, r, nil) 867 867 if err != nil { 868 868 - fmt.Printf("WebSocket upgrade failed: %v\n", err) 868 868 + slog.Error("WebSocket upgrade failed", "error", err) 869 869 return 870 870 } 871 871 ··· 970 970 did := r.URL.Query().Get("did") 971 971 cidOrDigest := r.URL.Query().Get("cid") 972 972 973 973 - log.Printf("[HandleGetBlob] %s request - did=%s, cid=%s", r.Method, did, cidOrDigest) 973 973 + slog.Debug("HandleGetBlob request", 974 974 + "method", r.Method, 975 975 + "did", did, 976 976 + "cid", cidOrDigest) 974 977 975 978 if did == "" || cidOrDigest == "" { 976 979 http.Error(w, "missing required parameters", http.StatusBadRequest) ··· 992 995 // Returns JSON with presigned URL for AppView integration 993 996 // Authorization: Protected by hold access control (captain.public or crew with blob:read) 994 997 func (h *XRPCHandler) handleGetOCIBlob(w http.ResponseWriter, r *http.Request, did, digest string) { 995 995 - log.Printf("[handleGetOCIBlob] Processing OCI blob: %s", digest) 998 998 + slog.Debug("Processing OCI blob", "digest", digest) 996 999 997 1000 // Validate blob read access (hold access control) 998 1001 // If captain.public = true, returns nil (public access allowed) 999 1002 // If captain.public = false, validates auth and checks for blob:read permission 1000 1003 _, err := ValidateBlobReadAccess(r, h.pds, h.httpClient) 1001 1004 if err != nil { 1002 1002 - log.Printf("[handleGetOCIBlob] Authorization failed: %v", err) 1005 1005 + slog.Warn("OCI blob authorization failed", "error", err, "digest", digest) 1003 1006 http.Error(w, fmt.Sprintf("authorization failed: %v", err), http.StatusForbidden) 1004 1007 return 1005 1008 } ··· 1014 1017 // Generate presigned URL (use empty DID for content-addressed storage) 1015 1018 presignedURL, err := h.GetPresignedURL(r.Context(), operation, digest, "") 1016 1019 if err != nil { 1017 1017 - log.Printf("[handleGetOCIBlob] Failed to get presigned %s URL: %v", operation, err) 1020 1020 + slog.Error("Failed to get presigned URL for OCI blob", 1021 1021 + "error", err, 1022 1022 + "operation", operation, 1023 1023 + "digest", digest) 1018 1024 http.Error(w, "failed to get presigned URL", http.StatusInternalServerError) 1019 1025 return 1020 1026 } 1021 1027 1022 1022 - log.Printf("[handleGetOCIBlob] Returning presigned %s URL: %s", operation, presignedURL) 1028 1028 + slog.Debug("Returning presigned URL for OCI blob", 1029 1029 + "operation", operation, 1030 1030 + "digest", digest, 1031 1031 + "url", presignedURL) 1023 1032 1024 1033 // Return JSON response with presigned URL (AppView expects this format) 1025 1034 response := map[string]string{ ··· 1033 1042 // Returns 307 redirect to presigned URL (standard ATProto behavior) 1034 1043 // Authorization: Public per ATProto spec (no auth required) 1035 1044 func (h *XRPCHandler) handleGetATProtoBlob(w http.ResponseWriter, r *http.Request, did, cid string) { 1036 1036 - log.Printf("[handleGetATProtoBlob] Processing ATProto blob: %s", cid) 1045 1045 + slog.Debug("Processing ATProto blob", "cid", cid) 1037 1046 1038 1047 // Validate DID (ATProto blobs are stored per-DID for data sovereignty) 1039 1048 if did != h.pds.DID() { 1040 1040 - log.Printf("[handleGetATProtoBlob] DID mismatch: got %s, expected %s", did, h.pds.DID()) 1049 1049 + slog.Warn("ATProto blob DID mismatch", 1050 1050 + "got", did, 1051 1051 + "expected", h.pds.DID()) 1041 1052 http.Error(w, "invalid did", http.StatusBadRequest) 1042 1053 return 1043 1054 } ··· 1051 1062 // Generate presigned URL (use DID for per-DID storage path) 1052 1063 presignedURL, err := h.GetPresignedURL(r.Context(), operation, cid, did) 1053 1064 if err != nil { 1054 1054 - log.Printf("[handleGetATProtoBlob] Failed to get presigned %s URL: %v", operation, err) 1065 1065 + slog.Error("Failed to get presigned URL for ATProto blob", 1066 1066 + "error", err, 1067 1067 + "operation", operation, 1068 1068 + "cid", cid, 1069 1069 + "did", did) 1055 1070 http.Error(w, "failed to get presigned URL", http.StatusInternalServerError) 1056 1071 return 1057 1072 } ··· 1170 1185 // This endpoint allows authenticated users to request crew membership 1171 1186 // Authorization is checked against captain record settings 1172 1187 func (h *XRPCHandler) HandleRequestCrew(w http.ResponseWriter, r *http.Request) { 1173 1173 - log.Printf("[HandleRequestCrew] Starting crew membership request") 1188 1188 + slog.Debug("Starting crew membership request") 1174 1189 1175 1190 // Get authenticated user from context (if coming through middleware) 1176 1191 // Otherwise validate directly (for tests or direct handler calls) ··· 1179 1194 var err error 1180 1195 user, err = ValidateDPoPRequest(r, h.httpClient) 1181 1196 if err != nil { 1182 1182 - log.Printf("[HandleRequestCrew] Authentication failed: %v", err) 1197 1197 + slog.Warn("Crew request authentication failed", "error", err) 1183 1198 http.Error(w, fmt.Sprintf("authentication failed: %v", err), http.StatusUnauthorized) 1184 1199 return 1185 1200 } 1186 1201 } 1187 1187 - log.Printf("[HandleRequestCrew] Authenticated user: %s", user.DID) 1202 1202 + slog.Debug("Authenticated user for crew request", "did", user.DID) 1188 1203 1189 1204 // Parse request body (optional parameters) 1190 1205 var req struct { ··· 1195 1210 // Body is optional - if empty, just use defaults 1196 1211 if r.Body != nil && r.ContentLength > 0 { 1197 1212 if err := json.NewDecoder(r.Body).Decode(&req); err != nil { 1198 1198 - log.Printf("[HandleRequestCrew] Failed to parse request body: %v", err) 1213 1213 + slog.Warn("Failed to parse crew request body", "error", err) 1199 1214 http.Error(w, fmt.Sprintf("invalid request body: %v", err), http.StatusBadRequest) 1200 1215 return 1201 1216 } 1202 1217 } 1203 1218 1204 1219 // Get captain record to check authorization settings 1205 1205 - log.Printf("[HandleRequestCrew] Getting captain record...") 1220 1220 + slog.Debug("Getting captain record for crew request") 1206 1221 _, captain, err := h.pds.GetCaptainRecord(r.Context()) 1207 1222 if err != nil { 1208 1208 - log.Printf("[HandleRequestCrew] Failed to get captain record: %v", err) 1223 1223 + slog.Error("Failed to get captain record", "error", err) 1209 1224 http.Error(w, fmt.Sprintf("failed to get captain record: %v", err), http.StatusInternalServerError) 1210 1225 return 1211 1226 } 1212 1212 - log.Printf("[HandleRequestCrew] Captain record retrieved: owner=%s, allowAllCrew=%v", captain.Owner, captain.AllowAllCrew) 1227 1227 + slog.Debug("Captain record retrieved", 1228 1228 + "owner", captain.Owner, 1229 1229 + "allowAllCrew", captain.AllowAllCrew) 1213 1230 1214 1231 // Check authorization: 1215 1232 // 1. If allowAllCrew is true, any authenticated user can join ··· 1231 1248 1232 1249 // Check if user is already a crew member 1233 1250 // List all crew members and check if this DID is already present 1234 1234 - log.Printf("[HandleRequestCrew] Checking existing crew membership...") 1251 1251 + slog.Debug("Checking existing crew membership") 1235 1252 crew, err := h.pds.ListCrewMembers(r.Context()) 1236 1253 if err != nil { 1237 1237 - log.Printf("[HandleRequestCrew] Failed to list crew members: %v", err) 1254 1254 + slog.Error("Failed to list crew members", "error", err) 1238 1255 http.Error(w, fmt.Sprintf("failed to list crew members: %v", err), http.StatusInternalServerError) 1239 1256 return 1240 1257 } 1241 1241 - log.Printf("[HandleRequestCrew] Found %d existing crew members", len(crew)) 1258 1258 + slog.Debug("Found existing crew members", "count", len(crew)) 1242 1259 1243 1260 for _, member := range crew { 1244 1261 if member.Record.Member == user.DID { 1245 1262 // Already a crew member, return success with existing record 1246 1246 - log.Printf("[HandleRequestCrew] User is already a crew member (rkey=%s)", member.Rkey) 1263 1263 + slog.Debug("User is already a crew member", 1264 1264 + "did", user.DID, 1265 1265 + "rkey", member.Rkey) 1247 1266 response := map[string]any{ 1248 1267 "uri": fmt.Sprintf("at://%s/%s/%s", h.pds.DID(), atproto.CrewCollection, member.Rkey), 1249 1268 "cid": member.Cid.String(), ··· 1258 1277 } 1259 1278 1260 1279 // Create new crew record 1261 1261 - log.Printf("[HandleRequestCrew] Creating new crew record for user %s (role=%s, permissions=%v)", user.DID, req.Role, req.Permissions) 1280 1280 + slog.Debug("Creating new crew record", 1281 1281 + "did", user.DID, 1282 1282 + "role", req.Role, 1283 1283 + "permissions", req.Permissions) 1262 1284 recordCID, err := h.pds.AddCrewMember(r.Context(), user.DID, req.Role, req.Permissions) 1263 1285 if err != nil { 1264 1264 - log.Printf("[HandleRequestCrew] Failed to create crew record: %v", err) 1286 1286 + slog.Error("Failed to create crew record", 1287 1287 + "error", err, 1288 1288 + "did", user.DID) 1265 1289 http.Error(w, fmt.Sprintf("failed to create crew record: %v", err), http.StatusInternalServerError) 1266 1290 return 1267 1291 } 1268 1268 - log.Printf("[HandleRequestCrew] Successfully created crew record (CID=%s)", recordCID.String()) 1292 1292 + slog.Info("Successfully created crew record", 1293 1293 + "did", user.DID, 1294 1294 + "cid", recordCID.String()) 1269 1295 1270 1296 // Return success response 1271 1297 // Note: rkey is generated by AddCrewMember (TID), we don't have direct access to it ··· 1341 1367 // Generate presigned URL with 15 minute expiry 1342 1368 url, err := req.Presign(15 * time.Minute) 1343 1369 if err != nil { 1344 1344 - log.Printf("[getPresignedURL] Presign FAILED for %s: %v", operation, err) 1345 1345 - log.Printf(" Falling back to XRPC endpoint") 1370 1370 + slog.Warn("Presign failed, falling back to XRPC endpoint", 1371 1371 + "error", err, 1372 1372 + "operation", operation, 1373 1373 + "digest", digest) 1374 1374 + slog.Debug("Using XRPC proxy fallback") 1346 1375 proxyURL := getProxyURL(h.pds.PublicURL, digest, did, operation) 1347 1376 if proxyURL == "" { 1348 1377 return "", fmt.Errorf("presign failed and XRPC proxy not supported for PUT operations")