func NewResourceManager()

in pkg/resource/manager.go [59:134]
58 lines of code
7 McCabe index (conditional complexity)

func NewResourceManager(ctx context.Context, resourceNames []string, wrapper api.Wrapper, log logr.Logger,
	healthzHandler *rcHealthz.HealthzHandler, conditions condition.Conditions) (ResourceManager, error) {
	// Load that static configuration of the resource
	resourceConfig := config.LoadResourceConfig()

	resources := make(map[string]Resource)

	healthCheckers := make(map[string]healthz.Checker)

	// add manager subpath into health checker map first
	healthCheckers[managerHealthCheckSubpath] = rcHealthz.SimplePing("resource manager", log)

	// For each supported resource, initialize the resource provider and handler
	for _, resourceName := range resourceNames {

		resourceConfig, ok := resourceConfig[resourceName]
		if !ok {
			return nil, fmt.Errorf("failed to find resource configuration %s", resourceName)
		}

		log.Info("initializing resource", "resource name",
			resourceName, "resource count", resourceConfig.WorkerCount)

		workers := worker.NewDefaultWorkerPool(
			resourceConfig.Name,
			resourceConfig.WorkerCount,
			config.WorkQueueDefaultMaxRetries,
			log.WithName(fmt.Sprintf("%s-%s", resourceName, "worker")), ctx)

		var resourceHandler handler.Handler
		var resourceProvider provider.ResourceProvider

		if resourceName == config.ResourceNameIPAddress {
			resourceProvider = ip.NewIPv4Provider(ctrl.Log.WithName("ipv4 provider"),
				wrapper, workers, resourceConfig, conditions)
			healthCheckers[ipv4ProviderHealthCheckSubpath] = resourceProvider.GetHealthChecker()
			resourceHandler = handler.NewWarmResourceHandler(ctrl.Log.WithName(resourceName), wrapper,
				resourceName, resourceProvider, ctx)
		} else if resourceName == config.ResourceNameIPAddressFromPrefix {
			resourceProvider = prefix.NewIPv4PrefixProvider(ctrl.Log.WithName("ipv4 prefix provider"),
				wrapper, workers, resourceConfig, conditions)
			healthCheckers[ipv4PrefixProviderHealthCheckSubpath] = resourceProvider.GetHealthChecker()
			resourceHandler = handler.NewWarmResourceHandler(ctrl.Log.WithName(resourceName), wrapper,
				config.ResourceNameIPAddress, resourceProvider, ctx)
		} else if resourceName == config.ResourceNamePodENI {
			resourceProvider = branch.NewBranchENIProvider(ctrl.Log.WithName("branch eni provider"),
				wrapper, workers, resourceConfig, ctx)
			healthCheckers[branchProviderHealthCheckSubpath] = resourceProvider.GetHealthChecker()
			resourceHandler = handler.NewOnDemandHandler(ctrl.Log.WithName(resourceName),
				resourceName, resourceProvider)
		} else {
			return nil, fmt.Errorf("resource type is not defnied %s", resourceName)
		}

		err := workers.StartWorkerPool(resourceProvider.ProcessAsyncJob)
		if err != nil {
			return nil, fmt.Errorf("unable to start the workers for resource %s", resourceName)
		}

		resources[resourceName] = Resource{
			Handler:          resourceHandler,
			ResourceProvider: resourceProvider,
		}

		log.Info("successfully initialized resource handler and provider",
			"resource name", resourceName)
	}

	// add health check on subpath for resource manager which includes providers as well
	healthzHandler.AddControllersHealthCheckers(healthCheckers)

	return &Manager{
		resource: resources,
		log:      log,
	}, nil
}