Introduction

Terraform plugin development framework adapter

Inspired by https://github.com/volcengine/terraform-provider-volcengine

Design

Adapter provides support for the interconversion between HCL and Unstructured Map

• RequestAdapter
  • Transformer: trans HCL to Row Unstructured Map
  • Converter: filter and process the Unstructured Map, so that the final result completely matches the API request data
• ResponseAdapter
  • Converter: filter and process the business output
  • Transformer: save the Converter Results to HCL

Example

Import

tfext "github.com/zpp12354321/terraform_extension"

Resource Interface

type Resource interface {
	// Adapt For Datasource
	Datasource(*schema.ResourceData) []Action

	// Adapt For Resource
	ReadResource(*schema.ResourceData) []Action
	CreateResource(*schema.ResourceData) []Action
	ModifyResource(*schema.ResourceData) []Action
	RemoveResource(*schema.ResourceData) []Action
}

Dispatcher

// resource
dispatcher := tfext.NewDispatcher(&VpcResource{}).WithResourceSchema(resourceSchema)
resource := &schema.Resource{
    Create: dispatcher.Create,
    Read:   dispatcher.Read,
    Update: dispatcher.Update,
    Delete: dispatcher.Delete,
    Importer: &schema.ResourceImporter{
        State: schema.ImportStatePassthrough,
    },
    Schema: resourceSchema,
}

// datasource
dispatcher := tfext.NewDispatcher(&VpcResource{}).WithDatasourceSchema(dataSchema)
datasource = &schema.Resource{
    Read:   dispatcher.Data,
    Schema: dataSchema,
}

Service

func (s *VpcResource) CreateResource(d *schema.ResourceData) []tfext.Action {
	res := []tfext.Action{
		{
			Name: "CreateVpc",
			RequestAdapter: &tfext.Adapter{
				Transformer: tfext.Transformer{StrCaseStyle: tfext.Camel},
			},
			Handlers: []tfext.HandlerFunc{
				func(info *tfext.Info) tfext.Then {
					params := info.GetRequestParams().(map[string]interface{})
					fmt.Println("get request params", params)
					// call create vpc api
					
					// mock result here
					resp := map[string]interface{}{
						"Result": map[string]interface{}{
							"VpcId": "1234567",
						},
					}
					info.SetResponseParams(resp)  // update result
					return tfext.ThenContinue
				},
				func(info *tfext.Info) tfext.Then {
					id, err := tfext.Select(".Result.VpcId", info.GetResponseParams())
					if err != nil {
						info.AppendError(err)
						return tfext.ThenHalt
					}
					d.SetId(id.(string))  // update id
					return tfext.ThenContinue
				},
				tfext.RefreshAction([]string{"Pending"}, []string{"Available"}, d.Timeout(schema.TimeoutCreate), 5*time.Second,
					func(info *tfext.Info) (result interface{}, state string, err error) {
						return s.Refresh(info.Meta, d.Id())
					}),
			},
		},
	}
	return res
}