Python websocket.create_connection函数代码示例

    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

 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)

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

    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"

 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"))

    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 = []

    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()

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...")

    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")

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

 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))

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.')

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))

 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())

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)