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()