def start_client(address, port): # see http://autobahn.ws/python/websocket/programming.html # because starting a client requires an integer port, # while starting a server requires a string port, accept both. if isinstance(port, str): port = int(port) loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) loop = asyncio.get_event_loop() global client_loop client_loop = loop composite_address = 'ws://' + address + ':' + str(port) info('client connecting to {}'.format(composite_address), INFO_ID) factory = WebSocketClientFactory(composite_address) factory.protocol = GameClientProtocol info("client creating connection to address {} and port {}".format( address, str(port)), INFO_ID) coro = loop.create_connection(factory, address, port) global client_protocol transport, client_protocol = loop.run_until_complete(coro) loop.run_forever()
def wsfactory(address, directory, resolution, keep_old_data): loop = asyncio.get_event_loop() gracefully_exit_handler = functools.partial(gracefully_exit, loop) loop.add_signal_handler(signal.SIGTERM, gracefully_exit_handler) loop.add_signal_handler(signal.SIGINT, gracefully_exit_handler) directory = create_directory_if_not_exists(directory) if not keep_old_data: remove_all_data(directory) factory = WebSocketClientFactory("ws://{0}".format(address)) factory.protocol = STFRecordProtocol factory.protocol.img_directory = directory factory.protocol.address = address factory.protocol.resolution = resolution coro = loop.create_connection( factory, address.split(":")[0], address.split(":")[1] ) log.info("Connecting to {0} ...".format(address)) loop.run_until_complete(coro) try: loop.run_forever() finally: loop.close()
def run_monitoring(type, host, port, user, passwd): log.info('Starting witness websocket monitoring on {}:{}'.format(host, port)) while True: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) _event_loops[(host, port)] = loop log.debug('new event loop: {}'.format(loop)) log.debug('in thread {}'.format(threading.current_thread().name)) factory = WebSocketClientFactory("ws://{}:{:d}".format(host, port)) factory.protocol = partial(MonitoringProtocol, type, host, port, user, passwd) try: coro = loop.create_connection(factory, host, port) loop.run_until_complete(coro) log.info('Successfully connected to witness on {}:{}'.format(host, port)) loop.run_forever() log.warning('Lost connection to witness node on {}:{}'.format(host, port)) except KeyboardInterrupt: log.info('Run loop exited manually (ctrl-C)') except OSError: log.debug('WebSocket connection refused to {}:{}'.format(host, port)) finally: loop.close() with suppress(KeyError): del _monitoring_protocols[(host, port)] del _event_loops[(host, port)] nseconds = core.config['monitoring']['monitor_time_interval'] time.sleep(nseconds) # wait some time before trying to reconnect
def init_app(app): from autobahn.asyncio.websocket import WebSocketClientProtocol from autobahn.asyncio.websocket import WebSocketClientFactory from ws import host, port class Client(WebSocketClientProtocol): def __init__(self, *args): WebSocketClientProtocol.__init__(self, *args) self.opened = asyncio.Future() def notify(self, **kwargs): kwargs.setdefault('_created', datetime.utcnow().isoformat()) self.sendMessage(json.dumps(kwargs).encode('utf8')) def onConnect(self, response): self.opened.set_result(None) factory = WebSocketClientFactory() factory.protocol = Client try: loop = asyncio.get_event_loop() coro = loop.create_connection(factory, host, port) _transport, client = loop.run_until_complete(coro) loop.run_until_complete(client.opened) app.notification_client = client except OSError: # no ws server running pass
def init_app(app): factory = WebSocketClientFactory() factory.protocol = Client try: loop = asyncio.get_event_loop() coro = loop.create_connection(factory, host, port) _transport, client = loop.run_until_complete(coro) loop.run_until_complete(client.opened) app.notification_client = client except OSError: # no ws server running pass
def create_connection(self, room, ws_url, agent): """Creates a new connection""" factory = WebSocketClientFactory(ws_url) factory.useragent = agent factory.protocol = lambda: room ws_url = urlsplit(ws_url) conn = self.loop.create_connection(factory, host=ws_url.netloc, port=ws_url.port or 443, ssl=ws_url.scheme == "wss" ) asyncio.async(conn, loop=self.loop)
def __init__(self, url, agent): self.agent = agent WebSocketClientFactory.__init__(self, url, useragent=agent) self.setProtocolOptions(failByDrop=False) # spec conformance # enable permessage-deflate WebSocket protocol extension offers = [PerMessageDeflateOffer()] self.setProtocolOptions(perMessageCompressionOffers=offers) def accept(response): if isinstance(response, PerMessageDeflateResponse): return PerMessageDeflateResponseAccept(response) self.setProtocolOptions(perMessageCompressionAccept=accept)
def __init__(self, url, event_handlers): self._event_handlers = event_handlers self._ws = asyncio.Future() self._pendingFutures = {} class ProxyWebSocketProtocol(WebSocketClientProtocol): def onConnect(this, response): self._ws.set_result(this) def onMessage(this, message, isBinary): result = RpcTunnel.parse_response(message) result_id = result.get('id', None) if result_id is None: return if isinstance(result_id, int): return_type = self._pendingFutures[result_id]['return_type'] if return_type == bytearray: result['result'] = base64.b64decode(result['result']) RpcTunnel.set_or_raise(self._pendingFutures[result_id]['future'], result, return_type) else: # This is an event: for callback_info in self._event_handlers[result_id]: callback = callback_info['callback'] return_type = callback_info['return_type'] result = result.get('result', None) if return_type is not None: if return_type == bytearray: result = base64.b64decode(result) callback(RpcTunnel.convert(result, return_type)) else: callback(result) parsed_url = urlparse(url) # TODO: generate the websocket url nicely: self._url = url.replace('http', 'ws') factory = WebSocketClientFactory(self._url, debug = False) factory.protocol = ProxyWebSocketProtocol asyncio.Task(asyncio.get_event_loop().create_connection(factory, parsed_url.hostname, parsed_url.port))
def __init__(self, loop, url, debug=False): super(DDPClient, self).__init__() ids = build_id_generator() self._board = board = pubsub.MessageBoard(loop) self._caller = pubsub.MethodCaller(board, MethodMessageFactory(ids)) factory = WebSocketClientFactory(url=url, loop=loop) factory.protocol = pubsub.SocketPublisherFactory(board) subscribers = [ self._caller, pubsub.DDPConnector(board), pubsub.Ponger(board), pubsub.Outbox(board), pubsub.SocketReconnector(board), pubsub.SocketConnector(board, loop, factory), pubsub.MessageParser(board, AddedBeforeMessageParser()), pubsub.MessageParser(board, AddedMessageParser()), pubsub.MessageParser(board, ChangedMessageParser()), pubsub.MessageParser(board, ConnectedMessageParser()), pubsub.MessageParser(board, ErrorMessageParser()), pubsub.MessageParser(board, FailedMessageParser()), pubsub.MessageParser(board, MovedBeforeMessageParser()), pubsub.MessageParser(board, NosubMessageParser()), pubsub.MessageParser(board, PingMessageParser()), pubsub.MessageParser(board, PongMessageParser()), pubsub.MessageParser(board, ReadyMessageParser()), pubsub.MessageParser(board, RemovedMessageParser()), pubsub.MessageParser(board, ResultMessageParser()), pubsub.MessageParser(board, UpdatedMessageParser()), pubsub.MessageSerializer(board, ConnectMessageSerializer()), pubsub.MessageSerializer(board, MethodMessageSerializer()), pubsub.MessageSerializer(board, PingMessageSerializer()), pubsub.MessageSerializer(board, PongMessageSerializer()), pubsub.MessageSerializer(board, SubMessageSerializer()), pubsub.MessageSerializer(board, UnsubMessageSerializer()), pubsub.PodMessageFilter(board, PodMessageFilter()), pubsub.PodMessageParser(board, PodMessageParser()), pubsub.PodMessageSerializer(board, PodMessageSerializer()), ] if debug: subscribers.append(pubsub.Logger(board)) for subscriber in subscribers: subscriber.subscribe()
def join_and_run_forever(self, roomid): session = self #yes, I'm putting a class definition inside a method definition. I acknowledge that this is weird. #this has to go here because I don't see any other way for the class' methods to refer to `self` properly. class SoClient(WebSocketClientProtocol): def onConnect(self, response): session.onConnect(response) def onOpen(self): session.onOpen() def onMessage(self, payload, is_binary): session.onMessage(payload) def onClose(self, was_clean, code, reason): session.onClose(was_clean, code, reason) url = self.join(roomid) host = "chat.sockets.stackexchange.com" factory = WebSocketClientFactory(url, headers={"Origin":"http://chat.stackoverflow.com"}) factory.protocol = SoClient self.loop = asyncio.get_event_loop() coro = self.loop.create_connection(factory, host, 80) self.loop.run_until_complete(coro) self.loop.run_forever() self.loop.close()
def connect(self, url, host, port): try: import asyncio except ImportError: # Trollius >= 0.3 was renamed import trollius as asyncio proto = [ "camctrl-protobuf/1.0" ] self.loop = asyncio.new_event_loop() self.factory = WebSocketClientFactory(url, protocols=proto, loop=self.loop) self.factory.protocol = SocketProtocol self.factory.setProtocolOptions(autoPingInterval=5, autoPingTimeout=5) #self.loop = asyncio.get_event_loop() coro = self.loop.create_connection(self.factory, host, port) self.loop.run_until_complete(coro) self.thread = threading.Thread(target=self._poll, name="Poll Camera") self.thread.daemon = True self.thread.start()
def main(): parser = argparse.ArgumentParser(description='DAO Curator Bot') parser.add_argument('config', nargs='?', help='Config module', default='config.development') args = parser.parse_args() config_mod = __import__(args.config, globals(), locals(), ['AppConfig']) appconfig = config_mod.AppConfig factory = WebSocketClientFactory(appconfig.ETHERSCAN_WEBSOCKET_URL) factory.protocol = EtherscanClientProtocol factory.appconfig = appconfig loop = asyncio.get_event_loop() coro = loop.create_connection(factory, factory.host, factory.port, ssl=factory.isSecure) loop.run_until_complete(coro) loop.run_forever() loop.close()
def __init__(self, url): self.agent = autobahn.asyncio.__ident__ WebSocketClientFactory.__init__(self, url, useragent=self.agent) self.setProtocolOptions(failByDrop=False) # spec conformance # enable permessage-deflate WebSocket protocol extension offers = [PerMessageDeflateOffer()] self.setProtocolOptions(perMessageCompressionOffers=offers) def accept(response): if isinstance(response, PerMessageDeflateResponse): return PerMessageDeflateResponseAccept(response) self.setProtocolOptions(perMessageCompressionAccept=accept) # setup client testee stuff self.endCaseId = None self.currentCaseId = 0 self.updateReports = True self.resource = "/getCaseCount"
def create_connection(self, room, ws_url, agent, cookies): """Creates a new connection""" urlparts = urlsplit(ws_url) req = Request("GET", ws_url) cookies = get_cookie_header(cookies, req) if cookies: headers = dict(Cookie=cookies) else: headers = None factory = WebSocketClientFactory(ws_url, headers=headers, loop=self.loop) factory.useragent = agent factory.protocol = lambda: room conn = self.loop.create_connection( factory, host=urlparts.netloc, port=urlparts.port or 443, ssl=urlparts.scheme == "wss", ) asyncio.ensure_future(conn, loop=self.loop)
def connect(self): url = 'ws://{0}:{1}/datalink'.format(self.address, str(self.port)) log.info(url) self.factory = WebSocketClientFactory(url, debug=False) self.factory.protocol = TelemachusProtocol coro = self.loop.create_connection(self.factory, self.address, self.port) #Notes about events: #The UI waits on the connect_event to know if the connection has either #failed or succeeded; the UI will clear this event. #self.connected differentiates between success and failure #Success -> self.connected=True ; Failure -> self.connected = False ### MAKING the connection try: self.loop.run_until_complete(coro) #TODO: Add in some informative messages to send back to the UI except: # Failure, shut down and abort self.connect_event.set() # Connection resolved self.connected = False # Connection resolved badly #Tear down the loop self.loop.stop() self.loop.close() self.loop = None self.make_connection.clear() # Clear so we can wait for it again return else: self.connect_event.set() # Connection resolved self.connected = True # Connection resolved well ### MAINTAINING the connection try: self.loop.run_forever() except Exception as e: log.exception(e) finally: #Tear down the loop self.loop.close() self.loop = None self.make_connection.clear() # Clear so we can wait for it again self.connected = False #Reset important connection state variables global MSG_QUEUE self.subscription_manager = SubscriptionManager(MSG_QUEUE) self.data_log_vars = OrderedSetWithSubscriptionHook(self.subscription_manager, ['t.universalTime', 'v.missionTime', 'sys.time'])
def testing_main(): import asyncio import ssl ctx = ssl.create_default_context() ctx.check_hostname = False ctx.verify_mode = ssl.CERT_NONE numb = np.random.randint(0, 1000) server_num = np.random.randint(0, 200) randstr = str(uuid.uuid1())[:8] url = f"wss://stream{server_num}.forexpros.com/echo/{numb}/{randstr}/websocket" host = f"stream{server_num}.forexpros.com" factory = WebSocketClientFactory(url) factory.setProtocolOptions(autoPingInterval=5) factory.protocol = InvestingdotcomProtocol.make_subids([1, 2]) loop = asyncio.get_event_loop() # {"cert_reqs": ssl.CERT_NONE}) coro = loop.create_connection(factory, host, 443, ssl=ctx) loop.run_until_complete(coro) loop.run_forever()
def execute(self, symbol): try: base_url = 'ws://ff.sinajs.cn/wskt' token = yield from self.get_token(symbol) url = base_url + '?' + 'token=' + token + '&' + 'list=' + ','.join(symbol) logging.debug('start {}'.format(url)) factory = WebSocketClientFactory(url, debug=False) factory.protocol = create_protocal(self, symbol) loop = asyncio.get_event_loop() coro = loop.create_connection(factory, self.host, 80) asyncio.async(coro) except requests.RequestException: logging.warning('requests error, don"t worry') yield from asyncio.sleep(3) yield from self.execute(symbol) except NotLoginException: logging.warning('not login error, try again') yield from asyncio.sleep(3) yield from self.execute(symbol) except: traceback.print_exc() logging.warning('unexpected error')
def run_client(client_class): """ Runs the given client until the client himself calls close or an exception is thrown. Is non blocking to allow the interaction of the gis and app client. """ result = None try: pathparts = urllib.parse.urlparse(config.LISTEN_PATH) adrparts = pathparts.netloc.split(':') factory = WebSocketClientFactory(config.LISTEN_PATH) factory.protocol = client_class loop = asyncio.get_event_loop() coro = loop.create_connection(factory, adrparts[0], adrparts[1]) loop.run_until_complete(coro) loop.run_forever() loop.close() except Exception as ex: result = ex return result
def run_monitoring(type, host, port, user, passwd): log.info('Starting witness websocket monitoring on {}:{}'.format( host, port)) while True: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) _event_loops[(host, port)] = loop log.debug('new event loop: {}'.format(loop)) log.debug('in thread {}'.format(threading.current_thread().name)) factory = WebSocketClientFactory("ws://{}:{:d}".format(host, port)) factory.protocol = partial(MonitoringProtocol, type, host, port, user, passwd) try: coro = loop.create_connection(factory, host, port) loop.run_until_complete(coro) log.info('Successfully connected to witness on {}:{}'.format( host, port)) loop.run_forever() log.warning('Lost connection to witness node on {}:{}'.format( host, port)) except KeyboardInterrupt: log.info('Run loop exited manually (ctrl-C)') except OSError: log.debug('WebSocket connection refused to {}:{}'.format( host, port)) finally: loop.close() with suppress(KeyError): del _monitoring_protocols[(host, port)] del _event_loops[(host, port)] nseconds = core.config['monitoring']['monitor_time_interval'] time.sleep(nseconds) # wait some time before trying to reconnect
def execute(self, symbol): try: base_url = 'ws://ff.sinajs.cn/wskt' token = yield from self.get_token(symbol) url = base_url + '?' + 'token=' + token + '&' + 'list=' + ','.join( symbol) logging.debug('start {}'.format(url)) factory = WebSocketClientFactory(url, debug=False) factory.protocol = create_protocal(self, symbol) loop = asyncio.get_event_loop() coro = loop.create_connection(factory, self.host, 80) asyncio. async (coro) except requests.RequestException: logging.warning('requests error, don"t worry') yield from asyncio.sleep(3) yield from self.execute(symbol) except NotLoginException: logging.warning('not login error, try again') yield from asyncio.sleep(3) yield from self.execute(symbol) except: traceback.print_exc() logging.warning('unexpected error')
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 __init__(self, user, pwd, ip, port, lang, loop): super().__init__() self.user = user self.lang = lang self.pwd = pwd self.req_no = 0 self.req_map = dict() self.closed = True ws_url = str.format("ws://{0}:{1}/vqservice/vq/socket", ip, str(port)) self.ws_url = ws_url self.ip = ip self.port = port self.factory = WebSocketClientFactory(ws_url) self.factory.protocol = lambda: self self.loop = loop self.push_future = None self.group_agent_service_list = list( ) # list of tuple (group_gid, agent_service) //all the group that is arleady joined self.recommand_groups = list() # self.state_vars = dict() # {group:{agent_servic:{var_name:var_value}}} self.node_caches = dict() # gid->(date, nodeInfo) self.joined_group_and_agent_service = list()
def worker(queue, send_queue, config): host = config.get('host', DEFAULT_HOST) port = config.get('port', DEFAULT_PORT) encoding = config.get('encoding', DEFAULT_ENCODING) if 0: # debug asyncio logging.basicConfig(level=logging.DEBUG) else: formatter = logging.Formatter('%(asctime)s %(name)s [%(levelname)s] %(message)s') handler = logging.StreamHandler() handler.setFormatter(formatter) handler.setLevel(logging.DEBUG) logger.setLevel(logging.DEBUG) logger.addHandler(handler) logger.info("Start main") import asyncio factory = WebSocketClientFactory('ws://{}:{}'.format(host, port)) factory.nick = config.get('nick', DEFAULT_NICK) factory.client = None factory.protocol = WSChatClientProtocol factory.queue = queue factory.encoding = encoding factory.send_queue = send_queue def ws_send_worker(queue, factory): for payload in queue_loop(queue): if __debug__: logger.debug("payload-length: {}".format(len(payload))) if factory.client: factory.client.sendMessage(payload) thread = Thread(target=ws_send_worker, args=(send_queue, factory), daemon=True) thread.start() loop = asyncio.get_event_loop() coro = loop.create_connection(factory, host, port) loop.run_until_complete(coro) loop.run_forever() loop.close()
def connect(self): factory = WebSocketClientFactory(self.endpoint) factory.protocol = self.protocol factory.headers["X-Host-ID"] = self.host_id factory.headers["X-Client-Type"] = self.type factory.headers["X-Gremlin-Filter"] = self.filter loop = asyncio.get_event_loop() u = urlparse(self.endpoint) coro = loop.create_connection(factory, u.hostname, u.port) loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: pass finally: loop.close()
def listen_for_events(callback): try: while True: print("Attempting to open websocket connection") factory = WebSocketClientFactory(u"wss://certstream.calidog.io") factory.setProtocolOptions(openHandshakeTimeout=10, tcpNoDelay=True) factory.protocol = MyClientProtocol factory.callback = callback ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH) ssl_context.check_hostname = True loop = asyncio.get_event_loop() coro = loop.create_connection(factory, 'certstream.calidog.io', 443, ssl=ssl_context) loop.run_until_complete(coro) loop.run_forever() except KeyboardInterrupt: loop.stop() loop.close()
text=str(random.randint(36, 38))) if randNum2 == 1: self.heartrate1.configure(text=str(random.randint(60, 63))) except Exception as e: print e self.window.update() if __name__ == '__main__': root = logging.getLogger() root.setLevel(logging.DEBUG) ch = logging.StreamHandler(sys.stdout) ch.setLevel(logging.DEBUG) root.addHandler(ch) factory = WebSocketClientFactory(u"ws://127.0.0.1:8888/get") proto = MyClientProtocol factory.protocol = proto factory.setProtocolOptions(autoPingInterval=10, autoPingTimeout=60, openHandshakeTimeout=30) loop = asyncio.get_event_loop() coro = loop.create_connection(factory, '127.0.0.1', 8888) loop.run_until_complete(coro) loop.run_forever()
def hello(): self.sendMessage(u"Hello, world!".encode('utf8')) self.sendMessage(b"\x00\x01\x03\x04", isBinary=True) self.factory.loop.call_later(1, hello) ## start sending messages every second .. hello() def onMessage(self, payload, isBinary): if isBinary: print("Binary message received: {0} bytes".format(len(payload))) else: print("Text message received: {0}".format(payload.decode('utf8'))) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) if __name__ == '__main__': import asyncio factory = WebSocketClientFactory("ws://localhost:9000", debug=False) factory.protocol = MyClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, '127.0.0.1', 9000) loop.run_until_complete(coro) loop.run_forever() loop.close()
#s.send(password + b'\r\n') #answer = s.recv(1024) #self.sendMessage(answer,1) #s.close() def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) async def heartbeat(self): while True: await asyncio.sleep(29) msg = u"--- MARK ---" self.sendMessage(msg.encode('utf-8')) if __name__ == '__main__': factory = WebSocketClientFactory(u"ws://192.168.165.20:80") factory.protocol = MyClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, '192.168.165.20', 80) loop.run_until_complete(coro) try: loop.run_forever() except KeyBoardInterrupt: pass finally: loop.close()
def connect(self): """ Create websocket factory by Autobahn """ self.factory = WebSocketClientFactory(self.url) self.factory.protocol = self.proto
import logging from os import environ from autobahn.asyncio.websocket import WebSocketClientFactory from loxone_websocket_client import ClientProtocol _LOGGER = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) MINISERVER_HOST = environ.get('MINISERVER_HOST', '127.0.0.1') MINISERVER_PORT = environ.get('MINISERVER_PORT', 80) MINISERVER_USERNAME = environ.get('MINISERVER_USERNAME', 'admin') MINISERVER_PASSWORD = environ.get('MINISERVER_PASSWORD', 'admin') if __name__ == '__main__': _LOGGER.info('Start WebSocket connection') ws_factory = WebSocketClientFactory('ws://{host}:{port}/ws/rfc6455'.format( host=MINISERVER_HOST, port=MINISERVER_PORT), protocols=['remotecontrol']) ws_factory.protocol = ClientProtocol ws_factory.username = MINISERVER_USERNAME ws_factory.password = MINISERVER_PASSWORD loop = asyncio.get_event_loop() coro = loop.create_connection(ws_factory, MINISERVER_HOST, MINISERVER_PORT) loop.run_until_complete(coro) loop.run_forever() loop.close()
print("Request to square {} sent.".format(x)) def onMessage(self, payload, isBinary): if not isBinary: res = json.loads(payload.decode('utf8')) print("Result received: {}".format(res)) self.sendClose() def onClose(self, wasClean, code, reason): if reason: print(reason) loop.stop() if __name__ == '__main__': try: import asyncio except ImportError: # Trollius >= 0.3 was renamed import trollius as asyncio factory = WebSocketClientFactory(u"ws://127.0.0.1:9000") factory.protocol = SlowSquareClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, '127.0.0.1', 9000) loop.run_until_complete(coro) loop.run_forever() loop.close()
def connect(self): factory = WebSocketClientFactory(self.endpoint) factory.protocol = self.protocol factory.client = self factory.kwargs = self.kwargs factory.headers["X-Host-ID"] = self.host_id factory.headers["X-Client-Type"] = self.type factory.headers["X-Client-Protocol"] = "json" if self.persistent: factory.headers["X-Persistence-Policy"] = "Persistent" else: factory.headers["X-Persistence-Policy"] = "DeleteOnDisconnect" if self.username: if self.auth.login(): cookie = 'authtok={}'.format(self.auth.authtok) if self.cookies: self.cookies.append(cookie) else: self.cookies = [cookie, ] if self.filter: factory.headers["X-Gremlin-Filter"] = self.filter if self.cookies: factory.headers['Cookie'] = ';'.join(self.cookies) context = None if self.url.scheme == "wss": if self.insecure: context = ssl._create_unverified_context() else: context = ssl.create_default_context() coro = self.loop.create_connection(factory, self.url.hostname, self.url.port, ssl=context) (transport, protocol) = self.loop.run_until_complete(coro) LOG.debug('transport, protocol: %r, %r', transport, protocol)
replaced = True string = new_text break if replaced: tag.string.replace_with(BeautifulSoup(string)) self.text = str(item) break if replaced: self.msg({"action":"set_text", "text":self.text}) else: self.msg({"action":"set_text", "text": self.text+"<h1>EASY!</h1>"}) self.text = None def onClose(self, wasClean, code, reason): loop.stop() if __name__ == '__main__': import asyncio factory = WebSocketClientFactory(u"ws://localhost:9000") factory.protocol = LuegenpresseCensorClientProtocoll loop = asyncio.get_event_loop() connection = loop.create_connection(factory, 'localhost', 9000) loop.run_until_complete(connection) loop.run_forever() loop.close()
parser = argparse.ArgumentParser() parser.add_argument('--host', dest='host', default='127.0.0.1', help="ip of the API (default: 127.0.0.1)") parser.add_argument('--port', dest='port', default=8080, help="port of the API (default: 8080)") parser.add_argument('--clients', dest='clients', default=100, type=int, help="number of clients to add each cycle") parser.add_argument('--duration', dest='duration', default=10, type=int, help="duration of each cycle") args = parser.parse_args() loop = asyncio.get_event_loop() factory = WebSocketClientFactory() factory.protocol = APIClientProtocol async def connect(): print("Connecting...") await loop.create_connection(factory, args.host, args.port) loop.run_until_complete(run(connect, args.clients, args.duration))
'url': '/auth/login', 'data': { 'username': '******', 'password': '******', } } self.sendMessage(json.dumps(request).encode('utf8')) def onMessage(self, payload, isBinary): message = json.loads(payload.decode('utf8')) print("Result: {0}".format(message)) if 'request' in message and message['request']['url'] == "/auth/login": # log out request = { 'method': 'POST', 'url': '/auth/logout', 'token': message['data']['token'] } self.sendMessage(json.dumps(request).encode('utf8')) if __name__ == '__main__': factory = WebSocketClientFactory("ws://localhost:8080") factory.protocol = AuthAPIClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, '127.0.0.1', 8080) loop.run_until_complete(coro) loop.run_forever() loop.close()
def connect(self): factory = WebSocketClientFactory(self.endpoint) factory.protocol = self.protocol factory.client = self factory.kwargs = self.kwargs factory.headers["X-Host-ID"] = self.host_id factory.headers["X-Client-Type"] = self.type if self.persistent: factory.headers["X-Persistence-Policy"] = "Persistent" else: factory.headers["X-Persistence-Policy"] = "DeleteOnDisconnect" if self.username: authorization = base64.b64encode( b"%s:%s" % (self.username, self.password)).decode("ascii") factory.headers["Authorization"] = 'Basic %s' % authorization if self.filter: factory.headers["X-Gremlin-Filter"] = self.filter self.loop = asyncio.get_event_loop() u = urlparse(self.endpoint) coro = self.loop.create_connection(factory, u.hostname, u.port) self.loop.run_until_complete(coro) try: self.loop.run_forever() except KeyboardInterrupt: self.loop.close() finally: pass
def connect(self): factory = WebSocketClientFactory(self.endpoint) factory.protocol = self.protocol factory.client = self factory.kwargs = self.kwargs factory.headers["X-Host-ID"] = self.host_id factory.headers["X-Client-Type"] = self.type factory.headers["X-Client-Protocol"] = "json" if self.persistent: factory.headers["X-Persistence-Policy"] = "Persistent" else: factory.headers["X-Persistence-Policy"] = "DeleteOnDisconnect" if self.username: if self.auth.login(): cookie = 'authtok={}'.format(self.auth.authtok) if self.cookies: self.cookies.append(cookie) else: self.cookies = [cookie, ] if self.filter: factory.headers["X-Gremlin-Filter"] = self.filter if self.cookies: factory.headers['Cookie'] = ';'.join(self.cookies) context = None if self.url.scheme == "wss": if self.insecure: context = ssl._create_unverified_context() else: context = ssl._create_default_context() coro = self.loop.create_connection(factory, self.url.hostname, self.url.port, ssl=context) (transport, protocol) = self.loop.run_until_complete(coro) LOG.debug('transport, protocol: %r, %r', transport, protocol)
s = ser.read() # größe anpassen #print (s); if s == b'1': # prüfen ob button gedrückt self.sendMessage(json.dumps({"action":"censor_single"}).encode()) thread = threading.Thread(target=self.turnOnPresse, args=(ser,)) thread.start() def onClose(self, wasClean, code, reason): loop.stop() def onMessage(self, payload, isBinary): if not isBinary: res = json.loads(payload.decode()) if res["action"] == b'1': # nachrichten filtern with serial.Serial(self.port, self.baud) as ser: ser.write("1\n".encode()) if __name__ == '__main__': import asyncio factory = WebSocketClientFactory(u"ws://localhost:9000") factory.protocol = CensorClientProtocol loop = asyncio.get_event_loop() connection = loop.create_connection(factory, 'localhost', 9000) loop.run_until_complete(connection) loop.run_forever() loop.close()
async def onOpen(self): print("WebSocket connection open.") # start sending messages every second .. while True: self.sendMessage("Hello, world!".encode('utf8')) self.sendMessage(b"\x00\x01\x03\x04", isBinary=True) await asyncio.sleep(1) def onMessage(self, payload, isBinary): if isBinary: print("Binary message received: {0} bytes".format(len(payload))) else: print("Text message received: {0}".format(payload.decode('utf8'))) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) if __name__ == '__main__': factory = WebSocketClientFactory("ws://127.0.0.1:9000") factory.protocol = MyClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, '127.0.0.1', 9000) loop.run_until_complete(coro) loop.run_forever() loop.close()
payload = json.dumps({ "pid": object['pid'], "card": card, "usr": object["usr"], "t": object["t"] }).encode('utf8') self.sendMessage(payload) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) if __name__ == '__main__': print(sys.argv) if len(sys.argv) == 2: factory = WebSocketClientFactory(sys.argv[1]) else: print( 'pass the url like "ws://127.0.0.1:6789/key=bot1&Room=0&seatN0=2" it should pass in qute' ) quit() factory = WebSocketClientFactory("ws://127.0.0.1:6789/key=" + sys.argv[1] + "&Room=0") factory.protocol = MyClientProtocol loop = asyncio.get_event_loop() async def main(): coro = loop.create_connection(factory, "3.128.89.158", 6789) print("running {}".format(coro)) transport, proto = await coro print("proto {}".format(proto))
def onConnect(self, response): print("Server connected: {0}".format(response.peer)) def onOpen(self): print("WebSocket connection open.") def onMessage(self, payload, isBinary): if isBinary: print("Binary message received: {0} bytes".format(len(payload))) else: result = json.loads(payload.decode('utf8')) print("Result received: {}".format(result)) message = u"JSON received by Python client at {}".format(strftime("%Y-%m-%d %H:%M:%S")) self.sendMessage(message.encode('utf8'), isBinary=False) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) if __name__ == '__main__': factory = WebSocketClientFactory(u"ws://127.0.0.1:9000") factory.protocol = EsriJsonClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, '127.0.0.1', 9000) loop.run_until_complete(coro) loop.run_forever() loop.close()
# hello username request = { 'method': 'GET', 'url': '/hello/' } self.sendMessage(json.dumps(request).encode('utf8')) # sum endpoint with arg in URL path (two random digits) for _ in range(0, 10): digit_1 = str(randint(1, 100)) digit_2 = str(randint(1, 100)) request = { 'method': 'GET', 'url': '/sum/{0}/{1}'.format(digit_1, digit_2) } self.sendMessage(json.dumps(request).encode('utf8')) def onMessage(self, payload, isBinary): print("Result: {0}".format(payload.decode('utf8'))) if __name__ == '__main__': factory = WebSocketClientFactory("ws://localhost:8080") factory.protocol = HelloClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, '127.0.0.1', 8080) loop.run_until_complete(coro) loop.run_forever() loop.close()
@asyncio.coroutine def onOpen(self): print("WebSocket connection open.") # start sending messages every second .. while True: self.sendMessage(u"Hello, world!".encode('utf8')) self.sendMessage(b"\x00\x01\x03\x04", isBinary=True) yield from asyncio.sleep(1) def onMessage(self, payload, isBinary): if isBinary: print("Binary message received: {0} bytes".format(len(payload))) else: print("Text message received: {0}".format(payload.decode('utf8'))) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) if __name__ == '__main__': factory = WebSocketClientFactory(u"ws://127.0.0.1:9000", debug=False) factory.protocol = MyClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, '127.0.0.1', 9000) loop.run_until_complete(coro) loop.run_forever() loop.close()
def onOpen(self): # request SO questions # (use 155-questions-active) for ALL SE sites) # (also should be able to put '1-questions-active-tag-python*' or similar) self.sendMessage(b'1-questions-active') # ^^^ might want to `call_later` this for a few seconds... def onMessage(self, payload, is_binary): # not sure if binary should technically happen? if not is_binary: event = json.loads(payload.decode('utf-8')) data = json.loads(event['data']) # it's a question, so subscribe to its events... if event['action'] == '1-questions-active': self.sendMessage('1-question-{}'.format(data['id']).encode('utf-8')) pprint(data) def onClose(self, was_clean, code, reason): print('Closed:', reason) factory = WebSocketClientFactory('ws://qa.sockets.stackexchange.com') factory.protocol = StackActivity loop = asyncio.get_event_loop() coro = loop.create_connection(factory, 'qa.sockets.stackexchange.com', 80) loop.run_until_complete(coro) loop.run_forever() loop.close()
class TestClientProtocol(WebSocketClientProtocol): def onOpen(self): self.sendMessage( json.dumps({ "action": "get_votes", "event_name": "jhsued2016" }).encode()) #self.sendClose() def onMessage(self, payload, inBinary): print(payload) def onClose(self, wasClean, code, reason): loop.stop() if __name__ == '__main__': import asyncio factory = WebSocketClientFactory(u"ws://localhost:9000") factory.protocol = TestClientProtocol loop = asyncio.get_event_loop() connection = loop.create_connection(factory, 'localhost', 9000) loop.run_until_complete(connection) loop.run_forever() loop.close()
def connect(self): self.factory = WebSocketClientFactory("ws://{}:{:d}".format( self.host, self.port), debug=False) self.factory.protocol = self.proto
def test(self): factory = WebSocketClientFactory(url='ws://127.0.0.1:29757/websocket') factory.protocol = self.protocol coro = self.loop.create_connection(factory, '127.0.0.1', 29757) self.loop.run_until_complete(coro) self.loop.run_forever()
from autobahn.asyncio.websocket import WebSocketClientProtocol, \ WebSocketClientFactory import json import random class DebugClientProtocol(WebSocketClientProtocol): def onMessage(self, payload, isBinary): if not isBinary: print(payload) def onClose(self, wasClean, code, reason): loop.stop() if __name__ == '__main__': import asyncio factory = WebSocketClientFactory(u"ws://localhost:9000") factory.protocol = DebugClientProtocol loop = asyncio.get_event_loop() connection = loop.create_connection(factory, 'localhost', 9000) loop.run_until_complete(connection) loop.run_forever() loop.close()
def onMessage(self, payload, isBinary): if not isBinary: res = json.loads(payload.decode('utf8')) if res["result"] == "state": print("State of {switch}: {state}".format(**res)) elif res["result"] == "config": print(res) self.sendClose() elif res["result"] == "error": print("An error occured: {0}".format(res["error"])) else: print(res) def onClose(self, wasClean, code, reason): loop.stop() if __name__ == '__main__': import asyncio factory = WebSocketClientFactory(u"ws://localhost:9000") factory.protocol = KommandozentraleClientProtocol loop = asyncio.get_event_loop() connection = loop.create_connection(factory, 'localhost', 9000) loop.run_until_complete(connection) loop.run_forever() loop.close()
'url': '/auth/login', 'args': { 'username': '******', 'password': '******', } } self.sendMessage(json.dumps(request).encode('utf8')) def onMessage(self, payload, isBinary): message = json.loads(payload.decode('utf8')) print("Result: {0}".format(message)) if 'request' in message and message['request']['url'] == "/auth/login": # log out request = { 'method': 'POST', 'url': '/auth/logout', 'token': message['data']['token'] } self.sendMessage(json.dumps(request).encode('utf8')) if __name__ == '__main__': factory = WebSocketClientFactory("ws://localhost:8080", debug=False) factory.protocol = AuthAPIClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, '127.0.0.1', 8080) loop.run_until_complete(coro) loop.run_forever() loop.close()
def __init__(self, url, callbacks, debug=False, debugCodePaths=False): WebSocketClientFactory.__init__(self, url, debug=debug, debugCodePaths=debugCodePaths) self.__clients = [] self.__callbacks = callbacks
message = await async_input('SL >>> ', self) print(message) if message == b'messages': for response in self.responses: print(response[0].isoformat, response[1]) continue elif message: self.sendMessage(message, isBinary=True) def onMessage(self, payload, isBinary): print(self.responses) self.responses.append((datetime.datetime.now(), payload)) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {}; {}".format(code, reason)) if __name__ == '__main__': factory = WebSocketClientFactory('handlers://127.0.0.1:8080/push') factory.protocol = MyClientProtocol coro = loop.create_connection(factory, '127.0.0.1', 8080) loop.run_until_complete(coro) try: loop.run_forever() except KeyboardInterrupt: loop.shutdown_asyncgens() loop.close() print('Bye')
def get_factory(loop): # Create a factory myo_factory = WebSocketClientFactory("ws://127.0.0.1:10138/myo/1", debug=False) myo_factory.protocol = MyoProtocol return loop.create_connection(myo_factory, "127.0.0.1", 10138)
# Save orientation data for future if data[1]["type"] == "orientation": accelerometer.append(data[1]["accelerometer"]) gyroscope.append(data[1]["gyroscope"]) orientation.append(data[1]["orientation"]) # Push out any detected poses elif data[1]["type"] == "pose": poses.append(data[1]["pose"]) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) def get_factory(loop): # Create a factory myo_factory = WebSocketClientFactory("ws://127.0.0.1:10138/myo/1", debug=False) myo_factory.protocol = MyoProtocol return loop.create_connection(myo_factory, "127.0.0.1", 10138) if __name__ == "__main__": factory = WebSocketClientFactory("ws://127.0.0.1:10138/myo/1", debug=False) factory.protocol = MyoProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, "127.0.0.1", 10138) loop.run_until_complete(coro) loop.run_forever() loop.close()
self.sendMessage(u"Hello, world!".encode("utf8")) self.sendMessage(b"\x00\x01\x03\x04", isBinary=True) yield from asyncio.sleep(1) def onMessage(self, payload, isBinary): if isBinary: print("Binary message received: {0} bytes".format(len(payload))) else: print("Text message received: {0}".format(payload.decode("utf8"))) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) if __name__ == "__main__": try: import asyncio except ImportError: ## Trollius >= 0.3 was renamed import trollius as asyncio factory = WebSocketClientFactory("ws://localhost:9000", debug=False) factory.protocol = MyClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, "127.0.0.1", 9000) loop.run_until_complete(coro) loop.run_forever() loop.close()
if isBinary: print("onMessage: Binary payload message", payload) else: print("onMessage: Text payload message", payload.decode('utf8')) print() def onClose(self, wasClean, code, reason): print("onClose - WebSocket connection closed:", reason) print() # Running Client if __name__ == '__main__': factory = WebSocketClientFactory("ws://localhost:8765") factory.protocol = MyClientProtocol loop = asyncio.get_event_loop() cliente = loop.create_connection(factory, 'localhost', 8765) loop.run_until_complete(cliente) try: loop.run_forever() except KeyboardInterrupt: pass finally: print() print('closind cliente ....') print() cliente.close()