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( \
                struct.unpack(str(lg)+'s', packet[:lg]))
 110             return 4+lg
 111         elif "Z" == field[0]:   # "v"变长字串=4位整数长度信息+自声明长度的串行化对象字串
 112             packet = packet[self.lg:]
 113             lg = struct.unpack('I', packet[:4])
 114             packet = packet[4:]
 115             bodyfield[field[1]] = pickle.loads( \
                zlib.decompress(struct.unpack(str(lg)+'s', packet[:lg])
 116                                 )
 117                             )
 118             return 4+lg
 119 
 120     def smartfloatunp(self,dictli,packet,bodyfield):
 121         """智能浮动复合数据解包
 122             - dictli 复合包结构声明字典列表
 123             - packet 对应剩余数据
 124             - bodyfield 回填对应的全局字典结点
 125         """
 126         for part in dictli
 127             self.lg += self.agentfloatunp(part,packet,bodyfield)
 128 
 129     def unpack-F(self,key,dictli,loop,value):
 130         """浮动复合数据解包
 131             - key self.body.fields回填索引
 132             - dictli 复合包结构声明字典列表
 133             - loop 复合包总数!
 134             - value 对应剩余数据
 135         """
 136         packet = value
 137         self.body.fields[key] = []
 138         i = 0
 139         #fixedstt = '64s16sII'
 140         #fixedlen = struct.calcsize(fixedstt)
 141         while i < loop:
 142             for field in actdict:
 143                 self.smartfloatunp(dictli,packet,self.body.fields[key][i])
 144             i += 1
 145 
 146 
 147     def smartagent(self,field,datadict,todotp):
 148         """智能代理,根据行为类型,以及数据类型自动分配处理函式
 149             - field 应用传入的对应一段数据类型
 150             - datadict 应用传入的数据包
 151             - todotp [pack|unpack]即[进行打包|进行解包]
 152         """
 153         if "pack" == todotp:    # 进行数据打包
 154             if "s" == field[0]:
 155                 key = field[2]+field[0]
 156                 return self.pack-s(key,datadict[field[1]])
 157             elif "I" == field[0]:
 158                 return self.pack-I(datadict[field[1]])
 159             elif "v" == field[0]:
 160                 lg = len(datadict[field[1]])
 161                 return self.pack-v('I'+str(lg)+'s',lg,datadict[field[1]])
 162             elif "z" == field[0]:
 163                 zdata = zlib.compress(datadict[field[1]])
 164                 lg = len(zdata)
 165                 return self.pack-z('I'+str(lg)+'s',lg,zdata)
 166             elif "Z" == field[0]:
 167                 zdata = zlib.compress(pickle.dumps(datadict[field[1]]))
 168                 lg = len(zdata)
 169                 return self.pack-Z('I'+str(lg)+'s',lg,zdata)
 170             else:       # "F"浮动复合数据!
 171                 return self.pack-F(datadict,field[1],field[2])
 172 
 173         else:           ## 对应解包处理
 174 
 175             if "s" == field[0]:
 176                 packstr = datadict[self.lg:]
 177                 stt = field[2]+field[0]
 178                 lg = struct.calcsize(stt)
 179                 self.body.fields[field[1]] = struct.unpack(stt,packstr)
 180                 return lg
 181             elif "I" == field[0]:
 182                 packstr = datadict[self.lg:]
 183                 lg = 4
 184                 self.body.fields[field[1]] = struct.unpack("I",packstr)
 185                 return lg
 186             elif "v" == field[0]:   # "v"变长字串=4位整数长度信息+自声明长度 的字串
 187                 packet = packet[self.lg:]
 188                 lg = struct.unpack('I', packet[:4])
 189                 packet = packet[4:]
 190                 self.body.fields[field[1]] = struct.unpack(str(lg)+'s', packet[:lg])
 191                 return 4+lg
 192 
 193             elif "z" == field[0]:   # "v"变长字串=4位整数长度信息+自声明长度的压缩字串
 194                 packet = packet[self.lg:]
 195                 lg = struct.unpack('I', packet[:4])
 196                 packet = packet[4:]
 197                 self.body.fields[field[1]] = zlib.decompress( \
                    struct.unpack(str(lg)+'s', packet[:lg]))
 198                 return 4+lg
 199 
 200             elif "Z" == field[0]:   # "v"变长字串=4位整数长度信息+自声明长度的串行化对象字串
 201                 packet = packet[self.lg:]
 202                 lg = struct.unpack('I', packet[:4])
 203                 packet = packet[4:]
 204                 self.body.fields[field[1]] = pickle.loads( \
                    zlib.decompress(struct.unpack(str(lg)+'s', packet[:lg])
 205                                     )
 206                                 )
 207                 return 4+lg
 208             else:       # "F"浮动复合数据!
 209                 packet = packet[self.lg:]   # 得到当前处理的剩余数据字串
 210                 floatlg = struct.unpack('I', packet[:4])
 211                 packet = packet[4:]
 212                 lg = self.unpack-F(field[1],field[2],floatlg,packet)
 213                 return lg
 214 
 215     def smartpack(self,fields,actdict):
 216         """智能打包
 217             - 应用传入的值字典
 218             - 对应的配置XML处理行为字典
 219         """
 220         mess = ""
 221         if 0 == len(actdict):   #空报文
 222             return None
 223         else:
 224             for actfield in actdict:
 225                 mess +=self.smartagent(actfield,fields,"pack")
 226             return mess
 227 
 228     def smartunpack(self,packet,actdict):
 229         """智能数据解包
 230         """
 231         if 0 == len(actdict):   #空报文
 232             pass
 233         else:
 234             for field in actdict:
 235                 self.lg += self.smartagent(field,packet,"unpack")
 236 
 237 
 238     ###     示范代码,列举最典型的三类数据包的处理!
 239     ##
 240     # 
 241 
 242     def pack_minimicp_connect(self, fields):
 243         """connect报文打包"""
 244         actdict=[
 245             ("s","system_id",6)
 246             ,("s","auth_source",16)
 247             ,("I","version",)
 248             ,("v","test",)
 249             ,("z","zip",)
 250             ,("Z","szip",)
 251             ,("s","time_stamp",8)
 252             ]
 253         message = self.smartpack(fields,actdict)
 254         return message
 255 
 256     def unpack_minimicp_connect(self, packet):
 257         """connect报文解包"""
 258         actdict=[
 259             ("s","system_id",6)
 260             ,("s","auth_source",16)
 261             ,("I","version",)
 262             ,("v","test",)
 263             ,("z","zip",)
 264             ,("Z","szip",)
 265             ,("s","time_stamp",8)
 266             ]
 267         self.smartunpack(packet,actdict)
 268 
 269 
 270     def pack_minimicp_terminate(self, fields):
 271         """terminate报文体为空"""
 272         actdict=[]
 273         message = self.smartpack(fields,actdict)
 274         return message
 275 
 276     def unpack_minimicp_terminate(self, packet):
 277         """terminate报文体为空"""
 278         actdict=[]
 279         self.smartunpack(packet,actdict)
 280 
 281 
 282     def pack_minimicp_get_webmail_list_resp(self, fields):
 283         """含有 'F'的复合活动数据报文
 284         """
 285         if fields['status'] == 0:
 286             actdict=[
 287                 ("I","status",)
 288                 ,("I","dataid",)
 289                 ,("I","order",)
 290                 ,("v","test",)
 291                 ,("z","zip",)
 292                 ,("Z","szip",)
 293                 ,("F","maillist",[
 294                     ("s","filename",64)
 295                     ,("v","subject",)
 296                     ,("s","date",16)
 297                     ,("I","size",)
 298                     ,("I","flag",)
 299                     ]
 300                  )
 301                 ]
 302             message = self.smartpack(fields,actdict)
 303             return message
 304         else:
 305             return struct.pack('I', \
                fields['status'])
 306 
 307     def unpack_minimicp_get_webmail_list_resp(self, packet):
 308         """含有 'F'的复合活动数据报文
 309         """
 310         (self.body.fields['status'],) = struct.unpack('I', packet)
 311         if self.body.fields['status'] == 0:
 312             actdict=[
 313                 ("I","status",)
 314                 ,("I","dataid",)
 315                 ,("I","order",)
 316                 ,("v","test",)
 317                 ,("z","zip",)
 318                 ,("Z","szip",)
 319                 ,("F","maillist",[
 320                     ("s","filename",64)
 321                     ,("v","subject",)
 322                     ,("s","date",16)
 323                     ,("I","size",)
 324                     ,("I","flag",)
 325                     ]
 326                  )
 327                 ]
 328             message = self.smartunpack(fields,actdict)
 329         else:
 330             pass