def connection_made(self, transport):
self.transport = transport
self._Deserializer = PacketType.Deserializer()
peername = transport.get_extra_info('peername')
print('server(prepare)-->client(prepare):Connection from {}'.format(
peername))
def __init__(self, loop):
self.loop = loop
self.flying_key_is_hit = False
self.got_hammer = False
self.deserializer = PacketType.Deserializer()
self.start_requesting = False
def __init__(self):
self.transport = None
self._Deserializer = PacketType.Deserializer()
self.receivedpkt = 1
def __init__(self):
self.transport = None
self._deserializer = PacketType.Deserializer()
def basicUnitTest():
print("~~~Welcome to Jukebox!~~~")
Genre = input(
"Please Enter the genre you would like to listen to! Available options - Rock/Pop/Classical/Jazz \n"
)
Genre = Genre.upper()
print(Genre)
AuthToken = input("Enter your authentication token - 3 digit\n")
if int(AuthToken) > 0:
# Packet 1 - Client Hello
ClientHello1 = ClientHello()
ClientHello1.UserAuthToken = AuthToken
ClientHello1.Genre = str(Genre)
# Sending the packet
packetBytes = ClientHello1.__serialize__()
deserializer_ClientHello = PacketType.Deserialize(packetBytes)
if deserializer_ClientHello == ClientHello1:
print(
"\nClient Hello has been successfully serialized and deserialized \n"
)
else:
print("\nHouston, we have a problem! \n")
return
# Genres
GenreList = ["ROCK", "POP", "CLASSICAL", "JAZZ"]
# AuthTokens
# UserTokens = [123,345,567,789,901]
print("==Server processing Client Hello==")
# Generating Random Session IDs
SessionID_Random = random.randint(1, 100)
# Packet 2 - Server Hello
ServerHello1 = ServerHello()
ServerHello1.SessionID = SessionID_Random
# Keeping track of all ongoing sessions
# SessionID_Random_List = []
# SessionID_Random_List.insert(0,SessionID_Random)
# Authentication token at this moment can be any 3 digit number
if re.match("^\d\d\d$", str(deserializer_ClientHello.UserAuthToken)):
ServerHello1.AuthResponse = 1
ServerHello1.RequestBitRate = "Enter the bit rate at which you would like to listen to your music"
if deserializer_ClientHello.Genre in GenreList:
ServerHello1.GenreAvailable = 1
else:
ServerHello1.GenreAvailable = 0
else:
ServerHello1.AuthResponse = 0
ServerHello1.GenreAvailable = 0
ServerHello1.RequestBitRate = "NULL"
# Sending out the Server response
packetBytes1 = ServerHello1.__serialize__()
deserializer1 = PacketType.Deserialize(packetBytes1)
if (deserializer1.GenreAvailable == True
and deserializer1.AuthResponse == 1):
print("Your requested Genre is available!")
else:
print("SERVER SIDE ERROR: Error with Genre or Username")
# Packet 3 - Client Request
ClientRequest1 = ClientRequest()
ClientRequest1.SessionID = deserializer1.SessionID
# print (ClientRequest1.SessionID)
ClientRequest1.ACKofServerHello = 1
if (deserializer1.AuthResponse == 1
and deserializer1.GenreAvailable == 1):
print("Authentication Succeeded")
# ClientRequest1.BitRate = ["320Kbps","123Kbps"]
else:
print("Authentication Failed :( ")
# ClientRequest1.BitRate = ["0"]
return (basicUnitTest())
ClientRequest1_serialize = ClientRequest1.__serialize__()
ClientRequest1_deserailze = PacketType.Deserialize(
ClientRequest1_serialize)
assert ClientRequest1_deserailze == ClientRequest1
# Packet 4 - Server Stream
ServerStream1 = ServerStream()
ServerStream1.SessionID = deserializer1.SessionID
if deserializer_ClientHello.Genre == "ROCK":
ServerStream1.Linktomusic = "https://www.youtube.com/watch?v=3_5RbI9goz4"
elif deserializer_ClientHello.Genre == "POP":
ServerStream1.Linktomusic = "https://www.youtube.com/watch?v=2VncTzuXhu0&list=PLMAV5w57ey1rYKkjhUwVpdLn3wCUTurGC"
elif deserializer_ClientHello.Genre == "CLASSICAL":
ServerStream1.Linktomusic = "https://www.youtube.com/watch?v=a-b6JgQa3EY&list=PLauX1OLju8VgJ1-oBaBDGKZeAiFav-mAE"
elif deserializer_ClientHello.Genre == "JAZZ":
ServerStream1.Linktomusic = "https://www.youtube.com/watch?v=2o4NyCE8-Zs&list=PLjBo9Ev93QFXo9_14jtlHGEir4G_omx34"
else:
ServerStream1.Linktomusic == "Unexpected error"
ServerStream1_serializer = ServerStream1.__serialize__()
# Deserializing the final response from the server.
deserializer1 = PacketType.Deserializer()
while len(ServerStream1_serializer) > 0:
chunk, ServerStream1_serializer = ServerStream1_serializer[:
10], ServerStream1_serializer[
10:]
deserializer1.update(chunk)
for packet in deserializer1.nextPackets():
if packet == ServerStream1:
print(str(packet.Linktomusic))
else:
print("Packet lost in transmission!")
else:
print("Incorrect Auth Token. Value should be anything above 0")
return (basicUnitTest())
def __init__(self):
self.loop = asyncio.get_event_loop()
self.deserializer = PacketType.Deserializer()
def __init__(self):
self.deserializer = PacketType.Deserializer()
def __init__(self, loop):
self.deserializer = PacketType.Deserializer()
self.transport = None
self.loop = loop
def connection_made(self, transport):
print("Client has been connected to server.")
self.transport = transport
self.Deserializer = PacketType.Deserializer()
def UnitTest():
# Test GetDeviceList() Packet
packet1 = GetDeviceList()
packet1.category = "lamp"
packet1.number = 1
try:
packet1Byte = packet1.__serialize__()
print("Packet1 serialize succeeded!")
except:
print("Packet1 serialize failed!")
try:
packet1a = GetDeviceList.Deserialize(packet1Byte)
assert packet1a == packet1
print("Packet1 deserialize succeeded!")
except:
print("Packet1 deserialize failed!")
#Test DeviceList() Packet
packet2 = DeviceList()
packet2.ID = 1001
packet2.name = b"table lamp"
packet2.category = "lamp"
packet2.status = b"on"
try:
packet2Byte = packet2.__serialize__()
print("Packet2 serialize succeeded!")
except:
print("Packet2 serialize failed!")
try:
packet2a = DeviceList.Deserialize(packet2Byte)
assert packet2a == packet2
print("Packet2 deserialize succeeded!")
except:
print("Packet2 deserialize failed!")
#Test ModifyDevice() Packet
packet3 = ModifyDevice()
packet3.object = 1001
packet3.operation = b"off"
try:
packet3Byte = packet3.__serialize__()
print("Packet3 serialize succeeded!")
except:
print("Packet3 serialize failed!")
try:
packet3a = ModifyDevice.Deserialize(packet3Byte)
assert packet3a == packet3
print("Packet3 deserialize succeeded!")
except:
print("Packet3 deserialize failed!")
#Test Respond() Packet
packet4 = Respond()
packet4.respond = 1001
try:
packet4Byte = packet4.__serialize__()
print("Packet4 serialize succeeded!")
except:
print("Packet4 serialize failed!")
try:
packet4a = Respond.Deserialize(packet4Byte)
assert packet4a == packet4
print("Packet4 deserialize succeeded!")
except:
print("Packet4 deserialize failed!")
packetBytes = packet4Byte + packet3Byte + packet2Byte + packet1Byte
deserializer = PacketType.Deserializer()
while len(packetBytes) > 0:
chunk, packetBytes = packetBytes[:16], packetBytes[16:]
deserializer.update(chunk)
print("Another 16 bytes loaded into deserializer.Left = {}".format(
len(packetBytes)))
for packet in deserializer.nextPackets():
print("got a packet!")
if packet == packet1:
print("It’s packet1!")
elif packet == packet2:
print("It’s packet 2!")
elif packet == packet3:
print("It’s packet 3!")
elif packet == packet4:
print("It’s packet 4!")
def connection_made(self, transport):
self.transport = transport
self._deserializer = PacketType.Deserializer()
print('Restaurant: Got Connection from a customer!')
self.status = self.WAITING
def connection_made(self, transport):
print("Received a connection")
self.transport = transport
self.deserializer = PacketType.Deserializer()
def __init__(self):
self.loop = asyncio.get_event_loop()
self.game = EscapeRoomGame()
self.deserializer = PacketType.Deserializer()
def data_received(self, data):
self.received += 1
self._Deserializer = PacketType.Deserializer()
self._Deserializer.update(data)
for pkt in self._Deserializer.nextPackets():
self.stringclass(pkt)
def connection_made(self, transport):
self._deserializer = PacketType.Deserializer()
self.transport = transport
print("Client Connected to Server ")
"""self.message = "db_connect()"
def connection_made(self, transport):
print("Server has connected to the client")
self.transport = transport
self.Deserializer = PacketType.Deserializer()
self.initiate_game(random.randint(0, 9))
def connection_made(self, transport):
print("Server Connected to Client ")
self._deserializer = PacketType.Deserializer()
self.transport = transport
def connection_made(self, transport):
client_name = transport.get_extra_info('peername')
self.transport = transport
self._deserializer = PacketType.Deserializer()
def __init__(self):
self.transport = None
self.invite('Bob', 'California', 1, 1, '10.0.0.1', 65001,
['G711u', 'G729', 'G722', 'OPUS', 'G711a'])
self._deserializer = PacketType.Deserializer()
def data_received(self, data):
print("S: Received packet")
d = PacketType.Deserializer()
d.update(data)
packets = list(d.nextPackets())
packet = packets[0]
if isinstance(packet, gc_packet_types.GameInitPacket):
username = gc_packet_types.process_game_init(packet)
print("S: {} playing".format(username))
pay_packet = gc_packet_types.create_game_require_pay_packet(
unique_id="graphchess", account="jlee662_account", amount=10)
self.transport.write(pay_packet.__serialize__())
print("S: Pay packet request sent")
elif isinstance(packet, gc_packet_types.GamePayPacket):
receipt, signature = gc_packet_types.process_game_pay_packet(
packet)
print("S: {}".format(receipt))
try:
verification = verify(bank_client=self.bank_client,
receipt_bytes=receipt,
signature_bytes=signature,
dst="jlee662_account",
amount=10,
memo="graphchess")
self.verification = verification
# Start game if verification is good
game = EscapeRoomGame()
game.output = functools.partial(write_function,
transport=self.transport,
status=game.status)
game.create_game()
game.start()
self.game = game
for a in game.agents:
asyncio.ensure_future(a)
except Exception as e:
print(e)
self.transport.write(
create_game_response_packet(response="",
status="dead").__serialize__())
self.transport.close()
elif isinstance(packet, AutogradeTestStatus):
print("S: SUBMITRESPONSE {} {} {}".format(packet.submit_status,
packet.client_status,
packet.server_status))
elif isinstance(packet, gc_packet_types.GameCommandPacket):
command = gc_packet_types.process_game_command(packet)
time.sleep(.2)
lines = command.split("<EOL>\n")
if self.verification:
for line in lines:
if len(line) > 0:
print("Sc: ", line)
self.game.command(line)
else:
raise ValueError(packet.DEFINITION_IDENTIFIER)
def connection_made(self, transport):
self.transport = transport
self._deserializer = PacketType.Deserializer()
def connection_made(self, transport):
self.transport=transport
self.transport.write(KeyRequest().__serialize__())
print("send:{}".format(KeyRequest().__serialize__()) )
self._deserializer = PacketType.Deserializer()
def connection_made(self, transport):
self.transport = transport
self._deserializer = PacketType.Deserializer()
print("Server made success")
def __init__(self, name, loop):
self.name = name
self.loop = loop
self.transport = None
self._deserializer = PacketType.Deserializer()
def __init__(self, transport):
self.t = transport
self.deserializer = PacketType.Deserializer()
def __init__(self):
self.ConnectionDict = {}
self.transport = None
self._deserializer = PacketType.Deserializer()
def connection_made(self, transport):
print("Server is connected to client")
self.transport = transport
peername = transport.get_extra_info('peername')
print('Build Connection from {}'.format(peername))
self.deserializer = PacketType.Deserializer()
def connection_made(self, transport):
self.transport = transport
self._deserializer = PacketType.Deserializer()
transport.write(self.packet.__serialize__())
PacketBytes = packet1.__serialize__() + packet2.__serialize__() + \
packet3.__serialize__()
packet2 = PacketType.Deserialize(packetBytes)
if packet1 == packet2:
print("These two packets are the same!")
'''
deserializer = PacketType.Deserializer()
deserilaizer.update(data)
for packet in deserializer.nextPackets():
# now I have a packet!
'''
deserializer = PacketType.Deserializer()
print("Starting with {} bytes of data".format(len(pktBytes)))
while len(pktBytes) > 0:
# let’s take of a 10 byte chunk
chunk, pktBytes = pktBytes[:10], pktBytes[10:]
deserializer.update(chunk)
print("Another 10 bytes loaded into deserializer.Left={}".format(len(pktBytes)))
for packet in deserializer.nextPackets():
print("got a packet!")
if packet == packet1:
print("It’s packet 1!")
elif packet == packet2:
print("It’s packet 2!")
elif packet == packet3:
print("It’s packet 3!")
def basicUnitTest():
print("\n \nTest Starting \n")
print("Packet1 Bytes:")
print(packet1Bytes)
print("Deserialized Packet1:")
print(packet1_dslzd)
print("packetLength:")
print(len(packet1Bytes))
assert packet1 == packet1_dslzd ##Testing the equality of the packet
assert packet1.clientID == packet1_dslzd.clientID ##Testing the equality of the values of the fields
print("Assertion complete")
print("\nPacket2 Bytes:")
print(packet2Bytes)
print("Deserialized Packet2")
print(packet2_dslzd)
print("packetLength:")
print(len(packet2Bytes))
assert packet2 == packet2_dslzd
print("Assertion complete")
print("\nPacket3 Bytes:")
print(packet3Bytes)
print("Deserialized Packet3")
print(packet3_dslzd.message)
print("packetLength:")
print(len(packet3Bytes))
assert packet3 == packet3_dslzd
assert packet3_dslzd.receiverID == "jchahal_r"
assert packet3_dslzd.message == b"Test Message."
print("Assertion complete")
print("\nPacket4 Bytes:")
print(packet4Bytes)
print("Deserialized Packet4 \n")
print(packet4_dslzd)
print("packetLength:")
print(len(packet4Bytes))
assert packet4 == packet4_dslzd
assert packet4.messageSentTime == packet4_dslzd.messageSentTime
print("Assertion complete")
print(
"\nChecking the equality of different packets: packet1 and packet3 after deserializing"
)
if packet1_dslzd == packet3_dslzd: ##Testing the equality of two different packets
print("They are equal")
else:
print("They are not equal")
packetBytes = packet1Bytes + packet2Bytes + packet3Bytes + packet4Bytes
print("\nTotal packetBytes")
print(packetBytes)
print("\nTotal length:")
print(len(packetBytes))
print("\n")
deserializer = PacketType.Deserializer(
) ##Deserializing the packets chunck by chunck and keeping a note when a whole packet has been deserialized
print("Starting with {} byets of data".format(len(packetBytes)))
while len(packetBytes) > 0:
chunk, packetBytes = packetBytes[:10], packetBytes[10:]
deserializer.update(chunk)
print("Another 10 bytes loaded into deserializer, Left = {}".format(
len(packetBytes)))
for packet in deserializer.nextPackets():
print("got a packet!")
if packet == packet1: print("It's packet 1")
elif packet == packet2: print("It's packet 2")
elif packet == packet3: print("It's packet 3")
elif packet == packet4: print("It's packet 4")
