benjamyn/any-sync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

node configuration command proto

Browse Source
This commit is contained in:
Sergey Cherepanov 2023-03-26 14:54:27 +02:00
parent d20f5fc2b3
commit 067bf797dd
No known key found for this signature in database
GPG Key ID: 87F8EDE8FBDF637C
3 changed files with 898 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

868
coordinator/coordinatorproto/coordinator.pb.go
View File

@ -90,6 +90,38 @@ func (SpaceStatus) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_d94f6f99586adae2, []int{1}
}
// NodeType determines the type of API that a node supports
type NodeType int32
const (
// TreeAPI supports space/tree sync api
NodeType_TreeAPI NodeType = 0
// FileAPI support file api
NodeType_FileAPI NodeType = 1
// CoordinatorAPI supports coordinator api
NodeType_CoordinatorAPI NodeType = 2
)
var NodeType_name = map[int32]string{
0: "TreeAPI",
1: "FileAPI",
2: "CoordinatorAPI",
}
var NodeType_value = map[string]int32{
"TreeAPI": 0,
"FileAPI": 1,
"CoordinatorAPI": 2,
}
func (x NodeType) String() string {
return proto.EnumName(NodeType_name, int32(x))
}
func (NodeType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_d94f6f99586adae2, []int{2}
}
type SpaceSignRequest struct {
SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
Header []byte `protobuf:"bytes,2,opt,name=header,proto3" json:"header,omitempty"`
@ -668,9 +700,172 @@ func (m *SpaceStatusChangeResponse) GetPayload() *SpaceStatusPayload {
return nil
}
// NetworkConfigurationRequest contains the requested configurationId, it can be empty to request the latest version
type NetworkConfigurationRequest struct {
ConfigurationId string `protobuf:"bytes,1,opt,name=configurationId,proto3" json:"configurationId,omitempty"`
}
func (m *NetworkConfigurationRequest) Reset() { *m = NetworkConfigurationRequest{} }
func (m *NetworkConfigurationRequest) String() string { return proto.CompactTextString(m) }
func (*NetworkConfigurationRequest) ProtoMessage() {}
func (*NetworkConfigurationRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_d94f6f99586adae2, []int{11}
}
func (m *NetworkConfigurationRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *NetworkConfigurationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_NetworkConfigurationRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *NetworkConfigurationRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_NetworkConfigurationRequest.Merge(m, src)
}
func (m *NetworkConfigurationRequest) XXX_Size() int {
return m.Size()
}
func (m *NetworkConfigurationRequest) XXX_DiscardUnknown() {
xxx_messageInfo_NetworkConfigurationRequest.DiscardUnknown(m)
}
var xxx_messageInfo_NetworkConfigurationRequest proto.InternalMessageInfo
func (m *NetworkConfigurationRequest) GetConfigurationId() string {
if m != nil {
return m.ConfigurationId
}
return ""
}
// NetworkConfigurationResponse contains list of nodes
type NetworkConfigurationResponse struct {
ConfigurationId string `protobuf:"bytes,1,opt,name=configurationId,proto3" json:"configurationId,omitempty"`
Nodes []*Node `protobuf:"bytes,2,rep,name=nodes,proto3" json:"nodes,omitempty"`
}
func (m *NetworkConfigurationResponse) Reset() { *m = NetworkConfigurationResponse{} }
func (m *NetworkConfigurationResponse) String() string { return proto.CompactTextString(m) }
func (*NetworkConfigurationResponse) ProtoMessage() {}
func (*NetworkConfigurationResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_d94f6f99586adae2, []int{12}
}
func (m *NetworkConfigurationResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *NetworkConfigurationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_NetworkConfigurationResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *NetworkConfigurationResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_NetworkConfigurationResponse.Merge(m, src)
}
func (m *NetworkConfigurationResponse) XXX_Size() int {
return m.Size()
}
func (m *NetworkConfigurationResponse) XXX_DiscardUnknown() {
xxx_messageInfo_NetworkConfigurationResponse.DiscardUnknown(m)
}
var xxx_messageInfo_NetworkConfigurationResponse proto.InternalMessageInfo
func (m *NetworkConfigurationResponse) GetConfigurationId() string {
if m != nil {
return m.ConfigurationId
}
return ""
}
func (m *NetworkConfigurationResponse) GetNodes() []*Node {
if m != nil {
return m.Nodes
}
return nil
}
// Node describes one node in the network
type Node struct {
// peerId - it's a peer identifier (libp2p format string) so it's an encoded publicKey
PeerId string `protobuf:"bytes,1,opt,name=peerId,proto3" json:"peerId,omitempty"`
// list of node addresses
Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty"`
// list of supported APIs
Types []NodeType `protobuf:"varint,3,rep,packed,name=types,proto3,enum=coordinator.NodeType" json:"types,omitempty"`
}
func (m *Node) Reset() { *m = Node{} }
func (m *Node) String() string { return proto.CompactTextString(m) }
func (*Node) ProtoMessage() {}
func (*Node) Descriptor() ([]byte, []int) {
return fileDescriptor_d94f6f99586adae2, []int{13}
}
func (m *Node) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Node.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Node) XXX_Merge(src proto.Message) {
xxx_messageInfo_Node.Merge(m, src)
}
func (m *Node) XXX_Size() int {
return m.Size()
}
func (m *Node) XXX_DiscardUnknown() {
xxx_messageInfo_Node.DiscardUnknown(m)
}
var xxx_messageInfo_Node proto.InternalMessageInfo
func (m *Node) GetPeerId() string {
if m != nil {
return m.PeerId
}
return ""
}
func (m *Node) GetAddresses() []string {
if m != nil {
return m.Addresses
}
return nil
}
func (m *Node) GetTypes() []NodeType {
if m != nil {
return m.Types
}
return nil
}
func init() {
proto.RegisterEnum("coordinator.ErrorCodes", ErrorCodes_name, ErrorCodes_value)
proto.RegisterEnum("coordinator.SpaceStatus", SpaceStatus_name, SpaceStatus_value)
proto.RegisterEnum("coordinator.NodeType", NodeType_name, NodeType_value)
proto.RegisterType((*SpaceSignRequest)(nil), "coordinator.SpaceSignRequest")
proto.RegisterType((*SpaceStatusPayload)(nil), "coordinator.SpaceStatusPayload")
proto.RegisterType((*SpaceSignResponse)(nil), "coordinator.SpaceSignResponse")
@ -682,6 +877,9 @@ func init() {
proto.RegisterType((*SpaceStatusCheckResponse)(nil), "coordinator.SpaceStatusCheckResponse")
proto.RegisterType((*SpaceStatusChangeRequest)(nil), "coordinator.SpaceStatusChangeRequest")
proto.RegisterType((*SpaceStatusChangeResponse)(nil), "coordinator.SpaceStatusChangeResponse")
proto.RegisterType((*NetworkConfigurationRequest)(nil), "coordinator.NetworkConfigurationRequest")
proto.RegisterType((*NetworkConfigurationResponse)(nil), "coordinator.NetworkConfigurationResponse")
proto.RegisterType((*Node)(nil), "coordinator.Node")
}
func init() {
@ -689,51 +887,61 @@ func init() {
}
var fileDescriptor_d94f6f99586adae2 = []byte{
// 704 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x4d, 0x4f, 0x13, 0x4f,
0x18, 0xef, 0xb6, 0x05, 0xd2, 0xa7, 0xa4, 0xff, 0x65, 0xfe, 0x80, 0x6b, 0x83, 0x2b, 0x59, 0x95,
0x34, 0xc4, 0x00, 0x29, 0x6a, 0xe2, 0xcd, 0x58, 0x30, 0xc1, 0x18, 0x24, 0x8b, 0xd5, 0xa8, 0x07,
0xb3, 0xec, 0x3e, 0xc0, 0x84, 0x65, 0x67, 0xdd, 0x99, 0x1a, 0x38, 0x98, 0xf8, 0x11, 0x3c, 0xf9,
0x29, 0xfc, 0x08, 0x7e, 0x00, 0x8f, 0x1c, 0x3d, 0x1a, 0xf8, 0x14, 0xde, 0xcc, 0xbe, 0x4c, 0x3b,
0xdb, 0x6e, 0xcb, 0xc1, 0x0b, 0x74, 0x7e, 0xcf, 0xcb, 0xef, 0xf7, 0xbc, 0xcc, 0x2c, 0x3c, 0x74,
0x19, 0x8b, 0x3c, 0x1a, 0x38, 0x82, 0x45, 0xeb, 0xca, 0xef, 0x30, 0x62, 0x82, 0xad, 0x27, 0x7f,
0xb9, 0x8a, 0xaf, 0x25, 0x10, 0xa9, 0x2b, 0x90, 0xb5, 0x05, 0xfa, 0x7e, 0xe8, 0xb8, 0xb8, 0x4f,
0x8f, 0x02, 0x1b, 0x3f, 0xf6, 0x90, 0x0b, 0x62, 0xc0, 0x0c, 0x8f, 0xb1, 0x1d, 0xcf, 0xd0, 0x96,
0xb5, 0x56, 0xcd, 0x96, 0x47, 0xb2, 0x08, 0xd3, 0xc7, 0xe8, 0x78, 0x18, 0x19, 0xe5, 0x65, 0xad,
0x35, 0x6b, 0x67, 0x27, 0x4b, 0x00, 0x49, 0xb3, 0x08, 0x47, 0xf4, 0xf8, 0x9e, 0x73, 0xee, 0x33,
0xc7, 0x23, 0x1b, 0x30, 0xcd, 0x13, 0x20, 0x49, 0xd3, 0x68, 0x1b, 0x6b, 0xaa, 0x18, 0x25, 0xc0,
0xce, 0xfc, 0xc8, 0x7d, 0x98, 0xf3, 0xd0, 0x47, 0x41, 0x59, 0xf0, 0x8a, 0x9e, 0x22, 0x17, 0xce,
0x69, 0x98, 0x50, 0x55, 0xec, 0x51, 0x83, 0xd5, 0x85, 0x39, 0x45, 0x3b, 0x0f, 0x59, 0xc0, 0x91,
0x3c, 0x81, 0x99, 0x08, 0x5d, 0xa4, 0xa1, 0x48, 0x58, 0xeb, 0xed, 0x95, 0x51, 0x56, 0x3b, 0x75,
0x78, 0x43, 0xc5, 0x71, 0x1c, 0xeb, 0x88, 0x5e, 0x84, 0xb6, 0x0c, 0xb3, 0x4e, 0xe0, 0xe6, 0x58,
0x2f, 0xb2, 0x01, 0xff, 0x73, 0xc5, 0x98, 0x95, 0x9a, 0x50, 0xcd, 0xda, 0x45, 0x26, 0xb2, 0x04,
0x35, 0x2e, 0xc3, 0xb3, 0xb6, 0x0d, 0x00, 0xeb, 0x87, 0x06, 0xb3, 0x2a, 0xdb, 0xe4, 0xe6, 0x87,
0x88, 0xd1, 0x8e, 0x97, 0x64, 0xa9, 0xd9, 0xd9, 0x89, 0xb4, 0xe0, 0x3f, 0xc7, 0x75, 0x59, 0x2f,
0x10, 0x3b, 0x1e, 0x06, 0x82, 0x8a, 0x73, 0xa3, 0x92, 0xd0, 0x0c, 0xc3, 0xb1, 0x78, 0x97, 0x05,
0x22, 0x62, 0xfe, 0x2e, 0xf3, 0xb0, 0xef, 0x5d, 0x4d, 0xc5, 0x17, 0x98, 0x88, 0x09, 0xf0, 0xc9,
0xf1, 0xa9, 0xd7, 0x0d, 0x04, 0xf5, 0x8d, 0xa9, 0x65, 0xad, 0x55, 0xb5, 0x15, 0xc4, 0x7a, 0x0f,
0x0b, 0xcf, 0xa8, 0x8f, 0x2f, 0xe8, 0x29, 0x15, 0x9d, 0x63, 0x74, 0x4f, 0xe4, 0x0e, 0x15, 0x88,
0xd2, 0x8a, 0x45, 0x29, 0x05, 0x97, 0x73, 0x05, 0x5b, 0x6b, 0xb0, 0x38, 0x9c, 0x3c, 0x1b, 0xf2,
0x3c, 0x4c, 0xf9, 0x31, 0x9a, 0xe4, 0xac, 0xda, 0xe9, 0xc1, 0xda, 0x84, 0x1b, 0xca, 0x52, 0xe5,
0xe4, 0x8c, 0xed, 0xaa, 0xd5, 0x05, 0x63, 0x34, 0x28, 0xa3, 0x79, 0x0c, 0x33, 0xa1, 0x32, 0xe0,
0x7a, 0xfb, 0xf6, 0xb8, 0x0d, 0xce, 0x86, 0x6d, 0x4b, 0x7f, 0xeb, 0x9b, 0x36, 0x94, 0xd7, 0x09,
0x8e, 0xf0, 0xfa, 0x0b, 0xb6, 0x0a, 0xba, 0xdc, 0xf3, 0x34, 0xa4, 0xdf, 0x95, 0x11, 0x9c, 0x3c,
0x80, 0x85, 0x3c, 0x26, 0x97, 0x31, 0x9d, 0x7e, 0xb1, 0xd1, 0x7a, 0x9d, 0x6d, 0x77, 0x5e, 0xd7,
0x3f, 0x17, 0xbc, 0xfa, 0x45, 0x03, 0xd8, 0x8e, 0x22, 0x16, 0x75, 0x98, 0x87, 0x9c, 0x34, 0x00,
0xba, 0x01, 0x9e, 0x85, 0xe8, 0x0a, 0xf4, 0xf4, 0x12, 0xd1, 0xb3, 0x35, 0xdf, 0x8a, 0x45, 0xa1,
0xa7, 0x6b, 0xc4, 0x80, 0xf9, 0x01, 0x42, 0x59, 0xb0, 0x87, 0x81, 0x47, 0x83, 0x23, 0xbd, 0xdc,
0xf7, 0xed, 0x44, 0xe8, 0xc4, 0xbe, 0x15, 0x42, 0xa0, 0x91, 0x20, 0xbb, 0x4c, 0x6c, 0x9f, 0x51,
0x2e, 0xb8, 0x5e, 0x25, 0x3a, 0xd4, 0x13, 0xbe, 0x97, 0x87, 0x87, 0x1c, 0x85, 0xfe, 0xbd, 0xbc,
0xfa, 0x19, 0xea, 0x8a, 0x42, 0xb2, 0x98, 0x7b, 0x94, 0x64, 0xb2, 0x12, 0x31, 0xa1, 0xa9, 0x16,
0x92, 0xd2, 0x4a, 0x15, 0xba, 0x36, 0x64, 0x97, 0x86, 0x7d, 0xe1, 0x44, 0x71, 0x7c, 0x79, 0x28,
0xaf, 0x2c, 0xa8, 0xd2, 0xfe, 0x53, 0x86, 0x7a, 0x67, 0xd0, 0x2d, 0xf2, 0x1c, 0x6a, 0xfd, 0xe7,
0x89, 0xdc, 0x2a, 0x68, 0xe4, 0xe0, 0xc9, 0x6d, 0x9a, 0xe3, 0xcc, 0xd9, 0x60, 0xde, 0x42, 0x23,
0x7f, 0x15, 0x88, 0x95, 0x8b, 0x28, 0xbc, 0x84, 0xcd, 0x3b, 0x13, 0x7d, 0xb2, 0xd4, 0x1f, 0xe4,
0x17, 0x60, 0x70, 0x01, 0xc8, 0xdd, 0x71, 0x63, 0xcf, 0xa5, 0xbf, 0x77, 0x8d, 0x57, 0x46, 0x70,
0x20, 0x9f, 0x69, 0x65, 0xe3, 0xc8, 0x84, 0x58, 0xe5, 0xa6, 0x34, 0x57, 0xae, 0x73, 0x4b, 0x39,
0x9e, 0x3e, 0xfa, 0x79, 0x69, 0x6a, 0x17, 0x97, 0xa6, 0xf6, 0xfb, 0xd2, 0xd4, 0xbe, 0x5e, 0x99,
0xa5, 0x8b, 0x2b, 0xb3, 0xf4, 0xeb, 0xca, 0x2c, 0xbd, 0x5b, 0x9a, 0xf4, 0x91, 0x3c, 0x98, 0x4e,
0xfe, 0x6d, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xe4, 0x76, 0x96, 0x0f, 0x4b, 0x07, 0x00, 0x00,
// 856 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xdd, 0x6e, 0xe3, 0x44,
0x14, 0x8e, 0xe3, 0xb4, 0x25, 0xc7, 0x55, 0x70, 0x87, 0xb6, 0x98, 0x50, 0x4c, 0x64, 0x60, 0x09,
0x05, 0x75, 0x57, 0x59, 0x40, 0x70, 0x07, 0x64, 0x17, 0x54, 0x84, 0x4a, 0xe5, 0xb6, 0x20, 0xe0,
0x02, 0x79, 0xed, 0xd3, 0x76, 0xd4, 0xd4, 0xe3, 0x9d, 0x99, 0xc0, 0xf6, 0x02, 0x89, 0x47, 0xe0,
0x8a, 0xa7, 0xe0, 0x11, 0x78, 0x00, 0x2e, 0xf7, 0x92, 0x4b, 0xd4, 0x4a, 0x3c, 0x07, 0x1a, 0x7b,
0x9c, 0x8c, 0x13, 0x27, 0xad, 0xc4, 0x4d, 0xdb, 0xf3, 0x9d, 0x9f, 0xef, 0x9c, 0x39, 0x3f, 0x2e,
0x7c, 0x10, 0x33, 0xc6, 0x13, 0x9a, 0x46, 0x92, 0xf1, 0xfb, 0xc6, 0xdf, 0x19, 0x67, 0x92, 0xdd,
0xcf, 0x7f, 0x0a, 0x13, 0xdf, 0xcb, 0x21, 0xe2, 0x18, 0x50, 0xf0, 0x08, 0xdc, 0xa3, 0x2c, 0x8a,
0xf1, 0x88, 0x9e, 0xa5, 0x21, 0x3e, 0x1d, 0xa3, 0x90, 0xc4, 0x83, 0x35, 0xa1, 0xb0, 0xfd, 0xc4,
0xb3, 0x7a, 0x56, 0xbf, 0x1d, 0x96, 0x22, 0xd9, 0x86, 0xd5, 0x73, 0x8c, 0x12, 0xe4, 0x5e, 0xb3,
0x67, 0xf5, 0xd7, 0x43, 0x2d, 0x05, 0x12, 0x48, 0x11, 0x45, 0x46, 0x72, 0x2c, 0x0e, 0xa3, 0xab,
0x11, 0x8b, 0x12, 0xf2, 0x00, 0x56, 0x45, 0x0e, 0xe4, 0x61, 0x3a, 0x03, 0x6f, 0xcf, 0x4c, 0xc6,
0x70, 0x08, 0xb5, 0x1d, 0x79, 0x0f, 0x36, 0x12, 0x1c, 0xa1, 0xa4, 0x2c, 0x3d, 0xa6, 0x97, 0x28,
0x64, 0x74, 0x99, 0xe5, 0x54, 0x76, 0x38, 0xaf, 0x08, 0x4e, 0x60, 0xc3, 0xc8, 0x5d, 0x64, 0x2c,
0x15, 0x48, 0x3e, 0x81, 0x35, 0x8e, 0x31, 0xd2, 0x4c, 0xe6, 0xac, 0xce, 0xe0, 0xde, 0x3c, 0x6b,
0x58, 0x18, 0x7c, 0x4b, 0xe5, 0xb9, 0xf2, 0x8d, 0xe4, 0x98, 0x63, 0x58, 0xba, 0x05, 0x17, 0xf0,
0xca, 0x42, 0x2b, 0xf2, 0x00, 0x5e, 0x12, 0x86, 0x52, 0x97, 0x9a, 0x53, 0xad, 0x87, 0x75, 0x2a,
0xb2, 0x03, 0x6d, 0x51, 0xba, 0xeb, 0x67, 0x9b, 0x02, 0xc1, 0x9f, 0x16, 0xac, 0x9b, 0x6c, 0xcb,
0x1f, 0x3f, 0x43, 0xe4, 0xfb, 0x49, 0x1e, 0xa5, 0x1d, 0x6a, 0x89, 0xf4, 0xe1, 0xc5, 0x28, 0x8e,
0xd9, 0x38, 0x95, 0xfb, 0x09, 0xa6, 0x92, 0xca, 0x2b, 0xcf, 0xce, 0x69, 0x66, 0x61, 0x95, 0x7c,
0xcc, 0x52, 0xc9, 0xd9, 0xe8, 0x80, 0x25, 0x38, 0xb1, 0x6e, 0x15, 0xc9, 0xd7, 0xa8, 0x88, 0x0f,
0xf0, 0x53, 0x34, 0xa2, 0xc9, 0x49, 0x2a, 0xe9, 0xc8, 0x5b, 0xe9, 0x59, 0xfd, 0x56, 0x68, 0x20,
0xc1, 0x0f, 0xb0, 0xf5, 0x39, 0x1d, 0xe1, 0x57, 0xf4, 0x92, 0xca, 0xe1, 0x39, 0xc6, 0x17, 0xe5,
0x0c, 0xd5, 0x24, 0x65, 0xd5, 0x27, 0x65, 0x14, 0xdc, 0xac, 0x14, 0x1c, 0xec, 0xc1, 0xf6, 0x6c,
0x70, 0xdd, 0xe4, 0x4d, 0x58, 0x19, 0x29, 0x34, 0x8f, 0xd9, 0x0a, 0x0b, 0x21, 0x78, 0x08, 0x2f,
0x1b, 0x43, 0x55, 0x49, 0x67, 0xe1, 0xab, 0x06, 0x27, 0xe0, 0xcd, 0x3b, 0x69, 0x9a, 0x8f, 0x61,
0x2d, 0x33, 0x1a, 0xec, 0x0c, 0x5e, 0x5f, 0x34, 0xc1, 0xba, 0xd9, 0x61, 0x69, 0x1f, 0xfc, 0x6e,
0xcd, 0xc4, 0x8d, 0xd2, 0x33, 0xbc, 0x7d, 0xc1, 0x76, 0xc1, 0x2d, 0xe7, 0xbc, 0x70, 0x99, 0xbc,
0xca, 0x1c, 0x4e, 0xde, 0x87, 0xad, 0x2a, 0x56, 0x0e, 0x63, 0xd1, 0xfd, 0x7a, 0x65, 0xf0, 0x8d,
0x9e, 0xee, 0x6a, 0x5e, 0xff, 0xbf, 0xe0, 0x2f, 0xe0, 0xd5, 0x03, 0x94, 0x3f, 0x33, 0x7e, 0x31,
0x64, 0xe9, 0x29, 0x3d, 0x1b, 0xf3, 0x48, 0x91, 0x1b, 0xf3, 0x10, 0x9b, 0xf8, 0xa4, 0xf4, 0x59,
0x38, 0x78, 0x0a, 0x3b, 0xf5, 0x81, 0x74, 0x8e, 0x77, 0x8e, 0x44, 0xde, 0x86, 0x95, 0x94, 0x25,
0x28, 0xbc, 0x66, 0xcf, 0xee, 0x3b, 0x83, 0x8d, 0x4a, 0x2d, 0x6a, 0xcc, 0xc3, 0x42, 0x1f, 0x50,
0x68, 0x29, 0xd1, 0xd8, 0x30, 0xab, 0xb2, 0x61, 0x3b, 0xd0, 0x8e, 0x92, 0x84, 0xa3, 0x10, 0x3a,
0x58, 0x3b, 0x9c, 0x02, 0xe4, 0x5d, 0x58, 0x91, 0x57, 0x19, 0x0a, 0xcf, 0xee, 0xd9, 0xfd, 0xce,
0x60, 0x6b, 0x8e, 0xe6, 0xf8, 0x2a, 0xc3, 0xb0, 0xb0, 0xd9, 0xfd, 0xd5, 0x02, 0x78, 0xcc, 0x39,
0xe3, 0x43, 0xc5, 0x4c, 0x3a, 0x00, 0x27, 0x29, 0x3e, 0xcb, 0x30, 0x96, 0x98, 0xb8, 0x0d, 0xe2,
0xea, 0x6b, 0xf0, 0x48, 0xf5, 0x0e, 0x13, 0xd7, 0x22, 0x1e, 0x6c, 0x4e, 0x11, 0xca, 0xd2, 0x43,
0x4c, 0x13, 0x9a, 0x9e, 0xb9, 0xcd, 0x89, 0xed, 0x90, 0x63, 0xa4, 0x6c, 0x6d, 0x42, 0xa0, 0x93,
0x23, 0x07, 0x4c, 0x3e, 0x7e, 0x46, 0x85, 0x14, 0x6e, 0x8b, 0xb8, 0xe0, 0xe4, 0x7c, 0x5f, 0x9f,
0x9e, 0x0a, 0x94, 0xee, 0x1f, 0xcd, 0xdd, 0x5f, 0xc0, 0x31, 0x1a, 0x49, 0xb6, 0x2b, 0xb7, 0xbb,
0x0c, 0xd6, 0x20, 0x3e, 0x74, 0xcd, 0x7e, 0x17, 0xb4, 0x65, 0x16, 0xae, 0x35, 0xa3, 0x2f, 0x15,
0x47, 0x32, 0xe2, 0xca, 0xbf, 0x39, 0x13, 0xb7, 0x2c, 0xc8, 0xde, 0xfd, 0x08, 0x5e, 0x28, 0x1f,
0x85, 0x38, 0xb0, 0x76, 0xcc, 0x11, 0x3f, 0x3d, 0xdc, 0x77, 0x1b, 0x4a, 0x50, 0xeb, 0xae, 0x04,
0x4b, 0x95, 0x32, 0x9c, 0x3e, 0xa3, 0xc2, 0x9a, 0x83, 0x7f, 0x6d, 0x70, 0x0c, 0x90, 0x7c, 0x09,
0xed, 0xc9, 0xfd, 0x27, 0xaf, 0xd5, 0x4c, 0xea, 0xf4, 0x9b, 0xd6, 0xf5, 0x17, 0xa9, 0xf5, 0x54,
0x7d, 0x07, 0x9d, 0xea, 0xad, 0x21, 0x41, 0xc5, 0xa3, 0xf6, 0xca, 0x75, 0xdf, 0x58, 0x6a, 0xa3,
0x43, 0xff, 0x58, 0x7e, 0x62, 0xa7, 0x17, 0x86, 0xbc, 0xb9, 0x68, 0xaf, 0x2a, 0xe1, 0xdf, 0xba,
0xc5, 0x4a, 0x13, 0x3c, 0x29, 0xbf, 0x83, 0xc6, 0x4a, 0x93, 0x25, 0xbe, 0xc6, 0x29, 0xea, 0xde,
0xbb, 0xcd, 0x4c, 0x73, 0x5c, 0xc0, 0x66, 0xdd, 0x56, 0x92, 0x7e, 0x75, 0xda, 0x17, 0x5f, 0x80,
0xee, 0x3b, 0x77, 0xb0, 0x2c, 0xc8, 0x3e, 0xfb, 0xf0, 0xaf, 0x6b, 0xdf, 0x7a, 0x7e, 0xed, 0x5b,
0xff, 0x5c, 0xfb, 0xd6, 0x6f, 0x37, 0x7e, 0xe3, 0xf9, 0x8d, 0xdf, 0xf8, 0xfb, 0xc6, 0x6f, 0x7c,
0xbf, 0xb3, 0xec, 0x5f, 0x9e, 0x27, 0xab, 0xf9, 0xaf, 0x87, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff,
0x69, 0x34, 0x32, 0xd9, 0x19, 0x09, 0x00, 0x00,
}
func (m *SpaceSignRequest) Marshal() (dAtA []byte, err error) {
@ -1143,6 +1351,137 @@ func (m *SpaceStatusChangeResponse) MarshalToSizedBuffer(dAtA []byte) (int, erro
return len(dAtA) - i, nil
}
func (m *NetworkConfigurationRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *NetworkConfigurationRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *NetworkConfigurationRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.ConfigurationId) > 0 {
i -= len(m.ConfigurationId)
copy(dAtA[i:], m.ConfigurationId)
i = encodeVarintCoordinator(dAtA, i, uint64(len(m.ConfigurationId)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *NetworkConfigurationResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *NetworkConfigurationResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *NetworkConfigurationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Nodes) > 0 {
for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Nodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintCoordinator(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
}
if len(m.ConfigurationId) > 0 {
i -= len(m.ConfigurationId)
copy(dAtA[i:], m.ConfigurationId)
i = encodeVarintCoordinator(dAtA, i, uint64(len(m.ConfigurationId)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *Node) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Node) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Types) > 0 {
dAtA5 := make([]byte, len(m.Types)*10)
var j4 int
for _, num := range m.Types {
for num >= 1<<7 {
dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j4++
}
dAtA5[j4] = uint8(num)
j4++
}
i -= j4
copy(dAtA[i:], dAtA5[:j4])
i = encodeVarintCoordinator(dAtA, i, uint64(j4))
i--
dAtA[i] = 0x1a
}
if len(m.Addresses) > 0 {
for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.Addresses[iNdEx])
copy(dAtA[i:], m.Addresses[iNdEx])
i = encodeVarintCoordinator(dAtA, i, uint64(len(m.Addresses[iNdEx])))
i--
dAtA[i] = 0x12
}
}
if len(m.PeerId) > 0 {
i -= len(m.PeerId)
copy(dAtA[i:], m.PeerId)
i = encodeVarintCoordinator(dAtA, i, uint64(len(m.PeerId)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintCoordinator(dAtA []byte, offset int, v uint64) int {
offset -= sovCoordinator(v)
base := offset
@ -1333,6 +1672,64 @@ func (m *SpaceStatusChangeResponse) Size() (n int) {
return n
}
func (m *NetworkConfigurationRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.ConfigurationId)
if l > 0 {
n += 1 + l + sovCoordinator(uint64(l))
}
return n
}
func (m *NetworkConfigurationResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.ConfigurationId)
if l > 0 {
n += 1 + l + sovCoordinator(uint64(l))
}
if len(m.Nodes) > 0 {
for _, e := range m.Nodes {
l = e.Size()
n += 1 + l + sovCoordinator(uint64(l))
}
}
return n
}
func (m *Node) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.PeerId)
if l > 0 {
n += 1 + l + sovCoordinator(uint64(l))
}
if len(m.Addresses) > 0 {
for _, s := range m.Addresses {
l = len(s)
n += 1 + l + sovCoordinator(uint64(l))
}
}
if len(m.Types) > 0 {
l = 0
for _, e := range m.Types {
l += sovCoordinator(uint64(e))
}
n += 1 + sovCoordinator(uint64(l)) + l
}
return n
}
func sovCoordinator(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
@ -2535,6 +2932,387 @@ func (m *SpaceStatusChangeResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *NetworkConfigurationRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: NetworkConfigurationRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: NetworkConfigurationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ConfigurationId", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthCoordinator
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthCoordinator
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ConfigurationId = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipCoordinator(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthCoordinator
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *NetworkConfigurationResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: NetworkConfigurationResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: NetworkConfigurationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ConfigurationId", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthCoordinator
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthCoordinator
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ConfigurationId = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthCoordinator
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthCoordinator
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Nodes = append(m.Nodes, &Node{})
if err := m.Nodes[len(m.Nodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipCoordinator(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthCoordinator
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Node) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Node: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthCoordinator
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthCoordinator
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.PeerId = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthCoordinator
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthCoordinator
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 3:
if wireType == 0 {
var v NodeType
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= NodeType(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Types = append(m.Types, v)
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthCoordinator
}
postIndex := iNdEx + packedLen
if postIndex < 0 {
return ErrInvalidLengthCoordinator
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
var elementCount int
if elementCount != 0 && len(m.Types) == 0 {
m.Types = make([]NodeType, 0, elementCount)
}
for iNdEx < postIndex {
var v NodeType
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowCoordinator
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= NodeType(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Types = append(m.Types, v)
}
} else {
return fmt.Errorf("proto: wrong wireType = %d for field Types", wireType)
}
default:
iNdEx = preIndex
skippy, err := skipCoordinator(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthCoordinator
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipCoordinator(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0

42
coordinator/coordinatorproto/coordinator_drpc.pb.go
View File

@ -44,6 +44,7 @@ type DRPCCoordinatorClient interface {
FileLimitCheck(ctx context.Context, in *FileLimitCheckRequest) (*FileLimitCheckResponse, error)
SpaceStatusCheck(ctx context.Context, in *SpaceStatusCheckRequest) (*SpaceStatusCheckResponse, error)
SpaceStatusChange(ctx context.Context, in *SpaceStatusChangeRequest) (*SpaceStatusChangeResponse, error)
NetworkConfiguration(ctx context.Context, in *NetworkConfigurationRequest) (*NetworkConfigurationResponse, error)
}
type drpcCoordinatorClient struct {
@ -92,11 +93,21 @@ func (c *drpcCoordinatorClient) SpaceStatusChange(ctx context.Context, in *Space
return out, nil
}
func (c *drpcCoordinatorClient) NetworkConfiguration(ctx context.Context, in *NetworkConfigurationRequest) (*NetworkConfigurationResponse, error) {
out := new(NetworkConfigurationResponse)
err := c.cc.Invoke(ctx, "/coordinator.Coordinator/NetworkConfiguration", drpcEncoding_File_coordinator_coordinatorproto_protos_coordinator_proto{}, in, out)
if err != nil {
return nil, err
}
return out, nil
}
type DRPCCoordinatorServer interface {
SpaceSign(context.Context, *SpaceSignRequest) (*SpaceSignResponse, error)
FileLimitCheck(context.Context, *FileLimitCheckRequest) (*FileLimitCheckResponse, error)
SpaceStatusCheck(context.Context, *SpaceStatusCheckRequest) (*SpaceStatusCheckResponse, error)
SpaceStatusChange(context.Context, *SpaceStatusChangeRequest) (*SpaceStatusChangeResponse, error)
NetworkConfiguration(context.Context, *NetworkConfigurationRequest) (*NetworkConfigurationResponse, error)
}
type DRPCCoordinatorUnimplementedServer struct{}
@ -117,9 +128,13 @@ func (s *DRPCCoordinatorUnimplementedServer) SpaceStatusChange(context.Context,
return nil, drpcerr.WithCode(errors.New("Unimplemented"), drpcerr.Unimplemented)
}
func (s *DRPCCoordinatorUnimplementedServer) NetworkConfiguration(context.Context, *NetworkConfigurationRequest) (*NetworkConfigurationResponse, error) {
return nil, drpcerr.WithCode(errors.New("Unimplemented"), drpcerr.Unimplemented)
}
type DRPCCoordinatorDescription struct{}
func (DRPCCoordinatorDescription) NumMethods() int { return 4 }
func (DRPCCoordinatorDescription) NumMethods() int { return 5 }
func (DRPCCoordinatorDescription) Method(n int) (string, drpc.Encoding, drpc.Receiver, interface{}, bool) {
switch n {
@ -159,6 +174,15 @@ func (DRPCCoordinatorDescription) Method(n int) (string, drpc.Encoding, drpc.Rec
in1.(*SpaceStatusChangeRequest),
)
}, DRPCCoordinatorServer.SpaceStatusChange, true
case 4:
return "/coordinator.Coordinator/NetworkConfiguration", drpcEncoding_File_coordinator_coordinatorproto_protos_coordinator_proto{},
func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
return srv.(DRPCCoordinatorServer).
NetworkConfiguration(
ctx,
in1.(*NetworkConfigurationRequest),
)
}, DRPCCoordinatorServer.NetworkConfiguration, true
default:
return "", nil, nil, nil, false
}
@ -231,3 +255,19 @@ func (x *drpcCoordinator_SpaceStatusChangeStream) SendAndClose(m *SpaceStatusCha
}
return x.CloseSend()
}
type DRPCCoordinator_NetworkConfigurationStream interface {
drpc.Stream
SendAndClose(*NetworkConfigurationResponse) error
}
type drpcCoordinator_NetworkConfigurationStream struct {
drpc.Stream
}
func (x *drpcCoordinator_NetworkConfigurationStream) SendAndClose(m *NetworkConfigurationResponse) error {
if err := x.MsgSend(m, drpcEncoding_File_coordinator_coordinatorproto_protos_coordinator_proto{}); err != nil {
return err
}
return x.CloseSend()
}

34
coordinator/coordinatorproto/protos/coordinator.proto
View File

@ -18,6 +18,9 @@ service Coordinator {
// SpaceStatusChange changes the status of space
rpc SpaceStatusChange(SpaceStatusChangeRequest) returns (SpaceStatusChangeResponse);
// NetworkConfiguration retrieves the latest network configuration
rpc NetworkConfiguration(NetworkConfigurationRequest) returns (NetworkConfigurationResponse);
}
message SpaceSignRequest {
@ -103,3 +106,34 @@ message SpaceStatusChangeRequest {
message SpaceStatusChangeResponse {
SpaceStatusPayload payload = 1;
}
// NetworkConfigurationRequest contains the requested configurationId, it can be empty to request the latest version
message NetworkConfigurationRequest {
string configurationId = 1;
}
// NetworkConfigurationResponse contains list of nodes
message NetworkConfigurationResponse {
string configurationId = 1;
repeated Node nodes = 2;
}
// NodeType determines the type of API that a node supports
enum NodeType {
// TreeAPI supports space/tree sync api
TreeAPI = 0;
// FileAPI support file api
FileAPI = 1;
// CoordinatorAPI supports coordinator api
CoordinatorAPI = 2;
}
// Node describes one node in the network
message Node {
// peerId - it's a peer identifier (libp2p format string) so it's an encoded publicKey
string peerId = 1;
// list of node addresses
repeated string addresses = 2;
// list of supported APIs
repeated NodeType types = 3;
}