def talker(self): # In ROS, nodes are uniquely named. If two nodes with the same # node are launched, the previous one is kicked off. The # anonymous=True flag means that rospy will choose a unique # name for our 'talker' node so that multiple talkers can # run simultaneously. rospy.init_node('blockly_server', anonymous=True) rospy.Subscriber("blockly", String, RobotBlocklyBackend.callback) CodeStatus.initialize_publisher() self.__current_block_publisher = rospy.Publisher('current_block_id', String, queue_size=5) rospy.Service('program_is_paused', Trigger, RobotBlocklyBackend.__is_status_paused) rospy.Service('program_completed', Empty, RobotBlocklyBackend.__set_status_completed) rospy.Service('program_set_current_block_id', SetCurrentBlockId, self.__set_current_block_id) factory = WebSocketServerFactory(u"ws://0.0.0.0:9000") factory.protocol = BlocklyServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, '0.0.0.0', 9000) server = loop.run_until_complete(coro) asyncio. async (RobotBlocklyBackend.wait_until_ros_node_shutdown(loop)) loop.run_forever() print("Closing...") server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def run_server(): logging.basicConfig( format='%(asctime)s <%(levelname)s> %(message)s', level=logging.DEBUG, ) logging.info('Starting server') localIP = utils.get_local_ip() port = 5678 serverString = u"ws://" + localIP + ":" + str(port) logging.info("Creating server on: " + serverString) factory = WebSocketServerFactory(serverString) factory.protocol = WosciServerProtocol asyncioLoop = asyncio.get_event_loop() coRoutine = asyncioLoop.create_server(factory, host=None, port=port) server = asyncioLoop.run_until_complete(coRoutine) try: asyncioLoop.run_forever() except KeyboardInterrupt: logging.warning("Received KeyboardInterrupt. Closing server.") finally: logging.info("Closing server...") server.close() asyncioLoop.stop() logging.info("Bye bye!")
def start_server(address, port): # see http://autobahn.ws/python/websocket/programming.html # accept both string and int, since client has to accept int if isinstance(port, int): port = str(port) global lobby_count lobby_count = 0 composite_address = 'ws://' + address + ':' + port info("starting websocket server at {}".format(composite_address), INFO_ID) factory = WebSocketServerFactory(composite_address) factory.protocol = GameServerProtocol loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) loop = asyncio.get_event_loop() coro = loop.create_server(factory, address, port) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: info('cleaning up.', INFO_ID) finally: server.close() loop.close()
def startWebsocketServer(): print(blue("Websocket server starting up...")) try: import asyncio except ImportError: ## Trollius >= 0.3 was renamed import trollius as asyncio #Asyncio only setups an event loop in the main thread, else we need to if threading.current_thread().name != 'MainThread': loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) factory = WebSocketServerFactory("ws://0.0.0.0:9000", debug=False) factory.protocol = TranslatronProtocol loop = asyncio.get_event_loop() server = loop.create_server(factory, '0.0.0.0', 9000) server = loop.run_until_complete(server) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def talker(self): rospy.init_node('blockly_server', anonymous=True) rospy.Subscriber("blockly", String, RobotBlocklyBackend.callback) CodeStatus.initialize_publisher() self.__current_block_publisher = rospy.Publisher('current_block_id', String, queue_size=5) rospy.Service('program_is_paused', Trigger, RobotBlocklyBackend.__is_status_paused) rospy.Service('program_completed', Empty, RobotBlocklyBackend.__set_status_completed) rospy.Service('program_set_current_block_id', SetCurrentBlockId, self.__set_current_block_id) socket_host = "127.0.0.1" socket_port = 9002 socket_url = "ws://%s:%s" % (socket_host, socket_port) factory = WebSocketServerFactory(socket_url) factory.protocol = BlocklyServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, '0.0.0.0', socket_port) server = loop.run_until_complete(coro) asyncio. async (RobotBlocklyBackend.wait_until_ros_node_shutdown(loop)) loop.run_forever() print("Closing...") server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def start_websocket_server(): """ Function to get the websocket server going and run the event loop that feeds it. """ # We need a new loop in case some other process has already started the # main loop. In principle we might be able to do a check for a running # loop but this works whether or not a loop is running. __interact_loop = asyncio.new_event_loop() # Need to do two things before starting the server factory: # # 1. Set our loop to be the default event loop on this thread asyncio.set_event_loop(__interact_loop) # 2. Line below is courtesy of # https://github.com/crossbario/autobahn-python/issues/1007#issuecomment-391541322 txaio.config.loop = __interact_loop # Now create the factory, start the server then run the event loop forever. __factory = WebSocketServerFactory( u"ws://localhost:{}/".format(__SOCKET_PORT)) __factory.protocol = WSserver __coro = __interact_loop.create_server(__factory, '0.0.0.0', __SOCKET_PORT) __interact_loop.run_until_complete(__coro) __interact_loop.run_forever()
def start(self): self.print_debug("start() called... debug = {}".format(self.debug)) ws = "ws" sslcontext = None if self.ssl: try: sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23) sslcontext.load_cert_chain(self.sslcert, self.sslkey) self.print_debug("using ssl") except Exception as ex: sslcontext = None self.print_debug("failed to use ssl") raise Exception("failed to use ssl: {}".format(ex)) ws = "wss" ResourceProtocol.server = self factory = WebSocketServerFactory(u"{0}://127.0.0.1:{1}".format( ws, self.port)) factory.protocol = ResourceProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, '', self.port, ssl=sslcontext) self.server = loop.run_until_complete(coro) self.print_debug("server should be started now")
def ws_api(): class ChooWebsocketServerProtocol(WebSocketServerProtocol): def onConnect(self, request): pass def onOpen(self): self.instance = ChooInstance(lambda r: self.sendMessage(r)) def onMessage(self, payload, isBinary): result = self.instance.handle_msg(payload) self.sendMessage(result) def connectionLost(self, reason): self.instance.abort_queries() loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) factory = WebSocketServerFactory('ws://%s:%d' % (args.ws_host, args.ws_port)) factory.protocol = ChooWebsocketServerProtocol factory.setProtocolOptions(allowHixie76=True) loop = asyncio.get_event_loop() coro = loop.create_server(factory, args.ws_host, args.ws_port) loop.run_until_complete(coro) loop.run_forever()
def talker(): # In ROS, nodes are uniquely named. If two nodes with the same # node are launched, the previous one is kicked off. The # anonymous=True flag means that rospy will choose a unique # name for our 'talker' node so that multiple talkers can # run simultaneously. rospy.init_node('rosimple_server', anonymous=True) rospy.Subscriber("rosimple", String, callback) try: import asyncio except ImportError: # Trollius >= 0.3 was renamed import trollius as asyncio factory = WebSocketServerFactory(u"ws://0.0.0.0:9000", debug=False) factory.protocol = ROSimpleServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, '0.0.0.0', 9000) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def main(*args): """ Starts the autobahn websockets server, and the receive loop for zeroMQ. Defaults for the ZeroMQ address (also overridable via commandline) and the websockets server can be overridden in the settings module. """ receive_loop = threading.Thread(target=backend.receive_loop, args=args) receive_loop.start() factory = WebSocketServerFactory() factory.protocol = GraphProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, *settings.WEBSOCKETS_ADDRESS) server = loop.run_until_complete(coro) try: print('Starting the websockets server on %s:%d' % settings.WEBSOCKETS_ADDRESS) loop.run_forever() except KeyboardInterrupt: pass finally: print('Closing down the websockets server') server.close() loop.close() sys.exit(0)
def __init__(self): self.loop = asyncio.get_event_loop() self.wsthread = threading.Thread(target=self.__run_loop, args=(self.loop, )) self.factory = WebSocketServerFactory(u"ws://{}:{}".format( config.PRIVATE_HOST_IP, config.WEBSOCKET_PORT)) self.factory.protocol = A3EWebsocketServerProtocol
def __init__(self, protocol, host='127.0.0.1', port='9000'): self.host = host self.port = port self.protocol = protocol self.url = f"ws://{host}:{port}" self.factory = WebSocketServerFactory(self.url) self.factory.protocol = protocol self.server = None
def __init__(self, protocol, port=9000): self.factory = WebSocketServerFactory() self.factory.protocol = protocol self.port = port # ASYNCIO server params self.loop = None self.coro = None self.server = None
def __init__(self, ip, port): ip_str = str(ip) port_int = int(port) wsip = u"ws://" + ip_str + u":" + str(port_int) factory = WebSocketServerFactory(wsip) factory.protocol = ChallengeProtocolB self.loop = trollius.get_event_loop() self.coro = self.loop.create_server(factory, ip_str, port_int) #self.server = self.loop.run_until_complete(self.coro) print("WebSockets configured on %s" % wsip)
def main(): try: import asyncio except ImportError: # Trollius >= 0.3 was renamed import trollius as asyncio factory = WebSocketServerFactory(u"ws://127.0.0.1:9000") factory.protocol = MyServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, '0.0.0.0', 9000) import asyncio_redis @asyncio.coroutine def example(): """ The function that subscribes to redis channel and waits for messages. Once one appear the function stores it in global messages. @return: """ # Create connection connection = yield from asyncio_redis.Connection.create( host='127.0.0.1', port=6379) # Create subscriber. subscriber = yield from connection.start_subscribe() # Subscribe to channel. yield from subscriber.subscribe(['our-channel']) # Inside a while loop, wait for incoming events. while True: reply = yield from subscriber.next_published() messages.append(repr(reply.value)) logging.info('Received: {} on channel {}'.format( repr(reply.value), repr(reply.channel))) #print('Received: ', repr(reply.value), 'on channel', reply.channel) # When finished, close the connection. connection.close() loop = asyncio.get_event_loop() server = asyncio. async (coro) subscriber = asyncio. async (example()) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def test_websocket_custom_loop(self): def time_gen(): yield yield loop = AsyncioTestLoop(time_gen) factory = WebSocketServerFactory(loop=loop) server = factory() transport = Mock() server.connection_made(transport)
def __init__(self, protocol, ip='127.0.0.1', port=9000): ip_str = str(ip) port_int = int(port) wsip = u"ws://" + ip_str + u":" + str(port_int) factory = WebSocketServerFactory(wsip) factory.protocol = protocol self.loop = trollius.get_event_loop() #self.loop.set_debug(False) self.coro = self.loop.create_server(factory, ip_str, port_int) self.server = self.loop.run_until_complete(self.coro) print("WebSockets configured on %s" % wsip)
def __init__(self, loop=asyncio.get_event_loop()): sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23) sslcontext.load_cert_chain(certfile='server.crt', keyfile='server.key') self.factory = WebSocketServerFactory('wss://0.0.0.0:9001') self.factory.protocol = SignalProtocol coro = loop.create_server(self.factory, '0.0.0.0', 9001, ssl=sslcontext) self.server = loop.run_until_complete(coro)
def main(): config = load_configuration() ServerState.logger = get_logger(config, 'CoreWS') address = config.get('CoreWS', 'address', '0.0.0.0') port = int(config.get('CoreWS', 'port', '9000')) mq_servers = comma_string_to_list( config.get('CoreMQ', 'cluster_nodes', '').split(',')) ServerState.logger.info('CoreWS Starting up...') ws_factory = WebSocketServerFactory('ws://%s:%s/ws' % (address, port)) ws_factory.protocol = WsProtocol loop = asyncio.get_event_loop() server_coro = loop.create_server(ws_factory, address, port) server = loop.run_until_complete(server_coro) ServerState.logger.info('WebSocket Server running') mq_factory = CoreMqClientFactory(WsMqClient, mq_servers, loop=loop) @asyncio.coroutine def connect(*args): ServerState.mq_connection = None while True: yield asyncio.From(mq_factory.connect()) if not mq_factory.connection: ServerState.logger.warn( 'No CoreMQ servers found. Retrying in 3 seconds...') yield asyncio.From(asyncio.sleep(3)) else: conn = mq_factory.connection[1] conn.connected_future.add_done_callback( lambda _: conn.begin_replication('%s:%s' % ( socket.gethostname(), port))) ServerState.mq_connection = conn break mq_factory.lost_connection_callback = connect loop.run_until_complete(connect()) try: loop.run_forever() except KeyboardInterrupt: pass finally: ServerState.logger.info('Shutting down WebSocket Server...') server.close() ServerState.logger.info('Shutting down MQ Client...') mq_factory.close() loop.close() ServerState.logger.info('CoreWS is now shut down')
def start_server(host='0.0.0.0', port=2087, loop=None): factory = WebSocketServerFactory() factory.protocol = LspWebsocketHandler if not loop: loop = asyncio.get_event_loop() coroutine = loop.create_server(factory, host, port) server = loop.run_until_complete(coroutine) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def server(): factory = WebSocketServerFactory(URI) factory.protocol = ServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, IP, PORT) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def sockets(): factory = WebSocketServerFactory(u"ws://127.0.0.1:9000") factory.protocol = MyServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, '0.0.0.0', 9000) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def test_async_on_connect_server(self): # see also issue 757 # for python 3.5, this can be "async def foo" def foo(x): f = txaio.create_future() txaio.resolve(f, x * x) return f values = [] def on_connect(req): f = txaio.create_future() def cb(x): f = foo(42) f.add_callbacks(f, lambda v: values.append(v), None) return f txaio.add_callbacks(f, cb, None) return f factory = WebSocketServerFactory() server = factory() server.onConnect = on_connect transport = Mock() server.connection_made(transport) # need/want to insert real-fake handshake data? server.data = b"\r\n".join([ b'GET /ws HTTP/1.1', b'Host: www.example.com', b'Sec-WebSocket-Version: 13', b'Origin: http://www.example.com.malicious.com', b'Sec-WebSocket-Extensions: permessage-deflate', b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==', b'Connection: keep-alive, Upgrade', b'Upgrade: websocket', b'\r\n', # last string doesn't get a \r\n from join() ]) server.processHandshake() import asyncio from asyncio.test_utils import run_once run_once(asyncio.get_event_loop()) self.assertEqual(1, len(values)) self.assertEqual(42 * 42, values[0])
def _start_loop(config: ConfigParser, port: int, pid_file: str): try: database = _get_zodb_database(config) ClientCommunicator.zodb_database = database rest_url = _get_rest_url(config) ClientCommunicator.rest_url = rest_url factory = WebSocketServerFactory('ws://localhost:{}'.format(port)) factory.protocol = ClientCommunicator loop = asyncio.get_event_loop() coro = loop.create_server(factory, port=port) logger.debug('Started WebSocket server listening on port %i', port) server = loop.run_until_complete(coro) _run_loop_until_interrupted(loop, server) finally: logger.info('Stopped WebSocket server') _remove_pid_file(pid_file)
def main(): factory = WebSocketServerFactory() factory.protocol = MyServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, '127.0.0.1', 8765) server = loop.run_until_complete(coro) loop.run_until_complete( asyncio.gather(*[ listen_command(), read_command(), # write_command(), print_stats() ])) loop.run_forever() loop.close() server.close()
def __init__(self, hostname="localhost", port="8080", processor=None): self.hostname = hostname self.port = port self.processor = processor factory = WebSocketServerFactory(u"ws://" + hostname + u":" + str(port)) protocol = EventProtocol protocol.processor = processor protocol.app = self factory.protocol = protocol self.loop = asyncio.get_event_loop() self.server = self.loop.create_server(factory, '0.0.0.0', port)
def start_server(host='127.0.0.1', port=9000): address = 'ws://' + host + ':' + str(port) factory = WebSocketServerFactory(address) factory.protocol = MyServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, '0.0.0.0', port) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def run(args): use_ssl = Config.get('expose.websocket.pem') != "" # use an ssl prefix if we have a pem file if use_ssl: prefix = "wss" else: prefix = "ws" # build the full URL of the web socket end-point url = "{0}://{1}:{2}".format(prefix, Config.get('expose.websocket.host'), Config.get('expose.websocket.port')) logger.info("starting web-socket server at %s", url) factory = WebSocketServerFactory(url) factory.protocol = PubSubProtocol # setup the main event loop for network i/o loop = asyncio.get_event_loop() # create an ssl context if we need one if use_ssl: context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) context.load_cert_chain(Config.get('expose.websocket.pem')) logger.debug("using ssl") else: context = None logger.debug("not using ssl") coro = loop.create_server(factory, host=Config.get('expose.websocket.host'), port=Config.get('expose.websocket.port'), ssl=context) server = loop.run_until_complete(coro) # setup publishers coroutines publishers = create_publishers() loop.run_until_complete(publishers) try: loop.run_forever() except KeyboardInterrupt: pass finally: publishers.close() server.close() loop.close()
def run(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) if self.mode == settings.NetworkEngineMode.HOST: self.factory = WebSocketServerFactory() self.factory.protocol = ConnectFourServerProtocol self.coro = self.loop.create_server(self.factory, self.ip, 80) elif self.mode == settings.NetworkEngineMode.JOIN: self.factory = WebSocketClientFactory() self.factory.protocol = ConnectFourClientProtocol self.coro = self.loop.create_connection(self.factory, self.ip, 80) self.connection = self.loop.run_until_complete(self.coro) self.loop.run_forever()
def startServer(): factory = WebSocketServerFactory() factory.protocol = ServerProtocol factory.setProtocolOptions(autoPingInterval=1) factory.setProtocolOptions(requireMaskedClientFrames=False) loop = asyncio.get_event_loop() coro = loop.create_server(factory, HOST, PORT) server = loop.run_until_complete(coro) print('Autobahn server is started at ws://{}:{}'.format(HOST, PORT)) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()