Added stpifpol resource, data source, examples, docs and name alias attr schema file

Author: shrsr

aci/base_attr_schema.go

@@ -9,7 +9,6 @@ func GetBaseAttrSchema() map[string]*schema.Schema {
 			Optional: true,
 			Computed: true,
 		},
-
 		"annotation": &schema.Schema{
 			Type:     schema.TypeString,
 			Optional: true,
@@ -23,6 +22,5 @@ func AppendBaseAttrSchema(attrs map[string]*schema.Schema) map[string]*schema.Sc
 	for key, value := range GetBaseAttrSchema() {
 		attrs[key] = value
 	}
-
 	return attrs
 }

aci/data_source_aci_stpifpol.go

@@ -0,0 +1,43 @@
+package aci
+
+import (
+	"fmt"
+
+	"github.com/ciscoecosystem/aci-go-client/client"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+)
+
+func dataSourceAciSpanningTreeInterfacePolicy() *schema.Resource {
+	return &schema.Resource{
+		Read:          dataSourceAciSpanningTreeInterfacePolicyRead,
+		SchemaVersion: 1,
+		Schema: AppendBaseAttrSchema(AppendNameAliasAttrSchema(map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"ctrl": &schema.Schema{
+				Type:     schema.TypeList,
+				Optional: true,
+				Computed: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+		})),
+	}
+}
+
+func dataSourceAciSpanningTreeInterfacePolicyRead(d *schema.ResourceData, m interface{}) error {
+	aciClient := m.(*client.Client)
+	name := d.Get("name").(string)
+	rn := fmt.Sprintf("ifPol-%s", name)
+	dn := fmt.Sprintf("uni/%s", rn)
+	stpIfPol, err := getRemoteSpanningTreeInterfacePolicy(aciClient, dn)
+	if err != nil {
+		return err
+	}
+	setSpanningTreeInterfacePolicyAttributes(stpIfPol, d)
+	return nil
+}

aci/name_alias_attr_schema.go

@@ -0,0 +1,21 @@
+package aci
+
+import "github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+
+func GetNameAliasAttrSchema() map[string]*schema.Schema {
+	return map[string]*schema.Schema{
+		"name_alias": &schema.Schema{
+			Type:     schema.TypeString,
+			Optional: true,
+			Computed: true,
+		},
+	}
+}
+
+// AppendNameAliasAttrSchema adds the NameAliasAttr to required schema
+func AppendNameAliasAttrSchema(attrs map[string]*schema.Schema) map[string]*schema.Schema {
+	for key, value := range GetNameAliasAttrSchema() {
+		attrs[key] = value
+	}
+	return attrs
+}

aci/provider.go

@@ -153,6 +153,7 @@ func Provider() terraform.ResourceProvider {
 			"aci_spine_interface_profile":                  resourceAciSpineInterfaceProfile(),
 			"aci_spine_port_policy_group":                  resourceAciSpineAccessPortPolicyGroup(),
 			"aci_fabric_if_pol":                            resourceAciLinkLevelPolicy(),
+			"aci_stp_if_pol":                               resourceAciSpanningTreeInterfacePolicy(),
 			"aci_aaa_domain":                               resourceAciSecurityDomain(),
 			"aci_l4_l7_service_graph_template":             resourceAciL4L7ServiceGraphTemplate(),
 			"aci_logical_device_context":                   resourceAciLogicalDeviceContext(),
@@ -289,6 +290,7 @@ func Provider() terraform.ResourceProvider {
 			"aci_spine_port_policy_group":                  dataSourceAciSpineAccessPortPolicyGroup(),
 			"aci_fabric_path_ep":                           dataSourceAciFabricPathEndpoint(),
 			"aci_fabric_if_pol":                            dataSourceAciLinkLevelPolicy(),
+			"aci_stp_if_pol":                               dataSourceAciSpanningTreeInterfacePolicy(),
 			"aci_aaa_domain":                               dataSourceAciSecurityDomain(),
 			"aci_client_end_point":                         dataSourceAciClientEndPoint(),
 			"aci_l4_l7_service_graph_template":             dataSourceAciL4L7ServiceGraphTemplate(),

aci/resource_aci_stpifpol.go

@@ -0,0 +1,181 @@
+package aci
+
+import (
+	"fmt"
+	"log"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/ciscoecosystem/aci-go-client/client"
+	"github.com/ciscoecosystem/aci-go-client/models"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
+)
+
+func resourceAciSpanningTreeInterfacePolicy() *schema.Resource {
+
+	return &schema.Resource{
+		Create: resourceAciSpanningTreeInterfacePolicyCreate,
+		Update: resourceAciSpanningTreeInterfacePolicyUpdate,
+		Read:   resourceAciSpanningTreeInterfacePolicyRead,
+		Delete: resourceAciSpanningTreeInterfacePolicyDelete,
+
+		Importer: &schema.ResourceImporter{
+			State: resourceAciSpanningTreeInterfacePolicyImport,
+		},
+
+		SchemaVersion: 1,
+		Schema: AppendBaseAttrSchema(AppendNameAliasAttrSchema(map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"ctrl": &schema.Schema{
+				Type:     schema.TypeList,
+				Optional: true,
+				Computed: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+					ValidateFunc: validation.StringInSlice([]string{
+						"bpdu-filter",
+						"bpdu-guard",
+					}, false),
+				},
+			},
+		})),
+	}
+}
+
+func getRemoteSpanningTreeInterfacePolicy(client *client.Client, dn string) (*models.SpanningTreeInterfacePolicy, error) {
+	stpIfPolCont, err := client.Get(dn)
+	if err != nil {
+		return nil, err
+	}
+	stpIfPol := models.SpanningTreeInterfacePolicyFromContainer(stpIfPolCont)
+	if stpIfPol.DistinguishedName == "" {
+		return nil, fmt.Errorf("SpanningTreeInterfacePolicy %s not found", stpIfPol.DistinguishedName)
+	}
+	return stpIfPol, nil
+}
+
+func setSpanningTreeInterfacePolicyAttributes(stpIfPol *models.SpanningTreeInterfacePolicy, d *schema.ResourceData) *schema.ResourceData {
+	d.SetId(stpIfPol.DistinguishedName)
+	d.Set("description", stpIfPol.Description)
+	stpIfPolMap, _ := stpIfPol.ToMap()
+	d.Set("name", stpIfPolMap["name"])
+	d.Set("annotation", stpIfPolMap["annotation"])
+	ctrlGet := make([]string, 0, 1)
+	for _, val := range strings.Split(stpIfPolMap["ctrl"], ",") {
+		ctrlGet = append(ctrlGet, strings.Trim(val, " "))
+	}
+	sort.Strings(ctrlGet)
+	if ctrlIntr, ok := d.GetOk("ctrl"); ok {
+		ctrlAct := make([]string, 0, 1)
+		for _, val := range ctrlIntr.([]interface{}) {
+			ctrlAct = append(ctrlAct, val.(string))
+		}
+		sort.Strings(ctrlAct)
+		if reflect.DeepEqual(ctrlAct, ctrlGet) {
+			d.Set("ctrl", d.Get("ctrl").([]interface{}))
+		} else {
+			d.Set("ctrl", ctrlGet)
+		}
+	} else {
+		d.Set("ctrl", ctrlGet)
+	}
+	d.Set("name_alias", stpIfPolMap["nameAlias"])
+	return d
+}
+
+func resourceAciSpanningTreeInterfacePolicyImport(d *schema.ResourceData, m interface{}) ([]*schema.ResourceData, error) {
+	log.Printf("[DEBUG] %s: Beginning Import", d.Id())
+	aciClient := m.(*client.Client)
+	dn := d.Id()
+	stpIfPol, err := getRemoteSpanningTreeInterfacePolicy(aciClient, dn)
+	if err != nil {
+		return nil, err
+	}
+	schemaFilled := setSpanningTreeInterfacePolicyAttributes(stpIfPol, d)
+	log.Printf("[DEBUG] %s: Import finished successfully", d.Id())
+	return []*schema.ResourceData{schemaFilled}, nil
+}
+
+func resourceAciSpanningTreeInterfacePolicyCreate(d *schema.ResourceData, m interface{}) error {
+	return resourceAciSpanningTreeInterfacePolicyCreateOrUpdate(d, m, false)
+}
+
+func resourceAciSpanningTreeInterfacePolicyUpdate(d *schema.ResourceData, m interface{}) error {
+	return resourceAciSpanningTreeInterfacePolicyCreateOrUpdate(d, m, true)
+}
+
+func resourceAciSpanningTreeInterfacePolicyRead(d *schema.ResourceData, m interface{}) error {
+	log.Printf("[DEBUG] %s: Beginning Read", d.Id())
+	aciClient := m.(*client.Client)
+	dn := d.Id()
+	stpIfPol, err := getRemoteSpanningTreeInterfacePolicy(aciClient, dn)
+	if err != nil {
+		d.SetId("")
+		return nil
+	}
+	setSpanningTreeInterfacePolicyAttributes(stpIfPol, d)
+	log.Printf("[DEBUG] %s: Read finished successfully", d.Id())
+	return nil
+}
+
+func resourceAciSpanningTreeInterfacePolicyDelete(d *schema.ResourceData, m interface{}) error {
+	log.Printf("[DEBUG] %s: Beginning Destroy", d.Id())
+	aciClient := m.(*client.Client)
+	dn := d.Id()
+	err := aciClient.DeleteByDn(dn, "stpIfPol")
+	if err != nil {
+		return err
+	}
+	log.Printf("[DEBUG] %s: Destroy finished successfully", d.Id())
+	d.SetId("")
+	return err
+}
+func resourceAciSpanningTreeInterfacePolicyCreateOrUpdate(d *schema.ResourceData, m interface{}, update bool) error {
+	action := "Creation"
+	if update == true {
+		action = "Update"
+	}
+	log.Printf("[DEBUG] SpanningTreeInterfacePolicy: Beginning %s", action)
+	aciClient := m.(*client.Client)
+	desc := d.Get("description").(string)
+	name := d.Get("name").(string)
+	stpIfPolAttr := models.SpanningTreeInterfacePolicyAttributes{}
+	if Annotation, ok := d.GetOk("annotation"); ok {
+		stpIfPolAttr.Annotation = Annotation.(string)
+	} else {
+		stpIfPolAttr.Annotation = "{}"
+	}
+	if Ctrl, ok := d.GetOk("ctrl"); ok {
+		ctrlList := make([]string, 0, 1)
+		for _, val := range Ctrl.([]interface{}) {
+			ctrlList = append(ctrlList, val.(string))
+		}
+		Ctrl := strings.Join(ctrlList, ",")
+		stpIfPolAttr.Ctrl = Ctrl
+	}
+	nameAlias := ""
+	if NameAlias, ok := d.GetOk("name_alias"); ok {
+		nameAlias = NameAlias.(string)
+	}
+
+	stpIfPol := models.NewSpanningTreeInterfacePolicy(fmt.Sprintf("infra/ifPol-%s", name), "uni", desc, nameAlias, stpIfPolAttr)
+	if update == true {
+		stpIfPol.Status = "modified"
+	}
+	err := aciClient.Save(stpIfPol)
+	if err != nil {
+		return err
+	}
+	d.Partial(true)
+	d.SetPartial("name")
+	d.Partial(false)
+	d.SetId(stpIfPol.DistinguishedName)
+	log.Printf("[DEBUG] %s: %s finished successfully", d.Id(), action)
+	return resourceAciSpanningTreeInterfacePolicyRead(d, m)
+}