本文整理汇总了Python中websocket.create_connection函数的典型用法代码示例。如果您正苦于以下问题:Python create_connection函数的具体用法?Python create_connection怎么用?Python create_connection使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了create_connection函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: run
def run(self):
while self.terminate == False:
try:
if hasattr(self, 'ws_rs'):
del self.ws_rx
if hasattr(self, 'ws_tx'):
del self.ws_tx
self.ws_rx = websocket.create_connection('%s/receive' % self.host)
self.ws_tx = websocket.create_connection('%s/submit' % self.host)
self.send_keepalives = True
print 'connected!'
while True and not self.terminate:
msg = json.loads(self.ws_rx.recv())
if msg.get('handle') == 'FIRE':
if time.time() - int(msg.get('timestamp','0')) < MESSAGE_DISCARD_THRESHOLD:
self.squirtgun.pulse(float(msg.get('text', '0.5')))
except websocket.WebSocketConnectionClosedException, e:
print 'connection closed'
self.send_keepalives = False
except socket.error, e:
if e.errno == 61:
print 'connection refused'
else:
print 'socket error number %d' % e.errno
self.send_keepalives = False
示例2: test_forbidden_channel
def test_forbidden_channel(self):
websocket_url = self.websocket_base_url + u'?subscribe-broadcast&publish-broadcast'
try:
create_connection(websocket_url, header=['Deny-Channels: YES'])
self.fail('Did not reject channels')
except WebSocketException:
self.assertTrue(True)
示例3: main
def main():
ws = create_connection("ws://88.198.19.60:9001/")
tw_client = get_twitter_client()
current_state = 0
counter = 0
last_tweet_time = 0
while True:
try:
data = get_socket_data(ws, 'Parrulaituri', 'Analog Sensor Data', 'Soil moisture')
# data = get_socket_data(ws, 'Light Sensor Data', 'Illuminance')
# data = get_socket_data(ws, 'Parrulaituri', 'Barometer Sensor Data', 'Temperature')
value = data.get(u'value')
if value is None:
continue
tweet, current_state = get_tweet(value, current_state, last_tweet_time)
logger.debug(tweet, current_state, value)
if tweet is not None:
tw_client.statuses.update(status=tweet)
last_tweet_time = time.time()
except Exception as e:
logger.exception(e)
ws = create_connection("ws://88.198.19.60:9001/")
tw_client = get_twitter_client()
counter += 1
if counter > 300:
break
示例4: init_websocket
def init_websocket():
try:
GlobalVars.metasmoke_ws = websocket.create_connection(
GlobalVars.metasmoke_ws_host, origin=GlobalVars.metasmoke_host
)
payload = json.dumps(
{
"command": "subscribe",
"identifier": '{"channel":"SmokeDetectorChannel",' '"key":"' + GlobalVars.metasmoke_key + '"}',
}
)
GlobalVars.metasmoke_ws.send(payload)
while True:
a = GlobalVars.metasmoke_ws.recv()
try:
data = json.loads(a)
Metasmoke.handle_websocket_data(data)
except Exception, e:
GlobalVars.metasmoke_ws = websocket.create_connection(
GlobalVars.metasmoke_ws_host, origin=GlobalVars.metasmoke_host
)
payload = json.dumps({"command": "subscribe", "identifier": '{"channel":"SmokeDetectorChannel"}'})
GlobalVars.metasmoke_ws.send(payload)
print e
try:
exc_info = sys.exc_info()
traceback.print_exception(*exc_info)
except:
print "meh"
except:
print "Couldn't bind to MS websocket"
示例5: WebSocketConnection
def WebSocketConnection(self):
if not self.verify_cert:
self.ws = None
self.ws = create_connection(self.url, enable_multithread=True,
sslopt={"cert_reqs": ssl.CERT_NONE})
else:
self.ws = None
if self.identity is not None:
if self.identity.root_ca_cert:
if not (os.path.exists(self.identity.root_ca_cert)):
log.error("Error : Wrong CA certificate path.")
raise ValueError("Error : Wrong CA certificate path.")
else:
log.error("Error : CA certificate path is missing")
raise ValueError("Error : CA certificate path is missing")
if os.path.isfile(self.identity.root_ca_cert):
try:
self.ws = create_connection(self.url, enable_multithread=True,
sslopt={"cert_reqs": ssl.CERT_REQUIRED,
"ca_certs": self.identity.root_ca_cert})
except ssl.SSLError:
log.exception("SSL Error during Websocket connection.")
raise Exception("SSL Error during Websocket connection.")
else:
log.error("Identity object is missing")
raise ValueError("Identity object is missing")
if self.ws is None:
raise (IOError("Couldn't verify host certificate"))
示例6: __init__
def __init__(self, url, timeout=10):
if not url.endswith('/'):
url+='/'
# POST or GET <url>/kernel
# if there is a terms of service agreement, you need to
# indicate acceptance in the data parameter below (see the API docs)
reply = requests.post(
url+'kernel',
data={'accepted_tos':'true'},
headers={'Accept': 'application/json'},
)
# Subsequent connections (including websocket) must preserve
# the cookies for the backend to route to the right server
cookie = ''
for key, value in reply.cookies.items():
cookie += '{0}={1}; '.format(key, value)
# RESPONSE: {"id": "ce20fada-f757-45e5-92fa-05e952dd9c87", "ws_url": "ws://localhost:8888/"}
# construct the iopub and shell websocket channel urls from that
response = reply.json()
self.kernel_url = response['ws_url']+'kernel/'+response['id']+'/'
websocket.setdefaulttimeout(timeout)
print self.kernel_url
self._shell = websocket.create_connection(self.kernel_url+'shell', cookie=cookie)
self._iopub = websocket.create_connection(self.kernel_url+'iopub', cookie=cookie)
# initialize our list of messages
self.shell_messages = []
self.iopub_messages = []
示例7: test_reuseSessionId
def test_reuseSessionId(self):
on_close = lambda(ws): self.assertFalse(True)
ws_url = 'ws:' + base_url.split(':',1)[1] + \
'/000/' + str(uuid.uuid4()) + '/websocket'
ws1 = websocket.create_connection(ws_url, on_close=on_close)
self.assertEqual(ws1.recv(), u'o')
ws2 = websocket.create_connection(ws_url, on_close=on_close)
self.assertEqual(ws2.recv(), u'o')
ws1.send(u'"a"')
self.assertEqual(ws1.recv(), u'a["a"]')
ws2.send(u'"b"')
self.assertEqual(ws2.recv(), u'a["b"]')
ws1.close()
ws2.close()
# It is correct to reuse the same `session_id` after closing a
# previous connection.
ws1 = websocket.create_connection(ws_url)
self.assertEqual(ws1.recv(), u'o')
ws1.send(u'"a"')
self.assertEqual(ws1.recv(), u'a["a"]')
ws1.close()
示例8: ServerWait
def ServerWait():
ws = create_connection(SOCKET_CONNECTION_URL)
# When program starts, open a connection and send a websocket packet to server with following command
# IMPORTANT: whisper_id is a pre-existing number associated with already-created whispers on the server,
# so send me something that i have sent you already...
message = {"pi_incoming_username": PI_USERNAME}
message_str = json.dumps(message)
print "Sending " + message_str
ws.send(message_str)
while True:
try:
result = ws.recv()
print "Received '%s'" % result
json_object = json.loads(result)
whisper_id = json_object['whisper_id']
PostRequest(whisper_id)
except KeyboardInterrupt:
exit()
break
except Exception, e:
print e.message
print "Reconnecting in 30 seconds.."
time.sleep(10)
ws = create_connection(SOCKET_CONNECTION_URL)
ws.send(message_str)
print("[SOCKET] " + PI_USERNAME + " connection restablished...")
示例9: test_client
def test_client(self):
# websocket.enableTrace(True)
ws = websocket.create_connection("ws://127.0.0.1:8888/talk/chat/room_hipo/?token=TOKEN_1234")
# TODO: wait until authorization
time.sleep(2)
d = json.dumps(dict(
body="hello world",
type="message"
))
ws.send(d)
d = json.dumps(dict(
body="hello 2222",
type="message"
))
ws.send(d)
result = ws.recv()
print "result --- ", result
ws.close()
resp = requests.get(
'http://127.0.0.1:8888/talk/history/room_hipo,room_foo?token=TOKEN_1234'
)
data = json.loads(resp.content)
self.assertEquals(data['results'][0]['messages'][0]["body"], "hello 2222")
self.assertEquals(len(data['results'][1]["messages"]), 0)
ws = websocket.create_connection("ws://127.0.0.1:8888/talk/chat/room_hipo/?token=TOKEN_5555")
time.sleep(5)
d = json.dumps(dict(
body="hello world 3333",
type="message"
))
ws.send(d)
d = json.dumps(dict(
body="hello 4444",
type="message"
))
ws.send(d)
ws.close()
resp = requests.get(
'http://127.0.0.1:8888/talk/old/room_hipo?token=TOKEN_1234'
)
data = json.loads(resp.content)
print "================================"
print "un......"
print data['results']['unread_messages'][0]
print "================================"
self.assertEquals(data['results']['read_messages'][0]["body"], "hello 2222")
self.assertEquals(data['results']['unread_messages'][0]["body"], "hello 4444")
示例10: test_asgi_ws_order_0
def test_asgi_ws_order_0(site, asgi):
# websocket.connect['order'] should always be 0
ws1 = create_connection(site.ws_url, timeout=2)
asgi_connect1 = asgi.receive_ws_connect()
assert asgi_connect1['order'] == 0
ws2 = create_connection(site.ws_url, timeout=2)
asgi_connect2 = asgi.receive_ws_connect()
assert asgi_connect2['order'] == 0
示例11: __init__
def __init__(self, ph):
pubport = ":1990"
hunterport = ":1991"
preyport = ":1992"
host = "ws://localhost"
self.ph = ph
self.pubsocket = create_connection(host + pubport)
self.phsocket = create_connection(host + (preyport if ph == 'p' else hunterport))
示例12: run
def run():
from websocket import create_connection
uri = 'ws://%s:%s/:/websockets/notifications' % (
plexcs.CONFIG.PMS_IP,
plexcs.CONFIG.PMS_PORT
)
# Set authentication token (if one is available)
if plexcs.CONFIG.PMS_TOKEN:
uri += '?X-Plex-Token=' + plexcs.CONFIG.PMS_TOKEN
ws_connected = False
reconnects = 0
# Try an open the websocket connection - if it fails after 15 retries fallback to polling
while not ws_connected and reconnects <= 15:
try:
logger.info(u'Plex:CS WebSocket :: Opening websocket, connection attempt %s.' % str(reconnects + 1))
ws = create_connection(uri)
reconnects = 0
ws_connected = True
logger.info(u'Plex:CS WebSocket :: Ready')
except IOError as e:
logger.error(u'Plex:CS WebSocket :: %s.' % e)
reconnects += 1
time.sleep(5)
while ws_connected:
try:
process(*receive(ws))
# successfully received data, reset reconnects counter
reconnects = 0
except websocket.WebSocketConnectionClosedException:
if reconnects <= 15:
reconnects += 1
# Sleep 5 between connection attempts
if reconnects > 1:
time.sleep(5)
logger.warn(u'Plex:CS WebSocket :: Connection has closed, reconnecting...')
try:
ws = create_connection(uri)
except IOError as e:
logger.info(u'Plex:CS WebSocket :: %s.' % e)
else:
ws_connected = False
break
if not ws_connected:
logger.error(u'Plex:CS WebSocket :: Connection unavailable, falling back to polling.')
plexcs.POLLING_FAILOVER = True
plexcs.initialize_scheduler()
logger.debug(u'Plex:CS WebSocket :: Leaving thread.')
示例13: test
def test():
log_debug('register', 'start testing ')
get_pkgs_details_cnt = 0
for i in range(TEST_ROUNDS):
if SHOW_TIME:
start_time = datetime.utcnow()
if RANDOM_CAT:
cat_num = randint(0, len(CAT) - 1)
cat_name = CAT[cat_num]
if not CATEGORIES.has_key(cat_name):
log_err('get_packages_details', 'failed to get the category, invalid category is %s' % str(cat_name))
return False
cate = CATEGORIES[cat_name]
else:
cate = CATEGORY
message = json.dumps({'operator':'get_counter', 'category':cate})
ws = create_connection("ws://%s:%d/" % (get_manager(), get_port()))
ws.send(message)
ret = ws.recv()
ws.close()
result = json.loads(ret)
if not result or 'get_counter' != result['operator'] or cate != result['category'] or not result['data']:
log_err('get_counter', 'failed to get counter')
return False
counter = result['data']
if not counter:
log_err('get_counter', 'failed to get the total number of %s ' % str(cate))
return False
if SHOW_TIME:
log_debug('get_counter', 'time=%d sec' % (datetime.utcnow() - start_time).seconds)
log_debug('get_counter', 'counter=%s' % str(counter))
rank = randint(0, (int(counter) + PAGE_SIZE - 1) / PAGE_SIZE - 1)
log_debug('get_counter', 'rank=%d' % rank)
if SHOW_TIME:
start_time = datetime.utcnow()
message = json.dumps({'operator':'get_packages_details', 'category':cate, 'rank':rank})
ws = create_connection("ws://%s:%d/" % (get_manager(), get_port()))
ws.send(message)
ret = ws.recv()
ws.close()
result = json.loads(ret)
if not result or 'get_packages_details' != result['operator'] or cate != result['category'] or rank != result['rank'] or not result['data']:
log_err('get_packages_details', 'failed to get packages details')
return False
ret = result['data']
for item in ret:
if not item['pkg'] or not item['title'] or not item['auth']:
log_err('get_packages_details', 'failed to get valid details')
return False
if SHOW_TIME:
log_debug('get_packages_details', 'time=%d sec' % (datetime.utcnow() - start_time).seconds)
get_pkgs_details_cnt += 1
log_debug('get_packages_details', 'get_pkgs_details_cnt=%d' % get_pkgs_details_cnt)
log_debug('get_packages_details', 'packages_details=%s' % str(ret))
示例14: __init__
def __init__(self):
f = urllib2.urlopen("%s/kernel" % (root,), "")
data = json.loads(f.read())
f.close()
self.kernel_id = data["kernel_id"]
self.ws_url = data["ws_url"]
self.iopub = websocket.create_connection("%skernel/%s/iopub" % (self.ws_url, self.kernel_id))
self.shell = websocket.create_connection("%skernel/%s/shell" % (self.ws_url, self.kernel_id))
self.session_id = str(uuid.uuid4())
示例15: test_host_api_garbage_token
def test_host_api_garbage_token(client):
hosts = client.list_host(kind='docker', removed_null=True)
assert len(hosts) > 0
# pass garbage token
stats = hosts[0].stats()
with pytest.raises(Exception) as excinfo:
ws.create_connection(stats.url+'?token=abcd')
assert 'Handshake status 401' in str(excinfo.value)