diff --git a/api/golang/core/kurtosis_core_rpc_api_bindings/kurtosis_core_rpc_api_bindingsconnect/api_container_service.connect.go b/api/golang/core/kurtosis_core_rpc_api_bindings/kurtosis_core_rpc_api_bindingsconnect/api_container_service.connect.go index c67ce705a3..4b096f6a58 100644 --- a/api/golang/core/kurtosis_core_rpc_api_bindings/kurtosis_core_rpc_api_bindingsconnect/api_container_service.connect.go +++ b/api/golang/core/kurtosis_core_rpc_api_bindings/kurtosis_core_rpc_api_bindingsconnect/api_container_service.connect.go @@ -5,9 +5,9 @@ package kurtosis_core_rpc_api_bindingsconnect import ( + connect "connectrpc.com/connect" context "context" errors "errors" - connect_go "github.com/bufbuild/connect-go" kurtosis_core_rpc_api_bindings "github.com/kurtosis-tech/kurtosis/api/golang/core/kurtosis_core_rpc_api_bindings" emptypb "google.golang.org/protobuf/types/known/emptypb" http "net/http" @@ -19,7 +19,7 @@ import ( // generated with a version of connect newer than the one compiled into your binary. You can fix the // problem by either regenerating this code with an older version of connect or updating the connect // version compiled into your binary. -const _ = connect_go.IsAtLeastVersion0_1_0 +const _ = connect.IsAtLeastVersion0_1_0 const ( // ApiContainerServiceName is the fully-qualified name of the ApiContainerService service. @@ -81,31 +81,31 @@ const ( // ApiContainerServiceClient is a client for the api_container_api.ApiContainerService service. type ApiContainerServiceClient interface { // Executes a Starlark script on the user's behalf - RunStarlarkScript(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs]) (*connect_go.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine], error) + RunStarlarkScript(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs]) (*connect.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine], error) // Uploads a Starlark package. This step is required before the package can be executed with RunStarlarkPackage - UploadStarlarkPackage(context.Context) *connect_go.ClientStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, emptypb.Empty] + UploadStarlarkPackage(context.Context) *connect.ClientStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, emptypb.Empty] // Executes a Starlark script on the user's behalf - RunStarlarkPackage(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs]) (*connect_go.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine], error) + RunStarlarkPackage(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs]) (*connect.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine], error) // Returns the IDs of the current services in the enclave - GetServices(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.GetServicesArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.GetServicesResponse], error) + GetServices(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.GetServicesArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.GetServicesResponse], error) // Returns information about all existing & historical services - GetExistingAndHistoricalServiceIdentifiers(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse], error) + GetExistingAndHistoricalServiceIdentifiers(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse], error) // Executes the given command inside a running container - ExecCommand(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.ExecCommandArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.ExecCommandResponse], error) + ExecCommand(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.ExecCommandArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.ExecCommandResponse], error) // Block until the given HTTP endpoint returns available, calling it through a HTTP Get request - WaitForHttpGetEndpointAvailability(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs]) (*connect_go.Response[emptypb.Empty], error) + WaitForHttpGetEndpointAvailability(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs]) (*connect.Response[emptypb.Empty], error) // Block until the given HTTP endpoint returns available, calling it through a HTTP Post request - WaitForHttpPostEndpointAvailability(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs]) (*connect_go.Response[emptypb.Empty], error) + WaitForHttpPostEndpointAvailability(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs]) (*connect.Response[emptypb.Empty], error) // Uploads a files artifact to the Kurtosis File System - UploadFilesArtifact(context.Context) *connect_go.ClientStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse] + UploadFilesArtifact(context.Context) *connect.ClientStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse] // Downloads a files artifact from the Kurtosis File System - DownloadFilesArtifact(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs]) (*connect_go.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk], error) + DownloadFilesArtifact(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs]) (*connect.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk], error) // Tells the API container to download a files artifact from the web to the Kurtosis File System - StoreWebFilesArtifact(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse], error) + StoreWebFilesArtifact(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse], error) // Tells the API container to copy a files artifact from a service to the Kurtosis File System - StoreFilesArtifactFromService(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse], error) - ListFilesArtifactNamesAndUuids(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse], error) - InspectFilesArtifactContents(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse], error) + StoreFilesArtifactFromService(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse], error) + ListFilesArtifactNamesAndUuids(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse], error) + InspectFilesArtifactContents(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest]) (*connect.Response[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse], error) } // NewApiContainerServiceClient constructs a client for the api_container_api.ApiContainerService @@ -115,75 +115,75 @@ type ApiContainerServiceClient interface { // // The URL supplied here should be the base URL for the Connect or gRPC server (for example, // http://api.acme.com or https://acme.com/grpc). -func NewApiContainerServiceClient(httpClient connect_go.HTTPClient, baseURL string, opts ...connect_go.ClientOption) ApiContainerServiceClient { +func NewApiContainerServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ApiContainerServiceClient { baseURL = strings.TrimRight(baseURL, "/") return &apiContainerServiceClient{ - runStarlarkScript: connect_go.NewClient[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs, kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]( + runStarlarkScript: connect.NewClient[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs, kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]( httpClient, baseURL+ApiContainerServiceRunStarlarkScriptProcedure, opts..., ), - uploadStarlarkPackage: connect_go.NewClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, emptypb.Empty]( + uploadStarlarkPackage: connect.NewClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, emptypb.Empty]( httpClient, baseURL+ApiContainerServiceUploadStarlarkPackageProcedure, opts..., ), - runStarlarkPackage: connect_go.NewClient[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs, kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]( + runStarlarkPackage: connect.NewClient[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs, kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]( httpClient, baseURL+ApiContainerServiceRunStarlarkPackageProcedure, opts..., ), - getServices: connect_go.NewClient[kurtosis_core_rpc_api_bindings.GetServicesArgs, kurtosis_core_rpc_api_bindings.GetServicesResponse]( + getServices: connect.NewClient[kurtosis_core_rpc_api_bindings.GetServicesArgs, kurtosis_core_rpc_api_bindings.GetServicesResponse]( httpClient, baseURL+ApiContainerServiceGetServicesProcedure, opts..., ), - getExistingAndHistoricalServiceIdentifiers: connect_go.NewClient[emptypb.Empty, kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse]( + getExistingAndHistoricalServiceIdentifiers: connect.NewClient[emptypb.Empty, kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse]( httpClient, baseURL+ApiContainerServiceGetExistingAndHistoricalServiceIdentifiersProcedure, opts..., ), - execCommand: connect_go.NewClient[kurtosis_core_rpc_api_bindings.ExecCommandArgs, kurtosis_core_rpc_api_bindings.ExecCommandResponse]( + execCommand: connect.NewClient[kurtosis_core_rpc_api_bindings.ExecCommandArgs, kurtosis_core_rpc_api_bindings.ExecCommandResponse]( httpClient, baseURL+ApiContainerServiceExecCommandProcedure, opts..., ), - waitForHttpGetEndpointAvailability: connect_go.NewClient[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs, emptypb.Empty]( + waitForHttpGetEndpointAvailability: connect.NewClient[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs, emptypb.Empty]( httpClient, baseURL+ApiContainerServiceWaitForHttpGetEndpointAvailabilityProcedure, opts..., ), - waitForHttpPostEndpointAvailability: connect_go.NewClient[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs, emptypb.Empty]( + waitForHttpPostEndpointAvailability: connect.NewClient[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs, emptypb.Empty]( httpClient, baseURL+ApiContainerServiceWaitForHttpPostEndpointAvailabilityProcedure, opts..., ), - uploadFilesArtifact: connect_go.NewClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse]( + uploadFilesArtifact: connect.NewClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse]( httpClient, baseURL+ApiContainerServiceUploadFilesArtifactProcedure, opts..., ), - downloadFilesArtifact: connect_go.NewClient[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs, kurtosis_core_rpc_api_bindings.StreamedDataChunk]( + downloadFilesArtifact: connect.NewClient[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs, kurtosis_core_rpc_api_bindings.StreamedDataChunk]( httpClient, baseURL+ApiContainerServiceDownloadFilesArtifactProcedure, opts..., ), - storeWebFilesArtifact: connect_go.NewClient[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs, kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse]( + storeWebFilesArtifact: connect.NewClient[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs, kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse]( httpClient, baseURL+ApiContainerServiceStoreWebFilesArtifactProcedure, opts..., ), - storeFilesArtifactFromService: connect_go.NewClient[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs, kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse]( + storeFilesArtifactFromService: connect.NewClient[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs, kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse]( httpClient, baseURL+ApiContainerServiceStoreFilesArtifactFromServiceProcedure, opts..., ), - listFilesArtifactNamesAndUuids: connect_go.NewClient[emptypb.Empty, kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse]( + listFilesArtifactNamesAndUuids: connect.NewClient[emptypb.Empty, kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse]( httpClient, baseURL+ApiContainerServiceListFilesArtifactNamesAndUuidsProcedure, opts..., ), - inspectFilesArtifactContents: connect_go.NewClient[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest, kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse]( + inspectFilesArtifactContents: connect.NewClient[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest, kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse]( httpClient, baseURL+ApiContainerServiceInspectFilesArtifactContentsProcedure, opts..., @@ -193,95 +193,95 @@ func NewApiContainerServiceClient(httpClient connect_go.HTTPClient, baseURL stri // apiContainerServiceClient implements ApiContainerServiceClient. type apiContainerServiceClient struct { - runStarlarkScript *connect_go.Client[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs, kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine] - uploadStarlarkPackage *connect_go.Client[kurtosis_core_rpc_api_bindings.StreamedDataChunk, emptypb.Empty] - runStarlarkPackage *connect_go.Client[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs, kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine] - getServices *connect_go.Client[kurtosis_core_rpc_api_bindings.GetServicesArgs, kurtosis_core_rpc_api_bindings.GetServicesResponse] - getExistingAndHistoricalServiceIdentifiers *connect_go.Client[emptypb.Empty, kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse] - execCommand *connect_go.Client[kurtosis_core_rpc_api_bindings.ExecCommandArgs, kurtosis_core_rpc_api_bindings.ExecCommandResponse] - waitForHttpGetEndpointAvailability *connect_go.Client[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs, emptypb.Empty] - waitForHttpPostEndpointAvailability *connect_go.Client[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs, emptypb.Empty] - uploadFilesArtifact *connect_go.Client[kurtosis_core_rpc_api_bindings.StreamedDataChunk, kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse] - downloadFilesArtifact *connect_go.Client[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs, kurtosis_core_rpc_api_bindings.StreamedDataChunk] - storeWebFilesArtifact *connect_go.Client[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs, kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse] - storeFilesArtifactFromService *connect_go.Client[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs, kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse] - listFilesArtifactNamesAndUuids *connect_go.Client[emptypb.Empty, kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse] - inspectFilesArtifactContents *connect_go.Client[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest, kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse] + runStarlarkScript *connect.Client[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs, kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine] + uploadStarlarkPackage *connect.Client[kurtosis_core_rpc_api_bindings.StreamedDataChunk, emptypb.Empty] + runStarlarkPackage *connect.Client[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs, kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine] + getServices *connect.Client[kurtosis_core_rpc_api_bindings.GetServicesArgs, kurtosis_core_rpc_api_bindings.GetServicesResponse] + getExistingAndHistoricalServiceIdentifiers *connect.Client[emptypb.Empty, kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse] + execCommand *connect.Client[kurtosis_core_rpc_api_bindings.ExecCommandArgs, kurtosis_core_rpc_api_bindings.ExecCommandResponse] + waitForHttpGetEndpointAvailability *connect.Client[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs, emptypb.Empty] + waitForHttpPostEndpointAvailability *connect.Client[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs, emptypb.Empty] + uploadFilesArtifact *connect.Client[kurtosis_core_rpc_api_bindings.StreamedDataChunk, kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse] + downloadFilesArtifact *connect.Client[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs, kurtosis_core_rpc_api_bindings.StreamedDataChunk] + storeWebFilesArtifact *connect.Client[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs, kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse] + storeFilesArtifactFromService *connect.Client[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs, kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse] + listFilesArtifactNamesAndUuids *connect.Client[emptypb.Empty, kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse] + inspectFilesArtifactContents *connect.Client[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest, kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse] } // RunStarlarkScript calls api_container_api.ApiContainerService.RunStarlarkScript. -func (c *apiContainerServiceClient) RunStarlarkScript(ctx context.Context, req *connect_go.Request[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs]) (*connect_go.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine], error) { +func (c *apiContainerServiceClient) RunStarlarkScript(ctx context.Context, req *connect.Request[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs]) (*connect.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine], error) { return c.runStarlarkScript.CallServerStream(ctx, req) } // UploadStarlarkPackage calls api_container_api.ApiContainerService.UploadStarlarkPackage. -func (c *apiContainerServiceClient) UploadStarlarkPackage(ctx context.Context) *connect_go.ClientStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, emptypb.Empty] { +func (c *apiContainerServiceClient) UploadStarlarkPackage(ctx context.Context) *connect.ClientStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, emptypb.Empty] { return c.uploadStarlarkPackage.CallClientStream(ctx) } // RunStarlarkPackage calls api_container_api.ApiContainerService.RunStarlarkPackage. -func (c *apiContainerServiceClient) RunStarlarkPackage(ctx context.Context, req *connect_go.Request[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs]) (*connect_go.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine], error) { +func (c *apiContainerServiceClient) RunStarlarkPackage(ctx context.Context, req *connect.Request[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs]) (*connect.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine], error) { return c.runStarlarkPackage.CallServerStream(ctx, req) } // GetServices calls api_container_api.ApiContainerService.GetServices. -func (c *apiContainerServiceClient) GetServices(ctx context.Context, req *connect_go.Request[kurtosis_core_rpc_api_bindings.GetServicesArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.GetServicesResponse], error) { +func (c *apiContainerServiceClient) GetServices(ctx context.Context, req *connect.Request[kurtosis_core_rpc_api_bindings.GetServicesArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.GetServicesResponse], error) { return c.getServices.CallUnary(ctx, req) } // GetExistingAndHistoricalServiceIdentifiers calls // api_container_api.ApiContainerService.GetExistingAndHistoricalServiceIdentifiers. -func (c *apiContainerServiceClient) GetExistingAndHistoricalServiceIdentifiers(ctx context.Context, req *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse], error) { +func (c *apiContainerServiceClient) GetExistingAndHistoricalServiceIdentifiers(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse], error) { return c.getExistingAndHistoricalServiceIdentifiers.CallUnary(ctx, req) } // ExecCommand calls api_container_api.ApiContainerService.ExecCommand. -func (c *apiContainerServiceClient) ExecCommand(ctx context.Context, req *connect_go.Request[kurtosis_core_rpc_api_bindings.ExecCommandArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.ExecCommandResponse], error) { +func (c *apiContainerServiceClient) ExecCommand(ctx context.Context, req *connect.Request[kurtosis_core_rpc_api_bindings.ExecCommandArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.ExecCommandResponse], error) { return c.execCommand.CallUnary(ctx, req) } // WaitForHttpGetEndpointAvailability calls // api_container_api.ApiContainerService.WaitForHttpGetEndpointAvailability. -func (c *apiContainerServiceClient) WaitForHttpGetEndpointAvailability(ctx context.Context, req *connect_go.Request[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs]) (*connect_go.Response[emptypb.Empty], error) { +func (c *apiContainerServiceClient) WaitForHttpGetEndpointAvailability(ctx context.Context, req *connect.Request[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs]) (*connect.Response[emptypb.Empty], error) { return c.waitForHttpGetEndpointAvailability.CallUnary(ctx, req) } // WaitForHttpPostEndpointAvailability calls // api_container_api.ApiContainerService.WaitForHttpPostEndpointAvailability. -func (c *apiContainerServiceClient) WaitForHttpPostEndpointAvailability(ctx context.Context, req *connect_go.Request[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs]) (*connect_go.Response[emptypb.Empty], error) { +func (c *apiContainerServiceClient) WaitForHttpPostEndpointAvailability(ctx context.Context, req *connect.Request[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs]) (*connect.Response[emptypb.Empty], error) { return c.waitForHttpPostEndpointAvailability.CallUnary(ctx, req) } // UploadFilesArtifact calls api_container_api.ApiContainerService.UploadFilesArtifact. -func (c *apiContainerServiceClient) UploadFilesArtifact(ctx context.Context) *connect_go.ClientStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse] { +func (c *apiContainerServiceClient) UploadFilesArtifact(ctx context.Context) *connect.ClientStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk, kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse] { return c.uploadFilesArtifact.CallClientStream(ctx) } // DownloadFilesArtifact calls api_container_api.ApiContainerService.DownloadFilesArtifact. -func (c *apiContainerServiceClient) DownloadFilesArtifact(ctx context.Context, req *connect_go.Request[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs]) (*connect_go.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk], error) { +func (c *apiContainerServiceClient) DownloadFilesArtifact(ctx context.Context, req *connect.Request[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs]) (*connect.ServerStreamForClient[kurtosis_core_rpc_api_bindings.StreamedDataChunk], error) { return c.downloadFilesArtifact.CallServerStream(ctx, req) } // StoreWebFilesArtifact calls api_container_api.ApiContainerService.StoreWebFilesArtifact. -func (c *apiContainerServiceClient) StoreWebFilesArtifact(ctx context.Context, req *connect_go.Request[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse], error) { +func (c *apiContainerServiceClient) StoreWebFilesArtifact(ctx context.Context, req *connect.Request[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse], error) { return c.storeWebFilesArtifact.CallUnary(ctx, req) } // StoreFilesArtifactFromService calls // api_container_api.ApiContainerService.StoreFilesArtifactFromService. -func (c *apiContainerServiceClient) StoreFilesArtifactFromService(ctx context.Context, req *connect_go.Request[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse], error) { +func (c *apiContainerServiceClient) StoreFilesArtifactFromService(ctx context.Context, req *connect.Request[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse], error) { return c.storeFilesArtifactFromService.CallUnary(ctx, req) } // ListFilesArtifactNamesAndUuids calls // api_container_api.ApiContainerService.ListFilesArtifactNamesAndUuids. -func (c *apiContainerServiceClient) ListFilesArtifactNamesAndUuids(ctx context.Context, req *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse], error) { +func (c *apiContainerServiceClient) ListFilesArtifactNamesAndUuids(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse], error) { return c.listFilesArtifactNamesAndUuids.CallUnary(ctx, req) } // InspectFilesArtifactContents calls // api_container_api.ApiContainerService.InspectFilesArtifactContents. -func (c *apiContainerServiceClient) InspectFilesArtifactContents(ctx context.Context, req *connect_go.Request[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse], error) { +func (c *apiContainerServiceClient) InspectFilesArtifactContents(ctx context.Context, req *connect.Request[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest]) (*connect.Response[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse], error) { return c.inspectFilesArtifactContents.CallUnary(ctx, req) } @@ -289,31 +289,31 @@ func (c *apiContainerServiceClient) InspectFilesArtifactContents(ctx context.Con // service. type ApiContainerServiceHandler interface { // Executes a Starlark script on the user's behalf - RunStarlarkScript(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs], *connect_go.ServerStream[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]) error + RunStarlarkScript(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs], *connect.ServerStream[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]) error // Uploads a Starlark package. This step is required before the package can be executed with RunStarlarkPackage - UploadStarlarkPackage(context.Context, *connect_go.ClientStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) (*connect_go.Response[emptypb.Empty], error) + UploadStarlarkPackage(context.Context, *connect.ClientStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) (*connect.Response[emptypb.Empty], error) // Executes a Starlark script on the user's behalf - RunStarlarkPackage(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs], *connect_go.ServerStream[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]) error + RunStarlarkPackage(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs], *connect.ServerStream[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]) error // Returns the IDs of the current services in the enclave - GetServices(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.GetServicesArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.GetServicesResponse], error) + GetServices(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.GetServicesArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.GetServicesResponse], error) // Returns information about all existing & historical services - GetExistingAndHistoricalServiceIdentifiers(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse], error) + GetExistingAndHistoricalServiceIdentifiers(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse], error) // Executes the given command inside a running container - ExecCommand(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.ExecCommandArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.ExecCommandResponse], error) + ExecCommand(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.ExecCommandArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.ExecCommandResponse], error) // Block until the given HTTP endpoint returns available, calling it through a HTTP Get request - WaitForHttpGetEndpointAvailability(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs]) (*connect_go.Response[emptypb.Empty], error) + WaitForHttpGetEndpointAvailability(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs]) (*connect.Response[emptypb.Empty], error) // Block until the given HTTP endpoint returns available, calling it through a HTTP Post request - WaitForHttpPostEndpointAvailability(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs]) (*connect_go.Response[emptypb.Empty], error) + WaitForHttpPostEndpointAvailability(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs]) (*connect.Response[emptypb.Empty], error) // Uploads a files artifact to the Kurtosis File System - UploadFilesArtifact(context.Context, *connect_go.ClientStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse], error) + UploadFilesArtifact(context.Context, *connect.ClientStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) (*connect.Response[kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse], error) // Downloads a files artifact from the Kurtosis File System - DownloadFilesArtifact(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs], *connect_go.ServerStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) error + DownloadFilesArtifact(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs], *connect.ServerStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) error // Tells the API container to download a files artifact from the web to the Kurtosis File System - StoreWebFilesArtifact(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse], error) + StoreWebFilesArtifact(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse], error) // Tells the API container to copy a files artifact from a service to the Kurtosis File System - StoreFilesArtifactFromService(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse], error) - ListFilesArtifactNamesAndUuids(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse], error) - InspectFilesArtifactContents(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse], error) + StoreFilesArtifactFromService(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse], error) + ListFilesArtifactNamesAndUuids(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse], error) + InspectFilesArtifactContents(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest]) (*connect.Response[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse], error) } // NewApiContainerServiceHandler builds an HTTP handler from the service implementation. It returns @@ -321,73 +321,73 @@ type ApiContainerServiceHandler interface { // // By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf // and JSON codecs. They also support gzip compression. -func NewApiContainerServiceHandler(svc ApiContainerServiceHandler, opts ...connect_go.HandlerOption) (string, http.Handler) { - apiContainerServiceRunStarlarkScriptHandler := connect_go.NewServerStreamHandler( +func NewApiContainerServiceHandler(svc ApiContainerServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + apiContainerServiceRunStarlarkScriptHandler := connect.NewServerStreamHandler( ApiContainerServiceRunStarlarkScriptProcedure, svc.RunStarlarkScript, opts..., ) - apiContainerServiceUploadStarlarkPackageHandler := connect_go.NewClientStreamHandler( + apiContainerServiceUploadStarlarkPackageHandler := connect.NewClientStreamHandler( ApiContainerServiceUploadStarlarkPackageProcedure, svc.UploadStarlarkPackage, opts..., ) - apiContainerServiceRunStarlarkPackageHandler := connect_go.NewServerStreamHandler( + apiContainerServiceRunStarlarkPackageHandler := connect.NewServerStreamHandler( ApiContainerServiceRunStarlarkPackageProcedure, svc.RunStarlarkPackage, opts..., ) - apiContainerServiceGetServicesHandler := connect_go.NewUnaryHandler( + apiContainerServiceGetServicesHandler := connect.NewUnaryHandler( ApiContainerServiceGetServicesProcedure, svc.GetServices, opts..., ) - apiContainerServiceGetExistingAndHistoricalServiceIdentifiersHandler := connect_go.NewUnaryHandler( + apiContainerServiceGetExistingAndHistoricalServiceIdentifiersHandler := connect.NewUnaryHandler( ApiContainerServiceGetExistingAndHistoricalServiceIdentifiersProcedure, svc.GetExistingAndHistoricalServiceIdentifiers, opts..., ) - apiContainerServiceExecCommandHandler := connect_go.NewUnaryHandler( + apiContainerServiceExecCommandHandler := connect.NewUnaryHandler( ApiContainerServiceExecCommandProcedure, svc.ExecCommand, opts..., ) - apiContainerServiceWaitForHttpGetEndpointAvailabilityHandler := connect_go.NewUnaryHandler( + apiContainerServiceWaitForHttpGetEndpointAvailabilityHandler := connect.NewUnaryHandler( ApiContainerServiceWaitForHttpGetEndpointAvailabilityProcedure, svc.WaitForHttpGetEndpointAvailability, opts..., ) - apiContainerServiceWaitForHttpPostEndpointAvailabilityHandler := connect_go.NewUnaryHandler( + apiContainerServiceWaitForHttpPostEndpointAvailabilityHandler := connect.NewUnaryHandler( ApiContainerServiceWaitForHttpPostEndpointAvailabilityProcedure, svc.WaitForHttpPostEndpointAvailability, opts..., ) - apiContainerServiceUploadFilesArtifactHandler := connect_go.NewClientStreamHandler( + apiContainerServiceUploadFilesArtifactHandler := connect.NewClientStreamHandler( ApiContainerServiceUploadFilesArtifactProcedure, svc.UploadFilesArtifact, opts..., ) - apiContainerServiceDownloadFilesArtifactHandler := connect_go.NewServerStreamHandler( + apiContainerServiceDownloadFilesArtifactHandler := connect.NewServerStreamHandler( ApiContainerServiceDownloadFilesArtifactProcedure, svc.DownloadFilesArtifact, opts..., ) - apiContainerServiceStoreWebFilesArtifactHandler := connect_go.NewUnaryHandler( + apiContainerServiceStoreWebFilesArtifactHandler := connect.NewUnaryHandler( ApiContainerServiceStoreWebFilesArtifactProcedure, svc.StoreWebFilesArtifact, opts..., ) - apiContainerServiceStoreFilesArtifactFromServiceHandler := connect_go.NewUnaryHandler( + apiContainerServiceStoreFilesArtifactFromServiceHandler := connect.NewUnaryHandler( ApiContainerServiceStoreFilesArtifactFromServiceProcedure, svc.StoreFilesArtifactFromService, opts..., ) - apiContainerServiceListFilesArtifactNamesAndUuidsHandler := connect_go.NewUnaryHandler( + apiContainerServiceListFilesArtifactNamesAndUuidsHandler := connect.NewUnaryHandler( ApiContainerServiceListFilesArtifactNamesAndUuidsProcedure, svc.ListFilesArtifactNamesAndUuids, opts..., ) - apiContainerServiceInspectFilesArtifactContentsHandler := connect_go.NewUnaryHandler( + apiContainerServiceInspectFilesArtifactContentsHandler := connect.NewUnaryHandler( ApiContainerServiceInspectFilesArtifactContentsProcedure, svc.InspectFilesArtifactContents, opts..., @@ -431,58 +431,58 @@ func NewApiContainerServiceHandler(svc ApiContainerServiceHandler, opts ...conne // UnimplementedApiContainerServiceHandler returns CodeUnimplemented from all methods. type UnimplementedApiContainerServiceHandler struct{} -func (UnimplementedApiContainerServiceHandler) RunStarlarkScript(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs], *connect_go.ServerStream[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]) error { - return connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.RunStarlarkScript is not implemented")) +func (UnimplementedApiContainerServiceHandler) RunStarlarkScript(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.RunStarlarkScriptArgs], *connect.ServerStream[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.RunStarlarkScript is not implemented")) } -func (UnimplementedApiContainerServiceHandler) UploadStarlarkPackage(context.Context, *connect_go.ClientStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) (*connect_go.Response[emptypb.Empty], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.UploadStarlarkPackage is not implemented")) +func (UnimplementedApiContainerServiceHandler) UploadStarlarkPackage(context.Context, *connect.ClientStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) (*connect.Response[emptypb.Empty], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.UploadStarlarkPackage is not implemented")) } -func (UnimplementedApiContainerServiceHandler) RunStarlarkPackage(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs], *connect_go.ServerStream[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]) error { - return connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.RunStarlarkPackage is not implemented")) +func (UnimplementedApiContainerServiceHandler) RunStarlarkPackage(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.RunStarlarkPackageArgs], *connect.ServerStream[kurtosis_core_rpc_api_bindings.StarlarkRunResponseLine]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.RunStarlarkPackage is not implemented")) } -func (UnimplementedApiContainerServiceHandler) GetServices(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.GetServicesArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.GetServicesResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.GetServices is not implemented")) +func (UnimplementedApiContainerServiceHandler) GetServices(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.GetServicesArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.GetServicesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.GetServices is not implemented")) } -func (UnimplementedApiContainerServiceHandler) GetExistingAndHistoricalServiceIdentifiers(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.GetExistingAndHistoricalServiceIdentifiers is not implemented")) +func (UnimplementedApiContainerServiceHandler) GetExistingAndHistoricalServiceIdentifiers(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_core_rpc_api_bindings.GetExistingAndHistoricalServiceIdentifiersResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.GetExistingAndHistoricalServiceIdentifiers is not implemented")) } -func (UnimplementedApiContainerServiceHandler) ExecCommand(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.ExecCommandArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.ExecCommandResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.ExecCommand is not implemented")) +func (UnimplementedApiContainerServiceHandler) ExecCommand(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.ExecCommandArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.ExecCommandResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.ExecCommand is not implemented")) } -func (UnimplementedApiContainerServiceHandler) WaitForHttpGetEndpointAvailability(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs]) (*connect_go.Response[emptypb.Empty], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.WaitForHttpGetEndpointAvailability is not implemented")) +func (UnimplementedApiContainerServiceHandler) WaitForHttpGetEndpointAvailability(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.WaitForHttpGetEndpointAvailabilityArgs]) (*connect.Response[emptypb.Empty], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.WaitForHttpGetEndpointAvailability is not implemented")) } -func (UnimplementedApiContainerServiceHandler) WaitForHttpPostEndpointAvailability(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs]) (*connect_go.Response[emptypb.Empty], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.WaitForHttpPostEndpointAvailability is not implemented")) +func (UnimplementedApiContainerServiceHandler) WaitForHttpPostEndpointAvailability(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.WaitForHttpPostEndpointAvailabilityArgs]) (*connect.Response[emptypb.Empty], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.WaitForHttpPostEndpointAvailability is not implemented")) } -func (UnimplementedApiContainerServiceHandler) UploadFilesArtifact(context.Context, *connect_go.ClientStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.UploadFilesArtifact is not implemented")) +func (UnimplementedApiContainerServiceHandler) UploadFilesArtifact(context.Context, *connect.ClientStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) (*connect.Response[kurtosis_core_rpc_api_bindings.UploadFilesArtifactResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.UploadFilesArtifact is not implemented")) } -func (UnimplementedApiContainerServiceHandler) DownloadFilesArtifact(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs], *connect_go.ServerStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) error { - return connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.DownloadFilesArtifact is not implemented")) +func (UnimplementedApiContainerServiceHandler) DownloadFilesArtifact(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.DownloadFilesArtifactArgs], *connect.ServerStream[kurtosis_core_rpc_api_bindings.StreamedDataChunk]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.DownloadFilesArtifact is not implemented")) } -func (UnimplementedApiContainerServiceHandler) StoreWebFilesArtifact(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.StoreWebFilesArtifact is not implemented")) +func (UnimplementedApiContainerServiceHandler) StoreWebFilesArtifact(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.StoreWebFilesArtifactResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.StoreWebFilesArtifact is not implemented")) } -func (UnimplementedApiContainerServiceHandler) StoreFilesArtifactFromService(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.StoreFilesArtifactFromService is not implemented")) +func (UnimplementedApiContainerServiceHandler) StoreFilesArtifactFromService(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceArgs]) (*connect.Response[kurtosis_core_rpc_api_bindings.StoreFilesArtifactFromServiceResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.StoreFilesArtifactFromService is not implemented")) } -func (UnimplementedApiContainerServiceHandler) ListFilesArtifactNamesAndUuids(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.ListFilesArtifactNamesAndUuids is not implemented")) +func (UnimplementedApiContainerServiceHandler) ListFilesArtifactNamesAndUuids(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_core_rpc_api_bindings.ListFilesArtifactNamesAndUuidsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.ListFilesArtifactNamesAndUuids is not implemented")) } -func (UnimplementedApiContainerServiceHandler) InspectFilesArtifactContents(context.Context, *connect_go.Request[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest]) (*connect_go.Response[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.InspectFilesArtifactContents is not implemented")) +func (UnimplementedApiContainerServiceHandler) InspectFilesArtifactContents(context.Context, *connect.Request[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsRequest]) (*connect.Response[kurtosis_core_rpc_api_bindings.InspectFilesArtifactContentsResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("api_container_api.ApiContainerService.InspectFilesArtifactContents is not implemented")) } diff --git a/api/golang/engine/kurtosis_engine_rpc_api_bindings/kurtosis_engine_rpc_api_bindingsconnect/engine_service.connect.go b/api/golang/engine/kurtosis_engine_rpc_api_bindings/kurtosis_engine_rpc_api_bindingsconnect/engine_service.connect.go index d39610c345..0fcb15543f 100644 --- a/api/golang/engine/kurtosis_engine_rpc_api_bindings/kurtosis_engine_rpc_api_bindingsconnect/engine_service.connect.go +++ b/api/golang/engine/kurtosis_engine_rpc_api_bindings/kurtosis_engine_rpc_api_bindingsconnect/engine_service.connect.go @@ -5,9 +5,9 @@ package kurtosis_engine_rpc_api_bindingsconnect import ( + connect "connectrpc.com/connect" context "context" errors "errors" - connect_go "github.com/bufbuild/connect-go" kurtosis_engine_rpc_api_bindings "github.com/kurtosis-tech/kurtosis/api/golang/engine/kurtosis_engine_rpc_api_bindings" emptypb "google.golang.org/protobuf/types/known/emptypb" http "net/http" @@ -19,7 +19,7 @@ import ( // generated with a version of connect newer than the one compiled into your binary. You can fix the // problem by either regenerating this code with an older version of connect or updating the connect // version compiled into your binary. -const _ = connect_go.IsAtLeastVersion0_1_0 +const _ = connect.IsAtLeastVersion0_1_0 const ( // EngineServiceName is the fully-qualified name of the EngineService service. @@ -62,26 +62,26 @@ const ( // EngineServiceClient is a client for the engine_api.EngineService service. type EngineServiceClient interface { // Endpoint for getting information about the engine, which is also what we use to verify that the engine has become available - GetEngineInfo(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse], error) + GetEngineInfo(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse], error) // ============================================================================================== // // Enclave Management // // ============================================================================================== // Creates a new Kurtosis Enclave - CreateEnclave(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse], error) + CreateEnclave(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs]) (*connect.Response[kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse], error) // Returns information about the existing enclaves - GetEnclaves(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetEnclavesResponse], error) + GetEnclaves(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetEnclavesResponse], error) // Returns information about all existing & historical enclaves - GetExistingAndHistoricalEnclaveIdentifiers(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse], error) + GetExistingAndHistoricalEnclaveIdentifiers(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse], error) // Stops all containers in an enclave - StopEnclave(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs]) (*connect_go.Response[emptypb.Empty], error) + StopEnclave(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs]) (*connect.Response[emptypb.Empty], error) // Destroys an enclave, removing all artifacts associated with it - DestroyEnclave(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs]) (*connect_go.Response[emptypb.Empty], error) + DestroyEnclave(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs]) (*connect.Response[emptypb.Empty], error) // Gets rid of old enclaves - Clean(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.CleanArgs]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.CleanResponse], error) + Clean(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.CleanArgs]) (*connect.Response[kurtosis_engine_rpc_api_bindings.CleanResponse], error) // Get service logs - GetServiceLogs(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs]) (*connect_go.ServerStreamForClient[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse], error) + GetServiceLogs(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs]) (*connect.ServerStreamForClient[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse], error) } // NewEngineServiceClient constructs a client for the engine_api.EngineService service. By default, @@ -91,45 +91,45 @@ type EngineServiceClient interface { // // The URL supplied here should be the base URL for the Connect or gRPC server (for example, // http://api.acme.com or https://acme.com/grpc). -func NewEngineServiceClient(httpClient connect_go.HTTPClient, baseURL string, opts ...connect_go.ClientOption) EngineServiceClient { +func NewEngineServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) EngineServiceClient { baseURL = strings.TrimRight(baseURL, "/") return &engineServiceClient{ - getEngineInfo: connect_go.NewClient[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse]( + getEngineInfo: connect.NewClient[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse]( httpClient, baseURL+EngineServiceGetEngineInfoProcedure, opts..., ), - createEnclave: connect_go.NewClient[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs, kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse]( + createEnclave: connect.NewClient[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs, kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse]( httpClient, baseURL+EngineServiceCreateEnclaveProcedure, opts..., ), - getEnclaves: connect_go.NewClient[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetEnclavesResponse]( + getEnclaves: connect.NewClient[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetEnclavesResponse]( httpClient, baseURL+EngineServiceGetEnclavesProcedure, opts..., ), - getExistingAndHistoricalEnclaveIdentifiers: connect_go.NewClient[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse]( + getExistingAndHistoricalEnclaveIdentifiers: connect.NewClient[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse]( httpClient, baseURL+EngineServiceGetExistingAndHistoricalEnclaveIdentifiersProcedure, opts..., ), - stopEnclave: connect_go.NewClient[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs, emptypb.Empty]( + stopEnclave: connect.NewClient[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs, emptypb.Empty]( httpClient, baseURL+EngineServiceStopEnclaveProcedure, opts..., ), - destroyEnclave: connect_go.NewClient[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs, emptypb.Empty]( + destroyEnclave: connect.NewClient[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs, emptypb.Empty]( httpClient, baseURL+EngineServiceDestroyEnclaveProcedure, opts..., ), - clean: connect_go.NewClient[kurtosis_engine_rpc_api_bindings.CleanArgs, kurtosis_engine_rpc_api_bindings.CleanResponse]( + clean: connect.NewClient[kurtosis_engine_rpc_api_bindings.CleanArgs, kurtosis_engine_rpc_api_bindings.CleanResponse]( httpClient, baseURL+EngineServiceCleanProcedure, opts..., ), - getServiceLogs: connect_go.NewClient[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs, kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse]( + getServiceLogs: connect.NewClient[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs, kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse]( httpClient, baseURL+EngineServiceGetServiceLogsProcedure, opts..., @@ -139,80 +139,80 @@ func NewEngineServiceClient(httpClient connect_go.HTTPClient, baseURL string, op // engineServiceClient implements EngineServiceClient. type engineServiceClient struct { - getEngineInfo *connect_go.Client[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse] - createEnclave *connect_go.Client[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs, kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse] - getEnclaves *connect_go.Client[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetEnclavesResponse] - getExistingAndHistoricalEnclaveIdentifiers *connect_go.Client[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse] - stopEnclave *connect_go.Client[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs, emptypb.Empty] - destroyEnclave *connect_go.Client[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs, emptypb.Empty] - clean *connect_go.Client[kurtosis_engine_rpc_api_bindings.CleanArgs, kurtosis_engine_rpc_api_bindings.CleanResponse] - getServiceLogs *connect_go.Client[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs, kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse] + getEngineInfo *connect.Client[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse] + createEnclave *connect.Client[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs, kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse] + getEnclaves *connect.Client[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetEnclavesResponse] + getExistingAndHistoricalEnclaveIdentifiers *connect.Client[emptypb.Empty, kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse] + stopEnclave *connect.Client[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs, emptypb.Empty] + destroyEnclave *connect.Client[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs, emptypb.Empty] + clean *connect.Client[kurtosis_engine_rpc_api_bindings.CleanArgs, kurtosis_engine_rpc_api_bindings.CleanResponse] + getServiceLogs *connect.Client[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs, kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse] } // GetEngineInfo calls engine_api.EngineService.GetEngineInfo. -func (c *engineServiceClient) GetEngineInfo(ctx context.Context, req *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse], error) { +func (c *engineServiceClient) GetEngineInfo(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse], error) { return c.getEngineInfo.CallUnary(ctx, req) } // CreateEnclave calls engine_api.EngineService.CreateEnclave. -func (c *engineServiceClient) CreateEnclave(ctx context.Context, req *connect_go.Request[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse], error) { +func (c *engineServiceClient) CreateEnclave(ctx context.Context, req *connect.Request[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs]) (*connect.Response[kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse], error) { return c.createEnclave.CallUnary(ctx, req) } // GetEnclaves calls engine_api.EngineService.GetEnclaves. -func (c *engineServiceClient) GetEnclaves(ctx context.Context, req *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetEnclavesResponse], error) { +func (c *engineServiceClient) GetEnclaves(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetEnclavesResponse], error) { return c.getEnclaves.CallUnary(ctx, req) } // GetExistingAndHistoricalEnclaveIdentifiers calls // engine_api.EngineService.GetExistingAndHistoricalEnclaveIdentifiers. -func (c *engineServiceClient) GetExistingAndHistoricalEnclaveIdentifiers(ctx context.Context, req *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse], error) { +func (c *engineServiceClient) GetExistingAndHistoricalEnclaveIdentifiers(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse], error) { return c.getExistingAndHistoricalEnclaveIdentifiers.CallUnary(ctx, req) } // StopEnclave calls engine_api.EngineService.StopEnclave. -func (c *engineServiceClient) StopEnclave(ctx context.Context, req *connect_go.Request[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs]) (*connect_go.Response[emptypb.Empty], error) { +func (c *engineServiceClient) StopEnclave(ctx context.Context, req *connect.Request[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs]) (*connect.Response[emptypb.Empty], error) { return c.stopEnclave.CallUnary(ctx, req) } // DestroyEnclave calls engine_api.EngineService.DestroyEnclave. -func (c *engineServiceClient) DestroyEnclave(ctx context.Context, req *connect_go.Request[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs]) (*connect_go.Response[emptypb.Empty], error) { +func (c *engineServiceClient) DestroyEnclave(ctx context.Context, req *connect.Request[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs]) (*connect.Response[emptypb.Empty], error) { return c.destroyEnclave.CallUnary(ctx, req) } // Clean calls engine_api.EngineService.Clean. -func (c *engineServiceClient) Clean(ctx context.Context, req *connect_go.Request[kurtosis_engine_rpc_api_bindings.CleanArgs]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.CleanResponse], error) { +func (c *engineServiceClient) Clean(ctx context.Context, req *connect.Request[kurtosis_engine_rpc_api_bindings.CleanArgs]) (*connect.Response[kurtosis_engine_rpc_api_bindings.CleanResponse], error) { return c.clean.CallUnary(ctx, req) } // GetServiceLogs calls engine_api.EngineService.GetServiceLogs. -func (c *engineServiceClient) GetServiceLogs(ctx context.Context, req *connect_go.Request[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs]) (*connect_go.ServerStreamForClient[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse], error) { +func (c *engineServiceClient) GetServiceLogs(ctx context.Context, req *connect.Request[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs]) (*connect.ServerStreamForClient[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse], error) { return c.getServiceLogs.CallServerStream(ctx, req) } // EngineServiceHandler is an implementation of the engine_api.EngineService service. type EngineServiceHandler interface { // Endpoint for getting information about the engine, which is also what we use to verify that the engine has become available - GetEngineInfo(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse], error) + GetEngineInfo(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse], error) // ============================================================================================== // // Enclave Management // // ============================================================================================== // Creates a new Kurtosis Enclave - CreateEnclave(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse], error) + CreateEnclave(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs]) (*connect.Response[kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse], error) // Returns information about the existing enclaves - GetEnclaves(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetEnclavesResponse], error) + GetEnclaves(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetEnclavesResponse], error) // Returns information about all existing & historical enclaves - GetExistingAndHistoricalEnclaveIdentifiers(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse], error) + GetExistingAndHistoricalEnclaveIdentifiers(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse], error) // Stops all containers in an enclave - StopEnclave(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs]) (*connect_go.Response[emptypb.Empty], error) + StopEnclave(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs]) (*connect.Response[emptypb.Empty], error) // Destroys an enclave, removing all artifacts associated with it - DestroyEnclave(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs]) (*connect_go.Response[emptypb.Empty], error) + DestroyEnclave(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs]) (*connect.Response[emptypb.Empty], error) // Gets rid of old enclaves - Clean(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.CleanArgs]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.CleanResponse], error) + Clean(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.CleanArgs]) (*connect.Response[kurtosis_engine_rpc_api_bindings.CleanResponse], error) // Get service logs - GetServiceLogs(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs], *connect_go.ServerStream[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse]) error + GetServiceLogs(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs], *connect.ServerStream[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse]) error } // NewEngineServiceHandler builds an HTTP handler from the service implementation. It returns the @@ -220,43 +220,43 @@ type EngineServiceHandler interface { // // By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf // and JSON codecs. They also support gzip compression. -func NewEngineServiceHandler(svc EngineServiceHandler, opts ...connect_go.HandlerOption) (string, http.Handler) { - engineServiceGetEngineInfoHandler := connect_go.NewUnaryHandler( +func NewEngineServiceHandler(svc EngineServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + engineServiceGetEngineInfoHandler := connect.NewUnaryHandler( EngineServiceGetEngineInfoProcedure, svc.GetEngineInfo, opts..., ) - engineServiceCreateEnclaveHandler := connect_go.NewUnaryHandler( + engineServiceCreateEnclaveHandler := connect.NewUnaryHandler( EngineServiceCreateEnclaveProcedure, svc.CreateEnclave, opts..., ) - engineServiceGetEnclavesHandler := connect_go.NewUnaryHandler( + engineServiceGetEnclavesHandler := connect.NewUnaryHandler( EngineServiceGetEnclavesProcedure, svc.GetEnclaves, opts..., ) - engineServiceGetExistingAndHistoricalEnclaveIdentifiersHandler := connect_go.NewUnaryHandler( + engineServiceGetExistingAndHistoricalEnclaveIdentifiersHandler := connect.NewUnaryHandler( EngineServiceGetExistingAndHistoricalEnclaveIdentifiersProcedure, svc.GetExistingAndHistoricalEnclaveIdentifiers, opts..., ) - engineServiceStopEnclaveHandler := connect_go.NewUnaryHandler( + engineServiceStopEnclaveHandler := connect.NewUnaryHandler( EngineServiceStopEnclaveProcedure, svc.StopEnclave, opts..., ) - engineServiceDestroyEnclaveHandler := connect_go.NewUnaryHandler( + engineServiceDestroyEnclaveHandler := connect.NewUnaryHandler( EngineServiceDestroyEnclaveProcedure, svc.DestroyEnclave, opts..., ) - engineServiceCleanHandler := connect_go.NewUnaryHandler( + engineServiceCleanHandler := connect.NewUnaryHandler( EngineServiceCleanProcedure, svc.Clean, opts..., ) - engineServiceGetServiceLogsHandler := connect_go.NewServerStreamHandler( + engineServiceGetServiceLogsHandler := connect.NewServerStreamHandler( EngineServiceGetServiceLogsProcedure, svc.GetServiceLogs, opts..., @@ -288,34 +288,34 @@ func NewEngineServiceHandler(svc EngineServiceHandler, opts ...connect_go.Handle // UnimplementedEngineServiceHandler returns CodeUnimplemented from all methods. type UnimplementedEngineServiceHandler struct{} -func (UnimplementedEngineServiceHandler) GetEngineInfo(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("engine_api.EngineService.GetEngineInfo is not implemented")) +func (UnimplementedEngineServiceHandler) GetEngineInfo(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("engine_api.EngineService.GetEngineInfo is not implemented")) } -func (UnimplementedEngineServiceHandler) CreateEnclave(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("engine_api.EngineService.CreateEnclave is not implemented")) +func (UnimplementedEngineServiceHandler) CreateEnclave(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs]) (*connect.Response[kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("engine_api.EngineService.CreateEnclave is not implemented")) } -func (UnimplementedEngineServiceHandler) GetEnclaves(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetEnclavesResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("engine_api.EngineService.GetEnclaves is not implemented")) +func (UnimplementedEngineServiceHandler) GetEnclaves(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetEnclavesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("engine_api.EngineService.GetEnclaves is not implemented")) } -func (UnimplementedEngineServiceHandler) GetExistingAndHistoricalEnclaveIdentifiers(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("engine_api.EngineService.GetExistingAndHistoricalEnclaveIdentifiers is not implemented")) +func (UnimplementedEngineServiceHandler) GetExistingAndHistoricalEnclaveIdentifiers(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("engine_api.EngineService.GetExistingAndHistoricalEnclaveIdentifiers is not implemented")) } -func (UnimplementedEngineServiceHandler) StopEnclave(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs]) (*connect_go.Response[emptypb.Empty], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("engine_api.EngineService.StopEnclave is not implemented")) +func (UnimplementedEngineServiceHandler) StopEnclave(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs]) (*connect.Response[emptypb.Empty], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("engine_api.EngineService.StopEnclave is not implemented")) } -func (UnimplementedEngineServiceHandler) DestroyEnclave(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs]) (*connect_go.Response[emptypb.Empty], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("engine_api.EngineService.DestroyEnclave is not implemented")) +func (UnimplementedEngineServiceHandler) DestroyEnclave(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs]) (*connect.Response[emptypb.Empty], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("engine_api.EngineService.DestroyEnclave is not implemented")) } -func (UnimplementedEngineServiceHandler) Clean(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.CleanArgs]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.CleanResponse], error) { - return nil, connect_go.NewError(connect_go.CodeUnimplemented, errors.New("engine_api.EngineService.Clean is not implemented")) +func (UnimplementedEngineServiceHandler) Clean(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.CleanArgs]) (*connect.Response[kurtosis_engine_rpc_api_bindings.CleanResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("engine_api.EngineService.Clean is not implemented")) } -func (UnimplementedEngineServiceHandler) GetServiceLogs(context.Context, *connect_go.Request[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs], *connect_go.ServerStream[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse]) error { - return connect_go.NewError(connect_go.CodeUnimplemented, errors.New("engine_api.EngineService.GetServiceLogs is not implemented")) +func (UnimplementedEngineServiceHandler) GetServiceLogs(context.Context, *connect.Request[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs], *connect.ServerStream[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse]) error { + return connect.NewError(connect.CodeUnimplemented, errors.New("engine_api.EngineService.GetServiceLogs is not implemented")) } diff --git a/api/golang/go.mod b/api/golang/go.mod index 0c19032e7e..cf524bb523 100644 --- a/api/golang/go.mod +++ b/api/golang/go.mod @@ -21,6 +21,7 @@ require ( ) require ( + connectrpc.com/connect v1.11.0 // indirect github.com/adrg/xdg v0.4.0 // indirect github.com/andybalholm/brotli v1.0.1 // indirect github.com/davecgh/go-spew v1.1.1 // indirect diff --git a/api/golang/go.sum b/api/golang/go.sum index 51720dde38..0def9d1ec6 100644 --- a/api/golang/go.sum +++ b/api/golang/go.sum @@ -1,3 +1,5 @@ +connectrpc.com/connect v1.11.0 h1:Av2KQXxSaX4vjqhf5Cl01SX4dqYADQ38eBtr84JSUBk= +connectrpc.com/connect v1.11.0/go.mod h1:3AGaO6RRGMx5IKFfqbe3hvK1NqLosFNP2BxDYTPmNPo= github.com/Masterminds/semver/v3 v3.1.1 h1:hLg3sBzpNErnxhQtUy/mmLR2I9foDujNK030IGemrRc= github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs= github.com/adrg/xdg v0.4.0 h1:RzRqFcjH4nE5C6oTAxhBtoE2IRyjBSa62SCbyPidvls= diff --git a/engine/server/engine/server/engine_connect_server_service.go b/engine/server/engine/server/engine_connect_server_service.go index 70230a7041..c1c46bef90 100644 --- a/engine/server/engine/server/engine_connect_server_service.go +++ b/engine/server/engine/server/engine_connect_server_service.go @@ -1,8 +1,8 @@ package server import ( + "connectrpc.com/connect" "context" - connect_go "github.com/bufbuild/connect-go" "github.com/kurtosis-tech/kurtosis/api/golang/engine/kurtosis_engine_rpc_api_bindings" "github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/enclave" user_service "github.com/kurtosis-tech/kurtosis/container-engine-lib/lib/backend_interface/objects/service" @@ -47,14 +47,14 @@ func NewEngineConnectServerService( return service } -func (service *EngineConnectServerService) GetEngineInfo(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse], error) { +func (service *EngineConnectServerService) GetEngineInfo(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse], error) { result := &kurtosis_engine_rpc_api_bindings.GetEngineInfoResponse{ EngineVersion: service.imageVersionTag, } - return connect_go.NewResponse(result), nil + return connect.NewResponse(result), nil } -func (service *EngineConnectServerService) CreateEnclave(ctx context.Context, connectArgs *connect_go.Request[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse], error) { +func (service *EngineConnectServerService) CreateEnclave(ctx context.Context, connectArgs *connect.Request[kurtosis_engine_rpc_api_bindings.CreateEnclaveArgs]) (*connect.Response[kurtosis_engine_rpc_api_bindings.CreateEnclaveResponse], error) { args := connectArgs.Msg logrus.Debugf("args: %+v", args) apiContainerLogLevel, err := logrus.ParseLevel(args.ApiContainerLogLevel) @@ -77,28 +77,28 @@ func (service *EngineConnectServerService) CreateEnclave(ctx context.Context, co EnclaveInfo: enclaveInfo, } - return connect_go.NewResponse(response), nil + return connect.NewResponse(response), nil } -func (service *EngineConnectServerService) GetEnclaves(ctx context.Context, _ *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetEnclavesResponse], error) { +func (service *EngineConnectServerService) GetEnclaves(ctx context.Context, _ *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetEnclavesResponse], error) { infoForEnclaves, err := service.enclaveManager.GetEnclaves(ctx) if err != nil { return nil, stacktrace.Propagate(err, "An error occurred getting info for enclaves") } response := &kurtosis_engine_rpc_api_bindings.GetEnclavesResponse{EnclaveInfo: infoForEnclaves} - return connect_go.NewResponse(response), nil + return connect.NewResponse(response), nil } -func (service *EngineConnectServerService) GetExistingAndHistoricalEnclaveIdentifiers(context.Context, *connect_go.Request[emptypb.Empty]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse], error) { +func (service *EngineConnectServerService) GetExistingAndHistoricalEnclaveIdentifiers(context.Context, *connect.Request[emptypb.Empty]) (*connect.Response[kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse], error) { allIdentifiers, err := service.enclaveManager.GetExistingAndHistoricalEnclaveIdentifiers() if err != nil { return nil, stacktrace.Propagate(err, "An error occurred while fetching enclave identifiers") } response := &kurtosis_engine_rpc_api_bindings.GetExistingAndHistoricalEnclaveIdentifiersResponse{AllIdentifiers: allIdentifiers} - return connect_go.NewResponse(response), nil + return connect.NewResponse(response), nil } -func (service *EngineConnectServerService) StopEnclave(ctx context.Context, connectArgs *connect_go.Request[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs]) (*connect_go.Response[emptypb.Empty], error) { +func (service *EngineConnectServerService) StopEnclave(ctx context.Context, connectArgs *connect.Request[kurtosis_engine_rpc_api_bindings.StopEnclaveArgs]) (*connect.Response[emptypb.Empty], error) { args := connectArgs.Msg enclaveIdentifier := args.EnclaveIdentifier @@ -106,20 +106,20 @@ func (service *EngineConnectServerService) StopEnclave(ctx context.Context, conn return nil, stacktrace.Propagate(err, "An error occurred stopping enclave '%v'", enclaveIdentifier) } - return connect_go.NewResponse(&emptypb.Empty{}), nil + return connect.NewResponse(&emptypb.Empty{}), nil } -func (service *EngineConnectServerService) DestroyEnclave(ctx context.Context, connectArgs *connect_go.Request[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs]) (*connect_go.Response[emptypb.Empty], error) { +func (service *EngineConnectServerService) DestroyEnclave(ctx context.Context, connectArgs *connect.Request[kurtosis_engine_rpc_api_bindings.DestroyEnclaveArgs]) (*connect.Response[emptypb.Empty], error) { args := connectArgs.Msg enclaveIdentifier := args.EnclaveIdentifier if err := service.enclaveManager.DestroyEnclave(ctx, enclaveIdentifier); err != nil { return nil, stacktrace.Propagate(err, "An error occurred destroying enclave with identifier '%v':", args.EnclaveIdentifier) } - return connect_go.NewResponse(&emptypb.Empty{}), nil + return connect.NewResponse(&emptypb.Empty{}), nil } -func (service *EngineConnectServerService) Clean(ctx context.Context, connectArgs *connect_go.Request[kurtosis_engine_rpc_api_bindings.CleanArgs]) (*connect_go.Response[kurtosis_engine_rpc_api_bindings.CleanResponse], error) { +func (service *EngineConnectServerService) Clean(ctx context.Context, connectArgs *connect.Request[kurtosis_engine_rpc_api_bindings.CleanArgs]) (*connect.Response[kurtosis_engine_rpc_api_bindings.CleanResponse], error) { args := connectArgs.Msg removedEnclaveUuidsAndNames, err := service.enclaveManager.Clean(ctx, args.ShouldCleanAll) if err != nil { @@ -127,10 +127,10 @@ func (service *EngineConnectServerService) Clean(ctx context.Context, connectArg } response := &kurtosis_engine_rpc_api_bindings.CleanResponse{RemovedEnclaveNameAndUuids: removedEnclaveUuidsAndNames} - return connect_go.NewResponse(response), nil + return connect.NewResponse(response), nil } -func (service *EngineConnectServerService) GetServiceLogs(ctx context.Context, connectArgs *connect_go.Request[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs], stream *connect_go.ServerStream[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse]) error { +func (service *EngineConnectServerService) GetServiceLogs(ctx context.Context, connectArgs *connect.Request[kurtosis_engine_rpc_api_bindings.GetServiceLogsArgs], stream *connect.ServerStream[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse]) error { args := connectArgs.Msg enclaveIdentifier := args.GetEnclaveIdentifier() @@ -231,7 +231,7 @@ func (service *EngineConnectServerService) reportAnyMissingUuidsAndGetNotFoundUu ctx context.Context, enclaveUuid enclave.EnclaveUUID, requestedServiceUuids map[user_service.ServiceUUID]bool, - stream *connect_go.ServerStream[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse], + stream *connect.ServerStream[kurtosis_engine_rpc_api_bindings.GetServiceLogsResponse], ) (map[string]bool, error) { existingServiceUuids, err := service.logsDatabaseClient.FilterExistingServiceUuids(ctx, enclaveUuid, requestedServiceUuids) if err != nil { diff --git a/engine/server/go.mod b/engine/server/go.mod index c2305dc41e..43bc5daee0 100644 --- a/engine/server/go.mod +++ b/engine/server/go.mod @@ -54,6 +54,7 @@ require ( require github.com/bufbuild/connect-go v1.10.0 require ( + connectrpc.com/connect v1.11.0 // indirect github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 // indirect github.com/emicklei/go-restful/v3 v3.9.0 // indirect github.com/go-logr/logr v1.2.3 // indirect diff --git a/engine/server/go.sum b/engine/server/go.sum index a956641bc2..0000a1a15d 100644 --- a/engine/server/go.sum +++ b/engine/server/go.sum @@ -1,4 +1,6 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +connectrpc.com/connect v1.11.0 h1:Av2KQXxSaX4vjqhf5Cl01SX4dqYADQ38eBtr84JSUBk= +connectrpc.com/connect v1.11.0/go.mod h1:3AGaO6RRGMx5IKFfqbe3hvK1NqLosFNP2BxDYTPmNPo= github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0= github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=