-
Notifications
You must be signed in to change notification settings - Fork 146
Expand file tree
/
Copy pathproto.go
More file actions
184 lines (154 loc) · 4.17 KB
/
proto.go
File metadata and controls
184 lines (154 loc) · 4.17 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
/*
* Copyright 2018 The CovenantSQL Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Package proto contains DHT RPC protocol struct.
package proto
import (
"context"
"fmt"
"time"
"github.com/pkg/errors"
"github.com/CovenantSQL/CovenantSQL/crypto/hash"
)
//go:generate hsp
//hsp:shim time.Duration as:int64 using:int64/int64 mode:cast
// EnvelopeAPI defines envelope access functions for rpc Request/Response.
type EnvelopeAPI interface {
GetVersion() string
GetTTL() time.Duration
GetExpire() time.Duration
GetNodeID() *RawNodeID
GetContext() context.Context
SetVersion(string)
SetTTL(time.Duration)
SetExpire(time.Duration)
SetNodeID(*RawNodeID)
SetContext(context.Context)
}
// Envelope is the protocol header.
type Envelope struct {
Version string `json:"v"`
TTL time.Duration `json:"t"`
Expire time.Duration `json:"e"`
NodeID *RawNodeID `json:"id"`
_ctx context.Context
}
// PingReq is Ping RPC request.
type PingReq struct {
Node Node
Envelope
}
// PingResp is Ping RPC response, i.e. Pong.
type PingResp struct {
Msg string
Envelope
}
// UploadMetricsReq is UploadMetrics RPC request.
type UploadMetricsReq struct {
// MetricFamily Bytes array
MFBytes [][]byte
Envelope
}
// UploadMetricsResp is UploadMetrics RPC response.
type UploadMetricsResp struct {
Msg string
Envelope
}
// FindNeighborReq is FindNeighbor RPC request.
type FindNeighborReq struct {
ID NodeID
Roles []ServerRole
Count int
Envelope
}
// FindNeighborResp is FindNeighbor RPC response.
type FindNeighborResp struct {
Nodes []Node
Msg string
Envelope
}
// FindNodeReq is FindNode RPC request.
type FindNodeReq struct {
ID NodeID
Envelope
}
// FindNodeResp is FindNode RPC response.
type FindNodeResp struct {
Node *Node
Msg string
Envelope
}
// Following are envelope methods implementing EnvelopeAPI interface
// GetVersion implements EnvelopeAPI.GetVersion.
func (e *Envelope) GetVersion() string {
return e.Version
}
// GetTTL implements EnvelopeAPI.GetTTL.
func (e *Envelope) GetTTL() time.Duration {
return e.TTL
}
// GetExpire implements EnvelopeAPI.GetExpire.
func (e *Envelope) GetExpire() time.Duration {
return e.Expire
}
// GetNodeID implements EnvelopeAPI.GetNodeID.
func (e *Envelope) GetNodeID() *RawNodeID {
return e.NodeID
}
// GetContext returns context from envelop which is set in server Accept.
func (e *Envelope) GetContext() context.Context {
if e._ctx == nil {
return context.Background()
}
return e._ctx
}
// SetVersion implements EnvelopeAPI.SetVersion.
func (e *Envelope) SetVersion(ver string) {
e.Version = ver
}
// SetTTL implements EnvelopeAPI.SetTTL.
func (e *Envelope) SetTTL(ttl time.Duration) {
e.TTL = ttl
}
// SetExpire implements EnvelopeAPI.SetExpire.
func (e *Envelope) SetExpire(exp time.Duration) {
e.Expire = exp
}
// SetNodeID implements EnvelopeAPI.SetNodeID.
func (e *Envelope) SetNodeID(nodeID *RawNodeID) {
e.NodeID = nodeID
}
// SetContext set a ctx in envelope.
func (e *Envelope) SetContext(ctx context.Context) {
e._ctx = ctx
}
// DatabaseID is database name, will be generated from UUID.
type DatabaseID string
// AccountAddress converts DatabaseID to AccountAddress.
func (d *DatabaseID) AccountAddress() (a AccountAddress, err error) {
h, err := hash.NewHashFromStr(string(*d))
if err != nil {
err = errors.Wrap(err, "fail to convert string to hash")
return
}
a = AccountAddress(*h)
return
}
// FromAccountAndNonce generates databaseID from Account and its nonce.
func FromAccountAndNonce(accountAddress AccountAddress, nonce uint32) DatabaseID {
addrAndNonce := fmt.Sprintf("%s%d", accountAddress.String(), nonce)
rawID := hash.THashH([]byte(addrAndNonce))
return DatabaseID(rawID.String())
}