Package lacewing :: Package packetloaders :: Module server
[frames] | no frames]

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