Implement ListResource RPC in proto6server

Author: bbasata

internal/fwserver/server_listresource.go

@@ -23,6 +23,7 @@ type ListRequest struct {
 	// Config is the configuration the user supplied for listing resource
 	// instances.
 	Config tfsdk.Config
+	// TODO: Config *tfsdk.Config
 
 	// IncludeResource indicates whether the provider should populate the
 	// Resource field in the ListResult struct.

internal/fwserver/server_listresources.go

@@ -15,12 +15,29 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/resource"
 )
 
+type ListResourceTypeNotFoundError struct {
+	TypeName string
+}
+
+func (e *ListResourceTypeNotFoundError) Error() string {
+	return "listResource Type Not Found: no listResource type named " + e.TypeName + " was found in the provider."
+}
+
+func (e *ListResourceTypeNotFoundError) Is(err error) bool {
+	compatibleErr, ok := err.(*ListResourceTypeNotFoundError)
+	if !ok {
+		return false
+	}
+
+	return e.TypeName == compatibleErr.TypeName
+}
+
 func (s *Server) ListResourceOrError(ctx context.Context, typeName string) (list.ListResource, error) {
 	listResourceFuncs, _ := s.ListResourceFuncs(ctx)
 	listResourceFunc, ok := listResourceFuncs[typeName]
 
 	if !ok {
-		return nil, fmt.Errorf("listResource Type Not Found: No listResource type named %q was found in the provider.", typeName)
+		return nil, &ListResourceTypeNotFoundError{typeName}
 	}
 
 	return listResourceFunc(), nil
@@ -99,17 +116,17 @@ func (s *Server) ListResourceFuncs(ctx context.Context) (map[string]func() list.
 // ListResourceMetadatas returns a slice of ListResourceMetadata for the GetMetadata
 // RPC.
 func (s *Server) ListResourceMetadatas(ctx context.Context) ([]ListResourceMetadata, diag.Diagnostics) {
-	resourceFuncs, diags := s.ListResourceFuncs(ctx)
+	listResourceFuncs, diags := s.ListResourceFuncs(ctx)
 
-	resourceMetadatas := make([]ListResourceMetadata, 0, len(resourceFuncs))
+	listResourceMetadatas := make([]ListResourceMetadata, 0, len(listResourceFuncs))
 
-	for typeName := range resourceFuncs {
-		resourceMetadatas = append(resourceMetadatas, ListResourceMetadata{
+	for typeName := range listResourceFuncs {
+		listResourceMetadatas = append(listResourceMetadatas, ListResourceMetadata{
 			TypeName: typeName,
 		})
 	}
 
-	return resourceMetadatas, diags
+	return listResourceMetadatas, diags
 }
 
 func (s *Server) ListResourceSchema(ctx context.Context, typeName string) (fwschema.Schema, diag.Diagnostics) {

internal/proto6server/server_listresource.go

@@ -0,0 +1,147 @@
+package proto6server
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/internal/fromproto6"
+	"github.com/hashicorp/terraform-plugin-framework/internal/fwserver"
+	"github.com/hashicorp/terraform-plugin-framework/internal/toproto6"
+	"github.com/hashicorp/terraform-plugin-go/tfprotov6"
+)
+
+type ResourceSchemaNotFoundError struct {
+	TypeName string
+}
+
+func (e *ResourceSchemaNotFoundError) Error() string {
+	return "resource schema not found for type: " + e.TypeName
+}
+func (e *ResourceSchemaNotFoundError) Is(err error) bool {
+	compatibleErr, ok := err.(*ResourceSchemaNotFoundError)
+	if !ok {
+		return false
+	}
+
+	return e.TypeName == compatibleErr.TypeName
+}
+
+type ResourceIdentitySchemaNotFoundError struct {
+	TypeName string
+}
+
+func (e *ResourceIdentitySchemaNotFoundError) Error() string {
+	return "resource identity schema not found for type: " + e.TypeName
+}
+
+func (e *ResourceIdentitySchemaNotFoundError) Is(err error) bool {
+	compatibleErr, ok := err.(*ResourceIdentitySchemaNotFoundError)
+	if !ok {
+		return false
+	}
+
+	return e.TypeName == compatibleErr.TypeName
+}
+
+type ListResourceSchemaNotFoundError struct {
+	TypeName string
+}
+
+func (e *ListResourceSchemaNotFoundError) Error() string {
+	return "list resource schema not found for type: " + e.TypeName
+}
+func (e *ListResourceSchemaNotFoundError) Is(err error) bool {
+	compatibleErr, ok := err.(*ListResourceSchemaNotFoundError)
+	if !ok {
+		return false
+	}
+
+	return e.TypeName == compatibleErr.TypeName
+}
+
+type ListResourceConfigError struct {
+	TypeName    string
+	Diagnostics diag.Diagnostics
+}
+
+func (e *ListResourceConfigError) Error() string {
+	return "list resource config error for type: " + e.TypeName // + ": " + e.Diagnostics.Error()
+}
+
+func (e *ListResourceConfigError) Is(err error) bool {
+	compatibleErr, ok := err.(*ListResourceConfigError)
+	if !ok {
+		return false
+	}
+
+	return e.TypeName != compatibleErr.TypeName
+}
+
+func (s *Server) ListResource(ctx context.Context, proto6Req *tfprotov6.ListResourceRequest) (*tfprotov6.ListResourceServerStream, error) {
+	listResource, err := s.FrameworkServer.ListResourceOrError(ctx, proto6Req.TypeName)
+	if err != nil {
+		proto6Stream := &tfprotov6.ListResourceServerStream{}
+		proto6Stream.Results = func(func(tfprotov6.ListResourceResult) bool) {}
+
+		return proto6Stream, err
+	}
+
+	resourceSchema, diags := s.FrameworkServer.ResourceSchema(ctx, proto6Req.TypeName)
+	if diags.HasError() {
+		proto6Stream := &tfprotov6.ListResourceServerStream{}
+		proto6Stream.Results = func(func(tfprotov6.ListResourceResult) bool) {}
+		return proto6Stream, &ResourceSchemaNotFoundError{TypeName: proto6Req.TypeName}
+	}
+
+	identitySchema, diags := s.FrameworkServer.ResourceIdentitySchema(ctx, proto6Req.TypeName)
+	if diags.HasError() {
+		proto6Stream := &tfprotov6.ListResourceServerStream{}
+		proto6Stream.Results = func(func(tfprotov6.ListResourceResult) bool) {}
+		return proto6Stream, &ResourceIdentitySchemaNotFoundError{TypeName: proto6Req.TypeName} // TODO: return a diagnostic instead of an error?
+	}
+
+	listResourceSchema, diags := s.FrameworkServer.ListResourceSchema(ctx, proto6Req.TypeName)
+	if diags.HasError() {
+		proto6Stream := &tfprotov6.ListResourceServerStream{}
+		proto6Stream.Results = func(func(tfprotov6.ListResourceResult) bool) {}
+		return proto6Stream, &ListResourceSchemaNotFoundError{TypeName: proto6Req.TypeName}
+	}
+
+	config, diags := fromproto6.Config(ctx, proto6Req.Config, listResourceSchema)
+	if diags.HasError() {
+		proto6Stream := &tfprotov6.ListResourceServerStream{}
+		proto6Stream.Results = func(func(tfprotov6.ListResourceResult) bool) {}
+		return proto6Stream, &ListResourceConfigError{TypeName: proto6Req.TypeName, Diagnostics: diags}
+	}
+
+	req := &fwserver.ListRequest{
+		Config:                 *config,
+		ListResource:           listResource,
+		ResourceSchema:         resourceSchema,
+		ResourceIdentitySchema: identitySchema,
+		IncludeResource:        proto6Req.IncludeResource,
+	}
+	stream := &fwserver.ListResultsStream{}
+
+	err = s.FrameworkServer.ListResource(ctx, req, stream)
+	if err != nil {
+		return nil, err
+	}
+
+	proto6Stream := &tfprotov6.ListResourceServerStream{}
+	proto6Stream.Results = func(push func(tfprotov6.ListResourceResult) bool) {
+		for result := range stream.Results {
+			var proto6Result tfprotov6.ListResourceResult
+			if req.IncludeResource {
+				proto6Result = toproto6.ListResourceResultWithResource(ctx, &result)
+			} else {
+				proto6Result = toproto6.ListResourceResult(ctx, &result)
+			}
+
+			if !push(proto6Result) {
+				return
+			}
+		}
+	}
+	return proto6Stream, nil
+}