From 2e5b5dee5db47ec2d45b51f1a4303acdc87070ce Mon Sep 17 00:00:00 2001 From: Sarah French <15078782+SarahFrench@users.noreply.github.com> Date: Wed, 22 Oct 2025 14:46:18 +0100 Subject: [PATCH] Upgrade protoc and protoc-gen-go-grpc versions to matching terraform-plugin-go (#37647) * Update protoc version in downloader script * go get google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.5.1 This matched terraform-plugin-go * make protobuf * Run `make protobuf` * Update generator to handle generic types from google.golang.org/grpc Looks like this was added in v1.69.3 in https://github.com/grpc/grpc-go/pull/7057 ? * Run `make generate` * Fix "cannot infer Res" compile error - more usage of generics * More fixing compile errors due to switching to use of a generic * Make putting `google.golang.org/grpc` import into generated files conditional * Run `make generate` * Update more places where generics now need to be used * Update generator to handle any types from google.golang.org/grpc in same switch case. --- go.mod | 2 +- go.sum | 4 +- .../cloudplugin1/grpc_client_test.go | 8 +- .../cloudplugin/cloudproto1/cloudproto1.pb.go | 2 +- .../cloudproto1/cloudproto1_grpc.pb.go | 80 ++--- internal/cloudplugin/mock_cloudproto1/mock.go | 62 ++-- internal/plans/planproto/planfile.pb.go | 2 +- internal/plugin/grpc_provisioner_test.go | 2 +- internal/plugin/mock_proto/mock.go | 186 +++++----- internal/plugin6/grpc_provider_test.go | 11 +- internal/plugin6/mock_proto/mock.go | 196 +++++------ internal/rpcapi/dynrpcserver/dependencies.go | 4 +- .../rpcapi/dynrpcserver/generator/main.go | 39 ++- internal/rpcapi/dynrpcserver/stacks.go | 12 +- internal/rpcapi/stacks_grpc_client_test.go | 10 +- .../dependencies/dependencies.pb.go | 2 +- .../dependencies/dependencies_grpc.pb.go | 107 +++--- .../rpcapi/terraform1/packages/packages.pb.go | 2 +- .../terraform1/packages/packages_grpc.pb.go | 66 +++- internal/rpcapi/terraform1/setup/setup.pb.go | 2 +- .../rpcapi/terraform1/setup/setup_grpc.pb.go | 33 +- .../rpcapi/terraform1/stacks/stacks.pb.go | 2 +- .../terraform1/stacks/stacks_grpc.pb.go | 329 ++++++------------ internal/rpcapi/terraform1/terraform1.pb.go | 2 +- .../stacks/tfstackdata1/tfstackdata1.pb.go | 2 +- .../stacksplugin/mock_stacksproto1/mock.go | 62 ++-- .../stacksproto1/stacksproto1.pb.go | 2 +- .../stacksproto1/stacksproto1_grpc.pb.go | 80 ++--- internal/tfplugin5/tfplugin5.pb.go | 2 +- internal/tfplugin5/tfplugin5_grpc.pb.go | 274 +++++++-------- internal/tfplugin6/tfplugin6.pb.go | 2 +- internal/tfplugin6/tfplugin6_grpc.pb.go | 328 +++++++---------- tools/protobuf-compile/protobuf-compile.go | 3 +- 33 files changed, 896 insertions(+), 1024 deletions(-) diff --git a/go.mod b/go.mod index 02732e06c8..1282961bce 100644 --- a/go.mod +++ b/go.mod @@ -82,7 +82,7 @@ require ( golang.org/x/tools v0.36.0 golang.org/x/tools/cmd/cover v0.1.0-deprecated google.golang.org/grpc v1.69.4 - google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0 + google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.5.1 google.golang.org/protobuf v1.36.6 honnef.co/go/tools v0.6.0 ) diff --git a/go.sum b/go.sum index 7914deaa49..8446062aad 100644 --- a/go.sum +++ b/go.sum @@ -1278,8 +1278,8 @@ google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAG google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= google.golang.org/grpc v1.69.4 h1:MF5TftSMkd8GLw/m0KM6V8CMOCY6NZ1NQDPGFgbTt4A= google.golang.org/grpc v1.69.4/go.mod h1:vyjdE6jLBI76dgpDojsFGNaHlxdjXN9ghpnd2o7JGZ4= -google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0 h1:rNBFJjBCOgVr9pWD7rs/knKL4FRTKgpZmsRfV214zcA= -google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.3.0/go.mod h1:Dk1tviKTvMCz5tvh7t+fh94dhmQVHuCt2OzJB3CTW9Y= +google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.5.1 h1:F29+wU6Ee6qgu9TddPgooOdaqsxTMunOoj8KA5yuS5A= +google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.5.1/go.mod h1:5KF+wpkbTSbGcR9zteSqZV6fqFOWBl4Yde8En8MryZA= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= diff --git a/internal/cloudplugin/cloudplugin1/grpc_client_test.go b/internal/cloudplugin/cloudplugin1/grpc_client_test.go index 2195cafcec..424b7454d3 100644 --- a/internal/cloudplugin/cloudplugin1/grpc_client_test.go +++ b/internal/cloudplugin/cloudplugin1/grpc_client_test.go @@ -18,7 +18,7 @@ import ( var mockError = "this is a mock error" -func testGRPCloudClient(t *testing.T, ctrl *gomock.Controller, client *mock_cloudproto1.MockCommandService_ExecuteClient, executeError error) *GRPCCloudClient { +func testGRPCloudClient(t *testing.T, ctrl *gomock.Controller, client *mock_cloudproto1.MockCommandService_ExecuteClient[cloudproto1.CommandResponse], executeError error) *GRPCCloudClient { t.Helper() if client != nil && executeError != nil { @@ -57,7 +57,7 @@ func Test_GRPCCloudClient_ExecuteError(t *testing.T) { func Test_GRPCCloudClient_Execute_RecvError(t *testing.T) { ctrl := gomock.NewController(t) - executeClient := mock_cloudproto1.NewMockCommandService_ExecuteClient(ctrl) + executeClient := mock_cloudproto1.NewMockCommandService_ExecuteClient[cloudproto1.CommandResponse](ctrl) executeClient.EXPECT().Recv().Return(nil, errors.New(mockError)) gRPCClient := testGRPCloudClient(t, ctrl, executeClient, nil) @@ -78,7 +78,7 @@ func Test_GRPCCloudClient_Execute_RecvError(t *testing.T) { func Test_GRPCCloudClient_Execute_Invalid_Exit(t *testing.T) { ctrl := gomock.NewController(t) - executeClient := mock_cloudproto1.NewMockCommandService_ExecuteClient(ctrl) + executeClient := mock_cloudproto1.NewMockCommandService_ExecuteClient[cloudproto1.CommandResponse](ctrl) executeClient.EXPECT().Recv().Return( &cloudproto1.CommandResponse{ @@ -99,7 +99,7 @@ func Test_GRPCCloudClient_Execute_Invalid_Exit(t *testing.T) { func Test_GRPCCloudClient_Execute(t *testing.T) { ctrl := gomock.NewController(t) - executeClient := mock_cloudproto1.NewMockCommandService_ExecuteClient(ctrl) + executeClient := mock_cloudproto1.NewMockCommandService_ExecuteClient[cloudproto1.CommandResponse](ctrl) gomock.InOrder( executeClient.EXPECT().Recv().Return( diff --git a/internal/cloudplugin/cloudproto1/cloudproto1.pb.go b/internal/cloudplugin/cloudproto1/cloudproto1.pb.go index 9cda01b22b..1b5bae9307 100644 --- a/internal/cloudplugin/cloudproto1/cloudproto1.pb.go +++ b/internal/cloudplugin/cloudproto1/cloudproto1.pb.go @@ -4,7 +4,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: cloudproto1.proto package cloudproto1 diff --git a/internal/cloudplugin/cloudproto1/cloudproto1_grpc.pb.go b/internal/cloudplugin/cloudproto1/cloudproto1_grpc.pb.go index 50f174f21e..a820b82ca3 100644 --- a/internal/cloudplugin/cloudproto1/cloudproto1_grpc.pb.go +++ b/internal/cloudplugin/cloudproto1/cloudproto1_grpc.pb.go @@ -3,8 +3,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.3.0 -// - protoc v3.15.6 +// - protoc-gen-go-grpc v1.5.1 +// - protoc v5.29.3 // source: cloudproto1.proto package cloudproto1 @@ -18,8 +18,8 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 const ( CommandService_Execute_FullMethodName = "/cloudproto1.CommandService/Execute" @@ -28,9 +28,12 @@ const ( // CommandServiceClient is the client API for CommandService service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// PluginService defines the gRPC service to handle available commands and +// their execution. type CommandServiceClient interface { // Execute runs a specific command with the provided flags and returns the result. - Execute(ctx context.Context, in *CommandRequest, opts ...grpc.CallOption) (CommandService_ExecuteClient, error) + Execute(ctx context.Context, in *CommandRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CommandResponse], error) } type commandServiceClient struct { @@ -41,12 +44,13 @@ func NewCommandServiceClient(cc grpc.ClientConnInterface) CommandServiceClient { return &commandServiceClient{cc} } -func (c *commandServiceClient) Execute(ctx context.Context, in *CommandRequest, opts ...grpc.CallOption) (CommandService_ExecuteClient, error) { - stream, err := c.cc.NewStream(ctx, &CommandService_ServiceDesc.Streams[0], CommandService_Execute_FullMethodName, opts...) +func (c *commandServiceClient) Execute(ctx context.Context, in *CommandRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CommandResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &CommandService_ServiceDesc.Streams[0], CommandService_Execute_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &commandServiceExecuteClient{stream} + x := &grpc.GenericClientStream[CommandRequest, CommandResponse]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -56,40 +60,33 @@ func (c *commandServiceClient) Execute(ctx context.Context, in *CommandRequest, return x, nil } -type CommandService_ExecuteClient interface { - Recv() (*CommandResponse, error) - grpc.ClientStream -} - -type commandServiceExecuteClient struct { - grpc.ClientStream -} - -func (x *commandServiceExecuteClient) Recv() (*CommandResponse, error) { - m := new(CommandResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type CommandService_ExecuteClient = grpc.ServerStreamingClient[CommandResponse] // CommandServiceServer is the server API for CommandService service. // All implementations must embed UnimplementedCommandServiceServer -// for forward compatibility +// for forward compatibility. +// +// PluginService defines the gRPC service to handle available commands and +// their execution. type CommandServiceServer interface { // Execute runs a specific command with the provided flags and returns the result. - Execute(*CommandRequest, CommandService_ExecuteServer) error + Execute(*CommandRequest, grpc.ServerStreamingServer[CommandResponse]) error mustEmbedUnimplementedCommandServiceServer() } -// UnimplementedCommandServiceServer must be embedded to have forward compatible implementations. -type UnimplementedCommandServiceServer struct { -} +// UnimplementedCommandServiceServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedCommandServiceServer struct{} -func (UnimplementedCommandServiceServer) Execute(*CommandRequest, CommandService_ExecuteServer) error { +func (UnimplementedCommandServiceServer) Execute(*CommandRequest, grpc.ServerStreamingServer[CommandResponse]) error { return status.Errorf(codes.Unimplemented, "method Execute not implemented") } func (UnimplementedCommandServiceServer) mustEmbedUnimplementedCommandServiceServer() {} +func (UnimplementedCommandServiceServer) testEmbeddedByValue() {} // UnsafeCommandServiceServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to CommandServiceServer will @@ -99,6 +96,13 @@ type UnsafeCommandServiceServer interface { } func RegisterCommandServiceServer(s grpc.ServiceRegistrar, srv CommandServiceServer) { + // If the following call pancis, it indicates UnimplementedCommandServiceServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&CommandService_ServiceDesc, srv) } @@ -107,21 +111,11 @@ func _CommandService_Execute_Handler(srv interface{}, stream grpc.ServerStream) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(CommandServiceServer).Execute(m, &commandServiceExecuteServer{stream}) -} - -type CommandService_ExecuteServer interface { - Send(*CommandResponse) error - grpc.ServerStream -} - -type commandServiceExecuteServer struct { - grpc.ServerStream + return srv.(CommandServiceServer).Execute(m, &grpc.GenericServerStream[CommandRequest, CommandResponse]{ServerStream: stream}) } -func (x *commandServiceExecuteServer) Send(m *CommandResponse) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type CommandService_ExecuteServer = grpc.ServerStreamingServer[CommandResponse] // CommandService_ServiceDesc is the grpc.ServiceDesc for CommandService service. // It's only intended for direct use with grpc.RegisterService, diff --git a/internal/cloudplugin/mock_cloudproto1/mock.go b/internal/cloudplugin/mock_cloudproto1/mock.go index f74d2f6382..5992f51590 100644 --- a/internal/cloudplugin/mock_cloudproto1/mock.go +++ b/internal/cloudplugin/mock_cloudproto1/mock.go @@ -44,14 +44,14 @@ func (m *MockCommandServiceClient) EXPECT() *MockCommandServiceClientMockRecorde } // Execute mocks base method. -func (m *MockCommandServiceClient) Execute(ctx context.Context, in *cloudproto1.CommandRequest, opts ...grpc.CallOption) (cloudproto1.CommandService_ExecuteClient, error) { +func (m *MockCommandServiceClient) Execute(ctx context.Context, in *cloudproto1.CommandRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[cloudproto1.CommandResponse], error) { m.ctrl.T.Helper() varargs := []any{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Execute", varargs...) - ret0, _ := ret[0].(cloudproto1.CommandService_ExecuteClient) + ret0, _ := ret[0].(grpc.ServerStreamingClient[cloudproto1.CommandResponse]) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -64,31 +64,31 @@ func (mr *MockCommandServiceClientMockRecorder) Execute(ctx, in any, opts ...any } // MockCommandService_ExecuteClient is a mock of CommandService_ExecuteClient interface. -type MockCommandService_ExecuteClient struct { +type MockCommandService_ExecuteClient[Res any] struct { ctrl *gomock.Controller - recorder *MockCommandService_ExecuteClientMockRecorder + recorder *MockCommandService_ExecuteClientMockRecorder[Res] isgomock struct{} } // MockCommandService_ExecuteClientMockRecorder is the mock recorder for MockCommandService_ExecuteClient. -type MockCommandService_ExecuteClientMockRecorder struct { - mock *MockCommandService_ExecuteClient +type MockCommandService_ExecuteClientMockRecorder[Res any] struct { + mock *MockCommandService_ExecuteClient[Res] } // NewMockCommandService_ExecuteClient creates a new mock instance. -func NewMockCommandService_ExecuteClient(ctrl *gomock.Controller) *MockCommandService_ExecuteClient { - mock := &MockCommandService_ExecuteClient{ctrl: ctrl} - mock.recorder = &MockCommandService_ExecuteClientMockRecorder{mock} +func NewMockCommandService_ExecuteClient[Res any](ctrl *gomock.Controller) *MockCommandService_ExecuteClient[Res] { + mock := &MockCommandService_ExecuteClient[Res]{ctrl: ctrl} + mock.recorder = &MockCommandService_ExecuteClientMockRecorder[Res]{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockCommandService_ExecuteClient) EXPECT() *MockCommandService_ExecuteClientMockRecorder { +func (m *MockCommandService_ExecuteClient[Res]) EXPECT() *MockCommandService_ExecuteClientMockRecorder[Res] { return m.recorder } // CloseSend mocks base method. -func (m *MockCommandService_ExecuteClient) CloseSend() error { +func (m *MockCommandService_ExecuteClient[Res]) CloseSend() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseSend") ret0, _ := ret[0].(error) @@ -96,13 +96,13 @@ func (m *MockCommandService_ExecuteClient) CloseSend() error { } // CloseSend indicates an expected call of CloseSend. -func (mr *MockCommandService_ExecuteClientMockRecorder) CloseSend() *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) CloseSend() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).CloseSend)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).CloseSend)) } // Context mocks base method. -func (m *MockCommandService_ExecuteClient) Context() context.Context { +func (m *MockCommandService_ExecuteClient[Res]) Context() context.Context { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) @@ -110,13 +110,13 @@ func (m *MockCommandService_ExecuteClient) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockCommandService_ExecuteClientMockRecorder) Context() *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) Context() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).Context)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).Context)) } // Header mocks base method. -func (m *MockCommandService_ExecuteClient) Header() (metadata.MD, error) { +func (m *MockCommandService_ExecuteClient[Res]) Header() (metadata.MD, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Header") ret0, _ := ret[0].(metadata.MD) @@ -125,13 +125,13 @@ func (m *MockCommandService_ExecuteClient) Header() (metadata.MD, error) { } // Header indicates an expected call of Header. -func (mr *MockCommandService_ExecuteClientMockRecorder) Header() *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) Header() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).Header)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).Header)) } // Recv mocks base method. -func (m *MockCommandService_ExecuteClient) Recv() (*cloudproto1.CommandResponse, error) { +func (m *MockCommandService_ExecuteClient[Res]) Recv() (*cloudproto1.CommandResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Recv") ret0, _ := ret[0].(*cloudproto1.CommandResponse) @@ -140,13 +140,13 @@ func (m *MockCommandService_ExecuteClient) Recv() (*cloudproto1.CommandResponse, } // Recv indicates an expected call of Recv. -func (mr *MockCommandService_ExecuteClientMockRecorder) Recv() *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) Recv() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).Recv)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).Recv)) } // RecvMsg mocks base method. -func (m_2 *MockCommandService_ExecuteClient) RecvMsg(m any) error { +func (m_2 *MockCommandService_ExecuteClient[Res]) RecvMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "RecvMsg", m) ret0, _ := ret[0].(error) @@ -154,13 +154,13 @@ func (m_2 *MockCommandService_ExecuteClient) RecvMsg(m any) error { } // RecvMsg indicates an expected call of RecvMsg. -func (mr *MockCommandService_ExecuteClientMockRecorder) RecvMsg(m any) *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) RecvMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).RecvMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).RecvMsg), m) } // SendMsg mocks base method. -func (m_2 *MockCommandService_ExecuteClient) SendMsg(m any) error { +func (m_2 *MockCommandService_ExecuteClient[Res]) SendMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "SendMsg", m) ret0, _ := ret[0].(error) @@ -168,13 +168,13 @@ func (m_2 *MockCommandService_ExecuteClient) SendMsg(m any) error { } // SendMsg indicates an expected call of SendMsg. -func (mr *MockCommandService_ExecuteClientMockRecorder) SendMsg(m any) *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) SendMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).SendMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).SendMsg), m) } // Trailer mocks base method. -func (m *MockCommandService_ExecuteClient) Trailer() metadata.MD { +func (m *MockCommandService_ExecuteClient[Res]) Trailer() metadata.MD { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Trailer") ret0, _ := ret[0].(metadata.MD) @@ -182,7 +182,7 @@ func (m *MockCommandService_ExecuteClient) Trailer() metadata.MD { } // Trailer indicates an expected call of Trailer. -func (mr *MockCommandService_ExecuteClientMockRecorder) Trailer() *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) Trailer() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).Trailer)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).Trailer)) } diff --git a/internal/plans/planproto/planfile.pb.go b/internal/plans/planproto/planfile.pb.go index e4351e4964..ada0316eea 100644 --- a/internal/plans/planproto/planfile.pb.go +++ b/internal/plans/planproto/planfile.pb.go @@ -4,7 +4,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: planfile.proto package planproto diff --git a/internal/plugin/grpc_provisioner_test.go b/internal/plugin/grpc_provisioner_test.go index 450f43d455..eff42ec46f 100644 --- a/internal/plugin/grpc_provisioner_test.go +++ b/internal/plugin/grpc_provisioner_test.go @@ -90,7 +90,7 @@ func TestGRPCProvisioner_ProvisionResource(t *testing.T) { gomock.Any(), ).Return(provisionerProtoSchema(), nil) - stream := mockproto.NewMockProvisioner_ProvisionResourceClient(ctrl) + stream := mockproto.NewMockProvisioner_ProvisionResourceClient[provisioners.ProvisionResourceResponse](ctrl) stream.EXPECT().Recv().Return(&proto.ProvisionResource_Response{ Output: "provisioned", }, io.EOF) diff --git a/internal/plugin/mock_proto/mock.go b/internal/plugin/mock_proto/mock.go index f7cac0ebc8..bf3cfc6877 100644 --- a/internal/plugin/mock_proto/mock.go +++ b/internal/plugin/mock_proto/mock.go @@ -244,14 +244,14 @@ func (mr *MockProviderClientMockRecorder) ImportResourceState(ctx, in any, opts } // InvokeAction mocks base method. -func (m *MockProviderClient) InvokeAction(ctx context.Context, in *tfplugin5.InvokeAction_Request, opts ...grpc.CallOption) (tfplugin5.Provider_InvokeActionClient, error) { +func (m *MockProviderClient) InvokeAction(ctx context.Context, in *tfplugin5.InvokeAction_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[tfplugin5.InvokeAction_Event], error) { m.ctrl.T.Helper() varargs := []any{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "InvokeAction", varargs...) - ret0, _ := ret[0].(tfplugin5.Provider_InvokeActionClient) + ret0, _ := ret[0].(grpc.ServerStreamingClient[tfplugin5.InvokeAction_Event]) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -264,14 +264,14 @@ func (mr *MockProviderClientMockRecorder) InvokeAction(ctx, in any, opts ...any) } // ListResource mocks base method. -func (m *MockProviderClient) ListResource(ctx context.Context, in *tfplugin5.ListResource_Request, opts ...grpc.CallOption) (tfplugin5.Provider_ListResourceClient, error) { +func (m *MockProviderClient) ListResource(ctx context.Context, in *tfplugin5.ListResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[tfplugin5.ListResource_Event], error) { m.ctrl.T.Helper() varargs := []any{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListResource", varargs...) - ret0, _ := ret[0].(tfplugin5.Provider_ListResourceClient) + ret0, _ := ret[0].(grpc.ServerStreamingClient[tfplugin5.ListResource_Event]) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -648,14 +648,14 @@ func (mr *MockProvisionerClientMockRecorder) GetSchema(ctx, in any, opts ...any) } // ProvisionResource mocks base method. -func (m *MockProvisionerClient) ProvisionResource(ctx context.Context, in *tfplugin5.ProvisionResource_Request, opts ...grpc.CallOption) (tfplugin5.Provisioner_ProvisionResourceClient, error) { +func (m *MockProvisionerClient) ProvisionResource(ctx context.Context, in *tfplugin5.ProvisionResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[tfplugin5.ProvisionResource_Response], error) { m.ctrl.T.Helper() varargs := []any{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ProvisionResource", varargs...) - ret0, _ := ret[0].(tfplugin5.Provisioner_ProvisionResourceClient) + ret0, _ := ret[0].(grpc.ServerStreamingClient[tfplugin5.ProvisionResource_Response]) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -708,31 +708,31 @@ func (mr *MockProvisionerClientMockRecorder) ValidateProvisionerConfig(ctx, in a } // MockProvisioner_ProvisionResourceClient is a mock of Provisioner_ProvisionResourceClient interface. -type MockProvisioner_ProvisionResourceClient struct { +type MockProvisioner_ProvisionResourceClient[Res any] struct { ctrl *gomock.Controller - recorder *MockProvisioner_ProvisionResourceClientMockRecorder + recorder *MockProvisioner_ProvisionResourceClientMockRecorder[Res] isgomock struct{} } // MockProvisioner_ProvisionResourceClientMockRecorder is the mock recorder for MockProvisioner_ProvisionResourceClient. -type MockProvisioner_ProvisionResourceClientMockRecorder struct { - mock *MockProvisioner_ProvisionResourceClient +type MockProvisioner_ProvisionResourceClientMockRecorder[Res any] struct { + mock *MockProvisioner_ProvisionResourceClient[Res] } // NewMockProvisioner_ProvisionResourceClient creates a new mock instance. -func NewMockProvisioner_ProvisionResourceClient(ctrl *gomock.Controller) *MockProvisioner_ProvisionResourceClient { - mock := &MockProvisioner_ProvisionResourceClient{ctrl: ctrl} - mock.recorder = &MockProvisioner_ProvisionResourceClientMockRecorder{mock} +func NewMockProvisioner_ProvisionResourceClient[Res any](ctrl *gomock.Controller) *MockProvisioner_ProvisionResourceClient[Res] { + mock := &MockProvisioner_ProvisionResourceClient[Res]{ctrl: ctrl} + mock.recorder = &MockProvisioner_ProvisionResourceClientMockRecorder[Res]{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockProvisioner_ProvisionResourceClient) EXPECT() *MockProvisioner_ProvisionResourceClientMockRecorder { +func (m *MockProvisioner_ProvisionResourceClient[Res]) EXPECT() *MockProvisioner_ProvisionResourceClientMockRecorder[Res] { return m.recorder } // CloseSend mocks base method. -func (m *MockProvisioner_ProvisionResourceClient) CloseSend() error { +func (m *MockProvisioner_ProvisionResourceClient[Res]) CloseSend() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseSend") ret0, _ := ret[0].(error) @@ -740,13 +740,13 @@ func (m *MockProvisioner_ProvisionResourceClient) CloseSend() error { } // CloseSend indicates an expected call of CloseSend. -func (mr *MockProvisioner_ProvisionResourceClientMockRecorder) CloseSend() *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) CloseSend() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient)(nil).CloseSend)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).CloseSend)) } // Context mocks base method. -func (m *MockProvisioner_ProvisionResourceClient) Context() context.Context { +func (m *MockProvisioner_ProvisionResourceClient[Res]) Context() context.Context { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) @@ -754,13 +754,13 @@ func (m *MockProvisioner_ProvisionResourceClient) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockProvisioner_ProvisionResourceClientMockRecorder) Context() *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) Context() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient)(nil).Context)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).Context)) } // Header mocks base method. -func (m *MockProvisioner_ProvisionResourceClient) Header() (metadata.MD, error) { +func (m *MockProvisioner_ProvisionResourceClient[Res]) Header() (metadata.MD, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Header") ret0, _ := ret[0].(metadata.MD) @@ -769,13 +769,13 @@ func (m *MockProvisioner_ProvisionResourceClient) Header() (metadata.MD, error) } // Header indicates an expected call of Header. -func (mr *MockProvisioner_ProvisionResourceClientMockRecorder) Header() *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) Header() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient)(nil).Header)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).Header)) } // Recv mocks base method. -func (m *MockProvisioner_ProvisionResourceClient) Recv() (*tfplugin5.ProvisionResource_Response, error) { +func (m *MockProvisioner_ProvisionResourceClient[Res]) Recv() (*tfplugin5.ProvisionResource_Response, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Recv") ret0, _ := ret[0].(*tfplugin5.ProvisionResource_Response) @@ -784,13 +784,13 @@ func (m *MockProvisioner_ProvisionResourceClient) Recv() (*tfplugin5.ProvisionRe } // Recv indicates an expected call of Recv. -func (mr *MockProvisioner_ProvisionResourceClientMockRecorder) Recv() *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) Recv() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient)(nil).Recv)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).Recv)) } // RecvMsg mocks base method. -func (m_2 *MockProvisioner_ProvisionResourceClient) RecvMsg(m any) error { +func (m_2 *MockProvisioner_ProvisionResourceClient[Res]) RecvMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "RecvMsg", m) ret0, _ := ret[0].(error) @@ -798,13 +798,13 @@ func (m_2 *MockProvisioner_ProvisionResourceClient) RecvMsg(m any) error { } // RecvMsg indicates an expected call of RecvMsg. -func (mr *MockProvisioner_ProvisionResourceClientMockRecorder) RecvMsg(m any) *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) RecvMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient)(nil).RecvMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).RecvMsg), m) } // SendMsg mocks base method. -func (m_2 *MockProvisioner_ProvisionResourceClient) SendMsg(m any) error { +func (m_2 *MockProvisioner_ProvisionResourceClient[Res]) SendMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "SendMsg", m) ret0, _ := ret[0].(error) @@ -812,13 +812,13 @@ func (m_2 *MockProvisioner_ProvisionResourceClient) SendMsg(m any) error { } // SendMsg indicates an expected call of SendMsg. -func (mr *MockProvisioner_ProvisionResourceClientMockRecorder) SendMsg(m any) *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) SendMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient)(nil).SendMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).SendMsg), m) } // Trailer mocks base method. -func (m *MockProvisioner_ProvisionResourceClient) Trailer() metadata.MD { +func (m *MockProvisioner_ProvisionResourceClient[Res]) Trailer() metadata.MD { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Trailer") ret0, _ := ret[0].(metadata.MD) @@ -826,37 +826,37 @@ func (m *MockProvisioner_ProvisionResourceClient) Trailer() metadata.MD { } // Trailer indicates an expected call of Trailer. -func (mr *MockProvisioner_ProvisionResourceClientMockRecorder) Trailer() *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceClientMockRecorder[Res]) Trailer() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient)(nil).Trailer)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvisioner_ProvisionResourceClient[Res])(nil).Trailer)) } // MockProvisioner_ProvisionResourceServer is a mock of Provisioner_ProvisionResourceServer interface. -type MockProvisioner_ProvisionResourceServer struct { +type MockProvisioner_ProvisionResourceServer[Res any] struct { ctrl *gomock.Controller - recorder *MockProvisioner_ProvisionResourceServerMockRecorder + recorder *MockProvisioner_ProvisionResourceServerMockRecorder[Res] isgomock struct{} } // MockProvisioner_ProvisionResourceServerMockRecorder is the mock recorder for MockProvisioner_ProvisionResourceServer. -type MockProvisioner_ProvisionResourceServerMockRecorder struct { - mock *MockProvisioner_ProvisionResourceServer +type MockProvisioner_ProvisionResourceServerMockRecorder[Res any] struct { + mock *MockProvisioner_ProvisionResourceServer[Res] } // NewMockProvisioner_ProvisionResourceServer creates a new mock instance. -func NewMockProvisioner_ProvisionResourceServer(ctrl *gomock.Controller) *MockProvisioner_ProvisionResourceServer { - mock := &MockProvisioner_ProvisionResourceServer{ctrl: ctrl} - mock.recorder = &MockProvisioner_ProvisionResourceServerMockRecorder{mock} +func NewMockProvisioner_ProvisionResourceServer[Res any](ctrl *gomock.Controller) *MockProvisioner_ProvisionResourceServer[Res] { + mock := &MockProvisioner_ProvisionResourceServer[Res]{ctrl: ctrl} + mock.recorder = &MockProvisioner_ProvisionResourceServerMockRecorder[Res]{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockProvisioner_ProvisionResourceServer) EXPECT() *MockProvisioner_ProvisionResourceServerMockRecorder { +func (m *MockProvisioner_ProvisionResourceServer[Res]) EXPECT() *MockProvisioner_ProvisionResourceServerMockRecorder[Res] { return m.recorder } // Context mocks base method. -func (m *MockProvisioner_ProvisionResourceServer) Context() context.Context { +func (m *MockProvisioner_ProvisionResourceServer[Res]) Context() context.Context { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) @@ -864,13 +864,13 @@ func (m *MockProvisioner_ProvisionResourceServer) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockProvisioner_ProvisionResourceServerMockRecorder) Context() *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) Context() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer)(nil).Context)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).Context)) } // RecvMsg mocks base method. -func (m_2 *MockProvisioner_ProvisionResourceServer) RecvMsg(m any) error { +func (m_2 *MockProvisioner_ProvisionResourceServer[Res]) RecvMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "RecvMsg", m) ret0, _ := ret[0].(error) @@ -878,13 +878,13 @@ func (m_2 *MockProvisioner_ProvisionResourceServer) RecvMsg(m any) error { } // RecvMsg indicates an expected call of RecvMsg. -func (mr *MockProvisioner_ProvisionResourceServerMockRecorder) RecvMsg(m any) *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) RecvMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer)(nil).RecvMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).RecvMsg), m) } // Send mocks base method. -func (m *MockProvisioner_ProvisionResourceServer) Send(arg0 *tfplugin5.ProvisionResource_Response) error { +func (m *MockProvisioner_ProvisionResourceServer[Res]) Send(arg0 *tfplugin5.ProvisionResource_Response) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Send", arg0) ret0, _ := ret[0].(error) @@ -892,13 +892,13 @@ func (m *MockProvisioner_ProvisionResourceServer) Send(arg0 *tfplugin5.Provision } // Send indicates an expected call of Send. -func (mr *MockProvisioner_ProvisionResourceServerMockRecorder) Send(arg0 any) *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) Send(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer)(nil).Send), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).Send), arg0) } // SendHeader mocks base method. -func (m *MockProvisioner_ProvisionResourceServer) SendHeader(arg0 metadata.MD) error { +func (m *MockProvisioner_ProvisionResourceServer[Res]) SendHeader(arg0 metadata.MD) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SendHeader", arg0) ret0, _ := ret[0].(error) @@ -906,13 +906,13 @@ func (m *MockProvisioner_ProvisionResourceServer) SendHeader(arg0 metadata.MD) e } // SendHeader indicates an expected call of SendHeader. -func (mr *MockProvisioner_ProvisionResourceServerMockRecorder) SendHeader(arg0 any) *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) SendHeader(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer)(nil).SendHeader), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).SendHeader), arg0) } // SendMsg mocks base method. -func (m_2 *MockProvisioner_ProvisionResourceServer) SendMsg(m any) error { +func (m_2 *MockProvisioner_ProvisionResourceServer[Res]) SendMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "SendMsg", m) ret0, _ := ret[0].(error) @@ -920,13 +920,13 @@ func (m_2 *MockProvisioner_ProvisionResourceServer) SendMsg(m any) error { } // SendMsg indicates an expected call of SendMsg. -func (mr *MockProvisioner_ProvisionResourceServerMockRecorder) SendMsg(m any) *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) SendMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer)(nil).SendMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).SendMsg), m) } // SetHeader mocks base method. -func (m *MockProvisioner_ProvisionResourceServer) SetHeader(arg0 metadata.MD) error { +func (m *MockProvisioner_ProvisionResourceServer[Res]) SetHeader(arg0 metadata.MD) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetHeader", arg0) ret0, _ := ret[0].(error) @@ -934,49 +934,49 @@ func (m *MockProvisioner_ProvisionResourceServer) SetHeader(arg0 metadata.MD) er } // SetHeader indicates an expected call of SetHeader. -func (mr *MockProvisioner_ProvisionResourceServerMockRecorder) SetHeader(arg0 any) *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) SetHeader(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer)(nil).SetHeader), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).SetHeader), arg0) } // SetTrailer mocks base method. -func (m *MockProvisioner_ProvisionResourceServer) SetTrailer(arg0 metadata.MD) { +func (m *MockProvisioner_ProvisionResourceServer[Res]) SetTrailer(arg0 metadata.MD) { m.ctrl.T.Helper() m.ctrl.Call(m, "SetTrailer", arg0) } // SetTrailer indicates an expected call of SetTrailer. -func (mr *MockProvisioner_ProvisionResourceServerMockRecorder) SetTrailer(arg0 any) *gomock.Call { +func (mr *MockProvisioner_ProvisionResourceServerMockRecorder[Res]) SetTrailer(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer)(nil).SetTrailer), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockProvisioner_ProvisionResourceServer[Res])(nil).SetTrailer), arg0) } // MockProvider_InvokeActionClient is a mock of Provider_InvokeActionClient interface. -type MockProvider_InvokeActionClient struct { +type MockProvider_InvokeActionClient[Res any] struct { ctrl *gomock.Controller - recorder *MockProvider_InvokeActionClientMockRecorder + recorder *MockProvider_InvokeActionClientMockRecorder[Res] isgomock struct{} } // MockProvider_InvokeActionClientMockRecorder is the mock recorder for MockProvider_InvokeActionClient. -type MockProvider_InvokeActionClientMockRecorder struct { - mock *MockProvider_InvokeActionClient +type MockProvider_InvokeActionClientMockRecorder[Res any] struct { + mock *MockProvider_InvokeActionClient[Res] } // NewMockProvider_InvokeActionClient creates a new mock instance. -func NewMockProvider_InvokeActionClient(ctrl *gomock.Controller) *MockProvider_InvokeActionClient { - mock := &MockProvider_InvokeActionClient{ctrl: ctrl} - mock.recorder = &MockProvider_InvokeActionClientMockRecorder{mock} +func NewMockProvider_InvokeActionClient[Res any](ctrl *gomock.Controller) *MockProvider_InvokeActionClient[Res] { + mock := &MockProvider_InvokeActionClient[Res]{ctrl: ctrl} + mock.recorder = &MockProvider_InvokeActionClientMockRecorder[Res]{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockProvider_InvokeActionClient) EXPECT() *MockProvider_InvokeActionClientMockRecorder { +func (m *MockProvider_InvokeActionClient[Res]) EXPECT() *MockProvider_InvokeActionClientMockRecorder[Res] { return m.recorder } // CloseSend mocks base method. -func (m *MockProvider_InvokeActionClient) CloseSend() error { +func (m *MockProvider_InvokeActionClient[Res]) CloseSend() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseSend") ret0, _ := ret[0].(error) @@ -984,13 +984,13 @@ func (m *MockProvider_InvokeActionClient) CloseSend() error { } // CloseSend indicates an expected call of CloseSend. -func (mr *MockProvider_InvokeActionClientMockRecorder) CloseSend() *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) CloseSend() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).CloseSend)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).CloseSend)) } // Context mocks base method. -func (m *MockProvider_InvokeActionClient) Context() context.Context { +func (m *MockProvider_InvokeActionClient[Res]) Context() context.Context { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) @@ -998,13 +998,13 @@ func (m *MockProvider_InvokeActionClient) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockProvider_InvokeActionClientMockRecorder) Context() *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Context() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).Context)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Context)) } // Header mocks base method. -func (m *MockProvider_InvokeActionClient) Header() (metadata.MD, error) { +func (m *MockProvider_InvokeActionClient[Res]) Header() (metadata.MD, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Header") ret0, _ := ret[0].(metadata.MD) @@ -1013,13 +1013,13 @@ func (m *MockProvider_InvokeActionClient) Header() (metadata.MD, error) { } // Header indicates an expected call of Header. -func (mr *MockProvider_InvokeActionClientMockRecorder) Header() *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Header() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).Header)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Header)) } // Recv mocks base method. -func (m *MockProvider_InvokeActionClient) Recv() (*tfplugin5.InvokeAction_Event, error) { +func (m *MockProvider_InvokeActionClient[Res]) Recv() (*tfplugin5.InvokeAction_Event, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Recv") ret0, _ := ret[0].(*tfplugin5.InvokeAction_Event) @@ -1028,13 +1028,13 @@ func (m *MockProvider_InvokeActionClient) Recv() (*tfplugin5.InvokeAction_Event, } // Recv indicates an expected call of Recv. -func (mr *MockProvider_InvokeActionClientMockRecorder) Recv() *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Recv() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).Recv)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Recv)) } // RecvMsg mocks base method. -func (m_2 *MockProvider_InvokeActionClient) RecvMsg(m any) error { +func (m_2 *MockProvider_InvokeActionClient[Res]) RecvMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "RecvMsg", m) ret0, _ := ret[0].(error) @@ -1042,13 +1042,13 @@ func (m_2 *MockProvider_InvokeActionClient) RecvMsg(m any) error { } // RecvMsg indicates an expected call of RecvMsg. -func (mr *MockProvider_InvokeActionClientMockRecorder) RecvMsg(m any) *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) RecvMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).RecvMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).RecvMsg), m) } // SendMsg mocks base method. -func (m_2 *MockProvider_InvokeActionClient) SendMsg(m any) error { +func (m_2 *MockProvider_InvokeActionClient[Res]) SendMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "SendMsg", m) ret0, _ := ret[0].(error) @@ -1056,13 +1056,13 @@ func (m_2 *MockProvider_InvokeActionClient) SendMsg(m any) error { } // SendMsg indicates an expected call of SendMsg. -func (mr *MockProvider_InvokeActionClientMockRecorder) SendMsg(m any) *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) SendMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).SendMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).SendMsg), m) } // Trailer mocks base method. -func (m *MockProvider_InvokeActionClient) Trailer() metadata.MD { +func (m *MockProvider_InvokeActionClient[Res]) Trailer() metadata.MD { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Trailer") ret0, _ := ret[0].(metadata.MD) @@ -1070,7 +1070,7 @@ func (m *MockProvider_InvokeActionClient) Trailer() metadata.MD { } // Trailer indicates an expected call of Trailer. -func (mr *MockProvider_InvokeActionClientMockRecorder) Trailer() *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Trailer() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).Trailer)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Trailer)) } diff --git a/internal/plugin6/grpc_provider_test.go b/internal/plugin6/grpc_provider_test.go index 226fb1578d..0ebd3c88c3 100644 --- a/internal/plugin6/grpc_provider_test.go +++ b/internal/plugin6/grpc_provider_test.go @@ -30,6 +30,7 @@ import ( "github.com/hashicorp/terraform/internal/providers" "github.com/hashicorp/terraform/internal/schemarepo" "github.com/hashicorp/terraform/internal/tfdiags" + "github.com/hashicorp/terraform/internal/tfplugin6" proto "github.com/hashicorp/terraform/internal/tfplugin6" ) @@ -62,14 +63,14 @@ func mockProviderClient(t *testing.T) *mockproto.MockProviderClient { return client } -func mockReadStateBytesClient(t *testing.T) *mockproto.MockProvider_ReadStateBytesClient { +func mockReadStateBytesClient(t *testing.T) *mockproto.MockProvider_ReadStateBytesClient[tfplugin6.ReadStateBytes_Response] { ctrl := gomock.NewController(t) - return mockproto.NewMockProvider_ReadStateBytesClient(ctrl) + return mockproto.NewMockProvider_ReadStateBytesClient[tfplugin6.ReadStateBytes_Response](ctrl) } -func mockWriteStateBytesClient(t *testing.T) *mockproto.MockProvider_WriteStateBytesClient { +func mockWriteStateBytesClient(t *testing.T) *mockproto.MockProvider_WriteStateBytesClient[tfplugin6.WriteStateBytes_RequestChunk, tfplugin6.WriteStateBytes_Response] { ctrl := gomock.NewController(t) - return mockproto.NewMockProvider_WriteStateBytesClient(ctrl) + return mockproto.NewMockProvider_WriteStateBytesClient[tfplugin6.WriteStateBytes_RequestChunk, tfplugin6.WriteStateBytes_Response](ctrl) } func checkDiags(t *testing.T, d tfdiags.Diagnostics) { @@ -2082,7 +2083,7 @@ func TestGRPCProvider_invokeAction_valid(t *testing.T) { client: client, } - mockInvokeClient := mockproto.NewMockProvider_InvokeActionClient(ctrl) + mockInvokeClient := mockproto.NewMockProvider_InvokeActionClient[tfplugin6.InvokeAction_Event](ctrl) mockInvokeClient.EXPECT().Recv().Return(&proto.InvokeAction_Event{ Type: &proto.InvokeAction_Event_Progress_{ Progress: &proto.InvokeAction_Event_Progress{ diff --git a/internal/plugin6/mock_proto/mock.go b/internal/plugin6/mock_proto/mock.go index 3fdb59450d..da23b466ad 100644 --- a/internal/plugin6/mock_proto/mock.go +++ b/internal/plugin6/mock_proto/mock.go @@ -304,14 +304,14 @@ func (mr *MockProviderClientMockRecorder) ImportResourceState(ctx, in any, opts } // InvokeAction mocks base method. -func (m *MockProviderClient) InvokeAction(ctx context.Context, in *tfplugin6.InvokeAction_Request, opts ...grpc.CallOption) (tfplugin6.Provider_InvokeActionClient, error) { +func (m *MockProviderClient) InvokeAction(ctx context.Context, in *tfplugin6.InvokeAction_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[tfplugin6.InvokeAction_Event], error) { m.ctrl.T.Helper() varargs := []any{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "InvokeAction", varargs...) - ret0, _ := ret[0].(tfplugin6.Provider_InvokeActionClient) + ret0, _ := ret[0].(grpc.ServerStreamingClient[tfplugin6.InvokeAction_Event]) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -324,14 +324,14 @@ func (mr *MockProviderClientMockRecorder) InvokeAction(ctx, in any, opts ...any) } // ListResource mocks base method. -func (m *MockProviderClient) ListResource(ctx context.Context, in *tfplugin6.ListResource_Request, opts ...grpc.CallOption) (tfplugin6.Provider_ListResourceClient, error) { +func (m *MockProviderClient) ListResource(ctx context.Context, in *tfplugin6.ListResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[tfplugin6.ListResource_Event], error) { m.ctrl.T.Helper() varargs := []any{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListResource", varargs...) - ret0, _ := ret[0].(tfplugin6.Provider_ListResourceClient) + ret0, _ := ret[0].(grpc.ServerStreamingClient[tfplugin6.ListResource_Event]) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -484,14 +484,14 @@ func (mr *MockProviderClientMockRecorder) ReadResource(ctx, in any, opts ...any) } // ReadStateBytes mocks base method. -func (m *MockProviderClient) ReadStateBytes(ctx context.Context, in *tfplugin6.ReadStateBytes_Request, opts ...grpc.CallOption) (tfplugin6.Provider_ReadStateBytesClient, error) { +func (m *MockProviderClient) ReadStateBytes(ctx context.Context, in *tfplugin6.ReadStateBytes_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[tfplugin6.ReadStateBytes_Response], error) { m.ctrl.T.Helper() varargs := []any{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ReadStateBytes", varargs...) - ret0, _ := ret[0].(tfplugin6.Provider_ReadStateBytesClient) + ret0, _ := ret[0].(grpc.ServerStreamingClient[tfplugin6.ReadStateBytes_Response]) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -744,14 +744,14 @@ func (mr *MockProviderClientMockRecorder) ValidateStateStoreConfig(ctx, in any, } // WriteStateBytes mocks base method. -func (m *MockProviderClient) WriteStateBytes(ctx context.Context, opts ...grpc.CallOption) (tfplugin6.Provider_WriteStateBytesClient, error) { +func (m *MockProviderClient) WriteStateBytes(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[tfplugin6.WriteStateBytes_RequestChunk, tfplugin6.WriteStateBytes_Response], error) { m.ctrl.T.Helper() varargs := []any{ctx} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "WriteStateBytes", varargs...) - ret0, _ := ret[0].(tfplugin6.Provider_WriteStateBytesClient) + ret0, _ := ret[0].(grpc.ClientStreamingClient[tfplugin6.WriteStateBytes_RequestChunk, tfplugin6.WriteStateBytes_Response]) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -764,31 +764,31 @@ func (mr *MockProviderClientMockRecorder) WriteStateBytes(ctx any, opts ...any) } // MockProvider_InvokeActionClient is a mock of Provider_InvokeActionClient interface. -type MockProvider_InvokeActionClient struct { +type MockProvider_InvokeActionClient[Res any] struct { ctrl *gomock.Controller - recorder *MockProvider_InvokeActionClientMockRecorder + recorder *MockProvider_InvokeActionClientMockRecorder[Res] isgomock struct{} } // MockProvider_InvokeActionClientMockRecorder is the mock recorder for MockProvider_InvokeActionClient. -type MockProvider_InvokeActionClientMockRecorder struct { - mock *MockProvider_InvokeActionClient +type MockProvider_InvokeActionClientMockRecorder[Res any] struct { + mock *MockProvider_InvokeActionClient[Res] } // NewMockProvider_InvokeActionClient creates a new mock instance. -func NewMockProvider_InvokeActionClient(ctrl *gomock.Controller) *MockProvider_InvokeActionClient { - mock := &MockProvider_InvokeActionClient{ctrl: ctrl} - mock.recorder = &MockProvider_InvokeActionClientMockRecorder{mock} +func NewMockProvider_InvokeActionClient[Res any](ctrl *gomock.Controller) *MockProvider_InvokeActionClient[Res] { + mock := &MockProvider_InvokeActionClient[Res]{ctrl: ctrl} + mock.recorder = &MockProvider_InvokeActionClientMockRecorder[Res]{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockProvider_InvokeActionClient) EXPECT() *MockProvider_InvokeActionClientMockRecorder { +func (m *MockProvider_InvokeActionClient[Res]) EXPECT() *MockProvider_InvokeActionClientMockRecorder[Res] { return m.recorder } // CloseSend mocks base method. -func (m *MockProvider_InvokeActionClient) CloseSend() error { +func (m *MockProvider_InvokeActionClient[Res]) CloseSend() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseSend") ret0, _ := ret[0].(error) @@ -796,13 +796,13 @@ func (m *MockProvider_InvokeActionClient) CloseSend() error { } // CloseSend indicates an expected call of CloseSend. -func (mr *MockProvider_InvokeActionClientMockRecorder) CloseSend() *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) CloseSend() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).CloseSend)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).CloseSend)) } // Context mocks base method. -func (m *MockProvider_InvokeActionClient) Context() context.Context { +func (m *MockProvider_InvokeActionClient[Res]) Context() context.Context { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) @@ -810,13 +810,13 @@ func (m *MockProvider_InvokeActionClient) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockProvider_InvokeActionClientMockRecorder) Context() *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Context() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).Context)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Context)) } // Header mocks base method. -func (m *MockProvider_InvokeActionClient) Header() (metadata.MD, error) { +func (m *MockProvider_InvokeActionClient[Res]) Header() (metadata.MD, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Header") ret0, _ := ret[0].(metadata.MD) @@ -825,13 +825,13 @@ func (m *MockProvider_InvokeActionClient) Header() (metadata.MD, error) { } // Header indicates an expected call of Header. -func (mr *MockProvider_InvokeActionClientMockRecorder) Header() *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Header() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).Header)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Header)) } // Recv mocks base method. -func (m *MockProvider_InvokeActionClient) Recv() (*tfplugin6.InvokeAction_Event, error) { +func (m *MockProvider_InvokeActionClient[Res]) Recv() (*tfplugin6.InvokeAction_Event, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Recv") ret0, _ := ret[0].(*tfplugin6.InvokeAction_Event) @@ -840,13 +840,13 @@ func (m *MockProvider_InvokeActionClient) Recv() (*tfplugin6.InvokeAction_Event, } // Recv indicates an expected call of Recv. -func (mr *MockProvider_InvokeActionClientMockRecorder) Recv() *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Recv() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).Recv)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Recv)) } // RecvMsg mocks base method. -func (m_2 *MockProvider_InvokeActionClient) RecvMsg(m any) error { +func (m_2 *MockProvider_InvokeActionClient[Res]) RecvMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "RecvMsg", m) ret0, _ := ret[0].(error) @@ -854,13 +854,13 @@ func (m_2 *MockProvider_InvokeActionClient) RecvMsg(m any) error { } // RecvMsg indicates an expected call of RecvMsg. -func (mr *MockProvider_InvokeActionClientMockRecorder) RecvMsg(m any) *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) RecvMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).RecvMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).RecvMsg), m) } // SendMsg mocks base method. -func (m_2 *MockProvider_InvokeActionClient) SendMsg(m any) error { +func (m_2 *MockProvider_InvokeActionClient[Res]) SendMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "SendMsg", m) ret0, _ := ret[0].(error) @@ -868,13 +868,13 @@ func (m_2 *MockProvider_InvokeActionClient) SendMsg(m any) error { } // SendMsg indicates an expected call of SendMsg. -func (mr *MockProvider_InvokeActionClientMockRecorder) SendMsg(m any) *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) SendMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).SendMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).SendMsg), m) } // Trailer mocks base method. -func (m *MockProvider_InvokeActionClient) Trailer() metadata.MD { +func (m *MockProvider_InvokeActionClient[Res]) Trailer() metadata.MD { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Trailer") ret0, _ := ret[0].(metadata.MD) @@ -882,37 +882,37 @@ func (m *MockProvider_InvokeActionClient) Trailer() metadata.MD { } // Trailer indicates an expected call of Trailer. -func (mr *MockProvider_InvokeActionClientMockRecorder) Trailer() *gomock.Call { +func (mr *MockProvider_InvokeActionClientMockRecorder[Res]) Trailer() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvider_InvokeActionClient)(nil).Trailer)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvider_InvokeActionClient[Res])(nil).Trailer)) } // MockProvider_ReadStateBytesClient is a mock of Provider_ReadStateBytesClient interface. -type MockProvider_ReadStateBytesClient struct { +type MockProvider_ReadStateBytesClient[Res any] struct { ctrl *gomock.Controller - recorder *MockProvider_ReadStateBytesClientMockRecorder + recorder *MockProvider_ReadStateBytesClientMockRecorder[Res] isgomock struct{} } // MockProvider_ReadStateBytesClientMockRecorder is the mock recorder for MockProvider_ReadStateBytesClient. -type MockProvider_ReadStateBytesClientMockRecorder struct { - mock *MockProvider_ReadStateBytesClient +type MockProvider_ReadStateBytesClientMockRecorder[Res any] struct { + mock *MockProvider_ReadStateBytesClient[Res] } // NewMockProvider_ReadStateBytesClient creates a new mock instance. -func NewMockProvider_ReadStateBytesClient(ctrl *gomock.Controller) *MockProvider_ReadStateBytesClient { - mock := &MockProvider_ReadStateBytesClient{ctrl: ctrl} - mock.recorder = &MockProvider_ReadStateBytesClientMockRecorder{mock} +func NewMockProvider_ReadStateBytesClient[Res any](ctrl *gomock.Controller) *MockProvider_ReadStateBytesClient[Res] { + mock := &MockProvider_ReadStateBytesClient[Res]{ctrl: ctrl} + mock.recorder = &MockProvider_ReadStateBytesClientMockRecorder[Res]{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockProvider_ReadStateBytesClient) EXPECT() *MockProvider_ReadStateBytesClientMockRecorder { +func (m *MockProvider_ReadStateBytesClient[Res]) EXPECT() *MockProvider_ReadStateBytesClientMockRecorder[Res] { return m.recorder } // CloseSend mocks base method. -func (m *MockProvider_ReadStateBytesClient) CloseSend() error { +func (m *MockProvider_ReadStateBytesClient[Res]) CloseSend() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseSend") ret0, _ := ret[0].(error) @@ -920,13 +920,13 @@ func (m *MockProvider_ReadStateBytesClient) CloseSend() error { } // CloseSend indicates an expected call of CloseSend. -func (mr *MockProvider_ReadStateBytesClientMockRecorder) CloseSend() *gomock.Call { +func (mr *MockProvider_ReadStateBytesClientMockRecorder[Res]) CloseSend() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvider_ReadStateBytesClient)(nil).CloseSend)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvider_ReadStateBytesClient[Res])(nil).CloseSend)) } // Context mocks base method. -func (m *MockProvider_ReadStateBytesClient) Context() context.Context { +func (m *MockProvider_ReadStateBytesClient[Res]) Context() context.Context { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) @@ -934,13 +934,13 @@ func (m *MockProvider_ReadStateBytesClient) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockProvider_ReadStateBytesClientMockRecorder) Context() *gomock.Call { +func (mr *MockProvider_ReadStateBytesClientMockRecorder[Res]) Context() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvider_ReadStateBytesClient)(nil).Context)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvider_ReadStateBytesClient[Res])(nil).Context)) } // Header mocks base method. -func (m *MockProvider_ReadStateBytesClient) Header() (metadata.MD, error) { +func (m *MockProvider_ReadStateBytesClient[Res]) Header() (metadata.MD, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Header") ret0, _ := ret[0].(metadata.MD) @@ -949,13 +949,13 @@ func (m *MockProvider_ReadStateBytesClient) Header() (metadata.MD, error) { } // Header indicates an expected call of Header. -func (mr *MockProvider_ReadStateBytesClientMockRecorder) Header() *gomock.Call { +func (mr *MockProvider_ReadStateBytesClientMockRecorder[Res]) Header() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvider_ReadStateBytesClient)(nil).Header)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvider_ReadStateBytesClient[Res])(nil).Header)) } // Recv mocks base method. -func (m *MockProvider_ReadStateBytesClient) Recv() (*tfplugin6.ReadStateBytes_Response, error) { +func (m *MockProvider_ReadStateBytesClient[Res]) Recv() (*tfplugin6.ReadStateBytes_Response, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Recv") ret0, _ := ret[0].(*tfplugin6.ReadStateBytes_Response) @@ -964,13 +964,13 @@ func (m *MockProvider_ReadStateBytesClient) Recv() (*tfplugin6.ReadStateBytes_Re } // Recv indicates an expected call of Recv. -func (mr *MockProvider_ReadStateBytesClientMockRecorder) Recv() *gomock.Call { +func (mr *MockProvider_ReadStateBytesClientMockRecorder[Res]) Recv() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProvider_ReadStateBytesClient)(nil).Recv)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockProvider_ReadStateBytesClient[Res])(nil).Recv)) } // RecvMsg mocks base method. -func (m_2 *MockProvider_ReadStateBytesClient) RecvMsg(m any) error { +func (m_2 *MockProvider_ReadStateBytesClient[Res]) RecvMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "RecvMsg", m) ret0, _ := ret[0].(error) @@ -978,13 +978,13 @@ func (m_2 *MockProvider_ReadStateBytesClient) RecvMsg(m any) error { } // RecvMsg indicates an expected call of RecvMsg. -func (mr *MockProvider_ReadStateBytesClientMockRecorder) RecvMsg(m any) *gomock.Call { +func (mr *MockProvider_ReadStateBytesClientMockRecorder[Res]) RecvMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvider_ReadStateBytesClient)(nil).RecvMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvider_ReadStateBytesClient[Res])(nil).RecvMsg), m) } // SendMsg mocks base method. -func (m_2 *MockProvider_ReadStateBytesClient) SendMsg(m any) error { +func (m_2 *MockProvider_ReadStateBytesClient[Res]) SendMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "SendMsg", m) ret0, _ := ret[0].(error) @@ -992,13 +992,13 @@ func (m_2 *MockProvider_ReadStateBytesClient) SendMsg(m any) error { } // SendMsg indicates an expected call of SendMsg. -func (mr *MockProvider_ReadStateBytesClientMockRecorder) SendMsg(m any) *gomock.Call { +func (mr *MockProvider_ReadStateBytesClientMockRecorder[Res]) SendMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvider_ReadStateBytesClient)(nil).SendMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvider_ReadStateBytesClient[Res])(nil).SendMsg), m) } // Trailer mocks base method. -func (m *MockProvider_ReadStateBytesClient) Trailer() metadata.MD { +func (m *MockProvider_ReadStateBytesClient[Res]) Trailer() metadata.MD { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Trailer") ret0, _ := ret[0].(metadata.MD) @@ -1006,37 +1006,37 @@ func (m *MockProvider_ReadStateBytesClient) Trailer() metadata.MD { } // Trailer indicates an expected call of Trailer. -func (mr *MockProvider_ReadStateBytesClientMockRecorder) Trailer() *gomock.Call { +func (mr *MockProvider_ReadStateBytesClientMockRecorder[Res]) Trailer() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvider_ReadStateBytesClient)(nil).Trailer)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvider_ReadStateBytesClient[Res])(nil).Trailer)) } // MockProvider_WriteStateBytesClient is a mock of Provider_WriteStateBytesClient interface. -type MockProvider_WriteStateBytesClient struct { +type MockProvider_WriteStateBytesClient[Req any, Res any] struct { ctrl *gomock.Controller - recorder *MockProvider_WriteStateBytesClientMockRecorder + recorder *MockProvider_WriteStateBytesClientMockRecorder[Req, Res] isgomock struct{} } // MockProvider_WriteStateBytesClientMockRecorder is the mock recorder for MockProvider_WriteStateBytesClient. -type MockProvider_WriteStateBytesClientMockRecorder struct { - mock *MockProvider_WriteStateBytesClient +type MockProvider_WriteStateBytesClientMockRecorder[Req any, Res any] struct { + mock *MockProvider_WriteStateBytesClient[Req, Res] } // NewMockProvider_WriteStateBytesClient creates a new mock instance. -func NewMockProvider_WriteStateBytesClient(ctrl *gomock.Controller) *MockProvider_WriteStateBytesClient { - mock := &MockProvider_WriteStateBytesClient{ctrl: ctrl} - mock.recorder = &MockProvider_WriteStateBytesClientMockRecorder{mock} +func NewMockProvider_WriteStateBytesClient[Req any, Res any](ctrl *gomock.Controller) *MockProvider_WriteStateBytesClient[Req, Res] { + mock := &MockProvider_WriteStateBytesClient[Req, Res]{ctrl: ctrl} + mock.recorder = &MockProvider_WriteStateBytesClientMockRecorder[Req, Res]{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockProvider_WriteStateBytesClient) EXPECT() *MockProvider_WriteStateBytesClientMockRecorder { +func (m *MockProvider_WriteStateBytesClient[Req, Res]) EXPECT() *MockProvider_WriteStateBytesClientMockRecorder[Req, Res] { return m.recorder } // CloseAndRecv mocks base method. -func (m *MockProvider_WriteStateBytesClient) CloseAndRecv() (*tfplugin6.WriteStateBytes_Response, error) { +func (m *MockProvider_WriteStateBytesClient[Req, Res]) CloseAndRecv() (*tfplugin6.WriteStateBytes_Response, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseAndRecv") ret0, _ := ret[0].(*tfplugin6.WriteStateBytes_Response) @@ -1045,13 +1045,13 @@ func (m *MockProvider_WriteStateBytesClient) CloseAndRecv() (*tfplugin6.WriteSta } // CloseAndRecv indicates an expected call of CloseAndRecv. -func (mr *MockProvider_WriteStateBytesClientMockRecorder) CloseAndRecv() *gomock.Call { +func (mr *MockProvider_WriteStateBytesClientMockRecorder[Req, Res]) CloseAndRecv() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseAndRecv", reflect.TypeOf((*MockProvider_WriteStateBytesClient)(nil).CloseAndRecv)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseAndRecv", reflect.TypeOf((*MockProvider_WriteStateBytesClient[Req, Res])(nil).CloseAndRecv)) } // CloseSend mocks base method. -func (m *MockProvider_WriteStateBytesClient) CloseSend() error { +func (m *MockProvider_WriteStateBytesClient[Req, Res]) CloseSend() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseSend") ret0, _ := ret[0].(error) @@ -1059,13 +1059,13 @@ func (m *MockProvider_WriteStateBytesClient) CloseSend() error { } // CloseSend indicates an expected call of CloseSend. -func (mr *MockProvider_WriteStateBytesClientMockRecorder) CloseSend() *gomock.Call { +func (mr *MockProvider_WriteStateBytesClientMockRecorder[Req, Res]) CloseSend() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvider_WriteStateBytesClient)(nil).CloseSend)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockProvider_WriteStateBytesClient[Req, Res])(nil).CloseSend)) } // Context mocks base method. -func (m *MockProvider_WriteStateBytesClient) Context() context.Context { +func (m *MockProvider_WriteStateBytesClient[Req, Res]) Context() context.Context { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) @@ -1073,13 +1073,13 @@ func (m *MockProvider_WriteStateBytesClient) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockProvider_WriteStateBytesClientMockRecorder) Context() *gomock.Call { +func (mr *MockProvider_WriteStateBytesClientMockRecorder[Req, Res]) Context() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvider_WriteStateBytesClient)(nil).Context)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockProvider_WriteStateBytesClient[Req, Res])(nil).Context)) } // Header mocks base method. -func (m *MockProvider_WriteStateBytesClient) Header() (metadata.MD, error) { +func (m *MockProvider_WriteStateBytesClient[Req, Res]) Header() (metadata.MD, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Header") ret0, _ := ret[0].(metadata.MD) @@ -1088,13 +1088,13 @@ func (m *MockProvider_WriteStateBytesClient) Header() (metadata.MD, error) { } // Header indicates an expected call of Header. -func (mr *MockProvider_WriteStateBytesClientMockRecorder) Header() *gomock.Call { +func (mr *MockProvider_WriteStateBytesClientMockRecorder[Req, Res]) Header() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvider_WriteStateBytesClient)(nil).Header)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockProvider_WriteStateBytesClient[Req, Res])(nil).Header)) } // RecvMsg mocks base method. -func (m_2 *MockProvider_WriteStateBytesClient) RecvMsg(m any) error { +func (m_2 *MockProvider_WriteStateBytesClient[Req, Res]) RecvMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "RecvMsg", m) ret0, _ := ret[0].(error) @@ -1102,13 +1102,13 @@ func (m_2 *MockProvider_WriteStateBytesClient) RecvMsg(m any) error { } // RecvMsg indicates an expected call of RecvMsg. -func (mr *MockProvider_WriteStateBytesClientMockRecorder) RecvMsg(m any) *gomock.Call { +func (mr *MockProvider_WriteStateBytesClientMockRecorder[Req, Res]) RecvMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvider_WriteStateBytesClient)(nil).RecvMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockProvider_WriteStateBytesClient[Req, Res])(nil).RecvMsg), m) } // Send mocks base method. -func (m *MockProvider_WriteStateBytesClient) Send(arg0 *tfplugin6.WriteStateBytes_RequestChunk) error { +func (m *MockProvider_WriteStateBytesClient[Req, Res]) Send(arg0 *tfplugin6.WriteStateBytes_RequestChunk) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Send", arg0) ret0, _ := ret[0].(error) @@ -1116,13 +1116,13 @@ func (m *MockProvider_WriteStateBytesClient) Send(arg0 *tfplugin6.WriteStateByte } // Send indicates an expected call of Send. -func (mr *MockProvider_WriteStateBytesClientMockRecorder) Send(arg0 any) *gomock.Call { +func (mr *MockProvider_WriteStateBytesClientMockRecorder[Req, Res]) Send(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockProvider_WriteStateBytesClient)(nil).Send), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockProvider_WriteStateBytesClient[Req, Res])(nil).Send), arg0) } // SendMsg mocks base method. -func (m_2 *MockProvider_WriteStateBytesClient) SendMsg(m any) error { +func (m_2 *MockProvider_WriteStateBytesClient[Req, Res]) SendMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "SendMsg", m) ret0, _ := ret[0].(error) @@ -1130,13 +1130,13 @@ func (m_2 *MockProvider_WriteStateBytesClient) SendMsg(m any) error { } // SendMsg indicates an expected call of SendMsg. -func (mr *MockProvider_WriteStateBytesClientMockRecorder) SendMsg(m any) *gomock.Call { +func (mr *MockProvider_WriteStateBytesClientMockRecorder[Req, Res]) SendMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvider_WriteStateBytesClient)(nil).SendMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockProvider_WriteStateBytesClient[Req, Res])(nil).SendMsg), m) } // Trailer mocks base method. -func (m *MockProvider_WriteStateBytesClient) Trailer() metadata.MD { +func (m *MockProvider_WriteStateBytesClient[Req, Res]) Trailer() metadata.MD { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Trailer") ret0, _ := ret[0].(metadata.MD) @@ -1144,7 +1144,7 @@ func (m *MockProvider_WriteStateBytesClient) Trailer() metadata.MD { } // Trailer indicates an expected call of Trailer. -func (mr *MockProvider_WriteStateBytesClientMockRecorder) Trailer() *gomock.Call { +func (mr *MockProvider_WriteStateBytesClientMockRecorder[Req, Res]) Trailer() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvider_WriteStateBytesClient)(nil).Trailer)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockProvider_WriteStateBytesClient[Req, Res])(nil).Trailer)) } diff --git a/internal/rpcapi/dynrpcserver/dependencies.go b/internal/rpcapi/dynrpcserver/dependencies.go index 5474381ad6..bbb2e80da8 100644 --- a/internal/rpcapi/dynrpcserver/dependencies.go +++ b/internal/rpcapi/dynrpcserver/dependencies.go @@ -8,6 +8,8 @@ import ( "context" "sync" + "google.golang.org/grpc" + dependencies "github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies" ) @@ -23,7 +25,7 @@ func NewDependenciesStub() *Dependencies { return &Dependencies{} } -func (s *Dependencies) BuildProviderPluginCache(a0 *dependencies.BuildProviderPluginCache_Request, a1 dependencies.Dependencies_BuildProviderPluginCacheServer) error { +func (s *Dependencies) BuildProviderPluginCache(a0 *dependencies.BuildProviderPluginCache_Request, a1 grpc.ServerStreamingServer[dependencies.BuildProviderPluginCache_Event]) error { impl, err := s.realRPCServer() if err != nil { return err diff --git a/internal/rpcapi/dynrpcserver/generator/main.go b/internal/rpcapi/dynrpcserver/generator/main.go index ff98a5072d..239474551f 100644 --- a/internal/rpcapi/dynrpcserver/generator/main.go +++ b/internal/rpcapi/dynrpcserver/generator/main.go @@ -29,6 +29,11 @@ var protobufPkgs = map[string]string{ "packages": "github.com/hashicorp/terraform/internal/rpcapi/terraform1/packages", } +var additionalImportsByName = map[string]string{ + "dependencies": `"google.golang.org/grpc"`, + "stacks": `"google.golang.org/grpc"`, +} + func main() { for shortName, pkgName := range protobufPkgs { cfg := &packages.Config{ @@ -118,10 +123,12 @@ func main() { "context" "sync" + %s + %s %q ) - `, shortName, pkg) + `, additionalImportsByName[shortName], shortName, pkg) fmt.Fprintf(&buf, "type %s struct {\n", baseName) fmt.Fprintf(&buf, "impl %s.%s\n", shortName, ifaceName) fmt.Fprintln(&buf, "mu sync.RWMutex") @@ -249,6 +256,10 @@ func typeRef(fullType, name, pkg string) string { // we typically expect to see in a server interface. This // might need extra rules if we step outside the design idiom // we've used for these services so far. + + // Identifies generic types from google.golang.org/grpc module with 1+ type arguments. + grpcGenericRe := regexp.MustCompile(`^google\.golang\.org\/grpc\.\w+\[[\w\.\/,\s]+\]`) + switch { case fullType == "context.Context" || fullType == "error": return fullType @@ -258,6 +269,32 @@ func typeRef(fullType, name, pkg string) string { return "*" + name + "." + fullType[len(pkg)+2:] case strings.HasPrefix(fullType, pkg+"."): return name + "." + fullType[len(pkg)+1:] + case grpcGenericRe.MatchString(fullType): + // Handling use of google.golang.org/grpc.Foobar[T...] generic types. + // Example 1: google.golang.org/grpc.ServerStreamingServer[github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies.BuildProviderPluginCache_Event] + // Example 2: google.golang.org/grpc.ClientStreamingServer[github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks.OpenStackPlan_RequestItem, github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks.OpenStackPlan_Response] + + // Pull grpc.Foobar out of fullType string + grpcGenericRe := regexp.MustCompile(`^google\.golang\.org\/(?Pgrpc\.\w+)\[github.com`) + i := grpcGenericRe.SubexpIndex("GrpcType") + grpcGeneric := grpcGenericRe.FindStringSubmatch(fullType)[i] + + // Get type argument(s) + typeRe := regexp.MustCompile(fmt.Sprintf(`%s\.\w+`, name)) + typeArgs := typeRe.FindAllString(fullType, -1) + + // Build string, with potential need for comma separation + // e.g. grpc.Foobar[pkg1.A, pkg2.B] + var buf strings.Builder + buf.WriteString(grpcGeneric + "[") + for i, arg := range typeArgs { + buf.WriteString(arg) + if i+1 != len(typeArgs) { + buf.WriteString(", ") + } + } + buf.WriteString("]") + return buf.String() default: log.Fatalf("don't know what to do with parameter type %s", fullType) return "" diff --git a/internal/rpcapi/dynrpcserver/stacks.go b/internal/rpcapi/dynrpcserver/stacks.go index c0fc256a74..a31e9a30b3 100644 --- a/internal/rpcapi/dynrpcserver/stacks.go +++ b/internal/rpcapi/dynrpcserver/stacks.go @@ -8,6 +8,8 @@ import ( "context" "sync" + "google.golang.org/grpc" + stacks "github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks" ) @@ -23,7 +25,7 @@ func NewStacksStub() *Stacks { return &Stacks{} } -func (s *Stacks) ApplyStackChanges(a0 *stacks.ApplyStackChanges_Request, a1 stacks.Stacks_ApplyStackChangesServer) error { +func (s *Stacks) ApplyStackChanges(a0 *stacks.ApplyStackChanges_Request, a1 grpc.ServerStreamingServer[stacks.ApplyStackChanges_Event]) error { impl, err := s.realRPCServer() if err != nil { return err @@ -87,7 +89,7 @@ func (s *Stacks) ListResourceIdentities(a0 context.Context, a1 *stacks.ListResou return impl.ListResourceIdentities(a0, a1) } -func (s *Stacks) MigrateTerraformState(a0 *stacks.MigrateTerraformState_Request, a1 stacks.Stacks_MigrateTerraformStateServer) error { +func (s *Stacks) MigrateTerraformState(a0 *stacks.MigrateTerraformState_Request, a1 grpc.ServerStreamingServer[stacks.MigrateTerraformState_Event]) error { impl, err := s.realRPCServer() if err != nil { return err @@ -95,7 +97,7 @@ func (s *Stacks) MigrateTerraformState(a0 *stacks.MigrateTerraformState_Request, return impl.MigrateTerraformState(a0, a1) } -func (s *Stacks) OpenPlan(a0 stacks.Stacks_OpenPlanServer) error { +func (s *Stacks) OpenPlan(a0 grpc.ClientStreamingServer[stacks.OpenStackPlan_RequestItem, stacks.OpenStackPlan_Response]) error { impl, err := s.realRPCServer() if err != nil { return err @@ -119,7 +121,7 @@ func (s *Stacks) OpenStackInspector(a0 context.Context, a1 *stacks.OpenStackInsp return impl.OpenStackInspector(a0, a1) } -func (s *Stacks) OpenState(a0 stacks.Stacks_OpenStateServer) error { +func (s *Stacks) OpenState(a0 grpc.ClientStreamingServer[stacks.OpenStackState_RequestItem, stacks.OpenStackState_Response]) error { impl, err := s.realRPCServer() if err != nil { return err @@ -135,7 +137,7 @@ func (s *Stacks) OpenTerraformState(a0 context.Context, a1 *stacks.OpenTerraform return impl.OpenTerraformState(a0, a1) } -func (s *Stacks) PlanStackChanges(a0 *stacks.PlanStackChanges_Request, a1 stacks.Stacks_PlanStackChangesServer) error { +func (s *Stacks) PlanStackChanges(a0 *stacks.PlanStackChanges_Request, a1 grpc.ServerStreamingServer[stacks.PlanStackChanges_Event]) error { impl, err := s.realRPCServer() if err != nil { return err diff --git a/internal/rpcapi/stacks_grpc_client_test.go b/internal/rpcapi/stacks_grpc_client_test.go index 0602a9c451..3fccb7d894 100644 --- a/internal/rpcapi/stacks_grpc_client_test.go +++ b/internal/rpcapi/stacks_grpc_client_test.go @@ -57,7 +57,7 @@ func mockDisco() *disco.Disco { return d } -func mockGRPStacksClient(t *testing.T, ctrl *gomock.Controller, client *mock_stacksproto1.MockCommandService_ExecuteClient, executeError error) *GRPCStacksClient { +func mockGRPStacksClient(t *testing.T, ctrl *gomock.Controller, client *mock_stacksproto1.MockCommandService_ExecuteClient[stacksproto1.CommandResponse], executeError error) *GRPCStacksClient { t.Helper() if client != nil && executeError != nil { @@ -100,7 +100,7 @@ func Test_GRPCStacksClient_ExecuteError(t *testing.T) { func Test_GRPCStacksClient_Execute_RecvError(t *testing.T) { ctrl := gomock.NewController(t) - executeClient := mock_stacksproto1.NewMockCommandService_ExecuteClient(ctrl) + executeClient := mock_stacksproto1.NewMockCommandService_ExecuteClient[stacksproto1.CommandResponse](ctrl) executeClient.EXPECT().Recv().Return(nil, errors.New(mockError)) gRPCClient := mockGRPStacksClient(t, ctrl, executeClient, nil) @@ -123,7 +123,7 @@ func Test_GRPCStacksClient_Execute_RecvError(t *testing.T) { func Test_GRPCStacksClient_Execute_HandleEOFError(t *testing.T) { ctrl := gomock.NewController(t) - executeClient := mock_stacksproto1.NewMockCommandService_ExecuteClient(ctrl) + executeClient := mock_stacksproto1.NewMockCommandService_ExecuteClient[stacksproto1.CommandResponse](ctrl) executeClient.EXPECT().Recv().Return(&stacksproto1.CommandResponse{ Data: &stacksproto1.CommandResponse_ExitCode{ ExitCode: 0, @@ -152,7 +152,7 @@ func Test_GRPCStacksClient_Execute_HandleEOFError(t *testing.T) { func Test_GRPCStacksClient_Execute_Invalid_Exit(t *testing.T) { ctrl := gomock.NewController(t) - executeClient := mock_stacksproto1.NewMockCommandService_ExecuteClient(ctrl) + executeClient := mock_stacksproto1.NewMockCommandService_ExecuteClient[stacksproto1.CommandResponse](ctrl) executeClient.EXPECT().Recv().Return( &stacksproto1.CommandResponse{ @@ -183,7 +183,7 @@ func Test_GRPCStacksClient_Execute_Invalid_Exit(t *testing.T) { func Test_GRPCStacksClient_Execute(t *testing.T) { ctrl := gomock.NewController(t) - executeClient := mock_stacksproto1.NewMockCommandService_ExecuteClient(ctrl) + executeClient := mock_stacksproto1.NewMockCommandService_ExecuteClient[stacksproto1.CommandResponse](ctrl) gomock.InOrder( executeClient.EXPECT().Recv().Return( diff --git a/internal/rpcapi/terraform1/dependencies/dependencies.pb.go b/internal/rpcapi/terraform1/dependencies/dependencies.pb.go index 4c4a987e44..e108317526 100644 --- a/internal/rpcapi/terraform1/dependencies/dependencies.pb.go +++ b/internal/rpcapi/terraform1/dependencies/dependencies.pb.go @@ -4,7 +4,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: dependencies.proto package dependencies diff --git a/internal/rpcapi/terraform1/dependencies/dependencies_grpc.pb.go b/internal/rpcapi/terraform1/dependencies/dependencies_grpc.pb.go index 086e086ce7..151d25407f 100644 --- a/internal/rpcapi/terraform1/dependencies/dependencies_grpc.pb.go +++ b/internal/rpcapi/terraform1/dependencies/dependencies_grpc.pb.go @@ -3,8 +3,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.3.0 -// - protoc v3.15.6 +// - protoc-gen-go-grpc v1.5.1 +// - protoc v5.29.3 // source: dependencies.proto package dependencies @@ -18,8 +18,8 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 const ( Dependencies_OpenSourceBundle_FullMethodName = "/terraform1.dependencies.Dependencies/OpenSourceBundle" @@ -75,7 +75,7 @@ type DependenciesClient interface { // provider selections to newer versions as a CLI user would do with // "terraform init -upgrade", because there would be no way to then // commit the updated locks to disk as a lock file. - BuildProviderPluginCache(ctx context.Context, in *BuildProviderPluginCache_Request, opts ...grpc.CallOption) (Dependencies_BuildProviderPluginCacheClient, error) + BuildProviderPluginCache(ctx context.Context, in *BuildProviderPluginCache_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[BuildProviderPluginCache_Event], error) // Opens an existing local filesystem directory as a provider plugin cache // directory, returning a plugin cache handle that can be used with other // RPC operations. @@ -110,8 +110,9 @@ func NewDependenciesClient(cc grpc.ClientConnInterface) DependenciesClient { } func (c *dependenciesClient) OpenSourceBundle(ctx context.Context, in *OpenSourceBundle_Request, opts ...grpc.CallOption) (*OpenSourceBundle_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(OpenSourceBundle_Response) - err := c.cc.Invoke(ctx, Dependencies_OpenSourceBundle_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_OpenSourceBundle_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -119,8 +120,9 @@ func (c *dependenciesClient) OpenSourceBundle(ctx context.Context, in *OpenSourc } func (c *dependenciesClient) CloseSourceBundle(ctx context.Context, in *CloseSourceBundle_Request, opts ...grpc.CallOption) (*CloseSourceBundle_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CloseSourceBundle_Response) - err := c.cc.Invoke(ctx, Dependencies_CloseSourceBundle_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_CloseSourceBundle_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -128,8 +130,9 @@ func (c *dependenciesClient) CloseSourceBundle(ctx context.Context, in *CloseSou } func (c *dependenciesClient) OpenDependencyLockFile(ctx context.Context, in *OpenDependencyLockFile_Request, opts ...grpc.CallOption) (*OpenDependencyLockFile_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(OpenDependencyLockFile_Response) - err := c.cc.Invoke(ctx, Dependencies_OpenDependencyLockFile_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_OpenDependencyLockFile_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -137,8 +140,9 @@ func (c *dependenciesClient) OpenDependencyLockFile(ctx context.Context, in *Ope } func (c *dependenciesClient) CreateDependencyLocks(ctx context.Context, in *CreateDependencyLocks_Request, opts ...grpc.CallOption) (*CreateDependencyLocks_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CreateDependencyLocks_Response) - err := c.cc.Invoke(ctx, Dependencies_CreateDependencyLocks_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_CreateDependencyLocks_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -146,8 +150,9 @@ func (c *dependenciesClient) CreateDependencyLocks(ctx context.Context, in *Crea } func (c *dependenciesClient) CloseDependencyLocks(ctx context.Context, in *CloseDependencyLocks_Request, opts ...grpc.CallOption) (*CloseDependencyLocks_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CloseDependencyLocks_Response) - err := c.cc.Invoke(ctx, Dependencies_CloseDependencyLocks_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_CloseDependencyLocks_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -155,20 +160,22 @@ func (c *dependenciesClient) CloseDependencyLocks(ctx context.Context, in *Close } func (c *dependenciesClient) GetLockedProviderDependencies(ctx context.Context, in *GetLockedProviderDependencies_Request, opts ...grpc.CallOption) (*GetLockedProviderDependencies_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetLockedProviderDependencies_Response) - err := c.cc.Invoke(ctx, Dependencies_GetLockedProviderDependencies_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_GetLockedProviderDependencies_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *dependenciesClient) BuildProviderPluginCache(ctx context.Context, in *BuildProviderPluginCache_Request, opts ...grpc.CallOption) (Dependencies_BuildProviderPluginCacheClient, error) { - stream, err := c.cc.NewStream(ctx, &Dependencies_ServiceDesc.Streams[0], Dependencies_BuildProviderPluginCache_FullMethodName, opts...) +func (c *dependenciesClient) BuildProviderPluginCache(ctx context.Context, in *BuildProviderPluginCache_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[BuildProviderPluginCache_Event], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Dependencies_ServiceDesc.Streams[0], Dependencies_BuildProviderPluginCache_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &dependenciesBuildProviderPluginCacheClient{stream} + x := &grpc.GenericClientStream[BuildProviderPluginCache_Request, BuildProviderPluginCache_Event]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -178,26 +185,13 @@ func (c *dependenciesClient) BuildProviderPluginCache(ctx context.Context, in *B return x, nil } -type Dependencies_BuildProviderPluginCacheClient interface { - Recv() (*BuildProviderPluginCache_Event, error) - grpc.ClientStream -} - -type dependenciesBuildProviderPluginCacheClient struct { - grpc.ClientStream -} - -func (x *dependenciesBuildProviderPluginCacheClient) Recv() (*BuildProviderPluginCache_Event, error) { - m := new(BuildProviderPluginCache_Event) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dependencies_BuildProviderPluginCacheClient = grpc.ServerStreamingClient[BuildProviderPluginCache_Event] func (c *dependenciesClient) OpenProviderPluginCache(ctx context.Context, in *OpenProviderPluginCache_Request, opts ...grpc.CallOption) (*OpenProviderPluginCache_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(OpenProviderPluginCache_Response) - err := c.cc.Invoke(ctx, Dependencies_OpenProviderPluginCache_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_OpenProviderPluginCache_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -205,8 +199,9 @@ func (c *dependenciesClient) OpenProviderPluginCache(ctx context.Context, in *Op } func (c *dependenciesClient) CloseProviderPluginCache(ctx context.Context, in *CloseProviderPluginCache_Request, opts ...grpc.CallOption) (*CloseProviderPluginCache_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CloseProviderPluginCache_Response) - err := c.cc.Invoke(ctx, Dependencies_CloseProviderPluginCache_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_CloseProviderPluginCache_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -214,8 +209,9 @@ func (c *dependenciesClient) CloseProviderPluginCache(ctx context.Context, in *C } func (c *dependenciesClient) GetCachedProviders(ctx context.Context, in *GetCachedProviders_Request, opts ...grpc.CallOption) (*GetCachedProviders_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetCachedProviders_Response) - err := c.cc.Invoke(ctx, Dependencies_GetCachedProviders_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_GetCachedProviders_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -223,8 +219,9 @@ func (c *dependenciesClient) GetCachedProviders(ctx context.Context, in *GetCach } func (c *dependenciesClient) GetBuiltInProviders(ctx context.Context, in *GetBuiltInProviders_Request, opts ...grpc.CallOption) (*GetBuiltInProviders_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetBuiltInProviders_Response) - err := c.cc.Invoke(ctx, Dependencies_GetBuiltInProviders_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_GetBuiltInProviders_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -232,8 +229,9 @@ func (c *dependenciesClient) GetBuiltInProviders(ctx context.Context, in *GetBui } func (c *dependenciesClient) GetProviderSchema(ctx context.Context, in *GetProviderSchema_Request, opts ...grpc.CallOption) (*GetProviderSchema_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetProviderSchema_Response) - err := c.cc.Invoke(ctx, Dependencies_GetProviderSchema_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Dependencies_GetProviderSchema_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -242,7 +240,7 @@ func (c *dependenciesClient) GetProviderSchema(ctx context.Context, in *GetProvi // DependenciesServer is the server API for Dependencies service. // All implementations must embed UnimplementedDependenciesServer -// for forward compatibility +// for forward compatibility. type DependenciesServer interface { // Opens a source bundle that was already extracted into the filesystem // somewhere, returning an opaque source bundle handle that can be used for @@ -279,7 +277,7 @@ type DependenciesServer interface { // provider selections to newer versions as a CLI user would do with // "terraform init -upgrade", because there would be no way to then // commit the updated locks to disk as a lock file. - BuildProviderPluginCache(*BuildProviderPluginCache_Request, Dependencies_BuildProviderPluginCacheServer) error + BuildProviderPluginCache(*BuildProviderPluginCache_Request, grpc.ServerStreamingServer[BuildProviderPluginCache_Event]) error // Opens an existing local filesystem directory as a provider plugin cache // directory, returning a plugin cache handle that can be used with other // RPC operations. @@ -306,9 +304,12 @@ type DependenciesServer interface { mustEmbedUnimplementedDependenciesServer() } -// UnimplementedDependenciesServer must be embedded to have forward compatible implementations. -type UnimplementedDependenciesServer struct { -} +// UnimplementedDependenciesServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedDependenciesServer struct{} func (UnimplementedDependenciesServer) OpenSourceBundle(context.Context, *OpenSourceBundle_Request) (*OpenSourceBundle_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method OpenSourceBundle not implemented") @@ -328,7 +329,7 @@ func (UnimplementedDependenciesServer) CloseDependencyLocks(context.Context, *Cl func (UnimplementedDependenciesServer) GetLockedProviderDependencies(context.Context, *GetLockedProviderDependencies_Request) (*GetLockedProviderDependencies_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method GetLockedProviderDependencies not implemented") } -func (UnimplementedDependenciesServer) BuildProviderPluginCache(*BuildProviderPluginCache_Request, Dependencies_BuildProviderPluginCacheServer) error { +func (UnimplementedDependenciesServer) BuildProviderPluginCache(*BuildProviderPluginCache_Request, grpc.ServerStreamingServer[BuildProviderPluginCache_Event]) error { return status.Errorf(codes.Unimplemented, "method BuildProviderPluginCache not implemented") } func (UnimplementedDependenciesServer) OpenProviderPluginCache(context.Context, *OpenProviderPluginCache_Request) (*OpenProviderPluginCache_Response, error) { @@ -347,6 +348,7 @@ func (UnimplementedDependenciesServer) GetProviderSchema(context.Context, *GetPr return nil, status.Errorf(codes.Unimplemented, "method GetProviderSchema not implemented") } func (UnimplementedDependenciesServer) mustEmbedUnimplementedDependenciesServer() {} +func (UnimplementedDependenciesServer) testEmbeddedByValue() {} // UnsafeDependenciesServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to DependenciesServer will @@ -356,6 +358,13 @@ type UnsafeDependenciesServer interface { } func RegisterDependenciesServer(s grpc.ServiceRegistrar, srv DependenciesServer) { + // If the following call pancis, it indicates UnimplementedDependenciesServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&Dependencies_ServiceDesc, srv) } @@ -472,21 +481,11 @@ func _Dependencies_BuildProviderPluginCache_Handler(srv interface{}, stream grpc if err := stream.RecvMsg(m); err != nil { return err } - return srv.(DependenciesServer).BuildProviderPluginCache(m, &dependenciesBuildProviderPluginCacheServer{stream}) -} - -type Dependencies_BuildProviderPluginCacheServer interface { - Send(*BuildProviderPluginCache_Event) error - grpc.ServerStream + return srv.(DependenciesServer).BuildProviderPluginCache(m, &grpc.GenericServerStream[BuildProviderPluginCache_Request, BuildProviderPluginCache_Event]{ServerStream: stream}) } -type dependenciesBuildProviderPluginCacheServer struct { - grpc.ServerStream -} - -func (x *dependenciesBuildProviderPluginCacheServer) Send(m *BuildProviderPluginCache_Event) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Dependencies_BuildProviderPluginCacheServer = grpc.ServerStreamingServer[BuildProviderPluginCache_Event] func _Dependencies_OpenProviderPluginCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(OpenProviderPluginCache_Request) diff --git a/internal/rpcapi/terraform1/packages/packages.pb.go b/internal/rpcapi/terraform1/packages/packages.pb.go index fcd3720550..228333455f 100644 --- a/internal/rpcapi/terraform1/packages/packages.pb.go +++ b/internal/rpcapi/terraform1/packages/packages.pb.go @@ -4,7 +4,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: packages.proto package packages diff --git a/internal/rpcapi/terraform1/packages/packages_grpc.pb.go b/internal/rpcapi/terraform1/packages/packages_grpc.pb.go index 963abe748b..8baf5024bd 100644 --- a/internal/rpcapi/terraform1/packages/packages_grpc.pb.go +++ b/internal/rpcapi/terraform1/packages/packages_grpc.pb.go @@ -3,8 +3,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.3.0 -// - protoc v3.15.6 +// - protoc-gen-go-grpc v1.5.1 +// - protoc v5.29.3 // source: packages.proto package packages @@ -18,8 +18,8 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 const ( Packages_ProviderPackageVersions_FullMethodName = "/terraform1.packages.Packages/ProviderPackageVersions" @@ -32,6 +32,18 @@ const ( // PackagesClient is the client API for Packages service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// The Packages service provides helper functions for retrieving Terraform +// modules and providers. +// +// Unlike the Dependencies service, the Packages service does not require any +// existing configuration or sourcebundle to function. +// +// This service is designed for use with a specific command-line tool, and is +// +// currently experimental. It can be changed and removed without warning, even +// +// in patch releases. type PackagesClient interface { ProviderPackageVersions(ctx context.Context, in *ProviderPackageVersions_Request, opts ...grpc.CallOption) (*ProviderPackageVersions_Response, error) FetchProviderPackage(ctx context.Context, in *FetchProviderPackage_Request, opts ...grpc.CallOption) (*FetchProviderPackage_Response, error) @@ -49,8 +61,9 @@ func NewPackagesClient(cc grpc.ClientConnInterface) PackagesClient { } func (c *packagesClient) ProviderPackageVersions(ctx context.Context, in *ProviderPackageVersions_Request, opts ...grpc.CallOption) (*ProviderPackageVersions_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ProviderPackageVersions_Response) - err := c.cc.Invoke(ctx, Packages_ProviderPackageVersions_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Packages_ProviderPackageVersions_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -58,8 +71,9 @@ func (c *packagesClient) ProviderPackageVersions(ctx context.Context, in *Provid } func (c *packagesClient) FetchProviderPackage(ctx context.Context, in *FetchProviderPackage_Request, opts ...grpc.CallOption) (*FetchProviderPackage_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(FetchProviderPackage_Response) - err := c.cc.Invoke(ctx, Packages_FetchProviderPackage_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Packages_FetchProviderPackage_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -67,8 +81,9 @@ func (c *packagesClient) FetchProviderPackage(ctx context.Context, in *FetchProv } func (c *packagesClient) ModulePackageVersions(ctx context.Context, in *ModulePackageVersions_Request, opts ...grpc.CallOption) (*ModulePackageVersions_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ModulePackageVersions_Response) - err := c.cc.Invoke(ctx, Packages_ModulePackageVersions_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Packages_ModulePackageVersions_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -76,8 +91,9 @@ func (c *packagesClient) ModulePackageVersions(ctx context.Context, in *ModulePa } func (c *packagesClient) ModulePackageSourceAddr(ctx context.Context, in *ModulePackageSourceAddr_Request, opts ...grpc.CallOption) (*ModulePackageSourceAddr_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ModulePackageSourceAddr_Response) - err := c.cc.Invoke(ctx, Packages_ModulePackageSourceAddr_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Packages_ModulePackageSourceAddr_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -85,8 +101,9 @@ func (c *packagesClient) ModulePackageSourceAddr(ctx context.Context, in *Module } func (c *packagesClient) FetchModulePackage(ctx context.Context, in *FetchModulePackage_Request, opts ...grpc.CallOption) (*FetchModulePackage_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(FetchModulePackage_Response) - err := c.cc.Invoke(ctx, Packages_FetchModulePackage_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Packages_FetchModulePackage_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -95,7 +112,19 @@ func (c *packagesClient) FetchModulePackage(ctx context.Context, in *FetchModule // PackagesServer is the server API for Packages service. // All implementations must embed UnimplementedPackagesServer -// for forward compatibility +// for forward compatibility. +// +// The Packages service provides helper functions for retrieving Terraform +// modules and providers. +// +// Unlike the Dependencies service, the Packages service does not require any +// existing configuration or sourcebundle to function. +// +// This service is designed for use with a specific command-line tool, and is +// +// currently experimental. It can be changed and removed without warning, even +// +// in patch releases. type PackagesServer interface { ProviderPackageVersions(context.Context, *ProviderPackageVersions_Request) (*ProviderPackageVersions_Response, error) FetchProviderPackage(context.Context, *FetchProviderPackage_Request) (*FetchProviderPackage_Response, error) @@ -105,9 +134,12 @@ type PackagesServer interface { mustEmbedUnimplementedPackagesServer() } -// UnimplementedPackagesServer must be embedded to have forward compatible implementations. -type UnimplementedPackagesServer struct { -} +// UnimplementedPackagesServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedPackagesServer struct{} func (UnimplementedPackagesServer) ProviderPackageVersions(context.Context, *ProviderPackageVersions_Request) (*ProviderPackageVersions_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method ProviderPackageVersions not implemented") @@ -125,6 +157,7 @@ func (UnimplementedPackagesServer) FetchModulePackage(context.Context, *FetchMod return nil, status.Errorf(codes.Unimplemented, "method FetchModulePackage not implemented") } func (UnimplementedPackagesServer) mustEmbedUnimplementedPackagesServer() {} +func (UnimplementedPackagesServer) testEmbeddedByValue() {} // UnsafePackagesServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to PackagesServer will @@ -134,6 +167,13 @@ type UnsafePackagesServer interface { } func RegisterPackagesServer(s grpc.ServiceRegistrar, srv PackagesServer) { + // If the following call pancis, it indicates UnimplementedPackagesServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&Packages_ServiceDesc, srv) } diff --git a/internal/rpcapi/terraform1/setup/setup.pb.go b/internal/rpcapi/terraform1/setup/setup.pb.go index 0500aa9f42..7c9577486d 100644 --- a/internal/rpcapi/terraform1/setup/setup.pb.go +++ b/internal/rpcapi/terraform1/setup/setup.pb.go @@ -4,7 +4,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: setup.proto package setup diff --git a/internal/rpcapi/terraform1/setup/setup_grpc.pb.go b/internal/rpcapi/terraform1/setup/setup_grpc.pb.go index 52370f18b6..cafc4a0707 100644 --- a/internal/rpcapi/terraform1/setup/setup_grpc.pb.go +++ b/internal/rpcapi/terraform1/setup/setup_grpc.pb.go @@ -3,8 +3,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.3.0 -// - protoc v3.15.6 +// - protoc-gen-go-grpc v1.5.1 +// - protoc v5.29.3 // source: setup.proto package setup @@ -18,8 +18,8 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 const ( Setup_Handshake_FullMethodName = "/terraform1.setup.Setup/Handshake" @@ -50,8 +50,9 @@ func NewSetupClient(cc grpc.ClientConnInterface) SetupClient { } func (c *setupClient) Handshake(ctx context.Context, in *Handshake_Request, opts ...grpc.CallOption) (*Handshake_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(Handshake_Response) - err := c.cc.Invoke(ctx, Setup_Handshake_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Setup_Handshake_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -59,8 +60,9 @@ func (c *setupClient) Handshake(ctx context.Context, in *Handshake_Request, opts } func (c *setupClient) Stop(ctx context.Context, in *Stop_Request, opts ...grpc.CallOption) (*Stop_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(Stop_Response) - err := c.cc.Invoke(ctx, Setup_Stop_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Setup_Stop_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -69,7 +71,7 @@ func (c *setupClient) Stop(ctx context.Context, in *Stop_Request, opts ...grpc.C // SetupServer is the server API for Setup service. // All implementations must embed UnimplementedSetupServer -// for forward compatibility +// for forward compatibility. type SetupServer interface { // Clients must call Handshake before any other function of any other // service, to complete the capability negotiation step that may @@ -83,9 +85,12 @@ type SetupServer interface { mustEmbedUnimplementedSetupServer() } -// UnimplementedSetupServer must be embedded to have forward compatible implementations. -type UnimplementedSetupServer struct { -} +// UnimplementedSetupServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedSetupServer struct{} func (UnimplementedSetupServer) Handshake(context.Context, *Handshake_Request) (*Handshake_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method Handshake not implemented") @@ -94,6 +99,7 @@ func (UnimplementedSetupServer) Stop(context.Context, *Stop_Request) (*Stop_Resp return nil, status.Errorf(codes.Unimplemented, "method Stop not implemented") } func (UnimplementedSetupServer) mustEmbedUnimplementedSetupServer() {} +func (UnimplementedSetupServer) testEmbeddedByValue() {} // UnsafeSetupServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to SetupServer will @@ -103,6 +109,13 @@ type UnsafeSetupServer interface { } func RegisterSetupServer(s grpc.ServiceRegistrar, srv SetupServer) { + // If the following call pancis, it indicates UnimplementedSetupServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&Setup_ServiceDesc, srv) } diff --git a/internal/rpcapi/terraform1/stacks/stacks.pb.go b/internal/rpcapi/terraform1/stacks/stacks.pb.go index 8ec49f6ace..d13e3fb17b 100644 --- a/internal/rpcapi/terraform1/stacks/stacks.pb.go +++ b/internal/rpcapi/terraform1/stacks/stacks.pb.go @@ -4,7 +4,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: stacks.proto package stacks diff --git a/internal/rpcapi/terraform1/stacks/stacks_grpc.pb.go b/internal/rpcapi/terraform1/stacks/stacks_grpc.pb.go index dd07dd4cfd..cee219f044 100644 --- a/internal/rpcapi/terraform1/stacks/stacks_grpc.pb.go +++ b/internal/rpcapi/terraform1/stacks/stacks_grpc.pb.go @@ -3,8 +3,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.3.0 -// - protoc v3.15.6 +// - protoc-gen-go-grpc v1.5.1 +// - protoc v5.29.3 // source: stacks.proto package stacks @@ -18,8 +18,8 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 const ( Stacks_OpenStackConfiguration_FullMethodName = "/terraform1.stacks.Stacks/OpenStackConfiguration" @@ -58,20 +58,20 @@ type StacksClient interface { FindStackConfigurationComponents(ctx context.Context, in *FindStackConfigurationComponents_Request, opts ...grpc.CallOption) (*FindStackConfigurationComponents_Response, error) // Load a stack state by sending a stream of raw state objects that were // streamed from a previous ApplyStackChanges response. - OpenState(ctx context.Context, opts ...grpc.CallOption) (Stacks_OpenStateClient, error) + OpenState(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[OpenStackState_RequestItem, OpenStackState_Response], error) // Close a stack state handle, discarding the associated state. CloseState(ctx context.Context, in *CloseStackState_Request, opts ...grpc.CallOption) (*CloseStackState_Response, error) // Calculate a desired state from the given configuration and compare it // with the current state to propose a set of changes to converge the // current state with the desired state, at least in part. - PlanStackChanges(ctx context.Context, in *PlanStackChanges_Request, opts ...grpc.CallOption) (Stacks_PlanStackChangesClient, error) + PlanStackChanges(ctx context.Context, in *PlanStackChanges_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[PlanStackChanges_Event], error) // Load a previously-created plan by sending a stream of raw change objects // that were streamed from a previous PlanStackChanges response. - OpenPlan(ctx context.Context, opts ...grpc.CallOption) (Stacks_OpenPlanClient, error) + OpenPlan(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[OpenStackPlan_RequestItem, OpenStackPlan_Response], error) // Close a saved plan handle, discarding the associated saved plan. ClosePlan(ctx context.Context, in *CloseStackPlan_Request, opts ...grpc.CallOption) (*CloseStackPlan_Response, error) // Execute the changes proposed by an earlier call to PlanStackChanges. - ApplyStackChanges(ctx context.Context, in *ApplyStackChanges_Request, opts ...grpc.CallOption) (Stacks_ApplyStackChangesClient, error) + ApplyStackChanges(ctx context.Context, in *ApplyStackChanges_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ApplyStackChanges_Event], error) // OpenStackInspector creates a stack inspector handle that can be used // with subsequent calls to the "Inspect"-prefixed functions. OpenStackInspector(ctx context.Context, in *OpenStackInspector_Request, opts ...grpc.CallOption) (*OpenStackInspector_Response, error) @@ -86,7 +86,7 @@ type StacksClient interface { CloseTerraformState(ctx context.Context, in *CloseTerraformState_Request, opts ...grpc.CallOption) (*CloseTerraformState_Response, error) // MigrateTerraformState migrates a Terraform state into Stacks state using // a mapping of addresses. - MigrateTerraformState(ctx context.Context, in *MigrateTerraformState_Request, opts ...grpc.CallOption) (Stacks_MigrateTerraformStateClient, error) + MigrateTerraformState(ctx context.Context, in *MigrateTerraformState_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[MigrateTerraformState_Event], error) // ListResourceIdentities lists the identities of all resources in a stack. ListResourceIdentities(ctx context.Context, in *ListResourceIdentities_Request, opts ...grpc.CallOption) (*ListResourceIdentities_Response, error) } @@ -100,8 +100,9 @@ func NewStacksClient(cc grpc.ClientConnInterface) StacksClient { } func (c *stacksClient) OpenStackConfiguration(ctx context.Context, in *OpenStackConfiguration_Request, opts ...grpc.CallOption) (*OpenStackConfiguration_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(OpenStackConfiguration_Response) - err := c.cc.Invoke(ctx, Stacks_OpenStackConfiguration_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_OpenStackConfiguration_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -109,8 +110,9 @@ func (c *stacksClient) OpenStackConfiguration(ctx context.Context, in *OpenStack } func (c *stacksClient) CloseStackConfiguration(ctx context.Context, in *CloseStackConfiguration_Request, opts ...grpc.CallOption) (*CloseStackConfiguration_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CloseStackConfiguration_Response) - err := c.cc.Invoke(ctx, Stacks_CloseStackConfiguration_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_CloseStackConfiguration_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -118,8 +120,9 @@ func (c *stacksClient) CloseStackConfiguration(ctx context.Context, in *CloseSta } func (c *stacksClient) ValidateStackConfiguration(ctx context.Context, in *ValidateStackConfiguration_Request, opts ...grpc.CallOption) (*ValidateStackConfiguration_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateStackConfiguration_Response) - err := c.cc.Invoke(ctx, Stacks_ValidateStackConfiguration_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_ValidateStackConfiguration_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -127,63 +130,45 @@ func (c *stacksClient) ValidateStackConfiguration(ctx context.Context, in *Valid } func (c *stacksClient) FindStackConfigurationComponents(ctx context.Context, in *FindStackConfigurationComponents_Request, opts ...grpc.CallOption) (*FindStackConfigurationComponents_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(FindStackConfigurationComponents_Response) - err := c.cc.Invoke(ctx, Stacks_FindStackConfigurationComponents_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_FindStackConfigurationComponents_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *stacksClient) OpenState(ctx context.Context, opts ...grpc.CallOption) (Stacks_OpenStateClient, error) { - stream, err := c.cc.NewStream(ctx, &Stacks_ServiceDesc.Streams[0], Stacks_OpenState_FullMethodName, opts...) +func (c *stacksClient) OpenState(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[OpenStackState_RequestItem, OpenStackState_Response], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Stacks_ServiceDesc.Streams[0], Stacks_OpenState_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &stacksOpenStateClient{stream} + x := &grpc.GenericClientStream[OpenStackState_RequestItem, OpenStackState_Response]{ClientStream: stream} return x, nil } -type Stacks_OpenStateClient interface { - Send(*OpenStackState_RequestItem) error - CloseAndRecv() (*OpenStackState_Response, error) - grpc.ClientStream -} - -type stacksOpenStateClient struct { - grpc.ClientStream -} - -func (x *stacksOpenStateClient) Send(m *OpenStackState_RequestItem) error { - return x.ClientStream.SendMsg(m) -} - -func (x *stacksOpenStateClient) CloseAndRecv() (*OpenStackState_Response, error) { - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err - } - m := new(OpenStackState_Response) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Stacks_OpenStateClient = grpc.ClientStreamingClient[OpenStackState_RequestItem, OpenStackState_Response] func (c *stacksClient) CloseState(ctx context.Context, in *CloseStackState_Request, opts ...grpc.CallOption) (*CloseStackState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CloseStackState_Response) - err := c.cc.Invoke(ctx, Stacks_CloseState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_CloseState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *stacksClient) PlanStackChanges(ctx context.Context, in *PlanStackChanges_Request, opts ...grpc.CallOption) (Stacks_PlanStackChangesClient, error) { - stream, err := c.cc.NewStream(ctx, &Stacks_ServiceDesc.Streams[1], Stacks_PlanStackChanges_FullMethodName, opts...) +func (c *stacksClient) PlanStackChanges(ctx context.Context, in *PlanStackChanges_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[PlanStackChanges_Event], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Stacks_ServiceDesc.Streams[1], Stacks_PlanStackChanges_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &stacksPlanStackChangesClient{stream} + x := &grpc.GenericClientStream[PlanStackChanges_Request, PlanStackChanges_Event]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -193,72 +178,39 @@ func (c *stacksClient) PlanStackChanges(ctx context.Context, in *PlanStackChange return x, nil } -type Stacks_PlanStackChangesClient interface { - Recv() (*PlanStackChanges_Event, error) - grpc.ClientStream -} - -type stacksPlanStackChangesClient struct { - grpc.ClientStream -} - -func (x *stacksPlanStackChangesClient) Recv() (*PlanStackChanges_Event, error) { - m := new(PlanStackChanges_Event) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Stacks_PlanStackChangesClient = grpc.ServerStreamingClient[PlanStackChanges_Event] -func (c *stacksClient) OpenPlan(ctx context.Context, opts ...grpc.CallOption) (Stacks_OpenPlanClient, error) { - stream, err := c.cc.NewStream(ctx, &Stacks_ServiceDesc.Streams[2], Stacks_OpenPlan_FullMethodName, opts...) +func (c *stacksClient) OpenPlan(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[OpenStackPlan_RequestItem, OpenStackPlan_Response], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Stacks_ServiceDesc.Streams[2], Stacks_OpenPlan_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &stacksOpenPlanClient{stream} + x := &grpc.GenericClientStream[OpenStackPlan_RequestItem, OpenStackPlan_Response]{ClientStream: stream} return x, nil } -type Stacks_OpenPlanClient interface { - Send(*OpenStackPlan_RequestItem) error - CloseAndRecv() (*OpenStackPlan_Response, error) - grpc.ClientStream -} - -type stacksOpenPlanClient struct { - grpc.ClientStream -} - -func (x *stacksOpenPlanClient) Send(m *OpenStackPlan_RequestItem) error { - return x.ClientStream.SendMsg(m) -} - -func (x *stacksOpenPlanClient) CloseAndRecv() (*OpenStackPlan_Response, error) { - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err - } - m := new(OpenStackPlan_Response) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Stacks_OpenPlanClient = grpc.ClientStreamingClient[OpenStackPlan_RequestItem, OpenStackPlan_Response] func (c *stacksClient) ClosePlan(ctx context.Context, in *CloseStackPlan_Request, opts ...grpc.CallOption) (*CloseStackPlan_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CloseStackPlan_Response) - err := c.cc.Invoke(ctx, Stacks_ClosePlan_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_ClosePlan_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *stacksClient) ApplyStackChanges(ctx context.Context, in *ApplyStackChanges_Request, opts ...grpc.CallOption) (Stacks_ApplyStackChangesClient, error) { - stream, err := c.cc.NewStream(ctx, &Stacks_ServiceDesc.Streams[3], Stacks_ApplyStackChanges_FullMethodName, opts...) +func (c *stacksClient) ApplyStackChanges(ctx context.Context, in *ApplyStackChanges_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ApplyStackChanges_Event], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Stacks_ServiceDesc.Streams[3], Stacks_ApplyStackChanges_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &stacksApplyStackChangesClient{stream} + x := &grpc.GenericClientStream[ApplyStackChanges_Request, ApplyStackChanges_Event]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -268,26 +220,13 @@ func (c *stacksClient) ApplyStackChanges(ctx context.Context, in *ApplyStackChan return x, nil } -type Stacks_ApplyStackChangesClient interface { - Recv() (*ApplyStackChanges_Event, error) - grpc.ClientStream -} - -type stacksApplyStackChangesClient struct { - grpc.ClientStream -} - -func (x *stacksApplyStackChangesClient) Recv() (*ApplyStackChanges_Event, error) { - m := new(ApplyStackChanges_Event) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Stacks_ApplyStackChangesClient = grpc.ServerStreamingClient[ApplyStackChanges_Event] func (c *stacksClient) OpenStackInspector(ctx context.Context, in *OpenStackInspector_Request, opts ...grpc.CallOption) (*OpenStackInspector_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(OpenStackInspector_Response) - err := c.cc.Invoke(ctx, Stacks_OpenStackInspector_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_OpenStackInspector_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -295,8 +234,9 @@ func (c *stacksClient) OpenStackInspector(ctx context.Context, in *OpenStackInsp } func (c *stacksClient) InspectExpressionResult(ctx context.Context, in *InspectExpressionResult_Request, opts ...grpc.CallOption) (*InspectExpressionResult_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(InspectExpressionResult_Response) - err := c.cc.Invoke(ctx, Stacks_InspectExpressionResult_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_InspectExpressionResult_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -304,8 +244,9 @@ func (c *stacksClient) InspectExpressionResult(ctx context.Context, in *InspectE } func (c *stacksClient) OpenTerraformState(ctx context.Context, in *OpenTerraformState_Request, opts ...grpc.CallOption) (*OpenTerraformState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(OpenTerraformState_Response) - err := c.cc.Invoke(ctx, Stacks_OpenTerraformState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_OpenTerraformState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -313,20 +254,22 @@ func (c *stacksClient) OpenTerraformState(ctx context.Context, in *OpenTerraform } func (c *stacksClient) CloseTerraformState(ctx context.Context, in *CloseTerraformState_Request, opts ...grpc.CallOption) (*CloseTerraformState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CloseTerraformState_Response) - err := c.cc.Invoke(ctx, Stacks_CloseTerraformState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_CloseTerraformState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *stacksClient) MigrateTerraformState(ctx context.Context, in *MigrateTerraformState_Request, opts ...grpc.CallOption) (Stacks_MigrateTerraformStateClient, error) { - stream, err := c.cc.NewStream(ctx, &Stacks_ServiceDesc.Streams[4], Stacks_MigrateTerraformState_FullMethodName, opts...) +func (c *stacksClient) MigrateTerraformState(ctx context.Context, in *MigrateTerraformState_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[MigrateTerraformState_Event], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Stacks_ServiceDesc.Streams[4], Stacks_MigrateTerraformState_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &stacksMigrateTerraformStateClient{stream} + x := &grpc.GenericClientStream[MigrateTerraformState_Request, MigrateTerraformState_Event]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -336,26 +279,13 @@ func (c *stacksClient) MigrateTerraformState(ctx context.Context, in *MigrateTer return x, nil } -type Stacks_MigrateTerraformStateClient interface { - Recv() (*MigrateTerraformState_Event, error) - grpc.ClientStream -} - -type stacksMigrateTerraformStateClient struct { - grpc.ClientStream -} - -func (x *stacksMigrateTerraformStateClient) Recv() (*MigrateTerraformState_Event, error) { - m := new(MigrateTerraformState_Event) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Stacks_MigrateTerraformStateClient = grpc.ServerStreamingClient[MigrateTerraformState_Event] func (c *stacksClient) ListResourceIdentities(ctx context.Context, in *ListResourceIdentities_Request, opts ...grpc.CallOption) (*ListResourceIdentities_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ListResourceIdentities_Response) - err := c.cc.Invoke(ctx, Stacks_ListResourceIdentities_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Stacks_ListResourceIdentities_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -364,7 +294,7 @@ func (c *stacksClient) ListResourceIdentities(ctx context.Context, in *ListResou // StacksServer is the server API for Stacks service. // All implementations must embed UnimplementedStacksServer -// for forward compatibility +// for forward compatibility. type StacksServer interface { // Load and perform initial static validation of a stack configuration // in a previously-opened source bundle. If successful, returns a @@ -380,20 +310,20 @@ type StacksServer interface { FindStackConfigurationComponents(context.Context, *FindStackConfigurationComponents_Request) (*FindStackConfigurationComponents_Response, error) // Load a stack state by sending a stream of raw state objects that were // streamed from a previous ApplyStackChanges response. - OpenState(Stacks_OpenStateServer) error + OpenState(grpc.ClientStreamingServer[OpenStackState_RequestItem, OpenStackState_Response]) error // Close a stack state handle, discarding the associated state. CloseState(context.Context, *CloseStackState_Request) (*CloseStackState_Response, error) // Calculate a desired state from the given configuration and compare it // with the current state to propose a set of changes to converge the // current state with the desired state, at least in part. - PlanStackChanges(*PlanStackChanges_Request, Stacks_PlanStackChangesServer) error + PlanStackChanges(*PlanStackChanges_Request, grpc.ServerStreamingServer[PlanStackChanges_Event]) error // Load a previously-created plan by sending a stream of raw change objects // that were streamed from a previous PlanStackChanges response. - OpenPlan(Stacks_OpenPlanServer) error + OpenPlan(grpc.ClientStreamingServer[OpenStackPlan_RequestItem, OpenStackPlan_Response]) error // Close a saved plan handle, discarding the associated saved plan. ClosePlan(context.Context, *CloseStackPlan_Request) (*CloseStackPlan_Response, error) // Execute the changes proposed by an earlier call to PlanStackChanges. - ApplyStackChanges(*ApplyStackChanges_Request, Stacks_ApplyStackChangesServer) error + ApplyStackChanges(*ApplyStackChanges_Request, grpc.ServerStreamingServer[ApplyStackChanges_Event]) error // OpenStackInspector creates a stack inspector handle that can be used // with subsequent calls to the "Inspect"-prefixed functions. OpenStackInspector(context.Context, *OpenStackInspector_Request) (*OpenStackInspector_Response, error) @@ -408,15 +338,18 @@ type StacksServer interface { CloseTerraformState(context.Context, *CloseTerraformState_Request) (*CloseTerraformState_Response, error) // MigrateTerraformState migrates a Terraform state into Stacks state using // a mapping of addresses. - MigrateTerraformState(*MigrateTerraformState_Request, Stacks_MigrateTerraformStateServer) error + MigrateTerraformState(*MigrateTerraformState_Request, grpc.ServerStreamingServer[MigrateTerraformState_Event]) error // ListResourceIdentities lists the identities of all resources in a stack. ListResourceIdentities(context.Context, *ListResourceIdentities_Request) (*ListResourceIdentities_Response, error) mustEmbedUnimplementedStacksServer() } -// UnimplementedStacksServer must be embedded to have forward compatible implementations. -type UnimplementedStacksServer struct { -} +// UnimplementedStacksServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedStacksServer struct{} func (UnimplementedStacksServer) OpenStackConfiguration(context.Context, *OpenStackConfiguration_Request) (*OpenStackConfiguration_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method OpenStackConfiguration not implemented") @@ -430,22 +363,22 @@ func (UnimplementedStacksServer) ValidateStackConfiguration(context.Context, *Va func (UnimplementedStacksServer) FindStackConfigurationComponents(context.Context, *FindStackConfigurationComponents_Request) (*FindStackConfigurationComponents_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method FindStackConfigurationComponents not implemented") } -func (UnimplementedStacksServer) OpenState(Stacks_OpenStateServer) error { +func (UnimplementedStacksServer) OpenState(grpc.ClientStreamingServer[OpenStackState_RequestItem, OpenStackState_Response]) error { return status.Errorf(codes.Unimplemented, "method OpenState not implemented") } func (UnimplementedStacksServer) CloseState(context.Context, *CloseStackState_Request) (*CloseStackState_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method CloseState not implemented") } -func (UnimplementedStacksServer) PlanStackChanges(*PlanStackChanges_Request, Stacks_PlanStackChangesServer) error { +func (UnimplementedStacksServer) PlanStackChanges(*PlanStackChanges_Request, grpc.ServerStreamingServer[PlanStackChanges_Event]) error { return status.Errorf(codes.Unimplemented, "method PlanStackChanges not implemented") } -func (UnimplementedStacksServer) OpenPlan(Stacks_OpenPlanServer) error { +func (UnimplementedStacksServer) OpenPlan(grpc.ClientStreamingServer[OpenStackPlan_RequestItem, OpenStackPlan_Response]) error { return status.Errorf(codes.Unimplemented, "method OpenPlan not implemented") } func (UnimplementedStacksServer) ClosePlan(context.Context, *CloseStackPlan_Request) (*CloseStackPlan_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method ClosePlan not implemented") } -func (UnimplementedStacksServer) ApplyStackChanges(*ApplyStackChanges_Request, Stacks_ApplyStackChangesServer) error { +func (UnimplementedStacksServer) ApplyStackChanges(*ApplyStackChanges_Request, grpc.ServerStreamingServer[ApplyStackChanges_Event]) error { return status.Errorf(codes.Unimplemented, "method ApplyStackChanges not implemented") } func (UnimplementedStacksServer) OpenStackInspector(context.Context, *OpenStackInspector_Request) (*OpenStackInspector_Response, error) { @@ -460,13 +393,14 @@ func (UnimplementedStacksServer) OpenTerraformState(context.Context, *OpenTerraf func (UnimplementedStacksServer) CloseTerraformState(context.Context, *CloseTerraformState_Request) (*CloseTerraformState_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method CloseTerraformState not implemented") } -func (UnimplementedStacksServer) MigrateTerraformState(*MigrateTerraformState_Request, Stacks_MigrateTerraformStateServer) error { +func (UnimplementedStacksServer) MigrateTerraformState(*MigrateTerraformState_Request, grpc.ServerStreamingServer[MigrateTerraformState_Event]) error { return status.Errorf(codes.Unimplemented, "method MigrateTerraformState not implemented") } func (UnimplementedStacksServer) ListResourceIdentities(context.Context, *ListResourceIdentities_Request) (*ListResourceIdentities_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method ListResourceIdentities not implemented") } func (UnimplementedStacksServer) mustEmbedUnimplementedStacksServer() {} +func (UnimplementedStacksServer) testEmbeddedByValue() {} // UnsafeStacksServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to StacksServer will @@ -476,6 +410,13 @@ type UnsafeStacksServer interface { } func RegisterStacksServer(s grpc.ServiceRegistrar, srv StacksServer) { + // If the following call pancis, it indicates UnimplementedStacksServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&Stacks_ServiceDesc, srv) } @@ -552,30 +493,11 @@ func _Stacks_FindStackConfigurationComponents_Handler(srv interface{}, ctx conte } func _Stacks_OpenState_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(StacksServer).OpenState(&stacksOpenStateServer{stream}) -} - -type Stacks_OpenStateServer interface { - SendAndClose(*OpenStackState_Response) error - Recv() (*OpenStackState_RequestItem, error) - grpc.ServerStream -} - -type stacksOpenStateServer struct { - grpc.ServerStream -} - -func (x *stacksOpenStateServer) SendAndClose(m *OpenStackState_Response) error { - return x.ServerStream.SendMsg(m) + return srv.(StacksServer).OpenState(&grpc.GenericServerStream[OpenStackState_RequestItem, OpenStackState_Response]{ServerStream: stream}) } -func (x *stacksOpenStateServer) Recv() (*OpenStackState_RequestItem, error) { - m := new(OpenStackState_RequestItem) - if err := x.ServerStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Stacks_OpenStateServer = grpc.ClientStreamingServer[OpenStackState_RequestItem, OpenStackState_Response] func _Stacks_CloseState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CloseStackState_Request) @@ -600,47 +522,18 @@ func _Stacks_PlanStackChanges_Handler(srv interface{}, stream grpc.ServerStream) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(StacksServer).PlanStackChanges(m, &stacksPlanStackChangesServer{stream}) -} - -type Stacks_PlanStackChangesServer interface { - Send(*PlanStackChanges_Event) error - grpc.ServerStream -} - -type stacksPlanStackChangesServer struct { - grpc.ServerStream + return srv.(StacksServer).PlanStackChanges(m, &grpc.GenericServerStream[PlanStackChanges_Request, PlanStackChanges_Event]{ServerStream: stream}) } -func (x *stacksPlanStackChangesServer) Send(m *PlanStackChanges_Event) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Stacks_PlanStackChangesServer = grpc.ServerStreamingServer[PlanStackChanges_Event] func _Stacks_OpenPlan_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(StacksServer).OpenPlan(&stacksOpenPlanServer{stream}) -} - -type Stacks_OpenPlanServer interface { - SendAndClose(*OpenStackPlan_Response) error - Recv() (*OpenStackPlan_RequestItem, error) - grpc.ServerStream -} - -type stacksOpenPlanServer struct { - grpc.ServerStream + return srv.(StacksServer).OpenPlan(&grpc.GenericServerStream[OpenStackPlan_RequestItem, OpenStackPlan_Response]{ServerStream: stream}) } -func (x *stacksOpenPlanServer) SendAndClose(m *OpenStackPlan_Response) error { - return x.ServerStream.SendMsg(m) -} - -func (x *stacksOpenPlanServer) Recv() (*OpenStackPlan_RequestItem, error) { - m := new(OpenStackPlan_RequestItem) - if err := x.ServerStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Stacks_OpenPlanServer = grpc.ClientStreamingServer[OpenStackPlan_RequestItem, OpenStackPlan_Response] func _Stacks_ClosePlan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CloseStackPlan_Request) @@ -665,21 +558,11 @@ func _Stacks_ApplyStackChanges_Handler(srv interface{}, stream grpc.ServerStream if err := stream.RecvMsg(m); err != nil { return err } - return srv.(StacksServer).ApplyStackChanges(m, &stacksApplyStackChangesServer{stream}) + return srv.(StacksServer).ApplyStackChanges(m, &grpc.GenericServerStream[ApplyStackChanges_Request, ApplyStackChanges_Event]{ServerStream: stream}) } -type Stacks_ApplyStackChangesServer interface { - Send(*ApplyStackChanges_Event) error - grpc.ServerStream -} - -type stacksApplyStackChangesServer struct { - grpc.ServerStream -} - -func (x *stacksApplyStackChangesServer) Send(m *ApplyStackChanges_Event) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Stacks_ApplyStackChangesServer = grpc.ServerStreamingServer[ApplyStackChanges_Event] func _Stacks_OpenStackInspector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(OpenStackInspector_Request) @@ -758,21 +641,11 @@ func _Stacks_MigrateTerraformState_Handler(srv interface{}, stream grpc.ServerSt if err := stream.RecvMsg(m); err != nil { return err } - return srv.(StacksServer).MigrateTerraformState(m, &stacksMigrateTerraformStateServer{stream}) + return srv.(StacksServer).MigrateTerraformState(m, &grpc.GenericServerStream[MigrateTerraformState_Request, MigrateTerraformState_Event]{ServerStream: stream}) } -type Stacks_MigrateTerraformStateServer interface { - Send(*MigrateTerraformState_Event) error - grpc.ServerStream -} - -type stacksMigrateTerraformStateServer struct { - grpc.ServerStream -} - -func (x *stacksMigrateTerraformStateServer) Send(m *MigrateTerraformState_Event) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Stacks_MigrateTerraformStateServer = grpc.ServerStreamingServer[MigrateTerraformState_Event] func _Stacks_ListResourceIdentities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListResourceIdentities_Request) diff --git a/internal/rpcapi/terraform1/terraform1.pb.go b/internal/rpcapi/terraform1/terraform1.pb.go index 71aa4ef1f6..1cac135a2a 100644 --- a/internal/rpcapi/terraform1/terraform1.pb.go +++ b/internal/rpcapi/terraform1/terraform1.pb.go @@ -4,7 +4,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: terraform1.proto package terraform1 diff --git a/internal/stacks/tfstackdata1/tfstackdata1.pb.go b/internal/stacks/tfstackdata1/tfstackdata1.pb.go index cb1fc74dd3..fefea2ac00 100644 --- a/internal/stacks/tfstackdata1/tfstackdata1.pb.go +++ b/internal/stacks/tfstackdata1/tfstackdata1.pb.go @@ -4,7 +4,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: tfstackdata1.proto package tfstackdata1 diff --git a/internal/stacksplugin/mock_stacksproto1/mock.go b/internal/stacksplugin/mock_stacksproto1/mock.go index 8474a0cd2d..57bf3ef184 100644 --- a/internal/stacksplugin/mock_stacksproto1/mock.go +++ b/internal/stacksplugin/mock_stacksproto1/mock.go @@ -44,14 +44,14 @@ func (m *MockCommandServiceClient) EXPECT() *MockCommandServiceClientMockRecorde } // Execute mocks base method. -func (m *MockCommandServiceClient) Execute(ctx context.Context, in *stacksproto1.CommandRequest, opts ...grpc.CallOption) (stacksproto1.CommandService_ExecuteClient, error) { +func (m *MockCommandServiceClient) Execute(ctx context.Context, in *stacksproto1.CommandRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[stacksproto1.CommandResponse], error) { m.ctrl.T.Helper() varargs := []any{ctx, in} for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Execute", varargs...) - ret0, _ := ret[0].(stacksproto1.CommandService_ExecuteClient) + ret0, _ := ret[0].(grpc.ServerStreamingClient[stacksproto1.CommandResponse]) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -64,31 +64,31 @@ func (mr *MockCommandServiceClientMockRecorder) Execute(ctx, in any, opts ...any } // MockCommandService_ExecuteClient is a mock of CommandService_ExecuteClient interface. -type MockCommandService_ExecuteClient struct { +type MockCommandService_ExecuteClient[Res any] struct { ctrl *gomock.Controller - recorder *MockCommandService_ExecuteClientMockRecorder + recorder *MockCommandService_ExecuteClientMockRecorder[Res] isgomock struct{} } // MockCommandService_ExecuteClientMockRecorder is the mock recorder for MockCommandService_ExecuteClient. -type MockCommandService_ExecuteClientMockRecorder struct { - mock *MockCommandService_ExecuteClient +type MockCommandService_ExecuteClientMockRecorder[Res any] struct { + mock *MockCommandService_ExecuteClient[Res] } // NewMockCommandService_ExecuteClient creates a new mock instance. -func NewMockCommandService_ExecuteClient(ctrl *gomock.Controller) *MockCommandService_ExecuteClient { - mock := &MockCommandService_ExecuteClient{ctrl: ctrl} - mock.recorder = &MockCommandService_ExecuteClientMockRecorder{mock} +func NewMockCommandService_ExecuteClient[Res any](ctrl *gomock.Controller) *MockCommandService_ExecuteClient[Res] { + mock := &MockCommandService_ExecuteClient[Res]{ctrl: ctrl} + mock.recorder = &MockCommandService_ExecuteClientMockRecorder[Res]{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockCommandService_ExecuteClient) EXPECT() *MockCommandService_ExecuteClientMockRecorder { +func (m *MockCommandService_ExecuteClient[Res]) EXPECT() *MockCommandService_ExecuteClientMockRecorder[Res] { return m.recorder } // CloseSend mocks base method. -func (m *MockCommandService_ExecuteClient) CloseSend() error { +func (m *MockCommandService_ExecuteClient[Res]) CloseSend() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseSend") ret0, _ := ret[0].(error) @@ -96,13 +96,13 @@ func (m *MockCommandService_ExecuteClient) CloseSend() error { } // CloseSend indicates an expected call of CloseSend. -func (mr *MockCommandService_ExecuteClientMockRecorder) CloseSend() *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) CloseSend() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).CloseSend)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).CloseSend)) } // Context mocks base method. -func (m *MockCommandService_ExecuteClient) Context() context.Context { +func (m *MockCommandService_ExecuteClient[Res]) Context() context.Context { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) @@ -110,13 +110,13 @@ func (m *MockCommandService_ExecuteClient) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockCommandService_ExecuteClientMockRecorder) Context() *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) Context() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).Context)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).Context)) } // Header mocks base method. -func (m *MockCommandService_ExecuteClient) Header() (metadata.MD, error) { +func (m *MockCommandService_ExecuteClient[Res]) Header() (metadata.MD, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Header") ret0, _ := ret[0].(metadata.MD) @@ -125,13 +125,13 @@ func (m *MockCommandService_ExecuteClient) Header() (metadata.MD, error) { } // Header indicates an expected call of Header. -func (mr *MockCommandService_ExecuteClientMockRecorder) Header() *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) Header() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).Header)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).Header)) } // Recv mocks base method. -func (m *MockCommandService_ExecuteClient) Recv() (*stacksproto1.CommandResponse, error) { +func (m *MockCommandService_ExecuteClient[Res]) Recv() (*stacksproto1.CommandResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Recv") ret0, _ := ret[0].(*stacksproto1.CommandResponse) @@ -140,13 +140,13 @@ func (m *MockCommandService_ExecuteClient) Recv() (*stacksproto1.CommandResponse } // Recv indicates an expected call of Recv. -func (mr *MockCommandService_ExecuteClientMockRecorder) Recv() *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) Recv() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).Recv)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).Recv)) } // RecvMsg mocks base method. -func (m_2 *MockCommandService_ExecuteClient) RecvMsg(m any) error { +func (m_2 *MockCommandService_ExecuteClient[Res]) RecvMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "RecvMsg", m) ret0, _ := ret[0].(error) @@ -154,13 +154,13 @@ func (m_2 *MockCommandService_ExecuteClient) RecvMsg(m any) error { } // RecvMsg indicates an expected call of RecvMsg. -func (mr *MockCommandService_ExecuteClientMockRecorder) RecvMsg(m any) *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) RecvMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).RecvMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).RecvMsg), m) } // SendMsg mocks base method. -func (m_2 *MockCommandService_ExecuteClient) SendMsg(m any) error { +func (m_2 *MockCommandService_ExecuteClient[Res]) SendMsg(m any) error { m_2.ctrl.T.Helper() ret := m_2.ctrl.Call(m_2, "SendMsg", m) ret0, _ := ret[0].(error) @@ -168,13 +168,13 @@ func (m_2 *MockCommandService_ExecuteClient) SendMsg(m any) error { } // SendMsg indicates an expected call of SendMsg. -func (mr *MockCommandService_ExecuteClientMockRecorder) SendMsg(m any) *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) SendMsg(m any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).SendMsg), m) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).SendMsg), m) } // Trailer mocks base method. -func (m *MockCommandService_ExecuteClient) Trailer() metadata.MD { +func (m *MockCommandService_ExecuteClient[Res]) Trailer() metadata.MD { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Trailer") ret0, _ := ret[0].(metadata.MD) @@ -182,7 +182,7 @@ func (m *MockCommandService_ExecuteClient) Trailer() metadata.MD { } // Trailer indicates an expected call of Trailer. -func (mr *MockCommandService_ExecuteClientMockRecorder) Trailer() *gomock.Call { +func (mr *MockCommandService_ExecuteClientMockRecorder[Res]) Trailer() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockCommandService_ExecuteClient)(nil).Trailer)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockCommandService_ExecuteClient[Res])(nil).Trailer)) } diff --git a/internal/stacksplugin/stacksproto1/stacksproto1.pb.go b/internal/stacksplugin/stacksproto1/stacksproto1.pb.go index 786b85c6f5..d6a7c6a0c5 100644 --- a/internal/stacksplugin/stacksproto1/stacksproto1.pb.go +++ b/internal/stacksplugin/stacksproto1/stacksproto1.pb.go @@ -4,7 +4,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: stacksproto1.proto package stacksproto1 diff --git a/internal/stacksplugin/stacksproto1/stacksproto1_grpc.pb.go b/internal/stacksplugin/stacksproto1/stacksproto1_grpc.pb.go index 490b9b954e..c6b89d7232 100644 --- a/internal/stacksplugin/stacksproto1/stacksproto1_grpc.pb.go +++ b/internal/stacksplugin/stacksproto1/stacksproto1_grpc.pb.go @@ -3,8 +3,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.3.0 -// - protoc v3.15.6 +// - protoc-gen-go-grpc v1.5.1 +// - protoc v5.29.3 // source: stacksproto1.proto package stacksproto1 @@ -18,8 +18,8 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 const ( CommandService_Execute_FullMethodName = "/stacksproto1.CommandService/Execute" @@ -28,9 +28,12 @@ const ( // CommandServiceClient is the client API for CommandService service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// PluginService defines the gRPC service to handle available commands and +// their execution. type CommandServiceClient interface { // Execute runs a specific command with the provided flags and returns the result. - Execute(ctx context.Context, in *CommandRequest, opts ...grpc.CallOption) (CommandService_ExecuteClient, error) + Execute(ctx context.Context, in *CommandRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CommandResponse], error) } type commandServiceClient struct { @@ -41,12 +44,13 @@ func NewCommandServiceClient(cc grpc.ClientConnInterface) CommandServiceClient { return &commandServiceClient{cc} } -func (c *commandServiceClient) Execute(ctx context.Context, in *CommandRequest, opts ...grpc.CallOption) (CommandService_ExecuteClient, error) { - stream, err := c.cc.NewStream(ctx, &CommandService_ServiceDesc.Streams[0], CommandService_Execute_FullMethodName, opts...) +func (c *commandServiceClient) Execute(ctx context.Context, in *CommandRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[CommandResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &CommandService_ServiceDesc.Streams[0], CommandService_Execute_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &commandServiceExecuteClient{stream} + x := &grpc.GenericClientStream[CommandRequest, CommandResponse]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -56,40 +60,33 @@ func (c *commandServiceClient) Execute(ctx context.Context, in *CommandRequest, return x, nil } -type CommandService_ExecuteClient interface { - Recv() (*CommandResponse, error) - grpc.ClientStream -} - -type commandServiceExecuteClient struct { - grpc.ClientStream -} - -func (x *commandServiceExecuteClient) Recv() (*CommandResponse, error) { - m := new(CommandResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type CommandService_ExecuteClient = grpc.ServerStreamingClient[CommandResponse] // CommandServiceServer is the server API for CommandService service. // All implementations must embed UnimplementedCommandServiceServer -// for forward compatibility +// for forward compatibility. +// +// PluginService defines the gRPC service to handle available commands and +// their execution. type CommandServiceServer interface { // Execute runs a specific command with the provided flags and returns the result. - Execute(*CommandRequest, CommandService_ExecuteServer) error + Execute(*CommandRequest, grpc.ServerStreamingServer[CommandResponse]) error mustEmbedUnimplementedCommandServiceServer() } -// UnimplementedCommandServiceServer must be embedded to have forward compatible implementations. -type UnimplementedCommandServiceServer struct { -} +// UnimplementedCommandServiceServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedCommandServiceServer struct{} -func (UnimplementedCommandServiceServer) Execute(*CommandRequest, CommandService_ExecuteServer) error { +func (UnimplementedCommandServiceServer) Execute(*CommandRequest, grpc.ServerStreamingServer[CommandResponse]) error { return status.Errorf(codes.Unimplemented, "method Execute not implemented") } func (UnimplementedCommandServiceServer) mustEmbedUnimplementedCommandServiceServer() {} +func (UnimplementedCommandServiceServer) testEmbeddedByValue() {} // UnsafeCommandServiceServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to CommandServiceServer will @@ -99,6 +96,13 @@ type UnsafeCommandServiceServer interface { } func RegisterCommandServiceServer(s grpc.ServiceRegistrar, srv CommandServiceServer) { + // If the following call pancis, it indicates UnimplementedCommandServiceServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&CommandService_ServiceDesc, srv) } @@ -107,21 +111,11 @@ func _CommandService_Execute_Handler(srv interface{}, stream grpc.ServerStream) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(CommandServiceServer).Execute(m, &commandServiceExecuteServer{stream}) -} - -type CommandService_ExecuteServer interface { - Send(*CommandResponse) error - grpc.ServerStream -} - -type commandServiceExecuteServer struct { - grpc.ServerStream + return srv.(CommandServiceServer).Execute(m, &grpc.GenericServerStream[CommandRequest, CommandResponse]{ServerStream: stream}) } -func (x *commandServiceExecuteServer) Send(m *CommandResponse) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type CommandService_ExecuteServer = grpc.ServerStreamingServer[CommandResponse] // CommandService_ServiceDesc is the grpc.ServiceDesc for CommandService service. // It's only intended for direct use with grpc.RegisterService, diff --git a/internal/tfplugin5/tfplugin5.pb.go b/internal/tfplugin5/tfplugin5.pb.go index 85e2731500..6cc61f20ad 100644 --- a/internal/tfplugin5/tfplugin5.pb.go +++ b/internal/tfplugin5/tfplugin5.pb.go @@ -22,7 +22,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: tfplugin5.proto package tfplugin5 diff --git a/internal/tfplugin5/tfplugin5_grpc.pb.go b/internal/tfplugin5/tfplugin5_grpc.pb.go index baa8a46b70..fdca408960 100644 --- a/internal/tfplugin5/tfplugin5_grpc.pb.go +++ b/internal/tfplugin5/tfplugin5_grpc.pb.go @@ -21,8 +21,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.3.0 -// - protoc v3.15.6 +// - protoc-gen-go-grpc v1.5.1 +// - protoc v5.29.3 // source: tfplugin5.proto package tfplugin5 @@ -36,8 +36,8 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 const ( Provider_GetMetadata_FullMethodName = "/tfplugin5.Provider/GetMetadata" @@ -109,7 +109,7 @@ type ProviderClient interface { RenewEphemeralResource(ctx context.Context, in *RenewEphemeralResource_Request, opts ...grpc.CallOption) (*RenewEphemeralResource_Response, error) CloseEphemeralResource(ctx context.Context, in *CloseEphemeralResource_Request, opts ...grpc.CallOption) (*CloseEphemeralResource_Response, error) // ///// List - ListResource(ctx context.Context, in *ListResource_Request, opts ...grpc.CallOption) (Provider_ListResourceClient, error) + ListResource(ctx context.Context, in *ListResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListResource_Event], error) ValidateListResourceConfig(ctx context.Context, in *ValidateListResourceConfig_Request, opts ...grpc.CallOption) (*ValidateListResourceConfig_Response, error) // GetFunctions returns the definitions of all functions. GetFunctions(ctx context.Context, in *GetFunctions_Request, opts ...grpc.CallOption) (*GetFunctions_Response, error) @@ -117,7 +117,7 @@ type ProviderClient interface { CallFunction(ctx context.Context, in *CallFunction_Request, opts ...grpc.CallOption) (*CallFunction_Response, error) // ////// Actions PlanAction(ctx context.Context, in *PlanAction_Request, opts ...grpc.CallOption) (*PlanAction_Response, error) - InvokeAction(ctx context.Context, in *InvokeAction_Request, opts ...grpc.CallOption) (Provider_InvokeActionClient, error) + InvokeAction(ctx context.Context, in *InvokeAction_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[InvokeAction_Event], error) ValidateActionConfig(ctx context.Context, in *ValidateActionConfig_Request, opts ...grpc.CallOption) (*ValidateActionConfig_Response, error) // ////// Graceful Shutdown Stop(ctx context.Context, in *Stop_Request, opts ...grpc.CallOption) (*Stop_Response, error) @@ -132,8 +132,9 @@ func NewProviderClient(cc grpc.ClientConnInterface) ProviderClient { } func (c *providerClient) GetMetadata(ctx context.Context, in *GetMetadata_Request, opts ...grpc.CallOption) (*GetMetadata_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetMetadata_Response) - err := c.cc.Invoke(ctx, Provider_GetMetadata_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GetMetadata_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -141,8 +142,9 @@ func (c *providerClient) GetMetadata(ctx context.Context, in *GetMetadata_Reques } func (c *providerClient) GetSchema(ctx context.Context, in *GetProviderSchema_Request, opts ...grpc.CallOption) (*GetProviderSchema_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetProviderSchema_Response) - err := c.cc.Invoke(ctx, Provider_GetSchema_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GetSchema_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -150,8 +152,9 @@ func (c *providerClient) GetSchema(ctx context.Context, in *GetProviderSchema_Re } func (c *providerClient) PrepareProviderConfig(ctx context.Context, in *PrepareProviderConfig_Request, opts ...grpc.CallOption) (*PrepareProviderConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(PrepareProviderConfig_Response) - err := c.cc.Invoke(ctx, Provider_PrepareProviderConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_PrepareProviderConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -159,8 +162,9 @@ func (c *providerClient) PrepareProviderConfig(ctx context.Context, in *PrepareP } func (c *providerClient) ValidateResourceTypeConfig(ctx context.Context, in *ValidateResourceTypeConfig_Request, opts ...grpc.CallOption) (*ValidateResourceTypeConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateResourceTypeConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateResourceTypeConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateResourceTypeConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -168,8 +172,9 @@ func (c *providerClient) ValidateResourceTypeConfig(ctx context.Context, in *Val } func (c *providerClient) ValidateDataSourceConfig(ctx context.Context, in *ValidateDataSourceConfig_Request, opts ...grpc.CallOption) (*ValidateDataSourceConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateDataSourceConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateDataSourceConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateDataSourceConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -177,8 +182,9 @@ func (c *providerClient) ValidateDataSourceConfig(ctx context.Context, in *Valid } func (c *providerClient) UpgradeResourceState(ctx context.Context, in *UpgradeResourceState_Request, opts ...grpc.CallOption) (*UpgradeResourceState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(UpgradeResourceState_Response) - err := c.cc.Invoke(ctx, Provider_UpgradeResourceState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_UpgradeResourceState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -186,8 +192,9 @@ func (c *providerClient) UpgradeResourceState(ctx context.Context, in *UpgradeRe } func (c *providerClient) GetResourceIdentitySchemas(ctx context.Context, in *GetResourceIdentitySchemas_Request, opts ...grpc.CallOption) (*GetResourceIdentitySchemas_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetResourceIdentitySchemas_Response) - err := c.cc.Invoke(ctx, Provider_GetResourceIdentitySchemas_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GetResourceIdentitySchemas_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -195,8 +202,9 @@ func (c *providerClient) GetResourceIdentitySchemas(ctx context.Context, in *Get } func (c *providerClient) UpgradeResourceIdentity(ctx context.Context, in *UpgradeResourceIdentity_Request, opts ...grpc.CallOption) (*UpgradeResourceIdentity_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(UpgradeResourceIdentity_Response) - err := c.cc.Invoke(ctx, Provider_UpgradeResourceIdentity_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_UpgradeResourceIdentity_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -204,8 +212,9 @@ func (c *providerClient) UpgradeResourceIdentity(ctx context.Context, in *Upgrad } func (c *providerClient) Configure(ctx context.Context, in *Configure_Request, opts ...grpc.CallOption) (*Configure_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(Configure_Response) - err := c.cc.Invoke(ctx, Provider_Configure_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_Configure_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -213,8 +222,9 @@ func (c *providerClient) Configure(ctx context.Context, in *Configure_Request, o } func (c *providerClient) ReadResource(ctx context.Context, in *ReadResource_Request, opts ...grpc.CallOption) (*ReadResource_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ReadResource_Response) - err := c.cc.Invoke(ctx, Provider_ReadResource_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ReadResource_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -222,8 +232,9 @@ func (c *providerClient) ReadResource(ctx context.Context, in *ReadResource_Requ } func (c *providerClient) PlanResourceChange(ctx context.Context, in *PlanResourceChange_Request, opts ...grpc.CallOption) (*PlanResourceChange_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(PlanResourceChange_Response) - err := c.cc.Invoke(ctx, Provider_PlanResourceChange_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_PlanResourceChange_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -231,8 +242,9 @@ func (c *providerClient) PlanResourceChange(ctx context.Context, in *PlanResourc } func (c *providerClient) ApplyResourceChange(ctx context.Context, in *ApplyResourceChange_Request, opts ...grpc.CallOption) (*ApplyResourceChange_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ApplyResourceChange_Response) - err := c.cc.Invoke(ctx, Provider_ApplyResourceChange_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ApplyResourceChange_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -240,8 +252,9 @@ func (c *providerClient) ApplyResourceChange(ctx context.Context, in *ApplyResou } func (c *providerClient) ImportResourceState(ctx context.Context, in *ImportResourceState_Request, opts ...grpc.CallOption) (*ImportResourceState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ImportResourceState_Response) - err := c.cc.Invoke(ctx, Provider_ImportResourceState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ImportResourceState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -249,8 +262,9 @@ func (c *providerClient) ImportResourceState(ctx context.Context, in *ImportReso } func (c *providerClient) MoveResourceState(ctx context.Context, in *MoveResourceState_Request, opts ...grpc.CallOption) (*MoveResourceState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(MoveResourceState_Response) - err := c.cc.Invoke(ctx, Provider_MoveResourceState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_MoveResourceState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -258,8 +272,9 @@ func (c *providerClient) MoveResourceState(ctx context.Context, in *MoveResource } func (c *providerClient) ReadDataSource(ctx context.Context, in *ReadDataSource_Request, opts ...grpc.CallOption) (*ReadDataSource_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ReadDataSource_Response) - err := c.cc.Invoke(ctx, Provider_ReadDataSource_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ReadDataSource_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -267,8 +282,9 @@ func (c *providerClient) ReadDataSource(ctx context.Context, in *ReadDataSource_ } func (c *providerClient) GenerateResourceConfig(ctx context.Context, in *GenerateResourceConfig_Request, opts ...grpc.CallOption) (*GenerateResourceConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GenerateResourceConfig_Response) - err := c.cc.Invoke(ctx, Provider_GenerateResourceConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GenerateResourceConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -276,8 +292,9 @@ func (c *providerClient) GenerateResourceConfig(ctx context.Context, in *Generat } func (c *providerClient) ValidateEphemeralResourceConfig(ctx context.Context, in *ValidateEphemeralResourceConfig_Request, opts ...grpc.CallOption) (*ValidateEphemeralResourceConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateEphemeralResourceConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateEphemeralResourceConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateEphemeralResourceConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -285,8 +302,9 @@ func (c *providerClient) ValidateEphemeralResourceConfig(ctx context.Context, in } func (c *providerClient) OpenEphemeralResource(ctx context.Context, in *OpenEphemeralResource_Request, opts ...grpc.CallOption) (*OpenEphemeralResource_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(OpenEphemeralResource_Response) - err := c.cc.Invoke(ctx, Provider_OpenEphemeralResource_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_OpenEphemeralResource_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -294,8 +312,9 @@ func (c *providerClient) OpenEphemeralResource(ctx context.Context, in *OpenEphe } func (c *providerClient) RenewEphemeralResource(ctx context.Context, in *RenewEphemeralResource_Request, opts ...grpc.CallOption) (*RenewEphemeralResource_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RenewEphemeralResource_Response) - err := c.cc.Invoke(ctx, Provider_RenewEphemeralResource_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_RenewEphemeralResource_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -303,20 +322,22 @@ func (c *providerClient) RenewEphemeralResource(ctx context.Context, in *RenewEp } func (c *providerClient) CloseEphemeralResource(ctx context.Context, in *CloseEphemeralResource_Request, opts ...grpc.CallOption) (*CloseEphemeralResource_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CloseEphemeralResource_Response) - err := c.cc.Invoke(ctx, Provider_CloseEphemeralResource_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_CloseEphemeralResource_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *providerClient) ListResource(ctx context.Context, in *ListResource_Request, opts ...grpc.CallOption) (Provider_ListResourceClient, error) { - stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[0], Provider_ListResource_FullMethodName, opts...) +func (c *providerClient) ListResource(ctx context.Context, in *ListResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListResource_Event], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[0], Provider_ListResource_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &providerListResourceClient{stream} + x := &grpc.GenericClientStream[ListResource_Request, ListResource_Event]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -326,26 +347,13 @@ func (c *providerClient) ListResource(ctx context.Context, in *ListResource_Requ return x, nil } -type Provider_ListResourceClient interface { - Recv() (*ListResource_Event, error) - grpc.ClientStream -} - -type providerListResourceClient struct { - grpc.ClientStream -} - -func (x *providerListResourceClient) Recv() (*ListResource_Event, error) { - m := new(ListResource_Event) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_ListResourceClient = grpc.ServerStreamingClient[ListResource_Event] func (c *providerClient) ValidateListResourceConfig(ctx context.Context, in *ValidateListResourceConfig_Request, opts ...grpc.CallOption) (*ValidateListResourceConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateListResourceConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateListResourceConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateListResourceConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -353,8 +361,9 @@ func (c *providerClient) ValidateListResourceConfig(ctx context.Context, in *Val } func (c *providerClient) GetFunctions(ctx context.Context, in *GetFunctions_Request, opts ...grpc.CallOption) (*GetFunctions_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetFunctions_Response) - err := c.cc.Invoke(ctx, Provider_GetFunctions_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GetFunctions_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -362,8 +371,9 @@ func (c *providerClient) GetFunctions(ctx context.Context, in *GetFunctions_Requ } func (c *providerClient) CallFunction(ctx context.Context, in *CallFunction_Request, opts ...grpc.CallOption) (*CallFunction_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CallFunction_Response) - err := c.cc.Invoke(ctx, Provider_CallFunction_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_CallFunction_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -371,20 +381,22 @@ func (c *providerClient) CallFunction(ctx context.Context, in *CallFunction_Requ } func (c *providerClient) PlanAction(ctx context.Context, in *PlanAction_Request, opts ...grpc.CallOption) (*PlanAction_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(PlanAction_Response) - err := c.cc.Invoke(ctx, Provider_PlanAction_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_PlanAction_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *providerClient) InvokeAction(ctx context.Context, in *InvokeAction_Request, opts ...grpc.CallOption) (Provider_InvokeActionClient, error) { - stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[1], Provider_InvokeAction_FullMethodName, opts...) +func (c *providerClient) InvokeAction(ctx context.Context, in *InvokeAction_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[InvokeAction_Event], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[1], Provider_InvokeAction_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &providerInvokeActionClient{stream} + x := &grpc.GenericClientStream[InvokeAction_Request, InvokeAction_Event]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -394,26 +406,13 @@ func (c *providerClient) InvokeAction(ctx context.Context, in *InvokeAction_Requ return x, nil } -type Provider_InvokeActionClient interface { - Recv() (*InvokeAction_Event, error) - grpc.ClientStream -} - -type providerInvokeActionClient struct { - grpc.ClientStream -} - -func (x *providerInvokeActionClient) Recv() (*InvokeAction_Event, error) { - m := new(InvokeAction_Event) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_InvokeActionClient = grpc.ServerStreamingClient[InvokeAction_Event] func (c *providerClient) ValidateActionConfig(ctx context.Context, in *ValidateActionConfig_Request, opts ...grpc.CallOption) (*ValidateActionConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateActionConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateActionConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateActionConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -421,8 +420,9 @@ func (c *providerClient) ValidateActionConfig(ctx context.Context, in *ValidateA } func (c *providerClient) Stop(ctx context.Context, in *Stop_Request, opts ...grpc.CallOption) (*Stop_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(Stop_Response) - err := c.cc.Invoke(ctx, Provider_Stop_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_Stop_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -431,7 +431,7 @@ func (c *providerClient) Stop(ctx context.Context, in *Stop_Request, opts ...grp // ProviderServer is the server API for Provider service. // All implementations must embed UnimplementedProviderServer -// for forward compatibility +// for forward compatibility. type ProviderServer interface { // GetMetadata returns upfront information about server capabilities and // supported resource types without requiring the server to instantiate all @@ -468,7 +468,7 @@ type ProviderServer interface { RenewEphemeralResource(context.Context, *RenewEphemeralResource_Request) (*RenewEphemeralResource_Response, error) CloseEphemeralResource(context.Context, *CloseEphemeralResource_Request) (*CloseEphemeralResource_Response, error) // ///// List - ListResource(*ListResource_Request, Provider_ListResourceServer) error + ListResource(*ListResource_Request, grpc.ServerStreamingServer[ListResource_Event]) error ValidateListResourceConfig(context.Context, *ValidateListResourceConfig_Request) (*ValidateListResourceConfig_Response, error) // GetFunctions returns the definitions of all functions. GetFunctions(context.Context, *GetFunctions_Request) (*GetFunctions_Response, error) @@ -476,16 +476,19 @@ type ProviderServer interface { CallFunction(context.Context, *CallFunction_Request) (*CallFunction_Response, error) // ////// Actions PlanAction(context.Context, *PlanAction_Request) (*PlanAction_Response, error) - InvokeAction(*InvokeAction_Request, Provider_InvokeActionServer) error + InvokeAction(*InvokeAction_Request, grpc.ServerStreamingServer[InvokeAction_Event]) error ValidateActionConfig(context.Context, *ValidateActionConfig_Request) (*ValidateActionConfig_Response, error) // ////// Graceful Shutdown Stop(context.Context, *Stop_Request) (*Stop_Response, error) mustEmbedUnimplementedProviderServer() } -// UnimplementedProviderServer must be embedded to have forward compatible implementations. -type UnimplementedProviderServer struct { -} +// UnimplementedProviderServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedProviderServer struct{} func (UnimplementedProviderServer) GetMetadata(context.Context, *GetMetadata_Request) (*GetMetadata_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method GetMetadata not implemented") @@ -547,7 +550,7 @@ func (UnimplementedProviderServer) RenewEphemeralResource(context.Context, *Rene func (UnimplementedProviderServer) CloseEphemeralResource(context.Context, *CloseEphemeralResource_Request) (*CloseEphemeralResource_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method CloseEphemeralResource not implemented") } -func (UnimplementedProviderServer) ListResource(*ListResource_Request, Provider_ListResourceServer) error { +func (UnimplementedProviderServer) ListResource(*ListResource_Request, grpc.ServerStreamingServer[ListResource_Event]) error { return status.Errorf(codes.Unimplemented, "method ListResource not implemented") } func (UnimplementedProviderServer) ValidateListResourceConfig(context.Context, *ValidateListResourceConfig_Request) (*ValidateListResourceConfig_Response, error) { @@ -562,7 +565,7 @@ func (UnimplementedProviderServer) CallFunction(context.Context, *CallFunction_R func (UnimplementedProviderServer) PlanAction(context.Context, *PlanAction_Request) (*PlanAction_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method PlanAction not implemented") } -func (UnimplementedProviderServer) InvokeAction(*InvokeAction_Request, Provider_InvokeActionServer) error { +func (UnimplementedProviderServer) InvokeAction(*InvokeAction_Request, grpc.ServerStreamingServer[InvokeAction_Event]) error { return status.Errorf(codes.Unimplemented, "method InvokeAction not implemented") } func (UnimplementedProviderServer) ValidateActionConfig(context.Context, *ValidateActionConfig_Request) (*ValidateActionConfig_Response, error) { @@ -572,6 +575,7 @@ func (UnimplementedProviderServer) Stop(context.Context, *Stop_Request) (*Stop_R return nil, status.Errorf(codes.Unimplemented, "method Stop not implemented") } func (UnimplementedProviderServer) mustEmbedUnimplementedProviderServer() {} +func (UnimplementedProviderServer) testEmbeddedByValue() {} // UnsafeProviderServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to ProviderServer will @@ -581,6 +585,13 @@ type UnsafeProviderServer interface { } func RegisterProviderServer(s grpc.ServiceRegistrar, srv ProviderServer) { + // If the following call pancis, it indicates UnimplementedProviderServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&Provider_ServiceDesc, srv) } @@ -949,21 +960,11 @@ func _Provider_ListResource_Handler(srv interface{}, stream grpc.ServerStream) e if err := stream.RecvMsg(m); err != nil { return err } - return srv.(ProviderServer).ListResource(m, &providerListResourceServer{stream}) -} - -type Provider_ListResourceServer interface { - Send(*ListResource_Event) error - grpc.ServerStream -} - -type providerListResourceServer struct { - grpc.ServerStream + return srv.(ProviderServer).ListResource(m, &grpc.GenericServerStream[ListResource_Request, ListResource_Event]{ServerStream: stream}) } -func (x *providerListResourceServer) Send(m *ListResource_Event) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_ListResourceServer = grpc.ServerStreamingServer[ListResource_Event] func _Provider_ValidateListResourceConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ValidateListResourceConfig_Request) @@ -1042,21 +1043,11 @@ func _Provider_InvokeAction_Handler(srv interface{}, stream grpc.ServerStream) e if err := stream.RecvMsg(m); err != nil { return err } - return srv.(ProviderServer).InvokeAction(m, &providerInvokeActionServer{stream}) -} - -type Provider_InvokeActionServer interface { - Send(*InvokeAction_Event) error - grpc.ServerStream + return srv.(ProviderServer).InvokeAction(m, &grpc.GenericServerStream[InvokeAction_Request, InvokeAction_Event]{ServerStream: stream}) } -type providerInvokeActionServer struct { - grpc.ServerStream -} - -func (x *providerInvokeActionServer) Send(m *InvokeAction_Event) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_InvokeActionServer = grpc.ServerStreamingServer[InvokeAction_Event] func _Provider_ValidateActionConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ValidateActionConfig_Request) @@ -1234,7 +1225,7 @@ const ( type ProvisionerClient interface { GetSchema(ctx context.Context, in *GetProvisionerSchema_Request, opts ...grpc.CallOption) (*GetProvisionerSchema_Response, error) ValidateProvisionerConfig(ctx context.Context, in *ValidateProvisionerConfig_Request, opts ...grpc.CallOption) (*ValidateProvisionerConfig_Response, error) - ProvisionResource(ctx context.Context, in *ProvisionResource_Request, opts ...grpc.CallOption) (Provisioner_ProvisionResourceClient, error) + ProvisionResource(ctx context.Context, in *ProvisionResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ProvisionResource_Response], error) Stop(ctx context.Context, in *Stop_Request, opts ...grpc.CallOption) (*Stop_Response, error) } @@ -1247,8 +1238,9 @@ func NewProvisionerClient(cc grpc.ClientConnInterface) ProvisionerClient { } func (c *provisionerClient) GetSchema(ctx context.Context, in *GetProvisionerSchema_Request, opts ...grpc.CallOption) (*GetProvisionerSchema_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetProvisionerSchema_Response) - err := c.cc.Invoke(ctx, Provisioner_GetSchema_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provisioner_GetSchema_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -1256,20 +1248,22 @@ func (c *provisionerClient) GetSchema(ctx context.Context, in *GetProvisionerSch } func (c *provisionerClient) ValidateProvisionerConfig(ctx context.Context, in *ValidateProvisionerConfig_Request, opts ...grpc.CallOption) (*ValidateProvisionerConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateProvisionerConfig_Response) - err := c.cc.Invoke(ctx, Provisioner_ValidateProvisionerConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provisioner_ValidateProvisionerConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *provisionerClient) ProvisionResource(ctx context.Context, in *ProvisionResource_Request, opts ...grpc.CallOption) (Provisioner_ProvisionResourceClient, error) { - stream, err := c.cc.NewStream(ctx, &Provisioner_ServiceDesc.Streams[0], Provisioner_ProvisionResource_FullMethodName, opts...) +func (c *provisionerClient) ProvisionResource(ctx context.Context, in *ProvisionResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ProvisionResource_Response], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Provisioner_ServiceDesc.Streams[0], Provisioner_ProvisionResource_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &provisionerProvisionResourceClient{stream} + x := &grpc.GenericClientStream[ProvisionResource_Request, ProvisionResource_Response]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -1279,26 +1273,13 @@ func (c *provisionerClient) ProvisionResource(ctx context.Context, in *Provision return x, nil } -type Provisioner_ProvisionResourceClient interface { - Recv() (*ProvisionResource_Response, error) - grpc.ClientStream -} - -type provisionerProvisionResourceClient struct { - grpc.ClientStream -} - -func (x *provisionerProvisionResourceClient) Recv() (*ProvisionResource_Response, error) { - m := new(ProvisionResource_Response) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provisioner_ProvisionResourceClient = grpc.ServerStreamingClient[ProvisionResource_Response] func (c *provisionerClient) Stop(ctx context.Context, in *Stop_Request, opts ...grpc.CallOption) (*Stop_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(Stop_Response) - err := c.cc.Invoke(ctx, Provisioner_Stop_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provisioner_Stop_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -1307,18 +1288,21 @@ func (c *provisionerClient) Stop(ctx context.Context, in *Stop_Request, opts ... // ProvisionerServer is the server API for Provisioner service. // All implementations must embed UnimplementedProvisionerServer -// for forward compatibility +// for forward compatibility. type ProvisionerServer interface { GetSchema(context.Context, *GetProvisionerSchema_Request) (*GetProvisionerSchema_Response, error) ValidateProvisionerConfig(context.Context, *ValidateProvisionerConfig_Request) (*ValidateProvisionerConfig_Response, error) - ProvisionResource(*ProvisionResource_Request, Provisioner_ProvisionResourceServer) error + ProvisionResource(*ProvisionResource_Request, grpc.ServerStreamingServer[ProvisionResource_Response]) error Stop(context.Context, *Stop_Request) (*Stop_Response, error) mustEmbedUnimplementedProvisionerServer() } -// UnimplementedProvisionerServer must be embedded to have forward compatible implementations. -type UnimplementedProvisionerServer struct { -} +// UnimplementedProvisionerServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedProvisionerServer struct{} func (UnimplementedProvisionerServer) GetSchema(context.Context, *GetProvisionerSchema_Request) (*GetProvisionerSchema_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method GetSchema not implemented") @@ -1326,13 +1310,14 @@ func (UnimplementedProvisionerServer) GetSchema(context.Context, *GetProvisioner func (UnimplementedProvisionerServer) ValidateProvisionerConfig(context.Context, *ValidateProvisionerConfig_Request) (*ValidateProvisionerConfig_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method ValidateProvisionerConfig not implemented") } -func (UnimplementedProvisionerServer) ProvisionResource(*ProvisionResource_Request, Provisioner_ProvisionResourceServer) error { +func (UnimplementedProvisionerServer) ProvisionResource(*ProvisionResource_Request, grpc.ServerStreamingServer[ProvisionResource_Response]) error { return status.Errorf(codes.Unimplemented, "method ProvisionResource not implemented") } func (UnimplementedProvisionerServer) Stop(context.Context, *Stop_Request) (*Stop_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method Stop not implemented") } func (UnimplementedProvisionerServer) mustEmbedUnimplementedProvisionerServer() {} +func (UnimplementedProvisionerServer) testEmbeddedByValue() {} // UnsafeProvisionerServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to ProvisionerServer will @@ -1342,6 +1327,13 @@ type UnsafeProvisionerServer interface { } func RegisterProvisionerServer(s grpc.ServiceRegistrar, srv ProvisionerServer) { + // If the following call pancis, it indicates UnimplementedProvisionerServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&Provisioner_ServiceDesc, srv) } @@ -1386,21 +1378,11 @@ func _Provisioner_ProvisionResource_Handler(srv interface{}, stream grpc.ServerS if err := stream.RecvMsg(m); err != nil { return err } - return srv.(ProvisionerServer).ProvisionResource(m, &provisionerProvisionResourceServer{stream}) + return srv.(ProvisionerServer).ProvisionResource(m, &grpc.GenericServerStream[ProvisionResource_Request, ProvisionResource_Response]{ServerStream: stream}) } -type Provisioner_ProvisionResourceServer interface { - Send(*ProvisionResource_Response) error - grpc.ServerStream -} - -type provisionerProvisionResourceServer struct { - grpc.ServerStream -} - -func (x *provisionerProvisionResourceServer) Send(m *ProvisionResource_Response) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provisioner_ProvisionResourceServer = grpc.ServerStreamingServer[ProvisionResource_Response] func _Provisioner_Stop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(Stop_Request) diff --git a/internal/tfplugin6/tfplugin6.pb.go b/internal/tfplugin6/tfplugin6.pb.go index ddbec14cda..bb76eff6f1 100644 --- a/internal/tfplugin6/tfplugin6.pb.go +++ b/internal/tfplugin6/tfplugin6.pb.go @@ -22,7 +22,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.6 -// protoc v3.15.6 +// protoc v5.29.3 // source: tfplugin6.proto package tfplugin6 diff --git a/internal/tfplugin6/tfplugin6_grpc.pb.go b/internal/tfplugin6/tfplugin6_grpc.pb.go index 134bb9cd98..009da41f26 100644 --- a/internal/tfplugin6/tfplugin6_grpc.pb.go +++ b/internal/tfplugin6/tfplugin6_grpc.pb.go @@ -21,8 +21,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: -// - protoc-gen-go-grpc v1.3.0 -// - protoc v3.15.6 +// - protoc-gen-go-grpc v1.5.1 +// - protoc v5.29.3 // source: tfplugin6.proto package tfplugin6 @@ -36,8 +36,8 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 const ( Provider_GetMetadata_FullMethodName = "/tfplugin6.Provider/GetMetadata" @@ -117,7 +117,7 @@ type ProviderClient interface { RenewEphemeralResource(ctx context.Context, in *RenewEphemeralResource_Request, opts ...grpc.CallOption) (*RenewEphemeralResource_Response, error) CloseEphemeralResource(ctx context.Context, in *CloseEphemeralResource_Request, opts ...grpc.CallOption) (*CloseEphemeralResource_Response, error) // ///// List - ListResource(ctx context.Context, in *ListResource_Request, opts ...grpc.CallOption) (Provider_ListResourceClient, error) + ListResource(ctx context.Context, in *ListResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListResource_Event], error) ValidateListResourceConfig(ctx context.Context, in *ValidateListResourceConfig_Request, opts ...grpc.CallOption) (*ValidateListResourceConfig_Response, error) // GetFunctions returns the definitions of all functions. GetFunctions(ctx context.Context, in *GetFunctions_Request, opts ...grpc.CallOption) (*GetFunctions_Response, error) @@ -128,9 +128,9 @@ type ProviderClient interface { // ConfigureStateStore configures the state store, such as S3 connection in the context of already configured provider ConfigureStateStore(ctx context.Context, in *ConfigureStateStore_Request, opts ...grpc.CallOption) (*ConfigureStateStore_Response, error) // ReadStateBytes streams byte chunks of a given state file from a state store - ReadStateBytes(ctx context.Context, in *ReadStateBytes_Request, opts ...grpc.CallOption) (Provider_ReadStateBytesClient, error) + ReadStateBytes(ctx context.Context, in *ReadStateBytes_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ReadStateBytes_Response], error) // WriteStateBytes streams byte chunks of a given state file into a state store - WriteStateBytes(ctx context.Context, opts ...grpc.CallOption) (Provider_WriteStateBytesClient, error) + WriteStateBytes(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[WriteStateBytes_RequestChunk, WriteStateBytes_Response], error) // LockState locks a given state (i.e. CE workspace) LockState(ctx context.Context, in *LockState_Request, opts ...grpc.CallOption) (*LockState_Response, error) // UnlockState unlocks a given state (i.e. CE workspace) @@ -141,7 +141,7 @@ type ProviderClient interface { DeleteState(ctx context.Context, in *DeleteState_Request, opts ...grpc.CallOption) (*DeleteState_Response, error) // ////// Actions PlanAction(ctx context.Context, in *PlanAction_Request, opts ...grpc.CallOption) (*PlanAction_Response, error) - InvokeAction(ctx context.Context, in *InvokeAction_Request, opts ...grpc.CallOption) (Provider_InvokeActionClient, error) + InvokeAction(ctx context.Context, in *InvokeAction_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[InvokeAction_Event], error) ValidateActionConfig(ctx context.Context, in *ValidateActionConfig_Request, opts ...grpc.CallOption) (*ValidateActionConfig_Response, error) // ////// Graceful Shutdown StopProvider(ctx context.Context, in *StopProvider_Request, opts ...grpc.CallOption) (*StopProvider_Response, error) @@ -156,8 +156,9 @@ func NewProviderClient(cc grpc.ClientConnInterface) ProviderClient { } func (c *providerClient) GetMetadata(ctx context.Context, in *GetMetadata_Request, opts ...grpc.CallOption) (*GetMetadata_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetMetadata_Response) - err := c.cc.Invoke(ctx, Provider_GetMetadata_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GetMetadata_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -165,8 +166,9 @@ func (c *providerClient) GetMetadata(ctx context.Context, in *GetMetadata_Reques } func (c *providerClient) GetProviderSchema(ctx context.Context, in *GetProviderSchema_Request, opts ...grpc.CallOption) (*GetProviderSchema_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetProviderSchema_Response) - err := c.cc.Invoke(ctx, Provider_GetProviderSchema_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GetProviderSchema_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -174,8 +176,9 @@ func (c *providerClient) GetProviderSchema(ctx context.Context, in *GetProviderS } func (c *providerClient) ValidateProviderConfig(ctx context.Context, in *ValidateProviderConfig_Request, opts ...grpc.CallOption) (*ValidateProviderConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateProviderConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateProviderConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateProviderConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -183,8 +186,9 @@ func (c *providerClient) ValidateProviderConfig(ctx context.Context, in *Validat } func (c *providerClient) ValidateResourceConfig(ctx context.Context, in *ValidateResourceConfig_Request, opts ...grpc.CallOption) (*ValidateResourceConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateResourceConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateResourceConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateResourceConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -192,8 +196,9 @@ func (c *providerClient) ValidateResourceConfig(ctx context.Context, in *Validat } func (c *providerClient) ValidateDataResourceConfig(ctx context.Context, in *ValidateDataResourceConfig_Request, opts ...grpc.CallOption) (*ValidateDataResourceConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateDataResourceConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateDataResourceConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateDataResourceConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -201,8 +206,9 @@ func (c *providerClient) ValidateDataResourceConfig(ctx context.Context, in *Val } func (c *providerClient) UpgradeResourceState(ctx context.Context, in *UpgradeResourceState_Request, opts ...grpc.CallOption) (*UpgradeResourceState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(UpgradeResourceState_Response) - err := c.cc.Invoke(ctx, Provider_UpgradeResourceState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_UpgradeResourceState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -210,8 +216,9 @@ func (c *providerClient) UpgradeResourceState(ctx context.Context, in *UpgradeRe } func (c *providerClient) GetResourceIdentitySchemas(ctx context.Context, in *GetResourceIdentitySchemas_Request, opts ...grpc.CallOption) (*GetResourceIdentitySchemas_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetResourceIdentitySchemas_Response) - err := c.cc.Invoke(ctx, Provider_GetResourceIdentitySchemas_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GetResourceIdentitySchemas_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -219,8 +226,9 @@ func (c *providerClient) GetResourceIdentitySchemas(ctx context.Context, in *Get } func (c *providerClient) UpgradeResourceIdentity(ctx context.Context, in *UpgradeResourceIdentity_Request, opts ...grpc.CallOption) (*UpgradeResourceIdentity_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(UpgradeResourceIdentity_Response) - err := c.cc.Invoke(ctx, Provider_UpgradeResourceIdentity_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_UpgradeResourceIdentity_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -228,8 +236,9 @@ func (c *providerClient) UpgradeResourceIdentity(ctx context.Context, in *Upgrad } func (c *providerClient) ConfigureProvider(ctx context.Context, in *ConfigureProvider_Request, opts ...grpc.CallOption) (*ConfigureProvider_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ConfigureProvider_Response) - err := c.cc.Invoke(ctx, Provider_ConfigureProvider_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ConfigureProvider_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -237,8 +246,9 @@ func (c *providerClient) ConfigureProvider(ctx context.Context, in *ConfigurePro } func (c *providerClient) ReadResource(ctx context.Context, in *ReadResource_Request, opts ...grpc.CallOption) (*ReadResource_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ReadResource_Response) - err := c.cc.Invoke(ctx, Provider_ReadResource_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ReadResource_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -246,8 +256,9 @@ func (c *providerClient) ReadResource(ctx context.Context, in *ReadResource_Requ } func (c *providerClient) PlanResourceChange(ctx context.Context, in *PlanResourceChange_Request, opts ...grpc.CallOption) (*PlanResourceChange_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(PlanResourceChange_Response) - err := c.cc.Invoke(ctx, Provider_PlanResourceChange_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_PlanResourceChange_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -255,8 +266,9 @@ func (c *providerClient) PlanResourceChange(ctx context.Context, in *PlanResourc } func (c *providerClient) ApplyResourceChange(ctx context.Context, in *ApplyResourceChange_Request, opts ...grpc.CallOption) (*ApplyResourceChange_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ApplyResourceChange_Response) - err := c.cc.Invoke(ctx, Provider_ApplyResourceChange_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ApplyResourceChange_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -264,8 +276,9 @@ func (c *providerClient) ApplyResourceChange(ctx context.Context, in *ApplyResou } func (c *providerClient) ImportResourceState(ctx context.Context, in *ImportResourceState_Request, opts ...grpc.CallOption) (*ImportResourceState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ImportResourceState_Response) - err := c.cc.Invoke(ctx, Provider_ImportResourceState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ImportResourceState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -273,8 +286,9 @@ func (c *providerClient) ImportResourceState(ctx context.Context, in *ImportReso } func (c *providerClient) MoveResourceState(ctx context.Context, in *MoveResourceState_Request, opts ...grpc.CallOption) (*MoveResourceState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(MoveResourceState_Response) - err := c.cc.Invoke(ctx, Provider_MoveResourceState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_MoveResourceState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -282,8 +296,9 @@ func (c *providerClient) MoveResourceState(ctx context.Context, in *MoveResource } func (c *providerClient) ReadDataSource(ctx context.Context, in *ReadDataSource_Request, opts ...grpc.CallOption) (*ReadDataSource_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ReadDataSource_Response) - err := c.cc.Invoke(ctx, Provider_ReadDataSource_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ReadDataSource_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -291,8 +306,9 @@ func (c *providerClient) ReadDataSource(ctx context.Context, in *ReadDataSource_ } func (c *providerClient) GenerateResourceConfig(ctx context.Context, in *GenerateResourceConfig_Request, opts ...grpc.CallOption) (*GenerateResourceConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GenerateResourceConfig_Response) - err := c.cc.Invoke(ctx, Provider_GenerateResourceConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GenerateResourceConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -300,8 +316,9 @@ func (c *providerClient) GenerateResourceConfig(ctx context.Context, in *Generat } func (c *providerClient) ValidateEphemeralResourceConfig(ctx context.Context, in *ValidateEphemeralResourceConfig_Request, opts ...grpc.CallOption) (*ValidateEphemeralResourceConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateEphemeralResourceConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateEphemeralResourceConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateEphemeralResourceConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -309,8 +326,9 @@ func (c *providerClient) ValidateEphemeralResourceConfig(ctx context.Context, in } func (c *providerClient) OpenEphemeralResource(ctx context.Context, in *OpenEphemeralResource_Request, opts ...grpc.CallOption) (*OpenEphemeralResource_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(OpenEphemeralResource_Response) - err := c.cc.Invoke(ctx, Provider_OpenEphemeralResource_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_OpenEphemeralResource_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -318,8 +336,9 @@ func (c *providerClient) OpenEphemeralResource(ctx context.Context, in *OpenEphe } func (c *providerClient) RenewEphemeralResource(ctx context.Context, in *RenewEphemeralResource_Request, opts ...grpc.CallOption) (*RenewEphemeralResource_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RenewEphemeralResource_Response) - err := c.cc.Invoke(ctx, Provider_RenewEphemeralResource_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_RenewEphemeralResource_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -327,20 +346,22 @@ func (c *providerClient) RenewEphemeralResource(ctx context.Context, in *RenewEp } func (c *providerClient) CloseEphemeralResource(ctx context.Context, in *CloseEphemeralResource_Request, opts ...grpc.CallOption) (*CloseEphemeralResource_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CloseEphemeralResource_Response) - err := c.cc.Invoke(ctx, Provider_CloseEphemeralResource_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_CloseEphemeralResource_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *providerClient) ListResource(ctx context.Context, in *ListResource_Request, opts ...grpc.CallOption) (Provider_ListResourceClient, error) { - stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[0], Provider_ListResource_FullMethodName, opts...) +func (c *providerClient) ListResource(ctx context.Context, in *ListResource_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ListResource_Event], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[0], Provider_ListResource_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &providerListResourceClient{stream} + x := &grpc.GenericClientStream[ListResource_Request, ListResource_Event]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -350,26 +371,13 @@ func (c *providerClient) ListResource(ctx context.Context, in *ListResource_Requ return x, nil } -type Provider_ListResourceClient interface { - Recv() (*ListResource_Event, error) - grpc.ClientStream -} - -type providerListResourceClient struct { - grpc.ClientStream -} - -func (x *providerListResourceClient) Recv() (*ListResource_Event, error) { - m := new(ListResource_Event) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_ListResourceClient = grpc.ServerStreamingClient[ListResource_Event] func (c *providerClient) ValidateListResourceConfig(ctx context.Context, in *ValidateListResourceConfig_Request, opts ...grpc.CallOption) (*ValidateListResourceConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateListResourceConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateListResourceConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateListResourceConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -377,8 +385,9 @@ func (c *providerClient) ValidateListResourceConfig(ctx context.Context, in *Val } func (c *providerClient) GetFunctions(ctx context.Context, in *GetFunctions_Request, opts ...grpc.CallOption) (*GetFunctions_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetFunctions_Response) - err := c.cc.Invoke(ctx, Provider_GetFunctions_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GetFunctions_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -386,8 +395,9 @@ func (c *providerClient) GetFunctions(ctx context.Context, in *GetFunctions_Requ } func (c *providerClient) CallFunction(ctx context.Context, in *CallFunction_Request, opts ...grpc.CallOption) (*CallFunction_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CallFunction_Response) - err := c.cc.Invoke(ctx, Provider_CallFunction_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_CallFunction_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -395,8 +405,9 @@ func (c *providerClient) CallFunction(ctx context.Context, in *CallFunction_Requ } func (c *providerClient) ValidateStateStoreConfig(ctx context.Context, in *ValidateStateStore_Request, opts ...grpc.CallOption) (*ValidateStateStore_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateStateStore_Response) - err := c.cc.Invoke(ctx, Provider_ValidateStateStoreConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateStateStoreConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -404,20 +415,22 @@ func (c *providerClient) ValidateStateStoreConfig(ctx context.Context, in *Valid } func (c *providerClient) ConfigureStateStore(ctx context.Context, in *ConfigureStateStore_Request, opts ...grpc.CallOption) (*ConfigureStateStore_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ConfigureStateStore_Response) - err := c.cc.Invoke(ctx, Provider_ConfigureStateStore_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ConfigureStateStore_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *providerClient) ReadStateBytes(ctx context.Context, in *ReadStateBytes_Request, opts ...grpc.CallOption) (Provider_ReadStateBytesClient, error) { - stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[1], Provider_ReadStateBytes_FullMethodName, opts...) +func (c *providerClient) ReadStateBytes(ctx context.Context, in *ReadStateBytes_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ReadStateBytes_Response], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[1], Provider_ReadStateBytes_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &providerReadStateBytesClient{stream} + x := &grpc.GenericClientStream[ReadStateBytes_Request, ReadStateBytes_Response]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -427,60 +440,26 @@ func (c *providerClient) ReadStateBytes(ctx context.Context, in *ReadStateBytes_ return x, nil } -type Provider_ReadStateBytesClient interface { - Recv() (*ReadStateBytes_Response, error) - grpc.ClientStream -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_ReadStateBytesClient = grpc.ServerStreamingClient[ReadStateBytes_Response] -type providerReadStateBytesClient struct { - grpc.ClientStream -} - -func (x *providerReadStateBytesClient) Recv() (*ReadStateBytes_Response, error) { - m := new(ReadStateBytes_Response) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} - -func (c *providerClient) WriteStateBytes(ctx context.Context, opts ...grpc.CallOption) (Provider_WriteStateBytesClient, error) { - stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[2], Provider_WriteStateBytes_FullMethodName, opts...) +func (c *providerClient) WriteStateBytes(ctx context.Context, opts ...grpc.CallOption) (grpc.ClientStreamingClient[WriteStateBytes_RequestChunk, WriteStateBytes_Response], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[2], Provider_WriteStateBytes_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &providerWriteStateBytesClient{stream} + x := &grpc.GenericClientStream[WriteStateBytes_RequestChunk, WriteStateBytes_Response]{ClientStream: stream} return x, nil } -type Provider_WriteStateBytesClient interface { - Send(*WriteStateBytes_RequestChunk) error - CloseAndRecv() (*WriteStateBytes_Response, error) - grpc.ClientStream -} - -type providerWriteStateBytesClient struct { - grpc.ClientStream -} - -func (x *providerWriteStateBytesClient) Send(m *WriteStateBytes_RequestChunk) error { - return x.ClientStream.SendMsg(m) -} - -func (x *providerWriteStateBytesClient) CloseAndRecv() (*WriteStateBytes_Response, error) { - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err - } - m := new(WriteStateBytes_Response) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_WriteStateBytesClient = grpc.ClientStreamingClient[WriteStateBytes_RequestChunk, WriteStateBytes_Response] func (c *providerClient) LockState(ctx context.Context, in *LockState_Request, opts ...grpc.CallOption) (*LockState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(LockState_Response) - err := c.cc.Invoke(ctx, Provider_LockState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_LockState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -488,8 +467,9 @@ func (c *providerClient) LockState(ctx context.Context, in *LockState_Request, o } func (c *providerClient) UnlockState(ctx context.Context, in *UnlockState_Request, opts ...grpc.CallOption) (*UnlockState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(UnlockState_Response) - err := c.cc.Invoke(ctx, Provider_UnlockState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_UnlockState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -497,8 +477,9 @@ func (c *providerClient) UnlockState(ctx context.Context, in *UnlockState_Reques } func (c *providerClient) GetStates(ctx context.Context, in *GetStates_Request, opts ...grpc.CallOption) (*GetStates_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetStates_Response) - err := c.cc.Invoke(ctx, Provider_GetStates_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_GetStates_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -506,8 +487,9 @@ func (c *providerClient) GetStates(ctx context.Context, in *GetStates_Request, o } func (c *providerClient) DeleteState(ctx context.Context, in *DeleteState_Request, opts ...grpc.CallOption) (*DeleteState_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(DeleteState_Response) - err := c.cc.Invoke(ctx, Provider_DeleteState_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_DeleteState_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -515,20 +497,22 @@ func (c *providerClient) DeleteState(ctx context.Context, in *DeleteState_Reques } func (c *providerClient) PlanAction(ctx context.Context, in *PlanAction_Request, opts ...grpc.CallOption) (*PlanAction_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(PlanAction_Response) - err := c.cc.Invoke(ctx, Provider_PlanAction_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_PlanAction_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *providerClient) InvokeAction(ctx context.Context, in *InvokeAction_Request, opts ...grpc.CallOption) (Provider_InvokeActionClient, error) { - stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[3], Provider_InvokeAction_FullMethodName, opts...) +func (c *providerClient) InvokeAction(ctx context.Context, in *InvokeAction_Request, opts ...grpc.CallOption) (grpc.ServerStreamingClient[InvokeAction_Event], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Provider_ServiceDesc.Streams[3], Provider_InvokeAction_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &providerInvokeActionClient{stream} + x := &grpc.GenericClientStream[InvokeAction_Request, InvokeAction_Event]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -538,26 +522,13 @@ func (c *providerClient) InvokeAction(ctx context.Context, in *InvokeAction_Requ return x, nil } -type Provider_InvokeActionClient interface { - Recv() (*InvokeAction_Event, error) - grpc.ClientStream -} - -type providerInvokeActionClient struct { - grpc.ClientStream -} - -func (x *providerInvokeActionClient) Recv() (*InvokeAction_Event, error) { - m := new(InvokeAction_Event) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_InvokeActionClient = grpc.ServerStreamingClient[InvokeAction_Event] func (c *providerClient) ValidateActionConfig(ctx context.Context, in *ValidateActionConfig_Request, opts ...grpc.CallOption) (*ValidateActionConfig_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ValidateActionConfig_Response) - err := c.cc.Invoke(ctx, Provider_ValidateActionConfig_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_ValidateActionConfig_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -565,8 +536,9 @@ func (c *providerClient) ValidateActionConfig(ctx context.Context, in *ValidateA } func (c *providerClient) StopProvider(ctx context.Context, in *StopProvider_Request, opts ...grpc.CallOption) (*StopProvider_Response, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(StopProvider_Response) - err := c.cc.Invoke(ctx, Provider_StopProvider_FullMethodName, in, out, opts...) + err := c.cc.Invoke(ctx, Provider_StopProvider_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -575,7 +547,7 @@ func (c *providerClient) StopProvider(ctx context.Context, in *StopProvider_Requ // ProviderServer is the server API for Provider service. // All implementations must embed UnimplementedProviderServer -// for forward compatibility +// for forward compatibility. type ProviderServer interface { // GetMetadata returns upfront information about server capabilities and // supported resource types without requiring the server to instantiate all @@ -612,7 +584,7 @@ type ProviderServer interface { RenewEphemeralResource(context.Context, *RenewEphemeralResource_Request) (*RenewEphemeralResource_Response, error) CloseEphemeralResource(context.Context, *CloseEphemeralResource_Request) (*CloseEphemeralResource_Response, error) // ///// List - ListResource(*ListResource_Request, Provider_ListResourceServer) error + ListResource(*ListResource_Request, grpc.ServerStreamingServer[ListResource_Event]) error ValidateListResourceConfig(context.Context, *ValidateListResourceConfig_Request) (*ValidateListResourceConfig_Response, error) // GetFunctions returns the definitions of all functions. GetFunctions(context.Context, *GetFunctions_Request) (*GetFunctions_Response, error) @@ -623,9 +595,9 @@ type ProviderServer interface { // ConfigureStateStore configures the state store, such as S3 connection in the context of already configured provider ConfigureStateStore(context.Context, *ConfigureStateStore_Request) (*ConfigureStateStore_Response, error) // ReadStateBytes streams byte chunks of a given state file from a state store - ReadStateBytes(*ReadStateBytes_Request, Provider_ReadStateBytesServer) error + ReadStateBytes(*ReadStateBytes_Request, grpc.ServerStreamingServer[ReadStateBytes_Response]) error // WriteStateBytes streams byte chunks of a given state file into a state store - WriteStateBytes(Provider_WriteStateBytesServer) error + WriteStateBytes(grpc.ClientStreamingServer[WriteStateBytes_RequestChunk, WriteStateBytes_Response]) error // LockState locks a given state (i.e. CE workspace) LockState(context.Context, *LockState_Request) (*LockState_Response, error) // UnlockState unlocks a given state (i.e. CE workspace) @@ -636,16 +608,19 @@ type ProviderServer interface { DeleteState(context.Context, *DeleteState_Request) (*DeleteState_Response, error) // ////// Actions PlanAction(context.Context, *PlanAction_Request) (*PlanAction_Response, error) - InvokeAction(*InvokeAction_Request, Provider_InvokeActionServer) error + InvokeAction(*InvokeAction_Request, grpc.ServerStreamingServer[InvokeAction_Event]) error ValidateActionConfig(context.Context, *ValidateActionConfig_Request) (*ValidateActionConfig_Response, error) // ////// Graceful Shutdown StopProvider(context.Context, *StopProvider_Request) (*StopProvider_Response, error) mustEmbedUnimplementedProviderServer() } -// UnimplementedProviderServer must be embedded to have forward compatible implementations. -type UnimplementedProviderServer struct { -} +// UnimplementedProviderServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedProviderServer struct{} func (UnimplementedProviderServer) GetMetadata(context.Context, *GetMetadata_Request) (*GetMetadata_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method GetMetadata not implemented") @@ -707,7 +682,7 @@ func (UnimplementedProviderServer) RenewEphemeralResource(context.Context, *Rene func (UnimplementedProviderServer) CloseEphemeralResource(context.Context, *CloseEphemeralResource_Request) (*CloseEphemeralResource_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method CloseEphemeralResource not implemented") } -func (UnimplementedProviderServer) ListResource(*ListResource_Request, Provider_ListResourceServer) error { +func (UnimplementedProviderServer) ListResource(*ListResource_Request, grpc.ServerStreamingServer[ListResource_Event]) error { return status.Errorf(codes.Unimplemented, "method ListResource not implemented") } func (UnimplementedProviderServer) ValidateListResourceConfig(context.Context, *ValidateListResourceConfig_Request) (*ValidateListResourceConfig_Response, error) { @@ -725,10 +700,10 @@ func (UnimplementedProviderServer) ValidateStateStoreConfig(context.Context, *Va func (UnimplementedProviderServer) ConfigureStateStore(context.Context, *ConfigureStateStore_Request) (*ConfigureStateStore_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method ConfigureStateStore not implemented") } -func (UnimplementedProviderServer) ReadStateBytes(*ReadStateBytes_Request, Provider_ReadStateBytesServer) error { +func (UnimplementedProviderServer) ReadStateBytes(*ReadStateBytes_Request, grpc.ServerStreamingServer[ReadStateBytes_Response]) error { return status.Errorf(codes.Unimplemented, "method ReadStateBytes not implemented") } -func (UnimplementedProviderServer) WriteStateBytes(Provider_WriteStateBytesServer) error { +func (UnimplementedProviderServer) WriteStateBytes(grpc.ClientStreamingServer[WriteStateBytes_RequestChunk, WriteStateBytes_Response]) error { return status.Errorf(codes.Unimplemented, "method WriteStateBytes not implemented") } func (UnimplementedProviderServer) LockState(context.Context, *LockState_Request) (*LockState_Response, error) { @@ -746,7 +721,7 @@ func (UnimplementedProviderServer) DeleteState(context.Context, *DeleteState_Req func (UnimplementedProviderServer) PlanAction(context.Context, *PlanAction_Request) (*PlanAction_Response, error) { return nil, status.Errorf(codes.Unimplemented, "method PlanAction not implemented") } -func (UnimplementedProviderServer) InvokeAction(*InvokeAction_Request, Provider_InvokeActionServer) error { +func (UnimplementedProviderServer) InvokeAction(*InvokeAction_Request, grpc.ServerStreamingServer[InvokeAction_Event]) error { return status.Errorf(codes.Unimplemented, "method InvokeAction not implemented") } func (UnimplementedProviderServer) ValidateActionConfig(context.Context, *ValidateActionConfig_Request) (*ValidateActionConfig_Response, error) { @@ -756,6 +731,7 @@ func (UnimplementedProviderServer) StopProvider(context.Context, *StopProvider_R return nil, status.Errorf(codes.Unimplemented, "method StopProvider not implemented") } func (UnimplementedProviderServer) mustEmbedUnimplementedProviderServer() {} +func (UnimplementedProviderServer) testEmbeddedByValue() {} // UnsafeProviderServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to ProviderServer will @@ -765,6 +741,13 @@ type UnsafeProviderServer interface { } func RegisterProviderServer(s grpc.ServiceRegistrar, srv ProviderServer) { + // If the following call pancis, it indicates UnimplementedProviderServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&Provider_ServiceDesc, srv) } @@ -1133,21 +1116,11 @@ func _Provider_ListResource_Handler(srv interface{}, stream grpc.ServerStream) e if err := stream.RecvMsg(m); err != nil { return err } - return srv.(ProviderServer).ListResource(m, &providerListResourceServer{stream}) + return srv.(ProviderServer).ListResource(m, &grpc.GenericServerStream[ListResource_Request, ListResource_Event]{ServerStream: stream}) } -type Provider_ListResourceServer interface { - Send(*ListResource_Event) error - grpc.ServerStream -} - -type providerListResourceServer struct { - grpc.ServerStream -} - -func (x *providerListResourceServer) Send(m *ListResource_Event) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_ListResourceServer = grpc.ServerStreamingServer[ListResource_Event] func _Provider_ValidateListResourceConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ValidateListResourceConfig_Request) @@ -1244,47 +1217,18 @@ func _Provider_ReadStateBytes_Handler(srv interface{}, stream grpc.ServerStream) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(ProviderServer).ReadStateBytes(m, &providerReadStateBytesServer{stream}) -} - -type Provider_ReadStateBytesServer interface { - Send(*ReadStateBytes_Response) error - grpc.ServerStream -} - -type providerReadStateBytesServer struct { - grpc.ServerStream + return srv.(ProviderServer).ReadStateBytes(m, &grpc.GenericServerStream[ReadStateBytes_Request, ReadStateBytes_Response]{ServerStream: stream}) } -func (x *providerReadStateBytesServer) Send(m *ReadStateBytes_Response) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_ReadStateBytesServer = grpc.ServerStreamingServer[ReadStateBytes_Response] func _Provider_WriteStateBytes_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(ProviderServer).WriteStateBytes(&providerWriteStateBytesServer{stream}) -} - -type Provider_WriteStateBytesServer interface { - SendAndClose(*WriteStateBytes_Response) error - Recv() (*WriteStateBytes_RequestChunk, error) - grpc.ServerStream -} - -type providerWriteStateBytesServer struct { - grpc.ServerStream + return srv.(ProviderServer).WriteStateBytes(&grpc.GenericServerStream[WriteStateBytes_RequestChunk, WriteStateBytes_Response]{ServerStream: stream}) } -func (x *providerWriteStateBytesServer) SendAndClose(m *WriteStateBytes_Response) error { - return x.ServerStream.SendMsg(m) -} - -func (x *providerWriteStateBytesServer) Recv() (*WriteStateBytes_RequestChunk, error) { - m := new(WriteStateBytes_RequestChunk) - if err := x.ServerStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_WriteStateBytesServer = grpc.ClientStreamingServer[WriteStateBytes_RequestChunk, WriteStateBytes_Response] func _Provider_LockState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(LockState_Request) @@ -1381,21 +1325,11 @@ func _Provider_InvokeAction_Handler(srv interface{}, stream grpc.ServerStream) e if err := stream.RecvMsg(m); err != nil { return err } - return srv.(ProviderServer).InvokeAction(m, &providerInvokeActionServer{stream}) -} - -type Provider_InvokeActionServer interface { - Send(*InvokeAction_Event) error - grpc.ServerStream + return srv.(ProviderServer).InvokeAction(m, &grpc.GenericServerStream[InvokeAction_Request, InvokeAction_Event]{ServerStream: stream}) } -type providerInvokeActionServer struct { - grpc.ServerStream -} - -func (x *providerInvokeActionServer) Send(m *InvokeAction_Event) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Provider_InvokeActionServer = grpc.ServerStreamingServer[InvokeAction_Event] func _Provider_ValidateActionConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ValidateActionConfig_Request) diff --git a/tools/protobuf-compile/protobuf-compile.go b/tools/protobuf-compile/protobuf-compile.go index 2d954f4ffd..c130cf198e 100644 --- a/tools/protobuf-compile/protobuf-compile.go +++ b/tools/protobuf-compile/protobuf-compile.go @@ -27,7 +27,8 @@ import ( "github.com/hashicorp/go-getter" ) -const protocVersion = "3.15.6" +// Release v29.3 in GitHub corresponds to protoc v5.29.3, which is currently used in terraform-plugin-go +const protocVersion = "29.3" // We also use protoc-gen-go and its grpc addon, but since these are Go tools // in Go modules our version selection for these comes from our top-level