go/lab/dut_manager_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.1.0
// - protoc             v3.17.1
// source: lab/dut_manager.proto

package lab

import (
	context "context"
	longrunning "go.chromium.org/chromiumos/config/go/longrunning"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

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

// DutManagerServiceClient is the client API for DutManagerService 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 DutManagerServiceClient interface {
	// Give the DutManager control over a Dut.
	CreateManagedDut(ctx context.Context, in *CreateManagedDutRequest, opts ...grpc.CallOption) (*longrunning.Operation, error)
	DeleteManagedDut(ctx context.Context, in *DeleteManagedDutRequest, opts ...grpc.CallOption) (*DeleteManagedDutResponse, error)
	// List all the Dut's and their current state.
	// this is a MVP - future versions will allow filter params to be
	// passed in so you can list all the failed Dut's etc/
	// The state history will not be populated in List requests.
	ListManagedDuts(ctx context.Context, in *ListManagedDutsRequest, opts ...grpc.CallOption) (*ListManagedDutsResponse, error)
	// Get details including state history for a given Dut.
	GetManagedDut(ctx context.Context, in *GetManagedDutRequest, opts ...grpc.CallOption) (*GetManagedDutResponse, error)
	UpdateManagedDut(ctx context.Context, in *UpdateManagedDutRequest, opts ...grpc.CallOption) (*UpdateManagedDutResponse, error)
	// Tests request temporary ownership of a Dut to run test on.
	// test metadata specifies what type of hardware/software is required.
	// Leases should be given a timeout, ideally the request would indicate the
	// length of lease required and that lease time would be used.
	LeaseManagedDut(ctx context.Context, in *LeaseManagedDutRequest, opts ...grpc.CallOption) (*longrunning.Operation, error)
	// When a test is done with a Dut it should return the lease.
	ReturnManagedDutLease(ctx context.Context, in *ReturnManagedDutLeaseRequest, opts ...grpc.CallOption) (*ReturnManagedDutLeaseResponse, error)
	// If a test needs to extend the time it owns the Dut is should renew
	// the lease.
	ExtendManagedDutLease(ctx context.Context, in *ExtendManagedDutLeaseRequest, opts ...grpc.CallOption) (*ExtendManagedDutLeaseResponse, error)
	// Provision a Dut, used in the Moblab "flashstation" user journey.
	ProvisionManagedDut(ctx context.Context, in *ProvisionManagedDutRequest, opts ...grpc.CallOption) (*ProvisionManagedDutResponse, error)
	// Request that a Dut be verified, if the verify fails it should be
	// put into repairs.  The call returns when the verification has started
	// not when complete/repaired.
	// Use case is when a Dut has been manually repaired this is how a user
	// can request that the Dut be checked and returned to READY state.
	VerifyManagedDut(ctx context.Context, in *VerifyManagedDutRequest, opts ...grpc.CallOption) (*VerifyManagedDutResponse, error)
}

type dutManagerServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDutManagerServiceClient(cc grpc.ClientConnInterface) DutManagerServiceClient {
	return &dutManagerServiceClient{cc}
}

func (c *dutManagerServiceClient) CreateManagedDut(ctx context.Context, in *CreateManagedDutRequest, opts ...grpc.CallOption) (*longrunning.Operation, error) {
	out := new(longrunning.Operation)
	err := c.cc.Invoke(ctx, "/lab.DutManagerService/CreateManagedDut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dutManagerServiceClient) DeleteManagedDut(ctx context.Context, in *DeleteManagedDutRequest, opts ...grpc.CallOption) (*DeleteManagedDutResponse, error) {
	out := new(DeleteManagedDutResponse)
	err := c.cc.Invoke(ctx, "/lab.DutManagerService/DeleteManagedDut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dutManagerServiceClient) ListManagedDuts(ctx context.Context, in *ListManagedDutsRequest, opts ...grpc.CallOption) (*ListManagedDutsResponse, error) {
	out := new(ListManagedDutsResponse)
	err := c.cc.Invoke(ctx, "/lab.DutManagerService/ListManagedDuts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dutManagerServiceClient) GetManagedDut(ctx context.Context, in *GetManagedDutRequest, opts ...grpc.CallOption) (*GetManagedDutResponse, error) {
	out := new(GetManagedDutResponse)
	err := c.cc.Invoke(ctx, "/lab.DutManagerService/GetManagedDut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dutManagerServiceClient) UpdateManagedDut(ctx context.Context, in *UpdateManagedDutRequest, opts ...grpc.CallOption) (*UpdateManagedDutResponse, error) {
	out := new(UpdateManagedDutResponse)
	err := c.cc.Invoke(ctx, "/lab.DutManagerService/UpdateManagedDut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dutManagerServiceClient) LeaseManagedDut(ctx context.Context, in *LeaseManagedDutRequest, opts ...grpc.CallOption) (*longrunning.Operation, error) {
	out := new(longrunning.Operation)
	err := c.cc.Invoke(ctx, "/lab.DutManagerService/LeaseManagedDut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dutManagerServiceClient) ReturnManagedDutLease(ctx context.Context, in *ReturnManagedDutLeaseRequest, opts ...grpc.CallOption) (*ReturnManagedDutLeaseResponse, error) {
	out := new(ReturnManagedDutLeaseResponse)
	err := c.cc.Invoke(ctx, "/lab.DutManagerService/ReturnManagedDutLease", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dutManagerServiceClient) ExtendManagedDutLease(ctx context.Context, in *ExtendManagedDutLeaseRequest, opts ...grpc.CallOption) (*ExtendManagedDutLeaseResponse, error) {
	out := new(ExtendManagedDutLeaseResponse)
	err := c.cc.Invoke(ctx, "/lab.DutManagerService/ExtendManagedDutLease", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dutManagerServiceClient) ProvisionManagedDut(ctx context.Context, in *ProvisionManagedDutRequest, opts ...grpc.CallOption) (*ProvisionManagedDutResponse, error) {
	out := new(ProvisionManagedDutResponse)
	err := c.cc.Invoke(ctx, "/lab.DutManagerService/ProvisionManagedDut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dutManagerServiceClient) VerifyManagedDut(ctx context.Context, in *VerifyManagedDutRequest, opts ...grpc.CallOption) (*VerifyManagedDutResponse, error) {
	out := new(VerifyManagedDutResponse)
	err := c.cc.Invoke(ctx, "/lab.DutManagerService/VerifyManagedDut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DutManagerServiceServer is the server API for DutManagerService service.
// All implementations must embed UnimplementedDutManagerServiceServer
// for forward compatibility
type DutManagerServiceServer interface {
	// Give the DutManager control over a Dut.
	CreateManagedDut(context.Context, *CreateManagedDutRequest) (*longrunning.Operation, error)
	DeleteManagedDut(context.Context, *DeleteManagedDutRequest) (*DeleteManagedDutResponse, error)
	// List all the Dut's and their current state.
	// this is a MVP - future versions will allow filter params to be
	// passed in so you can list all the failed Dut's etc/
	// The state history will not be populated in List requests.
	ListManagedDuts(context.Context, *ListManagedDutsRequest) (*ListManagedDutsResponse, error)
	// Get details including state history for a given Dut.
	GetManagedDut(context.Context, *GetManagedDutRequest) (*GetManagedDutResponse, error)
	UpdateManagedDut(context.Context, *UpdateManagedDutRequest) (*UpdateManagedDutResponse, error)
	// Tests request temporary ownership of a Dut to run test on.
	// test metadata specifies what type of hardware/software is required.
	// Leases should be given a timeout, ideally the request would indicate the
	// length of lease required and that lease time would be used.
	LeaseManagedDut(context.Context, *LeaseManagedDutRequest) (*longrunning.Operation, error)
	// When a test is done with a Dut it should return the lease.
	ReturnManagedDutLease(context.Context, *ReturnManagedDutLeaseRequest) (*ReturnManagedDutLeaseResponse, error)
	// If a test needs to extend the time it owns the Dut is should renew
	// the lease.
	ExtendManagedDutLease(context.Context, *ExtendManagedDutLeaseRequest) (*ExtendManagedDutLeaseResponse, error)
	// Provision a Dut, used in the Moblab "flashstation" user journey.
	ProvisionManagedDut(context.Context, *ProvisionManagedDutRequest) (*ProvisionManagedDutResponse, error)
	// Request that a Dut be verified, if the verify fails it should be
	// put into repairs.  The call returns when the verification has started
	// not when complete/repaired.
	// Use case is when a Dut has been manually repaired this is how a user
	// can request that the Dut be checked and returned to READY state.
	VerifyManagedDut(context.Context, *VerifyManagedDutRequest) (*VerifyManagedDutResponse, error)
	mustEmbedUnimplementedDutManagerServiceServer()
}

// UnimplementedDutManagerServiceServer must be embedded to have forward compatible implementations.
type UnimplementedDutManagerServiceServer struct {
}

func (UnimplementedDutManagerServiceServer) CreateManagedDut(context.Context, *CreateManagedDutRequest) (*longrunning.Operation, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateManagedDut not implemented")
}
func (UnimplementedDutManagerServiceServer) DeleteManagedDut(context.Context, *DeleteManagedDutRequest) (*DeleteManagedDutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteManagedDut not implemented")
}
func (UnimplementedDutManagerServiceServer) ListManagedDuts(context.Context, *ListManagedDutsRequest) (*ListManagedDutsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListManagedDuts not implemented")
}
func (UnimplementedDutManagerServiceServer) GetManagedDut(context.Context, *GetManagedDutRequest) (*GetManagedDutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetManagedDut not implemented")
}
func (UnimplementedDutManagerServiceServer) UpdateManagedDut(context.Context, *UpdateManagedDutRequest) (*UpdateManagedDutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateManagedDut not implemented")
}
func (UnimplementedDutManagerServiceServer) LeaseManagedDut(context.Context, *LeaseManagedDutRequest) (*longrunning.Operation, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LeaseManagedDut not implemented")
}
func (UnimplementedDutManagerServiceServer) ReturnManagedDutLease(context.Context, *ReturnManagedDutLeaseRequest) (*ReturnManagedDutLeaseResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReturnManagedDutLease not implemented")
}
func (UnimplementedDutManagerServiceServer) ExtendManagedDutLease(context.Context, *ExtendManagedDutLeaseRequest) (*ExtendManagedDutLeaseResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExtendManagedDutLease not implemented")
}
func (UnimplementedDutManagerServiceServer) ProvisionManagedDut(context.Context, *ProvisionManagedDutRequest) (*ProvisionManagedDutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProvisionManagedDut not implemented")
}
func (UnimplementedDutManagerServiceServer) VerifyManagedDut(context.Context, *VerifyManagedDutRequest) (*VerifyManagedDutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyManagedDut not implemented")
}
func (UnimplementedDutManagerServiceServer) mustEmbedUnimplementedDutManagerServiceServer() {}

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

func RegisterDutManagerServiceServer(s grpc.ServiceRegistrar, srv DutManagerServiceServer) {
	s.RegisterService(&DutManagerService_ServiceDesc, srv)
}

func _DutManagerService_CreateManagedDut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateManagedDutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DutManagerServiceServer).CreateManagedDut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lab.DutManagerService/CreateManagedDut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DutManagerServiceServer).CreateManagedDut(ctx, req.(*CreateManagedDutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DutManagerService_DeleteManagedDut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteManagedDutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DutManagerServiceServer).DeleteManagedDut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lab.DutManagerService/DeleteManagedDut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DutManagerServiceServer).DeleteManagedDut(ctx, req.(*DeleteManagedDutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DutManagerService_ListManagedDuts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListManagedDutsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DutManagerServiceServer).ListManagedDuts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lab.DutManagerService/ListManagedDuts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DutManagerServiceServer).ListManagedDuts(ctx, req.(*ListManagedDutsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DutManagerService_GetManagedDut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetManagedDutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DutManagerServiceServer).GetManagedDut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lab.DutManagerService/GetManagedDut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DutManagerServiceServer).GetManagedDut(ctx, req.(*GetManagedDutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DutManagerService_UpdateManagedDut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateManagedDutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DutManagerServiceServer).UpdateManagedDut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lab.DutManagerService/UpdateManagedDut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DutManagerServiceServer).UpdateManagedDut(ctx, req.(*UpdateManagedDutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DutManagerService_LeaseManagedDut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LeaseManagedDutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DutManagerServiceServer).LeaseManagedDut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lab.DutManagerService/LeaseManagedDut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DutManagerServiceServer).LeaseManagedDut(ctx, req.(*LeaseManagedDutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DutManagerService_ReturnManagedDutLease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReturnManagedDutLeaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DutManagerServiceServer).ReturnManagedDutLease(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lab.DutManagerService/ReturnManagedDutLease",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DutManagerServiceServer).ReturnManagedDutLease(ctx, req.(*ReturnManagedDutLeaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DutManagerService_ExtendManagedDutLease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExtendManagedDutLeaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DutManagerServiceServer).ExtendManagedDutLease(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lab.DutManagerService/ExtendManagedDutLease",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DutManagerServiceServer).ExtendManagedDutLease(ctx, req.(*ExtendManagedDutLeaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DutManagerService_ProvisionManagedDut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProvisionManagedDutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DutManagerServiceServer).ProvisionManagedDut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lab.DutManagerService/ProvisionManagedDut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DutManagerServiceServer).ProvisionManagedDut(ctx, req.(*ProvisionManagedDutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DutManagerService_VerifyManagedDut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyManagedDutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DutManagerServiceServer).VerifyManagedDut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lab.DutManagerService/VerifyManagedDut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DutManagerServiceServer).VerifyManagedDut(ctx, req.(*VerifyManagedDutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DutManagerService_ServiceDesc is the grpc.ServiceDesc for DutManagerService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DutManagerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "lab.DutManagerService",
	HandlerType: (*DutManagerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateManagedDut",
			Handler:    _DutManagerService_CreateManagedDut_Handler,
		},
		{
			MethodName: "DeleteManagedDut",
			Handler:    _DutManagerService_DeleteManagedDut_Handler,
		},
		{
			MethodName: "ListManagedDuts",
			Handler:    _DutManagerService_ListManagedDuts_Handler,
		},
		{
			MethodName: "GetManagedDut",
			Handler:    _DutManagerService_GetManagedDut_Handler,
		},
		{
			MethodName: "UpdateManagedDut",
			Handler:    _DutManagerService_UpdateManagedDut_Handler,
		},
		{
			MethodName: "LeaseManagedDut",
			Handler:    _DutManagerService_LeaseManagedDut_Handler,
		},
		{
			MethodName: "ReturnManagedDutLease",
			Handler:    _DutManagerService_ReturnManagedDutLease_Handler,
		},
		{
			MethodName: "ExtendManagedDutLease",
			Handler:    _DutManagerService_ExtendManagedDutLease_Handler,
		},
		{
			MethodName: "ProvisionManagedDut",
			Handler:    _DutManagerService_ProvisionManagedDut_Handler,
		},
		{
			MethodName: "VerifyManagedDut",
			Handler:    _DutManagerService_VerifyManagedDut_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lab/dut_manager.proto",
}