cluster

package
v0.0.0-...-bac99df Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 18, 2020 License: MIT Imports: 22 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	KeySep = ":"

	SectionConfig   = "config"
	SectionInstance = "instance"
	SectionPayload  = "payload"
)
View Source 
const GlobalConfigName = "global"

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Variables

View Source 
var (
	ErrInvalidLengthProtos = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProtos   = fmt.Errorf("proto: integer overflow")
)
View Source 
var C = NewCluster(nil, etcdv3.SC)
View Source 
var ErrorCode_Slice = []int32{
	0,
	1,
	2,
	3,
	4,
	5,
	6,
	7,
}
View Source 
var ErrorCode_name = map[int32]string{
	0: "EC_Success",
	1: "EC_Fail",
	2: "EC_ServiceGroupNotExist",
	3: "EC_ServiceInfoNotExist",
	4: "EC_MarshalInstanceFail",
	5: "EC_PutInstanceToEtcdFail",
	6: "EC_ServiceInstanceAlreadyExist",
	7: "EC_PutPayloadToEtcdFail",
}
View Source 
var ErrorCode_value = map[string]int32{
	"EC_Success":                     0,
	"EC_Fail":                        1,
	"EC_ServiceGroupNotExist":        2,
	"EC_ServiceInfoNotExist":         3,
	"EC_MarshalInstanceFail":         4,
	"EC_PutInstanceToEtcdFail":       5,
	"EC_ServiceInstanceAlreadyExist": 6,
	"EC_PutPayloadToEtcdFail":        7,
}
View Source 
var Protocol = rpc.New(nil)

Functions

func Check_ErrorCode 

func Check_ErrorCode(value ErrorCode) bool

func Check_ErrorCode_I 

func Check_ErrorCode_I(value int32) bool

func Each_ErrorCode 

func Each_ErrorCode(f func(ErrorCode) bool)

func Each_ErrorCode_I 

func Each_ErrorCode_I(f func(int32) bool)

func ErrorCode_Len 

func ErrorCode_Len() int

func GenKey 

func GenKey(args ...interface{}) (key string)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func ParseKey 

func ParseKey(key string) (etcdRoot string, section string, serviceName string, serviceID int, err error)

func ParseKeyS 

func ParseKeyS(key string) (etcdRoot string, section string, serviceName string, strServiceID string, err error)

func Put_C2S_GlobalConfig 

func Put_C2S_GlobalConfig(i interface{})

func Put_C2S_PutServiceInstance 

func Put_C2S_PutServiceInstance(i interface{})

func Put_C2S_PutServicePayload 

func Put_C2S_PutServicePayload(i interface{})

func Put_C2S_RoundRobinPickServiceInstance 

func Put_C2S_RoundRobinPickServiceInstance(i interface{})

func Put_C2S_ServiceGlobalConfig 

func Put_C2S_ServiceGlobalConfig(i interface{})

func Put_C2S_ServiceGroupAllInfo 

func Put_C2S_ServiceGroupAllInfo(i interface{})

func Put_C2S_ServiceInfo 

func Put_C2S_ServiceInfo(i interface{})

func Put_C2S_ServiceInstance 

func Put_C2S_ServiceInstance(i interface{})

func Put_C2S_ServicePayload 

func Put_C2S_ServicePayload(i interface{})

func Put_C2S_TryLockServicePosition 

func Put_C2S_TryLockServicePosition(i interface{})

func Put_Error 

func Put_Error(i interface{})

func Put_S2C_GlobalConfig 

func Put_S2C_GlobalConfig(i interface{})

func Put_S2C_PutServiceInstance 

func Put_S2C_PutServiceInstance(i interface{})

func Put_S2C_PutServicePayload 

func Put_S2C_PutServicePayload(i interface{})

func Put_S2C_RoundRobinPickServiceInstance 

func Put_S2C_RoundRobinPickServiceInstance(i interface{})

func Put_S2C_ServiceGlobalConfig 

func Put_S2C_ServiceGlobalConfig(i interface{})

func Put_S2C_ServiceGroupAllInfo 

func Put_S2C_ServiceGroupAllInfo(i interface{})

func Put_S2C_ServiceInfo 

func Put_S2C_ServiceInfo(i interface{})

func Put_S2C_ServiceInstance 

func Put_S2C_ServiceInstance(i interface{})

func Put_S2C_ServicePayload 

func Put_S2C_ServicePayload(i interface{})

func Put_S2C_TryLockServicePosition 

func Put_S2C_TryLockServicePosition(i interface{})

func Put_ServiceInfo 

func Put_ServiceInfo(i interface{})

func Put_ServiceInstance 

func Put_ServiceInstance(i interface{})

Types

type C2S_AddWatchCallback 

type C2S_AddWatchCallback struct {
	// contains filtered or unexported fields
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

type C2S_GlobalConfig 

type C2S_GlobalConfig struct {
}

请求全局配置 @response=S2C_GlobalConfig

func Clone_C2S_GlobalConfig_Slice 

func Clone_C2S_GlobalConfig_Slice(dst []*C2S_GlobalConfig, src []*C2S_GlobalConfig) []*C2S_GlobalConfig

func Get_C2S_GlobalConfig 

func Get_C2S_GlobalConfig() *C2S_GlobalConfig

func New_C2S_GlobalConfig 

func New_C2S_GlobalConfig() *C2S_GlobalConfig

func (C2S_GlobalConfig) CanIgnore 

func (C2S_GlobalConfig) CanIgnore() bool

func (C2S_GlobalConfig) Clone 

func (m C2S_GlobalConfig) Clone() *C2S_GlobalConfig

func (*C2S_GlobalConfig) Descriptor 

func (*C2S_GlobalConfig) Descriptor() ([]byte, []int)

func (*C2S_GlobalConfig) Equal 

func (this *C2S_GlobalConfig) Equal(that interface{}) bool

func (*C2S_GlobalConfig) GoString 

func (this *C2S_GlobalConfig) GoString() string

func (C2S_GlobalConfig) JsonString 

func (m C2S_GlobalConfig) JsonString() string

func (*C2S_GlobalConfig) Marshal 

func (m *C2S_GlobalConfig) Marshal() (dAtA []byte, err error)

func (*C2S_GlobalConfig) MarshalTo 

func (m *C2S_GlobalConfig) MarshalTo(dAtA []byte) (int, error)

func (*C2S_GlobalConfig) ProtoMessage 

func (*C2S_GlobalConfig) ProtoMessage()

func (*C2S_GlobalConfig) Reset 

func (m *C2S_GlobalConfig) Reset()

func (*C2S_GlobalConfig) ResetEx 

func (m *C2S_GlobalConfig) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_GlobalConfig begin

func (*C2S_GlobalConfig) Size 

func (m *C2S_GlobalConfig) Size() (n int)

func (*C2S_GlobalConfig) String 

func (this *C2S_GlobalConfig) String() string

func (*C2S_GlobalConfig) Unmarshal 

func (m *C2S_GlobalConfig) Unmarshal(dAtA []byte) error

func (*C2S_GlobalConfig) XXX_DiscardUnknown 

func (m *C2S_GlobalConfig) XXX_DiscardUnknown()

func (*C2S_GlobalConfig) XXX_Marshal 

func (m *C2S_GlobalConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_GlobalConfig) XXX_Merge 

func (m *C2S_GlobalConfig) XXX_Merge(src proto.Message)

func (*C2S_GlobalConfig) XXX_Size 

func (m *C2S_GlobalConfig) XXX_Size() int

func (*C2S_GlobalConfig) XXX_Unmarshal 

func (m *C2S_GlobalConfig) XXX_Unmarshal(b []byte) error

type C2S_PutServiceInstance 

type C2S_PutServiceInstance struct {
	Name     string           `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID       int32            `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
	Instance *ServiceInstance `protobuf:"bytes,3,opt,name=Instance,proto3" json:"Instance,omitempty"`
}

请求上传服务实例

func Clone_C2S_PutServiceInstance_Slice 

func Clone_C2S_PutServiceInstance_Slice(dst []*C2S_PutServiceInstance, src []*C2S_PutServiceInstance) []*C2S_PutServiceInstance

func Get_C2S_PutServiceInstance 

func Get_C2S_PutServiceInstance() *C2S_PutServiceInstance

func New_C2S_PutServiceInstance 

func New_C2S_PutServiceInstance() *C2S_PutServiceInstance

func (C2S_PutServiceInstance) CanIgnore 

func (C2S_PutServiceInstance) CanIgnore() bool

func (C2S_PutServiceInstance) Clone 

func (m C2S_PutServiceInstance) Clone() *C2S_PutServiceInstance

func (*C2S_PutServiceInstance) Descriptor 

func (*C2S_PutServiceInstance) Descriptor() ([]byte, []int)

func (*C2S_PutServiceInstance) Equal 

func (this *C2S_PutServiceInstance) Equal(that interface{}) bool

func (*C2S_PutServiceInstance) GetID 

func (m *C2S_PutServiceInstance) GetID() int32

func (*C2S_PutServiceInstance) GetInstance 

func (m *C2S_PutServiceInstance) GetInstance() *ServiceInstance

func (*C2S_PutServiceInstance) GetName 

func (m *C2S_PutServiceInstance) GetName() string

func (*C2S_PutServiceInstance) GoString 

func (this *C2S_PutServiceInstance) GoString() string

func (C2S_PutServiceInstance) JsonString 

func (m C2S_PutServiceInstance) JsonString() string

func (*C2S_PutServiceInstance) Marshal 

func (m *C2S_PutServiceInstance) Marshal() (dAtA []byte, err error)

func (*C2S_PutServiceInstance) MarshalTo 

func (m *C2S_PutServiceInstance) MarshalTo(dAtA []byte) (int, error)

func (*C2S_PutServiceInstance) ProtoMessage 

func (*C2S_PutServiceInstance) ProtoMessage()

func (*C2S_PutServiceInstance) Reset 

func (m *C2S_PutServiceInstance) Reset()

func (*C2S_PutServiceInstance) ResetEx 

func (m *C2S_PutServiceInstance) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_PutServiceInstance begin

func (*C2S_PutServiceInstance) Size 

func (m *C2S_PutServiceInstance) Size() (n int)

func (*C2S_PutServiceInstance) String 

func (this *C2S_PutServiceInstance) String() string

func (*C2S_PutServiceInstance) Unmarshal 

func (m *C2S_PutServiceInstance) Unmarshal(dAtA []byte) error

func (*C2S_PutServiceInstance) XXX_DiscardUnknown 

func (m *C2S_PutServiceInstance) XXX_DiscardUnknown()

func (*C2S_PutServiceInstance) XXX_Marshal 

func (m *C2S_PutServiceInstance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_PutServiceInstance) XXX_Merge 

func (m *C2S_PutServiceInstance) XXX_Merge(src proto.Message)

func (*C2S_PutServiceInstance) XXX_Size 

func (m *C2S_PutServiceInstance) XXX_Size() int

func (*C2S_PutServiceInstance) XXX_Unmarshal 

func (m *C2S_PutServiceInstance) XXX_Unmarshal(b []byte) error

type C2S_PutServicePayload 

type C2S_PutServicePayload struct {
	Name    string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID      int32  `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
	Payload int32  `protobuf:"varint,3,opt,name=Payload,proto3" json:"Payload,omitempty"`
}

请求上传服务负载

func Clone_C2S_PutServicePayload_Slice 

func Clone_C2S_PutServicePayload_Slice(dst []*C2S_PutServicePayload, src []*C2S_PutServicePayload) []*C2S_PutServicePayload

func Get_C2S_PutServicePayload 

func Get_C2S_PutServicePayload() *C2S_PutServicePayload

func New_C2S_PutServicePayload 

func New_C2S_PutServicePayload() *C2S_PutServicePayload

func (C2S_PutServicePayload) CanIgnore 

func (C2S_PutServicePayload) CanIgnore() bool

func (C2S_PutServicePayload) Clone 

func (m C2S_PutServicePayload) Clone() *C2S_PutServicePayload

func (*C2S_PutServicePayload) Descriptor 

func (*C2S_PutServicePayload) Descriptor() ([]byte, []int)

func (*C2S_PutServicePayload) Equal 

func (this *C2S_PutServicePayload) Equal(that interface{}) bool

func (*C2S_PutServicePayload) GetID 

func (m *C2S_PutServicePayload) GetID() int32

func (*C2S_PutServicePayload) GetName 

func (m *C2S_PutServicePayload) GetName() string

func (*C2S_PutServicePayload) GetPayload 

func (m *C2S_PutServicePayload) GetPayload() int32

func (*C2S_PutServicePayload) GoString 

func (this *C2S_PutServicePayload) GoString() string

func (C2S_PutServicePayload) JsonString 

func (m C2S_PutServicePayload) JsonString() string

func (*C2S_PutServicePayload) Marshal 

func (m *C2S_PutServicePayload) Marshal() (dAtA []byte, err error)

func (*C2S_PutServicePayload) MarshalTo 

func (m *C2S_PutServicePayload) MarshalTo(dAtA []byte) (int, error)

func (*C2S_PutServicePayload) ProtoMessage 

func (*C2S_PutServicePayload) ProtoMessage()

func (*C2S_PutServicePayload) Reset 

func (m *C2S_PutServicePayload) Reset()

func (*C2S_PutServicePayload) ResetEx 

func (m *C2S_PutServicePayload) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_PutServicePayload begin

func (*C2S_PutServicePayload) Size 

func (m *C2S_PutServicePayload) Size() (n int)

func (*C2S_PutServicePayload) String 

func (this *C2S_PutServicePayload) String() string

func (*C2S_PutServicePayload) Unmarshal 

func (m *C2S_PutServicePayload) Unmarshal(dAtA []byte) error

func (*C2S_PutServicePayload) XXX_DiscardUnknown 

func (m *C2S_PutServicePayload) XXX_DiscardUnknown()

func (*C2S_PutServicePayload) XXX_Marshal 

func (m *C2S_PutServicePayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_PutServicePayload) XXX_Merge 

func (m *C2S_PutServicePayload) XXX_Merge(src proto.Message)

func (*C2S_PutServicePayload) XXX_Size 

func (m *C2S_PutServicePayload) XXX_Size() int

func (*C2S_PutServicePayload) XXX_Unmarshal 

func (m *C2S_PutServicePayload) XXX_Unmarshal(b []byte) error

type C2S_RoundRobinPickServiceInstance 

type C2S_RoundRobinPickServiceInstance struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
}

请求循环选取服务实例

func Clone_C2S_RoundRobinPickServiceInstance_Slice 

func Clone_C2S_RoundRobinPickServiceInstance_Slice(dst []*C2S_RoundRobinPickServiceInstance, src []*C2S_RoundRobinPickServiceInstance) []*C2S_RoundRobinPickServiceInstance

func Get_C2S_RoundRobinPickServiceInstance 

func Get_C2S_RoundRobinPickServiceInstance() *C2S_RoundRobinPickServiceInstance

func New_C2S_RoundRobinPickServiceInstance 

func New_C2S_RoundRobinPickServiceInstance() *C2S_RoundRobinPickServiceInstance

func (C2S_RoundRobinPickServiceInstance) CanIgnore 

func (C2S_RoundRobinPickServiceInstance) CanIgnore() bool

func (C2S_RoundRobinPickServiceInstance) Clone 

func (m C2S_RoundRobinPickServiceInstance) Clone() *C2S_RoundRobinPickServiceInstance

func (*C2S_RoundRobinPickServiceInstance) Descriptor 

func (*C2S_RoundRobinPickServiceInstance) Descriptor() ([]byte, []int)

func (*C2S_RoundRobinPickServiceInstance) Equal 

func (this *C2S_RoundRobinPickServiceInstance) Equal(that interface{}) bool

func (*C2S_RoundRobinPickServiceInstance) GetName 

func (m *C2S_RoundRobinPickServiceInstance) GetName() string

func (*C2S_RoundRobinPickServiceInstance) GoString 

func (this *C2S_RoundRobinPickServiceInstance) GoString() string

func (C2S_RoundRobinPickServiceInstance) JsonString 

func (m C2S_RoundRobinPickServiceInstance) JsonString() string

func (*C2S_RoundRobinPickServiceInstance) Marshal 

func (m *C2S_RoundRobinPickServiceInstance) Marshal() (dAtA []byte, err error)

func (*C2S_RoundRobinPickServiceInstance) MarshalTo 

func (m *C2S_RoundRobinPickServiceInstance) MarshalTo(dAtA []byte) (int, error)

func (*C2S_RoundRobinPickServiceInstance) ProtoMessage 

func (*C2S_RoundRobinPickServiceInstance) ProtoMessage()

func (*C2S_RoundRobinPickServiceInstance) Reset 

func (m *C2S_RoundRobinPickServiceInstance) Reset()

func (*C2S_RoundRobinPickServiceInstance) ResetEx 

func (m *C2S_RoundRobinPickServiceInstance) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_RoundRobinPickServiceInstance begin

func (*C2S_RoundRobinPickServiceInstance) Size 

func (m *C2S_RoundRobinPickServiceInstance) Size() (n int)

func (*C2S_RoundRobinPickServiceInstance) String 

func (this *C2S_RoundRobinPickServiceInstance) String() string

func (*C2S_RoundRobinPickServiceInstance) Unmarshal 

func (m *C2S_RoundRobinPickServiceInstance) Unmarshal(dAtA []byte) error

func (*C2S_RoundRobinPickServiceInstance) XXX_DiscardUnknown 

func (m *C2S_RoundRobinPickServiceInstance) XXX_DiscardUnknown()

func (*C2S_RoundRobinPickServiceInstance) XXX_Marshal 

func (m *C2S_RoundRobinPickServiceInstance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_RoundRobinPickServiceInstance) XXX_Merge 

func (m *C2S_RoundRobinPickServiceInstance) XXX_Merge(src proto.Message)

func (*C2S_RoundRobinPickServiceInstance) XXX_Size 

func (m *C2S_RoundRobinPickServiceInstance) XXX_Size() int

func (*C2S_RoundRobinPickServiceInstance) XXX_Unmarshal 

func (m *C2S_RoundRobinPickServiceInstance) XXX_Unmarshal(b []byte) error

type C2S_ServiceGlobalConfig 

type C2S_ServiceGlobalConfig struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
}

请求服务全局配置

func Clone_C2S_ServiceGlobalConfig_Slice 

func Clone_C2S_ServiceGlobalConfig_Slice(dst []*C2S_ServiceGlobalConfig, src []*C2S_ServiceGlobalConfig) []*C2S_ServiceGlobalConfig

func Get_C2S_ServiceGlobalConfig 

func Get_C2S_ServiceGlobalConfig() *C2S_ServiceGlobalConfig

func New_C2S_ServiceGlobalConfig 

func New_C2S_ServiceGlobalConfig() *C2S_ServiceGlobalConfig

func (C2S_ServiceGlobalConfig) CanIgnore 

func (C2S_ServiceGlobalConfig) CanIgnore() bool

func (C2S_ServiceGlobalConfig) Clone 

func (m C2S_ServiceGlobalConfig) Clone() *C2S_ServiceGlobalConfig

func (*C2S_ServiceGlobalConfig) Descriptor 

func (*C2S_ServiceGlobalConfig) Descriptor() ([]byte, []int)

func (*C2S_ServiceGlobalConfig) Equal 

func (this *C2S_ServiceGlobalConfig) Equal(that interface{}) bool

func (*C2S_ServiceGlobalConfig) GetName 

func (m *C2S_ServiceGlobalConfig) GetName() string

func (*C2S_ServiceGlobalConfig) GoString 

func (this *C2S_ServiceGlobalConfig) GoString() string

func (C2S_ServiceGlobalConfig) JsonString 

func (m C2S_ServiceGlobalConfig) JsonString() string

func (*C2S_ServiceGlobalConfig) Marshal 

func (m *C2S_ServiceGlobalConfig) Marshal() (dAtA []byte, err error)

func (*C2S_ServiceGlobalConfig) MarshalTo 

func (m *C2S_ServiceGlobalConfig) MarshalTo(dAtA []byte) (int, error)

func (*C2S_ServiceGlobalConfig) ProtoMessage 

func (*C2S_ServiceGlobalConfig) ProtoMessage()

func (*C2S_ServiceGlobalConfig) Reset 

func (m *C2S_ServiceGlobalConfig) Reset()

func (*C2S_ServiceGlobalConfig) ResetEx 

func (m *C2S_ServiceGlobalConfig) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_ServiceGlobalConfig begin

func (*C2S_ServiceGlobalConfig) Size 

func (m *C2S_ServiceGlobalConfig) Size() (n int)

func (*C2S_ServiceGlobalConfig) String 

func (this *C2S_ServiceGlobalConfig) String() string

func (*C2S_ServiceGlobalConfig) Unmarshal 

func (m *C2S_ServiceGlobalConfig) Unmarshal(dAtA []byte) error

func (*C2S_ServiceGlobalConfig) XXX_DiscardUnknown 

func (m *C2S_ServiceGlobalConfig) XXX_DiscardUnknown()

func (*C2S_ServiceGlobalConfig) XXX_Marshal 

func (m *C2S_ServiceGlobalConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_ServiceGlobalConfig) XXX_Merge 

func (m *C2S_ServiceGlobalConfig) XXX_Merge(src proto.Message)

func (*C2S_ServiceGlobalConfig) XXX_Size 

func (m *C2S_ServiceGlobalConfig) XXX_Size() int

func (*C2S_ServiceGlobalConfig) XXX_Unmarshal 

func (m *C2S_ServiceGlobalConfig) XXX_Unmarshal(b []byte) error

type C2S_ServiceGroupAllInfo 

type C2S_ServiceGroupAllInfo struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
}

请求一组服务所有信息

func Clone_C2S_ServiceGroupAllInfo_Slice 

func Clone_C2S_ServiceGroupAllInfo_Slice(dst []*C2S_ServiceGroupAllInfo, src []*C2S_ServiceGroupAllInfo) []*C2S_ServiceGroupAllInfo

func Get_C2S_ServiceGroupAllInfo 

func Get_C2S_ServiceGroupAllInfo() *C2S_ServiceGroupAllInfo

func New_C2S_ServiceGroupAllInfo 

func New_C2S_ServiceGroupAllInfo() *C2S_ServiceGroupAllInfo

func (C2S_ServiceGroupAllInfo) CanIgnore 

func (C2S_ServiceGroupAllInfo) CanIgnore() bool

func (C2S_ServiceGroupAllInfo) Clone 

func (m C2S_ServiceGroupAllInfo) Clone() *C2S_ServiceGroupAllInfo

func (*C2S_ServiceGroupAllInfo) Descriptor 

func (*C2S_ServiceGroupAllInfo) Descriptor() ([]byte, []int)

func (*C2S_ServiceGroupAllInfo) Equal 

func (this *C2S_ServiceGroupAllInfo) Equal(that interface{}) bool

func (*C2S_ServiceGroupAllInfo) GetName 

func (m *C2S_ServiceGroupAllInfo) GetName() string

func (*C2S_ServiceGroupAllInfo) GoString 

func (this *C2S_ServiceGroupAllInfo) GoString() string

func (C2S_ServiceGroupAllInfo) JsonString 

func (m C2S_ServiceGroupAllInfo) JsonString() string

func (*C2S_ServiceGroupAllInfo) Marshal 

func (m *C2S_ServiceGroupAllInfo) Marshal() (dAtA []byte, err error)

func (*C2S_ServiceGroupAllInfo) MarshalTo 

func (m *C2S_ServiceGroupAllInfo) MarshalTo(dAtA []byte) (int, error)

func (*C2S_ServiceGroupAllInfo) ProtoMessage 

func (*C2S_ServiceGroupAllInfo) ProtoMessage()

func (*C2S_ServiceGroupAllInfo) Reset 

func (m *C2S_ServiceGroupAllInfo) Reset()

func (*C2S_ServiceGroupAllInfo) ResetEx 

func (m *C2S_ServiceGroupAllInfo) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_ServiceGroupAllInfo begin

func (*C2S_ServiceGroupAllInfo) Size 

func (m *C2S_ServiceGroupAllInfo) Size() (n int)

func (*C2S_ServiceGroupAllInfo) String 

func (this *C2S_ServiceGroupAllInfo) String() string

func (*C2S_ServiceGroupAllInfo) Unmarshal 

func (m *C2S_ServiceGroupAllInfo) Unmarshal(dAtA []byte) error

func (*C2S_ServiceGroupAllInfo) XXX_DiscardUnknown 

func (m *C2S_ServiceGroupAllInfo) XXX_DiscardUnknown()

func (*C2S_ServiceGroupAllInfo) XXX_Marshal 

func (m *C2S_ServiceGroupAllInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_ServiceGroupAllInfo) XXX_Merge 

func (m *C2S_ServiceGroupAllInfo) XXX_Merge(src proto.Message)

func (*C2S_ServiceGroupAllInfo) XXX_Size 

func (m *C2S_ServiceGroupAllInfo) XXX_Size() int

func (*C2S_ServiceGroupAllInfo) XXX_Unmarshal 

func (m *C2S_ServiceGroupAllInfo) XXX_Unmarshal(b []byte) error

type C2S_ServiceInfo 

type C2S_ServiceInfo struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID   int32  `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
}

请求服务信息

func Clone_C2S_ServiceInfo_Slice 

func Clone_C2S_ServiceInfo_Slice(dst []*C2S_ServiceInfo, src []*C2S_ServiceInfo) []*C2S_ServiceInfo

func Get_C2S_ServiceInfo 

func Get_C2S_ServiceInfo() *C2S_ServiceInfo

func New_C2S_ServiceInfo 

func New_C2S_ServiceInfo() *C2S_ServiceInfo

func (C2S_ServiceInfo) CanIgnore 

func (C2S_ServiceInfo) CanIgnore() bool

func (C2S_ServiceInfo) Clone 

func (m C2S_ServiceInfo) Clone() *C2S_ServiceInfo

func (*C2S_ServiceInfo) Descriptor 

func (*C2S_ServiceInfo) Descriptor() ([]byte, []int)

func (*C2S_ServiceInfo) Equal 

func (this *C2S_ServiceInfo) Equal(that interface{}) bool

func (*C2S_ServiceInfo) GetID 

func (m *C2S_ServiceInfo) GetID() int32

func (*C2S_ServiceInfo) GetName 

func (m *C2S_ServiceInfo) GetName() string

func (*C2S_ServiceInfo) GoString 

func (this *C2S_ServiceInfo) GoString() string

func (C2S_ServiceInfo) JsonString 

func (m C2S_ServiceInfo) JsonString() string

func (*C2S_ServiceInfo) Marshal 

func (m *C2S_ServiceInfo) Marshal() (dAtA []byte, err error)

func (*C2S_ServiceInfo) MarshalTo 

func (m *C2S_ServiceInfo) MarshalTo(dAtA []byte) (int, error)

func (*C2S_ServiceInfo) ProtoMessage 

func (*C2S_ServiceInfo) ProtoMessage()

func (*C2S_ServiceInfo) Reset 

func (m *C2S_ServiceInfo) Reset()

func (*C2S_ServiceInfo) ResetEx 

func (m *C2S_ServiceInfo) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_ServiceInfo begin

func (*C2S_ServiceInfo) Size 

func (m *C2S_ServiceInfo) Size() (n int)

func (*C2S_ServiceInfo) String 

func (this *C2S_ServiceInfo) String() string

func (*C2S_ServiceInfo) Unmarshal 

func (m *C2S_ServiceInfo) Unmarshal(dAtA []byte) error

func (*C2S_ServiceInfo) XXX_DiscardUnknown 

func (m *C2S_ServiceInfo) XXX_DiscardUnknown()

func (*C2S_ServiceInfo) XXX_Marshal 

func (m *C2S_ServiceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_ServiceInfo) XXX_Merge 

func (m *C2S_ServiceInfo) XXX_Merge(src proto.Message)

func (*C2S_ServiceInfo) XXX_Size 

func (m *C2S_ServiceInfo) XXX_Size() int

func (*C2S_ServiceInfo) XXX_Unmarshal 

func (m *C2S_ServiceInfo) XXX_Unmarshal(b []byte) error

type C2S_ServiceInstance 

type C2S_ServiceInstance struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID   int32  `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
}

请求服务实例

func Clone_C2S_ServiceInstance_Slice 

func Clone_C2S_ServiceInstance_Slice(dst []*C2S_ServiceInstance, src []*C2S_ServiceInstance) []*C2S_ServiceInstance

func Get_C2S_ServiceInstance 

func Get_C2S_ServiceInstance() *C2S_ServiceInstance

func New_C2S_ServiceInstance 

func New_C2S_ServiceInstance() *C2S_ServiceInstance

func (C2S_ServiceInstance) CanIgnore 

func (C2S_ServiceInstance) CanIgnore() bool

func (C2S_ServiceInstance) Clone 

func (m C2S_ServiceInstance) Clone() *C2S_ServiceInstance

func (*C2S_ServiceInstance) Descriptor 

func (*C2S_ServiceInstance) Descriptor() ([]byte, []int)

func (*C2S_ServiceInstance) Equal 

func (this *C2S_ServiceInstance) Equal(that interface{}) bool

func (*C2S_ServiceInstance) GetID 

func (m *C2S_ServiceInstance) GetID() int32

func (*C2S_ServiceInstance) GetName 

func (m *C2S_ServiceInstance) GetName() string

func (*C2S_ServiceInstance) GoString 

func (this *C2S_ServiceInstance) GoString() string

func (C2S_ServiceInstance) JsonString 

func (m C2S_ServiceInstance) JsonString() string

func (*C2S_ServiceInstance) Marshal 

func (m *C2S_ServiceInstance) Marshal() (dAtA []byte, err error)

func (*C2S_ServiceInstance) MarshalTo 

func (m *C2S_ServiceInstance) MarshalTo(dAtA []byte) (int, error)

func (*C2S_ServiceInstance) ProtoMessage 

func (*C2S_ServiceInstance) ProtoMessage()

func (*C2S_ServiceInstance) Reset 

func (m *C2S_ServiceInstance) Reset()

func (*C2S_ServiceInstance) ResetEx 

func (m *C2S_ServiceInstance) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_ServiceInstance begin

func (*C2S_ServiceInstance) Size 

func (m *C2S_ServiceInstance) Size() (n int)

func (*C2S_ServiceInstance) String 

func (this *C2S_ServiceInstance) String() string

func (*C2S_ServiceInstance) Unmarshal 

func (m *C2S_ServiceInstance) Unmarshal(dAtA []byte) error

func (*C2S_ServiceInstance) XXX_DiscardUnknown 

func (m *C2S_ServiceInstance) XXX_DiscardUnknown()

func (*C2S_ServiceInstance) XXX_Marshal 

func (m *C2S_ServiceInstance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_ServiceInstance) XXX_Merge 

func (m *C2S_ServiceInstance) XXX_Merge(src proto.Message)

func (*C2S_ServiceInstance) XXX_Size 

func (m *C2S_ServiceInstance) XXX_Size() int

func (*C2S_ServiceInstance) XXX_Unmarshal 

func (m *C2S_ServiceInstance) XXX_Unmarshal(b []byte) error

type C2S_ServicePayload 

type C2S_ServicePayload struct {
	Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID   int32  `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
}

请求服务负载

func Clone_C2S_ServicePayload_Slice 

func Clone_C2S_ServicePayload_Slice(dst []*C2S_ServicePayload, src []*C2S_ServicePayload) []*C2S_ServicePayload

func Get_C2S_ServicePayload 

func Get_C2S_ServicePayload() *C2S_ServicePayload

func New_C2S_ServicePayload 

func New_C2S_ServicePayload() *C2S_ServicePayload

func (C2S_ServicePayload) CanIgnore 

func (C2S_ServicePayload) CanIgnore() bool

func (C2S_ServicePayload) Clone 

func (m C2S_ServicePayload) Clone() *C2S_ServicePayload

func (*C2S_ServicePayload) Descriptor 

func (*C2S_ServicePayload) Descriptor() ([]byte, []int)

func (*C2S_ServicePayload) Equal 

func (this *C2S_ServicePayload) Equal(that interface{}) bool

func (*C2S_ServicePayload) GetID 

func (m *C2S_ServicePayload) GetID() int32

func (*C2S_ServicePayload) GetName 

func (m *C2S_ServicePayload) GetName() string

func (*C2S_ServicePayload) GoString 

func (this *C2S_ServicePayload) GoString() string

func (C2S_ServicePayload) JsonString 

func (m C2S_ServicePayload) JsonString() string

func (*C2S_ServicePayload) Marshal 

func (m *C2S_ServicePayload) Marshal() (dAtA []byte, err error)

func (*C2S_ServicePayload) MarshalTo 

func (m *C2S_ServicePayload) MarshalTo(dAtA []byte) (int, error)

func (*C2S_ServicePayload) ProtoMessage 

func (*C2S_ServicePayload) ProtoMessage()

func (*C2S_ServicePayload) Reset 

func (m *C2S_ServicePayload) Reset()

func (*C2S_ServicePayload) ResetEx 

func (m *C2S_ServicePayload) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_ServicePayload begin

func (*C2S_ServicePayload) Size 

func (m *C2S_ServicePayload) Size() (n int)

func (*C2S_ServicePayload) String 

func (this *C2S_ServicePayload) String() string

func (*C2S_ServicePayload) Unmarshal 

func (m *C2S_ServicePayload) Unmarshal(dAtA []byte) error

func (*C2S_ServicePayload) XXX_DiscardUnknown 

func (m *C2S_ServicePayload) XXX_DiscardUnknown()

func (*C2S_ServicePayload) XXX_Marshal 

func (m *C2S_ServicePayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_ServicePayload) XXX_Merge 

func (m *C2S_ServicePayload) XXX_Merge(src proto.Message)

func (*C2S_ServicePayload) XXX_Size 

func (m *C2S_ServicePayload) XXX_Size() int

func (*C2S_ServicePayload) XXX_Unmarshal 

func (m *C2S_ServicePayload) XXX_Unmarshal(b []byte) error

type C2S_TryLockServicePosition 

type C2S_TryLockServicePosition struct {
	Name     string           `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
	ID       int32            `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
	Instance *ServiceInstance `protobuf:"bytes,3,opt,name=Instance,proto3" json:"Instance,omitempty"`
}

请求锁定服务坑位

func Clone_C2S_TryLockServicePosition_Slice 

func Clone_C2S_TryLockServicePosition_Slice(dst []*C2S_TryLockServicePosition, src []*C2S_TryLockServicePosition) []*C2S_TryLockServicePosition

func Get_C2S_TryLockServicePosition 

func Get_C2S_TryLockServicePosition() *C2S_TryLockServicePosition

func New_C2S_TryLockServicePosition 

func New_C2S_TryLockServicePosition() *C2S_TryLockServicePosition

func (C2S_TryLockServicePosition) CanIgnore 

func (C2S_TryLockServicePosition) CanIgnore() bool

func (C2S_TryLockServicePosition) Clone 

func (m C2S_TryLockServicePosition) Clone() *C2S_TryLockServicePosition

func (*C2S_TryLockServicePosition) Descriptor 

func (*C2S_TryLockServicePosition) Descriptor() ([]byte, []int)

func (*C2S_TryLockServicePosition) Equal 

func (this *C2S_TryLockServicePosition) Equal(that interface{}) bool

func (*C2S_TryLockServicePosition) GetID 

func (m *C2S_TryLockServicePosition) GetID() int32

func (*C2S_TryLockServicePosition) GetInstance 

func (m *C2S_TryLockServicePosition) GetInstance() *ServiceInstance

func (*C2S_TryLockServicePosition) GetName 

func (m *C2S_TryLockServicePosition) GetName() string

func (*C2S_TryLockServicePosition) GoString 

func (this *C2S_TryLockServicePosition) GoString() string

func (C2S_TryLockServicePosition) JsonString 

func (m C2S_TryLockServicePosition) JsonString() string

func (*C2S_TryLockServicePosition) Marshal 

func (m *C2S_TryLockServicePosition) Marshal() (dAtA []byte, err error)

func (*C2S_TryLockServicePosition) MarshalTo 

func (m *C2S_TryLockServicePosition) MarshalTo(dAtA []byte) (int, error)

func (*C2S_TryLockServicePosition) ProtoMessage 

func (*C2S_TryLockServicePosition) ProtoMessage()

func (*C2S_TryLockServicePosition) Reset 

func (m *C2S_TryLockServicePosition) Reset()

func (*C2S_TryLockServicePosition) ResetEx 

func (m *C2S_TryLockServicePosition) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_TryLockServicePosition begin

func (*C2S_TryLockServicePosition) Size 

func (m *C2S_TryLockServicePosition) Size() (n int)

func (*C2S_TryLockServicePosition) String 

func (this *C2S_TryLockServicePosition) String() string

func (*C2S_TryLockServicePosition) Unmarshal 

func (m *C2S_TryLockServicePosition) Unmarshal(dAtA []byte) error

func (*C2S_TryLockServicePosition) XXX_DiscardUnknown 

func (m *C2S_TryLockServicePosition) XXX_DiscardUnknown()

func (*C2S_TryLockServicePosition) XXX_Marshal 

func (m *C2S_TryLockServicePosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_TryLockServicePosition) XXX_Merge 

func (m *C2S_TryLockServicePosition) XXX_Merge(src proto.Message)

func (*C2S_TryLockServicePosition) XXX_Size 

func (m *C2S_TryLockServicePosition) XXX_Size() int

func (*C2S_TryLockServicePosition) XXX_Unmarshal 

func (m *C2S_TryLockServicePosition) XXX_Unmarshal(b []byte) error

type Cluster 

type Cluster struct {
	mactor.ISuper
	// contains filtered or unexported fields
}

func NewCluster 

func NewCluster(logger mlog.ILogger, etcdsc *etcdv3.SimpleClient) (c *Cluster)

func (*Cluster) AddWatchCallback 

func (c *Cluster) AddWatchCallback(cb WatchCallback) (err error)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (*Cluster) Close 

func (c *Cluster) Close()

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (*Cluster) DirectGetInstance 

func (c *Cluster) DirectGetInstance(serviceName string, serviceID int) (instance service.Instance, err error)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (*Cluster) DirectGetPayload 

func (c *Cluster) DirectGetPayload(serviceName string, serviceID int) (payload int, err error)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (*Cluster) DirectPutInstance 

func (c *Cluster) DirectPutInstance(serviceName string, serviceID int, instance service.Instance) error

func (*Cluster) DirectPutPayload 

func (c *Cluster) DirectPutPayload(serviceName string, serviceID int, payload int) (err error)

func (Cluster) EtcdConfig 

func (c Cluster) EtcdConfig() EtcdConfig

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (Cluster) GenConfigKey 

func (c Cluster) GenConfigKey(serviceName string, serviceID int) string

func (Cluster) GenConfigKeyPrefix 

func (c Cluster) GenConfigKeyPrefix(serviceName string) string

func (Cluster) GenConfigKeyS 

func (c Cluster) GenConfigKeyS(serviceName string, strServiceID string) string

func (Cluster) GenGlobalConfigKey 

func (c Cluster) GenGlobalConfigKey() string

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (Cluster) GenInstanceKey 

func (c Cluster) GenInstanceKey(serviceName string, serviceID int) string

func (Cluster) GenInstanceKeyPrefix 

func (c Cluster) GenInstanceKeyPrefix(serviceName string) string

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (Cluster) GenInstanceKeyS 

func (c Cluster) GenInstanceKeyS(serviceName string, strServiceID string) string

func (Cluster) GenPayloadKey 

func (c Cluster) GenPayloadKey(serviceName string, serviceID int) string

func (Cluster) GenPayloadKeyPrefix 

func (c Cluster) GenPayloadKeyPrefix(serviceName string) string

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (Cluster) GenPayloadKeyS 

func (c Cluster) GenPayloadKeyS(serviceName string, strServiceID string) string

func (Cluster) GetGlobalConfig 

func (c Cluster) GetGlobalConfig() (IGlobalConfig, error)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (Cluster) GetServiceGlobalConfig 

func (c Cluster) GetServiceGlobalConfig(serviceName string) (service.IGlobalConfig, error)

func (Cluster) GetServiceGroupAllInfo 

func (c Cluster) GetServiceGroupAllInfo(serviceName string) ([]*service.Info, error)

func (Cluster) GetServiceInfo 

func (c Cluster) GetServiceInfo(serviceName string, serviceID int) (*service.Info, error)

func (Cluster) GetServiceInstance 

func (c Cluster) GetServiceInstance(serviceName string, serviceID int) (*service.Instance, error)

func (Cluster) GetServicePayload 

func (c Cluster) GetServicePayload(serviceName string, serviceID int) (int, error)

func (*Cluster) Init 

func (c *Cluster) Init(etcdConfigFilePath string, globalConfig IGlobalConfig, serviceConfigInfoMap ServiceGroupInfoMap) (err error)

func (Cluster) LeaseID 

func (c Cluster) LeaseID() clientv3.LeaseID

func (Cluster) ParseConfigKey 

func (c Cluster) ParseConfigKey(key string) (serviceName string, serviceID int, err error)

func (Cluster) ParseConfigKeyS 

func (c Cluster) ParseConfigKeyS(key string) (serviceName string, strServiceID string, err error)

func (Cluster) ParseInstanceKey 

func (c Cluster) ParseInstanceKey(key string) (serviceName string, serviceID int, err error)

func (Cluster) ParseInstanceKeyS 

func (c Cluster) ParseInstanceKeyS(key string) (serviceName string, strServiceID string, err error)

func (Cluster) ParsePayloadKey 

func (c Cluster) ParsePayloadKey(key string) (serviceName string, serviceID int, err error)

func (Cluster) ParsePayloadKeyS 

func (c Cluster) ParsePayloadKeyS(key string) (serviceName string, strServiceID string, err error)

func (Cluster) PutServiceInstance 

func (c Cluster) PutServiceInstance(serviceName string, serviceID int, instance *service.Instance) error

func (Cluster) PutServicePayload 

func (c Cluster) PutServicePayload(serviceName string, serviceID int, payload int) error

func (*Cluster) RoundRobinPickServiceInstance 

func (c *Cluster) RoundRobinPickServiceInstance(serviceName string) (info *service.Info, err error)

func (Cluster) TryLockServicePosition 

func (c Cluster) TryLockServicePosition(serviceName string, serviceID int, instance *service.Instance) error

type Error 

type Error struct {
	Code    ErrorCode `protobuf:"varint,1,opt,name=Code,proto3,enum=cluster.ErrorCode" json:"Code,omitempty"`
	Message string    `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
}

func Clone_Error_Slice 

func Clone_Error_Slice(dst []*Error, src []*Error) []*Error

func Get_Error 

func Get_Error() *Error

func New_Error 

func New_Error() *Error

func (Error) CanIgnore 

func (Error) CanIgnore() bool

func (Error) Clone 

func (m Error) Clone() *Error

func (*Error) Descriptor 

func (*Error) Descriptor() ([]byte, []int)

func (*Error) Equal 

func (this *Error) Equal(that interface{}) bool

func (Error) Error 

func (e Error) Error() string

func (*Error) GetCode 

func (m *Error) GetCode() ErrorCode

func (*Error) GetMessage 

func (m *Error) GetMessage() string

func (*Error) GoString 

func (this *Error) GoString() string

func (Error) IsNil 

func (e Error) IsNil() bool

func (Error) JsonString 

func (m Error) JsonString() string

func (*Error) Marshal 

func (m *Error) Marshal() (dAtA []byte, err error)

func (*Error) MarshalTo 

func (m *Error) MarshalTo(dAtA []byte) (int, error)

func (*Error) ProtoMessage 

func (*Error) ProtoMessage()

func (*Error) Reset 

func (m *Error) Reset()

func (*Error) ResetEx 

func (m *Error) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message Error begin

func (*Error) Size 

func (m *Error) Size() (n int)

func (*Error) String 

func (this *Error) String() string

func (*Error) Unmarshal 

func (m *Error) Unmarshal(dAtA []byte) error

func (*Error) XXX_DiscardUnknown 

func (m *Error) XXX_DiscardUnknown()

func (*Error) XXX_Marshal 

func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Error) XXX_Merge 

func (m *Error) XXX_Merge(src proto.Message)

func (*Error) XXX_Size 

func (m *Error) XXX_Size() int

func (*Error) XXX_Unmarshal 

func (m *Error) XXX_Unmarshal(b []byte) error

type ErrorCode 

type ErrorCode int32
const (
	EC_Success                     ErrorCode = 0
	EC_Fail                        ErrorCode = 1
	EC_ServiceGroupNotExist        ErrorCode = 2
	EC_ServiceInfoNotExist         ErrorCode = 3
	EC_MarshalInstanceFail         ErrorCode = 4
	EC_PutInstanceToEtcdFail       ErrorCode = 5
	EC_ServiceInstanceAlreadyExist ErrorCode = 6
	EC_PutPayloadToEtcdFail        ErrorCode = 7
)

func (ErrorCode) EnumDescriptor 

func (ErrorCode) EnumDescriptor() ([]byte, []int)

func (ErrorCode) String 

func (x ErrorCode) String() string

type EtcdConfig 

type EtcdConfig struct {
	Endpoint string
	Root     string
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (EtcdConfig) Check 

func (cfg EtcdConfig) Check() error

func (*EtcdConfig) Load 

func (cfg *EtcdConfig) Load(path string) error

type IGlobalConfig 

type IGlobalConfig interface {
	Check() error
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

type S2C_AddWatchCallback 

type S2C_AddWatchCallback struct {
	// contains filtered or unexported fields
}

func Request_S2C_AddWatchCallback 

func Request_S2C_AddWatchCallback(pid *actor.PID, send *C2S_AddWatchCallback) (*S2C_AddWatchCallback, error)

func Request_S2C_AddWatchCallback_T 

func Request_S2C_AddWatchCallback_T(pid *actor.PID, send *C2S_AddWatchCallback, timeout time.Duration) (*S2C_AddWatchCallback, error)

type S2C_GlobalConfig 

type S2C_GlobalConfig struct {
	ConfigData []byte `protobuf:"bytes,1,opt,name=ConfigData,proto3" json:"ConfigData,omitempty"`
}

请求全局配置回复

func Clone_S2C_GlobalConfig_Slice 

func Clone_S2C_GlobalConfig_Slice(dst []*S2C_GlobalConfig, src []*S2C_GlobalConfig) []*S2C_GlobalConfig

func Get_S2C_GlobalConfig 

func Get_S2C_GlobalConfig() *S2C_GlobalConfig

func New_S2C_GlobalConfig 

func New_S2C_GlobalConfig() *S2C_GlobalConfig

func Request_S2C_GlobalConfig 

func Request_S2C_GlobalConfig(pid *actor.PID, send *C2S_GlobalConfig) (*S2C_GlobalConfig, error)

func Request_S2C_GlobalConfig_T 

func Request_S2C_GlobalConfig_T(pid *actor.PID, send *C2S_GlobalConfig, timeout time.Duration) (*S2C_GlobalConfig, error)

func (S2C_GlobalConfig) CanIgnore 

func (S2C_GlobalConfig) CanIgnore() bool

func (S2C_GlobalConfig) Clone 

func (m S2C_GlobalConfig) Clone() *S2C_GlobalConfig

func (*S2C_GlobalConfig) Descriptor 

func (*S2C_GlobalConfig) Descriptor() ([]byte, []int)

func (*S2C_GlobalConfig) Equal 

func (this *S2C_GlobalConfig) Equal(that interface{}) bool

func (*S2C_GlobalConfig) GetConfigData 

func (m *S2C_GlobalConfig) GetConfigData() []byte

func (*S2C_GlobalConfig) GoString 

func (this *S2C_GlobalConfig) GoString() string

func (S2C_GlobalConfig) JsonString 

func (m S2C_GlobalConfig) JsonString() string

func (*S2C_GlobalConfig) Marshal 

func (m *S2C_GlobalConfig) Marshal() (dAtA []byte, err error)

func (*S2C_GlobalConfig) MarshalTo 

func (m *S2C_GlobalConfig) MarshalTo(dAtA []byte) (int, error)

func (*S2C_GlobalConfig) ProtoMessage 

func (*S2C_GlobalConfig) ProtoMessage()

func (*S2C_GlobalConfig) Reset 

func (m *S2C_GlobalConfig) Reset()

func (*S2C_GlobalConfig) ResetEx 

func (m *S2C_GlobalConfig) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_GlobalConfig begin

func (*S2C_GlobalConfig) Size 

func (m *S2C_GlobalConfig) Size() (n int)

func (*S2C_GlobalConfig) String 

func (this *S2C_GlobalConfig) String() string

func (*S2C_GlobalConfig) Unmarshal 

func (m *S2C_GlobalConfig) Unmarshal(dAtA []byte) error

func (*S2C_GlobalConfig) XXX_DiscardUnknown 

func (m *S2C_GlobalConfig) XXX_DiscardUnknown()

func (*S2C_GlobalConfig) XXX_Marshal 

func (m *S2C_GlobalConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_GlobalConfig) XXX_Merge 

func (m *S2C_GlobalConfig) XXX_Merge(src proto.Message)

func (*S2C_GlobalConfig) XXX_Size 

func (m *S2C_GlobalConfig) XXX_Size() int

func (*S2C_GlobalConfig) XXX_Unmarshal 

func (m *S2C_GlobalConfig) XXX_Unmarshal(b []byte) error

type S2C_PutServiceInstance 

type S2C_PutServiceInstance struct {
	Err *Error `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
}

请求上传服务实例回复

func Clone_S2C_PutServiceInstance_Slice 

func Clone_S2C_PutServiceInstance_Slice(dst []*S2C_PutServiceInstance, src []*S2C_PutServiceInstance) []*S2C_PutServiceInstance

func Get_S2C_PutServiceInstance 

func Get_S2C_PutServiceInstance() *S2C_PutServiceInstance

func New_S2C_PutServiceInstance 

func New_S2C_PutServiceInstance() *S2C_PutServiceInstance

func Request_S2C_PutServiceInstance 

func Request_S2C_PutServiceInstance(pid *actor.PID, send *C2S_PutServiceInstance) (*S2C_PutServiceInstance, error)

func Request_S2C_PutServiceInstance_T 

func Request_S2C_PutServiceInstance_T(pid *actor.PID, send *C2S_PutServiceInstance, timeout time.Duration) (*S2C_PutServiceInstance, error)

func (S2C_PutServiceInstance) CanIgnore 

func (S2C_PutServiceInstance) CanIgnore() bool

func (S2C_PutServiceInstance) Clone 

func (m S2C_PutServiceInstance) Clone() *S2C_PutServiceInstance

func (*S2C_PutServiceInstance) Descriptor 

func (*S2C_PutServiceInstance) Descriptor() ([]byte, []int)

func (*S2C_PutServiceInstance) Equal 

func (this *S2C_PutServiceInstance) Equal(that interface{}) bool

func (*S2C_PutServiceInstance) GetErr 

func (m *S2C_PutServiceInstance) GetErr() *Error

func (*S2C_PutServiceInstance) GoString 

func (this *S2C_PutServiceInstance) GoString() string

func (S2C_PutServiceInstance) JsonString 

func (m S2C_PutServiceInstance) JsonString() string

func (*S2C_PutServiceInstance) Marshal 

func (m *S2C_PutServiceInstance) Marshal() (dAtA []byte, err error)

func (*S2C_PutServiceInstance) MarshalTo 

func (m *S2C_PutServiceInstance) MarshalTo(dAtA []byte) (int, error)

func (*S2C_PutServiceInstance) ProtoMessage 

func (*S2C_PutServiceInstance) ProtoMessage()

func (*S2C_PutServiceInstance) Reset 

func (m *S2C_PutServiceInstance) Reset()

func (*S2C_PutServiceInstance) ResetEx 

func (m *S2C_PutServiceInstance) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_PutServiceInstance begin

func (*S2C_PutServiceInstance) Size 

func (m *S2C_PutServiceInstance) Size() (n int)

func (*S2C_PutServiceInstance) String 

func (this *S2C_PutServiceInstance) String() string

func (*S2C_PutServiceInstance) Unmarshal 

func (m *S2C_PutServiceInstance) Unmarshal(dAtA []byte) error

func (*S2C_PutServiceInstance) XXX_DiscardUnknown 

func (m *S2C_PutServiceInstance) XXX_DiscardUnknown()

func (*S2C_PutServiceInstance) XXX_Marshal 

func (m *S2C_PutServiceInstance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_PutServiceInstance) XXX_Merge 

func (m *S2C_PutServiceInstance) XXX_Merge(src proto.Message)

func (*S2C_PutServiceInstance) XXX_Size 

func (m *S2C_PutServiceInstance) XXX_Size() int

func (*S2C_PutServiceInstance) XXX_Unmarshal 

func (m *S2C_PutServiceInstance) XXX_Unmarshal(b []byte) error

type S2C_PutServicePayload 

type S2C_PutServicePayload struct {
	Err *Error `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
}

请求上传服务负载回复

func Clone_S2C_PutServicePayload_Slice 

func Clone_S2C_PutServicePayload_Slice(dst []*S2C_PutServicePayload, src []*S2C_PutServicePayload) []*S2C_PutServicePayload

func Get_S2C_PutServicePayload 

func Get_S2C_PutServicePayload() *S2C_PutServicePayload

func New_S2C_PutServicePayload 

func New_S2C_PutServicePayload() *S2C_PutServicePayload

func Request_S2C_PutServicePayload 

func Request_S2C_PutServicePayload(pid *actor.PID, send *C2S_PutServicePayload) (*S2C_PutServicePayload, error)

func Request_S2C_PutServicePayload_T 

func Request_S2C_PutServicePayload_T(pid *actor.PID, send *C2S_PutServicePayload, timeout time.Duration) (*S2C_PutServicePayload, error)

func (S2C_PutServicePayload) CanIgnore 

func (S2C_PutServicePayload) CanIgnore() bool

func (S2C_PutServicePayload) Clone 

func (m S2C_PutServicePayload) Clone() *S2C_PutServicePayload

func (*S2C_PutServicePayload) Descriptor 

func (*S2C_PutServicePayload) Descriptor() ([]byte, []int)

func (*S2C_PutServicePayload) Equal 

func (this *S2C_PutServicePayload) Equal(that interface{}) bool

func (*S2C_PutServicePayload) GetErr 

func (m *S2C_PutServicePayload) GetErr() *Error

func (*S2C_PutServicePayload) GoString 

func (this *S2C_PutServicePayload) GoString() string

func (S2C_PutServicePayload) JsonString 

func (m S2C_PutServicePayload) JsonString() string

func (*S2C_PutServicePayload) Marshal 

func (m *S2C_PutServicePayload) Marshal() (dAtA []byte, err error)

func (*S2C_PutServicePayload) MarshalTo 

func (m *S2C_PutServicePayload) MarshalTo(dAtA []byte) (int, error)

func (*S2C_PutServicePayload) ProtoMessage 

func (*S2C_PutServicePayload) ProtoMessage()

func (*S2C_PutServicePayload) Reset 

func (m *S2C_PutServicePayload) Reset()

func (*S2C_PutServicePayload) ResetEx 

func (m *S2C_PutServicePayload) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_PutServicePayload begin

func (*S2C_PutServicePayload) Size 

func (m *S2C_PutServicePayload) Size() (n int)

func (*S2C_PutServicePayload) String 

func (this *S2C_PutServicePayload) String() string

func (*S2C_PutServicePayload) Unmarshal 

func (m *S2C_PutServicePayload) Unmarshal(dAtA []byte) error

func (*S2C_PutServicePayload) XXX_DiscardUnknown 

func (m *S2C_PutServicePayload) XXX_DiscardUnknown()

func (*S2C_PutServicePayload) XXX_Marshal 

func (m *S2C_PutServicePayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_PutServicePayload) XXX_Merge 

func (m *S2C_PutServicePayload) XXX_Merge(src proto.Message)

func (*S2C_PutServicePayload) XXX_Size 

func (m *S2C_PutServicePayload) XXX_Size() int

func (*S2C_PutServicePayload) XXX_Unmarshal 

func (m *S2C_PutServicePayload) XXX_Unmarshal(b []byte) error

type S2C_RoundRobinPickServiceInstance 

type S2C_RoundRobinPickServiceInstance struct {
	Err  *Error       `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Info *ServiceInfo `protobuf:"bytes,2,opt,name=Info,proto3" json:"Info,omitempty"`
}

请求循环选取服务实例回复

func Clone_S2C_RoundRobinPickServiceInstance_Slice 

func Clone_S2C_RoundRobinPickServiceInstance_Slice(dst []*S2C_RoundRobinPickServiceInstance, src []*S2C_RoundRobinPickServiceInstance) []*S2C_RoundRobinPickServiceInstance

func Get_S2C_RoundRobinPickServiceInstance 

func Get_S2C_RoundRobinPickServiceInstance() *S2C_RoundRobinPickServiceInstance

func New_S2C_RoundRobinPickServiceInstance 

func New_S2C_RoundRobinPickServiceInstance() *S2C_RoundRobinPickServiceInstance

func Request_S2C_RoundRobinPickServiceInstance 

func Request_S2C_RoundRobinPickServiceInstance(pid *actor.PID, send *C2S_RoundRobinPickServiceInstance) (*S2C_RoundRobinPickServiceInstance, error)

func Request_S2C_RoundRobinPickServiceInstance_T 

func Request_S2C_RoundRobinPickServiceInstance_T(pid *actor.PID, send *C2S_RoundRobinPickServiceInstance, timeout time.Duration) (*S2C_RoundRobinPickServiceInstance, error)

func (S2C_RoundRobinPickServiceInstance) CanIgnore 

func (S2C_RoundRobinPickServiceInstance) CanIgnore() bool

func (S2C_RoundRobinPickServiceInstance) Clone 

func (m S2C_RoundRobinPickServiceInstance) Clone() *S2C_RoundRobinPickServiceInstance

func (*S2C_RoundRobinPickServiceInstance) Descriptor 

func (*S2C_RoundRobinPickServiceInstance) Descriptor() ([]byte, []int)

func (*S2C_RoundRobinPickServiceInstance) Equal 

func (this *S2C_RoundRobinPickServiceInstance) Equal(that interface{}) bool

func (*S2C_RoundRobinPickServiceInstance) GetErr 

func (m *S2C_RoundRobinPickServiceInstance) GetErr() *Error

func (*S2C_RoundRobinPickServiceInstance) GetInfo 

func (m *S2C_RoundRobinPickServiceInstance) GetInfo() *ServiceInfo

func (*S2C_RoundRobinPickServiceInstance) GoString 

func (this *S2C_RoundRobinPickServiceInstance) GoString() string

func (S2C_RoundRobinPickServiceInstance) JsonString 

func (m S2C_RoundRobinPickServiceInstance) JsonString() string

func (*S2C_RoundRobinPickServiceInstance) Marshal 

func (m *S2C_RoundRobinPickServiceInstance) Marshal() (dAtA []byte, err error)

func (*S2C_RoundRobinPickServiceInstance) MarshalTo 

func (m *S2C_RoundRobinPickServiceInstance) MarshalTo(dAtA []byte) (int, error)

func (*S2C_RoundRobinPickServiceInstance) ProtoMessage 

func (*S2C_RoundRobinPickServiceInstance) ProtoMessage()

func (*S2C_RoundRobinPickServiceInstance) Reset 

func (m *S2C_RoundRobinPickServiceInstance) Reset()

func (*S2C_RoundRobinPickServiceInstance) ResetEx 

func (m *S2C_RoundRobinPickServiceInstance) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_RoundRobinPickServiceInstance begin

func (*S2C_RoundRobinPickServiceInstance) Size 

func (m *S2C_RoundRobinPickServiceInstance) Size() (n int)

func (*S2C_RoundRobinPickServiceInstance) String 

func (this *S2C_RoundRobinPickServiceInstance) String() string

func (*S2C_RoundRobinPickServiceInstance) Unmarshal 

func (m *S2C_RoundRobinPickServiceInstance) Unmarshal(dAtA []byte) error

func (*S2C_RoundRobinPickServiceInstance) XXX_DiscardUnknown 

func (m *S2C_RoundRobinPickServiceInstance) XXX_DiscardUnknown()

func (*S2C_RoundRobinPickServiceInstance) XXX_Marshal 

func (m *S2C_RoundRobinPickServiceInstance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_RoundRobinPickServiceInstance) XXX_Merge 

func (m *S2C_RoundRobinPickServiceInstance) XXX_Merge(src proto.Message)

func (*S2C_RoundRobinPickServiceInstance) XXX_Size 

func (m *S2C_RoundRobinPickServiceInstance) XXX_Size() int

func (*S2C_RoundRobinPickServiceInstance) XXX_Unmarshal 

func (m *S2C_RoundRobinPickServiceInstance) XXX_Unmarshal(b []byte) error

type S2C_ServiceGlobalConfig 

type S2C_ServiceGlobalConfig struct {
	Err        *Error `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	ConfigData []byte `protobuf:"bytes,2,opt,name=ConfigData,proto3" json:"ConfigData,omitempty"`
}

请求服务全局配置回复

func Clone_S2C_ServiceGlobalConfig_Slice 

func Clone_S2C_ServiceGlobalConfig_Slice(dst []*S2C_ServiceGlobalConfig, src []*S2C_ServiceGlobalConfig) []*S2C_ServiceGlobalConfig

func Get_S2C_ServiceGlobalConfig 

func Get_S2C_ServiceGlobalConfig() *S2C_ServiceGlobalConfig

func New_S2C_ServiceGlobalConfig 

func New_S2C_ServiceGlobalConfig() *S2C_ServiceGlobalConfig

func Request_S2C_ServiceGlobalConfig 

func Request_S2C_ServiceGlobalConfig(pid *actor.PID, send *C2S_ServiceGlobalConfig) (*S2C_ServiceGlobalConfig, error)

func Request_S2C_ServiceGlobalConfig_T 

func Request_S2C_ServiceGlobalConfig_T(pid *actor.PID, send *C2S_ServiceGlobalConfig, timeout time.Duration) (*S2C_ServiceGlobalConfig, error)

func (S2C_ServiceGlobalConfig) CanIgnore 

func (S2C_ServiceGlobalConfig) CanIgnore() bool

func (S2C_ServiceGlobalConfig) Clone 

func (m S2C_ServiceGlobalConfig) Clone() *S2C_ServiceGlobalConfig

func (*S2C_ServiceGlobalConfig) Descriptor 

func (*S2C_ServiceGlobalConfig) Descriptor() ([]byte, []int)

func (*S2C_ServiceGlobalConfig) Equal 

func (this *S2C_ServiceGlobalConfig) Equal(that interface{}) bool

func (*S2C_ServiceGlobalConfig) GetConfigData 

func (m *S2C_ServiceGlobalConfig) GetConfigData() []byte

func (*S2C_ServiceGlobalConfig) GetErr 

func (m *S2C_ServiceGlobalConfig) GetErr() *Error

func (*S2C_ServiceGlobalConfig) GoString 

func (this *S2C_ServiceGlobalConfig) GoString() string

func (S2C_ServiceGlobalConfig) JsonString 

func (m S2C_ServiceGlobalConfig) JsonString() string

func (*S2C_ServiceGlobalConfig) Marshal 

func (m *S2C_ServiceGlobalConfig) Marshal() (dAtA []byte, err error)

func (*S2C_ServiceGlobalConfig) MarshalTo 

func (m *S2C_ServiceGlobalConfig) MarshalTo(dAtA []byte) (int, error)

func (*S2C_ServiceGlobalConfig) ProtoMessage 

func (*S2C_ServiceGlobalConfig) ProtoMessage()

func (*S2C_ServiceGlobalConfig) Reset 

func (m *S2C_ServiceGlobalConfig) Reset()

func (*S2C_ServiceGlobalConfig) ResetEx 

func (m *S2C_ServiceGlobalConfig) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_ServiceGlobalConfig begin

func (*S2C_ServiceGlobalConfig) Size 

func (m *S2C_ServiceGlobalConfig) Size() (n int)

func (*S2C_ServiceGlobalConfig) String 

func (this *S2C_ServiceGlobalConfig) String() string

func (*S2C_ServiceGlobalConfig) Unmarshal 

func (m *S2C_ServiceGlobalConfig) Unmarshal(dAtA []byte) error

func (*S2C_ServiceGlobalConfig) XXX_DiscardUnknown 

func (m *S2C_ServiceGlobalConfig) XXX_DiscardUnknown()

func (*S2C_ServiceGlobalConfig) XXX_Marshal 

func (m *S2C_ServiceGlobalConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_ServiceGlobalConfig) XXX_Merge 

func (m *S2C_ServiceGlobalConfig) XXX_Merge(src proto.Message)

func (*S2C_ServiceGlobalConfig) XXX_Size 

func (m *S2C_ServiceGlobalConfig) XXX_Size() int

func (*S2C_ServiceGlobalConfig) XXX_Unmarshal 

func (m *S2C_ServiceGlobalConfig) XXX_Unmarshal(b []byte) error

type S2C_ServiceGroupAllInfo 

type S2C_ServiceGroupAllInfo struct {
	Err   *Error         `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Infos []*ServiceInfo `protobuf:"bytes,2,rep,name=Infos,proto3" json:"Infos,omitempty"`
}

请求一组服务所有信息回复

func Clone_S2C_ServiceGroupAllInfo_Slice 

func Clone_S2C_ServiceGroupAllInfo_Slice(dst []*S2C_ServiceGroupAllInfo, src []*S2C_ServiceGroupAllInfo) []*S2C_ServiceGroupAllInfo

func Get_S2C_ServiceGroupAllInfo 

func Get_S2C_ServiceGroupAllInfo() *S2C_ServiceGroupAllInfo

func New_S2C_ServiceGroupAllInfo 

func New_S2C_ServiceGroupAllInfo() *S2C_ServiceGroupAllInfo

func Request_S2C_ServiceGroupAllInfo 

func Request_S2C_ServiceGroupAllInfo(pid *actor.PID, send *C2S_ServiceGroupAllInfo) (*S2C_ServiceGroupAllInfo, error)

func Request_S2C_ServiceGroupAllInfo_T 

func Request_S2C_ServiceGroupAllInfo_T(pid *actor.PID, send *C2S_ServiceGroupAllInfo, timeout time.Duration) (*S2C_ServiceGroupAllInfo, error)

func (S2C_ServiceGroupAllInfo) CanIgnore 

func (S2C_ServiceGroupAllInfo) CanIgnore() bool

func (S2C_ServiceGroupAllInfo) Clone 

func (m S2C_ServiceGroupAllInfo) Clone() *S2C_ServiceGroupAllInfo

func (*S2C_ServiceGroupAllInfo) Descriptor 

func (*S2C_ServiceGroupAllInfo) Descriptor() ([]byte, []int)

func (*S2C_ServiceGroupAllInfo) Equal 

func (this *S2C_ServiceGroupAllInfo) Equal(that interface{}) bool

func (*S2C_ServiceGroupAllInfo) GetErr 

func (m *S2C_ServiceGroupAllInfo) GetErr() *Error

func (*S2C_ServiceGroupAllInfo) GetInfos 

func (m *S2C_ServiceGroupAllInfo) GetInfos() []*ServiceInfo

func (*S2C_ServiceGroupAllInfo) GoString 

func (this *S2C_ServiceGroupAllInfo) GoString() string

func (S2C_ServiceGroupAllInfo) JsonString 

func (m S2C_ServiceGroupAllInfo) JsonString() string

func (*S2C_ServiceGroupAllInfo) Marshal 

func (m *S2C_ServiceGroupAllInfo) Marshal() (dAtA []byte, err error)

func (*S2C_ServiceGroupAllInfo) MarshalTo 

func (m *S2C_ServiceGroupAllInfo) MarshalTo(dAtA []byte) (int, error)

func (*S2C_ServiceGroupAllInfo) ProtoMessage 

func (*S2C_ServiceGroupAllInfo) ProtoMessage()

func (*S2C_ServiceGroupAllInfo) Reset 

func (m *S2C_ServiceGroupAllInfo) Reset()

func (*S2C_ServiceGroupAllInfo) ResetEx 

func (m *S2C_ServiceGroupAllInfo) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_ServiceGroupAllInfo begin

func (*S2C_ServiceGroupAllInfo) Size 

func (m *S2C_ServiceGroupAllInfo) Size() (n int)

func (*S2C_ServiceGroupAllInfo) String 

func (this *S2C_ServiceGroupAllInfo) String() string

func (*S2C_ServiceGroupAllInfo) Unmarshal 

func (m *S2C_ServiceGroupAllInfo) Unmarshal(dAtA []byte) error

func (*S2C_ServiceGroupAllInfo) XXX_DiscardUnknown 

func (m *S2C_ServiceGroupAllInfo) XXX_DiscardUnknown()

func (*S2C_ServiceGroupAllInfo) XXX_Marshal 

func (m *S2C_ServiceGroupAllInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_ServiceGroupAllInfo) XXX_Merge 

func (m *S2C_ServiceGroupAllInfo) XXX_Merge(src proto.Message)

func (*S2C_ServiceGroupAllInfo) XXX_Size 

func (m *S2C_ServiceGroupAllInfo) XXX_Size() int

func (*S2C_ServiceGroupAllInfo) XXX_Unmarshal 

func (m *S2C_ServiceGroupAllInfo) XXX_Unmarshal(b []byte) error

type S2C_ServiceInfo 

type S2C_ServiceInfo struct {
	Err  *Error       `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Info *ServiceInfo `protobuf:"bytes,2,opt,name=Info,proto3" json:"Info,omitempty"`
}

请求服务信息回复

func Clone_S2C_ServiceInfo_Slice 

func Clone_S2C_ServiceInfo_Slice(dst []*S2C_ServiceInfo, src []*S2C_ServiceInfo) []*S2C_ServiceInfo

func Get_S2C_ServiceInfo 

func Get_S2C_ServiceInfo() *S2C_ServiceInfo

func New_S2C_ServiceInfo 

func New_S2C_ServiceInfo() *S2C_ServiceInfo

func Request_S2C_ServiceInfo 

func Request_S2C_ServiceInfo(pid *actor.PID, send *C2S_ServiceInfo) (*S2C_ServiceInfo, error)

func Request_S2C_ServiceInfo_T 

func Request_S2C_ServiceInfo_T(pid *actor.PID, send *C2S_ServiceInfo, timeout time.Duration) (*S2C_ServiceInfo, error)

func (S2C_ServiceInfo) CanIgnore 

func (S2C_ServiceInfo) CanIgnore() bool

func (S2C_ServiceInfo) Clone 

func (m S2C_ServiceInfo) Clone() *S2C_ServiceInfo

func (*S2C_ServiceInfo) Descriptor 

func (*S2C_ServiceInfo) Descriptor() ([]byte, []int)

func (*S2C_ServiceInfo) Equal 

func (this *S2C_ServiceInfo) Equal(that interface{}) bool

func (*S2C_ServiceInfo) GetErr 

func (m *S2C_ServiceInfo) GetErr() *Error

func (*S2C_ServiceInfo) GetInfo 

func (m *S2C_ServiceInfo) GetInfo() *ServiceInfo

func (*S2C_ServiceInfo) GoString 

func (this *S2C_ServiceInfo) GoString() string

func (S2C_ServiceInfo) JsonString 

func (m S2C_ServiceInfo) JsonString() string

func (*S2C_ServiceInfo) Marshal 

func (m *S2C_ServiceInfo) Marshal() (dAtA []byte, err error)

func (*S2C_ServiceInfo) MarshalTo 

func (m *S2C_ServiceInfo) MarshalTo(dAtA []byte) (int, error)

func (*S2C_ServiceInfo) ProtoMessage 

func (*S2C_ServiceInfo) ProtoMessage()

func (*S2C_ServiceInfo) Reset 

func (m *S2C_ServiceInfo) Reset()

func (*S2C_ServiceInfo) ResetEx 

func (m *S2C_ServiceInfo) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_ServiceInfo begin

func (*S2C_ServiceInfo) Size 

func (m *S2C_ServiceInfo) Size() (n int)

func (*S2C_ServiceInfo) String 

func (this *S2C_ServiceInfo) String() string

func (*S2C_ServiceInfo) Unmarshal 

func (m *S2C_ServiceInfo) Unmarshal(dAtA []byte) error

func (*S2C_ServiceInfo) XXX_DiscardUnknown 

func (m *S2C_ServiceInfo) XXX_DiscardUnknown()

func (*S2C_ServiceInfo) XXX_Marshal 

func (m *S2C_ServiceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_ServiceInfo) XXX_Merge 

func (m *S2C_ServiceInfo) XXX_Merge(src proto.Message)

func (*S2C_ServiceInfo) XXX_Size 

func (m *S2C_ServiceInfo) XXX_Size() int

func (*S2C_ServiceInfo) XXX_Unmarshal 

func (m *S2C_ServiceInfo) XXX_Unmarshal(b []byte) error

type S2C_ServiceInstance 

type S2C_ServiceInstance struct {
	Err      *Error           `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Instance *ServiceInstance `protobuf:"bytes,2,opt,name=Instance,proto3" json:"Instance,omitempty"`
}

请求服务实例回复

func Clone_S2C_ServiceInstance_Slice 

func Clone_S2C_ServiceInstance_Slice(dst []*S2C_ServiceInstance, src []*S2C_ServiceInstance) []*S2C_ServiceInstance

func Get_S2C_ServiceInstance 

func Get_S2C_ServiceInstance() *S2C_ServiceInstance

func New_S2C_ServiceInstance 

func New_S2C_ServiceInstance() *S2C_ServiceInstance

func Request_S2C_ServiceInstance 

func Request_S2C_ServiceInstance(pid *actor.PID, send *C2S_ServiceInstance) (*S2C_ServiceInstance, error)

func Request_S2C_ServiceInstance_T 

func Request_S2C_ServiceInstance_T(pid *actor.PID, send *C2S_ServiceInstance, timeout time.Duration) (*S2C_ServiceInstance, error)

func (S2C_ServiceInstance) CanIgnore 

func (S2C_ServiceInstance) CanIgnore() bool

func (S2C_ServiceInstance) Clone 

func (m S2C_ServiceInstance) Clone() *S2C_ServiceInstance

func (*S2C_ServiceInstance) Descriptor 

func (*S2C_ServiceInstance) Descriptor() ([]byte, []int)

func (*S2C_ServiceInstance) Equal 

func (this *S2C_ServiceInstance) Equal(that interface{}) bool

func (*S2C_ServiceInstance) GetErr 

func (m *S2C_ServiceInstance) GetErr() *Error

func (*S2C_ServiceInstance) GetInstance 

func (m *S2C_ServiceInstance) GetInstance() *ServiceInstance

func (*S2C_ServiceInstance) GoString 

func (this *S2C_ServiceInstance) GoString() string

func (S2C_ServiceInstance) JsonString 

func (m S2C_ServiceInstance) JsonString() string

func (*S2C_ServiceInstance) Marshal 

func (m *S2C_ServiceInstance) Marshal() (dAtA []byte, err error)

func (*S2C_ServiceInstance) MarshalTo 

func (m *S2C_ServiceInstance) MarshalTo(dAtA []byte) (int, error)

func (*S2C_ServiceInstance) ProtoMessage 

func (*S2C_ServiceInstance) ProtoMessage()

func (*S2C_ServiceInstance) Reset 

func (m *S2C_ServiceInstance) Reset()

func (*S2C_ServiceInstance) ResetEx 

func (m *S2C_ServiceInstance) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_ServiceInstance begin

func (*S2C_ServiceInstance) Size 

func (m *S2C_ServiceInstance) Size() (n int)

func (*S2C_ServiceInstance) String 

func (this *S2C_ServiceInstance) String() string

func (*S2C_ServiceInstance) Unmarshal 

func (m *S2C_ServiceInstance) Unmarshal(dAtA []byte) error

func (*S2C_ServiceInstance) XXX_DiscardUnknown 

func (m *S2C_ServiceInstance) XXX_DiscardUnknown()

func (*S2C_ServiceInstance) XXX_Marshal 

func (m *S2C_ServiceInstance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_ServiceInstance) XXX_Merge 

func (m *S2C_ServiceInstance) XXX_Merge(src proto.Message)

func (*S2C_ServiceInstance) XXX_Size 

func (m *S2C_ServiceInstance) XXX_Size() int

func (*S2C_ServiceInstance) XXX_Unmarshal 

func (m *S2C_ServiceInstance) XXX_Unmarshal(b []byte) error

type S2C_ServicePayload 

type S2C_ServicePayload struct {
	Err     *Error `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Payload int32  `protobuf:"varint,2,opt,name=Payload,proto3" json:"Payload,omitempty"`
}

请求服务负载回复

func Clone_S2C_ServicePayload_Slice 

func Clone_S2C_ServicePayload_Slice(dst []*S2C_ServicePayload, src []*S2C_ServicePayload) []*S2C_ServicePayload

func Get_S2C_ServicePayload 

func Get_S2C_ServicePayload() *S2C_ServicePayload

func New_S2C_ServicePayload 

func New_S2C_ServicePayload() *S2C_ServicePayload

func Request_S2C_ServicePayload 

func Request_S2C_ServicePayload(pid *actor.PID, send *C2S_ServicePayload) (*S2C_ServicePayload, error)

func Request_S2C_ServicePayload_T 

func Request_S2C_ServicePayload_T(pid *actor.PID, send *C2S_ServicePayload, timeout time.Duration) (*S2C_ServicePayload, error)

func (S2C_ServicePayload) CanIgnore 

func (S2C_ServicePayload) CanIgnore() bool

func (S2C_ServicePayload) Clone 

func (m S2C_ServicePayload) Clone() *S2C_ServicePayload

func (*S2C_ServicePayload) Descriptor 

func (*S2C_ServicePayload) Descriptor() ([]byte, []int)

func (*S2C_ServicePayload) Equal 

func (this *S2C_ServicePayload) Equal(that interface{}) bool

func (*S2C_ServicePayload) GetErr 

func (m *S2C_ServicePayload) GetErr() *Error

func (*S2C_ServicePayload) GetPayload 

func (m *S2C_ServicePayload) GetPayload() int32

func (*S2C_ServicePayload) GoString 

func (this *S2C_ServicePayload) GoString() string

func (S2C_ServicePayload) JsonString 

func (m S2C_ServicePayload) JsonString() string

func (*S2C_ServicePayload) Marshal 

func (m *S2C_ServicePayload) Marshal() (dAtA []byte, err error)

func (*S2C_ServicePayload) MarshalTo 

func (m *S2C_ServicePayload) MarshalTo(dAtA []byte) (int, error)

func (*S2C_ServicePayload) ProtoMessage 

func (*S2C_ServicePayload) ProtoMessage()

func (*S2C_ServicePayload) Reset 

func (m *S2C_ServicePayload) Reset()

func (*S2C_ServicePayload) ResetEx 

func (m *S2C_ServicePayload) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_ServicePayload begin

func (*S2C_ServicePayload) Size 

func (m *S2C_ServicePayload) Size() (n int)

func (*S2C_ServicePayload) String 

func (this *S2C_ServicePayload) String() string

func (*S2C_ServicePayload) Unmarshal 

func (m *S2C_ServicePayload) Unmarshal(dAtA []byte) error

func (*S2C_ServicePayload) XXX_DiscardUnknown 

func (m *S2C_ServicePayload) XXX_DiscardUnknown()

func (*S2C_ServicePayload) XXX_Marshal 

func (m *S2C_ServicePayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_ServicePayload) XXX_Merge 

func (m *S2C_ServicePayload) XXX_Merge(src proto.Message)

func (*S2C_ServicePayload) XXX_Size 

func (m *S2C_ServicePayload) XXX_Size() int

func (*S2C_ServicePayload) XXX_Unmarshal 

func (m *S2C_ServicePayload) XXX_Unmarshal(b []byte) error

type S2C_TryLockServicePosition 

type S2C_TryLockServicePosition struct {
	Err *Error `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
}

请求锁定服务坑位回复

func Clone_S2C_TryLockServicePosition_Slice 

func Clone_S2C_TryLockServicePosition_Slice(dst []*S2C_TryLockServicePosition, src []*S2C_TryLockServicePosition) []*S2C_TryLockServicePosition

func Get_S2C_TryLockServicePosition 

func Get_S2C_TryLockServicePosition() *S2C_TryLockServicePosition

func New_S2C_TryLockServicePosition 

func New_S2C_TryLockServicePosition() *S2C_TryLockServicePosition

func Request_S2C_TryLockServicePosition 

func Request_S2C_TryLockServicePosition(pid *actor.PID, send *C2S_TryLockServicePosition) (*S2C_TryLockServicePosition, error)

func Request_S2C_TryLockServicePosition_T 

func Request_S2C_TryLockServicePosition_T(pid *actor.PID, send *C2S_TryLockServicePosition, timeout time.Duration) (*S2C_TryLockServicePosition, error)

func (S2C_TryLockServicePosition) CanIgnore 

func (S2C_TryLockServicePosition) CanIgnore() bool

func (S2C_TryLockServicePosition) Clone 

func (m S2C_TryLockServicePosition) Clone() *S2C_TryLockServicePosition

func (*S2C_TryLockServicePosition) Descriptor 

func (*S2C_TryLockServicePosition) Descriptor() ([]byte, []int)

func (*S2C_TryLockServicePosition) Equal 

func (this *S2C_TryLockServicePosition) Equal(that interface{}) bool

func (*S2C_TryLockServicePosition) GetErr 

func (m *S2C_TryLockServicePosition) GetErr() *Error

func (*S2C_TryLockServicePosition) GoString 

func (this *S2C_TryLockServicePosition) GoString() string

func (S2C_TryLockServicePosition) JsonString 

func (m S2C_TryLockServicePosition) JsonString() string

func (*S2C_TryLockServicePosition) Marshal 

func (m *S2C_TryLockServicePosition) Marshal() (dAtA []byte, err error)

func (*S2C_TryLockServicePosition) MarshalTo 

func (m *S2C_TryLockServicePosition) MarshalTo(dAtA []byte) (int, error)

func (*S2C_TryLockServicePosition) ProtoMessage 

func (*S2C_TryLockServicePosition) ProtoMessage()

func (*S2C_TryLockServicePosition) Reset 

func (m *S2C_TryLockServicePosition) Reset()

func (*S2C_TryLockServicePosition) ResetEx 

func (m *S2C_TryLockServicePosition) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_TryLockServicePosition begin

func (*S2C_TryLockServicePosition) Size 

func (m *S2C_TryLockServicePosition) Size() (n int)

func (*S2C_TryLockServicePosition) String 

func (this *S2C_TryLockServicePosition) String() string

func (*S2C_TryLockServicePosition) Unmarshal 

func (m *S2C_TryLockServicePosition) Unmarshal(dAtA []byte) error

func (*S2C_TryLockServicePosition) XXX_DiscardUnknown 

func (m *S2C_TryLockServicePosition) XXX_DiscardUnknown()

func (*S2C_TryLockServicePosition) XXX_Marshal 

func (m *S2C_TryLockServicePosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_TryLockServicePosition) XXX_Merge 

func (m *S2C_TryLockServicePosition) XXX_Merge(src proto.Message)

func (*S2C_TryLockServicePosition) XXX_Size 

func (m *S2C_TryLockServicePosition) XXX_Size() int

func (*S2C_TryLockServicePosition) XXX_Unmarshal 

func (m *S2C_TryLockServicePosition) XXX_Unmarshal(b []byte) error

type ServiceGroupInfo 

type ServiceGroupInfo struct {
	GlobalConfig service.IGlobalConfig
	Config       service.IConfig
}

type ServiceGroupInfoMap 

type ServiceGroupInfoMap = map[string]ServiceGroupInfo

type ServiceInfo 

type ServiceInfo struct {
	ID         int32            `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
	ConfigData []byte           `protobuf:"bytes,2,opt,name=ConfigData,proto3" json:"ConfigData,omitempty"`
	Instance   *ServiceInstance `protobuf:"bytes,3,opt,name=Instance,proto3" json:"Instance,omitempty"`
	Payload    int32            `protobuf:"varint,4,opt,name=Payload,proto3" json:"Payload,omitempty"`
}

func Clone_ServiceInfo_Slice 

func Clone_ServiceInfo_Slice(dst []*ServiceInfo, src []*ServiceInfo) []*ServiceInfo

func Get_ServiceInfo 

func Get_ServiceInfo() *ServiceInfo

func New_ServiceInfo 

func New_ServiceInfo() *ServiceInfo

func (ServiceInfo) CanIgnore 

func (ServiceInfo) CanIgnore() bool

func (ServiceInfo) Clone 

func (m ServiceInfo) Clone() *ServiceInfo

func (*ServiceInfo) CopyFrom 

func (si *ServiceInfo) CopyFrom(info *service.Info) *ServiceInfo

func (*ServiceInfo) Descriptor 

func (*ServiceInfo) Descriptor() ([]byte, []int)

func (*ServiceInfo) DumpTo 

func (si *ServiceInfo) DumpTo(info *service.Info) *ServiceInfo

func (*ServiceInfo) Equal 

func (this *ServiceInfo) Equal(that interface{}) bool

func (*ServiceInfo) GetConfigData 

func (m *ServiceInfo) GetConfigData() []byte

func (*ServiceInfo) GetID 

func (m *ServiceInfo) GetID() int32

func (*ServiceInfo) GetInstance 

func (m *ServiceInfo) GetInstance() *ServiceInstance

func (*ServiceInfo) GetPayload 

func (m *ServiceInfo) GetPayload() int32

func (*ServiceInfo) GoString 

func (this *ServiceInfo) GoString() string

func (*ServiceInfo) IsEmpty 

func (si *ServiceInfo) IsEmpty() bool

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (ServiceInfo) JsonString 

func (m ServiceInfo) JsonString() string

func (*ServiceInfo) Marshal 

func (m *ServiceInfo) Marshal() (dAtA []byte, err error)

func (*ServiceInfo) MarshalTo 

func (m *ServiceInfo) MarshalTo(dAtA []byte) (int, error)

func (*ServiceInfo) ProtoMessage 

func (*ServiceInfo) ProtoMessage()

func (*ServiceInfo) Reset 

func (m *ServiceInfo) Reset()

func (*ServiceInfo) ResetEx 

func (m *ServiceInfo) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message ServiceInfo begin

func (*ServiceInfo) Size 

func (m *ServiceInfo) Size() (n int)

func (*ServiceInfo) String 

func (this *ServiceInfo) String() string

func (*ServiceInfo) Unmarshal 

func (m *ServiceInfo) Unmarshal(dAtA []byte) error

func (*ServiceInfo) XXX_DiscardUnknown 

func (m *ServiceInfo) XXX_DiscardUnknown()

func (*ServiceInfo) XXX_Marshal 

func (m *ServiceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ServiceInfo) XXX_Merge 

func (m *ServiceInfo) XXX_Merge(src proto.Message)

func (*ServiceInfo) XXX_Size 

func (m *ServiceInfo) XXX_Size() int

func (*ServiceInfo) XXX_Unmarshal 

func (m *ServiceInfo) XXX_Unmarshal(b []byte) error

type ServiceInstance 

type ServiceInstance struct {
	PID       *actor.PID `protobuf:"bytes,1,opt,name=PID,proto3" json:"PID,omitempty"`
	PprofAddr string     `protobuf:"bytes,2,opt,name=PprofAddr,proto3" json:"PprofAddr,omitempty"`
	Extra     []byte     `protobuf:"bytes,3,opt,name=Extra,proto3" json:"Extra,omitempty"`
}

func Clone_ServiceInstance_Slice 

func Clone_ServiceInstance_Slice(dst []*ServiceInstance, src []*ServiceInstance) []*ServiceInstance

func Get_ServiceInstance 

func Get_ServiceInstance() *ServiceInstance

func New_ServiceInstance 

func New_ServiceInstance() *ServiceInstance

func (ServiceInstance) CanIgnore 

func (ServiceInstance) CanIgnore() bool

func (ServiceInstance) Clone 

func (m ServiceInstance) Clone() *ServiceInstance

func (*ServiceInstance) CopyFrom 

func (si *ServiceInstance) CopyFrom(instance *service.Instance) *ServiceInstance

func (*ServiceInstance) Descriptor 

func (*ServiceInstance) Descriptor() ([]byte, []int)

func (*ServiceInstance) DumpTo 

func (si *ServiceInstance) DumpTo(instance *service.Instance) *ServiceInstance

func (*ServiceInstance) Equal 

func (this *ServiceInstance) Equal(that interface{}) bool

func (*ServiceInstance) GetExtra 

func (m *ServiceInstance) GetExtra() []byte

func (*ServiceInstance) GetPID 

func (m *ServiceInstance) GetPID() *actor.PID

func (*ServiceInstance) GetPprofAddr 

func (m *ServiceInstance) GetPprofAddr() string

func (*ServiceInstance) GoString 

func (this *ServiceInstance) GoString() string

func (*ServiceInstance) IsEmpty 

func (si *ServiceInstance) IsEmpty() bool

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

func (ServiceInstance) JsonString 

func (m ServiceInstance) JsonString() string

func (*ServiceInstance) Marshal 

func (m *ServiceInstance) Marshal() (dAtA []byte, err error)

func (*ServiceInstance) MarshalTo 

func (m *ServiceInstance) MarshalTo(dAtA []byte) (int, error)

func (*ServiceInstance) ProtoMessage 

func (*ServiceInstance) ProtoMessage()

func (*ServiceInstance) Reset 

func (m *ServiceInstance) Reset()

func (*ServiceInstance) ResetEx 

func (m *ServiceInstance) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message ServiceInstance begin

func (*ServiceInstance) Size 

func (m *ServiceInstance) Size() (n int)

func (*ServiceInstance) String 

func (this *ServiceInstance) String() string

func (*ServiceInstance) Unmarshal 

func (m *ServiceInstance) Unmarshal(dAtA []byte) error

func (*ServiceInstance) XXX_DiscardUnknown 

func (m *ServiceInstance) XXX_DiscardUnknown()

func (*ServiceInstance) XXX_Marshal 

func (m *ServiceInstance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ServiceInstance) XXX_Merge 

func (m *ServiceInstance) XXX_Merge(src proto.Message)

func (*ServiceInstance) XXX_Size 

func (m *ServiceInstance) XXX_Size() int

func (*ServiceInstance) XXX_Unmarshal 

func (m *ServiceInstance) XXX_Unmarshal(b []byte) error

type WatchCallback 

type WatchCallback func(section string, serviceName string, serviceID int, ev *clientv3.Event, err error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.