feat: add healthcheck adpater (#1454)

Resolves https://github.com/overmindtech/workspace/issues/1435

Features:
Implements GCP HealthCheck adapter
GitOrigin-RevId: 9037bddf22977f57bb783cd82dbc72e1458a9ced

Author: omerdemirok

sources/gcp/adapters/adapters.go

@@ -40,6 +40,11 @@ func Adapters(ctx context.Context, projectID string, regions []string, zones []s
 		return nil, err
 	}
 
+	computeHealthCheckCli, err := compute.NewHealthChecksRESTClient(ctx)
+	if err != nil {
+		return nil, err
+	}
+
 	backendServiceCli, err := compute.NewBackendServicesRESTClient(ctx)
 	if err != nil {
 		return nil, err
@@ -77,6 +82,7 @@ func Adapters(ctx context.Context, projectID string, regions []string, zones []s
 	adapters = append(adapters,
 		sources.WrapperToAdapter(NewComputeBackendService(shared.NewComputeBackendServiceClient(backendServiceCli), projectID)),
 		sources.WrapperToAdapter(NewComputeImage(shared.NewComputeImagesClient(computeImagesCli), projectID)),
+		sources.WrapperToAdapter(NewComputeHealthCheck(shared.NewComputeHealthCheckClient(computeHealthCheckCli), projectID)),
 	)
 
 	// Register the metadata for each adapter

sources/gcp/adapters/compute-healthcheck.go

@@ -0,0 +1,125 @@
+package adapters
+
+import (
+	"context"
+	"errors"
+
+	"cloud.google.com/go/compute/apiv1/computepb"
+	"google.golang.org/api/iterator"
+
+	"github.com/overmindtech/cli/sdp-go"
+	"github.com/overmindtech/cli/sources"
+	gcpshared "github.com/overmindtech/cli/sources/gcp/shared"
+	"github.com/overmindtech/cli/sources/shared"
+)
+
+var (
+	ComputeHealthCheck = shared.NewItemType(gcpshared.GCP, gcpshared.Compute, gcpshared.HealthCheck)
+
+	ComputeHealthCheckLookupByName = shared.NewItemTypeLookup("name", ComputeHealthCheck)
+)
+
+type computeHealthCheckWrapper struct {
+	client gcpshared.ComputeHealthCheckClient
+
+	*gcpshared.ProjectBase
+}
+
+// NewComputeHealthCheck creates a new computeHealthCheckWrapper instance.
+func NewComputeHealthCheck(client gcpshared.ComputeHealthCheckClient, projectID string) sources.ListableWrapper {
+	return &computeHealthCheckWrapper{
+		client: client,
+		ProjectBase: gcpshared.NewProjectBase(
+			projectID,
+			sdp.AdapterCategory_ADAPTER_CATEGORY_CONFIGURATION,
+			ComputeHealthCheck,
+		),
+	}
+}
+
+func (c computeHealthCheckWrapper) TerraformMappings() []*sdp.TerraformMapping {
+	return []*sdp.TerraformMapping{
+		{
+			TerraformMethod:   sdp.QueryMethod_GET,
+			TerraformQueryMap: "google_compute_health_check.name",
+		},
+	}
+}
+
+func (c computeHealthCheckWrapper) GetLookups() sources.ItemTypeLookups {
+	return sources.ItemTypeLookups{
+		ComputeHealthCheckLookupByName,
+	}
+}
+
+func (c computeHealthCheckWrapper) Get(ctx context.Context, queryParts ...string) (*sdp.Item, *sdp.QueryError) {
+	req := &computepb.GetHealthCheckRequest{
+		Project:     c.ProjectID(),
+		HealthCheck: queryParts[0],
+	}
+
+	healthCheck, err := c.client.Get(ctx, req)
+	if err != nil {
+		return nil, gcpshared.QueryError(err)
+	}
+
+	var sdpErr *sdp.QueryError
+	var item *sdp.Item
+	item, sdpErr = c.gcpComputeHealthCheckToSDPItem(healthCheck)
+	if sdpErr != nil {
+		return nil, sdpErr
+	}
+
+	return item, nil
+}
+
+func (c computeHealthCheckWrapper) List(ctx context.Context) ([]*sdp.Item, *sdp.QueryError) {
+	results := c.client.List(ctx, &computepb.ListHealthChecksRequest{
+		Project: c.ProjectID(),
+	})
+
+	var items []*sdp.Item
+	for {
+		healthCheck, err := results.Next()
+		if errors.Is(err, iterator.Done) {
+			break
+		}
+
+		if err != nil {
+			return nil, gcpshared.QueryError(err)
+		}
+
+		var sdpErr *sdp.QueryError
+		var item *sdp.Item
+		item, sdpErr = c.gcpComputeHealthCheckToSDPItem(healthCheck)
+		if sdpErr != nil {
+			return nil, sdpErr
+		}
+
+		items = append(items, item)
+	}
+
+	return items, nil
+}
+
+// gcpComputeHealthCheckToSDPItem converts a GCP HealthCheck to an SDP Item
+func (c computeHealthCheckWrapper) gcpComputeHealthCheckToSDPItem(healthCheck *computepb.HealthCheck) (*sdp.Item, *sdp.QueryError) {
+	attributes, err := shared.ToAttributesWithExclude(healthCheck)
+	if err != nil {
+		return nil, &sdp.QueryError{
+			ErrorType:   sdp.QueryError_OTHER,
+			ErrorString: err.Error(),
+		}
+	}
+
+	sdpItem := &sdp.Item{
+		Type:            ComputeHealthCheck.String(),
+		UniqueAttribute: "name",
+		Attributes:      attributes,
+		Scope:           c.DefaultScope(),
+	}
+
+	//Healthcheck type has no relevant links
+
+	return sdpItem, nil
+}

sources/gcp/adapters/compute-healthcheck_test.go

@@ -0,0 +1,91 @@
+package adapters_test
+
+import (
+	"context"
+	"testing"
+
+	"cloud.google.com/go/compute/apiv1/computepb"
+	"go.uber.org/mock/gomock"
+	"google.golang.org/api/iterator"
+	"k8s.io/utils/ptr"
+
+	"github.com/overmindtech/cli/sources"
+	"github.com/overmindtech/cli/sources/gcp/adapters"
+	"github.com/overmindtech/cli/sources/gcp/shared/mocks"
+)
+
+func TestComputeHealthCheck(t *testing.T) {
+	ctx := context.Background()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockClient := mocks.NewMockComputeHealthCheckClient(ctrl)
+	projectID := "test-project-id"
+
+	t.Run("Get", func(t *testing.T) {
+		wrapper := adapters.NewComputeHealthCheck(mockClient, projectID)
+
+		mockClient.EXPECT().Get(ctx, gomock.Any()).Return(createHealthCheck("test-healthcheck"), nil)
+
+		adapter := sources.WrapperToAdapter(wrapper)
+
+		sdpItem, qErr := adapter.Get(ctx, wrapper.Scopes()[0], "test-healthcheck", true)
+		if qErr != nil {
+			t.Fatalf("Expected no error, got: %v", qErr)
+		}
+
+		// [SPEC] The default scope is the project ID.
+		if sdpItem.GetScope() != "test-project-id" {
+			t.Fatalf("Expected scope to be 'test-project-id', got: %s", sdpItem.GetScope())
+		}
+
+		// [SPEC] HealthChecks have no linked items.
+		if len(sdpItem.GetLinkedItemQueries()) != 0 {
+			t.Fatalf("Expected 0 linked item queries, got: %d", len(sdpItem.GetLinkedItemQueries()))
+		}
+
+	})
+
+	t.Run("List", func(t *testing.T) {
+		wrapper := adapters.NewComputeHealthCheck(mockClient, projectID)
+
+		adapter := sources.WrapperToAdapter(wrapper)
+
+		mockComputeHealthCheckIter := mocks.NewMockComputeHealthCheckIterator(ctrl)
+
+		// Mock out items listed from the API.
+		mockComputeHealthCheckIter.EXPECT().Next().Return(createHealthCheck("test-healthcheck-1"), nil)
+		mockComputeHealthCheckIter.EXPECT().Next().Return(createHealthCheck("test-healthcheck-2"), nil)
+		mockComputeHealthCheckIter.EXPECT().Next().Return(nil, iterator.Done)
+
+		// Mock the List method
+		mockClient.EXPECT().List(ctx, gomock.Any()).Return(mockComputeHealthCheckIter)
+
+		sdpItems, err := adapter.List(ctx, wrapper.Scopes()[0], true)
+		if err != nil {
+			t.Fatalf("Expected no error, got: %v", err)
+		}
+
+		if len(sdpItems) != 2 {
+			t.Fatalf("Expected 2 items, got: %d", len(sdpItems))
+		}
+
+		for _, item := range sdpItems {
+			if item.Validate() != nil {
+				t.Fatalf("Expected no validation error, got: %v", item.Validate())
+			}
+		}
+	})
+}
+
+func createHealthCheck(healthCheckName string) *computepb.HealthCheck {
+	return &computepb.HealthCheck{
+		Name:             ptr.To(healthCheckName),
+		CheckIntervalSec: ptr.To(int32(5)),
+		TimeoutSec:       ptr.To(int32(5)),
+		Type:             ptr.To("TCP"),
+		TcpHealthCheck: &computepb.TCPHealthCheck{
+			Port: ptr.To(int32(80)),
+		},
+	}
+}

sources/gcp/adapters/compute-node-group.go

@@ -1,9 +1,10 @@
 package adapters
 
 import (
-	"cloud.google.com/go/compute/apiv1/computepb"
 	"context"
 	"errors"
+
+	"cloud.google.com/go/compute/apiv1/computepb"
 	"google.golang.org/api/iterator"
 
 	"github.com/overmindtech/cli/sdp-go"