Source Code for Module lacewing.packetloaders.client

  1  from struct import Struct 
  2   
  3  from lacewing.baseloader import _BaseLoader, _EmptyLoader 
  4  from lacewing.bitdict import BitDict 
  5  from lacewing.packetloaders.common import (_BinaryMessageMixin,  
  6      _ObjectMessageMixin) 
  7  from lacewing.packetloaders.common import (CONNECT, SET_NAME, JOIN_CHANNEL,  
  8      LEAVE_CHANNEL) 
  9   
 10  REQUEST_TYPE = Struct('<B') 
 11  FLAG_DATA = Struct('<B') 
 12  CHANNEL_DATA = Struct('<H') 
 13  SUBCHANNEL_DATA = Struct('<B') 
 14  CHANNEL_MESSAGE_DATA = Struct('<BH') 
 15  PEER_MESSAGE_DATA = Struct('<BHH') 
 16  CHANNEL_MASTER_DATA = Struct('<HBH') 
 17   
 18  MASTER_KICK, = xrange(1) 
 19   
 20  CHANNEL_FLAGS = BitDict( 
 21      'HideChannel', 
 22      'AutoClose' 
 23  ) 
 24   
 25 -class Request(_BaseLoader): 
 26      request = None 
 27      version = None 
 28      name = None 
 29      flags = None 
 30      channel = None 
 31       
 32 -    def initialize(self): 
 33          self.flags = CHANNEL_FLAGS.copy() 
 34   
 35 -    def read(self, data): 
 36          request, = REQUEST_TYPE.unpack_from(data) 
 37          data = buffer(data, 1) 
 38          self.request = request 
 39          if request == CONNECT: 
 40              self.version = str(data) 
 41          elif request == SET_NAME: 
 42              self.name = str(data) 
 43          elif request == JOIN_CHANNEL: 
 44              flags, = FLAG_DATA.unpack_from(data) 
 45              self.flags.setFlags(flags) 
 46              self.name = str(buffer(data, FLAG_DATA.size)) 
 47          elif request == LEAVE_CHANNEL: 
 48              self.channel, = CHANNEL_DATA.unpack_from(data) 
 49   
 50 -    def generate(self): 
 51          request = self.request 
 52          requestByte = REQUEST_TYPE.pack(request) 
 53          if request == CONNECT: 
 54              return requestByte + self.version 
 55          elif request == SET_NAME: 
 56              return requestByte + self.name 
 57          elif request == JOIN_CHANNEL: 
 58              return (requestByte + FLAG_DATA.pack( 
 59                  self.flags.getFlags()) + self.name) 
 60          elif request == LEAVE_CHANNEL: 
 61              return requestByte + CHANNEL_DATA.pack(self.channel) 
 62          else: 
 63              return requestByte 
 64   
 65 -class _ServerMessage(_BaseLoader): 
 66      subchannel = None 
 67 -    def read(self, data): 
 68          self.subchannel, = SUBCHANNEL_DATA.unpack_from(data) 
 69          self.readMessage(buffer(data, 1)) 
 70       
 71 -    def generate(self): 
 72          return SUBCHANNEL_DATA.pack(self.subchannel) + self.generateMessage() 
 73   
 74 -class _ChannelMessage(_BaseLoader): 
 75      subchannel = None 
 76      channel = None 
 77 -    def read(self, data): 
 78          self.subchannel, self.channel = CHANNEL_MESSAGE_DATA.unpack_from(data) 
 79          self.readMessage(buffer(data, CHANNEL_MESSAGE_DATA.size)) 
 80       
 81 -    def generate(self): 
 82          return CHANNEL_MESSAGE_DATA.pack(self.subchannel,  
 83              self.channel) + self.generateMessage() 
 84   
 85 -class _PeerMessage(_BaseLoader): 
 86      subchannel = None 
 87      channel = None 
 88      peer = None 
 89 -    def read(self, data): 
 90          (self.subchannel, self.channel,  
 91              self.peer) = PEER_MESSAGE_DATA.unpack_from(data) 
 92          self.readMessage(buffer(data, PEER_MESSAGE_DATA.size)) 
 93       
 94 -    def generate(self): 
 95          return PEER_MESSAGE_DATA.pack(self.subchannel,  
 96              self.channel, self.peer) + self.generateMessage() 
 97   
 98 -class BinaryServerMessage(_BinaryMessageMixin, _ServerMessage): 
 99      pass 
100   
101 -class BinaryChannelMessage(_BinaryMessageMixin, _ChannelMessage): 
102      pass 
103   
104 -class BinaryPeerMessage(_BinaryMessageMixin, _PeerMessage): 
105      pass 
106   
107 -class ObjectServerMessage(_ObjectMessageMixin, _ServerMessage): 
108      pass 
109   
110 -class ObjectChannelMessage(_ObjectMessageMixin, _ChannelMessage): 
111      pass 
112   
113 -class ObjectPeerMessage(_ObjectMessageMixin, _PeerMessage): 
114      pass 
115   
116 -class UDPHello(_EmptyLoader): 
117      pass 
118   
119 -class Pong(_EmptyLoader): 
120      pass 
121   
122 -class ChannelMaster(_BaseLoader): 
123      channel = None 
124      action = None 
125      peer = None 
126   
127 -    def read(self, data): 
128          self.channel, self.action, self.peer = CHANNEL_MASTER_DATA.unpack_from( 
129              data) 
130       
131 -    def generate(self): 
132          return CHANNEL_MASTER_DATA.pack(self.channel, self.action, self.peer) 
133