fe71ee57b3
- NewTimingWheelService 改为返回 error，避免 panic - ProvideTimingWheelService 透传 error 并更新 wire 生成代码 - 补充定时任务调度/取消/周期任务相关单元测试
324 lines
17 KiB
Go
324 lines
17 KiB
Go
// Code generated by Wire. DO NOT EDIT.
|
|
|
|
//go:generate go run -mod=mod github.com/google/wire/cmd/wire
|
|
//go:build !wireinject
|
|
// +build !wireinject
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"github.com/Wei-Shaw/sub2api/ent"
|
|
"github.com/Wei-Shaw/sub2api/internal/config"
|
|
"github.com/Wei-Shaw/sub2api/internal/handler"
|
|
"github.com/Wei-Shaw/sub2api/internal/handler/admin"
|
|
"github.com/Wei-Shaw/sub2api/internal/repository"
|
|
"github.com/Wei-Shaw/sub2api/internal/server"
|
|
"github.com/Wei-Shaw/sub2api/internal/server/middleware"
|
|
"github.com/Wei-Shaw/sub2api/internal/service"
|
|
"github.com/redis/go-redis/v9"
|
|
"log"
|
|
"net/http"
|
|
"time"
|
|
)
|
|
|
|
import (
|
|
_ "embed"
|
|
_ "github.com/Wei-Shaw/sub2api/ent/runtime"
|
|
)
|
|
|
|
// Injectors from wire.go:
|
|
|
|
func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
|
|
configConfig, err := config.ProvideConfig()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
client, err := repository.ProvideEnt(configConfig)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
db, err := repository.ProvideSQLDB(client)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
userRepository := repository.NewUserRepository(client, db)
|
|
settingRepository := repository.NewSettingRepository(client)
|
|
settingService := service.NewSettingService(settingRepository, configConfig)
|
|
redisClient := repository.ProvideRedis(configConfig)
|
|
emailCache := repository.NewEmailCache(redisClient)
|
|
emailService := service.NewEmailService(settingRepository, emailCache)
|
|
turnstileVerifier := repository.NewTurnstileVerifier()
|
|
turnstileService := service.NewTurnstileService(settingService, turnstileVerifier)
|
|
emailQueueService := service.ProvideEmailQueueService(emailService)
|
|
promoCodeRepository := repository.NewPromoCodeRepository(client)
|
|
billingCache := repository.NewBillingCache(redisClient)
|
|
userSubscriptionRepository := repository.NewUserSubscriptionRepository(client)
|
|
billingCacheService := service.NewBillingCacheService(billingCache, userRepository, userSubscriptionRepository, configConfig)
|
|
apiKeyRepository := repository.NewAPIKeyRepository(client)
|
|
groupRepository := repository.NewGroupRepository(client, db)
|
|
apiKeyCache := repository.NewAPIKeyCache(redisClient)
|
|
apiKeyService := service.NewAPIKeyService(apiKeyRepository, userRepository, groupRepository, userSubscriptionRepository, apiKeyCache, configConfig)
|
|
apiKeyAuthCacheInvalidator := service.ProvideAPIKeyAuthCacheInvalidator(apiKeyService)
|
|
promoService := service.NewPromoService(promoCodeRepository, userRepository, billingCacheService, client, apiKeyAuthCacheInvalidator)
|
|
authService := service.NewAuthService(userRepository, configConfig, settingService, emailService, turnstileService, emailQueueService, promoService)
|
|
userService := service.NewUserService(userRepository, apiKeyAuthCacheInvalidator)
|
|
authHandler := handler.NewAuthHandler(configConfig, authService, userService, settingService, promoService)
|
|
userHandler := handler.NewUserHandler(userService)
|
|
apiKeyHandler := handler.NewAPIKeyHandler(apiKeyService)
|
|
usageLogRepository := repository.NewUsageLogRepository(client, db)
|
|
usageService := service.NewUsageService(usageLogRepository, userRepository, client, apiKeyAuthCacheInvalidator)
|
|
usageHandler := handler.NewUsageHandler(usageService, apiKeyService)
|
|
redeemCodeRepository := repository.NewRedeemCodeRepository(client)
|
|
subscriptionService := service.NewSubscriptionService(groupRepository, userSubscriptionRepository, billingCacheService)
|
|
redeemCache := repository.NewRedeemCache(redisClient)
|
|
redeemService := service.NewRedeemService(redeemCodeRepository, userRepository, subscriptionService, redeemCache, billingCacheService, client, apiKeyAuthCacheInvalidator)
|
|
redeemHandler := handler.NewRedeemHandler(redeemService)
|
|
subscriptionHandler := handler.NewSubscriptionHandler(subscriptionService)
|
|
dashboardAggregationRepository := repository.NewDashboardAggregationRepository(db)
|
|
dashboardStatsCache := repository.NewDashboardCache(redisClient, configConfig)
|
|
dashboardService := service.NewDashboardService(usageLogRepository, dashboardAggregationRepository, dashboardStatsCache, configConfig)
|
|
timingWheelService, err := service.ProvideTimingWheelService()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
dashboardAggregationService := service.ProvideDashboardAggregationService(dashboardAggregationRepository, timingWheelService, configConfig)
|
|
dashboardHandler := admin.NewDashboardHandler(dashboardService, dashboardAggregationService)
|
|
accountRepository := repository.NewAccountRepository(client, db)
|
|
proxyRepository := repository.NewProxyRepository(client, db)
|
|
proxyExitInfoProber := repository.NewProxyExitInfoProber(configConfig)
|
|
proxyLatencyCache := repository.NewProxyLatencyCache(redisClient)
|
|
adminService := service.NewAdminService(userRepository, groupRepository, accountRepository, proxyRepository, apiKeyRepository, redeemCodeRepository, billingCacheService, proxyExitInfoProber, proxyLatencyCache, apiKeyAuthCacheInvalidator)
|
|
adminUserHandler := admin.NewUserHandler(adminService)
|
|
groupHandler := admin.NewGroupHandler(adminService)
|
|
claudeOAuthClient := repository.NewClaudeOAuthClient()
|
|
oAuthService := service.NewOAuthService(proxyRepository, claudeOAuthClient)
|
|
openAIOAuthClient := repository.NewOpenAIOAuthClient()
|
|
openAIOAuthService := service.NewOpenAIOAuthService(proxyRepository, openAIOAuthClient)
|
|
geminiOAuthClient := repository.NewGeminiOAuthClient(configConfig)
|
|
geminiCliCodeAssistClient := repository.NewGeminiCliCodeAssistClient()
|
|
geminiOAuthService := service.NewGeminiOAuthService(proxyRepository, geminiOAuthClient, geminiCliCodeAssistClient, configConfig)
|
|
antigravityOAuthService := service.NewAntigravityOAuthService(proxyRepository)
|
|
geminiQuotaService := service.NewGeminiQuotaService(configConfig, settingRepository)
|
|
tempUnschedCache := repository.NewTempUnschedCache(redisClient)
|
|
timeoutCounterCache := repository.NewTimeoutCounterCache(redisClient)
|
|
geminiTokenCache := repository.NewGeminiTokenCache(redisClient)
|
|
compositeTokenCacheInvalidator := service.NewCompositeTokenCacheInvalidator(geminiTokenCache)
|
|
rateLimitService := service.ProvideRateLimitService(accountRepository, usageLogRepository, configConfig, geminiQuotaService, tempUnschedCache, timeoutCounterCache, settingService, compositeTokenCacheInvalidator)
|
|
claudeUsageFetcher := repository.NewClaudeUsageFetcher()
|
|
antigravityQuotaFetcher := service.NewAntigravityQuotaFetcher(proxyRepository)
|
|
usageCache := service.NewUsageCache()
|
|
accountUsageService := service.NewAccountUsageService(accountRepository, usageLogRepository, claudeUsageFetcher, geminiQuotaService, antigravityQuotaFetcher, usageCache)
|
|
geminiTokenProvider := service.NewGeminiTokenProvider(accountRepository, geminiTokenCache, geminiOAuthService)
|
|
gatewayCache := repository.NewGatewayCache(redisClient)
|
|
antigravityTokenProvider := service.NewAntigravityTokenProvider(accountRepository, geminiTokenCache, antigravityOAuthService)
|
|
httpUpstream := repository.NewHTTPUpstream(configConfig)
|
|
antigravityGatewayService := service.NewAntigravityGatewayService(accountRepository, gatewayCache, antigravityTokenProvider, rateLimitService, httpUpstream, settingService)
|
|
accountTestService := service.NewAccountTestService(accountRepository, geminiTokenProvider, antigravityGatewayService, httpUpstream, configConfig)
|
|
concurrencyCache := repository.ProvideConcurrencyCache(redisClient, configConfig)
|
|
concurrencyService := service.ProvideConcurrencyService(concurrencyCache, accountRepository, configConfig)
|
|
crsSyncService := service.NewCRSSyncService(accountRepository, proxyRepository, oAuthService, openAIOAuthService, geminiOAuthService, configConfig)
|
|
accountHandler := admin.NewAccountHandler(adminService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, rateLimitService, accountUsageService, accountTestService, concurrencyService, crsSyncService)
|
|
oAuthHandler := admin.NewOAuthHandler(oAuthService)
|
|
openAIOAuthHandler := admin.NewOpenAIOAuthHandler(openAIOAuthService, adminService)
|
|
geminiOAuthHandler := admin.NewGeminiOAuthHandler(geminiOAuthService)
|
|
antigravityOAuthHandler := admin.NewAntigravityOAuthHandler(antigravityOAuthService)
|
|
proxyHandler := admin.NewProxyHandler(adminService)
|
|
adminRedeemHandler := admin.NewRedeemHandler(adminService)
|
|
promoHandler := admin.NewPromoHandler(promoService)
|
|
opsRepository := repository.NewOpsRepository(db)
|
|
schedulerCache := repository.NewSchedulerCache(redisClient)
|
|
schedulerOutboxRepository := repository.NewSchedulerOutboxRepository(db)
|
|
schedulerSnapshotService := service.ProvideSchedulerSnapshotService(schedulerCache, schedulerOutboxRepository, accountRepository, groupRepository, configConfig)
|
|
pricingRemoteClient := repository.ProvidePricingRemoteClient(configConfig)
|
|
pricingService, err := service.ProvidePricingService(configConfig, pricingRemoteClient)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
billingService := service.NewBillingService(configConfig, pricingService)
|
|
identityCache := repository.NewIdentityCache(redisClient)
|
|
identityService := service.NewIdentityService(identityCache)
|
|
deferredService := service.ProvideDeferredService(accountRepository, timingWheelService)
|
|
claudeTokenProvider := service.NewClaudeTokenProvider(accountRepository, geminiTokenCache, oAuthService)
|
|
gatewayService := service.NewGatewayService(accountRepository, groupRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, identityService, httpUpstream, deferredService, claudeTokenProvider)
|
|
openAITokenProvider := service.NewOpenAITokenProvider(accountRepository, geminiTokenCache, openAIOAuthService)
|
|
openAIGatewayService := service.NewOpenAIGatewayService(accountRepository, usageLogRepository, userRepository, userSubscriptionRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, httpUpstream, deferredService, openAITokenProvider)
|
|
geminiMessagesCompatService := service.NewGeminiMessagesCompatService(accountRepository, groupRepository, gatewayCache, schedulerSnapshotService, geminiTokenProvider, rateLimitService, httpUpstream, antigravityGatewayService, configConfig)
|
|
opsService := service.NewOpsService(opsRepository, settingRepository, configConfig, accountRepository, concurrencyService, gatewayService, openAIGatewayService, geminiMessagesCompatService, antigravityGatewayService)
|
|
settingHandler := admin.NewSettingHandler(settingService, emailService, turnstileService, opsService)
|
|
opsHandler := admin.NewOpsHandler(opsService)
|
|
updateCache := repository.NewUpdateCache(redisClient)
|
|
gitHubReleaseClient := repository.ProvideGitHubReleaseClient(configConfig)
|
|
serviceBuildInfo := provideServiceBuildInfo(buildInfo)
|
|
updateService := service.ProvideUpdateService(updateCache, gitHubReleaseClient, serviceBuildInfo)
|
|
systemHandler := handler.ProvideSystemHandler(updateService)
|
|
adminSubscriptionHandler := admin.NewSubscriptionHandler(subscriptionService)
|
|
adminUsageHandler := admin.NewUsageHandler(usageService, apiKeyService, adminService)
|
|
userAttributeDefinitionRepository := repository.NewUserAttributeDefinitionRepository(client)
|
|
userAttributeValueRepository := repository.NewUserAttributeValueRepository(client)
|
|
userAttributeService := service.NewUserAttributeService(userAttributeDefinitionRepository, userAttributeValueRepository)
|
|
userAttributeHandler := admin.NewUserAttributeHandler(userAttributeService)
|
|
adminHandlers := handler.ProvideAdminHandlers(dashboardHandler, adminUserHandler, groupHandler, accountHandler, oAuthHandler, openAIOAuthHandler, geminiOAuthHandler, antigravityOAuthHandler, proxyHandler, adminRedeemHandler, promoHandler, settingHandler, opsHandler, systemHandler, adminSubscriptionHandler, adminUsageHandler, userAttributeHandler)
|
|
gatewayHandler := handler.NewGatewayHandler(gatewayService, geminiMessagesCompatService, antigravityGatewayService, userService, concurrencyService, billingCacheService, configConfig)
|
|
openAIGatewayHandler := handler.NewOpenAIGatewayHandler(openAIGatewayService, concurrencyService, billingCacheService, configConfig)
|
|
handlerSettingHandler := handler.ProvideSettingHandler(settingService, buildInfo)
|
|
handlers := handler.ProvideHandlers(authHandler, userHandler, apiKeyHandler, usageHandler, redeemHandler, subscriptionHandler, adminHandlers, gatewayHandler, openAIGatewayHandler, handlerSettingHandler)
|
|
jwtAuthMiddleware := middleware.NewJWTAuthMiddleware(authService, userService)
|
|
adminAuthMiddleware := middleware.NewAdminAuthMiddleware(authService, userService, settingService)
|
|
apiKeyAuthMiddleware := middleware.NewAPIKeyAuthMiddleware(apiKeyService, subscriptionService, configConfig)
|
|
engine := server.ProvideRouter(configConfig, handlers, jwtAuthMiddleware, adminAuthMiddleware, apiKeyAuthMiddleware, apiKeyService, subscriptionService, opsService, settingService, redisClient)
|
|
httpServer := server.ProvideHTTPServer(configConfig, engine)
|
|
opsMetricsCollector := service.ProvideOpsMetricsCollector(opsRepository, settingRepository, accountRepository, concurrencyService, db, redisClient, configConfig)
|
|
opsAggregationService := service.ProvideOpsAggregationService(opsRepository, settingRepository, db, redisClient, configConfig)
|
|
opsAlertEvaluatorService := service.ProvideOpsAlertEvaluatorService(opsService, opsRepository, emailService, redisClient, configConfig)
|
|
opsCleanupService := service.ProvideOpsCleanupService(opsRepository, db, redisClient, configConfig)
|
|
opsScheduledReportService := service.ProvideOpsScheduledReportService(opsService, userService, emailService, redisClient, configConfig)
|
|
tokenRefreshService := service.ProvideTokenRefreshService(accountRepository, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService, compositeTokenCacheInvalidator, configConfig)
|
|
accountExpiryService := service.ProvideAccountExpiryService(accountRepository)
|
|
v := provideCleanup(client, redisClient, opsMetricsCollector, opsAggregationService, opsAlertEvaluatorService, opsCleanupService, opsScheduledReportService, schedulerSnapshotService, tokenRefreshService, accountExpiryService, pricingService, emailQueueService, billingCacheService, oAuthService, openAIOAuthService, geminiOAuthService, antigravityOAuthService)
|
|
application := &Application{
|
|
Server: httpServer,
|
|
Cleanup: v,
|
|
}
|
|
return application, nil
|
|
}
|
|
|
|
// wire.go:
|
|
|
|
type Application struct {
|
|
Server *http.Server
|
|
Cleanup func()
|
|
}
|
|
|
|
func provideServiceBuildInfo(buildInfo handler.BuildInfo) service.BuildInfo {
|
|
return service.BuildInfo{
|
|
Version: buildInfo.Version,
|
|
BuildType: buildInfo.BuildType,
|
|
}
|
|
}
|
|
|
|
func provideCleanup(
|
|
entClient *ent.Client,
|
|
rdb *redis.Client,
|
|
opsMetricsCollector *service.OpsMetricsCollector,
|
|
opsAggregation *service.OpsAggregationService,
|
|
opsAlertEvaluator *service.OpsAlertEvaluatorService,
|
|
opsCleanup *service.OpsCleanupService,
|
|
opsScheduledReport *service.OpsScheduledReportService,
|
|
schedulerSnapshot *service.SchedulerSnapshotService,
|
|
tokenRefresh *service.TokenRefreshService,
|
|
accountExpiry *service.AccountExpiryService,
|
|
pricing *service.PricingService,
|
|
emailQueue *service.EmailQueueService,
|
|
billingCache *service.BillingCacheService,
|
|
oauth *service.OAuthService,
|
|
openaiOAuth *service.OpenAIOAuthService,
|
|
geminiOAuth *service.GeminiOAuthService,
|
|
antigravityOAuth *service.AntigravityOAuthService,
|
|
) func() {
|
|
return func() {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
cleanupSteps := []struct {
|
|
name string
|
|
fn func() error
|
|
}{
|
|
{"OpsScheduledReportService", func() error {
|
|
if opsScheduledReport != nil {
|
|
opsScheduledReport.Stop()
|
|
}
|
|
return nil
|
|
}},
|
|
{"OpsCleanupService", func() error {
|
|
if opsCleanup != nil {
|
|
opsCleanup.Stop()
|
|
}
|
|
return nil
|
|
}},
|
|
{"OpsAlertEvaluatorService", func() error {
|
|
if opsAlertEvaluator != nil {
|
|
opsAlertEvaluator.Stop()
|
|
}
|
|
return nil
|
|
}},
|
|
{"OpsAggregationService", func() error {
|
|
if opsAggregation != nil {
|
|
opsAggregation.Stop()
|
|
}
|
|
return nil
|
|
}},
|
|
{"OpsMetricsCollector", func() error {
|
|
if opsMetricsCollector != nil {
|
|
opsMetricsCollector.Stop()
|
|
}
|
|
return nil
|
|
}},
|
|
{"SchedulerSnapshotService", func() error {
|
|
if schedulerSnapshot != nil {
|
|
schedulerSnapshot.Stop()
|
|
}
|
|
return nil
|
|
}},
|
|
{"TokenRefreshService", func() error {
|
|
tokenRefresh.Stop()
|
|
return nil
|
|
}},
|
|
{"AccountExpiryService", func() error {
|
|
accountExpiry.Stop()
|
|
return nil
|
|
}},
|
|
{"PricingService", func() error {
|
|
pricing.Stop()
|
|
return nil
|
|
}},
|
|
{"EmailQueueService", func() error {
|
|
emailQueue.Stop()
|
|
return nil
|
|
}},
|
|
{"BillingCacheService", func() error {
|
|
billingCache.Stop()
|
|
return nil
|
|
}},
|
|
{"OAuthService", func() error {
|
|
oauth.Stop()
|
|
return nil
|
|
}},
|
|
{"OpenAIOAuthService", func() error {
|
|
openaiOAuth.Stop()
|
|
return nil
|
|
}},
|
|
{"GeminiOAuthService", func() error {
|
|
geminiOAuth.Stop()
|
|
return nil
|
|
}},
|
|
{"AntigravityOAuthService", func() error {
|
|
antigravityOAuth.Stop()
|
|
return nil
|
|
}},
|
|
{"Redis", func() error {
|
|
return rdb.Close()
|
|
}},
|
|
{"Ent", func() error {
|
|
return entClient.Close()
|
|
}},
|
|
}
|
|
|
|
for _, step := range cleanupSteps {
|
|
if err := step.fn(); err != nil {
|
|
log.Printf("[Cleanup] %s failed: %v", step.name, err)
|
|
|
|
} else {
|
|
log.Printf("[Cleanup] %s succeeded", step.name)
|
|
}
|
|
}
|
|
|
|
select {
|
|
case <-ctx.Done():
|
|
log.Printf("[Cleanup] Warning: cleanup timed out after 10 seconds")
|
|
default:
|
|
log.Printf("[Cleanup] All cleanup steps completed")
|
|
}
|
|
}
|
|
}
|