-
-
Notifications
You must be signed in to change notification settings - Fork 1.2k
/
request.go
235 lines (196 loc) · 6.05 KB
/
request.go
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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
package znet
import (
"math"
"sync"
"github.com/aceld/zinx/zconf"
"github.com/aceld/zinx/ziface"
"github.com/aceld/zinx/zpack"
)
const (
PRE_HANDLE ziface.HandleStep = iota // PreHandle for pre-processing
HANDLE // Handle for processing
POST_HANDLE // PostHandle for post-processing
HANDLE_OVER
)
var RequestPool = new(sync.Pool)
func init() {
RequestPool.New = func() interface{} {
return allocateRequest()
}
}
// Request 请求
type Request struct {
ziface.BaseRequest
conn ziface.IConnection // the connection which has been established with the client(已经和客户端建立好的链接)
msg ziface.IMessage // the request data sent by the client(客户端请求的数据)
router ziface.IRouter // the router that handles this request(请求处理的函数)
steps ziface.HandleStep // used to control the execution of router functions(用来控制路由函数执行)
stepLock sync.RWMutex // concurrency lock(并发互斥)
needNext bool // whether to execute the next router function(是否需要执行下一个路由函数)
icResp ziface.IcResp // response data returned by the interceptors (拦截器返回数据)
handlers []ziface.RouterHandler // router function slice(路由函数切片)
index int8 // router function slice index(路由函数切片索引)
keys map[string]interface{} // keys 路由处理时可能会存取的上下文信息
}
func (r *Request) GetResponse() ziface.IcResp {
return r.icResp
}
func (r *Request) SetResponse(response ziface.IcResp) {
r.icResp = response
}
func NewRequest(conn ziface.IConnection, msg ziface.IMessage) ziface.IRequest {
req := new(Request)
req.steps = PRE_HANDLE
req.conn = conn
req.msg = msg
req.stepLock = sync.RWMutex{}
req.needNext = true
req.index = -1
return req
}
func GetRequest(conn ziface.IConnection, msg ziface.IMessage) ziface.IRequest {
// 根据当前模式判断是否使用对象池
if zconf.GlobalObject.RequestPoolMode {
// 从对象池中取得一个 Request 对象,如果池子中没有可用的 Request 对象则会调用 allocateRequest 函数构造一个新的对象分配
r := RequestPool.Get().(*Request)
// 因为取出的 Request 对象可能是已存在也可能是新构造的,无论是哪种情况都应该初始化再返回使用
r.Reset(conn, msg)
return r
}
return NewRequest(conn, msg)
}
func PutRequest(request ziface.IRequest) {
// 判断是否开启了对象池模式
if zconf.GlobalObject.RequestPoolMode {
RequestPool.Put(request)
}
}
func allocateRequest() ziface.IRequest {
req := new(Request)
req.steps = PRE_HANDLE
req.needNext = true
req.index = -1
return req
}
func (r *Request) Reset(conn ziface.IConnection, msg ziface.IMessage) {
r.steps = PRE_HANDLE
r.conn = conn
r.msg = msg
r.needNext = true
r.index = -1
r.keys = nil
}
// Copy 在执行路由函数的时候可能会出现需要再起一个协程的需求,但是 Request 对象由对象池管理后无法保证新协程中的 Request 参数一致
// 通过 Copy 方法复制一份 Request 对象保持创建协程时候的参数一致。但新开的协程不应该在对原始的执行过程有影响,所以不包含连接和路由对象。
// 但如果一定对连接信息有所需要可以在 Copy 后手动 set 一份参数在 Request 对象中
func (r *Request) Copy() ziface.IRequest {
// 构造一个新的 Request 对象,复制部分原始对象的参数,但是复制的 Request 不应该再对原始连接操作,所以不含有连接参数
// 同理也不应该再执行路由方法,路由函数也不包含
newRequest := &Request{
conn: nil,
router: nil,
steps: r.steps,
needNext: false,
icResp: nil,
handlers: nil,
index: math.MaxInt8,
}
// 复制原本的上下文信息
newRequest.keys = make(map[string]interface{})
for k, v := range r.keys {
newRequest.keys[k] = v
}
// 复制一份原本的 icResp
copyResp := []ziface.IcResp{r.icResp}
newIcResp := make([]ziface.IcResp, 0, 1)
copy(newIcResp, copyResp)
for _, v := range newIcResp {
newRequest.icResp = v
}
// 复制一份原本的 msg 信息
newRequest.msg = zpack.NewMessageByMsgId(r.msg.GetMsgID(), r.msg.GetDataLen(), r.msg.GetRawData())
return newRequest
}
// Set 在 Request 中存放一个上下文,如果 keys 为空会实例化一个
func (r *Request) Set(key string, value interface{}) {
r.stepLock.Lock()
if r.keys == nil {
r.keys = make(map[string]interface{})
}
r.keys[key] = value
r.stepLock.Unlock()
}
// Get 在 Request 中取出一个上下文信息
func (r *Request) Get(key string) (value interface{}, exists bool) {
r.stepLock.RLock()
value, exists = r.keys[key]
r.stepLock.RUnlock()
return
}
func (r *Request) GetMessage() ziface.IMessage {
return r.msg
}
func (r *Request) GetConnection() ziface.IConnection {
return r.conn
}
func (r *Request) GetData() []byte {
return r.msg.GetData()
}
func (r *Request) GetMsgID() uint32 {
return r.msg.GetMsgID()
}
func (r *Request) BindRouter(router ziface.IRouter) {
r.router = router
}
func (r *Request) next() {
if r.needNext == false {
r.needNext = true
return
}
r.stepLock.Lock()
r.steps++
r.stepLock.Unlock()
}
func (r *Request) Goto(step ziface.HandleStep) {
r.stepLock.Lock()
r.steps = step
r.needNext = false
r.stepLock.Unlock()
}
func (r *Request) Call() {
if r.router == nil {
return
}
for r.steps < HANDLE_OVER {
switch r.steps {
case PRE_HANDLE:
r.router.PreHandle(r)
case HANDLE:
r.router.Handle(r)
case POST_HANDLE:
r.router.PostHandle(r)
}
r.next()
}
r.steps = PRE_HANDLE
}
func (r *Request) Abort() {
if zconf.GlobalObject.RouterSlicesMode {
r.index = int8(len(r.handlers))
} else {
r.stepLock.Lock()
r.steps = HANDLE_OVER
r.stepLock.Unlock()
}
}
// BindRouterSlices New version
func (r *Request) BindRouterSlices(handlers []ziface.RouterHandler) {
r.handlers = handlers
}
func (r *Request) RouterSlicesNext() {
r.index++
for r.index < int8(len(r.handlers)) {
r.handlers[r.index](r)
r.index++
}
}