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)
