feat: update to terraform plugin framework

Author: fabiomatavelli-f3

githubfile/provider.go

@@ -15,26 +15,20 @@
 package githubfile
 
 import (
+	"context"
 	"encoding/base64"
-	"fmt"
+	"os"
+
 	"github.com/google/go-github/v54/github"
-	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
-	tpg "github.com/integrations/terraform-provider-github/v5/github"
-	"strings"
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/provider"
+	"github.com/hashicorp/terraform-plugin-framework/provider/schema"
+	"github.com/hashicorp/terraform-plugin-framework/resource"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"golang.org/x/oauth2"
 )
 
-const (
-	resourceFileName = "githubfile_file"
-)
-
-const (
-	commitMessagePrefixKey = "commit_message_prefix"
-	githubEmailKey         = "github_email"
-	githubTokenKey         = "github_token"
-	githubUsernameKey      = "github_username"
-	gpgPassphraseKey       = "gpg_passphrase"
-	gpgSecretKeyKey        = "gpg_secret_key"
-)
+var _ provider.Provider = &githubfileProvider{}
 
 type providerConfiguration struct {
 	commitMessagePrefix string
@@ -45,83 +39,131 @@ type providerConfiguration struct {
 	gpgSecretKey        string
 }
 
-func Provider() *schema.Provider {
-	return &schema.Provider{
-		ConfigureFunc: func(d *schema.ResourceData) (interface{}, error) {
-			c := tpg.Config{
-				Token:   d.Get(githubTokenKey).(string),
-				BaseURL: "https://api.github.com/",
-			}
-
-			gc, err := c.NewRESTClient(c.AuthenticatedHTTPClient())
-			if err != nil {
-				return nil, fmt.Errorf("failed to create GitHub Client: %v", err)
-			}
-
-			// Support reading a base64-encoded GPG secret key.
-			sk := d.Get(gpgSecretKeyKey).(string)
-			if v, err := base64.StdEncoding.DecodeString(sk); err == nil {
-				sk = string(v)
-			}
-			return &providerConfiguration{
-				commitMessagePrefix: d.Get(commitMessagePrefixKey).(string),
-				githubClient:        gc,
-				githubEmail:         d.Get(githubEmailKey).(string),
-				githubUsername:      d.Get(githubUsernameKey).(string),
-				gpgSecretKey:        sk,
-				gpgPassphrase:       d.Get(gpgPassphraseKey).(string),
-			}, nil
-		},
-		ResourcesMap: map[string]*schema.Resource{
-			resourceFileName: resourceFile(),
-		},
-		Schema: map[string]*schema.Schema{
-			commitMessagePrefixKey: {
-				Type:        schema.TypeString,
-				DefaultFunc: defaultFuncForKey(commitMessagePrefixKey),
+type githubfileProvider struct{}
+
+type githubfileProviderModel struct {
+	CommitMessagePrefix types.String `tfsdk:"commit_message_prefix"`
+	GithubEmail         types.String `tfsdk:"github_email"`
+	GithubToken         types.String `tfsdk:"github_token"`
+	GithubUsername      types.String `tfsdk:"github_username"`
+	GpgPassphrase       types.String `tfsdk:"gpg_passphrase"`
+	GpgSecretKey        types.String `tfsdk:"gpg_secret_key"`
+}
+
+// New returns a new instance of the githubfile provider.
+func New() provider.Provider {
+	return &githubfileProvider{}
+}
+
+func (p *githubfileProvider) Metadata(_ context.Context, _ provider.MetadataRequest, resp *provider.MetadataResponse) {
+	resp.TypeName = "githubfile"
+}
+
+func (p *githubfileProvider) Schema(_ context.Context, _ provider.SchemaRequest, resp *provider.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"commit_message_prefix": schema.StringAttribute{
 				Optional:    true,
-				Sensitive:   false,
-				Description: "An optional prefix to be added to all commits created as a result of manipulating files.",
+				Description: "An optional prefix to be added to all commits created as a result of manipulating files. Can also be set via the COMMIT_MESSAGE_PREFIX environment variable.",
 			},
-			githubEmailKey: {
-				Type:        schema.TypeString,
-				DefaultFunc: defaultFuncForKey(githubEmailKey),
-				Required:    true,
+			"github_email": schema.StringAttribute{
+				Optional:    true,
 				Sensitive:   true,
-				Description: "The email address to use for commit messages. If a GPG key is provided, this must match the one which the key corresponds to.",
+				Description: "The email address to use for commit messages. If a GPG key is provided, this must match the one which the key corresponds to. Can also be set via the GITHUB_EMAIL environment variable.",
 			},
-			githubTokenKey: {
-				Type:        schema.TypeString,
-				DefaultFunc: defaultFuncForKey(githubTokenKey),
-				Required:    true,
+			"github_token": schema.StringAttribute{
+				Optional:    true,
 				Sensitive:   true,
-				Description: "A GitHub authorisation token with permissions to manage CRUD files in the target repositories.",
+				Description: "A GitHub authorisation token with permissions to manage CRUD files in the target repositories. Can also be set via the GITHUB_TOKEN environment variable.",
 			},
-			githubUsernameKey: {
-				Type:        schema.TypeString,
-				DefaultFunc: defaultFuncForKey(githubUsernameKey),
-				Required:    true,
+			"github_username": schema.StringAttribute{
+				Optional:    true,
 				Sensitive:   true,
-				Description: "The username to use for commit messages.",
+				Description: "The username to use for commit messages. Can also be set via the GITHUB_USERNAME environment variable.",
 			},
-			gpgPassphraseKey: {
-				Type:        schema.TypeString,
-				DefaultFunc: defaultFuncForKey(gpgPassphraseKey),
+			"gpg_passphrase": schema.StringAttribute{
 				Optional:    true,
 				Sensitive:   true,
-				Description: fmt.Sprintf("The passphrase associated with the provided %q.", gpgSecretKeyKey),
+				Description: "The passphrase associated with the provided \"gpg_secret_key\". Can also be set via the GPG_PASSPHRASE environment variable.",
 			},
-			gpgSecretKeyKey: {
-				Type:        schema.TypeString,
-				DefaultFunc: defaultFuncForKey(gpgSecretKeyKey),
+			"gpg_secret_key": schema.StringAttribute{
 				Optional:    true,
 				Sensitive:   true,
-				Description: "The GPG secret key to be use for commit signing.",
+				Description: "The GPG secret key to be use for commit signing. Can also be set via the GPG_SECRET_KEY environment variable.",
 			},
 		},
 	}
 }
 
-func defaultFuncForKey(v string) schema.SchemaDefaultFunc {
-	return schema.EnvDefaultFunc(strings.ToUpper(v), "")
+func (p *githubfileProvider) Configure(ctx context.Context, req provider.ConfigureRequest, resp *provider.ConfigureResponse) {
+	var config githubfileProviderModel
+	resp.Diagnostics.Append(req.Config.Get(ctx, &config)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	token := stringValueOrEnv(config.GithubToken, "GITHUB_TOKEN")
+	if token == "" {
+		resp.Diagnostics.AddError(
+			"Missing GitHub Token",
+			"github_token must be configured or the GITHUB_TOKEN environment variable must be set.",
+		)
+		return
+	}
+
+	email := stringValueOrEnv(config.GithubEmail, "GITHUB_EMAIL")
+	if email == "" {
+		resp.Diagnostics.AddError(
+			"Missing GitHub Email",
+			"github_email must be configured or the GITHUB_EMAIL environment variable must be set.",
+		)
+		return
+	}
+
+	username := stringValueOrEnv(config.GithubUsername, "GITHUB_USERNAME")
+	if username == "" {
+		resp.Diagnostics.AddError(
+			"Missing GitHub Username",
+			"github_username must be configured or the GITHUB_USERNAME environment variable must be set.",
+		)
+		return
+	}
+
+	ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token})
+	tc := oauth2.NewClient(ctx, ts)
+	gc := github.NewClient(tc)
+
+	sk := stringValueOrEnv(config.GpgSecretKey, "GPG_SECRET_KEY")
+	if v, err := base64.StdEncoding.DecodeString(sk); err == nil {
+		sk = string(v)
+	}
+
+	providerConfig := &providerConfiguration{
+		commitMessagePrefix: stringValueOrEnv(config.CommitMessagePrefix, "COMMIT_MESSAGE_PREFIX"),
+		githubClient:        gc,
+		githubEmail:         email,
+		githubUsername:      username,
+		gpgSecretKey:        sk,
+		gpgPassphrase:       stringValueOrEnv(config.GpgPassphrase, "GPG_PASSPHRASE"),
+	}
+
+	resp.DataSourceData = providerConfig
+	resp.ResourceData = providerConfig
+}
+
+func (p *githubfileProvider) Resources(_ context.Context) []func() resource.Resource {
+	return []func() resource.Resource{
+		NewFileResource,
+	}
+}
+
+func (p *githubfileProvider) DataSources(_ context.Context) []func() datasource.DataSource {
+	return nil
+}
+
+func stringValueOrEnv(v types.String, envKey string) string {
+	if !v.IsNull() && !v.IsUnknown() {
+		return v.ValueString()
+	}
+	return os.Getenv(envKey)
 }

githubfile/provider_test.go

@@ -18,20 +18,12 @@ import (
 	"os"
 	"testing"
 
-	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
-	"github.com/hashicorp/terraform-plugin-sdk/terraform"
+	"github.com/hashicorp/terraform-plugin-framework/providerserver"
+	"github.com/hashicorp/terraform-plugin-go/tfprotov6"
 )
 
-var (
-	testAccProviders map[string]terraform.ResourceProvider
-	testAccProvider  *schema.Provider
-)
-
-func init() {
-	testAccProvider = Provider()
-	testAccProviders = map[string]terraform.ResourceProvider{
-		"githubfile": testAccProvider,
-	}
+var testAccProtoV6ProviderFactories = map[string]func() (tfprotov6.ProviderServer, error){
+	"githubfile": providerserver.NewProtocol6WithError(New()),
 }
 
 func testAccPreCheck(t *testing.T) {
@@ -48,7 +40,8 @@ func testAccPreCheck(t *testing.T) {
 }
 
 func TestProvider(t *testing.T) {
-	if err := Provider().InternalValidate(); err != nil {
-		t.Fatalf("failed to test provider: %v", err)
+	p := New()
+	if p == nil {
+		t.Fatal("provider should not be nil")
 	}
 }