func main()

in clusterloader2/cmd/clusterloader.go [241:376]
118 lines of code
33 McCabe index (conditional complexity)

func main() {
	defer klog.Flush()
	initFlags()
	if err := flags.Parse(); err != nil {
		klog.Exitf("Flag parse failed: %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 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
	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.EnableExecService {
		if err := execservice.SetUpExecService(f); 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)
		if !errList.IsEmpty() {
			klog.Exitf("Test compilation failed: %s", errList.String())
		}
		if err := dumpTestConfig(ctx, testConfig); err != nil {
			klog.Errorf("Error while dumping test config: %v", err)
		}
		ctx.SetTestConfig(testConfig)
		contexts = append(contexts, ctx)
	}

	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.EnableExecService {
		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)
	}
}