def on_close(ws): print("### closed ###") def on_open(ws): def run(*args): for i in range(3): time.sleep(1) ws.send("Hello %d" % i) time.sleep(40) # todo ws.close() print("thread and websocket terminating...") threading.Thread(target=run).start() if __name__ == "__main__": # websocket.enableTrace(True) ws = websocket.WebSocketApp( "ws://echo.websocket.org/", on_ping=on_ping, on_pong=on_pong, on_error=on_error, on_close=on_close, ) ws.on_open = on_open ws.on_message = on_message ws.run_forever()
def connect_and_send_admin_command(self, command, arg_characters=None): if command == "nmi": func = self.send_nmi success_message = "NMI sent successfully \r\n" failure_message = "Failed to send NMI \r\n" loading_text = "Sending NMI to VM" elif command == "reset": func = self.send_reset success_message = "Successfully Hard Reset VM \r\n" failure_message = "Failed to Hard Reset VM \r\n" loading_text = "Forcing VM to Hard Reset" elif command == "sysrq" and arg_characters is not None: def wrapper(): return self.send_sys_rq(arg_characters) func = wrapper success_message = "Successfully sent SysRq command\r\n" failure_message = "Failed to send SysRq command. Make sure the input only contains numbers and letters.\r\n" loading_text = "Sending SysRq to VM" else: return GV.loading = True th1 = threading.Thread(target=self.send_loading_message, args=(loading_text, )) th1.daemon = True th1.start() if self.load_websocket_url(): def on_message(ws, _): GV.trycount += 1 if func(): GV.loading = False GV.terminating_app = True print(success_message, end="") ws.close() elif GV.trycount >= 2: GV.loading = False GV.terminating_app = True print(failure_message, end="") ws.close() wsapp = websocket.WebSocketApp( self.websocket_url + "?authorization=" + self.access_token, on_message=on_message) wsapp.run_forever() GV.loading = False if GV.trycount == 0: error_message = "Could not establish connection to VM or VMSS." recommendation = 'Try restarting it with "az vm restart".' raise AzureConnectionError(error_message, recommendation=recommendation) else: GV.loading = False error_message = "An unexpected error occured. Could not establish connection to VM or VMSS." recommendation = "Check network connection and try again." raise ResourceNotFoundError(error_message, recommendation=recommendation)
key = f'bitmex/tick/xbtusd' redis.set(key, data) def on_error(self, evt): print('running on_error....') websocket.enableTrace(False) host = url ws = websocket.WebSocketApp(host, on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever(ping_interval=30, ping_timeout=15) def on_close(self, evt): print('DISCONNECT') if __name__ == "__main__": websocket.enableTrace(False) host = url ws = websocket.WebSocketApp(host, on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever(ping_interval=30, ping_timeout=15)
import websocket def on_message(ws, msg): print(msg) def on_error(ws, error): print(error) def on_close(ws): print("connection closed ...") def on_open(ws): req = '{"event": "subscribe", "channel":"chan1"}' print(req) ws.send(req) if __name__ == '__main__': # websocket.enableTrace(True) ws = websocket.WebSocketApp("ws://127.0.0.1:8181", on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever(ping_timeout=30)
mqtt_client.on_disconnect = on_mqtt_disconnect mqtt_client.username_pw_set(settings['mqtt_username'], settings['mqtt_password']) mqtt_client.tls_set('/etc/ssl/certs/DST_Root_CA_X3.pem') mqtt_client.will_set(settings['mqtt_topic_prefix'] + 'available', 'offline', 1, retain=True) mqtt_client.connect(settings['mqtt_server'], settings.get('mqtt_port', 8883), 60) mqtt_client.loop_start() while True: # websocket.enableTrace(True) ws = websocket.WebSocketApp(settings['pixelblaze_address'], on_open=on_open, on_close=on_close, on_message=on_message, on_error=on_error) ws.run_forever( ping_interval=3, ping_timeout=2, ) time.sleep(5)
print(rsi) last_rsi = rsi[-1] if last_rsi > RSI_OVERBOUGHT: #Sell if inPosition: #Sell order_succeeded = order(SIDE_SELL, TRADE_QUANTITY, TRADE_SYMBOL) if order_succeeded: inPosition = False else: #Nothing to do "...(no sale)" if last_rsi < RSI_OVERSOLD: #Buy if inPosition: #We already own print("...no buy") else: #If we have not already bought: buy order_succeeded = order(SIDE_BUY, TRADE_QUANTITY, TRADE_SYMBOL) if order_succeeded: inPosition = True ws = websocket.WebSocketApp(SOCKET, on_open=on_open, on_close=on_close, on_message=on_message) ws.run_forever()
def on_open(ws): def run(*args): print("Start Streaming Data!") _thread.start_new_thread(run, ()) if __name__ == "__main__": # URL for WebSocket Connection from Streaming API page hostname = "internal-ui.central.arubanetworks.com" url = "wss://{}/streaming/api".format(hostname) # Construct Header for WebSocket Connection header = {} # Central User email header["UserName"] = "******" # WebSocket Key from Streaming API Page header["Authorization"] = "XXXXXX" # Subscription TOPIC for Streaming API # (audit|apprf|location|monitoring|presence|security) header["Topic"] = "monitoring" # Create WebSocket connection websocket.enableTrace(True) ws = websocket.WebSocketApp(url=url, header=header, on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever()
raise def on_message(ws, message): try: print(message) res = json.loads(message) except: return try: if not res['server']: print("connect failed") ws.close() os._exit() if re['user']: users.add(res) handler(ws) except: return def on_error(ws, error): print("websocket:",error) def on_close(ws): print("### closed ###") if __name__ == "__main__": websocket.enableTrace(True) wsr = websocket.WebSocketApp('ws://'+setting.server_ip+'/backend',on_message=on_message,on_close=on_close,on_error=on_error) wsr.on_open = on_open wsr.run_forever()
def on_error(ws, error): print(error) def on_close(ws): print("### closed ###") def on_open(ws): def run(*args): print('nsRobot Running!') time.sleep(1) thread.start_new_thread(run, ()) if __name__ == "__main__": initMirai() wsURL = "ws://{}/all?verifyKey={}&sessionKey={}&qq={}".format( init.miraiURL[7:], miraiKey, mirai.session, miraiQQ) print(wsURL) websocket.enableTrace(True) ws = websocket.WebSocketApp(url=wsURL, on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever()
print(message) def on_error(ws, error): print(error) def on_close(ws): print("### closed ###") def on_open(ws): def run(*args): for i in range(3): time.sleep(1) ws.send("Hello %d" % i) time.sleep(1) ws.close() print("thread terminating...") thread.start_new_thread(run, ()) if __name__ == "__main__": websocket.enableTrace(True) ws = websocket.WebSocketApp("ws://localhost:8081", on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever()
credentials = file.read().replace('\n', '') mongo_client = MongoClient(credentials) # e.g. 'mongodb://localhost:27017' db = mongo_client['cryptocurrency'] bitfinex_coll = db['bitfinex'] def on_message(mes): print(datetime.datetime.now()) print("Bitfinex - 4 - EOS-USD:" + " " + mes) message = json.loads(mes) if message[1] in ('tu'): result = { '_id': message[2][0], 't': message[2][1], 'q': message[2][2], 'p': message[2][3], 's': 'EOS-USD', 'date': datetime.datetime.utcnow().strftime('%Y-%m-%d') } res = bitfinex_coll.insert_one(result) ws = websocket.WebSocketApp('wss://api-pub.bitfinex.com/ws/2') ws.on_open = lambda self: self.send( '{ "event": "subscribe", "channel": "trades", "symbol": "tEOSUSD"}') ws.on_message = lambda self, evt: on_message(evt) ws.run_forever(ping_interval=10, ping_timeout=5)
'DASHUSDT' ] stream = ['@depth5@500ms'] BidAsk = {} AggTrades = {} SymKlns = {} client = Client(apikey, scrkey, testnet=testnet) client.change_position_mode(dualSide='true') for symbol in insIds: client.change_leverage(symbol, 1) BidAsk[symbol] = [] AggTrades[symbol] = [] SymKlns[symbol] = [] print('\n' + barstr(text='Start Data Streaming') + '\n') header_print(testnet, client) print('\nStream updating...') listen_key = client.get_listen_key() ws = websocket.WebSocketApp(f'{client.wss_way}{listen_key}', on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever() print('\n\tLocal Time at Close: %s \n' % timestr(time.time() * 1000)) print( barstr(text='Elapsed time = {} seconds'.format( round(time.time() - start_time, 2)))) print(barstr(text="", space_size=0)) os._exit(1)
threading.Thread(target=_run, args=(ws, id)).start() def setup_args(): """ Set up args, specifically for the port number. :return: A parser that parses the port from commandline arguments. """ parser = ParlaiParser(False, False) parser_grp = parser.add_argument_group('Terminal Chat') parser_grp.add_argument('--port', default=35496, type=int, help='Port to run the terminal chat server') return parser.parse_args() if __name__ == "__main__": opt = setup_args() port = opt.get('port', 34596) print("Connecting to port: ", port) ws = websocket.WebSocketApp( "ws://localhost:{}/websocket".format(port), on_message=on_message, on_error=on_error, on_close=on_close, ) ws.on_open = on_open ws.run_forever()
def on_message(ws, message): print(message) def on_error(ws, error): print(error) def on_close(ws): print("### closed ###") # def on_open(ws): # def run(*args): # # for i in range(3): # # time.sleep(1) # # ws.send("Hello %d" % i) # # time.sleep(1) # # ws.close() # # print("thread terminating...") # thread.start_new_thread(run, ()) if __name__ == "__main__": websocket.enableTrace(True) ws = websocket.WebSocketApp("ws://youthful-driver.glitch.me/", on_message=on_message, on_error=on_error, on_close=on_close) # ws.on_open = on_open ws.run_forever()
def main(arg1): # JWT Token #key='mySecretKey327a89b42cf9b9fb2d6eeb8f0dac1540440b10da34c7789737b67bad0d729d46' #data={'sub': '1234567890','name': 'John Doe','exp': 1548857731} #token = jwt.encode(data, key, algorithm='HS256').decode('utf-8') def on_subscribe(client, userdata, mid, granted_qos): #create function for callback print("subscribed with qos", granted_qos, "\n") pass def on_message(client, userdata, message): #receivedMessage = json.loads(str(message.payload.decode("utf-8"))) #containerName = receivedMessage["containerName"] #containerId = receivedMessage["containerId"] #rollingSecret = receivedMessage["rollingSecret"] #url = receivedMessage["url"] #print(containerName + " " + containerId + " " + rollingSecret + " " + url) print("message received ", str(message.payload.decode("utf-8"))) print(" ") ws.send(str(message.payload.decode("utf-8"))) def on_publish(client, userdata, mid): #create function for callback print("data published mid=", mid, "\n") print(" ") pass def on_disconnect(client, userdata, rc): print("client disconnected ok") receivedMessage = json.loads(arg1) secret = receivedMessage["secret"] containerName = receivedMessage["containerName"] containerId = receivedMessage["containerId"] print(secret) print(containerName) print(containerId) print(type(secret)) # JWT Token key = secret + containerId print(key) data = {'sub': '1234567890', 'name': 'John Doe', 'exp': 1557002934} token = jwt.encode(data, key, algorithm='HS256').decode('utf-8') # WebSocket ws = websocket.WebSocketApp(containerName, header={'Authorization: Bearer ' + token}, on_message=on_message) # WebSocket Thread to execute run_forever() wst = threading.Thread(target=ws.run_forever) wst.daemon = True wst.start() #Create client object client = paho.Client("client-socks", transport='websockets') client.on_subscribe = on_subscribe #assign function to callback client.on_publish = on_publish #assign function to callback client.on_message = on_message #assign function to callback client.on_disconnect = on_disconnect print("Connecting to Broker ", broker, "on port ", port) client.connect(broker, port) #establish connection print("Subscribing to ", sub_topic) client.subscribe(sub_topic) while True: client.loop_start() #start loop time.sleep(2) client.loop_stop()
def on_error(ws, error): writeLog(error) def on_close(ws): os.remove(pathSubscriptionIds) message = "Socket was closed." writeLog(message) def on_open(ws): subscribe(loginToken) if __name__ == "__main__": loginToken = apicLogin() refreshThread = threading.Thread(target=refresh) refreshThread.start() websocket.enableTrace(True) ws = websocket.WebSocketApp("wss://" + config['apic_login']['address'] + "/socket" + loginToken, on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever(sslopt={"cert_reqs": ssl.CERT_NONE})
def on_open(ws): def run(*args): time.sleep(1) ws.send(json.dumps(AreaBlitz)) thread.start_new_thread(run, ()) def send_notification(message): params = { 'user': USER_TOKEN, 'token': APP_TOKEN, 'title': 'Notiblitz', 'message': message } requests.post('https://api.pushover.net/1/messages.json', data=params) if __name__ == "__main__": websocket.enableTrace(True) # port = random.randint(8050, 8090) port = 8057 ws = websocket.WebSocketApp("ws://ws.blitzortung.org:" + str(port), on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever()
# 最后一帧处理 elif status == STATUS_LAST_FRAME: d = {"data": {"status": 2, "format": "audio/L16;rate=16000", "audio": str(base64.b64encode(buf), 'utf-8'), "encoding": "raw"}} ws.send(json.dumps(d)) time.sleep(1) break # 模拟音频采样间隔 time.sleep(intervel) ws.close() thread.start_new_thread(run, ()) if __name__ == "__main__": # 测试时候在此处正确填写相关信息即可运行 time1 = datetime.now() wsParam = Ws_Param(APPID='5dd9f6c9', APIKey='db057df4cc9e6e8b4ea51a0b067008ef', APISecret='3ba16aa23db6d5c534d3d9dde376563a', AudioFile='demo1.pcm') websocket.enableTrace(False) wsUrl = wsParam.create_url() ws = websocket.WebSocketApp(wsUrl, on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever(sslopt={"cert_reqs": ssl.CERT_NONE}) time2 = datetime.now() print(time2 - time1) print("global:") print(strs)
print(f"[!!!] Skipping data! {data['table']} Action: {data['action']} Data: {data['data']}") def on_error(ws, error): print(error) def on_close(ws): print("### closed ###") def on_open(ws): print("thread terminating...") if __name__ == "__main__": websocket.enableTrace(True) ws = websocket.WebSocketApp('wss://www.bitmex.com/realtime?subscribe=tradeBin1m:XBTUSD,tradeBin5m:XBTUSD,instrument:XBTUSD', on_message = on_message, on_error = on_error, on_close = on_close) # ws = websocket.WebSocketApp('wss://www.bitmex.com/realtime?subscribe=funding:XBTUSD', # on_message = on_message, # on_error = on_error, # on_close = on_close) ws.on_open = on_open ws.run_forever() # # turn off SSL certification check for BitMEX websocket # ws = websocket.WebSocket(sslopt={'cert_reqs': ssl.CERT_NONE}) # ws.on('') # # connect and subscribe to websocket chanels # ws.connect()
def on_close(ws): print("closed") logging.debug("closed") def on_open(ws): subscribe(ws, "1", "") subscribe(ws, "6", "") subscribe(ws, "f6380db0-c00d-4e0c-8de6-bda0d83ab212", "") def subscribe(ws, channel, password): if (password == ""): msg = '{"subscribe":{"channelId":\"' + channel + '\"}}' else: msg = '{"subscribe":{"channelId":\"' + channel + '\", "password":\"' + password + '\"}}' print(msg) logging.debug(msg) ws.send(msg) if __name__ == "__main__": websocket.enableTrace(True) ws = websocket.WebSocketApp("ws://coffee.waeco-soft.com/websocket", on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever()
def on_close(ws): print "### stream closed ###" def on_open(ws): print "### stream opened ###" if (tutum_auth): header = "Authorization: " + tutum_auth else: header = "Authorization: Basic %s" % base64.b64encode("%s:%s" % (username, apikey)) ws = websocket.WebSocketApp('wss://stream.tutum.co/v1/events', header=[header], on_message=on_message, on_error=on_error, on_close=on_close, on_open=on_open ) existing_containers = tutum.Container.list(service=service_full) for container in existing_containers: if container.state in ['Running', 'Starting', 'Creating']: containers[container.resource_uri] = container print "Found " + str(len(containers)) + " containers" rewrite_config() ws.run_forever()
def initiate(self): websocket.enableTrace(True) self.ws = websocket.WebSocketApp("ws://"+self.ip+"/pubsub",on_message = self.on_message,on_error = self.on_error,on_close = self.on_close) self.ws.on_open = self.on_open self.ws.run_forever(ping_timeout=10)
def confirmexecution(orderid: str, poststatus: object, bidpricing: object) -> None: # Introduce function. logger.debug( f'Confirming execution of the order identified by the Gemini assigned number: {orderid}' ) # Define websocket functions. def on_close(ws): logger.debug(f'{ws} connection closed.') def on_open(ws): logger.debug(f'{ws} connection opened.') def on_error(ws, error): logger.debug(error) def on_message(ws, message, orderid=orderid): dictionary = json.loads(message) exitstatus = '' # Remove comment to debug with: logger.debug( dictionary ) # Check if this is an 'initial' message from Gemini. # It is actually the second message. The subscription acknowledgement is first. if dictionary == []: exitstatus = f'Order {orderid} not active.' if isinstance(dictionary, list): for listitem in dictionary: size = listitem['original_amount'] pair = listitem['symbol'].upper() rate = listitem['price'] side = listitem['side'] cost = Decimal(size) * Decimal(rate) bit0 = f'{pair} {side} order {orderid} valued at ' bit1 = f'{cost.quantize( Decimal(rate) )} {pair[3:].upper()} ' bit2 = f'[{size} {pair[:3].upper()} at {rate} {pair[3:].upper()}] was ' text = f'{bit0}{bit1}{bit2}' if listitem['order_id'] == orderid: # Exit upon receiving order cancellation message. if listitem['is_cancelled']: exitstatus = f'{text} cancelled.' if listitem['type'] == 'cancelled': exitstatus = f'{text} cancelled [reason:{listitem["reason"]}].' if listitem['type'] == 'rejected': exitstatus = f'{text} rejected.' if listitem['type'] == 'fill': # Make sure that the order was completely filled. if listitem['remaining_amount'] == '0': exitstatus = f'{text} filled.' if exitstatus: ws.close() logger.info(exitstatus) smsalert(exitstatus) poststatus.setvalue(exitstatus) bidpricing.setvalue(rate) # Construct payload. endpoint = '/v1/order/events' nonce = int(time.time() * 1000) payload = {'request': endpoint, 'nonce': nonce} header = authenticator.authenticate(payload) # Establish websocket connection. logger.debug( f'Establishing websocket connection to confirm the execution of order number {orderid}.' ) ws = websocket.WebSocketApp(str(resourcelocator.sockserver + endpoint), on_open=on_open, on_message=on_message, on_error=on_error, on_close=on_close, header=header['sockheader']) ws.run_forever(sslopt={'cert_reqs': ssl.CERT_NONE})
coin = Coin(coin_name, "usdt") instrument_id = coin.get_instrument_id() future_instrument_id = coin.get_future_instrument_id() file_transaction, file_deal = coin.gen_file_name() config_file = sys.argv[2] if config_file == 'config_mother': from config_mother import spotAPI, okFuture, futureAPI elif config_file == 'config_son1': from config_son1 import spotAPI, okFuture, futureAPI elif config_file == 'config_son3': from config_son3 import spotAPI, okFuture, futureAPI else: print( '输入config_file有误,请输入config_mother or config_son1 or config_son3' ) sys.exit() ws = websocket.WebSocketApp( "wss://real.okex.com:10440/websocket/okexapi?compress=true", on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open while True: ws.run_forever(ping_interval=20, ping_timeout=10) print("write left lines into file...") with codecs.open(file_deal, 'a+', 'UTF-8') as f: f.writelines(write_lines) write_lines = [] else: print('缺少参数 coin_name, config_file') print('for example: python monitor_spot etc config_mother')
def start(self, ping_interval=5, ping_timeout=3): """ 开始合成,新建到服务端的连接 :param ping_interval: 自动发送ping命令,指定发送间隔,单位为秒 :param ping_timeout: 等待接收pong消息的超时时间,单位为秒 :return: 与服务端建立连接成功,返回0 与服务端建立连接失败,返回-1 """ if self._status == Status.STATUS_INIT: _log.debug('starting synthesizer...') self._status = Status.STATUS_STARTING else: _log.error("Illegal status: %s" % self._status) return -1 def _on_open(ws): _log.debug('websocket connected') self._status = Status.STATUS_STARTED self._is_connected = True time.sleep(0.01) msg_id = six.u(uuid.uuid1().hex) self._task_id = six.u(uuid.uuid1().hex) self._header[Constant.HEADER_KEY_NAME] = Constant.HEADER_VALUE_TTS_NAME_START self._header[Constant.HEADER_KEY_MESSAGE_ID] = msg_id self._header[Constant.HEADER_KEY_TASK_ID] = self._task_id text = self.serialize() _log.info('sending start cmd: ' + text) ws.send(text) def _on_data(ws, raw, opcode, flag): if opcode == websocket.ABNF.OPCODE_BINARY: _log.debug("received binary data, size: %s" % len(raw)) self._callback.on_binary_data_received(raw) elif opcode == websocket.ABNF.OPCODE_TEXT: _log.debug("websocket message received: %s" % raw) msg = json.loads(raw) name = msg[Constant.HEADER][Constant.HEADER_KEY_NAME] if name == Constant.HEADER_VALUE_TTS_NAME_COMPLETED: self._status = Status.STATUS_STOPPED _log.debug('websocket status changed to stopped') _log.debug('callback on_completed') self._callback.on_completed(msg) elif name == Constant.HEADER_VALUE_NAME_TASK_FAILED: self._status = Status.STATUS_STOPPED _log.error(msg) _log.debug('websocket status changed to stopped') _log.debug('callback on_task_failed') self._callback.on_task_failed(msg) def _on_close(ws): _log.debug('callback on_channel_closed') self._callback.on_channel_closed() def _on_error(ws, error): if self._is_connected or self._last_start_retry: _log.error(error) self._status = Status.STATUS_STOPPED message = json.loads('{"header":{"namespace":"Default","name":"TaskFailed",' '"status":400,"message_id":"0","task_id":"0",' '"status_text":"%s"}}' % error) self._callback.on_task_failed(message) else: _log.warning('retry start: %s' % error) retry_count = 3 for count in range(retry_count): self._status = Status.STATUS_STARTING if count == (retry_count - 1): self._last_start_retry = True # Init WebSocket self._ws = websocket.WebSocketApp(self._gateway_url, on_open=_on_open, on_data=_on_data, on_error=_on_error, on_close=_on_close, header={Constant.HEADER_TOKEN: self._token}) self._thread = threading.Thread(target=self._ws.run_forever, args=(None, None, ping_interval, ping_timeout)) self._thread.daemon = True self._thread.start() # waite for no more than 10 seconds for i in range(1000): if self._status == Status.STATUS_STARTED or self._status == Status.STATUS_STOPPED: break else: time.sleep(0.01) if self._status == Status.STATUS_STARTED: # 与服务端连接建立成功 _log.debug('start succeed!') return 0 else: if self._is_connected or self._last_start_retry: # 已建立了WebSocket链接但是与服务端的连接失败, 或者是最后一次重试,则返回-1 _log.error("start failed, status: %s" % self._status) return -1 else: # 尝试重连 continue
connstat = False def ws_client_on_open(ws): global connstat print("### ws_client opened ###") connstat = True def server_start(): #while True: server.serveforever() print("server restart") def client_start(): #while True: ws_client.run_forever() #() print("client restart") if __name__ == "__main__": server = SimpleWebSocketServer('', 1234, Server) threading.Thread(target=server_start).start() ws_client = websocket.WebSocketApp("ws://" + obshost + ":" + obsport, on_message=ws_client_on_message, on_error=ws_client_on_error, on_close=ws_client_on_close) ws_client.on_open = ws_client_on_open threading.Thread(target=client_start).start()
def on_open(ws): print('Connected') def run(*args): ws.run_forever() # def connect(): # websocket.enableTrace(True) # ws = websocket.WebSocketApp("ws://192.168.43.23:8000", on_message = on_message, on_error = on_error, on_close = on_close) # ws.on_open = on_open websocket.enableTrace(True) ws = websocket.WebSocketApp("ws://192.168.43.23:8000", on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open thread.start_new_thread(run, ()) def tell(): data = {'type': 'tts', 'data': u' পারিই '} data = json.dumps(data) ws.send(data) print("Sent=", data) def speak():
print(error) ## Call back the the connection is closed def on_close(ws): print("### closed ###") # Open web socket channel connection def on_open(ws): def run(*args): for i in range( 10 ): # choose how many seconds you want the web socket session to ran for time.sleep(1) ws.send("Running session for %d seconds" % i) time.sleep(1) ws.close() print("thread terminating...") thread.start_new_thread(run, ()) if __name__ == "__main__": websocket.enableTrace(True) ws = websocket.WebSocketApp("ws://nym-mix-node:9001/mix/", on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever()
def on_open(ws): def run(*args): for i in range(3): time.sleep(1) msg = { 'msgType': 'POSITION_SUB', 'target': '1', 'lat': '12.4', 'lng': '37.2' } json_msg = json.dumps(msg) ws.send("{}".format(json_msg)) time.sleep(1) #ws.close() print("thread terminating...") Thread(target=run).start() if __name__ == "__main__": ws = websocket.WebSocketApp("ws://localhost:8080/monitor/car", on_open=on_open, on_message=on_message, on_error=on_error, on_close=on_close) ws.run_forever() ws.close() print("종료합니다.")
def on_error(ws, error): print(error) def on_close(ws): print("### closed ###") def on_open(ws): def run(*args): while True: time.sleep(1) #ws.close() print("thread terminating...") thread.start_new_thread(run, ()) if __name__ == "__main__": while True: time.sleep(1) try: websocket.enableTrace(False) ws = websocket.WebSocketApp("ws://hplc.inc-forschung.kfa-juelich.de/ws/JuHPLC/ThinClient/", on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open = on_open ws.run_forever() except ex: print("exception, restarting connection to server") print(ex)