func main()

in clusterloader2/cmd/clusterloader.go [258:413]
133 lines of code
37 McCabe index (conditional complexity)

func main() {
	defer klog.Flush()
	initFlags()
	if err := flags.Parse(); err != nil {
		klog.Exitf("Flag parse failed: %v", err)
	}

	// Start http server with pprof.
	go func() {
		klog.Infof("Listening on %d", port)
		err := http.ListenAndServe(fmt.Sprintf("localhost:%d", port), nil)
		klog.Errorf("http server unexpectedly ended: %v", err)
	}()

	provider, err := provider.NewProvider(&providerInitOptions)
	if err != nil {
		klog.Exitf("Error init provider: %v", err)
	}
	clusterLoaderConfig.ClusterConfig.Provider = provider

	if errList := validateFlags(); !errList.IsEmpty() {
		klog.Exitf("Parsing flags error: %v", errList.String())
	}

	mclient, err := framework.NewMultiClientSet(clusterLoaderConfig.ClusterConfig.KubeConfigPath, 1)
	if err != nil {
		klog.Exitf("Client creation error: %v", err)
	}

	if err = completeConfig(mclient); err != nil {
		klog.Exitf("Config completing error: %v", err)
	}

	klog.V(0).Infof("Using config: %+v", clusterLoaderConfig)

	if err = createReportDir(); err != nil {
		klog.Exitf("Cannot create report directory: %v", err)
	}

	if err = util.LogClusterNodes(mclient.GetClient()); err != nil {
		klog.Errorf("Nodes info logging error: %v", err)
	}

	if !clusterLoaderConfig.ClusterConfig.SkipClusterVerification {
		if err = verifyCluster(mclient.GetClient()); err != nil {
			klog.Exitf("Cluster verification error: %v", err)
		}
	}

	f, err := framework.NewFramework(
		&clusterLoaderConfig.ClusterConfig,
		clusterLoaderConfig.ClusterConfig.K8SClientsNumber,
	)
	if err != nil {
		klog.Exitf("Framework creation error: %v", err)
	}

	var prometheusController *prometheus.Controller
	var prometheusFramework *framework.Framework
	var testReporter test.Reporter

	if !dryRun {
		if clusterLoaderConfig.PrometheusConfig.EnableServer {
			if prometheusController, err = prometheus.NewController(&clusterLoaderConfig); err != nil {
				klog.Exitf("Error while creating Prometheus Controller: %v", err)
			}
			prometheusFramework = prometheusController.GetFramework()
			if err := prometheusController.SetUpPrometheusStack(); err != nil {
				klog.Exitf("Error while setting up prometheus stack: %v", err)
			}
			if clusterLoaderConfig.PrometheusConfig.TearDownServer {
				prometheusController.EnableTearDownPrometheusStackOnInterrupt()
			}
		}
		if clusterLoaderConfig.ExecServiceConfig.Enable {
			if err := execservice.SetUpExecService(f, clusterLoaderConfig.ExecServiceConfig); err != nil {
				klog.Exitf("Error while setting up exec service: %v", err)
			}
		}
		if err := imagepreload.Setup(&clusterLoaderConfig, f); err != nil {
			klog.Exitf("Error while preloading images: %v", err)
		}

		if err := metadata.Dump(f, path.Join(clusterLoaderConfig.ReportDir, "cl2-metadata.json")); err != nil {
			klog.Errorf("Error while dumping metadata: %v", err)
		}
		testReporter = test.CreateSimpleReporter(path.Join(clusterLoaderConfig.ReportDir, "junit.xml"), "ClusterLoaderV2")
		testReporter.BeginTestSuite()
	}

	var testScenarios []api.TestScenario
	if testSuiteConfigPath != "" {
		testSuite, err := config.LoadTestSuite(testSuiteConfigPath)
		if err != nil {
			klog.Exitf("Error while reading test suite: %v", err)
		}
		testScenarios = []api.TestScenario(testSuite)
	} else {
		for i := range testConfigPaths {
			testScenario := api.TestScenario{
				ConfigPath:    testConfigPaths[i],
				OverridePaths: []string{},
			}
			testScenarios = append(testScenarios, testScenario)
		}
	}

	var contexts []test.Context
	for i := range testScenarios {
		ctx, errList := test.CreateTestContext(f, prometheusFramework, &clusterLoaderConfig, testReporter, &testScenarios[i])
		if !errList.IsEmpty() {
			klog.Exitf("Test context creation failed: %s", errList.String())
		}
		testConfig, errList := test.CompileTestConfig(ctx)
		// Dump test config before checking errors - it can still be useful for debugging.
		if testConfig != nil {
			if err := dumpTestConfig(ctx, testConfig); err != nil {
				klog.Errorf("Error while dumping test config: %v", err)
			}
		}
		if !errList.IsEmpty() {
			klog.Exitf("Test compilation failed: %s", errList.String())
		}
		ctx.SetTestConfig(testConfig)
		contexts = append(contexts, ctx)
	}

	if dryRun {
		// Dry run always exits with error so if it's ever enabled in CI, the test will fail.
		klog.Exitf("Dry run mode enabled, exiting after dumping test config in %s.", path.Join(clusterLoaderConfig.ReportDir))
	}

	for i := range contexts {
		runSingleTest(contexts[i])
	}

	testReporter.EndTestSuite()

	if err := prometheusController.MakePrometheusSnapshotIfEnabled(); err != nil {
		klog.Errorf("Error while making prometheus snapshot: %v", err)
	}

	if clusterLoaderConfig.PrometheusConfig.EnableServer && clusterLoaderConfig.PrometheusConfig.TearDownServer {
		if err := prometheusController.TearDownPrometheusStack(); err != nil {
			klog.Errorf("Error while tearing down prometheus stack: %v", err)
		}
	}
	if clusterLoaderConfig.ExecServiceConfig.Enable {
		if err := execservice.TearDownExecService(f); err != nil {
			klog.Errorf("Error while tearing down exec service: %v", err)
		}
	}
	if failedTestItems := testReporter.GetNumberOfFailedTestItems(); failedTestItems > 0 {
		klog.Exitf("%d tests have failed!", failedTestItems)
	}
}