control_grpc.pb.go

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

package types

import (
	context "context"
	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

const (
	Control_Tenants_FullMethodName                = "/Control/Tenants"
	Control_AddTenant_FullMethodName              = "/Control/AddTenant"
	Control_AddPackage_FullMethodName             = "/Control/AddPackage"
	Control_AllPackages_FullMethodName            = "/Control/AllPackages"
	Control_Packages_FullMethodName               = "/Control/Packages"
	Control_UpdatePackage_FullMethodName          = "/Control/UpdatePackage"
	Control_DeletePackage_FullMethodName          = "/Control/DeletePackage"
	Control_UpdateToPackagesStr_FullMethodName    = "/Control/UpdateToPackagesStr"
	Control_Environment_FullMethodName            = "/Control/Environment"
	Control_UpdateToEnvironmentStr_FullMethodName = "/Control/UpdateToEnvironmentStr"
	Control_AddEnvironment_FullMethodName         = "/Control/AddEnvironment"
	Control_UpdateEnvironment_FullMethodName      = "/Control/UpdateEnvironment"
)

// ControlClient is the client API for Control 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 ControlClient interface {
	Tenants(ctx context.Context, in *TenantsRequest, opts ...grpc.CallOption) (*TenantsReply, error)
	AddTenant(ctx context.Context, in *AddTenantRequest, opts ...grpc.CallOption) (*AddTenantReply, error)
	AddPackage(ctx context.Context, in *AddPackageRequest, opts ...grpc.CallOption) (*AddPackageReply, error)
	AllPackages(ctx context.Context, in *Void, opts ...grpc.CallOption) (*AllPackagesReply, error)
	Packages(ctx context.Context, in *PackagesRequest, opts ...grpc.CallOption) (*PackagesReply, error)
	UpdatePackage(ctx context.Context, in *UpdatePackageRequest, opts ...grpc.CallOption) (*Void, error)
	DeletePackage(ctx context.Context, in *DeletePackageRequest, opts ...grpc.CallOption) (*Void, error)
	UpdateToPackagesStr(ctx context.Context, in *UpdateToPackagesStrRequest, opts ...grpc.CallOption) (Control_UpdateToPackagesStrClient, error)
	Environment(ctx context.Context, in *Void, opts ...grpc.CallOption) (*EnvironmentReply, error)
	UpdateToEnvironmentStr(ctx context.Context, in *Void, opts ...grpc.CallOption) (Control_UpdateToEnvironmentStrClient, error)
	AddEnvironment(ctx context.Context, in *AddEnvironmentRequest, opts ...grpc.CallOption) (*AddEnvironmentReply, error)
	UpdateEnvironment(ctx context.Context, in *UpdateEnvironmentRequest, opts ...grpc.CallOption) (*Void, error)
}

type controlClient struct {
	cc grpc.ClientConnInterface
}

func NewControlClient(cc grpc.ClientConnInterface) ControlClient {
	return &controlClient{cc}
}

func (c *controlClient) Tenants(ctx context.Context, in *TenantsRequest, opts ...grpc.CallOption) (*TenantsReply, error) {
	out := new(TenantsReply)
	err := c.cc.Invoke(ctx, Control_Tenants_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) AddTenant(ctx context.Context, in *AddTenantRequest, opts ...grpc.CallOption) (*AddTenantReply, error) {
	out := new(AddTenantReply)
	err := c.cc.Invoke(ctx, Control_AddTenant_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) AddPackage(ctx context.Context, in *AddPackageRequest, opts ...grpc.CallOption) (*AddPackageReply, error) {
	out := new(AddPackageReply)
	err := c.cc.Invoke(ctx, Control_AddPackage_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) AllPackages(ctx context.Context, in *Void, opts ...grpc.CallOption) (*AllPackagesReply, error) {
	out := new(AllPackagesReply)
	err := c.cc.Invoke(ctx, Control_AllPackages_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) Packages(ctx context.Context, in *PackagesRequest, opts ...grpc.CallOption) (*PackagesReply, error) {
	out := new(PackagesReply)
	err := c.cc.Invoke(ctx, Control_Packages_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) UpdatePackage(ctx context.Context, in *UpdatePackageRequest, opts ...grpc.CallOption) (*Void, error) {
	out := new(Void)
	err := c.cc.Invoke(ctx, Control_UpdatePackage_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) DeletePackage(ctx context.Context, in *DeletePackageRequest, opts ...grpc.CallOption) (*Void, error) {
	out := new(Void)
	err := c.cc.Invoke(ctx, Control_DeletePackage_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) UpdateToPackagesStr(ctx context.Context, in *UpdateToPackagesStrRequest, opts ...grpc.CallOption) (Control_UpdateToPackagesStrClient, error) {
	stream, err := c.cc.NewStream(ctx, &Control_ServiceDesc.Streams[0], Control_UpdateToPackagesStr_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &controlUpdateToPackagesStrClient{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 Control_UpdateToPackagesStrClient interface {
	Recv() (*UpdateToPackagesStrReply, error)
	grpc.ClientStream
}

type controlUpdateToPackagesStrClient struct {
	grpc.ClientStream
}

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

func (c *controlClient) Environment(ctx context.Context, in *Void, opts ...grpc.CallOption) (*EnvironmentReply, error) {
	out := new(EnvironmentReply)
	err := c.cc.Invoke(ctx, Control_Environment_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) UpdateToEnvironmentStr(ctx context.Context, in *Void, opts ...grpc.CallOption) (Control_UpdateToEnvironmentStrClient, error) {
	stream, err := c.cc.NewStream(ctx, &Control_ServiceDesc.Streams[1], Control_UpdateToEnvironmentStr_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &controlUpdateToEnvironmentStrClient{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 Control_UpdateToEnvironmentStrClient interface {
	Recv() (*UpdateToEnvironmentStrReply, error)
	grpc.ClientStream
}

type controlUpdateToEnvironmentStrClient struct {
	grpc.ClientStream
}

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

func (c *controlClient) AddEnvironment(ctx context.Context, in *AddEnvironmentRequest, opts ...grpc.CallOption) (*AddEnvironmentReply, error) {
	out := new(AddEnvironmentReply)
	err := c.cc.Invoke(ctx, Control_AddEnvironment_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) UpdateEnvironment(ctx context.Context, in *UpdateEnvironmentRequest, opts ...grpc.CallOption) (*Void, error) {
	out := new(Void)
	err := c.cc.Invoke(ctx, Control_UpdateEnvironment_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ControlServer is the server API for Control service.
// All implementations must embed UnimplementedControlServer
// for forward compatibility
type ControlServer interface {
	Tenants(context.Context, *TenantsRequest) (*TenantsReply, error)
	AddTenant(context.Context, *AddTenantRequest) (*AddTenantReply, error)
	AddPackage(context.Context, *AddPackageRequest) (*AddPackageReply, error)
	AllPackages(context.Context, *Void) (*AllPackagesReply, error)
	Packages(context.Context, *PackagesRequest) (*PackagesReply, error)
	UpdatePackage(context.Context, *UpdatePackageRequest) (*Void, error)
	DeletePackage(context.Context, *DeletePackageRequest) (*Void, error)
	UpdateToPackagesStr(*UpdateToPackagesStrRequest, Control_UpdateToPackagesStrServer) error
	Environment(context.Context, *Void) (*EnvironmentReply, error)
	UpdateToEnvironmentStr(*Void, Control_UpdateToEnvironmentStrServer) error
	AddEnvironment(context.Context, *AddEnvironmentRequest) (*AddEnvironmentReply, error)
	UpdateEnvironment(context.Context, *UpdateEnvironmentRequest) (*Void, error)
	mustEmbedUnimplementedControlServer()
}

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

func (UnimplementedControlServer) Tenants(context.Context, *TenantsRequest) (*TenantsReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Tenants not implemented")
}
func (UnimplementedControlServer) AddTenant(context.Context, *AddTenantRequest) (*AddTenantReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddTenant not implemented")
}
func (UnimplementedControlServer) AddPackage(context.Context, *AddPackageRequest) (*AddPackageReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddPackage not implemented")
}
func (UnimplementedControlServer) AllPackages(context.Context, *Void) (*AllPackagesReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AllPackages not implemented")
}
func (UnimplementedControlServer) Packages(context.Context, *PackagesRequest) (*PackagesReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Packages not implemented")
}
func (UnimplementedControlServer) UpdatePackage(context.Context, *UpdatePackageRequest) (*Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdatePackage not implemented")
}
func (UnimplementedControlServer) DeletePackage(context.Context, *DeletePackageRequest) (*Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePackage not implemented")
}
func (UnimplementedControlServer) UpdateToPackagesStr(*UpdateToPackagesStrRequest, Control_UpdateToPackagesStrServer) error {
	return status.Errorf(codes.Unimplemented, "method UpdateToPackagesStr not implemented")
}
func (UnimplementedControlServer) Environment(context.Context, *Void) (*EnvironmentReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Environment not implemented")
}
func (UnimplementedControlServer) UpdateToEnvironmentStr(*Void, Control_UpdateToEnvironmentStrServer) error {
	return status.Errorf(codes.Unimplemented, "method UpdateToEnvironmentStr not implemented")
}
func (UnimplementedControlServer) AddEnvironment(context.Context, *AddEnvironmentRequest) (*AddEnvironmentReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddEnvironment not implemented")
}
func (UnimplementedControlServer) UpdateEnvironment(context.Context, *UpdateEnvironmentRequest) (*Void, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateEnvironment not implemented")
}
func (UnimplementedControlServer) mustEmbedUnimplementedControlServer() {}

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

func RegisterControlServer(s grpc.ServiceRegistrar, srv ControlServer) {
	s.RegisterService(&Control_ServiceDesc, srv)
}

func _Control_Tenants_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TenantsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).Tenants(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_Tenants_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).Tenants(ctx, req.(*TenantsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_AddTenant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddTenantRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).AddTenant(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_AddTenant_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).AddTenant(ctx, req.(*AddTenantRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_AddPackage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddPackageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).AddPackage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_AddPackage_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).AddPackage(ctx, req.(*AddPackageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_AllPackages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Void)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).AllPackages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_AllPackages_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).AllPackages(ctx, req.(*Void))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_Packages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PackagesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).Packages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_Packages_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).Packages(ctx, req.(*PackagesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_UpdatePackage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdatePackageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).UpdatePackage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_UpdatePackage_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).UpdatePackage(ctx, req.(*UpdatePackageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_DeletePackage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePackageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).DeletePackage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_DeletePackage_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).DeletePackage(ctx, req.(*DeletePackageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_UpdateToPackagesStr_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(UpdateToPackagesStrRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ControlServer).UpdateToPackagesStr(m, &controlUpdateToPackagesStrServer{stream})
}

type Control_UpdateToPackagesStrServer interface {
	Send(*UpdateToPackagesStrReply) error
	grpc.ServerStream
}

type controlUpdateToPackagesStrServer struct {
	grpc.ServerStream
}

func (x *controlUpdateToPackagesStrServer) Send(m *UpdateToPackagesStrReply) error {
	return x.ServerStream.SendMsg(m)
}

func _Control_Environment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Void)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).Environment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_Environment_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).Environment(ctx, req.(*Void))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_UpdateToEnvironmentStr_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Void)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ControlServer).UpdateToEnvironmentStr(m, &controlUpdateToEnvironmentStrServer{stream})
}

type Control_UpdateToEnvironmentStrServer interface {
	Send(*UpdateToEnvironmentStrReply) error
	grpc.ServerStream
}

type controlUpdateToEnvironmentStrServer struct {
	grpc.ServerStream
}

func (x *controlUpdateToEnvironmentStrServer) Send(m *UpdateToEnvironmentStrReply) error {
	return x.ServerStream.SendMsg(m)
}

func _Control_AddEnvironment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddEnvironmentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).AddEnvironment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_AddEnvironment_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).AddEnvironment(ctx, req.(*AddEnvironmentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_UpdateEnvironment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateEnvironmentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).UpdateEnvironment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Control_UpdateEnvironment_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).UpdateEnvironment(ctx, req.(*UpdateEnvironmentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Control_ServiceDesc is the grpc.ServiceDesc for Control service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Control_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "Control",
	HandlerType: (*ControlServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Tenants",
			Handler:    _Control_Tenants_Handler,
		},
		{
			MethodName: "AddTenant",
			Handler:    _Control_AddTenant_Handler,
		},
		{
			MethodName: "AddPackage",
			Handler:    _Control_AddPackage_Handler,
		},
		{
			MethodName: "AllPackages",
			Handler:    _Control_AllPackages_Handler,
		},
		{
			MethodName: "Packages",
			Handler:    _Control_Packages_Handler,
		},
		{
			MethodName: "UpdatePackage",
			Handler:    _Control_UpdatePackage_Handler,
		},
		{
			MethodName: "DeletePackage",
			Handler:    _Control_DeletePackage_Handler,
		},
		{
			MethodName: "Environment",
			Handler:    _Control_Environment_Handler,
		},
		{
			MethodName: "AddEnvironment",
			Handler:    _Control_AddEnvironment_Handler,
		},
		{
			MethodName: "UpdateEnvironment",
			Handler:    _Control_UpdateEnvironment_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "UpdateToPackagesStr",
			Handler:       _Control_UpdateToPackagesStr_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UpdateToEnvironmentStr",
			Handler:       _Control_UpdateToEnvironmentStr_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "control.proto",
}