Create pipeline stage to generate list of supported resources

hack/crossplane/apis/resources.md

@@ -0,0 +1,13 @@
+### microsoft.cache
+
+v1alpha1api20200601
+
+- Redis
+
+### microsoft.sql
+
+v1alpha1api20201101preview
+
+- Server
+- ServersDatabase
+

hack/generated/apis/resources.md

@@ -0,0 +1,65 @@
+### microsoft.batch
+
+v1alpha1api20210101
+
+- BatchAccount
+
+### microsoft.compute
+
+v1alpha1api20200930
+
+- Disk
+
+v1alpha1api20201201
+
+- VirtualMachineScaleSet
+
+### microsoft.containerservice
+
+v1alpha1api20210501
+
+- ManagedCluster
+- ManagedClustersAgentPool
+
+### microsoft.documentdb
+
+v1alpha1api20210515
+
+- DatabaseAccount
+
+### microsoft.managedidentity
+
+v1alpha1api20181130
+
+- UserAssignedIdentity
+
+### microsoft.network
+
+v1alpha1api20201101
+
+- LoadBalancer
+- NetworkSecurityGroup
+- NetworkSecurityGroupsSecurityRule
+- PublicIPAddress
+- VirtualNetwork
+- VirtualNetworkGateway
+- VirtualNetworkTap
+- VirtualNetworksSubnet
+- VirtualNetworksVirtualNetworkPeering
+
+### microsoft.servicebus
+
+v1alpha1api20210101preview
+
+- Namespace
+- NamespacesQueue
+- NamespacesTopic
+
+### microsoft.storage
+
+v1alpha1api20210401
+
+- StorageAccount
+- StorageAccountsBlobService
+- StorageAccountsBlobServicesContainer
+

hack/generator/pkg/codegen/code_generator.go

@@ -196,6 +196,8 @@ func createAllPipelineStages(idFactory astmodel.IdentifierFactory, configuration
 		pipeline.ExportPackages(configuration.FullTypesOutputPath()),
 
 		pipeline.ExportControllerResourceRegistrations(configuration.FullTypesRegistrationOutputFilePath()).UsedFor(pipeline.ARMTarget),
+
+		pipeline.ReportResourceVersions(configuration),
 	}
 }
 

hack/generator/pkg/codegen/golden_files_test.go

@@ -159,7 +159,8 @@ func NewTestCodeGenerator(testName string, path string, t *testing.T, testConfig
 			pipeline.ImplementConvertibleSpecInterfaceStageId,
 			pipeline.ImplementConvertibleStatusInterfaceStageId,
 			pipeline.ReportOnTypesAndVersionsStageID,
-			pipeline.AddStatusConditionsStageID)
+			pipeline.AddStatusConditionsStageID,
+			pipeline.ReportResourceVersionsStageID)
 		if !testConfig.HasARMResources {
 			codegen.RemoveStages(pipeline.CreateARMTypesStageID, pipeline.ApplyARMConversionInterfaceStageID)
 
@@ -176,7 +177,10 @@ func NewTestCodeGenerator(testName string, path string, t *testing.T, testConfig
 			codegen.ReplaceStage(pipeline.AddCrossResourceReferencesStageID, addCrossResourceReferencesForTest(idFactory))
 		}
 	case config.GenerationPipelineCrossplane:
-		codegen.RemoveStages(pipeline.DeleteGeneratedCodeStageID, pipeline.CheckForAnyTypeStageID)
+		codegen.RemoveStages(
+			pipeline.DeleteGeneratedCodeStageID,
+			pipeline.CheckForAnyTypeStageID,
+			pipeline.ReportResourceVersionsStageID)
 		if !testConfig.HasARMResources {
 			codegen.ReplaceStage(pipeline.StripUnreferencedTypeDefinitionsStageID, stripUnusedTypesPipelineStage())
 		}

hack/generator/pkg/codegen/pipeline/report_resource_versions.go

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ */
+
+package pipeline
+
+import (
+	"context"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+	"sort"
+	"strings"
+
+	"github.com/pkg/errors"
+
+	"github.com/Azure/azure-service-operator/hack/generator/pkg/astmodel"
+	"github.com/Azure/azure-service-operator/hack/generator/pkg/config"
+)
+
+// ReportResourceVersionsStageID is the unique identifier of this stage
+const ReportResourceVersionsStageID = "reportResourceVersions"
+
+// ReportResourceVersions creates a pipeline stage that generates a report listing all generated resources.
+func ReportResourceVersions(configuration *config.Configuration) Stage {
+
+	return MakeStage(
+		ReportResourceVersionsStageID,
+		"Generate a report listing all the resources generated",
+		func(ctx context.Context, state *State) (*State, error) {
+			report := NewResourceVersionsReport(state.Types())
+			err := report.WriteTo(configuration.FullTypesOutputPath())
+			return state, err
+		})
+}
+
+type ResourceVersionsReport struct {
+	// A separate list of resources for each package
+	lists map[astmodel.PackageReference][]string
+}
+
+func NewResourceVersionsReport(types astmodel.Types) *ResourceVersionsReport {
+	result := &ResourceVersionsReport{
+		lists: make(map[astmodel.PackageReference][]string),
+	}
+
+	result.summarize(types)
+	return result
+}
+
+// summarize collates a list of all resources, grouped by package
+func (r *ResourceVersionsReport) summarize(types astmodel.Types) {
+	resources := astmodel.FindResourceTypes(types)
+	for _, rsrc := range resources {
+		name := rsrc.Name()
+		pkg := name.PackageReference
+		r.lists[pkg] = append(r.lists[pkg], name.Name())
+	}
+}
+
+// WriteTo creates a file containing the generated report
+func (r *ResourceVersionsReport) WriteTo(outputPath string) error {
+	var buffer strings.Builder
+	r.WriteToBuffer(&buffer)
+
+	if _, err := os.Stat(outputPath); os.IsNotExist(err) {
+		err = os.MkdirAll(outputPath, 0700)
+		if err != nil {
+			return errors.Wrapf(err, "Unable to create directory %q", outputPath)
+		}
+	}
+
+	destination := path.Join(outputPath, "resources.md")
+	return ioutil.WriteFile(destination, []byte(buffer.String()), 0600)
+}
+
+// WriteToBuffer creates the report in the provided buffer
+func (r *ResourceVersionsReport) WriteToBuffer(buffer *strings.Builder) {
+	// Sort packages into increasing order
+	// Skip storage versions
+	var packages []astmodel.PackageReference
+	for pkg := range r.lists {
+		if !astmodel.IsStoragePackageReference(pkg) {
+			packages = append(packages, pkg)
+		}
+	}
+
+	astmodel.SortPackageReferencesByPathAndVersion(packages)
+
+	lastService := ""
+	for _, pkg := range packages {
+
+		// Write a header for each service
+		svc := r.serviceName(pkg)
+		if lastService != svc {
+			buffer.WriteString(fmt.Sprintf("### %s\n\n", svc))
+			lastService = svc
+		}
+
+		// For each version, write an alphabetical list of resources
+		buffer.WriteString(fmt.Sprintf("%s\n\n", pkg.PackageName()))
+
+		resources := r.lists[pkg]
+		sort.Strings(resources)
+
+		for _, rsrc := range resources {
+			buffer.WriteString(fmt.Sprintf("- %s\n", rsrc))
+		}
+
+		buffer.WriteString("\n")
+	}
+}
+
+func (r *ResourceVersionsReport) serviceName(ref astmodel.PackageReference) string {
+	pathBits := strings.Split(ref.PackagePath(), "/")
+	index := len(pathBits) - 1
+	if index > 0 {
+		index--
+	}
+
+	return pathBits[index]
+}

hack/generator/pkg/codegen/pipeline/report_resource_versions_test.go

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ */
+
+package pipeline
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/sebdah/goldie/v2"
+
+	"github.com/Azure/azure-service-operator/hack/generator/pkg/astmodel"
+	"github.com/Azure/azure-service-operator/hack/generator/pkg/test"
+)
+
+func TestGolden_ReportResourceVersions(t *testing.T) {
+	g := goldie.New(t)
+
+	person2020 := test.CreateResource(
+		test.Pkg2020,
+		"Person",
+		test.CreateSpec(test.Pkg2020, "Person"),
+		test.CreateStatus(test.Pkg2020, "Person"))
+
+	address2020 := test.CreateResource(
+		test.Pkg2020,
+		"Address",
+		test.CreateSpec(test.Pkg2020, "Address"),
+		test.CreateStatus(test.Pkg2020, "Address"))
+
+	person2021 := test.CreateResource(
+		test.Pkg2021,
+		"Person",
+		test.CreateSpec(test.Pkg2021, "Person"),
+		test.CreateStatus(test.Pkg2021, "Person"))
+
+	address2021 := test.CreateResource(
+		test.Pkg2021,
+		"Address",
+		test.CreateSpec(test.Pkg2021, "Address"),
+		test.CreateStatus(test.Pkg2021, "Address"))
+
+	types := make(astmodel.Types)
+	types.AddAll(person2020, address2020, person2021, address2021)
+
+	report := NewResourceVersionsReport(types)
+
+	var buffer strings.Builder
+	report.WriteToBuffer(&buffer)
+
+	g.Assert(t, t.Name(), []byte(buffer.String()))
+}

hack/generator/pkg/codegen/pipeline/report_type_versions.go

@@ -24,7 +24,8 @@ import (
 // ReportOnTypesAndVersionsStageID is the unique identifier of this stage
 const ReportOnTypesAndVersionsStageID = "reportTypesAndVersions"
 
-// ReportOnTypesAndVersions creates a pipeline stage that removes any wrapper types prior to actual code generation
+// ReportOnTypesAndVersions creates a pipeline stage that generates a report for each group showing a matrix of all
+// types and versions
 func ReportOnTypesAndVersions(configuration *config.Configuration) Stage {
 
 	return MakeLegacyStage(

hack/generator/pkg/codegen/pipeline/testdata/TestGolden_ReportResourceVersions.golden

@@ -0,0 +1,12 @@
+### microsoft.person
+
+v20200101
+
+- Address
+- Person
+
+v20211231
+
+- Address
+- Person
+

hack/generator/pkg/codegen/testdata/TestNewARMCodeGeneratorFromConfigCreatesRightPipeline.golden

@@ -47,3 +47,4 @@ ensureArmTypeExistsForEveryType           azure      Check that an ARM type exis
 deleteGenerated                                      Delete generated code from .
 exportPackages                                       Export packages to "."
 exportControllerResourceRegistrations     azure      Export resource registrations to ""
+reportResourceVersions                               Generate a report listing all the resources generated

hack/generator/pkg/codegen/testdata/TestNewCrossplaneCodeGeneratorFromConfigCreatesRightPipeline.golden

@@ -33,3 +33,4 @@ markStorageVersion                                 Mark the latest version of ea
 rogueCheck                                         Check for rogue definitions using AnyTypes
 deleteGenerated                                    Delete generated code from .
 exportPackages                                     Export packages to "."
+reportResourceVersions                             Generate a report listing all the resources generated