def serve():
protoConfig = ProtoConfig.getConfig()
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
pushServer = Push(accessToken=protoConfig.wioLinks['havok'].accessToken)
sensors_pb2.add_PushServicer_to_server(pushServer, server)
port = protoConfig.ports.pushPort
server.add_insecure_port('[::]:%s' % port)
server.start()
print('Started Push Server on Port %s ' % port)
websocket.enableTrace(True)
ws = websocket.WebSocketApp(
"wss://us.wio.seeed.io/v1/node/event",
on_message = pushServer.on_message,
on_error = pushServer.on_error,
on_close = pushServer.on_close)
ws.on_open = pushServer.on_open
ws.run_forever()
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
python类enableTrace()的实例源码
def connect(self, callback, traceRoute):
"""Connects the client to the websocket"""
if(not self.isConnected()):
if(traceRoute):
#Enables tracing of connection
self.trace = True
websocket.enableTrace(True)
#Set callback for received messages to go to
self.callback = callback
#Have to put this in here, otherwise respawned dies for some reason
self.ws = websocket.WebSocketApp(WEBSOCKET_URL,
on_message = self.onRecieve,
on_error = self.onError,
on_close = self.onClose)
self.ws.on_open = self.onOpen
#Start the actual connection
self.mainThread = threading.Thread(target = self.ws.run_forever, args=())
self.mainThread.start()
else:
print ("Attempting to connect but already connected.")
def connect(self, host, apiKey, secretKey, trace=False):
"""?????"""
self.host = host
self.apiKey = apiKey
self.secretKey = secretKey
if self.host == OKCOIN_CNY:
self.currency = CURRENCY_CNY
else:
self.currency = CURRENCY_USD
websocket.enableTrace(trace)
self.ws = websocket.WebSocketApp(host,
on_message=self.onMessage,
on_error=self.onError,
on_close=self.onClose,
on_open=self.onOpen)
self.thread = Thread(target=self.ws.run_forever)
self.thread.start()
#----------------------------------------------------------------------
def connect(self):
time.sleep(random.randrange(0, 2**self.connection_attempts))
self.connection_attempts += 1
# websocket.enableTrace(True)
ws = websocket.WebSocketApp(self.config_server_url,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close)
ws.on_open = self.on_open
if self.config_server_url.startswith("wss://"):
ws.run_forever(sslopt={"cert_reqs": ssl.CERT_REQUIRED,
"ca_certs": ca_cert,
"ssl_version": ssl.PROTOCOL_TLSv1_2,
"keyfile": client_pem,
"certfile": client_crt})
else:
ws.run_forever()
def main():
# websocket.enableTrace(True)
if len(sys.argv) < 2:
host = ws_url
else:
host = sys.argv[1]
ws = websocket.WebSocketApp(host,
on_message=on_message,
on_error=on_error,
on_close=on_close)
ws.on_open = on_open
if host.startswith("wss://"):
ws.run_forever(sslopt={"cert_reqs": ssl.CERT_REQUIRED,
"ca_certs": ca_cert,
"ssl_version": ssl.PROTOCOL_TLSv1_2,
"keyfile": client_pem,
"certfile": client_crt})
else:
ws.run_forever()
def websocket_debug():
websocket.enableTrace(True)
def init_connection(self):
logger.debug('Initializing connection')
if self._pconfig['verbose']:
websocket.enableTrace(True)
self.socket = websocket.WebSocketApp(self.service,
on_message=self.on_socket_message,
on_close=self.on_socket_close,
on_error=self.on_socket_error)
self.socket_thread = threading.Thread(target=self.socket.run_forever)
self.socket_thread.daemon = True
self.socket_thread.start()
def setUp(self):
ws.enableTrace(TRACABLE)
def setUp(self):
ws.enableTrace(TRACABLE)
WebSocketAppTest.keep_running_open = WebSocketAppTest.NotSetYet()
WebSocketAppTest.keep_running_close = WebSocketAppTest.NotSetYet()
WebSocketAppTest.get_mask_key_id = WebSocketAppTest.NotSetYet()
def setUp(self):
ws.enableTrace(TRACABLE)
def setUp(self):
ws.enableTrace(TRACABLE)
WebSocketAppTest.keep_running_open = WebSocketAppTest.NotSetYet()
WebSocketAppTest.keep_running_close = WebSocketAppTest.NotSetYet()
WebSocketAppTest.get_mask_key_id = WebSocketAppTest.NotSetYet()
def start(self):
# Standard REST API:
# This is use to get channel_id from a channel_name,
# and the OAuth token needed for Websocket requests
self.twitch = pytwitcherapi.TwitchSession()
self.twitch_login()
self.access_token = self.twitch.token['access_token']
try:
self.channel_id
except AttributeError:
self.channel_id = self.get_channel_id()
self._write_config('channel_id', self.channel_id)
if self.first_run:
# First run was a success, we don't need to wait 45 seconds for user login
# Set first_run param to 0 (== False)
self._write_config('first_run', '0')
# Websocket / PubSub:
# This is use to get Twitch's Bits information stream
if self.verbose:
websocket.enableTrace(True)
self.twitch.ws = websocket.WebSocketApp(
self.ws_host,
on_message=self.on_message,
on_error=self.on_error,
on_close=lambda _: self.log.info("Terminating...")
)
self.cm = ConsoleMini(db_filepath=self.db_filepath, log=self.log)
self.twitch.ws.on_open = self.on_open
self.twitch.ws.run_forever()
def run(self):
websocket.enableTrace(True)
ws = websocket.WebSocketApp(self.url,
on_message = self.on_message,
on_error = self.on_error,
on_close = self.on_close)
ws.on_open = self.on_open
ws.run_forever()
def connect(self):
""" Initialize a websocket handshake. """
tc_header = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0',
'Accept-Language': 'en-US,en;q=0.5',
'Accept-Encoding': 'gzip, deflate, br',
'Sec-WebSocket-Protocol': 'tc',
'Sec-WebSocket-Extensions': 'permessage-deflate'
}
# Comment out next 2 lines to not
# have debug info from websocket show in console.
if config.DEBUG_MODE:
websocket.enableTrace(True)
self._ws = websocket.create_connection(
'wss://wss.tinychat.com',
header=tc_header,
origin='https://tinychat.com'
)
if self._ws.connected:
log.info('connecting to: %s' % self.room_name)
if self.send_join_msg():
self.is_connected = True
self.__callback()
def run_forever(self):
""" This method is used to run the websocket app continuously.
It will execute callbacks as defined and try to stay
connected with the provided APIs
"""
cnt = 0
while True:
cnt += 1
self.url = next(self.urls)
log.debug("Trying to connect to node %s" % self.url)
try:
# websocket.enableTrace(True)
self.ws = websocket.WebSocketApp(
self.url,
on_message=self.on_message,
# on_data=self.on_message,
on_error=self.on_error,
on_close=self.on_close,
on_open=self.on_open
)
self.ws.run_forever()
except websocket.WebSocketException as exc:
if (self.num_retries >= 0 and cnt > self.num_retries):
raise NumRetriesReached()
sleeptime = (cnt - 1) * 2 if cnt < 10 else 10
if sleeptime:
log.warning(
"Lost connection to node during wsconnect(): %s (%d/%d) "
% (self.url, cnt, self.num_retries) +
"Retrying in %d seconds" % sleeptime
)
time.sleep(sleeptime)
except KeyboardInterrupt:
self.ws.keep_running = False
raise
except Exception as e:
log.critical("{}\n\n{}".format(str(e), traceback.format_exc()))
def setUp(self):
ws.enableTrace(TRACABLE)
def setUp(self):
ws.enableTrace(TRACABLE)
WebSocketAppTest.keep_running_open = WebSocketAppTest.NotSetYet()
WebSocketAppTest.keep_running_close = WebSocketAppTest.NotSetYet()
WebSocketAppTest.get_mask_key_id = WebSocketAppTest.NotSetYet()
def start_websocket():
websocket.enableTrace(True)
ws = websocket.WebSocketApp("ws://192.168.31.71:8080/api/ws/runner",
on_message = on_message,
on_error = on_error,
on_close = on_close)
ws.on_open = on_open
ws.run_forever()
# print('start_websocket...')
# t = threading.Thread(target=start_websocket, args=())
# t.start()
def main():
# Connect to websocket interfaces
headers = {}
userpass = ":".join(get_auth())
headers["Authorization"] = "Basic " + base64.b64encode(
userpass.encode()).decode()
url = ("wss://stream.watsonplatform.net//speech-to-text/api/v1/recognize"
"?model=en-US_BroadbandModel")
# If you really want to see everything going across the wire,
# uncomment this. However realize the trace is going to also do
# things like dump the binary sound packets in text in the
# console.
#
# websocket.enableTrace(True)
ws = websocket.WebSocketApp(url,
header=headers,
on_message=on_message,
on_error=on_error,
on_close=on_close)
ws.on_open = on_open
ws.args = parse_args()
# This gives control over the WebSocketApp. This is a blocking
# call, so it won't return until the ws.close() gets called (after
# 6 seconds in the dedicated thread).
ws.run_forever()
def setUp(self):
ws.enableTrace(TRACABLE)
def setUp(self):
ws.enableTrace(TRACABLE)
WebSocketAppTest.keep_running_open = WebSocketAppTest.NotSetYet()
WebSocketAppTest.keep_running_close = WebSocketAppTest.NotSetYet()
WebSocketAppTest.get_mask_key_id = WebSocketAppTest.NotSetYet()
def setUp(self):
ws.enableTrace(TRACEABLE)
def setUp(self):
ws.enableTrace(TRACEABLE)
WebSocketAppTest.keep_running_open = WebSocketAppTest.NotSetYet()
WebSocketAppTest.keep_running_close = WebSocketAppTest.NotSetYet()
WebSocketAppTest.get_mask_key_id = WebSocketAppTest.NotSetYet()
def __init__(self, url, token, on_message):
#websocket.enableTrace(True)
self.ws = websocket.WebSocketApp(url,
on_message = on_message,
on_error = self.on_error,
on_close = self.on_close,
header = ["Authorization: Bearer " + token],
subprotocols=["binary", "base64"])
def setUp(self):
ws.enableTrace(TRACABLE)
def setUp(self):
ws.enableTrace(TRACABLE)
WebSocketAppTest.keep_running_open = WebSocketAppTest.NotSetYet()
WebSocketAppTest.keep_running_close = WebSocketAppTest.NotSetYet()
WebSocketAppTest.get_mask_key_id = WebSocketAppTest.NotSetYet()
def run_client(host_url):
websocket.enableTrace(True)
ws = websocket.WebSocketApp(host_url,
on_message=on_message,
on_error=on_error,
on_close=on_close)
ws.on_open = on_open
ws.run_forever()
# run_client('ws://192.168.43.114:8000/bot')
def connect(self):
screepsConnection = API(u=self.user,p=self.password,ptr=self.ptr,host=self.host,secure=self.secure)
me = screepsConnection.me()
self.user_id = me['_id']
self.token = screepsConnection.token
if self.logging:
logging.getLogger('websocket').addHandler(logging.StreamHandler())
websocket.enableTrace(True)
else:
logging.getLogger('websocket').addHandler(logging.NullHandler())
websocket.enableTrace(False)
if self.host:
url = 'wss://' if self.secure else 'ws://'
url += self.host + '/socket/websocket'
elif not self.ptr:
url = 'wss://screeps.com/socket/websocket'
else:
url = 'wss://screeps.com/ptr/socket/websocket'
self.ws = websocket.WebSocketApp(url=url,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close,
on_open=self.on_open)
ssl_defaults = ssl.get_default_verify_paths()
sslopt_ca_certs = {'ca_certs': ssl_defaults.cafile}
if 'http_proxy' in self.settings and self.settings['http_proxy'] is not None:
http_proxy_port = self.settings['http_proxy_port'] if 'http_proxy_port' in self.settings else 8080
self.ws.run_forever(http_proxy_host=self.settings['http_proxy'], http_proxy_port=http_proxy_port, ping_interval=1, sslopt=sslopt_ca_certs)
else:
self.ws.run_forever(ping_interval=1, sslopt=sslopt_ca_certs)
def __init__(self, ip, password):
ConBase.__init__(self)
threading.Thread.__init__(self)
self.daemon = True
self.fifo = deque()
self.fifo_lock = threading.Lock()
# websocket.enableTrace(logging.root.getEffectiveLevel() < logging.INFO)
self.ws = websocket.WebSocketApp("ws://%s:8266" % ip,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close)
self.start()
self.timeout = 5.0
if b'Password:' in self.read(256, blocking=False):
self.ws.send(password + "\r")
if not b'WebREPL connected' in self.read(256, blocking=False):
raise ConError()
else:
raise ConError()
self.timeout = 1.0
logging.info("websocket connected to ws://%s:8266" % ip)
def setUp(self):
ws.enableTrace(TRACABLE)
