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 if self.cookies: factory.headers['Cookie'] = ';'.join(self.cookies) self.loop = asyncio.get_event_loop() u = urlparse(self.endpoint) coro = self.loop.create_connection(factory, u.hostname, u.port) (transport, protocol) = self.loop.run_until_complete(coro) LOG.debug('transport, protocol: %r, %r', transport, protocol)
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 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 = "authtoken={}".format(self.auth.token) 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) coro = self.loop.create_connection(factory, self.url.hostname, self.url.port, ssl=self.ssl_context) (transport, protocol) = self.loop.run_until_complete(coro) LOG.debug("transport, protocol: %r, %r", transport, protocol)
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 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 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 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 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 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
async def connect(self): if (self.client is not None) and (self.client.state == WebSocketClientProtocol.STATE_OPEN): # return self.client.future await self.client.future elif (self.client is not None) and (self.client.state == WebSocketClientProtocol.STATE_CONNECTING): # return self.client.future await self.client.future else: future = asyncio.Future(loop=self.loop) try: url_parsed = urlparse(self.options['url']) ssl = True if url_parsed.scheme == 'wss' else False port = url_parsed.port if url_parsed.port is not None else 443 if ssl else 80 client = MyClientProtocol(self, future, self.loop, self.options['verbose']) if 'proxies' in list(self.options.keys()): if url_parsed.scheme == 'wss': proxy_url_parsed = urlparse( self.options['proxies']['https']) else: proxy_url_parsed = urlparse( self.options['proxies']['http']) proxy = { 'host': proxy_url_parsed.hostname, 'port': proxy_url_parsed.port } factory = WebSocketClientFactory(self.options['url'], proxy=proxy) else: factory = WebSocketClientFactory(self.options['url'] + self.urlParam) factory.protocol = lambda: client fut = self.loop.create_connection(factory, url_parsed.hostname, port, ssl=ssl) self.loop.call_later( self.timeout / 1000, lambda: future.done() or future.set_exception(TimeoutError( ))) await fut # self.loop.run_until_complete(fut) self.client = client if ('wait-after-connect' in self.options): await asyncio.sleep(self.options['wait-after-connect'] / 1000) self.emit('open') except Exception as ex: future.done() or future.set_exception(ex) self.emit('err', ex) # return future await future
def _get_connection_task(self): """ Create the connection task that will connect to the websocket server :return: """ factory = WebSocketClientFactory(u"ws://" + str(self._address) + ":" + str(self._port) + self._path) factory.protocol = AgentClientProtocol task = self._loop.create_connection(factory, self._address, self._port) return task
def run(): import asyncio from autobahn.asyncio.websocket import WebSocketClientFactory factory = WebSocketClientFactory() factory.protocol = LineClient 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 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 main(): factory = WebSocketClientFactory(config.WebserverConfig.server_uri) factory.protocol = DCSSProtocol #channel_id = DCSSProtocol.get_channel_id() loop = asyncio.get_event_loop() coro = loop.create_connection(factory, config.WebserverConfig.server_ip, config.WebserverConfig.server_port) client = loop.run_until_complete(coro) #client[1].load_ai_agent() loop.run_forever()
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 start(self): factory = WebSocketClientFactory(config.WebserverConfig.server_uri) factory.protocol = DCSSProtocol #channel_id = DCSSProtocol.get_channel_id() loop = asyncio.get_event_loop() coro = loop.create_connection(factory, config.WebserverConfig.server_ip, config.WebserverConfig.server_port) self.client = loop.run_until_complete(coro) self.has_started = True loop.run_forever()
def init(): try: factory = WebSocketClientFactory('ws://{}:{}'.format(HOST, PORT)) factory.protocol = MyClientProtocol loop = asyncio.get_event_loop() coro = loop.create_connection(factory, HOST, PORT) loop.run_until_complete(coro) loop.run_forever() loop.close() except Exception as err: print('Error while trying to start socket client:') print(err)
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 main(argv): # loads JSON from a file. parametros = os.path.abspath( os.path.join(os.path.dirname(__file__), '..', 'appOmsApi.ini')) with open(parametros, 'r') as f: conArgs = json.load(f) showConf(conArgs) # serviceUrl = 'ws://localhost:8765' serviceUrl = 'wss://' + conArgs['login']['host'] + ':' + conArgs['stomp'][ 'port'] + conArgs['stomp']['service'] print('serviceUrl: ', serviceUrl) print() token = 'a5a1dd5d-3dad-4949-8439-bff0ad2179b5' wssHeader = {'Authorization': 'Bearer ' + token} factory = WebSocketClientFactory(serviceUrl, headers=wssHeader) factory.protocol = MyClientProtocol(conArgs) # SSL client context: default if factory.isSecure: print('Secure Server') print() contextFactory = ssl.SSLContext(ssl.PROTOCOL_TLSv1) contextFactory.check_hostname = False contextFactory.verify_mode = ssl.CERT_NONE else: print('WARNING!!!! NOT Secure Server') print() contextFactory = False loop = asyncio.get_event_loop() # cliente = loop.create_connection(factory, 'localhost', 8765) cliente = loop.create_connection(factory, host=conArgs['login']['host'], port=conArgs['stomp']['port'], ssl=contextFactory) loop.run_until_complete(cliente) try: loop.run_forever() except KeyboardInterrupt: pass finally: print() print('closind cliente ....') print() cliente.close() loop.close()
def run(): import asyncio from autobahn.asyncio.websocket import WebSocketClientFactory global ser ser = serial.Serial(PORT, BAUD, timeout=0.5) # Open named port factory = WebSocketClientFactory() factory.protocol = ArduinoClient 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 main(): executor = ProcessPoolExecutor(2) factory = WebSocketClientFactory(config.WebserverConfig.server_uri) factory.protocol = DCSSProtocol #channel_id = DCSSProtocol.get_channel_id() loop = asyncio.get_event_loop() coro = loop.create_connection(factory, config.WebserverConfig.server_ip, config.WebserverConfig.server_port) client = loop.run_until_complete(coro) client[1].load_ai_agent_from_config() gameconnection = asyncio.create_task(loop.run_in_executor(executor, )) loop.run_forever()
def main(): args = _parse_args() _set_up_logging(args) factory = WebSocketClientFactory(u"ws://%s:%s/%s" % (args.host, args.port, args.venue)) factory.protocol = SnakebotProtocol while True: coro = loop.create_connection(factory, args.host, args.port) loop.run_until_complete(coro) loop.run_forever()
async def client(): factory = WebSocketClientFactory(URI) factory.protocol = ClientProtocol loop = asyncio.get_running_loop() transport, proto = await loop.create_connection(factory, IP, PORT) # await proto.is_open try: await proto.is_closed print("Connection was closed") finally: transport.close() t = normalize_t(proto.t) print_statistics(t, len(DATA), N) plot_statistics(t)
def run_agent(ids, interval): 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=1) factory.protocol = BaselineExecAgent.make_subids(ids).set_timeout(interval) return factory, host, 445, ctx
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 run_simulation(args): host, port, venue, snake = args factory = WebSocketClientFactory(u"ws://%s:%s/%s" % (host, port, venue)) factory.protocol = SnakebotProtocol SnakebotProtocol.snake = snake # https://stackoverflow.com/a/51089229/2209243 connection_coro = loop.create_connection(factory, host, port) transport, protocol = loop.run_until_complete(connection_coro) loop.run_until_complete(protocol.wait_connection_lost()) protocol.dropConnection(abort=True) transport.close() return snake.result
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 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 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 build_client_factory(self): """ Setup a cloudgatewayclientfactory object before a connection is established to Cloudgateway. Configures things like the uri to connect on, auth headers, websocket protocol options, etc. Returns: CloudgatewayClientFactory object """ headers = {'Authorization': sb_auth_header(self.encryption_context)} if self.shard_id: headers[constants.HEADER_SHARD_ID] = self.shard_id self.logger.info("Using shard_id={}".format(self.shard_id)) ws_url = "wss://{0}/deployment".format( self.config.get_spacebridge_server()) proxy, auth = self.config.get_ws_https_proxy_settings() if auth: headers['Proxy-Authorization'] = 'Basic ' + auth if sys.version_info < (3, 0): factory = cloudgateway_client_protocol.CloudgatewayClientFactory( ws_url, headers=headers, proxy=proxy) factory.configure( cloudgateway_client_protocol.SpacebridgeWebsocketProtocol, self.max_reconnect_delay) factory.setProtocolOptions(autoFragmentSize=65536) else: factory = WebSocketClientFactory(ws_url, headers=headers) factory.protocol = aio_client_protocol.AioSpacebridgeServerProtocol factory.autoFragmentSize = 65536 factory.protocol.encryption_context = self.encryption_context factory.protocol.system_auth_header = SplunkAuthHeader( self.system_session_key) factory.protocol.parent_process_monitor = self.parent_process_monitor factory.protocol.logger = self.logger factory.protocol.mode = self.mode factory.protocol.cluster_monitor = self.cluster_monitor factory.protocol.websocket_context = self.websocket_context return factory
def test_wss(self, loop): ws_url = "wss://{}/echo".format(config.get_spacebridge_server()) headers = {'Authorization': "f00d"} use_proxy = self.useProxy proxy, auth = config.get_ws_https_proxy_settings() if use_proxy: # Proxy setup if auth: headers['Proxy-Authorization'] = 'Basic ' + auth else: proxy = None factory = WebSocketClientFactory(ws_url, headers=headers) factory.protocol = CheckMobileWssProtocol factory.state = self.echo_state factory.loop = loop context = ssl.create_default_context(cafile=certifi.where()) coro = loop.create_connection(factory, config.get_spacebridge_server(), 443, ssl=context) self.timeout_id = loop.call_later(10, self.timeout) try: loop.run_until_complete(coro) loop.run_forever() except asyncio.TimeoutError: self.echo_state.message = 'Timeout' except Exception as e: self.echo_state.message = str(e) record = { 'websocket': self.echo_state.ok, 'message': self.echo_state.message } return record
def start(self, **kwargs): host = 'www.bitsgap.com' port = 443 ssl = True conn_str = f'wss://{host}/ws/?wsguid={self.public_key}' factory = WebSocketClientFactory(conn_str) factory.protocol = MyClientProtocol if 'callback' in kwargs: factory.callback = kwargs['callback'] factory.base_client = self loop = asyncio.get_event_loop() try: coro = loop.create_connection(factory, host, port, ssl=ssl) loop.run_until_complete(coro) loop.run_forever() except KeyboardInterrupt: pass finally: 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)
def run(config, botname, log_level, server_port): logging.basicConfig(level=getattr(logging, log_level.upper())) cfg = load_config(config, botname) host = cfg['base-url'] group = cfg["group"] apikey = cfg['apikey'] secret = cfg['secret'] wss_endpoint = cfg['wss-endpoint'] ssl = cfg['ssl'] port = int(cfg.get('wss-port')) or 443 global risk_engine, api risk_engine = FuturesRiskEngine(host, apikey, secret).initialize() api = risk_engine.api if ssl: connect_str = f"wss://{wss_endpoint}:{port}/{group}/api/pro/v2/stream" else: connect_str = f"ws://{wss_endpoint}:{port}/{group}/api/pro/v2/stream" print("Connection string " + connect_str) factory = WebSocketClientFactory(connect_str) factory.protocol = create_protocol(apikey, secret) loop = asyncio.get_event_loop() coro_wss = loop.create_connection(factory, wss_endpoint, port, ssl=ssl) coro_server = app.run_task(port=server_port) async def multitask(): # Assign a single task task1 = loop.create_task(coro_wss) task2 = loop.create_task(coro_server) # Run the task asynchronously await asyncio.wait([task1, task2]) # loop.run_until_complete(coro_wss) loop.run_until_complete(multitask()) loop.run_forever() loop.close()
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 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 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 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)
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 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')
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()
def play(self, acc): self.acc = acc self.loop = asyncio.get_event_loop() Coliseum.userid = acc.getID() time.sleep(random.uniform(1, 2)) self.check = False self.tried = 0 while not self.check: if (self.tried < 3): try: html = self.acc.get('/main.php', param={ 'p': 'coliseum', }, referer='/main.php?p=coliseum') self.check = True except (requests.exceptions.ConnectionError, requests.exceptions.ReadTimeout): print('[' + str(datetime.datetime.now().time())[:-3] + '] ' + 'Coli_1_error') self.tried += 1 time.sleep(random.uniform(1, 2)) pass else: print('[' + str(datetime.datetime.now().time())[:-3] + '] ' + 'Bad network. Try again later.') sys.exit() time.sleep(random.uniform(1, 2)) # print('lenhtml:', len(html.text)) # print('test') self.check = False self.tried = 0 while not self.check: if (self.tried < 3): try: html2 = self.acc.get('http://207.58.158.212:4231/coliseum0/socket.io/1/', param={ 't': str(int(time.time() * 1000)), }, head={ 'Accept': '*/*', 'Origin': 'http://flightrising.com', }, referer='/main.php?p=coliseum' ) self.check = True except (requests.exceptions.ConnectionError, requests.exceptions.ReadTimeout): print('[' + str(datetime.datetime.now().time())[:-3] + '] ' + 'Coli_2_error') self.tried += 1 time.sleep(random.uniform(1, 2)) pass else: print('[' + str(datetime.datetime.now().time())[:-3] + '] ' + 'Bad network. Try again later.') sys.exit() # print('lenhtml2:', len(html2.text)) # print('test2') if (html2.status_code == requests.codes.ok): temp = re.search('(.*):60:60:websocket', html2.text) # print('test3') self.wskey = temp.group(1) # print('test4') self.connection = re.search('(\w+) = io\.connect', html.text).group(1) # print('test5') self.thing = re.search('(\w+) = \'JMxc-w-wd2DQ\'', html.text).group(1) # print('test6') Coliseum.longthing = re.search(self.connection + "\.emit\(" + self.thing + "\, \'(.*?)\'\)\;", html.text).group(1) # print('test7') if self.debuglog: with open(Coliseum.userid + '.log', 'a') as p: p.write('\n' + "Beginning WebSocket operations" + '\n') p.write(self.wskey + '\n') p.write(self.connection + '\n') p.write(self.thing + '\n') p.write(Coliseum.longthing + '\n') factory = WebSocketClientFactory("ws://207.58.158.212:4231/coliseum0/socket.io/1/websocket/" + self.wskey, debug=False, headers=self.headers, useragent=self.useragent ) factory.protocol = Coliseum coro = self.loop.create_connection(factory, '207.58.158.212', 4231) try: self.loop.run_until_complete(coro) self.loop.run_forever() except KeyboardInterrupt: if self.debuglog: with open(Coliseum.userid + '.log', 'a') as p: p.write("----- {}".format("KeyboardInterrupt") + '\n') sys.exit() finally: self.loop.stop() # self.loop.close() return elif not (html2.status_code == requests.codes.ok): # print('Not 200.') print(html2.status_code) else: print("Derp.")
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()
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()
if test.validateResponse(msg): print("Test passed: {}".format(test.__class__.__name__)) self.tests.pop(index) if len(self.tests) == 0: print("Run tests") sys.exit(0) else: self.sendTest() def sendTest(self): test = self.tests[-1] self.sendMessage(test.getPayload()) def onClose(self, wasClean, code, reason): print("Connection to {url} closed: {error_message}".format(url=self.factory.url, error_message=reason)) if __name__ == '__main__': import asyncio factory = WebSocketClientFactory(u"ws://127.0.0.1:9000", useragent="Kommandozentrale TestClient 0.1") factory.protocol = TestClientProtocol 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 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()
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()
# 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()
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()
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)
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()
'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()
# 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()
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()
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()