api_container_service_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v4.23.2
// source: api_container_service.proto

package kurtosis_core_rpc_api_bindings

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// 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

const (
	ApiContainerService_RunStarlarkScript_FullMethodName                          = "/api_container_api.ApiContainerService/RunStarlarkScript"
	ApiContainerService_UploadStarlarkPackage_FullMethodName                      = "/api_container_api.ApiContainerService/UploadStarlarkPackage"
	ApiContainerService_RunStarlarkPackage_FullMethodName                         = "/api_container_api.ApiContainerService/RunStarlarkPackage"
	ApiContainerService_GetServices_FullMethodName                                = "/api_container_api.ApiContainerService/GetServices"
	ApiContainerService_GetExistingAndHistoricalServiceIdentifiers_FullMethodName = "/api_container_api.ApiContainerService/GetExistingAndHistoricalServiceIdentifiers"
	ApiContainerService_ExecCommand_FullMethodName                                = "/api_container_api.ApiContainerService/ExecCommand"
	ApiContainerService_WaitForHttpGetEndpointAvailability_FullMethodName         = "/api_container_api.ApiContainerService/WaitForHttpGetEndpointAvailability"
	ApiContainerService_WaitForHttpPostEndpointAvailability_FullMethodName        = "/api_container_api.ApiContainerService/WaitForHttpPostEndpointAvailability"
	ApiContainerService_UploadFilesArtifact_FullMethodName                        = "/api_container_api.ApiContainerService/UploadFilesArtifact"
	ApiContainerService_DownloadFilesArtifact_FullMethodName                      = "/api_container_api.ApiContainerService/DownloadFilesArtifact"
	ApiContainerService_StoreWebFilesArtifact_FullMethodName                      = "/api_container_api.ApiContainerService/StoreWebFilesArtifact"
	ApiContainerService_StoreFilesArtifactFromService_FullMethodName              = "/api_container_api.ApiContainerService/StoreFilesArtifactFromService"
	ApiContainerService_ListFilesArtifactNamesAndUuids_FullMethodName             = "/api_container_api.ApiContainerService/ListFilesArtifactNamesAndUuids"
	ApiContainerService_InspectFilesArtifactContents_FullMethodName               = "/api_container_api.ApiContainerService/InspectFilesArtifactContents"
)

// ApiContainerServiceClient is the client API for ApiContainerService 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.
type ApiContainerServiceClient interface {
	// Executes a Starlark script on the user's behalf
	RunStarlarkScript(ctx context.Context, in *RunStarlarkScriptArgs, opts ...grpc.CallOption) (ApiContainerService_RunStarlarkScriptClient, error)
	// Uploads a Starlark package. This step is required before the package can be executed with RunStarlarkPackage
	UploadStarlarkPackage(ctx context.Context, opts ...grpc.CallOption) (ApiContainerService_UploadStarlarkPackageClient, error)
	// Executes a Starlark script on the user's behalf
	RunStarlarkPackage(ctx context.Context, in *RunStarlarkPackageArgs, opts ...grpc.CallOption) (ApiContainerService_RunStarlarkPackageClient, error)
	// Returns the IDs of the current services in the enclave
	GetServices(ctx context.Context, in *GetServicesArgs, opts ...grpc.CallOption) (*GetServicesResponse, error)
	// Returns information about all existing & historical services
	GetExistingAndHistoricalServiceIdentifiers(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetExistingAndHistoricalServiceIdentifiersResponse, error)
	// Executes the given command inside a running container
	ExecCommand(ctx context.Context, in *ExecCommandArgs, opts ...grpc.CallOption) (*ExecCommandResponse, error)
	// Block until the given HTTP endpoint returns available, calling it through a HTTP Get request
	WaitForHttpGetEndpointAvailability(ctx context.Context, in *WaitForHttpGetEndpointAvailabilityArgs, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Block until the given HTTP endpoint returns available, calling it through a HTTP Post request
	WaitForHttpPostEndpointAvailability(ctx context.Context, in *WaitForHttpPostEndpointAvailabilityArgs, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Uploads a files artifact to the Kurtosis File System
	UploadFilesArtifact(ctx context.Context, opts ...grpc.CallOption) (ApiContainerService_UploadFilesArtifactClient, error)
	// Downloads a files artifact from the Kurtosis File System
	DownloadFilesArtifact(ctx context.Context, in *DownloadFilesArtifactArgs, opts ...grpc.CallOption) (ApiContainerService_DownloadFilesArtifactClient, error)
	// Tells the API container to download a files artifact from the web to the Kurtosis File System
	StoreWebFilesArtifact(ctx context.Context, in *StoreWebFilesArtifactArgs, opts ...grpc.CallOption) (*StoreWebFilesArtifactResponse, error)
	// Tells the API container to copy a files artifact from a service to the Kurtosis File System
	StoreFilesArtifactFromService(ctx context.Context, in *StoreFilesArtifactFromServiceArgs, opts ...grpc.CallOption) (*StoreFilesArtifactFromServiceResponse, error)
	ListFilesArtifactNamesAndUuids(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListFilesArtifactNamesAndUuidsResponse, error)
	InspectFilesArtifactContents(ctx context.Context, in *InspectFilesArtifactContentsRequest, opts ...grpc.CallOption) (*InspectFilesArtifactContentsResponse, error)
}

type apiContainerServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewApiContainerServiceClient(cc grpc.ClientConnInterface) ApiContainerServiceClient {
	return &apiContainerServiceClient{cc}
}

func (c *apiContainerServiceClient) RunStarlarkScript(ctx context.Context, in *RunStarlarkScriptArgs, opts ...grpc.CallOption) (ApiContainerService_RunStarlarkScriptClient, error) {
	stream, err := c.cc.NewStream(ctx, &ApiContainerService_ServiceDesc.Streams[0], ApiContainerService_RunStarlarkScript_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &apiContainerServiceRunStarlarkScriptClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ApiContainerService_RunStarlarkScriptClient interface {
	Recv() (*StarlarkRunResponseLine, error)
	grpc.ClientStream
}

type apiContainerServiceRunStarlarkScriptClient struct {
	grpc.ClientStream
}

func (x *apiContainerServiceRunStarlarkScriptClient) Recv() (*StarlarkRunResponseLine, error) {
	m := new(StarlarkRunResponseLine)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *apiContainerServiceClient) UploadStarlarkPackage(ctx context.Context, opts ...grpc.CallOption) (ApiContainerService_UploadStarlarkPackageClient, error) {
	stream, err := c.cc.NewStream(ctx, &ApiContainerService_ServiceDesc.Streams[1], ApiContainerService_UploadStarlarkPackage_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &apiContainerServiceUploadStarlarkPackageClient{stream}
	return x, nil
}

type ApiContainerService_UploadStarlarkPackageClient interface {
	Send(*StreamedDataChunk) error
	CloseAndRecv() (*emptypb.Empty, error)
	grpc.ClientStream
}

type apiContainerServiceUploadStarlarkPackageClient struct {
	grpc.ClientStream
}

func (x *apiContainerServiceUploadStarlarkPackageClient) Send(m *StreamedDataChunk) error {
	return x.ClientStream.SendMsg(m)
}

func (x *apiContainerServiceUploadStarlarkPackageClient) CloseAndRecv() (*emptypb.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(emptypb.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *apiContainerServiceClient) RunStarlarkPackage(ctx context.Context, in *RunStarlarkPackageArgs, opts ...grpc.CallOption) (ApiContainerService_RunStarlarkPackageClient, error) {
	stream, err := c.cc.NewStream(ctx, &ApiContainerService_ServiceDesc.Streams[2], ApiContainerService_RunStarlarkPackage_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &apiContainerServiceRunStarlarkPackageClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ApiContainerService_RunStarlarkPackageClient interface {
	Recv() (*StarlarkRunResponseLine, error)
	grpc.ClientStream
}

type apiContainerServiceRunStarlarkPackageClient struct {
	grpc.ClientStream
}

func (x *apiContainerServiceRunStarlarkPackageClient) Recv() (*StarlarkRunResponseLine, error) {
	m := new(StarlarkRunResponseLine)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *apiContainerServiceClient) GetServices(ctx context.Context, in *GetServicesArgs, opts ...grpc.CallOption) (*GetServicesResponse, error) {
	out := new(GetServicesResponse)
	err := c.cc.Invoke(ctx, ApiContainerService_GetServices_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiContainerServiceClient) GetExistingAndHistoricalServiceIdentifiers(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetExistingAndHistoricalServiceIdentifiersResponse, error) {
	out := new(GetExistingAndHistoricalServiceIdentifiersResponse)
	err := c.cc.Invoke(ctx, ApiContainerService_GetExistingAndHistoricalServiceIdentifiers_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiContainerServiceClient) ExecCommand(ctx context.Context, in *ExecCommandArgs, opts ...grpc.CallOption) (*ExecCommandResponse, error) {
	out := new(ExecCommandResponse)
	err := c.cc.Invoke(ctx, ApiContainerService_ExecCommand_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiContainerServiceClient) WaitForHttpGetEndpointAvailability(ctx context.Context, in *WaitForHttpGetEndpointAvailabilityArgs, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ApiContainerService_WaitForHttpGetEndpointAvailability_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiContainerServiceClient) WaitForHttpPostEndpointAvailability(ctx context.Context, in *WaitForHttpPostEndpointAvailabilityArgs, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ApiContainerService_WaitForHttpPostEndpointAvailability_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiContainerServiceClient) UploadFilesArtifact(ctx context.Context, opts ...grpc.CallOption) (ApiContainerService_UploadFilesArtifactClient, error) {
	stream, err := c.cc.NewStream(ctx, &ApiContainerService_ServiceDesc.Streams[3], ApiContainerService_UploadFilesArtifact_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &apiContainerServiceUploadFilesArtifactClient{stream}
	return x, nil
}

type ApiContainerService_UploadFilesArtifactClient interface {
	Send(*StreamedDataChunk) error
	CloseAndRecv() (*UploadFilesArtifactResponse, error)
	grpc.ClientStream
}

type apiContainerServiceUploadFilesArtifactClient struct {
	grpc.ClientStream
}

func (x *apiContainerServiceUploadFilesArtifactClient) Send(m *StreamedDataChunk) error {
	return x.ClientStream.SendMsg(m)
}

func (x *apiContainerServiceUploadFilesArtifactClient) CloseAndRecv() (*UploadFilesArtifactResponse, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(UploadFilesArtifactResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *apiContainerServiceClient) DownloadFilesArtifact(ctx context.Context, in *DownloadFilesArtifactArgs, opts ...grpc.CallOption) (ApiContainerService_DownloadFilesArtifactClient, error) {
	stream, err := c.cc.NewStream(ctx, &ApiContainerService_ServiceDesc.Streams[4], ApiContainerService_DownloadFilesArtifact_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &apiContainerServiceDownloadFilesArtifactClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type ApiContainerService_DownloadFilesArtifactClient interface {
	Recv() (*StreamedDataChunk, error)
	grpc.ClientStream
}

type apiContainerServiceDownloadFilesArtifactClient struct {
	grpc.ClientStream
}

func (x *apiContainerServiceDownloadFilesArtifactClient) Recv() (*StreamedDataChunk, error) {
	m := new(StreamedDataChunk)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *apiContainerServiceClient) StoreWebFilesArtifact(ctx context.Context, in *StoreWebFilesArtifactArgs, opts ...grpc.CallOption) (*StoreWebFilesArtifactResponse, error) {
	out := new(StoreWebFilesArtifactResponse)
	err := c.cc.Invoke(ctx, ApiContainerService_StoreWebFilesArtifact_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiContainerServiceClient) StoreFilesArtifactFromService(ctx context.Context, in *StoreFilesArtifactFromServiceArgs, opts ...grpc.CallOption) (*StoreFilesArtifactFromServiceResponse, error) {
	out := new(StoreFilesArtifactFromServiceResponse)
	err := c.cc.Invoke(ctx, ApiContainerService_StoreFilesArtifactFromService_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiContainerServiceClient) ListFilesArtifactNamesAndUuids(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListFilesArtifactNamesAndUuidsResponse, error) {
	out := new(ListFilesArtifactNamesAndUuidsResponse)
	err := c.cc.Invoke(ctx, ApiContainerService_ListFilesArtifactNamesAndUuids_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiContainerServiceClient) InspectFilesArtifactContents(ctx context.Context, in *InspectFilesArtifactContentsRequest, opts ...grpc.CallOption) (*InspectFilesArtifactContentsResponse, error) {
	out := new(InspectFilesArtifactContentsResponse)
	err := c.cc.Invoke(ctx, ApiContainerService_InspectFilesArtifactContents_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ApiContainerServiceServer is the server API for ApiContainerService service.
// All implementations should embed UnimplementedApiContainerServiceServer
// for forward compatibility
type ApiContainerServiceServer interface {
	// Executes a Starlark script on the user's behalf
	RunStarlarkScript(*RunStarlarkScriptArgs, ApiContainerService_RunStarlarkScriptServer) error
	// Uploads a Starlark package. This step is required before the package can be executed with RunStarlarkPackage
	UploadStarlarkPackage(ApiContainerService_UploadStarlarkPackageServer) error
	// Executes a Starlark script on the user's behalf
	RunStarlarkPackage(*RunStarlarkPackageArgs, ApiContainerService_RunStarlarkPackageServer) error
	// Returns the IDs of the current services in the enclave
	GetServices(context.Context, *GetServicesArgs) (*GetServicesResponse, error)
	// Returns information about all existing & historical services
	GetExistingAndHistoricalServiceIdentifiers(context.Context, *emptypb.Empty) (*GetExistingAndHistoricalServiceIdentifiersResponse, error)
	// Executes the given command inside a running container
	ExecCommand(context.Context, *ExecCommandArgs) (*ExecCommandResponse, error)
	// Block until the given HTTP endpoint returns available, calling it through a HTTP Get request
	WaitForHttpGetEndpointAvailability(context.Context, *WaitForHttpGetEndpointAvailabilityArgs) (*emptypb.Empty, error)
	// Block until the given HTTP endpoint returns available, calling it through a HTTP Post request
	WaitForHttpPostEndpointAvailability(context.Context, *WaitForHttpPostEndpointAvailabilityArgs) (*emptypb.Empty, error)
	// Uploads a files artifact to the Kurtosis File System
	UploadFilesArtifact(ApiContainerService_UploadFilesArtifactServer) error
	// Downloads a files artifact from the Kurtosis File System
	DownloadFilesArtifact(*DownloadFilesArtifactArgs, ApiContainerService_DownloadFilesArtifactServer) error
	// Tells the API container to download a files artifact from the web to the Kurtosis File System
	StoreWebFilesArtifact(context.Context, *StoreWebFilesArtifactArgs) (*StoreWebFilesArtifactResponse, error)
	// Tells the API container to copy a files artifact from a service to the Kurtosis File System
	StoreFilesArtifactFromService(context.Context, *StoreFilesArtifactFromServiceArgs) (*StoreFilesArtifactFromServiceResponse, error)
	ListFilesArtifactNamesAndUuids(context.Context, *emptypb.Empty) (*ListFilesArtifactNamesAndUuidsResponse, error)
	InspectFilesArtifactContents(context.Context, *InspectFilesArtifactContentsRequest) (*InspectFilesArtifactContentsResponse, error)
}

// UnimplementedApiContainerServiceServer should be embedded to have forward compatible implementations.
type UnimplementedApiContainerServiceServer struct {
}

func (UnimplementedApiContainerServiceServer) RunStarlarkScript(*RunStarlarkScriptArgs, ApiContainerService_RunStarlarkScriptServer) error {
	return status.Errorf(codes.Unimplemented, "method RunStarlarkScript not implemented")
}
func (UnimplementedApiContainerServiceServer) UploadStarlarkPackage(ApiContainerService_UploadStarlarkPackageServer) error {
	return status.Errorf(codes.Unimplemented, "method UploadStarlarkPackage not implemented")
}
func (UnimplementedApiContainerServiceServer) RunStarlarkPackage(*RunStarlarkPackageArgs, ApiContainerService_RunStarlarkPackageServer) error {
	return status.Errorf(codes.Unimplemented, "method RunStarlarkPackage not implemented")
}
func (UnimplementedApiContainerServiceServer) GetServices(context.Context, *GetServicesArgs) (*GetServicesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetServices not implemented")
}
func (UnimplementedApiContainerServiceServer) GetExistingAndHistoricalServiceIdentifiers(context.Context, *emptypb.Empty) (*GetExistingAndHistoricalServiceIdentifiersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetExistingAndHistoricalServiceIdentifiers not implemented")
}
func (UnimplementedApiContainerServiceServer) ExecCommand(context.Context, *ExecCommandArgs) (*ExecCommandResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExecCommand not implemented")
}
func (UnimplementedApiContainerServiceServer) WaitForHttpGetEndpointAvailability(context.Context, *WaitForHttpGetEndpointAvailabilityArgs) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WaitForHttpGetEndpointAvailability not implemented")
}
func (UnimplementedApiContainerServiceServer) WaitForHttpPostEndpointAvailability(context.Context, *WaitForHttpPostEndpointAvailabilityArgs) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WaitForHttpPostEndpointAvailability not implemented")
}
func (UnimplementedApiContainerServiceServer) UploadFilesArtifact(ApiContainerService_UploadFilesArtifactServer) error {
	return status.Errorf(codes.Unimplemented, "method UploadFilesArtifact not implemented")
}
func (UnimplementedApiContainerServiceServer) DownloadFilesArtifact(*DownloadFilesArtifactArgs, ApiContainerService_DownloadFilesArtifactServer) error {
	return status.Errorf(codes.Unimplemented, "method DownloadFilesArtifact not implemented")
}
func (UnimplementedApiContainerServiceServer) StoreWebFilesArtifact(context.Context, *StoreWebFilesArtifactArgs) (*StoreWebFilesArtifactResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StoreWebFilesArtifact not implemented")
}
func (UnimplementedApiContainerServiceServer) StoreFilesArtifactFromService(context.Context, *StoreFilesArtifactFromServiceArgs) (*StoreFilesArtifactFromServiceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StoreFilesArtifactFromService not implemented")
}
func (UnimplementedApiContainerServiceServer) ListFilesArtifactNamesAndUuids(context.Context, *emptypb.Empty) (*ListFilesArtifactNamesAndUuidsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListFilesArtifactNamesAndUuids not implemented")
}
func (UnimplementedApiContainerServiceServer) InspectFilesArtifactContents(context.Context, *InspectFilesArtifactContentsRequest) (*InspectFilesArtifactContentsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectFilesArtifactContents not implemented")
}

// UnsafeApiContainerServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to ApiContainerServiceServer will
// result in compilation errors.
type UnsafeApiContainerServiceServer interface {
	mustEmbedUnimplementedApiContainerServiceServer()
}

func RegisterApiContainerServiceServer(s grpc.ServiceRegistrar, srv ApiContainerServiceServer) {
	s.RegisterService(&ApiContainerService_ServiceDesc, srv)
}

func _ApiContainerService_RunStarlarkScript_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RunStarlarkScriptArgs)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ApiContainerServiceServer).RunStarlarkScript(m, &apiContainerServiceRunStarlarkScriptServer{stream})
}

type ApiContainerService_RunStarlarkScriptServer interface {
	Send(*StarlarkRunResponseLine) error
	grpc.ServerStream
}

type apiContainerServiceRunStarlarkScriptServer struct {
	grpc.ServerStream
}

func (x *apiContainerServiceRunStarlarkScriptServer) Send(m *StarlarkRunResponseLine) error {
	return x.ServerStream.SendMsg(m)
}

func _ApiContainerService_UploadStarlarkPackage_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ApiContainerServiceServer).UploadStarlarkPackage(&apiContainerServiceUploadStarlarkPackageServer{stream})
}

type ApiContainerService_UploadStarlarkPackageServer interface {
	SendAndClose(*emptypb.Empty) error
	Recv() (*StreamedDataChunk, error)
	grpc.ServerStream
}

type apiContainerServiceUploadStarlarkPackageServer struct {
	grpc.ServerStream
}

func (x *apiContainerServiceUploadStarlarkPackageServer) SendAndClose(m *emptypb.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *apiContainerServiceUploadStarlarkPackageServer) Recv() (*StreamedDataChunk, error) {
	m := new(StreamedDataChunk)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _ApiContainerService_RunStarlarkPackage_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RunStarlarkPackageArgs)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ApiContainerServiceServer).RunStarlarkPackage(m, &apiContainerServiceRunStarlarkPackageServer{stream})
}

type ApiContainerService_RunStarlarkPackageServer interface {
	Send(*StarlarkRunResponseLine) error
	grpc.ServerStream
}

type apiContainerServiceRunStarlarkPackageServer struct {
	grpc.ServerStream
}

func (x *apiContainerServiceRunStarlarkPackageServer) Send(m *StarlarkRunResponseLine) error {
	return x.ServerStream.SendMsg(m)
}

func _ApiContainerService_GetServices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetServicesArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiContainerServiceServer).GetServices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ApiContainerService_GetServices_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiContainerServiceServer).GetServices(ctx, req.(*GetServicesArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiContainerService_GetExistingAndHistoricalServiceIdentifiers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiContainerServiceServer).GetExistingAndHistoricalServiceIdentifiers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ApiContainerService_GetExistingAndHistoricalServiceIdentifiers_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiContainerServiceServer).GetExistingAndHistoricalServiceIdentifiers(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiContainerService_ExecCommand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExecCommandArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiContainerServiceServer).ExecCommand(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ApiContainerService_ExecCommand_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiContainerServiceServer).ExecCommand(ctx, req.(*ExecCommandArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiContainerService_WaitForHttpGetEndpointAvailability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WaitForHttpGetEndpointAvailabilityArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiContainerServiceServer).WaitForHttpGetEndpointAvailability(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ApiContainerService_WaitForHttpGetEndpointAvailability_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiContainerServiceServer).WaitForHttpGetEndpointAvailability(ctx, req.(*WaitForHttpGetEndpointAvailabilityArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiContainerService_WaitForHttpPostEndpointAvailability_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WaitForHttpPostEndpointAvailabilityArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiContainerServiceServer).WaitForHttpPostEndpointAvailability(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ApiContainerService_WaitForHttpPostEndpointAvailability_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiContainerServiceServer).WaitForHttpPostEndpointAvailability(ctx, req.(*WaitForHttpPostEndpointAvailabilityArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiContainerService_UploadFilesArtifact_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ApiContainerServiceServer).UploadFilesArtifact(&apiContainerServiceUploadFilesArtifactServer{stream})
}

type ApiContainerService_UploadFilesArtifactServer interface {
	SendAndClose(*UploadFilesArtifactResponse) error
	Recv() (*StreamedDataChunk, error)
	grpc.ServerStream
}

type apiContainerServiceUploadFilesArtifactServer struct {
	grpc.ServerStream
}

func (x *apiContainerServiceUploadFilesArtifactServer) SendAndClose(m *UploadFilesArtifactResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *apiContainerServiceUploadFilesArtifactServer) Recv() (*StreamedDataChunk, error) {
	m := new(StreamedDataChunk)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _ApiContainerService_DownloadFilesArtifact_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DownloadFilesArtifactArgs)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ApiContainerServiceServer).DownloadFilesArtifact(m, &apiContainerServiceDownloadFilesArtifactServer{stream})
}

type ApiContainerService_DownloadFilesArtifactServer interface {
	Send(*StreamedDataChunk) error
	grpc.ServerStream
}

type apiContainerServiceDownloadFilesArtifactServer struct {
	grpc.ServerStream
}

func (x *apiContainerServiceDownloadFilesArtifactServer) Send(m *StreamedDataChunk) error {
	return x.ServerStream.SendMsg(m)
}

func _ApiContainerService_StoreWebFilesArtifact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoreWebFilesArtifactArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiContainerServiceServer).StoreWebFilesArtifact(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ApiContainerService_StoreWebFilesArtifact_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiContainerServiceServer).StoreWebFilesArtifact(ctx, req.(*StoreWebFilesArtifactArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiContainerService_StoreFilesArtifactFromService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoreFilesArtifactFromServiceArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiContainerServiceServer).StoreFilesArtifactFromService(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ApiContainerService_StoreFilesArtifactFromService_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiContainerServiceServer).StoreFilesArtifactFromService(ctx, req.(*StoreFilesArtifactFromServiceArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiContainerService_ListFilesArtifactNamesAndUuids_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiContainerServiceServer).ListFilesArtifactNamesAndUuids(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ApiContainerService_ListFilesArtifactNamesAndUuids_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiContainerServiceServer).ListFilesArtifactNamesAndUuids(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApiContainerService_InspectFilesArtifactContents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InspectFilesArtifactContentsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApiContainerServiceServer).InspectFilesArtifactContents(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ApiContainerService_InspectFilesArtifactContents_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApiContainerServiceServer).InspectFilesArtifactContents(ctx, req.(*InspectFilesArtifactContentsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ApiContainerService_ServiceDesc is the grpc.ServiceDesc for ApiContainerService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ApiContainerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "api_container_api.ApiContainerService",
	HandlerType: (*ApiContainerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetServices",
			Handler:    _ApiContainerService_GetServices_Handler,
		},
		{
			MethodName: "GetExistingAndHistoricalServiceIdentifiers",
			Handler:    _ApiContainerService_GetExistingAndHistoricalServiceIdentifiers_Handler,
		},
		{
			MethodName: "ExecCommand",
			Handler:    _ApiContainerService_ExecCommand_Handler,
		},
		{
			MethodName: "WaitForHttpGetEndpointAvailability",
			Handler:    _ApiContainerService_WaitForHttpGetEndpointAvailability_Handler,
		},
		{
			MethodName: "WaitForHttpPostEndpointAvailability",
			Handler:    _ApiContainerService_WaitForHttpPostEndpointAvailability_Handler,
		},
		{
			MethodName: "StoreWebFilesArtifact",
			Handler:    _ApiContainerService_StoreWebFilesArtifact_Handler,
		},
		{
			MethodName: "StoreFilesArtifactFromService",
			Handler:    _ApiContainerService_StoreFilesArtifactFromService_Handler,
		},
		{
			MethodName: "ListFilesArtifactNamesAndUuids",
			Handler:    _ApiContainerService_ListFilesArtifactNamesAndUuids_Handler,
		},
		{
			MethodName: "InspectFilesArtifactContents",
			Handler:    _ApiContainerService_InspectFilesArtifactContents_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "RunStarlarkScript",
			Handler:       _ApiContainerService_RunStarlarkScript_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UploadStarlarkPackage",
			Handler:       _ApiContainerService_UploadStarlarkPackage_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "RunStarlarkPackage",
			Handler:       _ApiContainerService_RunStarlarkPackage_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UploadFilesArtifact",
			Handler:       _ApiContainerService_UploadFilesArtifact_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "DownloadFilesArtifact",
			Handler:       _ApiContainerService_DownloadFilesArtifact_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api_container_service.proto",
}