-
Notifications
You must be signed in to change notification settings - Fork 0
/
server.go
184 lines (153 loc) · 4.57 KB
/
server.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
package adrpc
import (
"adrpc/codec"
"fmt"
"log"
"net"
"reflect"
"strings"
)
//以下方法按时间顺序排列,创建---注册服务------
///接受连接-------读取到来信息------处理请求-------调用服务------发送回信
func NewServer(magicnumber uint64) *Server {
server := Server{
MagicNumber: uint64(magicnumber),
Services: make(map[string]*service),
}
return &server
}
func (server *Server) StartServer(port string) {
listen, err := net.Listen("tcp", port)
if err != nil {
fmt.Print("server listen create failed")
}
for {
code := server.Accept(listen, codec.JsonType)
h, b, s, m := server.Read(*code)
fmt.Println(b.Args)
if h == nil {
log.Println("head is nil ")
continue
}
if b == nil {
log.Println("from " + string(h.Clientid) + " body is nil")
continue
}
req := server.NewRequest(h, b, s, m)
req.Args = req.Methodt.newArgv()
req.Reply = req.Methodt.newReplyv()
// make sure that argvi is a pointer, ReadBody need a pointer as parameter
//原来真的是可以先预设反射类型,然后把用编码器把interface编码成字节数组,然后解码到反射的输入接口
argvi := req.Args.Interface()
if req.Args.Type().Kind() != reflect.Ptr {
argvi = req.Args.Addr().Interface()
}
if err = (*code).ReadBody(argvi); err != nil {
log.Println("rpc server: read body err:", err)
return
}
// fmt.Println("argvi:", argvi)
// fmt.Println("接受到的args:", req.Args.Interface())
server.GetReply(req)
server.Send(*code, req)
}
}
func (server *Server) Register(newStruct interface{}) bool {
servicex := NewService(newStruct)
server.mu.Lock()
server.Services[servicex.Name] = servicex
server.mu.Unlock()
return true
}
func (server *Server) Accept(lis net.Listener, encodingType codec.Type) *codec.Codec {
conn, err := lis.Accept()
if err != nil {
log.Println("server accept error:", err)
}
codefun := codec.NewCodecFuncMap[encodingType]
request := codefun(conn)
return &request
}
func (server *Server) Read(request codec.Codec) (*Header, *Body, *service, *methodType) {
var h Header
var err error
err = request.ReadHeader(&h)
if err != nil {
log.Println("server rpc read header error", err)
return nil, nil, nil, nil
}
server.mu.Lock()
ok := h.MagicNumber != server.MagicNumber
server.mu.Unlock()
if ok {
log.Println("server rpc read header magicnumber is incorrect")
// err = errors.New("magicnumber is incorrect")
return &h, nil, nil, nil
}
service, method := server.Find(h.ServiceMethod)
body := Body{}
// err = request.ReadBody(&body)
if err != nil {
log.Println("server rpc read header error", err)
return &h, &body, service, method
}
return &h, &body, service, method
}
func (server *Server) Find(serviceMethod string) (*service, *methodType) {
dot := strings.LastIndex(serviceMethod, ".")
serviceName, methodName := serviceMethod[:dot], serviceMethod[dot+1:]
servicex, err := server.Services[serviceName]
if err == false {
return nil, nil
}
method, err := servicex.Method[methodName]
if err == false {
return servicex, nil
}
return servicex, method
}
func (server *Server) NewRequest(h *Header, b *Body, s *service, m *methodType) *Request {
req := Request{
RH: h,
Args: m.newArgv(), //而此时有参数类型是interface{},我想把它转化想要的已经存储在m.ArgType的类型
Reply: m.newReplyv(),
Service: s,
Methodt: m,
}
// fmt.Println("反射args:", req.Args.Interface())
return &req
}
func (server *Server) GetReply(request *Request) {
// servicex.Call(method, request.Args, request.Reply)
// prebody.err = nil
request.Service.Call(request.Methodt, request.Args, request.Reply)
}
// func (server *Server) Handle(body *Body) error {
// fmt.Println(*body)
// dot := strings.LastIndex(body.ServiceMethod, ".")
// serviceName, methodName := body.ServiceMethod[:dot], body.ServiceMethod[dot+1:]
// servicex, err := server.Services[serviceName]
// if err == false {
// log.Println("server rpc no service")
// body.err = errors.New("server rpc no service")
// return body.err
// }
// method, err := servicex.Method[methodName]
// if err == false {
// log.Println("server rpc service:", servicex.Name, "has no ", methodName)
// body.err = errors.New("server rpc service:" + servicex.Name + "has no " + methodName)
// return body.err
// }
// return nil
// }
func (server *Server) Send(code codec.Codec, req *Request) error {
b := Body{
Args: req.Args.Interface(),
Reply: req.Reply.Interface(),
err: nil,
}
server.sending.Lock()
err := code.Write(&req.RH, &b)
server.sending.Unlock()
return err
}