mysqlctl.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: mysqlctl.proto

package mysqlctl // import "vitess.io/vitess/go/vt/proto/mysqlctl"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type StartRequest struct {
	MysqldArgs           []string `protobuf:"bytes,1,rep,name=mysqld_args,json=mysqldArgs,proto3" json:"mysqld_args,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StartRequest) Reset()         { *m = StartRequest{} }
func (m *StartRequest) String() string { return proto.CompactTextString(m) }
func (*StartRequest) ProtoMessage()    {}
func (*StartRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_mysqlctl_dc3430948664e7fa, []int{0}
}
func (m *StartRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StartRequest.Unmarshal(m, b)
}
func (m *StartRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StartRequest.Marshal(b, m, deterministic)
}
func (dst *StartRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StartRequest.Merge(dst, src)
}
func (m *StartRequest) XXX_Size() int {
	return xxx_messageInfo_StartRequest.Size(m)
}
func (m *StartRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StartRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StartRequest proto.InternalMessageInfo

func (m *StartRequest) GetMysqldArgs() []string {
	if m != nil {
		return m.MysqldArgs
	}
	return nil
}

type StartResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StartResponse) Reset()         { *m = StartResponse{} }
func (m *StartResponse) String() string { return proto.CompactTextString(m) }
func (*StartResponse) ProtoMessage()    {}
func (*StartResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_mysqlctl_dc3430948664e7fa, []int{1}
}
func (m *StartResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StartResponse.Unmarshal(m, b)
}
func (m *StartResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StartResponse.Marshal(b, m, deterministic)
}
func (dst *StartResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StartResponse.Merge(dst, src)
}
func (m *StartResponse) XXX_Size() int {
	return xxx_messageInfo_StartResponse.Size(m)
}
func (m *StartResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StartResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StartResponse proto.InternalMessageInfo

type ShutdownRequest struct {
	WaitForMysqld        bool     `protobuf:"varint,1,opt,name=wait_for_mysqld,json=waitForMysqld,proto3" json:"wait_for_mysqld,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ShutdownRequest) Reset()         { *m = ShutdownRequest{} }
func (m *ShutdownRequest) String() string { return proto.CompactTextString(m) }
func (*ShutdownRequest) ProtoMessage()    {}
func (*ShutdownRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_mysqlctl_dc3430948664e7fa, []int{2}
}
func (m *ShutdownRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShutdownRequest.Unmarshal(m, b)
}
func (m *ShutdownRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShutdownRequest.Marshal(b, m, deterministic)
}
func (dst *ShutdownRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShutdownRequest.Merge(dst, src)
}
func (m *ShutdownRequest) XXX_Size() int {
	return xxx_messageInfo_ShutdownRequest.Size(m)
}
func (m *ShutdownRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ShutdownRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ShutdownRequest proto.InternalMessageInfo

func (m *ShutdownRequest) GetWaitForMysqld() bool {
	if m != nil {
		return m.WaitForMysqld
	}
	return false
}

type ShutdownResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ShutdownResponse) Reset()         { *m = ShutdownResponse{} }
func (m *ShutdownResponse) String() string { return proto.CompactTextString(m) }
func (*ShutdownResponse) ProtoMessage()    {}
func (*ShutdownResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_mysqlctl_dc3430948664e7fa, []int{3}
}
func (m *ShutdownResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShutdownResponse.Unmarshal(m, b)
}
func (m *ShutdownResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShutdownResponse.Marshal(b, m, deterministic)
}
func (dst *ShutdownResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShutdownResponse.Merge(dst, src)
}
func (m *ShutdownResponse) XXX_Size() int {
	return xxx_messageInfo_ShutdownResponse.Size(m)
}
func (m *ShutdownResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ShutdownResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ShutdownResponse proto.InternalMessageInfo

type RunMysqlUpgradeRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RunMysqlUpgradeRequest) Reset()         { *m = RunMysqlUpgradeRequest{} }
func (m *RunMysqlUpgradeRequest) String() string { return proto.CompactTextString(m) }
func (*RunMysqlUpgradeRequest) ProtoMessage()    {}
func (*RunMysqlUpgradeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_mysqlctl_dc3430948664e7fa, []int{4}
}
func (m *RunMysqlUpgradeRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RunMysqlUpgradeRequest.Unmarshal(m, b)
}
func (m *RunMysqlUpgradeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RunMysqlUpgradeRequest.Marshal(b, m, deterministic)
}
func (dst *RunMysqlUpgradeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RunMysqlUpgradeRequest.Merge(dst, src)
}
func (m *RunMysqlUpgradeRequest) XXX_Size() int {
	return xxx_messageInfo_RunMysqlUpgradeRequest.Size(m)
}
func (m *RunMysqlUpgradeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RunMysqlUpgradeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RunMysqlUpgradeRequest proto.InternalMessageInfo

type RunMysqlUpgradeResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RunMysqlUpgradeResponse) Reset()         { *m = RunMysqlUpgradeResponse{} }
func (m *RunMysqlUpgradeResponse) String() string { return proto.CompactTextString(m) }
func (*RunMysqlUpgradeResponse) ProtoMessage()    {}
func (*RunMysqlUpgradeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_mysqlctl_dc3430948664e7fa, []int{5}
}
func (m *RunMysqlUpgradeResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RunMysqlUpgradeResponse.Unmarshal(m, b)
}
func (m *RunMysqlUpgradeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RunMysqlUpgradeResponse.Marshal(b, m, deterministic)
}
func (dst *RunMysqlUpgradeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RunMysqlUpgradeResponse.Merge(dst, src)
}
func (m *RunMysqlUpgradeResponse) XXX_Size() int {
	return xxx_messageInfo_RunMysqlUpgradeResponse.Size(m)
}
func (m *RunMysqlUpgradeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RunMysqlUpgradeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RunMysqlUpgradeResponse proto.InternalMessageInfo

type ReinitConfigRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReinitConfigRequest) Reset()         { *m = ReinitConfigRequest{} }
func (m *ReinitConfigRequest) String() string { return proto.CompactTextString(m) }
func (*ReinitConfigRequest) ProtoMessage()    {}
func (*ReinitConfigRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_mysqlctl_dc3430948664e7fa, []int{6}
}
func (m *ReinitConfigRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReinitConfigRequest.Unmarshal(m, b)
}
func (m *ReinitConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReinitConfigRequest.Marshal(b, m, deterministic)
}
func (dst *ReinitConfigRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReinitConfigRequest.Merge(dst, src)
}
func (m *ReinitConfigRequest) XXX_Size() int {
	return xxx_messageInfo_ReinitConfigRequest.Size(m)
}
func (m *ReinitConfigRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ReinitConfigRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ReinitConfigRequest proto.InternalMessageInfo

type ReinitConfigResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReinitConfigResponse) Reset()         { *m = ReinitConfigResponse{} }
func (m *ReinitConfigResponse) String() string { return proto.CompactTextString(m) }
func (*ReinitConfigResponse) ProtoMessage()    {}
func (*ReinitConfigResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_mysqlctl_dc3430948664e7fa, []int{7}
}
func (m *ReinitConfigResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReinitConfigResponse.Unmarshal(m, b)
}
func (m *ReinitConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReinitConfigResponse.Marshal(b, m, deterministic)
}
func (dst *ReinitConfigResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReinitConfigResponse.Merge(dst, src)
}
func (m *ReinitConfigResponse) XXX_Size() int {
	return xxx_messageInfo_ReinitConfigResponse.Size(m)
}
func (m *ReinitConfigResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ReinitConfigResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ReinitConfigResponse proto.InternalMessageInfo

type RefreshConfigRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RefreshConfigRequest) Reset()         { *m = RefreshConfigRequest{} }
func (m *RefreshConfigRequest) String() string { return proto.CompactTextString(m) }
func (*RefreshConfigRequest) ProtoMessage()    {}
func (*RefreshConfigRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_mysqlctl_dc3430948664e7fa, []int{8}
}
func (m *RefreshConfigRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RefreshConfigRequest.Unmarshal(m, b)
}
func (m *RefreshConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RefreshConfigRequest.Marshal(b, m, deterministic)
}
func (dst *RefreshConfigRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RefreshConfigRequest.Merge(dst, src)
}
func (m *RefreshConfigRequest) XXX_Size() int {
	return xxx_messageInfo_RefreshConfigRequest.Size(m)
}
func (m *RefreshConfigRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RefreshConfigRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RefreshConfigRequest proto.InternalMessageInfo

type RefreshConfigResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RefreshConfigResponse) Reset()         { *m = RefreshConfigResponse{} }
func (m *RefreshConfigResponse) String() string { return proto.CompactTextString(m) }
func (*RefreshConfigResponse) ProtoMessage()    {}
func (*RefreshConfigResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_mysqlctl_dc3430948664e7fa, []int{9}
}
func (m *RefreshConfigResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RefreshConfigResponse.Unmarshal(m, b)
}
func (m *RefreshConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RefreshConfigResponse.Marshal(b, m, deterministic)
}
func (dst *RefreshConfigResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RefreshConfigResponse.Merge(dst, src)
}
func (m *RefreshConfigResponse) XXX_Size() int {
	return xxx_messageInfo_RefreshConfigResponse.Size(m)
}
func (m *RefreshConfigResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RefreshConfigResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RefreshConfigResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*StartRequest)(nil), "mysqlctl.StartRequest")
	proto.RegisterType((*StartResponse)(nil), "mysqlctl.StartResponse")
	proto.RegisterType((*ShutdownRequest)(nil), "mysqlctl.ShutdownRequest")
	proto.RegisterType((*ShutdownResponse)(nil), "mysqlctl.ShutdownResponse")
	proto.RegisterType((*RunMysqlUpgradeRequest)(nil), "mysqlctl.RunMysqlUpgradeRequest")
	proto.RegisterType((*RunMysqlUpgradeResponse)(nil), "mysqlctl.RunMysqlUpgradeResponse")
	proto.RegisterType((*ReinitConfigRequest)(nil), "mysqlctl.ReinitConfigRequest")
	proto.RegisterType((*ReinitConfigResponse)(nil), "mysqlctl.ReinitConfigResponse")
	proto.RegisterType((*RefreshConfigRequest)(nil), "mysqlctl.RefreshConfigRequest")
	proto.RegisterType((*RefreshConfigResponse)(nil), "mysqlctl.RefreshConfigResponse")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MysqlCtlClient is the client API for MysqlCtl service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MysqlCtlClient interface {
	Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error)
	Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error)
	RunMysqlUpgrade(ctx context.Context, in *RunMysqlUpgradeRequest, opts ...grpc.CallOption) (*RunMysqlUpgradeResponse, error)
	ReinitConfig(ctx context.Context, in *ReinitConfigRequest, opts ...grpc.CallOption) (*ReinitConfigResponse, error)
	RefreshConfig(ctx context.Context, in *RefreshConfigRequest, opts ...grpc.CallOption) (*RefreshConfigResponse, error)
}

type mysqlCtlClient struct {
	cc *grpc.ClientConn
}

func NewMysqlCtlClient(cc *grpc.ClientConn) MysqlCtlClient {
	return &mysqlCtlClient{cc}
}

func (c *mysqlCtlClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error) {
	out := new(StartResponse)
	err := c.cc.Invoke(ctx, "/mysqlctl.MysqlCtl/Start", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *mysqlCtlClient) RunMysqlUpgrade(ctx context.Context, in *RunMysqlUpgradeRequest, opts ...grpc.CallOption) (*RunMysqlUpgradeResponse, error) {
	out := new(RunMysqlUpgradeResponse)
	err := c.cc.Invoke(ctx, "/mysqlctl.MysqlCtl/RunMysqlUpgrade", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mysqlCtlClient) ReinitConfig(ctx context.Context, in *ReinitConfigRequest, opts ...grpc.CallOption) (*ReinitConfigResponse, error) {
	out := new(ReinitConfigResponse)
	err := c.cc.Invoke(ctx, "/mysqlctl.MysqlCtl/ReinitConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mysqlCtlClient) RefreshConfig(ctx context.Context, in *RefreshConfigRequest, opts ...grpc.CallOption) (*RefreshConfigResponse, error) {
	out := new(RefreshConfigResponse)
	err := c.cc.Invoke(ctx, "/mysqlctl.MysqlCtl/RefreshConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MysqlCtlServer is the server API for MysqlCtl service.
type MysqlCtlServer interface {
	Start(context.Context, *StartRequest) (*StartResponse, error)
	Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error)
	RunMysqlUpgrade(context.Context, *RunMysqlUpgradeRequest) (*RunMysqlUpgradeResponse, error)
	ReinitConfig(context.Context, *ReinitConfigRequest) (*ReinitConfigResponse, error)
	RefreshConfig(context.Context, *RefreshConfigRequest) (*RefreshConfigResponse, error)
}

func RegisterMysqlCtlServer(s *grpc.Server, srv MysqlCtlServer) {
	s.RegisterService(&_MysqlCtl_serviceDesc, srv)
}

func _MysqlCtl_Start_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MysqlCtlServer).Start(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mysqlctl.MysqlCtl/Start",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MysqlCtlServer).Start(ctx, req.(*StartRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MysqlCtl_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.(MysqlCtlServer).Shutdown(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mysqlctl.MysqlCtl/Shutdown",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MysqlCtlServer).Shutdown(ctx, req.(*ShutdownRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MysqlCtl_RunMysqlUpgrade_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunMysqlUpgradeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MysqlCtlServer).RunMysqlUpgrade(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mysqlctl.MysqlCtl/RunMysqlUpgrade",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MysqlCtlServer).RunMysqlUpgrade(ctx, req.(*RunMysqlUpgradeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MysqlCtl_ReinitConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReinitConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MysqlCtlServer).ReinitConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mysqlctl.MysqlCtl/ReinitConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MysqlCtlServer).ReinitConfig(ctx, req.(*ReinitConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MysqlCtl_RefreshConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RefreshConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MysqlCtlServer).RefreshConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/mysqlctl.MysqlCtl/RefreshConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MysqlCtlServer).RefreshConfig(ctx, req.(*RefreshConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _MysqlCtl_serviceDesc = grpc.ServiceDesc{
	ServiceName: "mysqlctl.MysqlCtl",
	HandlerType: (*MysqlCtlServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Start",
			Handler:    _MysqlCtl_Start_Handler,
		},
		{
			MethodName: "Shutdown",
			Handler:    _MysqlCtl_Shutdown_Handler,
		},
		{
			MethodName: "RunMysqlUpgrade",
			Handler:    _MysqlCtl_RunMysqlUpgrade_Handler,
		},
		{
			MethodName: "ReinitConfig",
			Handler:    _MysqlCtl_ReinitConfig_Handler,
		},
		{
			MethodName: "RefreshConfig",
			Handler:    _MysqlCtl_RefreshConfig_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mysqlctl.proto",
}

func init() { proto.RegisterFile("mysqlctl.proto", fileDescriptor_mysqlctl_dc3430948664e7fa) }

var fileDescriptor_mysqlctl_dc3430948664e7fa = []byte{
	// 339 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0x4d, 0x4f, 0xfa, 0x30,
	0x1c, 0xc7, 0xff, 0x84, 0xfc, 0xcd, 0xfc, 0x09, 0xce, 0x54, 0x79, 0x6a, 0xa2, 0xe0, 0x12, 0x95,
	0x13, 0x4d, 0xf4, 0xa4, 0x37, 0x25, 0xf1, 0x66, 0x4c, 0x4a, 0x4c, 0x8c, 0x17, 0x32, 0xa5, 0x8c,
	0x26, 0xb8, 0x42, 0x5b, 0x20, 0xbe, 0x05, 0x5f, 0xb5, 0xb1, 0x6b, 0xc7, 0xc6, 0xc0, 0xdb, 0xfa,
	0x7d, 0x6a, 0xf6, 0xd9, 0xe0, 0xf0, 0xf3, 0x4b, 0xcd, 0xa7, 0x1f, 0x7a, 0xda, 0x9b, 0x49, 0xa1,
	0x05, 0xf2, 0xdc, 0x39, 0x20, 0x50, 0x19, 0xe8, 0x50, 0x6a, 0xca, 0xe6, 0x0b, 0xa6, 0x34, 0x6a,
	0xc3, 0x81, 0xf1, 0x46, 0xc3, 0x50, 0x46, 0xaa, 0x59, 0xea, 0x94, 0xbb, 0xfb, 0x14, 0x12, 0xe9,
	0x5e, 0x46, 0x2a, 0xf0, 0xa1, 0x6a, 0x0b, 0x6a, 0x26, 0x62, 0xc5, 0x82, 0x5b, 0xf0, 0x07, 0x93,
	0x85, 0x1e, 0x89, 0x55, 0xec, 0x46, 0x2e, 0xc1, 0x5f, 0x85, 0x5c, 0x0f, 0xc7, 0x42, 0x0e, 0x93,
	0x6a, 0xb3, 0xd4, 0x29, 0x75, 0x3d, 0x5a, 0xfd, 0x95, 0x1f, 0x85, 0x7c, 0x32, 0x62, 0x80, 0xe0,
	0x68, 0x5d, 0xb5, 0x73, 0x4d, 0xa8, 0xd3, 0x45, 0x6c, 0x02, 0x2f, 0xb3, 0x48, 0x86, 0x23, 0x66,
	0x57, 0x83, 0x16, 0x34, 0x0a, 0x8e, 0x2d, 0xd5, 0xe0, 0x98, 0x32, 0x1e, 0x73, 0xdd, 0x17, 0xf1,
	0x98, 0x47, 0xae, 0x51, 0x87, 0x93, 0xbc, 0x6c, 0xe3, 0x46, 0x1f, 0x4b, 0xa6, 0x26, 0xf9, 0x7c,
	0x03, 0x6a, 0x1b, 0x7a, 0x52, 0xb8, 0xfe, 0x2e, 0x83, 0x67, 0x2e, 0xee, 0xeb, 0x29, 0xba, 0x83,
	0xff, 0x86, 0x00, 0xaa, 0xf7, 0x52, 0xac, 0x59, 0x86, 0xb8, 0x51, 0xd0, 0xed, 0xbd, 0xff, 0x50,
	0x1f, 0x3c, 0xf7, 0xc6, 0xa8, 0x95, 0x89, 0xe5, 0x01, 0x62, 0xbc, 0xcd, 0x4a, 0x47, 0x5e, 0xc1,
	0xdf, 0x00, 0x81, 0x3a, 0xeb, 0xc2, 0x76, 0x7a, 0xf8, 0xfc, 0x8f, 0x44, 0xba, 0xfc, 0x0c, 0x95,
	0x2c, 0x30, 0x74, 0x9a, 0x29, 0x15, 0xf9, 0xe2, 0xb3, 0x5d, 0x76, 0x3a, 0x48, 0xa1, 0x9a, 0x23,
	0x8a, 0x72, 0x95, 0xe2, 0x27, 0xc0, 0xed, 0x9d, 0xbe, 0xdb, 0x7c, 0xb8, 0x7a, 0xbb, 0x58, 0x72,
	0xcd, 0x94, 0xea, 0x71, 0x41, 0x92, 0x27, 0x12, 0x09, 0xb2, 0xd4, 0xc4, 0xfc, 0xdc, 0xc4, 0x0d,
	0xbc, 0xef, 0x99, 0xf3, 0xcd, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb8, 0xe2, 0x15, 0x86, 0xfe,
	0x02, 0x00, 0x00,
}