data_source hosted runner: fix review

Author: nico34638

github/data_source_github_enterprise_actions_hosted_runner.go

@@ -2,33 +2,33 @@ package github
 
 import (
 	"context"
-	"fmt"
+	"strconv"
 	"time"
 
-	"github.com/google/go-github/v82/github"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )
 
 func dataSourceGithubEnterpriseActionsHostedRunner() *schema.Resource {
 	return &schema.Resource{
-		Read: dataSourceGithubEnterpriseActionsHostedRunnerRead,
+		ReadContext: dataSourceGithubEnterpriseActionsHostedRunnerRead,
 
 		Schema: map[string]*schema.Schema{
 			"enterprise_slug": {
 				Type:        schema.TypeString,
 				Required:    true,
 				Description: "The slug of the enterprise.",
 			},
-			"name": {
-				Type:        schema.TypeString,
-				Required:    true,
-				Description: "The name of the hosted runner to lookup.",
-			},
 			"runner_id": {
 				Type:        schema.TypeInt,
-				Computed:    true,
+				Required:    true,
 				Description: "The numeric ID of the hosted runner.",
 			},
+			"name": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The name of the hosted runner.",
+			},
 			"runner_group_id": {
 				Type:        schema.TypeInt,
 				Computed:    true,
@@ -150,101 +150,65 @@ func dataSourceGithubEnterpriseActionsHostedRunner() *schema.Resource {
 	}
 }
 
-func dataSourceGithubEnterpriseActionsHostedRunnerRead(d *schema.ResourceData, meta any) error {
+func dataSourceGithubEnterpriseActionsHostedRunnerRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
 	client := meta.(*Owner).v3client
-	ctx := context.Background()
 
 	enterpriseSlug := d.Get("enterprise_slug").(string)
-	runnerName := d.Get("name").(string)
-
-	// List all runners and find the one matching the name
-	opts := &github.ListOptions{PerPage: 100}
-	var foundRunner *github.HostedRunner
-
-	for {
-		runners, resp, err := client.Enterprise.ListHostedRunners(ctx, enterpriseSlug, opts)
-		if err != nil {
-			return err
-		}
-
-		for _, runner := range runners.Runners {
-			if runner.Name != nil && *runner.Name == runnerName {
-				foundRunner = runner
-				break
-			}
-		}
-
-		if foundRunner != nil || resp.NextPage == 0 {
-			break
-		}
-		opts.Page = resp.NextPage
-	}
+	runnerID := int64(d.Get("runner_id").(int))
 
-	if foundRunner == nil {
-		return fmt.Errorf("no hosted runner found with name %q in enterprise %q", runnerName, enterpriseSlug)
+	// Get the specific runner by ID
+	runner, _, err := client.Enterprise.GetHostedRunner(ctx, enterpriseSlug, runnerID)
+	if err != nil {
+		return diag.FromErr(err)
 	}
 
 	// Set the ID as enterprise_slug/runner_id
-	d.SetId(fmt.Sprintf("%s/%d", enterpriseSlug, *foundRunner.ID))
+	id, err := buildID(enterpriseSlug, strconv.FormatInt(runner.GetID(), 10))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	d.SetId(id)
 
-	if foundRunner.ID != nil {
-		if err := d.Set("runner_id", int(*foundRunner.ID)); err != nil {
-			return err
-		}
+	if err := d.Set("name", runner.GetName()); err != nil {
+		return diag.FromErr(err)
 	}
 
-	if foundRunner.RunnerGroupID != nil {
-		if err := d.Set("runner_group_id", int(*foundRunner.RunnerGroupID)); err != nil {
-			return err
-		}
+	if err := d.Set("runner_group_id", int(runner.GetRunnerGroupID())); err != nil {
+		return diag.FromErr(err)
 	}
 
-	if foundRunner.Platform != nil {
-		if err := d.Set("platform", *foundRunner.Platform); err != nil {
-			return err
-		}
+	if err := d.Set("platform", runner.GetPlatform()); err != nil {
+		return diag.FromErr(err)
 	}
 
-	if foundRunner.Status != nil {
-		if err := d.Set("status", *foundRunner.Status); err != nil {
-			return err
-		}
+	if err := d.Set("status", runner.GetStatus()); err != nil {
+		return diag.FromErr(err)
 	}
 
-	if foundRunner.MaximumRunners != nil {
-		if err := d.Set("maximum_runners", int(*foundRunner.MaximumRunners)); err != nil {
-			return err
-		}
+	if err := d.Set("maximum_runners", int(runner.GetMaximumRunners())); err != nil {
+		return diag.FromErr(err)
 	}
 
-	if foundRunner.PublicIPEnabled != nil {
-		if err := d.Set("public_ip_enabled", *foundRunner.PublicIPEnabled); err != nil {
-			return err
-		}
+	if err := d.Set("public_ip_enabled", runner.GetPublicIPEnabled()); err != nil {
+		return diag.FromErr(err)
 	}
 
-	if foundRunner.LastActiveOn != nil {
-		if err := d.Set("last_active_on", foundRunner.LastActiveOn.Format(time.RFC3339)); err != nil {
-			return err
+	if runner.LastActiveOn != nil {
+		if err := d.Set("last_active_on", runner.LastActiveOn.Format(time.RFC3339)); err != nil {
+			return diag.FromErr(err)
 		}
 	}
 
-	if foundRunner.ImageDetails != nil {
-		if err := d.Set("image_details", flattenHostedRunnerImage(foundRunner.ImageDetails)); err != nil {
-			return err
-		}
+	if err := d.Set("image_details", flattenHostedRunnerImage(runner.ImageDetails)); err != nil {
+		return diag.FromErr(err)
 	}
 
-	if foundRunner.MachineSizeDetails != nil {
-		if err := d.Set("machine_size_details", flattenHostedRunnerMachineSpec(foundRunner.MachineSizeDetails)); err != nil {
-			return err
-		}
+	if err := d.Set("machine_size_details", flattenHostedRunnerMachineSpec(runner.MachineSizeDetails)); err != nil {
+		return diag.FromErr(err)
 	}
 
-	if foundRunner.PublicIPs != nil {
-		if err := d.Set("public_ips", flattenHostedRunnerPublicIPs(foundRunner.PublicIPs)); err != nil {
-			return err
-		}
+	if err := d.Set("public_ips", flattenHostedRunnerPublicIPs(runner.PublicIPs)); err != nil {
+		return diag.FromErr(err)
 	}
 
 	return nil

github/data_source_github_enterprise_actions_hosted_runner_test.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 )
 
 func TestAccGithubEnterpriseActionsHostedRunnersDataSource(t *testing.T) {
@@ -31,7 +31,7 @@ func TestAccGithubEnterpriseActionsHostedRunnersDataSource(t *testing.T) {
 }
 
 func TestAccGithubEnterpriseActionsHostedRunnerDataSource(t *testing.T) {
-	t.Run("gets a specific enterprise hosted runner by name", func(t *testing.T) {
+	t.Run("gets a specific enterprise hosted runner by ID", func(t *testing.T) {
 		config := fmt.Sprintf(`
 			data "github_enterprise" "enterprise" {
 				slug = "%s"
@@ -58,7 +58,7 @@ func TestAccGithubEnterpriseActionsHostedRunnerDataSource(t *testing.T) {
 
 			data "github_enterprise_actions_hosted_runner" "test" {
 				enterprise_slug = data.github_enterprise.enterprise.slug
-				name            = github_enterprise_actions_hosted_runner.test.name
+				runner_id       = github_enterprise_actions_hosted_runner.test.runner_id
 			}
 		`, testAccConf.enterpriseSlug)
 

github/data_source_github_enterprise_actions_hosted_runners.go

@@ -5,12 +5,13 @@ import (
 	"time"
 
 	"github.com/google/go-github/v82/github"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )
 
 func dataSourceGithubEnterpriseActionsHostedRunners() *schema.Resource {
 	return &schema.Resource{
-		Read: dataSourceGithubEnterpriseActionsHostedRunnersRead,
+		ReadContext: dataSourceGithubEnterpriseActionsHostedRunnersRead,
 
 		Schema: map[string]*schema.Schema{
 			"enterprise_slug": {
@@ -134,20 +135,19 @@ func dataSourceGithubEnterpriseActionsHostedRunners() *schema.Resource {
 	}
 }
 
-func dataSourceGithubEnterpriseActionsHostedRunnersRead(d *schema.ResourceData, meta any) error {
+func dataSourceGithubEnterpriseActionsHostedRunnersRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
 	client := meta.(*Owner).v3client
-	ctx := context.Background()
 
 	enterpriseSlug := d.Get("enterprise_slug").(string)
 
 	// List all hosted runners with pagination
-	opts := &github.ListOptions{PerPage: 100}
+	opts := &github.ListOptions{PerPage: maxPerPage}
 	var allRunners []*github.HostedRunner
 
 	for {
 		runners, resp, err := client.Enterprise.ListHostedRunners(ctx, enterpriseSlug, opts)
 		if err != nil {
-			return err
+			return diag.FromErr(err)
 		}
 
 		allRunners = append(allRunners, runners.Runners...)
@@ -163,7 +163,7 @@ func dataSourceGithubEnterpriseActionsHostedRunnersRead(d *schema.ResourceData,
 
 	// Flatten runners data
 	if err := d.Set("runners", flattenHostedRunners(allRunners)); err != nil {
-		return err
+		return diag.FromErr(err)
 	}
 
 	return nil