func main()

in main.go [65:247]
166 lines of code
30 McCabe index (conditional complexity)

func main() {
	nodeMetadata := make(map[string]string)
	flag.Var(newStringMapVal(&nodeMetadata), "node-metadata",
		"additional metadata of the form key=value to be included in the node configuration")

	flag.Var(flag.Lookup("secrets-dir").Value, "secrets-dir-experimental",
		"alias of secrets-dir. This flag is EXPERIMENTAL and will be removed in a later release")
	flag.Var(flag.Lookup("node-metadata").Value, "node-metadata-experimental",
		"alias of node-metadata. This flag is EXPERIMENTAL and will be removed in a later release")
	flag.Var(flag.Lookup("gke-cluster-name").Value, "gke-cluster-name-experimental",
		"alias of gke-cluster-name. This flag is EXPERIMENTAL and will be removed in a later release")
	flag.Var(flag.Lookup("generate-mesh-id").Value, "generate-mesh-id-experimental",
		"alias of generate-mesh-id. This flag is EXPERIMENTAL and will be removed in a later release")
	flag.Var(flag.Lookup("config-mesh").Value, "config-mesh-experimental",
		"alias of config-mesh. This flag is EXPERIMENTAL and will be removed in a later release")

	flag.Parse()

	if *gcpProjectNumber == 0 {
		var err error
		*gcpProjectNumber, err = getProjectID()
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error: failed to determine project id: %s\n", err)
			os.Exit(1)
		}
	}

	ip, err := getHostIP()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Warning: failed to determine host's IP: %s\n", err)
	}

	// Retrieve zone from the metadata server only if not specified in args.
	zone := *localityZone
	if zone == "" {
		zone, err = getZone()
		if err != nil {
			fmt.Fprintf(os.Stderr, "Warning: %s\n", err)
		}
	}

	// Generate deployment info from metadata server or from command-line
	// arguments, with the latter taking preference.
	var deploymentInfo map[string]string
	dType, err := getDeploymentType()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Warning: unable to determine deployment type: %s\n", err)
	}
	switch dType {
	case deploymentTypeGKE:
		cluster := *gkeClusterName
		if cluster == "" {
			cluster, err = getClusterName()
			if err != nil {
				fmt.Fprintf(os.Stderr, "Error: generating deployment info: %s\n", err)
				os.Exit(1)
			}
		}
		pod := *gkePodName
		if pod == "" {
			pod = getPodName()
		}
		clusterLocation := *gkeLocation
		if clusterLocation == "" {
			clusterLocation, err = getClusterLocality()
			if err != nil {
				fmt.Fprintf(os.Stderr, "Error: generating deployment info: %s\n", err)
				os.Exit(1)
			}
		}
		deploymentInfo = map[string]string{
			"GKE-CLUSTER":  cluster,
			"GKE-LOCATION": clusterLocation,
			"GCP-ZONE":     zone,
			"INSTANCE-IP":  ip,
			"GKE-POD":      pod,
		}
		if *gkeNamespace != "" {
			deploymentInfo["GKE-NAMESPACE"] = *gkeNamespace
		}
	case deploymentTypeGCE:
		vmName := *gceVM
		if vmName == "" {
			vmName = getVMName()
		}
		deploymentInfo = map[string]string{
			"GCE-VM":      vmName,
			"GCP-ZONE":    zone,
			"INSTANCE-IP": ip,
		}
	}

	meshID := *configMesh
	if *generateMeshID {
		if meshID != "" {
			fmt.Fprint(os.Stderr, "Error: --config-mesh flag cannot be specified while --generate-mesh-id is also set.\n")
			os.Exit(1)
		}

		clusterLocality := *gkeLocation
		if clusterLocality == "" {
			clusterLocality, err = getClusterLocality()
			if err != nil {
				fmt.Fprintf(os.Stderr, "Error: unable to generate mesh id: %s\n", err)
				os.Exit(1)
			}
		}

		cluster := *gkeClusterName
		if cluster == "" {
			cluster, err = getClusterName()
			if err != nil {
				fmt.Fprintf(os.Stderr, "Error: unable to generate mesh id: %s\n", err)
				os.Exit(1)
			}
		}

		meshNamer := csmnamer.MeshNamer{
			ClusterName: cluster,
			Location:    clusterLocality,
		}
		meshID = meshNamer.GenerateMeshId()
	}

	gitCommitHash, err := getCommitID()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error: unable to determine git commit ID: %s\n", err)
		os.Exit(1)
	}

	input := configInput{
		xdsServerURI:               *xdsServerURI,
		gcpProjectNumber:           *gcpProjectNumber,
		vpcNetworkName:             *vpcNetworkName,
		ip:                         ip,
		zone:                       zone,
		ignoreResourceDeletion:     *ignoreResourceDeletion,
		secretsDir:                 *secretsDir,
		metadataLabels:             nodeMetadata,
		deploymentInfo:             deploymentInfo,
		configMesh:                 meshID,
		ipv6Capable:                isIPv6Capable(),
		gitCommitHash:              gitCommitHash,
		isTrustedXDSServer:         *isTrustedXDSServer,
		includeAllowedGrpcServices: *includeAllowedGrpcServices,
	}

	if err := validate(input); err != nil {
		fmt.Fprintf(os.Stderr, "Error: %s\n", err)
		os.Exit(1)
	}

	config, err := generate(input)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to generate config: %s\n", err)
		os.Exit(1)
	}
	var output *os.File
	if *outputName == "-" {
		output = os.Stdout
	} else {
		output, err = os.Create(*outputName)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Failed to open output file: %s\n", err)
			os.Exit(1)
		}
	}
	_, err = output.Write(config)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to write config: %s\n", err)
		os.Exit(1)
	}
	_, err = output.Write([]byte("\n"))
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to write config: %s\n", err)
		os.Exit(1)
	}
	err = output.Close()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to close config: %s\n", err)
		os.Exit(1)
	}
}