aztfexport res supports multiple resources (#552)

command_before_func.go

@@ -11,8 +11,8 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
-func commandBeforeFunc(fset *FlagSet) func(ctx *cli.Context) error {
-	return func(_ *cli.Context) error {
+func commandBeforeFunc(fset *FlagSet, mode Mode) func(ctx *cli.Context) error {
+	return func(ctx *cli.Context) error {
 		// Common flags check
 		if fset.flagAppend {
 			if fset.flagOverwrite {
@@ -103,6 +103,19 @@ func commandBeforeFunc(fset *FlagSet) func(ctx *cli.Context) error {
 			return err
 		}
 
+		// Mode specific flags check
+		switch mode {
+		case ModeResource:
+			if ctx.Args().Len() > 1 || (ctx.Args().Len() == 1 && strings.HasPrefix(ctx.Args().First(), "@")) {
+				if fset.flagResType != "" {
+					return fmt.Errorf("`--type` can't be specified for multi-resource mode")
+				}
+				if fset.flagResName != "" {
+					return fmt.Errorf("`--name` can't be specified for multi-resource mode")
+				}
+			}
+		}
+
 		// Initialize output directory
 		if _, err := os.Stat(fset.flagOutputDir); os.IsNotExist(err) {
 			if err := os.MkdirAll(fset.flagOutputDir, 0750); err != nil {

command_before_func_test.go

@@ -226,7 +226,7 @@ func TestCommondBeforeFunc(t *testing.T) {
 				tt.fset.flagSubscriptionId = "test"
 			}
 
-			err := commandBeforeFunc(&tt.fset)(nil)
+			err := commandBeforeFunc(&tt.fset, "")(nil)
 			if tt.err == "" {
 				require.NoError(t, err)
 				if tt.postCheck != nil {

flag.go

@@ -74,8 +74,9 @@ type FlagSet struct {
 	// Subcommand specific flags
 	//
 	// res:
-	// flagResName
-	// flagResType
+	// flagResName (for single resource)
+	// flagResType (for single resource)
+	// flagPattern (for multi resources)
 	//
 	// rg:
 	// flagPattern
@@ -94,18 +95,20 @@ type FlagSet struct {
 	flagIncludeResourceGroup  bool
 }
 
+type Mode string
+
 const (
-	ModeResource      = "resource"
-	ModeResourceGroup = "resource-group"
-	ModeQuery         = "query"
-	ModeMappingFile   = "mapping-file"
+	ModeResource      Mode = "resource"
+	ModeResourceGroup Mode = "resource-group"
+	ModeQuery         Mode = "query"
+	ModeMappingFile   Mode = "mapping-file"
 )
 
 // DescribeCLI construct a description of the CLI based on the flag set and the specified mode.
 // The main reason is to record the usage of some "interesting" options in the telemetry.
 // Note that only insensitive values are recorded (i.e. subscription id, resource id, etc are not recorded)
-func (flag FlagSet) DescribeCLI(mode string) string {
-	args := []string{mode}
+func (flag FlagSet) DescribeCLI(mode Mode) string {
+	args := []string{string(mode)}
 
 	// The following flags are skipped eiter not interesting, or might contain sensitive info:
 	// - flagOutputDir
@@ -225,6 +228,9 @@ func (flag FlagSet) DescribeCLI(mode string) string {
 		if flag.flagResType != "" {
 			args = append(args, "--type="+flag.flagResType)
 		}
+		if flag.flagPattern != "" {
+			args = append(args, "--name-pattern="+flag.flagPattern)
+		}
 	case ModeResourceGroup:
 		if flag.flagPattern != "" {
 			args = append(args, "--name-pattern="+flag.flagPattern)

internal/meta/meta_res.go

@@ -13,9 +13,11 @@ import (
 
 type MetaResource struct {
 	baseMeta
-	AzureId      armid.ResourceId
-	ResourceName string
-	ResourceType string
+	AzureIds           []armid.ResourceId
+	ResourceName       string
+	ResourceType       string
+	resourceNamePrefix string
+	resourceNameSuffix string
 }
 
 func NewMetaResource(cfg config.Config) (*MetaResource, error) {
@@ -25,79 +27,119 @@ func NewMetaResource(cfg config.Config) (*MetaResource, error) {
 		return nil, err
 	}
 
-	id, err := armid.ParseResourceId(cfg.ResourceId)
-	if err != nil {
-		return nil, err
+	var ids []armid.ResourceId
+
+	for _, id := range cfg.ResourceIds {
+		id, err := armid.ParseResourceId(id)
+		if err != nil {
+			return nil, err
+		}
+		ids = append(ids, id)
 	}
+
 	meta := &MetaResource{
 		baseMeta:     *baseMeta,
-		AzureId:      id,
+		AzureIds:     ids,
 		ResourceName: cfg.TFResourceName,
 		ResourceType: cfg.TFResourceType,
 	}
+
+	meta.resourceNamePrefix, meta.resourceNameSuffix = resourceNamePattern(cfg.ResourceNamePattern)
+
 	return meta, nil
 }
 
 func (meta MetaResource) ScopeName() string {
-	return meta.AzureId.String()
+	if len(meta.AzureIds) == 1 {
+		return meta.AzureIds[0].String()
+	} else {
+		return meta.AzureIds[0].String() + " and more..."
+	}
 }
 
-func (meta *MetaResource) ListResource(_ context.Context) (ImportList, error) {
-	resourceSet := &resourceset.AzureResourceSet{
-		Resources: []resourceset.AzureResource{
-			{
-				Id: meta.AzureId,
-			},
-		},
+func (meta *MetaResource) ListResource(ctx context.Context) (ImportList, error) {
+	var resources []resourceset.AzureResource
+	for _, id := range meta.AzureIds {
+		resources = append(resources, resourceset.AzureResource{Id: id})
+	}
+
+	rset := &resourceset.AzureResourceSet{
+		Resources: resources,
 	}
+
 	meta.Logger().Debug("Azure Resource set map to TF resource set")
 
 	var rl []resourceset.TFResource
 	if meta.useAzAPI() {
-		rl = resourceSet.ToTFAzAPIResources()
+		rl = rset.ToTFAzAPIResources()
 	} else {
-		rl = resourceSet.ToTFAzureRMResources(meta.Logger(), meta.parallelism, meta.azureSDKCred, meta.azureSDKClientOpt)
+		rl = rset.ToTFAzureRMResources(meta.Logger(), meta.parallelism, meta.azureSDKCred, meta.azureSDKClientOpt)
 	}
 
-	// This is to record known resource types. In case there is a known resource type and there comes another same typed resource,
-	// then we need to modify the resource name. Otherwise, there will be a resource address conflict.
-	// See https://github.com/Azure/aztfexport/issues/275 for an example.
-	rtCnt := map[string]int{}
-
 	var l ImportList
-	for _, res := range rl {
+
+	// The ResourceName and ResourceType are only honored for single resource
+	if len(rl) == 1 {
+		res := rl[0]
+
+		// Honor the ResourceName
 		name := meta.ResourceName
-		rtCnt[res.TFType]++
-		if rtCnt[res.TFType] > 1 {
-			name += fmt.Sprintf("-%d", rtCnt[res.TFType]-1)
+		if name == "" {
+			name = fmt.Sprintf("%s%d%s", meta.resourceNamePrefix, 0, meta.resourceNameSuffix)
 		}
+
+		// Honor the ResourceType
+		tftype := res.TFType
+		tfid := res.TFId
+		if meta.ResourceType != "" && meta.ResourceType != res.TFType {
+			// res.TFType can be either empty (if aztft failed to query), or not.
+			// If the user has specified a different type, then use it.
+			tftype = meta.ResourceType
+
+			// Also use this resource type to requery its resource id.
+			var err error
+			tfid, err = aztft.QueryId(res.AzureId.String(), meta.ResourceType,
+				&aztft.APIOption{
+					Cred:         meta.azureSDKCred,
+					ClientOption: meta.azureSDKClientOpt,
+				})
+			if err != nil {
+				return nil, err
+			}
+		}
+
 		tfAddr := tfaddr.TFAddr{
-			Type: res.TFType, // this might be empty if have multiple matches in aztft
+			Type: tftype,
 			Name: name,
 		}
+
 		item := ImportItem{
 			AzureResourceID: res.AzureId,
-			TFResourceId:    res.TFId, // this might be empty if have multiple matches in aztft
+			TFResourceId:    tfid,
 			TFAddr:          tfAddr,
 			TFAddrCache:     tfAddr,
 		}
+		l = append(l, item)
+		return l, nil
+	}
 
-		// Some special Azure resource is missing the essential property that is used by aztft to detect their TF resource type.
-		// In this case, users can use the `--type` option to manually specify the TF resource type.
-		if meta.ResourceType != "" && !meta.useAzAPI() {
-			if meta.AzureId.Equal(res.AzureId) {
-				tfid, err := aztft.QueryId(meta.AzureId.String(), meta.ResourceType,
-					&aztft.APIOption{
-						Cred:         meta.azureSDKCred,
-						ClientOption: meta.azureSDKClientOpt,
-					})
-				if err != nil {
-					return nil, err
-				}
-				item.TFResourceId = tfid
-				item.TFAddr.Type = meta.ResourceType
-				item.TFAddrCache.Type = meta.ResourceType
-			}
+	// Multi-resource mode only honors the resourceName[Pre|Suf]fix
+	for i, res := range rl {
+		tfAddr := tfaddr.TFAddr{
+			Type: "",
+			Name: fmt.Sprintf("%s%d%s", meta.resourceNamePrefix, i, meta.resourceNameSuffix),
+		}
+		item := ImportItem{
+			AzureResourceID: res.AzureId,
+			TFResourceId:    res.TFId,
+			TFAddr:          tfAddr,
+			TFAddrCache:     tfAddr,
+		}
+		if res.TFType != "" {
+			item.TFAddr.Type = res.TFType
+			item.TFAddrCache.Type = res.TFType
+			item.Recommendations = []string{res.TFType}
+			item.IsRecommended = true
 		}
 
 		l = append(l, item)

internal/test/cases/case_vnet.go

@@ -0,0 +1,85 @@
+package cases
+
+import (
+	"fmt"
+
+	"github.com/Azure/aztfexport/internal/resmap"
+	"github.com/Azure/aztfexport/internal/test"
+)
+
+var _ Case = CaseVnet{}
+
+type CaseVnet struct{}
+
+func (CaseVnet) Tpl(d test.Data) string {
+	return fmt.Sprintf(`
+provider "azurerm" {
+  features {
+    resource_group {
+      prevent_deletion_if_contains_resources = false
+    }
+  }
+}
+resource "azurerm_resource_group" "test" {
+  name     = "%[1]s"
+  location = "WestEurope"
+}
+resource "azurerm_virtual_network" "test" {
+  name                = "aztfexport-test-%[2]s"
+  address_space       = ["10.0.0.0/16"]
+  location            = azurerm_resource_group.test.location
+  resource_group_name = azurerm_resource_group.test.name
+}
+resource "azurerm_subnet" "test" {
+  name                 = "internal"
+  resource_group_name  = azurerm_resource_group.test.name
+  virtual_network_name = azurerm_virtual_network.test.name
+  address_prefixes     = ["10.0.2.0/24"]
+}
+`, d.RandomRgName(), d.RandomStringOfLength(8))
+}
+
+func (CaseVnet) Total() int {
+	return 3
+}
+
+func (CaseVnet) ResourceMapping(d test.Data) (resmap.ResourceMapping, error) {
+	return test.ResourceMapping(fmt.Sprintf(`{
+{{ "/subscriptions/%[1]s/resourcegroups/%[2]s" | Quote }}: {
+  "resource_type": "azurerm_resource_group",
+  "resource_name": "test",
+  "resource_id": "/subscriptions/%[1]s/resourceGroups/%[2]s"
+},
+
+{{ "/subscriptions/%[1]s/resourcegroups/%[2]s/providers/microsoft.network/virtualnetworks/aztfexport-test-%[3]s" | Quote }}: {
+  "resource_type": "azurerm_virtual_network",
+  "resource_name": "test",
+  "resource_id": "/subscriptions/%[1]s/resourceGroups/%[2]s/providers/Microsoft.Network/virtualNetworks/aztfexport-test-%[3]s"
+},
+
+{{ "/subscriptions/%[1]s/resourcegroups/%[2]s/providers/microsoft.network/virtualnetworks/aztfexport-test-%[3]s/subnets/internal" | Quote }}: {
+  "resource_type": "azurerm_subnet",
+  "resource_name": "test",
+  "resource_id": "/subscriptions/%[1]s/resourceGroups/%[2]s/providers/Microsoft.Network/virtualNetworks/aztfexport-test-%[3]s/subnets/internal"
+}
+
+}
+`, d.SubscriptionId, d.RandomRgName(), d.RandomStringOfLength(8)))
+}
+
+func (CaseVnet) SingleResourceContext(d test.Data) ([]SingleResourceContext, error) {
+	return []SingleResourceContext{
+		{
+			AzureId:             fmt.Sprintf("/subscriptions/%[1]s/resourceGroups/%[2]s", d.SubscriptionId, d.RandomRgName()),
+			ExpectResourceCount: 1,
+		},
+		{
+			AzureId:             fmt.Sprintf("/subscriptions/%[1]s/resourceGroups/%[2]s/providers/Microsoft.Network/virtualNetworks/aztfexport-test-%[3]s", d.SubscriptionId, d.RandomRgName(), d.RandomStringOfLength(8)),
+			ExpectResourceCount: 1,
+		},
+		{
+			AzureId:             fmt.Sprintf("/subscriptions/%[1]s/resourceGroups/%[2]s/providers/Microsoft.Network/virtualNetworks/aztfexport-test-%[3]s/subnets/internal", d.SubscriptionId, d.RandomRgName(), d.RandomStringOfLength(8)),
+			ExpectResourceCount: 1,
+		},
+	}, nil
+}

internal/test/resmap/e2e_cases_test.go

@@ -96,6 +96,13 @@ func runCase(t *testing.T, d test.Data, c cases.Case) {
 	test.Verify(t, ctx, aztfexportDir, tfexecPath, len(resMapping))
 }
 
+func TestVnet(t *testing.T) {
+	t.Parallel()
+	test.Precheck(t)
+	c, d := cases.CaseVnet{}, test.NewData()
+	runCase(t, d, c)
+}
+
 func TestComputeVMDisk(t *testing.T) {
 	t.Parallel()
 	test.Precheck(t)