func main()

in hack/tools/launchtemplate_counter/main.go [45:150]
99 lines of code
5 McCabe index (conditional complexity)

func main() {
	lo.Must0(os.Setenv("AWS_SDK_LOAD_CONFIG", "true"))

	ctx := coreoptions.ToContext(context.Background(), coretest.Options(coretest.OptionsFields{
		FeatureGates: coretest.FeatureGates{ReservedCapacity: lo.ToPtr(false)},
	}))
	ctx = options.ToContext(ctx, test.Options(test.OptionsFields{
		ClusterName:     lo.ToPtr("docs-gen"),
		ClusterEndpoint: lo.ToPtr("https://docs-gen.aws"),
		IsolatedVPC:     lo.ToPtr(true), // disable pricing lookup
	}))

	region := "us-west-2"
	cfg := lo.Must(config.LoadDefaultConfig(ctx, config.WithRegion(region)))
	ec2api := ec2.NewFromConfig(cfg)
	subnetProvider := subnet.NewDefaultProvider(ec2api, cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval), cache.New(awscache.AvailableIPAddressTTL, awscache.DefaultCleanupInterval), cache.New(awscache.AssociatePublicIPAddressTTL, awscache.DefaultCleanupInterval))
	instanceTypeProvider := instancetype.NewDefaultProvider(
		cache.New(awscache.InstanceTypesZonesAndOfferingsTTL, awscache.DefaultCleanupInterval),
		cache.New(awscache.InstanceTypesZonesAndOfferingsTTL, awscache.DefaultCleanupInterval),
		cache.New(awscache.DiscoveredCapacityCacheTTL, awscache.DefaultCleanupInterval),
		ec2api,
		subnetProvider,
		pricing.NewDefaultProvider(
			ctx,
			pricing.NewAPI(cfg),
			ec2api,
			cfg.Region,
		),
		nil,
		awscache.NewUnavailableOfferings(),
		instancetype.NewDefaultResolver(
			region,
		),
	)
	if err := instanceTypeProvider.UpdateInstanceTypes(ctx); err != nil {
		log.Fatalf("updating instance types, %s", err)
	}
	if err := instanceTypeProvider.UpdateInstanceTypeOfferings(ctx); err != nil {
		log.Fatalf("updating instance types offerings, %s", err)
	}
	// Fake a NodeClass, so we can use it to get InstanceTypes
	nodeClass := &v1.EC2NodeClass{
		Spec: v1.EC2NodeClassSpec{
			AMISelectorTerms: []v1.AMISelectorTerm{{
				Alias: "al2023@latest",
			}},
			SubnetSelectorTerms: []v1.SubnetSelectorTerm{
				{
					Tags: map[string]string{
						"*": "*",
					},
				},
			},
		},
	}
	subnets, err := subnetProvider.List(ctx, nodeClass)
	if err != nil {
		log.Fatalf("listing subnets, %s", err)
	}
	nodeClass.Status.Subnets = lo.Map(subnets, func(ec2subnet ec2types.Subnet, _ int) v1.Subnet {
		return v1.Subnet{
			ID:   *ec2subnet.SubnetId,
			Zone: *ec2subnet.AvailabilityZone,
		}
	})
	nodeClass.Status.AMIs = []v1.AMI{
		{
			ID:   coretest.RandomName(),
			Name: coretest.RandomName(),
			Requirements: []corev1.NodeSelectorRequirement{
				{
					Key:      corev1.LabelArchStable,
					Operator: corev1.NodeSelectorOpIn,
					Values:   []string{karpv1.ArchitectureAmd64},
				},
			},
		},
		{
			ID:   coretest.RandomName(),
			Name: coretest.RandomName(),
			Requirements: []corev1.NodeSelectorRequirement{
				{
					Key:      corev1.LabelArchStable,
					Operator: corev1.NodeSelectorOpIn,
					Values:   []string{karpv1.ArchitectureArm64},
				},
			},
		},
	}
	instanceTypes := lo.Must(instanceTypeProvider.List(ctx, nodeClass))

	// See how many launch templates we get by constraining our instance types to just be "c", "m", and "r"
	reqs := scheduling.NewRequirements(scheduling.NewRequirement(v1.LabelInstanceCategory, corev1.NodeSelectorOpIn, "c", "m", "r"))
	instanceTypes = lo.Filter(instanceTypes, func(it *cloudprovider.InstanceType, _ int) bool {
		return it.Requirements.Compatible(reqs) == nil
	})
	fmt.Printf("Got %d instance types after filtering\n", len(instanceTypes))

	resolver := amifamily.NewDefaultResolver()
	launchTemplates, err := resolver.Resolve(nodeClass, &karpv1.NodeClaim{}, lo.Slice(instanceTypes, 0, 60), karpv1.CapacityTypeOnDemand, &amifamily.Options{InstanceStorePolicy: lo.ToPtr(v1.InstanceStorePolicyRAID0)})

	if err != nil {
		log.Fatalf("resolving launchTemplates, %s", err)
	}
	fmt.Printf("Got %d launch templates back from the resolver\n", len(launchTemplates))
}