def main(args):
loop = asyncio.get_event_loop()
coro = playground.create_connection(lambda: ClientProtocol(loop=loop),
IPADDR, PORT)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def main(args):
EnablePresetLogging(PRESET_VERBOSE)
host = args[0]
port = int(args[1])
print('host:', host)
print('port:', port)
bank_addr = '20194.0.1.1'
bank_port = 888
username = input('Enter username: '******'Enter password for {}: '.format(username))
user_acct = input('Enter account name: ')
# user_acct = "sabdous1_account"
bank_client = BankClientProtocol(bank_cert, username, password)
loop = asyncio.get_event_loop()
coro = playground.create_connection(lambda: GameClientProtocol(
loop, bank_client, bank_addr, bank_port, username, user_acct),
host=host,
port=port,
family=STACK)
client = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
loop.close()
def main(args):
loop = asyncio.get_event_loop()
# IPADDR = input("input the server address:")
# PORT = input("input the server port:")
firstPkt = create_game_init_packet("test")
coro = playground.create_connection(lambda: ClientProtocol(loop=loop, firstPkt=firstPkt),
IPADDR, PORT) # for E5
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def main(args):
loop = asyncio.get_event_loop()
coro = playground.create_connection(EchoClient, '20194.0.0.19000', 19005)
#1)change loop into playground 2)change IP address into address in Playground 20194.0.019000
client = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
client.close()
loop.run_until_complete(client.close())
loop.close()
def main(args):
team_num = int(input("team number: "))
set_server_info(team_num)
loop = asyncio.get_event_loop()
firstPkt = create_game_init_packet(USER_NAME_INIT_PKT)
coro = playground.create_connection(
lambda: ClientProtocol(loop=loop, firstPkt=firstPkt),
IP_ADDR,
PORT,
family="lzy_lab3") # for E5
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def main(args):
loop = asyncio.get_event_loop()
# NOTE: this for change into check mode
if len(args) != 0:
firstPkt = getCheckResPkt() if args[0] == "check" else getFirstPkt()
else:
firstPkt = getFirstPkt()
# NOTE: just removed the first pkt func
firstPkt = create_game_init_packet("test")
coro = playground.create_connection(
lambda: ClientProtocol(loop=loop, firstPkt=firstPkt), IPADDR,
PORT) # for E5
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
result = await paymentInit("tfeng7_account", account, amount,
unique_id)
print(result)
receipt, receipt_sig = result
game_packet = create_game_pay_packet(receipt, receipt_sig)
self.transport.write(game_packet.__serialize__())
def flush_output(self, *args, **kargs):
print(*args, **kargs)
sys.stdout.flush()
def game_next_input(self):
input = sys.stdin.readline().strip()
self.command_packet = create_game_command(input)
self.transport.write(self.command_packet.__serialize__())
if __name__ == "__main__":
loop = asyncio.get_event_loop()
coro = playground.create_connection(EchoClient, 'crap://20194.2.57.98',
2222)
# loop.set_debug(enabled=True)
# from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
# EnablePresetLogging(PRESET_DEBUG)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
if text.split("<EOL>\n")[0].endswith("wall"):
instruction = self.instructions[
self.instruction_counter] + "<EOL>\n"
self.transport.write(instruction.encode())
self.instruction_counter += 1
else:
instruction = self.instructions[
self.instruction_counter] + "<EOL>\n"
print("C: {}".format(instruction))
self.transport.write(instruction.encode())
self.instruction_counter += 1
else:
print("RAN OUT OF INSTRUCTIONS!")
if __name__ == "__main__":
loop = asyncio.get_event_loop()
coro = playground.create_connection(StudentClient, '20194.0.0.19000',
19005)
client = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
client.close()
loop.run_until_complete(client.close())
loop.close()
async def get_gncasino_input(self):
command = await async_get_input(">> ")
cmd = GameRequest(command=command)
self.transport.write(cmd.__serialize__())
if __name__ == "__main__":
import sys, argparse
parser = argparse.ArgumentParser()
parser.add_argument("account")
parser.add_argument("--host", default="20191.2.1.0")
parser.add_argument("-p", "--port", default=5657)
parser.add_argument("-s", "--stack", default="pls_roast")
args = parser.parse_args(sys.argv[1:])
host, port, stack = args.host, args.port, args.stack
port = int(port)
# this will ask for login name and password for bank for this account
# but it doesn't actually log in yet.
global_payment_processor.set_src_account(args.account)
loop = asyncio.get_event_loop()
coro = playground.create_connection(HomepageClientProtocol,
host=host,
port=port,
family=stack)
transport, protocol = loop.run_until_complete(coro)
print("connected", protocol, transport)
loop.add_reader(sys.stdin, stdin_reader)
loop.run_forever()
loop.close()
d.update(data)
for gamePacket in d.nextPackets():
if isinstance(gamePacket, mypacket.GameRequirePayPacket):
print(gamePacket.amount)
unique_id, account, amount = process_game_require_pay_packet(gamePacket)
print(unique_id)
print(account)
print(amount)
self.loop.create_task(self.Create_Payment(account, amount, unique_id))
elif isinstance(gamePacket, mypacket.GameResponsePacket):
print(gamePacket.response)
self.flush_output(gamePacket.response())
if self.i == 0:
self.flush_output(">>", end=' ')
self.i +=1
def game_next_input(self):
input = sys.stdin.readline().strip()
self.command_packet = create_game_command(input)
self.transport.write(self.command_packet.__serialize__())
if __name__ == "__main__":
loop = asyncio.get_event_loop()
coro = playground.create_connection(EchoClient, 'localhost', 12414)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
mode = echoArgs[0]
loop = asyncio.get_event_loop()
loop.set_debug(enabled=True)
from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
EnablePresetLogging(PRESET_DEBUG) # Can be commented out
if mode.lower() == "server":
coro = playground.create_server(lambda: EchoServerProtocol(),
port=port,
family=stack)
server = loop.run_until_complete(coro)
print("Echo Server Started at {}".format(
server.sockets[0].gethostname()))
loop.run_forever()
loop.close()
else:
remoteAddress = mode
control = EchoControl()
coro = playground.create_connection(control.buildProtocol,
host=remoteAddress,
port=port,
family=stack)
transport, protocol = loop.run_until_complete(coro)
print("Echo Client Connected. Starting UI t:{}. p:{}".format(
transport, protocol))
control.connect(protocol)
loop.run_forever()
loop.close()
def main(args):
EnablePresetLogging(PRESET_VERBOSE)
team_list = []
'''
commands to win team to:
1) "enter code to the coded lock"
2) enter current time on your laptop
3) "open chest"
4) "get hammer from chest"
5) "hit flyingkey with hammer" (do it till you hit it)
6) "get key"
7) "unlock door with key"
8) "open door"
'''
commands = [
"enter code to the coded lock",
datetime.datetime.now().strftime("%H%M"), "open chest",
"get hammer from chest", "hit flyingkey with hammer", "get key",
"unlock door with key", "open door"
]
team_list.append(
Team(team_number='2', host='20194.2.57.98', port=2222, commands=None))
'''
commands to win team to:
1) "look mirror"
2) "look puzzle"
3) "answer 368.2"
4) "look mirror"
5) "get hairpin"
6) "unlock chest with hairpin"
7) "open chest"
8) "get hammer from chest"
9) "get spear from chest"
10) "hit flyingkey with hammer" (do it till you hit it)
11) "hit flyingring with spear" (do it till you hit it)
12) "get flyingkey"
13) "get flyingring"
14) "get glue"
15) "combine flyingkey with flyingring using glue"
16) "get key"
17) "unlock door with key"
18) "hit monster with hammer"
19) "open door"
'''
commands = [
"look mirror", "look puzzle", "answer 368.2", "look mirror",
"get hairpin", "unlock chest with hairpin", "open chest",
"get hammer from chest", "get spear from chest",
"hit flyingkey with hammer", "hit flyingring with spear",
"get flyingkey", "get flyingring", "get glue",
"combine flyingkey with flyingring using glue", "get key",
"unlock door with key", "hit monster with hammer", "open door"
]
team_list.append(
Team(team_number='3', host='20194.3.6.9', port=333, commands=None))
'''
commands to win team to:
1) "look mirror"
2) "get hairpin"
3) "unlock chest with hairpin"
4) "open chest"
5) "get hammer from chest"
6) "hit flyingkey with hammer" (do it till you hit it)
7) "get key"
8) "unlock door with key"
9) "open door"
'''
team_list.append(Team(team_number='4', host='20194.4.4.4', port=8666))
'''
commands to win team to:
1) "look mirror"
2) "get hairpin"
3) "unlock chest with hairpin"
4) "open chest"
5) "get hammer from chest"
6) "hit flyingkey with hammer" (do it till you hit it)
7) "get key"
8) "unlock door with key"
9) "open door"
'''
commands = [
"look mirror", "get hairpin", "unlock chest with hairpin",
"open chest", "get hammer from chest", "hit flyingkey with hammer",
"get key", "unlock door with key", "open door"
]
team_list.append(
Team(team_number='5', host='20194.5.20.30', port=8989, commands=None))
'''
commands to win team to:
1) "hit flyingkey with hammer" (do it till you hit it)
2) "get key"
3) "unlock door with key"
4) "open door"
'''
commands = [
"hit flyingkey with hammer", "get key", "unlock door with key",
"open door"
]
team_list.append(
Team(team_number='6', host='20194.6.20.30', port=16666, commands=None))
'''
commands to win team to:
0) "get shield"
1) "look mirror"
2) "get hairpin"
3) "unlock chest with hairpin"
4) "open chest"
5) "get hammer from chest"
6) "hit flyingkey with hammer" (do it till you hit it)
7) "get key"
8) "unlock door with key"
9) "open door"
'''
commands = [
"get shield", "look mirror", "get hairpin",
"unlock chest with hairpin", "open chest", "get hammer from chest",
"hit flyingkey with hammer", "get key", "unlock door with key",
"open door"
]
team_list.append(
Team(team_number='9', host='20194.9.1.1', port=7826, commands=None))
while True:
team_number = input("Enter team number escaperoom you want to play: ")
if team_number not in ['2', '3', '4', '5', '6', '9']:
print('Invalid team number!')
continue
break
for i in team_list:
if team_number == i.team_number:
host = i.host
port = i.port
commands = i.commands
break
print('host:', host)
print('port:', port)
bank_addr = '20194.0.1.1'
bank_port = 888
# username = input('Enter username: '******'Enter password for {}: '.format(username))
# user_acct = input('Enter account name: ')
user_acct = "sabdous1_account"
bank_client = BankClientProtocol(bank_cert, username, password)
loop = asyncio.get_event_loop()
coro = playground.create_connection(
lambda: GameClientProtocol(loop,
bank_client,
bank_addr,
bank_port,
username,
user_acct,
commands=commands,
team_number=team_number),
host=host,
port=port,
family=STACK)
client = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
loop.close()
async def Create_Payment(self, account, amount, unique_id):
result = await paymentInit("tfeng7_account", account, amount,
unique_id)
print(result)
receipt, receipt_sig = result
game_packet = create_game_pay_packet(receipt, receipt_sig)
self.transport.write(game_packet.__serialize__())
def flush_output(self, *args, **kargs):
print(*args, **kargs)
sys.stdout.flush()
def game_next_input(self):
input = sys.stdin.readline().strip()
self.command_packet = create_game_command(input)
self.transport.write(self.command_packet.__serialize__())
if __name__ == "__main__":
loop = asyncio.get_event_loop()
coro = playground.create_connection(EchoClient, 'crap://20194.3.6.9', 333)
# loop.set_debug(enabled=True)
# from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
# EnablePresetLogging(PRESET_DEBUG)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def send(self, data):
GameCommandPacket = gamePackage.GameCommandPacket.create_game_command_packet(
data)
#print(GameCommandPacket)
self.transport.write(GameCommandPacket.__serialize__())
async def Create_Payment(self, account, amount, unique_id):
result = await Payment_Init("ymao22_account", account, amount,
unique_id)
print(result)
receipt, receipt_sig = result
game_packet = create_game_pay_packet(receipt, receipt_sig)
self.transport.write(game_packet.__serialize__())
print("newnewnew")
if __name__ == "__main__":
loop = asyncio.get_event_loop()
loop.set_debug(enabled=True)
EnablePresetLogging(PRESET_DEBUG)
coro = playground.create_connection(EchoClient, '20194.0.0.19000', 19007)
client = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
client.close()
loop.run_until_complete(client.close())
loop.close()
input = sys.stdin.readline().strip()
self.command_packet = create_game_command(input)
self.transport.write(self.command_packet.__serialize__())
if __name__ == "__main__":
loop = asyncio.get_event_loop()
#team2
#destinationaddress = 'MAO://20194.2.57.98'
#destinationport = '1106'
#team3
#destinationaddress = 'crap://20194.3.6.9'
#destinationport = '333'
#team4
#destinationaddress = 'crap://20194.4.4.4'
#destinationport = '8666'
#team6
#destinationaddress = 'crap://20194.6.20.30'
#destinationport = '16666'
#team9
destinationaddress = 'crap://20194.9.1.1'
destinationport = '7826'
coro = playground.create_connection(EchoClient, destinationaddress,destinationport)
# coro = playground.create_connection(lambda: ClientProtocol(loop=loop), destinationaddress, destinationport, family="crap")
# loop.set_debug(enabled=True)
from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
#EnablePresetLogging(PRESET_DEBUG)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
async def get_escape_room_input(self):
command = await async_get_input(">> ")
cmd = GameRequest(token=self._token, command=command)
self.transport.write(cmd.__serialize__())
if __name__ == "__main__":
import sys, argparse
parser = argparse.ArgumentParser()
parser.add_argument("account")
parser.add_argument("--host", default="localhost")
parser.add_argument("-p", "--port", default=5678)
args = parser.parse_args(sys.argv[1:])
host, port = args.host, args.port
port = int(port)
# this will ask for login name and password for bank for this account
# but it doesn't actually log in yet.
global_payment_processor.set_src_account(args.account)
loop = asyncio.get_event_loop()
coro = playground.create_connection(EscapeRoomClientProtocol,
host=host,
port=port)
transport, protocol = loop.run_until_complete(coro)
print("connected", protocol, transport)
loop.add_reader(sys.stdin, stdin_reader)
loop.run_forever()
loop.close()
async def Create_Payment(self, account, amount, unique_id):
result = await paymentInit("tfeng7_account", account, amount, unique_id)
print(result)
receipt, receipt_sig = result
game_packet = create_game_pay_packet(receipt, receipt_sig)
self.transport.write(game_packet.__serialize__())
def flush_output(self, *args, **kargs):
print(*args, **kargs)
sys.stdout.flush()
def game_next_input(self):
input = sys.stdin.readline().strip()
self.command_packet = create_game_command(input)
self.transport.write(self.command_packet.__serialize__())
if __name__ == "__main__":
loop = asyncio.get_event_loop()
coro = playground.create_connection(EchoClient, '20194.0.1.1', 8666)
# loop.set_debug(enabled=True)
# from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
# EnablePresetLogging(PRESET_DEBUG)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
# print(line)
# deal_with_input(self, line)
def write(self, msg):
#msg += "<EOL>\n"
#self.transport.write(msg.encode())
print("Data to send: {}".format(msg))
self.transport.write(msg.__serialize__())
def connection_lost(self):
print("Disconnected")
if __name__ == "__main__":
username = '******'
password = '******'
bank_client = BankClientProtocol(bank_cert, username, password)
loop = asyncio.get_event_loop()
coro = playground.create_connection(lambda: Ex7Client(bank_client), AG_IP,
AG_PORT)
client = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
client.close()
loop.run_until_complete(client.close())
loop.close()
):
self.server_test_protocol.transport.close()
def close_client(self):
self.transport.close()
asyncio.get_event_loop().stop()
if __name__ == "__main__":
import sys
from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
EnablePresetLogging(PRESET_DEBUG)
server_addr, test_type, mode = sys.argv[1:]
loop = asyncio.get_event_loop()
coro = playground.create_connection(
lambda: Lab1AutogradeClient(server_addr, test_type, mode),
host=server_addr,
port=19101)
transport, protocol = loop.run_until_complete(coro)
print("Connected on", transport.get_extra_info("peername"))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
loop.close()
result = await paymentInit("tfeng7_account", account, amount,
unique_id)
print(result)
receipt, receipt_sig = result
game_packet = create_game_pay_packet(receipt, receipt_sig)
self.transport.write(game_packet.__serialize__())
def flush_output(self, *args, **kargs):
print(*args, **kargs)
sys.stdout.flush()
def game_next_input(self):
input = sys.stdin.readline().strip()
self.command_packet = create_game_command(input)
self.transport.write(self.command_packet.__serialize__())
if __name__ == "__main__":
loop = asyncio.get_event_loop()
coro = playground.create_connection(EchoClient, 'crap://20194.6.20.30',
8989)
# loop.set_debug(enabled=True)
# from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
# EnablePresetLogging(PRESET_DEBUG)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def connection_made(self, transport):
transport.write(self.message.encode())
self.transport = transport
def data_received(self, data):
print(data.decode())
input = stdinAlert()
self.transport.write(input.encode())
def connection_lost(self, exc):
print('The server closed the connection')
print('Stop the event loop')
self.loop.stop()
def stdinAlert():
lines = sys.stdin.readline()
return lines
loop = asyncio.get_event_loop()
loop.add_reader(sys.stdin, stdinAlert)
message = stdinAlert()
coro = playground.create_connection(
lambda: HomepageClientProtocol(message, loop), '20191.157.156.156', 9090)
loop.run_until_complete(coro)
loop.run_forever()
if self.server_test_protocol.transport and not self.server_test_protocol.transport.is_closing(
):
self.server_test_protocol.transport.close()
def close_client(self):
self.transport.close()
asyncio.get_event_loop().stop()
if __name__ == "__main__":
import sys
from playground.common.logging import EnablePresetLogging, PRESET_VERBOSE, PRESET_DEBUG
EnablePresetLogging(PRESET_VERBOSE)
server_addr, team_number, email, test_type, mode = sys.argv[1:]
loop = asyncio.get_event_loop()
coro = playground.create_connection(lambda: Lab2AutogradeClient(
server_addr, team_number, email, test_type, mode),
host=server_addr,
port=19102)
transport, protocol = loop.run_until_complete(coro)
print("Connected on", transport.get_extra_info("peername"))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
loop.close()
print("Client sends: ", curr_msg)
gr_packet = GameCommandPacket(cmd=curr_msg).__serialize__()
self.transport.write(gr_packet)
self.count += 1
time.sleep(0.2)
print("Client sent")
elif isinstance(packet, AutogradeResultResponse):
print("Client recieves: Result Response packet: test_id : " +
str(packet.test_id) + ", passed?" + str(packet.passed))
else:
print("what happened?")
if __name__ == "__main__":
# EnablePresetLogging(PRESET_DEBUG)
loop = asyncio.get_event_loop()
if testLocally:
coro = playground.create_connection(EchoClient, 'localhost', 4242)
else:
coro = playground.create_connection(EchoClient, '20194.0.0.19000',
19007)
client = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
loop.run_until_complete(client.close())
print("client closed")
loop.close()
async def Create_Payment(self, account, amount, unique_id):
result = await paymentInit("tfeng7_account", account, amount,
unique_id)
print(result)
receipt, receipt_sig = result
game_packet = create_game_pay_packet(receipt, receipt_sig)
self.transport.write(game_packet.__serialize__())
def flush_output(self, *args, **kargs):
print(*args, **kargs)
sys.stdout.flush()
def game_next_input(self):
input = sys.stdin.readline().strip()
self.command_packet = create_game_command(input)
self.transport.write(self.command_packet.__serialize__())
if __name__ == "__main__":
loop = asyncio.get_event_loop()
coro = playground.create_connection(EchoClient, 'crap://20194.4.4.4', 8666)
# loop.set_debug(enabled=True)
# from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
# EnablePresetLogging(PRESET_DEBUG)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
get_result_byte = get_result.__serialize__()
print('Packet that is going out: ' + str(get_result_byte))
self.transport.write(get_result_byte)
def data_received(self, data):
if not self.gotResult:
self.gotResult = True
print('something received: ' + str(data))
self.deserializer.update(data)
for packet in self.deserializer.nextPackets():
print('Packet Received: ' + str(packet))
print('Packet Info:\n' +
'test_id: ' + str(packet.test_id) +
'\npassed: ' + str(packet.passed))
def connection_lost(self, exc):
print('Connection Lost!')
self.loop.stop()
IP = "20194.0.0.19000"
PORT = 19008
# IP = "0.0.0.0"
# PORT = "1234"
loop = asyncio.get_event_loop()
coro = playground.create_connection(lambda: ClientProtocol(loop),
IP, PORT)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
if __name__ == "__main__":
if ('server' in sys.argv[1:]) or ('client' in sys.argv[1:]):
if ('server' in sys.argv[1:]):
loop = asyncio.get_event_loop()
#coro = playground.create_server(EchoServer,'20191.100.100.1',1810)
coro = playground.create_server(
lambda: EchoServer('dhaoshu1', 'dhaoshu1_account', 5),
'localhost', Server_Port_number)
asyncio.ensure_future(coro)
else:
print('The bank client config: ', bank_addr, bank_port,
bank_username)
yngo = input('If the above message is right, continue? [y/n]: ')
if yngo == 'y':
loop = asyncio.get_event_loop()
coro = playground.create_connection(
lambda: EchoClient('dhaoshu1', 'dhaoshu1_account'),
'20194.0.0.19000', 19008)
asyncio.ensure_future(coro)
#client = loop.run_until_complete(coro)
else:
raise Exception('Not able to process, need reconfig.')
try:
loop.run_forever()
except KeyboardInterrupt:
loop.stop()
loop.close()
else:
print('Need assigning input argument, server or client.')
def data_received(self, data):
if "escaped" not in data.decode() and "dead" not in data.decode():
print(data.decode())
command = stdinAlert()
self.transport.write(command.encode())
else:
print(data.decode())
self.transport.close()
def connection_lost(self, exc):
print('The server closed the connection')
print('Stop the event loop')
self.loop.stop()
def stdinAlert():
lines = sys.stdin.readline()
return lines
loop = asyncio.get_event_loop()
loop.add_reader(sys.stdin, stdinAlert)
message = stdinAlert()
coro = playground.create_connection(
lambda: EscapeClientProtocol(message, loop), '20191.10.20.30', 62261)
loop.run_until_complete(coro)
loop.run_forever()
if pk.DEFINITION_IDENTIFIER == "20194.exercise6.autograderesultresponse":
print(pk.test_id)
print(pk.passed)
else:
print("what's that?")
'''
async def main(loop):
message = "SUBMIT,{ziyang lin},{zlin32@jh,edu},{2},{54216}<EOL>\n"
transport,protocol = await loop.create_connection(
lambda: clientProtocol(message,loop),'192.168.200.52',19003)
message = "look mirror<EOL>\nget hairpin<EOL>\nunlock door with hairpin<EOL>\nopen door<EOL>\n"
#print(transport.data)
transport.write(message.encode())
'''
if __name__ == "__main__":
loop = asyncio.get_event_loop()
coro = playground.create_connection(lambda: clientProtocol(loop),
'20194.0.0.19000', 19007)
loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
loop.close()
gc_packet_types.create_game_command(command=instruction).__serialize__()
)
self.instruction_counter += 1
else:
instruction = self.instructions[self.instruction_counter] #+ "<EOL>\n"
print("CS: {}".format(instruction))
self.transport.write(
gc_packet_types.create_game_command(command=instruction).__serialize__()
)
self.instruction_counter += 1
else:
raise ValueError(packet.DEFINITION_IDENTIFIER)
if __name__ == "__main__":
loop = asyncio.get_event_loop()
coro = playground.create_connection(StudentClient,host='20194.0.0.19000',port=19008)
client = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
client.close()
loop.run_until_complete(client.close())
loop.close()
self.flag = self.flag + 1
time.sleep(1)
async def CreatePayment(self, account, amount, unique_id):
result = await paymentInit("tfeng7_account", account, amount,
unique_id)
print(result)
receipt, receipt_sig = result
game_packet = create_game_pay_packet(receipt, receipt_sig)
self.transport.write(game_packet.__serialize__())
def connection_lost(self, exc):
print('The server closed the connection')
print('Stop the event loop')
self.loop.stop()
if __name__ == "__main__":
loop = asyncio.get_event_loop()
loop.set_debug(enabled=True)
from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
EnablePresetLogging(PRESET_DEBUG)
coro = playground.create_connection(lambda: EchoClientProtocol(),
'20194.0.0.19000', 19008)
# coro = loop.create_connection(lambda: EchoClientProtocol(loop), 'localhost', 1024)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
