pmsg-scon-opt.py
-- Zoom.Quiet [2004-09-04 04:14:46]
Contents
1 # -*- coding: gbk -*-
2 """minimic 协议信息包处理 Otter 目标代码优化尝试
3 """
4 import string
5 import struct
6 import zlib
7 import cPickle
8 pickle cPickle
9 from minimic.message import bytemsg
10
11 class minimicPMessage(bytemsg.ByteMessage):
12 """minimicP 消息基类"""
13 def __init__(self):
14 # 消息头
15 self.head = bytemsg.ByteMessageHead(self)
16 # 消息体
17 self.body = bytemsg.ByteMessageBody(self)
18 # 消息工具
19 self.msgutilcls = minimicPMessageUtil
20 # 协议名称
21 self.protocolname = 'minimicp'
22 # 当前的消息名称
23 self.msgname = ''
24 # 解包长度计数
25 self.lg = 0
26 def pack-s(self,key,value):
27 """定长字串数据打包
28 """
29 return struct.pack(key,value)
30 def unpack-s(self,key,value):
31 """定长字串数据解包
32 """
33 pass
34 def pack-I(self,value):
35 """整数数据打包
36 """
37 return struct.pack("I",value)
38 def unpack-I(self,key,value):
39 """整数数据解包
40 """
41 pass
42 def pack-v(self,fstr,lg,value):
43 """变长字串数据打包
44 """
45 return struct.pack(fstr,lg,value)
46 def unpack-v(self,key,value):
47 """变长字串数据解包
48 """
49 pass
50 def pack-z(self,fstr,lg,value):
51 """压缩字符串打包
52 """
53 return struct.pack(fstr,lg,value)
54 def unpack-z(self,key,value):
55 """压缩字符串解包
56 """
57 pass
58
59 def pack-Z(self,fstr,lg,value):
60 """压缩序列化对象打包
61 """
62 return struct.pack(fstr,lg,value)
63 def unpack-Z(self,key,value):
64 """压缩序列化对象解包
65 """
66 pass
67
68 def pack-F(self,fields,key,actdict):
69 """浮动复合数据打包
70 - fields 应用传入的全部数据
71 - key "F"数据类别索引
72 - actdict 对应数据集合结构定义
73 """
74 body = ''
75 body += struct.pack('I', len(fields[key]))
76 i = 0
77 while i < len(fields[key]):
78 body += self.smartpack(fields[key][i],actdict)
79 i += 1
80 return body
81
82 def agentfloatunp(self,field,datadict,bodyfield):
83 """浮动复合数据解包辅助，专门进行复合包的内容解包
84 - field 应用传入的对应一段数据类型
85 - datadict 对应剩余数据
86 - bodyfield 回填对应的全局字典结点
87 """
88 if "s" == field[0]:
89 packstr = datadict[self.lg:]
90 stt = field[2]+field[0]
91 lg = struct.calcsize(stt)
92 bodyfield[field[1]] = struct.unpack(stt,packstr)
93 return lg
94 elif "I" == field[0]:
95 packstr = datadict[self.lg:]
96 lg = 4
97 bodyfield[field[1]] = struct.unpack("I",packstr)
98 return lg
99 elif "v" == field[0]: # "v"变长字串=4位整数长度信息+自声明长度 的字串
100 packet = packet[self.lg:]
101 lg = struct.unpack('I', packet[:4])
102 packet = packet[4:]
103 bodyfield[field[1]] = struct.unpack(str(lg)+'s', packet[:lg])
104 return 4+lg
105 elif "z" == field[0]: # "v"变长字串=4位整数长度信息+自声明长度的压缩字串
106 packet = packet[self.lg:]
107 lg = struct.unpack('I', packet[:4])
108 packet = packet[4:]
109 bodyfield[field[1]] = zlib.decompress( \
110 struct.unpack(str(lg)+'s', packet[:lg]))
111 return 4+lg
112 elif "Z" == field[0]: # "v"变长字串=4位整数长度信息+自声明长度的串行化对象字串
113 packet = packet[self.lg:]
114 lg = struct.unpack('I', packet[:4])
115 packet = packet[4:]
116 bodyfield[field[1]] = pickle.loads( \
117 zlib.decompress(struct.unpack(str(lg)+'s', packet[:lg])
118 )
119 )
120 return 4+lg
121
122 def smartfloatunp(self,dictli,packet,bodyfield):
123 """智能浮动复合数据解包
124 - dictli 复合包结构声明字典列表
125 - packet 对应剩余数据
126 - bodyfield 回填对应的全局字典结点
127 """
128 for part in dictli
129 self.lg += self.agentfloatunp(part,packet,bodyfield)
130
131 def unpack-F(self,key,dictli,loop,value):
132 """浮动复合数据解包
133 - key self.body.fields回填索引
134 - dictli 复合包结构声明字典列表
135 - loop 复合包总数！
136 - value 对应剩余数据
137 """
138 packet = value
139 self.body.fields[key] = []
140 i = 0
141 #fixedstt = '64s16sII'
142 #fixedlen = struct.calcsize(fixedstt)
143 while i < loop:
144 for field in actdict:
145 self.smartfloatunp(dictli,packet,self.body.fields[key][i])
146 i += 1
147
148
149 def smartagent(self,field,datadict,todotp):
150 """智能代理，根据行为类型，以及数据类型自动分配处理函式
151 - field 应用传入的对应一段数据类型
152 - datadict 应用传入的数据包
153 - todotp [pack|unpack]即[进行打包|进行解包]
154 """
155 if "pack" == todotp: # 进行数据打包
156 if "s" == field[0]:
157 key = field[2]+field[0]
158 return self.pack-s(key,datadict[field[1]])
159 elif "I" == field[0]:
160 return self.pack-I(datadict[field[1]])
161 elif "v" == field[0]:
162 lg = len(datadict[field[1]])
163 return self.pack-v('I'+str(lg)+'s',lg,datadict[field[1]])
164 elif "z" == field[0]:
165 zdata = zlib.compress(datadict[field[1]])
166 lg = len(zdata)
167 return self.pack-z('I'+str(lg)+'s',lg,zdata)
168 elif "Z" == field[0]:
169 zdata = zlib.compress(pickle.dumps(datadict[field[1]]))
170 lg = len(zdata)
171 return self.pack-Z('I'+str(lg)+'s',lg,zdata)
172 else: # "F"浮动复合数据！
173 return self.pack-F(datadict,field[1],field[2])
174
175 else: ## 对应解包处理
176
177 if "s" == field[0]:
178 packstr = datadict[self.lg:]
179 stt = field[2]+field[0]
180 lg = struct.calcsize(stt)
181 self.body.fields[field[1]] = struct.unpack(stt,packstr)
182 return lg
183 elif "I" == field[0]:
184 packstr = datadict[self.lg:]
185 lg = 4
186 self.body.fields[field[1]] = struct.unpack("I",packstr)
187 return lg
188 elif "v" == field[0]: # "v"变长字串=4位整数长度信息+自声明长度 的字串
189 packet = packet[self.lg:]
190 lg = struct.unpack('I', packet[:4])
191 packet = packet[4:]
192 self.body.fields[field[1]] = struct.unpack(str(lg)+'s', packet[:lg])
193 return 4+lg
194
195 elif "z" == field[0]: # "v"变长字串=4位整数长度信息+自声明长度的压缩字串
196 packet = packet[self.lg:]
197 lg = struct.unpack('I', packet[:4])
198 packet = packet[4:]
199 self.body.fields[field[1]] = zlib.decompress( \
200 struct.unpack(str(lg)+'s', packet[:lg]))
201 return 4+lg
202
203 elif "Z" == field[0]: # "v"变长字串=4位整数长度信息+自声明长度的串行化对象字串
204 packet = packet[self.lg:]
205 lg = struct.unpack('I', packet[:4])
206 packet = packet[4:]
207 self.body.fields[field[1]] = pickle.loads( \
208 zlib.decompress(struct.unpack(str(lg)+'s', packet[:lg])
209 )
210 )
211 return 4+lg
212 else: # "F"浮动复合数据！
213 packet = packet[self.lg:] # 得到当前处理的剩余数据字串
214 floatlg = struct.unpack('I', packet[:4])
215 packet = packet[4:]
216 lg = self.unpack-F(field[1],field[2],floatlg,packet)
217 return lg
218
219 def smartpack(self,fields,actdict):
220 """智能打包
221 - 应用传入的值字典
222 - 对应的配置XML处理行为字典
223 """
224 mess = ""
225 if 0 == len(actdict): #空报文
226 return None
227 else:
228 for actfield in actdict:
229 mess +=self.smartagent(actfield,fields,"pack")
230 return mess
231
232 def smartunpack(self,packet,actdict):
233 """智能数据解包
234 """
235 if 0 == len(actdict): #空报文
236 pass
237 else:
238 for field in actdict:
239 self.lg += self.smartagent(field,packet,"unpack")
240
241
242 ### 示范代码，列举最典型的三类数据包的处理！
243 ##
244 #
245
246 def pack_minimicp_connect(self, fields):
247 """connect报文打包"""
248 actdict=[
249 ("s","system_id",6)
250 ,("s","auth_source",16)
251 ,("I","version",)
252 ,("v","test",)
253 ,("z","zip",)
254 ,("Z","szip",)
255 ,("s","time_stamp",8)
256 ]
257 message = self.smartpack(fields,actdict)
258 return message
259
260 def unpack_minimicp_connect(self, packet):
261 """connect报文解包"""
262 actdict=[
263 ("s","system_id",6)
264 ,("s","auth_source",16)
265 ,("I","version",)
266 ,("v","test",)
267 ,("z","zip",)
268 ,("Z","szip",)
269 ,("s","time_stamp",8)
270 ]
271 self.smartunpack(packet,actdict)
272
273
274 def pack_minimicp_terminate(self, fields):
275 """terminate报文体为空"""
276 actdict=[]
277 message = self.smartpack(fields,actdict)
278 return message
279
280 def unpack_minimicp_terminate(self, packet):
281 """terminate报文体为空"""
282 actdict=[]
283 self.smartunpack(packet,actdict)
284
285
286 def pack_minimicp_get_webmail_list_resp(self, fields):
287 """含有 'F'的复合活动数据报文
288 """
289 if fields['status'] == 0:
290 actdict=[
291 ("I","status",)
292 ,("I","dataid",)
293 ,("I","order",)
294 ,("v","test",)
295 ,("z","zip",)
296 ,("Z","szip",)
297 ,("F","maillist",[
298 ("s","filename",64)
299 ,("v","subject",)
300 ,("s","date",16)
301 ,("I","size",)
302 ,("I","flag",)
303 ]
304 )
305 ]
306 message = self.smartpack(fields,actdict)
307 return message
308 else:
309 return struct.pack('I', \
310 fields['status'])
311
312 def unpack_minimicp_get_webmail_list_resp(self, packet):
313 """含有 'F'的复合活动数据报文
314 """
315 (self.body.fields['status'],) = struct.unpack('I', packet)
316 if self.body.fields['status'] == 0:
317 actdict=[
318 ("I","status",)
319 ,("I","dataid",)
320 ,("I","order",)
321 ,("v","test",)
322 ,("z","zip",)
323 ,("Z","szip",)
324 ,("F","maillist",[
325 ("s","filename",64)
326 ,("v","subject",)
327 ,("s","date",16)
328 ,("I","size",)
329 ,("I","flag",)
330 ]
331 )
332 ]
333 message = self.smartunpack(fields,actdict)
334 else:
335 pass