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 __init__(self):
self.loop = asyncio.get_event_loop()
self.deserializer = PacketType.Deserializer()
self.i = 0
self.list = ["look mirror", "get hairpin",
"unlock chest with hairpin", "open chest", "get hammer in chest", "hit flyingkey with hammer",
"get key","unlock door with key", "open door"]
loop.set_debug(enabled=True)
from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
EnablePresetLogging(PRESET_DEBUG)
def main():
from playground.common.logging import EnablePresetLogging, PRESET_DEBUG
EnablePresetLogging(PRESET_DEBUG)
args = sys.argv[1:]
if len(args) != 4:
print("Incorrect number of arguments (got %s, expected 4)" % len(args))
print(
"USAGE:\n\tpython3 bank_functional1.py [Bank Cert Path] [User Login Name]\n\t\t[Client/Requester Bank Account Name] [Server/Merchant Bank Account Name]"
)
return
bankcert = loadCertFromFile(args[0])
username = args[1]
pw = getpass.getpass("Enter client/requester's bank password: "******"print('this is a test')"
fee = 1
#debugPrint("Creating NullServerWallet")
#serverWallet = NullServerWallet()
debugPrint("Creating PayingServerWallet")
serverWallet = PayingServerWallet(bankcert, merchantaccount)
debugPrint("Creating SimplePayingServerAuth")
serverAuth = SimplePayingServerAuth(fee)
debugPrint("Creating DefaultMobileCodeEngine")
serverEngine = DefaultMobileCodeEngine()
# debugPrint("Creating NullClientWallet")
# clientWallet = NullClientWallet()
debugPrint("Creating PayingClientWallet")
clientWallet = PayingClientWallet(bankstackfactory, username, pw,
payeraccount, merchantaccount)
def serverFactory():
debugPrint("Factory creating MobileCodeServer")
return MobileCodeServer(serverWallet, serverAuth, serverEngine)
debugPrint("Creating MobileCodeClient")
client = MobileCodeClient("default", "localhost", 1, samplecode,
SimplePayingClientAuth(), clientWallet)
coro = playground.getConnector().create_playground_server(serverFactory, 1)
loop = get_event_loop()
server = loop.run_until_complete(coro)
print("Server started")
loop.call_later(0, RunCodeAndPrintResult, client)
loop.run_forever()
def 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_server(EchoServerProtocol, 'localhost', 2001)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
server.close()
loop.run_until_complete(server.wait_close())
loop.close()
await self.server_test_protocol.disconnected
print("Server test disconnected. Close transport.",
self.server_test_protocol.transport)
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
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()
def runVnic(vnic_address, port, statusfile, switch_address, switch_port,
daemon):
# normally, all of this would be global. We have it
# here so it is not messing with the fork!
from playground.network.devices import VNIC
from playground.common.logging import EnablePresetLogging, PRESET_QUIET, PRESET_VERBOSE
import asyncio
logger = logging.getLogger("playground.vnic")
class VnicStatusListeners:
def __init__(self):
self.reset()
def alert(self, method):
for l in self.listeners:
l.alert(method)
def reset(self):
self.listeners = set([])
vnicStatusListeners = VnicStatusListeners()
class StatusVnic(VNIC):
def connected(self):
super().connected()
vnicStatusListeners.alert(self.connected)
def disconnected(self):
super().disconnected()
vnicStatusListeners.alert(self.disconnected)
class StatusManager:
def __init__(self, statusfile, port, switchIp, switchPort, vnic):
self._port = port
self._vnic = vnic
self._statusfile = statusfile
self._switchIp = switchIp
self._switchPort = str(switchPort)
def alert(self, event):
if event == self._vnic.connected:
self.writeStatus("Connected")
elif event == self._vnic.disconnected:
self.writeStatus("Disconnected")
def writeStatus(self, status):
#print("{} writing status {} to {}".format(self._port, status, self._statusfile))
with open(self._statusfile, "w+") as f:
f.write("{}\n{}\n{}".format(
self._port, ":".join([self._switchIp, self._switchPort]),
status))
class ConnectToSwitchTask:
RECONNECT_DELAY = 30
def __init__(self, vnic, switchIp, switchPort):
self._vnic = vnic
self._switchIp = switchIp
self._switchPort = switchPort
def alert(self, event):
if event == self._vnic.disconnected:
asyncio.get_event_loop().call_later(self.RECONNECT_DELAY,
self.connect)
def connect(self):
coro = asyncio.get_event_loop().create_connection(
self._vnic.switchConnectionFactory, self._switchIp,
self._switchPort)
futureConnection = asyncio.get_event_loop().create_task(coro)
futureConnection.add_done_callback(self._connectFinished)
def _connectFinished(self, futureConnection):
if futureConnection.exception() != None:
# Couldn't connect. Try again later.
logger.debug("Couldn't connect. Reason: {}".format(
futureConnection.exception()))
asyncio.get_event_loop().call_later(self.RECONNECT_DELAY,
self.connect)
else:
logger.debug("Connected to Switch")
#### IMPORTANT #########
# Because the Dameon process does a fork, you need to enable logging (which creates a file)
# after the fork! So, enable logging within runVnic, rather than outside of it.
# EnablePresetLogging(PRESET_QUIET)
EnablePresetLogging(PRESET_VERBOSE)
asyncio.get_event_loop().set_debug(enabled=True)
logger.info("pid {} asyncio {}, asyncio loop {}".format(
os.getpid(), asyncio, asyncio.get_event_loop()))
logger.info("""
====================================
| Launch VNIC (Address: {}, Pid: {})
====================================
""".format(vnic_address, os.getpid()))
loop = asyncio.get_event_loop()
loop.set_debug(enabled=True)
vnicStatusListeners.reset() # reset listeners
vnic = StatusVnic(vnic_address)
# Connection to the switch is optional. That is, the VNIC should be
# up and "operating" even if it can't connect to the switch. So
# start the server first.
coro = loop.create_server(vnic.controlConnectionFactory,
host="127.0.0.1",
port=port)
prot = vnic.controlConnectionFactory()
logger.error("Got prot {}".format(prot))
server = loop.run_until_complete(coro)
servingPort = server.sockets[0].getsockname()[1]
statusManager = StatusManager(statusfile, servingPort, switch_address,
switch_port, vnic)
vnicStatusListeners.listeners.add(statusManager)
statusManager.writeStatus("Disconnected")
switchConnector = ConnectToSwitchTask(vnic, switch_address, switch_port)
vnicStatusListeners.listeners.add(switchConnector)
switchConnector.connect()
logger.info("Run Forever")
loop.run_forever()
logger.info("Server Close")
server.close()
loop.close()
def setLogLevel(self, lvl):
EnablePresetLogging(lvl)
self._presetLogging = lvl
def runVnic(vnic_address, port, statusfile, switch_address, switch_port,
daemon):
# normally, all of this would be global. We have it
# here so it is not messing with the fork!
from playground.network.devices import VNIC
from playground.network.protocols.spmp import HiddenSPMPServerProtocol
from playground.common.logging import EnablePresetLogging, PRESET_NONE, PRESET_DEBUG, PRESET_LEVELS
import asyncio
logger = logging.getLogger("playground.vnic")
class VnicStatusListeners:
def __init__(self):
self.reset()
def alert(self, method):
for l in self.listeners:
l.alert(method)
def reset(self):
self.listeners = set([])
vnicStatusListeners = VnicStatusListeners()
class StatusVnic(VNIC):
def __init__(self, *args, **kargs):
super().__init__(*args, **kargs)
self.buildSpmpApi()
self._spmp_connection_status = "Not Connected"
def setLogLevel(self, lvl):
EnablePresetLogging(lvl)
self._presetLogging = lvl
def buildSpmpApi(self):
self._presetLogging = PRESET_NONE
self.SPMPApi = {
"verbs": (lambda: ", ".join(list(self.SPMPApi.keys()))),
"get-promsicuity-level":
(lambda: str(self.promiscuousLevel())),
"set-promiscutiy-level":
(lambda lvl: self.setPromiscuousLevel(str(lvl))),
"all-log-levels": (lambda: ", ".join(PRESET_LEVELS)),
"get-log-level": (lambda: self._presetLogging),
"set-log-level": (lambda lvl: self.setLogLevel(lvl)),
"switch-live": (lambda: self._spmp_connection_status)
}
def connectionMade(self):
super().connectionMade()
self._spmp_connection_status = "Connected"
vnicStatusListeners.alert(self.connectionMade)
def connectionLost(self):
super().connectionLost()
self._spmp_connection_status = "Not Connected"
vnicStatusListeners.alert(self.connectionLost)
def controlConnectionFactory(self):
originalProtocol = super().controlConnectionFactory()
spmpServerProtocol = HiddenSPMPServerProtocol(
originalProtocol, self, self.SPMPApi)
return spmpServerProtocol
class StatusManager:
def __init__(self, statusfile, port, switchIp, switchPort, vnic):
self._port = port
self._vnic = vnic
self._statusfile = statusfile
self._switchIp = switchIp
self._switchPort = str(switchPort)
def alert(self, event):
if event == self._vnic.connectionMade:
self.writeStatus("Connected")
elif event == self._vnic.connectionLost:
self.writeStatus("Disconnected")
def writeStatus(self, status):
#print("{} writing status {} to {}".format(self._port, status, self._statusfile))
with open(self._statusfile, "w+") as f:
f.write("{}\n{}\n{}".format(
self._port, ":".join([self._switchIp, self._switchPort]),
status))
class ConnectToSwitchTask:
RECONNECT_DELAY = 30
def __init__(self, vnic, switchIp, switchPort):
self._vnic = vnic
self._switchIp = switchIp
self._switchPort = switchPort
def alert(self, event):
if event == self._vnic.connectionLost:
asyncio.get_event_loop().call_later(self.RECONNECT_DELAY,
self.connect)
def connect(self):
coro = asyncio.get_event_loop().create_connection(
self._vnic.switchConnectionFactory, self._switchIp,
self._switchPort)
futureConnection = asyncio.get_event_loop().create_task(coro)
futureConnection.add_done_callback(self._connectFinished)
def _connectFinished(self, futureConnection):
if futureConnection.exception() != None:
# Couldn't connect. Try again later.
logger.debug("Couldn't connect. Reason: {}".format(
futureConnection.exception()))
asyncio.get_event_loop().call_later(self.RECONNECT_DELAY,
self.connect)
else:
logger.debug("Connected to Switch")
#### IMPORTANT #########
# Because the Dameon process does a fork, you need to enable logging (which creates a file)
# after the fork! So, enable logging within runVnic, rather than outside of it.
# EnablePresetLogging(PRESET_QUIET)
# EnablePresetLogging(PRESET_VERBOSE)
EnablePresetLogging(PRESET_DEBUG)
asyncio.get_event_loop().set_debug(enabled=True)
logger.info("pid {} asyncio {}, asyncio loop {}".format(
os.getpid(), asyncio, asyncio.get_event_loop()))
logger.info("""
====================================
| Launch VNIC (Address: {}, Pid: {})
====================================
""".format(vnic_address, os.getpid()))
loop = asyncio.get_event_loop()
loop.set_debug(enabled=True)
vnicStatusListeners.reset() # reset listeners
vnic = StatusVnic(vnic_address)
# Connection to the switch is optional. That is, the VNIC should be
# up and "operating" even if it can't connect to the switch. So
# start the server first.
coro = loop.create_server(vnic.controlConnectionFactory,
host="127.0.0.1",
port=port)
server = loop.run_until_complete(coro)
servingPort = server.sockets[0].getsockname()[1]
statusManager = StatusManager(statusfile, servingPort, switch_address,
switch_port, vnic)
vnicStatusListeners.listeners.add(statusManager)
statusManager.writeStatus("Disconnected")
switchConnector = ConnectToSwitchTask(vnic, switch_address, switch_port)
vnicStatusListeners.listeners.add(switchConnector)
switchConnector.connect()
logger.info("Run Forever")
loop.run_forever()
logger.info("Server Close")
server.close()
loop.close()
def main():
from OnlineBank import BankClientProtocol, BANK_FIXED_PLAYGROUND_ADDR, BANK_FIXED_PLAYGROUND_PORT
from CipherUtil import loadCertFromFile
#logctx = LoggingContext()
#logctx.nodeId = "parallelTSP_"+myAddr.toString()
# set this up as a configuration option
#logctx.doPacketTracing = True
#playground.playgroundlog.startLogging(logctx)
# Having placeHolders for asyncio
loop = asyncio.get_event_loop()
loop.set_debug(enabled=True)
ptspArgs = {}
from playground.common.logging import EnablePresetLogging, PRESET_VERBOSE, PRESET_DEBUG
EnablePresetLogging(PRESET_VERBOSE)
args= sys.argv[1:]
i = 0
for arg in args:
if arg.startswith("-"):
k,v = arg.split("=")
ptspArgs[k]=v
else:
ptspArgs[i] = arg
i+=1
stack = ptspArgs.get("-stack","default")
bankAddress = ptspArgs.get("-bankaddr", BANK_FIXED_PLAYGROUND_ADDR)
bankPort = ptspArgs.get("-bankport", BANK_FIXED_PLAYGROUND_PORT)
tracker = MobileCodeServerTracker()
tracker.startScan()
bankcert = loadCertFromFile(ptspArgs[0])
payeraccount = ptspArgs[2]
username = args[1]
pw = getpass.getpass("Enter bank password for {}: ".format(username))
bankstackfactory = lambda: BankClientProtocol(bankcert, username, pw)
wallet = PayingClientWallet(stack, bankstackfactory, username, pw, payeraccount,
bankAddress, bankPort)
clientAuth = SimplePayingClientAuth()
PTSP = ParallelTSP(tracker, clientAuth, wallet, n=50)
def initShell():
uiFactory = ParallelTSPCLI(PTSP)
uiFactory.registerExitListener(lambda reason: loop.call_later(2.0, loop.stop))
a = AdvancedStdio(uiFactory)
# loop.set_debug(enabled=True)
loop.call_soon(initShell)
# TODO - Will switchAddr be changed to "localhost" ?
# stack can be "default" or user provided stack from ~/.playgroun/connector
#parallelMaster = MobileCodeClient(stack, switchAddr, port, samplecode, NullClientAuth(), NullClientWallet())
#coro = playground.getConnector(stack).create_playground_connection(lambda: TwistedStdioReplacement.StandardIO(ParallelTSPCLI(configOptions, parallelMaster)),switchAddr, port)
#transport, protocol = loop.run_until_complete(coro)
loop.run_forever()
tracker.stopScan()
loop.close()
else:
echoArgs[i] = arg
i += 1
if "-stack" in echoArgs:
stack = echoArgs["-stack"]
if not 0 in echoArgs:
sys.exit(USAGE)
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,
def runSwitch(switch_type, host, port, statusfile):
# Don't import anything playground or asyncio related until after the fork.
from playground.network.devices import Switch, UnreliableSwitch
from playground.network.protocols.spmp import SPMPServerProtocol, FramedProtocolAdapter
from playground.common.logging import EnablePresetLogging, PRESET_NONE, PRESET_DEBUG, PRESET_LEVELS
import asyncio, logging
try:
EnablePresetLogging(PRESET_DEBUG)
logging.getLogger("playground").debug("start")
if switch_type == "unreliable":
BaseSwitch = UnreliableSwitch
else:
BaseSwitch = Switch
class SPMPSwitch(BaseSwitch):
def __init__(self, *args, **kargs):
super().__init__(*args, **kargs)
self.buildSpmpApi()
def setLogLevel(self, lvl):
EnablePresetLogging(lvl)
self._presetLogging = lvl
def buildSpmpApi(self):
self._presetLogging = PRESET_NONE
self.SPMPApi = {
"verbs" :(lambda : ", ".join(list(self.SPMPApi.keys()))),
"all-log-levels" :(lambda : ", ".join(PRESET_LEVELS)),
"get-log-level" :(lambda : self._presetLogging),
"set-log-level" :(lambda lvl: self.setLogLevel(lvl)),
}
if BaseSwitch == UnreliableSwitch:
self.SPMPApi.update( {
"get-error-rate" :(lambda : "Errors per Bytes = {}".format(self.getErrorRate())),
"set-error-rate" :(lambda rate, horizon: self.setErrorRate(int(rate), int(horizon))),
"get-delay-rate" :(lambda : "Every {} packets, delay {} second".format(*self.getDelayRate())),
"set-delay-rate" :(lambda rate, delay: self.setDelayRate(int(rate), float(delay)))
})
def ProtocolFactory(self):
logging.getLogger("playground.SPMPSwitch").debug("Producing Protocol")
originalProtocol = super().ProtocolFactory()
spmpServerProtocol = SPMPServerProtocol(self, self.SPMPApi)
framedProtocol = FramedProtocolAdapter(spmpServerProtocol, originalProtocol)
return framedProtocol
switch = SPMPSwitch()
loop = asyncio.get_event_loop()
coro = loop.create_server(switch.ProtocolFactory, host=host, port=port, family=socket.AF_INET)
server = loop.run_until_complete(coro)
servingPort = server.sockets[0].getsockname()[1]
if statusfile:
with open(statusfile,"w+") as f:
f.write("{}".format(servingPort))
logging.getLogger("playground.launch_switch").debug("start run forever on port {}".format(servingPort))
loop.run_forever()
server.close()
except Exception as e:
logging.getLogger("playground.launch_switch").debug("Launch of switch failed because: {}".format(e))
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()