def run(): loop = asyncio.get_event_loop() httpServer = asyncio.start_server(serve, host="0.0.0.0", port=http_server_port) wsServer = asyncio.start_server(websocketHandle, host="0.0.0.0", port=ws_server_port) loop.call_soon(httpServer) loop.create_task(wsServer) loop.create_task(blink()) loop.create_task(temperature()) try: loop.run_forever() except Exception as err: httpServer.close() wsServer.close() loop.close() raise err
def get_task(self, host='0.0.0.0', port=80, debug=False): gc.collect() self.debug = int(debug) self.init() if debug: print("* Running on http://%s:%s/" % (host, port)) return asyncio.start_server(self._handle, host, port)
def boot(self): super().boot() uart.init(**self.load()['uart']) loop = get_event_loop() loop.create_task( start_server(Serial.getInstance().handle, '0.0.0.0', 23)) loop.create_task(Serial.getInstance().readln())
def run(host="192.168.4.1", port=8081, loop_forever=True, backlog=16): loop = asyncio.get_event_loop() print("* Starting Server at {}:{}".format(host, port)) loop.create_task(asyncio.start_server(_handler, host, port, backlog=backlog)) if loop_forever: loop.run_forever() loop.close()
def main(): loop = uasyncio.get_event_loop() loop.create_task(set_time()) loop.create_task(pump_routine()) # loop.create_task(check_moisture()) loop.create_task(uasyncio.start_server(webapp.handle, '0.0.0.0', 80)) loop.run_forever()
def start(root_path='/wwwroot', default_document='index.html', network_port=80): try: my_address = get_address() loop = asyncio.get_event_loop() print('Starting DNS server...') mydnsserver = MyDNSServer() loop.create_task(mydnsserver.handle_query(my_address)) print('Starting web server at {0}:{1}...'.format( my_address, network_port)) myhttpserver = MyHTTPServer(root_path, default_document, network_port) server = asyncio.start_server(myhttpserver.handle_request, "0.0.0.0", network_port) loop.create_task(server) print('...(<ctrl>+c to stop)...') loop.run_forever() except KeyboardInterrupt: print('Servers stopped.') finally: asyncio.new_event_loop()
def run(self, host='0.0.0.0', port=5000, debug=False): self.debug = debug async def serve(reader, writer): if not hasattr(writer, 'awrite'): # pragma: no cover # CPython provides the awrite and aclose methods in 3.8+ async def awrite(self, data): self.write(data) await self.drain() async def aclose(self): self.close() await self.wait_closed() from types import MethodType writer.awrite = MethodType(awrite, writer) writer.aclose = MethodType(aclose, writer) await self.dispatch_request(reader, writer) if self.debug: # pragma: no cover print('Starting async server on {host}:{port}...'.format( host=host, port=port)) loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.start_server(serve, host, port)) loop.run_forever() loop.close() # pragma: no cover
def serve(self, loop, host, port): # Actually serve client connections. Subclasses may override this # to e.g. catch and handle exceptions when dealing with server socket # (which are otherwise unhandled and will terminate a Picoweb app). # Note: name and signature of this method may change. loop.create_task(asyncio.start_server(self._handle, host, port)) loop.run_forever()
def httpserver(fromcard = False, rootpath = '', watchdog = False): global webroot #logging.basicConfig(level=logging.ERROR) addr = get_address() if fromcard: from shields import microsd_shield sdcard = microsd_shield.MicroSD_Shield() sdcard.mount() webroot = '/sd/wwwroot' if rootpath: webroot = rootpath #uasyncio.set_debug(1) loop = uasyncio.get_event_loop() loop.create_task(uasyncio.start_server(serve_content, addr, 80, 20)) if watchdog: from machine import Pin, WDT wdt = WDT() wdt.feed() led = Pin(2, Pin.OUT) loop.create_task(heartbeat(wdt, led)) loop.run_forever() loop.close() if fromcard: sdcard.unmount() #httpserver()
async def PASV(self, stream, argument): if self.addr != "0.0.0.0": result = '227 Entering Passive Mode ({},{},{}).\r\n'.format( self.addr.replace('.', ','), self.dport >> 8, self.dport % 256) log.debug("PASV: {}".format(result)) await _awrite(stream, result) if not self._run_pasv: log.info("Start Passive Data Server to %s %d" % (self.addr, self.dport)) loop = asyncio.get_event_loop() loop.call_soon( asyncio.start_server(self.data_server, "0.0.0.0", self.dport)) #loop.call_soon(asyncio.start_server, self.data_server, "0.0.0.0", self.dport) self.con_type = "passive" self._run_pasv = True return True else: await _awrite(stream, "221 Bye!.\r\n") return False
def main(): global car_actions init_logger() # Initialize the car and stop it from moving car = Car(CAR_CONF) car.stop() # Define the actions that the Car supports car_actions = { "FORWARD": car.forward, "REVERSE": car.reverse, "TURN_LEFT": car.turn_left, "TURN_RIGHT": car.turn_right, "ACCELERATE": car.accelerate, "DECELERATE": car.decelerate, "STOP": car.stop } coro = asyncio.start_server(handle_car_data, host=HOST, port=PORT) log.info('[HANDLE_DATA] Starting uasyncio event loop') loop.create_task(coro) loop.run_forever() log.info('[HANDLE_DATA] Finishing uasyncio event loop') loop.close() # Stop the car to avoid crashes ;) car.stop()
def run(): global robot_busy robot_busy = False loop = asyncio.get_event_loop() loop.call_soon(asyncio.start_server(serve, "192.168.4.1", 80)) loop.run_forever() loop.close()
def start(loop=None, port=21, preload=False): """ Start the ftp server with asyncio loop. loop : asyncio loop object port : tcp/ip port of the server preload : True = preload the server at the start, False = load the server at the first connection """ server = Ftp(port, preload) # If asyncio loop not created if loop == None: # Create asyncio loop loop = uasyncio.get_event_loop() # Run for ever in this case the ftp server run_forever = True else: # The ftp server is called on asyncio connection run_forever = False # Start ftp server on port specified asyncServer = uasyncio.start_server(server.onConnection, "0.0.0.0", port, backlog=1) # Create asyncio task loop.create_task(asyncServer) # If ftp server is stand alone mode if run_forever: loop.run_forever()
def initialize(self): print("Initialize threads") loop = uasyncio.get_event_loop() loop.create_task(self.dht_m.measureTempAndHum()) loop.call_soon(uasyncio.start_server(self.api.process, "0.0.0.0", 80)) loop.run_forever() pass
def runhotspotserver(): import network si = network.WLAN(network.AP_IF) # create access-point interface macaddress = "".join("{:02x}".format(x) for x in si.config("mac")) si.active(True) # activate the interface print("Creating access point ESP_{}".format(macaddress[-6:])) ipnumber = si.ifconfig()[0] print("Device has ipnumber", ipnumber) import uasyncio as asyncio def handleconnection_indirect(reader, writer): try: return handleconnection(reader, writer) except OSError as e: print("handleconnection exception", str(e)) port = 80 loop = asyncio.get_event_loop() print("* Running on http://%s:%s/" % (ipnumber, port)) loop.create_task( asyncio.start_server(handleconnection_indirect, ipnumber, port)) loop.run_forever()
def main(): print("Wait until connected to known APs") while not try_connect_to_known_aps(): sleep(5) pass print("Network config:", sta_if.ifconfig()) PeripheralConfig["IP"], *_ = sta_if.ifconfig() loop = get_event_loop() print("Creating discovery server udp://{IP}:{DISCOVERY_PORT}".format( **PeripheralConfig)) loop.create_task( start_discovery_server(PeripheralConfig["IP"], PeripheralConfig["DISCOVERY_PORT"])) print("Creating websocket server tcp://{IP}:{LINK_PORT}".format( **PeripheralConfig)) loop.create_task( start_server(link_endpoint_handler, PeripheralConfig["IP"], PeripheralConfig["LINK_PORT"])) import gc gc.collect() print("Eventloop: run_forever()") loop.run_forever() loop.close()
def main(): loop = asyncio.get_event_loop() loop.create_task(heartbeat()) #loop.create_task(calc_sunrise_sunset()) loop.create_task(measure_dht()) loop.create_task(asyncio.start_server(webapp.handle, '0.0.0.0', 80)) gc.collect() loop.run_forever()
def start_dome(): machine.freq(160000000) loop = uasyncio.get_event_loop() loop.create_task(DeviceHandler.main()) loop.create_task(uasyncio.start_server(conn_handler, "0.0.0.0", 8081)) loop.run_forever() loop.close()
def run(self, host, port): import uasyncio try: loop = uasyncio.get_event_loop() loop.create_task(uasyncio.start_server(self.serve, host, port)) loop.run_forever() finally: loop.close()
def __init__(self): self.rawLidarReadings = None self.server = uasyncio.start_server(self.tcp_callback, my_ip, TCP_PORT, backlog=5) self.i2c_master = i2c_master.I2C_master(self) uasyncio.create_task(self.server)
def start(): #import logging #logging.basicConfig(level=logging.ERROR) loop = asyncio.get_event_loop() loop.call_soon(asyncio.start_server(serve, "0.0.0.0", 80, 20)) loop.run_forever() loop.close()
def start(self, addr="0.0.0.0", port=23): loop = asyncio.get_event_loop() if not self.run: loop.create_task(asyncio.start_server(self.server, addr, port)) log.info("Telnet server started on {}:{}".format(addr, port)) self.run = "{};{}".format(addr, port) return True
def main(robo): loop = uasyncio.get_event_loop() loop.create_task(heartbeat(robo)) loop.create_task(can_send(robo)) loop.create_task( uasyncio.start_server(tcp_callback, "192.168.137.10", 8123, backlog=1)) loop.run_forever() loop.close()
def create_server(): loop = asyncio.get_event_loop() loop.call_soon( asyncio.start_server( handle_request, '0.0.0.0', 80, backlog=100, ) )
def async_main(): loop = asyncio.get_event_loop() loop.create_task( asyncio.start_server(configserver.handle_request, "0.0.0.0", 80, 1)) loop.create_task(main_state_machine()) loop.run_forever() loop.close()
def main(): """ Set up the tasks and start the event loop """ connect() loop = asyncio.get_event_loop() loop.create_task(set_time()) loop.create_task(calc_sunrise_sunset()) loop.create_task(door_check()) loop.create_task(asyncio.start_server(webapp.handle, '0.0.0.0', 80)) gc.collect() loop.run_forever()
def run(self, host="127.0.0.1", port=8081, debug=False, lazy_init=False): self.debug = int(debug) self.init() if not lazy_init: for app in self.mounts: app.init() loop = asyncio.get_event_loop() if debug: print("* Running on http://%s:%s/" % (host, port)) loop.create_task(asyncio.start_server(self._handle, host, port)) loop.run_forever() loop.close()
def init_as_task(host="127.0.0.1", port=8081, debug=False, lazy_init=False): gc.collect() self.debug = int(debug) self.init() if not lazy_init: for app in self.mounts: app.init() if debug: print("* Running on http://%s:%s/" % (host, port)) return asyncio.start_server(self._handle, host, port)
def start(server_paths): global ServerPaths ServerPaths = server_paths loop = asyncio.get_event_loop() loop.create_task(asyncio.start_server(serve, "0.0.0.0", 80, 20)) try: loop.run_forever() except KeyboardInterrupt: print("User terminated") finally: print("closing") loop.close()
def run(self): loop = uasyncio.get_event_loop() loop.create_task( uasyncio.start_server(self.request_handler, '0.0.0.0', 80)) loop.create_task(self.feed_watchdog()) from led_dim_level_cfg import restore_power_led_level Pins.power_led.on() restore_power_led_level() del restore_power_led_level del sys.modules['led_dim_level_cfg'] print(self.message) loop.run_forever()
def run(self, host="127.0.0.1", port=8081, debug=False, lazy_init=False, log=None): if log is None and debug >= 0: import ulogging log = ulogging.getLogger("picoweb") if debug > 0: log.setLevel(ulogging.DEBUG) self.log = log gc.collect() self.debug = int(debug) self.init() if not lazy_init: for app in self.mounts: app.init() loop = asyncio.get_event_loop() if debug > 0: print("* Running on http://%s:%s/" % (host, port)) loop.create_task(asyncio.start_server(self._handle, host, port)) loop.run_forever() loop.close()
def run(self, debug=False): if debug: import logging logging.basicConfig(level=logging.DEBUG) loop = asyncio.get_event_loop() this = self @asyncio.coroutine def serve(reader, writer): yield from this.serve(reader, writer) loop.call_soon(asyncio.start_server( client_coro=serve, host=self._bind_addr, port=self._port, backlog=self._backlog )) loop.run_forever() loop.close()
def test_client_server(self): '''Simple client-server echo test''' sockaddr = ('127.0.0.1', 8080) l = get_event_loop() async def echo_server(reader, writer): data = await reader.readline() await writer.awrite(data) await writer.aclose() async def echo_client(line, result): await sleep_ms(10) # Allow server to get up reader, writer = await open_connection(*sockaddr) await writer.awrite(line) data = await reader.readline() await writer.aclose() result.append(data) # capture response result = [] l.create_task(start_server(echo_server, *sockaddr)) l.run_until_complete(echo_client(b'Hello\r\n', result)) self.assertEqual(result[0], b'Hello\r\n')
global cnt #s = "Hello.\r\n" s = "Hello. %07d\r\n" % cnt cnt += 1 yield from reader.read() yield from writer.awrite("HTTP/1.0 200 OK\r\n\r\n") try: yield from writer.awrite(s) yield from writer.awrite(s * 100) yield from writer.awrite(s * 400000) yield from writer.awrite("=== END ===") yield from writer.close() except OSError as e: if e.args[0] == errno.EPIPE: print("EPIPE") elif e.args[0] == errno.ECONNRESET: print("ECONNRESET") else: raise import logging logging.basicConfig(level=logging.INFO) #logging.basicConfig(level=logging.DEBUG) signal.signal(signal.SIGPIPE, signal.SIG_IGN) loop = asyncio.get_event_loop() mem_info() loop.call_soon(asyncio.start_server(serve, "0.0.0.0", 8081, backlog=100)) loop.run_forever() loop.close()
import uasyncio as asyncio @asyncio.coroutine def serve(reader, writer): #print(reader, writer) #print("================") yield from reader.read(256) yield from writer.awrite("HTTP/1.0 200 OK\r\n\r\nHello.\r\n") yield from writer.aclose() #print("Finished processing request") import logging #logging.basicConfig(level=logging.INFO) logging.basicConfig(level=logging.DEBUG) loop = asyncio.get_event_loop() #mem_info() loop.create_task(asyncio.start_server(serve, "127.0.0.1", 8081, backlog=100)) loop.run_forever() loop.close()
import uasyncio as asyncio @asyncio.coroutine def serve(reader, writer): print(reader, writer) print("================") print((yield from reader.read())) yield from writer.awrite("HTTP/1.0 200 OK\r\n\r\nHello.\r\n") print("After response write") yield from writer.close() print("Finished processing request") import logging #logging.basicConfig(level=logging.INFO) logging.basicConfig(level=logging.DEBUG) loop = asyncio.get_event_loop() mem_info() loop.call_soon(asyncio.start_server(serve, "127.0.0.1", 8081)) loop.run_forever() loop.close()