control_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.19.4
// source: drand/control.proto

package drand

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

// 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 {
	// PingPong returns an empty message. Purpose is to test the control port.
	PingPong(ctx context.Context, in *Ping, opts ...grpc.CallOption) (*Pong, error)
	// Status responds with the actual status of drand process
	Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error)
	// ListSchemes responds with the list of ids for the available schemes
	ListSchemes(ctx context.Context, in *ListSchemesRequest, opts ...grpc.CallOption) (*ListSchemesResponse, error)
	// ListBeaconIDs responds with the list of ids for the running networks on the node
	ListBeaconIDs(ctx context.Context, in *ListBeaconIDsRequest, opts ...grpc.CallOption) (*ListBeaconIDsResponse, error)
	// InitDKG sends information to daemon to start a fresh DKG protocol
	InitDKG(ctx context.Context, in *InitDKGPacket, opts ...grpc.CallOption) (*GroupPacket, error)
	// InitReshares sends all informations so that the drand node knows how to
	// proceeed during the next resharing protocol.
	InitReshare(ctx context.Context, in *InitResharePacket, opts ...grpc.CallOption) (*GroupPacket, error)
	// Share returns the current private share used by the node
	Share(ctx context.Context, in *ShareRequest, opts ...grpc.CallOption) (*ShareResponse, error)
	// PublicKey returns the longterm public key of the drand node
	PublicKey(ctx context.Context, in *PublicKeyRequest, opts ...grpc.CallOption) (*PublicKeyResponse, error)
	// PrivateKey returns the longterm private key of the drand node
	PrivateKey(ctx context.Context, in *PrivateKeyRequest, opts ...grpc.CallOption) (*PrivateKeyResponse, error)
	// CollectiveKey returns the distributed public key used by the node
	ChainInfo(ctx context.Context, in *ChainInfoRequest, opts ...grpc.CallOption) (*ChainInfoPacket, error)
	// GroupFile returns the TOML-encoded group file
	// similar to public.Group method but needed for ease of use of the
	// control functionalities
	GroupFile(ctx context.Context, in *GroupRequest, opts ...grpc.CallOption) (*GroupPacket, error)
	Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error)
	LoadBeacon(ctx context.Context, in *LoadBeaconRequest, opts ...grpc.CallOption) (*LoadBeaconResponse, error)
	StartFollowChain(ctx context.Context, in *StartSyncRequest, opts ...grpc.CallOption) (Control_StartFollowChainClient, error)
	StartCheckChain(ctx context.Context, in *StartSyncRequest, opts ...grpc.CallOption) (Control_StartCheckChainClient, error)
	BackupDatabase(ctx context.Context, in *BackupDBRequest, opts ...grpc.CallOption) (*BackupDBResponse, error)
	// RemoteStatus request the status of some remote drand nodes
	RemoteStatus(ctx context.Context, in *RemoteStatusRequest, opts ...grpc.CallOption) (*RemoteStatusResponse, error)
}

type controlClient struct {
	cc grpc.ClientConnInterface
}

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

func (c *controlClient) PingPong(ctx context.Context, in *Ping, opts ...grpc.CallOption) (*Pong, error) {
	out := new(Pong)
	err := c.cc.Invoke(ctx, "/drand.Control/PingPong", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) {
	out := new(StatusResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/Status", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) ListSchemes(ctx context.Context, in *ListSchemesRequest, opts ...grpc.CallOption) (*ListSchemesResponse, error) {
	out := new(ListSchemesResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/ListSchemes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) ListBeaconIDs(ctx context.Context, in *ListBeaconIDsRequest, opts ...grpc.CallOption) (*ListBeaconIDsResponse, error) {
	out := new(ListBeaconIDsResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/ListBeaconIDs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) InitDKG(ctx context.Context, in *InitDKGPacket, opts ...grpc.CallOption) (*GroupPacket, error) {
	out := new(GroupPacket)
	err := c.cc.Invoke(ctx, "/drand.Control/InitDKG", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) InitReshare(ctx context.Context, in *InitResharePacket, opts ...grpc.CallOption) (*GroupPacket, error) {
	out := new(GroupPacket)
	err := c.cc.Invoke(ctx, "/drand.Control/InitReshare", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) Share(ctx context.Context, in *ShareRequest, opts ...grpc.CallOption) (*ShareResponse, error) {
	out := new(ShareResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/Share", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) PublicKey(ctx context.Context, in *PublicKeyRequest, opts ...grpc.CallOption) (*PublicKeyResponse, error) {
	out := new(PublicKeyResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/PublicKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) PrivateKey(ctx context.Context, in *PrivateKeyRequest, opts ...grpc.CallOption) (*PrivateKeyResponse, error) {
	out := new(PrivateKeyResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/PrivateKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) ChainInfo(ctx context.Context, in *ChainInfoRequest, opts ...grpc.CallOption) (*ChainInfoPacket, error) {
	out := new(ChainInfoPacket)
	err := c.cc.Invoke(ctx, "/drand.Control/ChainInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) GroupFile(ctx context.Context, in *GroupRequest, opts ...grpc.CallOption) (*GroupPacket, error) {
	out := new(GroupPacket)
	err := c.cc.Invoke(ctx, "/drand.Control/GroupFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) {
	out := new(ShutdownResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/Shutdown", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) LoadBeacon(ctx context.Context, in *LoadBeaconRequest, opts ...grpc.CallOption) (*LoadBeaconResponse, error) {
	out := new(LoadBeaconResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/LoadBeacon", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) StartFollowChain(ctx context.Context, in *StartSyncRequest, opts ...grpc.CallOption) (Control_StartFollowChainClient, error) {
	stream, err := c.cc.NewStream(ctx, &Control_ServiceDesc.Streams[0], "/drand.Control/StartFollowChain", opts...)
	if err != nil {
		return nil, err
	}
	x := &controlStartFollowChainClient{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_StartFollowChainClient interface {
	Recv() (*SyncProgress, error)
	grpc.ClientStream
}

type controlStartFollowChainClient struct {
	grpc.ClientStream
}

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

func (c *controlClient) StartCheckChain(ctx context.Context, in *StartSyncRequest, opts ...grpc.CallOption) (Control_StartCheckChainClient, error) {
	stream, err := c.cc.NewStream(ctx, &Control_ServiceDesc.Streams[1], "/drand.Control/StartCheckChain", opts...)
	if err != nil {
		return nil, err
	}
	x := &controlStartCheckChainClient{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_StartCheckChainClient interface {
	Recv() (*SyncProgress, error)
	grpc.ClientStream
}

type controlStartCheckChainClient struct {
	grpc.ClientStream
}

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

func (c *controlClient) BackupDatabase(ctx context.Context, in *BackupDBRequest, opts ...grpc.CallOption) (*BackupDBResponse, error) {
	out := new(BackupDBResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/BackupDatabase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) RemoteStatus(ctx context.Context, in *RemoteStatusRequest, opts ...grpc.CallOption) (*RemoteStatusResponse, error) {
	out := new(RemoteStatusResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/RemoteStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ControlServer is the server API for Control service.
// All implementations should embed UnimplementedControlServer
// for forward compatibility
type ControlServer interface {
	// PingPong returns an empty message. Purpose is to test the control port.
	PingPong(context.Context, *Ping) (*Pong, error)
	// Status responds with the actual status of drand process
	Status(context.Context, *StatusRequest) (*StatusResponse, error)
	// ListSchemes responds with the list of ids for the available schemes
	ListSchemes(context.Context, *ListSchemesRequest) (*ListSchemesResponse, error)
	// ListBeaconIDs responds with the list of ids for the running networks on the node
	ListBeaconIDs(context.Context, *ListBeaconIDsRequest) (*ListBeaconIDsResponse, error)
	// InitDKG sends information to daemon to start a fresh DKG protocol
	InitDKG(context.Context, *InitDKGPacket) (*GroupPacket, error)
	// InitReshares sends all informations so that the drand node knows how to
	// proceeed during the next resharing protocol.
	InitReshare(context.Context, *InitResharePacket) (*GroupPacket, error)
	// Share returns the current private share used by the node
	Share(context.Context, *ShareRequest) (*ShareResponse, error)
	// PublicKey returns the longterm public key of the drand node
	PublicKey(context.Context, *PublicKeyRequest) (*PublicKeyResponse, error)
	// PrivateKey returns the longterm private key of the drand node
	PrivateKey(context.Context, *PrivateKeyRequest) (*PrivateKeyResponse, error)
	// CollectiveKey returns the distributed public key used by the node
	ChainInfo(context.Context, *ChainInfoRequest) (*ChainInfoPacket, error)
	// GroupFile returns the TOML-encoded group file
	// similar to public.Group method but needed for ease of use of the
	// control functionalities
	GroupFile(context.Context, *GroupRequest) (*GroupPacket, error)
	Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error)
	LoadBeacon(context.Context, *LoadBeaconRequest) (*LoadBeaconResponse, error)
	StartFollowChain(*StartSyncRequest, Control_StartFollowChainServer) error
	StartCheckChain(*StartSyncRequest, Control_StartCheckChainServer) error
	BackupDatabase(context.Context, *BackupDBRequest) (*BackupDBResponse, error)
	// RemoteStatus request the status of some remote drand nodes
	RemoteStatus(context.Context, *RemoteStatusRequest) (*RemoteStatusResponse, error)
}

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

func (UnimplementedControlServer) PingPong(context.Context, *Ping) (*Pong, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PingPong not implemented")
}
func (UnimplementedControlServer) Status(context.Context, *StatusRequest) (*StatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Status not implemented")
}
func (UnimplementedControlServer) ListSchemes(context.Context, *ListSchemesRequest) (*ListSchemesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSchemes not implemented")
}
func (UnimplementedControlServer) ListBeaconIDs(context.Context, *ListBeaconIDsRequest) (*ListBeaconIDsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListBeaconIDs not implemented")
}
func (UnimplementedControlServer) InitDKG(context.Context, *InitDKGPacket) (*GroupPacket, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitDKG not implemented")
}
func (UnimplementedControlServer) InitReshare(context.Context, *InitResharePacket) (*GroupPacket, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitReshare not implemented")
}
func (UnimplementedControlServer) Share(context.Context, *ShareRequest) (*ShareResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Share not implemented")
}
func (UnimplementedControlServer) PublicKey(context.Context, *PublicKeyRequest) (*PublicKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublicKey not implemented")
}
func (UnimplementedControlServer) PrivateKey(context.Context, *PrivateKeyRequest) (*PrivateKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PrivateKey not implemented")
}
func (UnimplementedControlServer) ChainInfo(context.Context, *ChainInfoRequest) (*ChainInfoPacket, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChainInfo not implemented")
}
func (UnimplementedControlServer) GroupFile(context.Context, *GroupRequest) (*GroupPacket, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GroupFile not implemented")
}
func (UnimplementedControlServer) Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Shutdown not implemented")
}
func (UnimplementedControlServer) LoadBeacon(context.Context, *LoadBeaconRequest) (*LoadBeaconResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LoadBeacon not implemented")
}
func (UnimplementedControlServer) StartFollowChain(*StartSyncRequest, Control_StartFollowChainServer) error {
	return status.Errorf(codes.Unimplemented, "method StartFollowChain not implemented")
}
func (UnimplementedControlServer) StartCheckChain(*StartSyncRequest, Control_StartCheckChainServer) error {
	return status.Errorf(codes.Unimplemented, "method StartCheckChain not implemented")
}
func (UnimplementedControlServer) BackupDatabase(context.Context, *BackupDBRequest) (*BackupDBResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BackupDatabase not implemented")
}
func (UnimplementedControlServer) RemoteStatus(context.Context, *RemoteStatusRequest) (*RemoteStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoteStatus not implemented")
}

// 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_PingPong_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Ping)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).PingPong(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/PingPong",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).PingPong(ctx, req.(*Ping))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).Status(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/Status",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).Status(ctx, req.(*StatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_ListSchemes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSchemesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).ListSchemes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/ListSchemes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).ListSchemes(ctx, req.(*ListSchemesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_ListBeaconIDs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListBeaconIDsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).ListBeaconIDs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/ListBeaconIDs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).ListBeaconIDs(ctx, req.(*ListBeaconIDsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_InitDKG_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InitDKGPacket)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).InitDKG(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/InitDKG",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).InitDKG(ctx, req.(*InitDKGPacket))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_InitReshare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InitResharePacket)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).InitReshare(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/InitReshare",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).InitReshare(ctx, req.(*InitResharePacket))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_Share_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ShareRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).Share(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/Share",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).Share(ctx, req.(*ShareRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_PublicKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublicKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).PublicKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/PublicKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).PublicKey(ctx, req.(*PublicKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_PrivateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrivateKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).PrivateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/PrivateKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).PrivateKey(ctx, req.(*PrivateKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_ChainInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChainInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).ChainInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/ChainInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).ChainInfo(ctx, req.(*ChainInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_GroupFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).GroupFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/GroupFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).GroupFile(ctx, req.(*GroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ShutdownRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).Shutdown(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/Shutdown",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).Shutdown(ctx, req.(*ShutdownRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_LoadBeacon_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadBeaconRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).LoadBeacon(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/LoadBeacon",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).LoadBeacon(ctx, req.(*LoadBeaconRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_StartFollowChain_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StartSyncRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ControlServer).StartFollowChain(m, &controlStartFollowChainServer{stream})
}

type Control_StartFollowChainServer interface {
	Send(*SyncProgress) error
	grpc.ServerStream
}

type controlStartFollowChainServer struct {
	grpc.ServerStream
}

func (x *controlStartFollowChainServer) Send(m *SyncProgress) error {
	return x.ServerStream.SendMsg(m)
}

func _Control_StartCheckChain_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StartSyncRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ControlServer).StartCheckChain(m, &controlStartCheckChainServer{stream})
}

type Control_StartCheckChainServer interface {
	Send(*SyncProgress) error
	grpc.ServerStream
}

type controlStartCheckChainServer struct {
	grpc.ServerStream
}

func (x *controlStartCheckChainServer) Send(m *SyncProgress) error {
	return x.ServerStream.SendMsg(m)
}

func _Control_BackupDatabase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackupDBRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).BackupDatabase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/BackupDatabase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).BackupDatabase(ctx, req.(*BackupDBRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_RemoteStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoteStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).RemoteStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/RemoteStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).RemoteStatus(ctx, req.(*RemoteStatusRequest))
	}
	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: "drand.Control",
	HandlerType: (*ControlServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PingPong",
			Handler:    _Control_PingPong_Handler,
		},
		{
			MethodName: "Status",
			Handler:    _Control_Status_Handler,
		},
		{
			MethodName: "ListSchemes",
			Handler:    _Control_ListSchemes_Handler,
		},
		{
			MethodName: "ListBeaconIDs",
			Handler:    _Control_ListBeaconIDs_Handler,
		},
		{
			MethodName: "InitDKG",
			Handler:    _Control_InitDKG_Handler,
		},
		{
			MethodName: "InitReshare",
			Handler:    _Control_InitReshare_Handler,
		},
		{
			MethodName: "Share",
			Handler:    _Control_Share_Handler,
		},
		{
			MethodName: "PublicKey",
			Handler:    _Control_PublicKey_Handler,
		},
		{
			MethodName: "PrivateKey",
			Handler:    _Control_PrivateKey_Handler,
		},
		{
			MethodName: "ChainInfo",
			Handler:    _Control_ChainInfo_Handler,
		},
		{
			MethodName: "GroupFile",
			Handler:    _Control_GroupFile_Handler,
		},
		{
			MethodName: "Shutdown",
			Handler:    _Control_Shutdown_Handler,
		},
		{
			MethodName: "LoadBeacon",
			Handler:    _Control_LoadBeacon_Handler,
		},
		{
			MethodName: "BackupDatabase",
			Handler:    _Control_BackupDatabase_Handler,
		},
		{
			MethodName: "RemoteStatus",
			Handler:    _Control_RemoteStatus_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StartFollowChain",
			Handler:       _Control_StartFollowChain_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StartCheckChain",
			Handler:       _Control_StartCheckChain_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "drand/control.proto",
}