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 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 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 start_websocket_server(): """Function to start the websocket server.""" import asyncio if not os.path.exists(LOGFOLDER): os.makedirs(LOGFOLDER) logging.basicConfig(filename=LOGFOLDER+ "/" + WEBSOCKETLOG,level=LOGLEVEL) logging.info("Starting Server") loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) factory = WebSocketServerFactory( u"ws://127.0.0.1:" + str(PORT) + "/" + WS_URL, DEBUG) factory.protocol = GraphalyzerServerProtocol coro = loop.create_server(factory, '0.0.0.0', PORT) server = loop.run_until_complete(coro) try: logging.info("Server started") loop.run_forever() except KeyboardInterrupt: pass finally: logging.info("Server shutting down") server.close() 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_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 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 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", debug=False) 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 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 main(): loop = asyncio.get_event_loop() db = loop.run_until_complete( aiozmq.rpc.connect_rpc( connect=os.environ['DBSERVER_PORT_5000_TCP'], translation_table=translation_table, timeout=5)) # Is this good idea to have one connection? game = loop.run_until_complete( aiozmq.rpc.connect_rpc( connect=os.environ['GAME_PORT_5200_TCP'], translation_table=translation_table, error_table=error_table, timeout=5)) def create_protocol(*args, **kwargs): return FrontendHandler(db=db, game=game, *args, **kwargs) factory = WebSocketServerFactory( url='ws://{}:{}'.format(os.environ['FRONTEND_ADDR'], os.environ['FRONTEND_PORT']), loop=loop) factory.protocol = create_protocol server = loop.run_until_complete( loop.create_server(factory, '0.0.0.0', os.environ['FRONTEND_PORT'])) 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 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 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("blockly_server", anonymous=True) rospy.Subscriber("blockly", 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 = BlocklyServerProtocol 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 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 launch_server(): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) factory = WebSocketServerFactory() factory.protocol = MyServerProtocol coro = loop.create_server(factory, WS_HOST, WS_PORT) server = loop.run_until_complete(coro) loop.run_forever()
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 __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 __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 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 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 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 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 run_liveview_server(liveview_url): # set new event loop because there is no default event loop. # asyncio.set_event_loop(asyncio.new_event_loop()) factory = WebSocketServerFactory("ws://localhost:9000", debug=False) factory.protocol = LiveviewServerProtocol(liveview_url) loop = asyncio.get_event_loop() coro = loop.create_server(factory, "127.0.0.1", 9000) server = loop.run_until_complete(coro) loop.run_forever() server.close() loop.close()
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 __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 _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 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 main(): PORT = 8765 factory = WebSocketServerFactory('ws://localhost:%d' % PORT) factory.protocol = TestProtocol loop = asyncio.get_event_loop() start_server = loop.create_server(factory, '127.0.0.1', PORT) server = loop.run_until_complete(start_server) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def startWebSocketServer(address, port): print("Starting WebSocket server...") factory = WebSocketServerFactory() factory.protocol = RobotServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, address, port) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close() setdefault() ledDisplay.shutOff()
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()
def main(): PORT = 8765 factory = WebSocketServerFactory('ws://localhost:%d' % PORT) factory.protocol = TestProtocol loop = asyncio.get_event_loop() start_server = loop.create_server(factory, '127.0.0.1', PORT) server = loop.run_until_complete(start_server) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def talker(self, port=8128): factory = WebSocketServerFactory(u"ws://0.0.0.0:%d" % port) factory.protocol = self.protocol self.loop = asyncio.get_event_loop() coro = self.loop.create_server(factory, '0.0.0.0', port) server = self.loop.run_until_complete(coro) asyncio.ensure_future(self.wait_until_shutdown(self.loop)) # signal.signal(signal.SIGINT, self.signal_handler) self.loop.run_forever() info("Closing...") server.close() self.loop.run_until_complete(server.wait_closed()) self.loop.close()
def installer_service(): from autobahn.asyncio.websocket import WebSocketServerFactory loop = asyncio.get_event_loop() factory = WebSocketServerFactory() factory.protocol = InstallServerProtocol loop.set_debug(True) print "Starting" coro = loop.create_server(factory, '127.0.0.1', 9190) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: server.close() loop.close() finally: server.close() loop.close()
def run(): import asyncio from autobahn.asyncio.websocket import WebSocketServerFactory factory = WebSocketServerFactory() factory.protocol = MessageServer 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 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 start(): port = get_free_port() prepare_html(port) factory = WebSocketServerFactory(u'ws://127.0.0.1:' + str(port)) factory.protocol = MyServerProtocol loop = asyncio.ProactorEventLoop() asyncio.set_event_loop(loop) coro = loop.create_server(factory, '127.0.0.1', port) logger.info('starting server') server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def ws_exec(): factory = WebSocketServerFactory() factory.protocol = MyServerProtocol t = threading.Thread(target=md_exec,args=()) t.setDaemon(True) t.start() loop = asyncio.get_event_loop() coro = loop.create_server(factory, '127.0.0.1', 9002) server = loop.run_until_complete(coro) print("server created") try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def ws_exec(): factory = WebSocketServerFactory() factory.protocol = MyServerProtocol t = threading.Thread(target=md_exec, args=()) t.setDaemon(True) t.start() loop = asyncio.get_event_loop() coro = loop.create_server(factory, '127.0.0.1', 9002) server = loop.run_until_complete(coro) print("server created") try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def startTwisted(self): from twisted.python import log log.startLogging(open("wssserver.log", "w")) self.print_debug("startTwisted() started") ws = "ws" ResourceProtocol.server = self sslcontext = None if self.ssl: self.print_debug("using wss... and ssl") sslcontext = ssl.DefaultOpenSSLContextFactory(self.sslkey, self.sslcert) ws = "wss" factory = WebSocketServerFactory(u"{}://127.0.0.1:{}".format(ws, self.port)) factory.protocol = ResourceProtocol listenWS(factory, sslcontext) reactor.run()
def startTwisted(self): from twisted.python import log log.startLogging(open("wssserver.log", "w")) self.print_debug("startTwisted() started") ws = "ws" ResourceProtocol.server = self sslcontext = None if self.ssl: self.print_debug("using wss... and ssl") sslcontext = ssl.DefaultOpenSSLContextFactory(self.sslkey, self.sslcert) ws = "wss" factory = WebSocketServerFactory(u"{}://127.0.0.1:{}".format(ws, self.port)) factory.protocol = ResourceProtocol listenWS(factory, sslcontext) reactor.run()
def __init__(self, protocol, ip='127.0.0.1', port=9000): global flyermmap, flyersem, flyerqueue self.queue = posix_ipc.MessageQueue("/flyerqueue") memory = posix_ipc.SharedMemory("flyermmap") self.sem = posix_ipc.Semaphore("flyersem") self.memmap = mmap.mmap(memory.fd, memory.size) flyermmap = self.memmap flyersem = self.sem flyerqueue = self.queue memory.close_fd() 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 run(secret_key): form = '[%(asctime)s] %(levelname)s: %(message)s' logger = logging.getLogger("WSServer") logging.basicConfig(level=logging.INFO, format=form) log_handler = logging.FileHandler('logs/log.txt') log_handler.setFormatter(logging.Formatter(form)) logger.addHandler(log_handler) logger.info('Start %s:%s' % (IP, PORT)) Handler.secret_key = secret_key factory = WebSocketServerFactory(u"ws://%s:%s" % (IP, PORT)) factory.protocol = Handler loop = asyncio.get_event_loop() coro = loop.create_server(factory, IP, PORT) loop.run_until_complete(coro) thread = Thread(loop.run_forever) return thread
def ws_server(self): ''' Servidor del websocket. ''' websocket = WebSocketServerFactory(u"ws://127.0.0.1:"+str(self.ws_port), debug=True) websocket.protocol = WSHandle websocket.protocol.ensemble=self.ensemble loop = asyncio.get_event_loop() coro = loop.create_server(websocket, '0.0.0.0', str(self.ws_port)) ws_server = loop.run_until_complete(coro) try: loop.run_forever() while True: pass except KeyboardInterrupt: pass finally: ws_server.close() loop.close()
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('blockly_server', anonymous=True) rospy.Subscriber("blockly", String, callback) factory = WebSocketServerFactory(u"ws://0.0.0.0:9000", debug=False) 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(wait_until_ros_node_shutdown(loop)) loop.run_forever() print("Closing...") server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def __init__(self, wsPort, lightAnimationController, verbose = False): # initializations self.port = wsPort self.animationController = lightAnimationController self.beVerbose = verbose # prepare the web socket protocol webSocketProtocol = WebSocketProtocol webSocketProtocol.setReferences( webSocketProtocol, self, self.animationController, self.beVerbose) # prepare the web sockets factory = WebSocketServerFactory() factory.protocol = webSocketProtocol # get the host's IP if config.AUTO_DETECT_HOST_IP: host = socket.gethostbyname(socket.gethostname()) else: host = config.HOST_IP # start the server event loop loop = asyncio.get_event_loop() coro = loop.create_server(factory, host, self.port) wsServer = loop.run_until_complete(coro) try: if self.beVerbose: serverAddressString = host + ':' + str(self.port) print('WS sever: launched at', serverAddressString) loop.run_forever() except KeyboardInterrupt: pass finally: wsServer.close() loop.close()
await asyncio.sleep(1) return x * x async def onMessage(self, payload, isBinary): if not isBinary: x = json.loads(payload.decode('utf8')) try: res = await self.slowsquare(x) except Exception as e: self.sendClose(1000, "Exception raised: {0}".format(e)) else: self.sendMessage(json.dumps(res).encode('utf8')) if __name__ == '__main__': factory = WebSocketServerFactory(u"ws://127.0.0.1:9000") factory.protocol = SlowSquareServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, '127.0.0.1', 9000) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
def exception_handler(loop,context): #print "got exception: " + context["message"]; print "got exception: " + str(context) loop.stop() exit(1) try: import asyncio except ImportError: ## Trollius >= 0.3 was renamed import trollius as asyncio server_url = "ws://%s:%d" % (server_host, int(server_port)) factory = WebSocketServerFactory(server_url, debug = False) factory.protocol = StreamingMarconiServerProtocol loop = asyncio.get_event_loop() coro = loop.create_server(factory, server_host, server_port) server = loop.run_until_complete(coro) loop.set_exception_handler(exception_handler) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.stop() loop.close()
self.sendMessage(reply.encode('utf8')) def sonar_callback(self, data): """ This method handles sonar data received from pymata_core. @param data: sonar data callback message @return:{"method": "sonar_data_reply", "params": [DATA_VALUE]} """ reply = json.dumps({"method": "sonar_data_reply", "params": data}) self.sendMessage(reply.encode('utf8')) if __name__ == '__main__': ws_string = 'ws://' + PymataIOT.ip_addr + ':' + PymataIOT.ip_port print('Websocket server operating on: ' + ws_string) factory = WebSocketServerFactory(ws_string, debug=False) factory.protocol = PymataIOT loop = asyncio.get_event_loop() coro = loop.create_server(factory, '0.0.0.0', int(PymataIOT.ip_port)) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
# py >2.7 try: import asyncio except ImportError: import trollius as asyncio from iotsensorprotocol import IotSensorProtocol from autobahn.asyncio.websocket import WebSocketServerFactory factory = WebSocketServerFactory() factory.protocol = IotSensorProtocol loop = asyncio.get_event_loop() #TODO: get ip from os coro = loop.create_server(factory, '192.168.99.40', 9000) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
if '-f' in sys.argv: input_file = sys.argv[sys.argv.index('-f') + 1] if args.interface == 'c3telem': print('Opening C3-style serial telemetry from serial port',input_file) interface = InterfaceC3Telemetry(input_file) interface.start() elif args.interface == 'c2log': print('Replaying C2 format log file',input_file) interface = InterfaceC2Log(input_file) interface.start() else: print('No interface type specified. Use `-i list` to list available types.') interface = InterfaceNull() factory = WebSocketServerFactory("ws://localhost:9000", debug = False) factory.protocol = CANServer loop = asyncio.get_event_loop() coro = loop.create_server(factory, '127.0.0.1', 9000) server = loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
print("WebSocket connection closed: {0}".format(reason)) CONNECTIONS.remove(self) if __name__ == '__main__': # import logging # logging.basicConfig(level=logging.DEBUG) port="7778" if len(sys.argv) == 2: port = sys.argv[1] CONNECTIONS = [] queue = asyncio.Queue() factory = WebSocketServerFactory("ws://localhost:{}".format(port), debug=False) factory.protocol = MyServerProtocol loop = asyncio.get_event_loop() # loop.add_reader(sys.stdin, functools.partial(handleStdin, sys.stdin)) coro = loop.create_server(factory, '127.0.0.1', int(port)) server = loop.run_until_complete(asyncio.wait( [coro, asyncio.async(MyServerProtocol.sendLine())])) try: loop.run_forever() except KeyboardInterrupt: pass finally: server.close() loop.close()
try: loop.run_until_complete(Ban.test_ban()) loult_state.can_ban = True except BanFail: loult_state.can_ban = False logger.warning("nft command dosen't work; bans are disabled.") class AutobahnLoultServer(LoultServer, WebSocketServerProtocol): loult_state = loult_state client_logger = logging.getLogger('client') factory = WebSocketServerFactory(server='Lou.lt/NG') # 'ws://127.0.0.1:9000', factory.protocol = AutobahnLoultServer # Allow 4KiB max size for messages, in a single frame. factory.setProtocolOptions( autoPingInterval=60, autoPingTimeout=30, ) coro = loop.create_server(factory, '127.0.0.1', 9000) scheduler_task = ensure_future(scheduler.start()) server = loop.run_until_complete(gather(coro, scheduler_task)) try: loop.run_forever() except KeyboardInterrupt: logger.info('Shutting down all connections...') for client in chain.from_iterable((channel.clients for channel in loult_state.chans.values())):