Source Code for Module lacewing.packetloaders.server

  1  # Copyright (c) 2011 Mathias Kaerlev. 
  2  # See LICENSE for details. 
  3   
  4  from struct import Struct 
  5   
  6  from lacewing.baseloader import _BaseLoader, _EmptyLoader 
  7  from lacewing.bitdict import BitDict 
  8  from lacewing.packetloaders.common import (CONNECT, SET_NAME, JOIN_CHANNEL,  
  9      LEAVE_CHANNEL, CHANNEL_LIST) 
 10  from lacewing.packetloaders.common import (_BinaryMessageMixin,  
 11      _ObjectMessageMixin) 
 12   
 13  RESPONSE_DATA = Struct('<BB') 
 14  NAME_DATA = Struct('<B') 
 15  SUBCHANNEL_DATA = Struct('<B') 
 16  JOIN_CHANNEL_DATA = Struct('<BB') 
 17  CHANNEL_ID = Struct('<H') 
 18  YOUR_ID = Struct('<H') 
 19  PEER_DATA = Struct('<HBB') 
 20  CHANNEL_LIST_DATA = Struct('<HB') 
 21  CHANNEL_MESSAGE_DATA = Struct('<BH') 
 22  PEER_MESSAGE_DATA = Struct('<BHH') 
 23  SERVER_CHANNEL_MESSAGE_DATA = Struct('<BH') 
 24  NEW_PEER_DATA = Struct('<HHB') 
 25  PEER_LEAVE_DATA = Struct('<HH') 
 26   
 27 -class ChannelPeer(_BaseLoader): 
 28      id = None 
 29      isMaster = None 
 30      name = None 
 31       
 32 -    def read(self, data): 
 33          self.id, flags, size = PEER_DATA.unpack_from(data) 
 34          self.isMaster = flags 
 35          self.name = str(buffer(data, PEER_DATA.size, size)) 
 36          return PEER_DATA.size + size 
 37       
 38 -    def generate(self): 
 39          return PEER_DATA.pack(self.id, int(self.isMaster),  
 40              len(self.name)) + self.name 
 41   
 42 -class Response(_BaseLoader): 
 43      response = None 
 44      success = None 
 45      welcome = None 
 46      name = None 
 47      isMaster = None 
 48      channel = None 
 49      peers = None 
 50      channels = None 
 51      playerId = None 
 52      value = None 
 53   
 54 -    def read(self, data): 
 55          self.response, self.success = RESPONSE_DATA.unpack_from(data) 
 56          data = buffer(data, 2) 
 57          if self.response == CONNECT and self.success: 
 58              self.playerId, = YOUR_ID.unpack_from(data) 
 59              self.welcome = str(buffer(data, 2)) 
 60          elif self.response == SET_NAME: 
 61              size, = NAME_DATA.unpack_from(data) 
 62              self.name = str(buffer(data, 1, size)) 
 63              data = buffer(data, 1 + size) 
 64          elif self.response == JOIN_CHANNEL: 
 65              self.isMaster, size = JOIN_CHANNEL_DATA.unpack_from(data) 
 66              self.name = str(buffer(data, JOIN_CHANNEL_DATA.size, size)) 
 67              data = buffer(data, JOIN_CHANNEL_DATA.size + size) 
 68              if self.success: 
 69                  self.channel, = CHANNEL_ID.unpack_from(data) 
 70                  data = buffer(data, 2) 
 71                  self.peers = peers = [] 
 72                  while data: 
 73                      peer = ChannelPeer() 
 74                      peers.append(peer) 
 75                      bytesRead = peer.read(data) 
 76                      data = buffer(data, bytesRead) 
 77          elif self.response == LEAVE_CHANNEL: 
 78              self.channel, = CHANNEL_ID.unpack_from(data) 
 79              data = buffer(data, 2) 
 80          elif self.response == CHANNEL_LIST and self.success: 
 81              self.channels = channels = [] 
 82              while data: 
 83                  count, size = CHANNEL_LIST_DATA.unpack_from(data) 
 84                  name = buffer(data, CHANNEL_LIST_DATA.size, size) 
 85                  data = buffer(data, CHANNEL_LIST_DATA.size + size) 
 86                  channels.append((name, count)) 
 87          if not self.success: 
 88              self.value = str(data) 
 89       
 90 -    def addPeer(self, name, id, isMaster): 
 91          if self.peers is None: 
 92              self.peers = [] 
 93          peer = ChannelPeer() 
 94          peer.id = id 
 95          peer.isMaster = isMaster 
 96          peer.name = name 
 97          self.peers.append(peer) 
 98   
 99 -    def generate(self): 
100          data = RESPONSE_DATA.pack(self.response, self.success) 
101          if self.response == CONNECT: 
102              data += YOUR_ID.pack(self.playerId or 0) 
103              data += self.welcome or '' 
104          elif self.response == SET_NAME: 
105              data += NAME_DATA.pack(len(self.name)) + self.name 
106          elif self.response == JOIN_CHANNEL: 
107              data += JOIN_CHANNEL_DATA.pack( 
108                  int(self.isMaster or 0), len(self.name)) + self.name 
109              if self.success: 
110                  data += CHANNEL_ID.pack(self.channel) 
111                  for item in self.peers or (): 
112                      data += item.generate() 
113          elif self.response == LEAVE_CHANNEL: 
114              data += CHANNEL_ID.pack(self.channel) 
115          elif self.response == CHANNEL_LIST and self.success: 
116              for (name, count) in self.channels: 
117                  data += CHANNEL_LIST_DATA.pack(count, len(name)) + name 
118          if not self.success: 
119              data += self.value or '' 
120          return data 
121   
122 -class _ServerMessage(_BaseLoader): 
123      subchannel = None 
124 -    def read(self, data): 
125          self.subchannel, = SUBCHANNEL_DATA.unpack_from(data) 
126          self.readMessage(buffer(data, 1)) 
127       
128 -    def generate(self): 
129          return SUBCHANNEL_DATA.pack(self.subchannel) + self.generateMessage() 
130   
131 -class _PeerMessage(_BaseLoader): 
132      subchannel = None 
133      channel = None 
134      peer = None 
135 -    def read(self, data): 
136          (self.subchannel, self.channel,  
137              self.peer) = PEER_MESSAGE_DATA.unpack_from(data) 
138          self.readMessage(buffer(data, PEER_MESSAGE_DATA.size)) 
139       
140 -    def generate(self): 
141          return PEER_MESSAGE_DATA.pack(self.subchannel,  
142              self.channel, self.peer) + self.generateMessage() 
143   
144 -class _ServerChannelMessage(_BaseLoader): 
145      subchannel = None 
146      channel = None 
147 -    def read(self, data): 
148          (self.subchannel,  
149              self.channel) = SERVER_CHANNEL_MESSAGE_DATA.unpack_from(data) 
150          self.readMessage(buffer(data, SERVER_CHANNEL_MESSAGE_DATA.size)) 
151       
152 -    def generate(self): 
153          return SERVER_CHANNEL_MESSAGE_DATA.pack(self.subchannel,  
154              self.channel) + self.generateMessage() 
155   
156 -class BinaryServerMessage(_BinaryMessageMixin, _ServerMessage): 
157      pass 
158   
159 -class BinaryChannelMessage(_BinaryMessageMixin, _PeerMessage): 
160      pass 
161   
162 -class BinaryPeerMessage(_BinaryMessageMixin, _PeerMessage): 
163      pass 
164   
165 -class BinaryServerChannelMessage(_BinaryMessageMixin, _ServerChannelMessage): 
166      pass 
167   
168 -class ObjectServerMessage(_ObjectMessageMixin, _ServerMessage): 
169      pass 
170   
171 -class ObjectChannelMessage(_ObjectMessageMixin, _PeerMessage): 
172      pass 
173   
174 -class ObjectPeerMessage(_ObjectMessageMixin, _PeerMessage): 
175      pass 
176   
177 -class ObjectServerChannelMessage(_ObjectMessageMixin, _ServerChannelMessage): 
178      pass 
179   
180 -class Peer(_BaseLoader): 
181      channel = None 
182      peer = None 
183      isMaster = None 
184      name = None 
185       
186 -    def read(self, data): 
187          if len(data) == PEER_LEAVE_DATA.size: 
188              self.channel, self.peer = PEER_LEAVE_DATA.unpack_from(data) 
189          else: 
190              self.channel, self.peer, self.isMaster = NEW_PEER_DATA.unpack_from( 
191                  data) 
192              self.name = str(buffer(data, NEW_PEER_DATA.size)) 
193       
194 -    def generate(self): 
195          if self.isMaster is None and self.name is None: 
196              return PEER_LEAVE_DATA.pack(self.channel, self.peer) 
197          else: 
198              return NEW_PEER_DATA.pack(self.channel, self.peer,  
199                  self.isMaster) + self.name 
200   
201 -class UDPWelcome(_EmptyLoader): 
202      pass 
203   
204 -class Ping(_EmptyLoader): 
205      pass 
206