func()

in router/core/router.go [931:1070]
121 lines of code
25 McCabe index (conditional complexity)

func (r *Router) buildClients() error {
	s3Providers := map[string]config.S3StorageProvider{}
	cdnProviders := map[string]config.BaseStorageProvider{}
	redisProviders := map[string]config.RedisStorageProvider{}

	for _, provider := range r.storageProviders.S3 {
		if _, ok := s3Providers[provider.ID]; ok {
			return fmt.Errorf("duplicate s3 storage provider with id '%s'", provider.ID)
		}
		s3Providers[provider.ID] = provider
	}

	for _, provider := range r.storageProviders.CDN {
		if _, ok := cdnProviders[provider.ID]; ok {
			return fmt.Errorf("duplicate cdn storage provider with id '%s'", provider.ID)
		}
		cdnProviders[provider.ID] = provider
	}

	for _, provider := range r.storageProviders.Redis {
		if _, ok := redisProviders[provider.ID]; ok {
			return fmt.Errorf("duplicate Redis storage provider with id '%s'", provider.ID)
		}
		redisProviders[provider.ID] = provider
	}

	var pClient persistedoperation.Client

	if provider, ok := cdnProviders[r.persistedOperationsConfig.Storage.ProviderID]; ok {
		if r.graphApiToken == "" {
			return errors.New("graph token is required to fetch persisted operations from CDN")
		}

		c, err := cdn.NewClient(provider.URL, r.graphApiToken, cdn.Options{
			Logger: r.logger,
		})
		if err != nil {
			return err
		}
		pClient = c

		r.logger.Info("Use CDN as storage provider for persisted operations",
			zap.String("provider_id", provider.ID),
		)
	} else if provider, ok := s3Providers[r.persistedOperationsConfig.Storage.ProviderID]; ok {

		c, err := s3.NewClient(provider.Endpoint, &s3.Options{
			AccessKeyID:      provider.AccessKey,
			SecretAccessKey:  provider.SecretKey,
			Region:           provider.Region,
			UseSSL:           provider.Secure,
			BucketName:       provider.Bucket,
			ObjectPathPrefix: r.persistedOperationsConfig.Storage.ObjectPrefix,
			TraceProvider:    r.tracerProvider,
		})
		if err != nil {
			return err
		}
		pClient = c

		r.logger.Info("Use S3 as storage provider for persisted operations",
			zap.String("provider_id", provider.ID),
		)
	} else if r.graphApiToken != "" {
		if r.persistedOperationsConfig.Storage.ProviderID != "" {
			return fmt.Errorf("unknown storage provider id '%s' for persisted operations", r.persistedOperationsConfig.Storage.ProviderID)
		}

		c, err := cdn.NewClient(r.cdnConfig.URL, r.graphApiToken, cdn.Options{
			Logger: r.logger,
		})
		if err != nil {
			return err
		}
		pClient = c

		r.logger.Debug("Default to Cosmo CDN as persisted operations provider",
			zap.String("url", r.cdnConfig.URL),
		)
	}

	var kvClient apq.KVClient
	if provider, ok := redisProviders[r.automaticPersistedQueriesConfig.Storage.ProviderID]; ok {
		c, err := apq.NewRedisClient(&apq.RedisOptions{
			Logger:        r.logger,
			StorageConfig: &provider,
			Prefix:        r.automaticPersistedQueriesConfig.Storage.ObjectPrefix,
		})
		if err != nil {
			return err
		}
		kvClient = c
		r.logger.Info("Use redis as storage provider for automatic persisted operations",
			zap.String("provider_id", provider.ID),
		)
	}

	var apqClient apq.Client
	if r.automaticPersistedQueriesConfig.Enabled {
		var err error
		apqClient, err = apq.NewClient(&apq.Options{
			Logger:    r.logger,
			ApqConfig: &r.automaticPersistedQueriesConfig,
			KVClient:  kvClient,
		})
		if err != nil {
			return err
		}
	}

	if pClient != nil || apqClient != nil {
		// For backwards compatibility with cdn config field
		cacheSize := r.persistedOperationsConfig.Cache.Size.Uint64()
		if cacheSize <= 0 {
			cacheSize = r.cdnConfig.CacheSize.Uint64()
		}

		c, err := persistedoperation.NewClient(&persistedoperation.Options{
			CacheSize:      cacheSize,
			Logger:         r.logger,
			ProviderClient: pClient,
			ApqClient:      apqClient,
		})
		if err != nil {
			return err
		}

		r.persistedOperationClient = c
	}

	configPoller, err := InitializeConfigPoller(r, cdnProviders, s3Providers)
	if err != nil {
		return err
	}
	if configPoller != nil {
		r.configPoller = *configPoller
	}

	return nil
}