def test_timeout_event_on_broken_heartbeat(self): ch = helper.gen_channel("heartbeat-test") pubnub = PubNub(messenger_config) pubnub_listener = PubNub(listener_config) pubnub.config.uuid = helper.gen_channel("messenger") pubnub_listener.config.uuid = helper.gen_channel("listener") callback_presence = SubscribeListener() callback_messages = SubscribeListener() # - connect to :ch-pnpres pubnub_listener.add_listener(callback_presence) pubnub_listener.subscribe().channels(ch).with_presence().execute() callback_presence.wait_for_connect() presence_message = callback_presence.wait_for_presence_on(ch) assert ch == presence_message.channel assert 'join' == presence_message.event assert pubnub_listener.uuid == presence_message.uuid # - connect to :ch pubnub.add_listener(callback_messages) pubnub.subscribe().channels(ch).execute() callback_messages.wait_for_connect() prs_envelope = callback_presence.wait_for_presence_on(ch) assert ch == prs_envelope.channel assert 'join' == prs_envelope.event assert pubnub.uuid == prs_envelope.uuid # wait for one heartbeat call time.sleep(6) # - break messenger heartbeat loop pubnub._subscription_manager._stop_heartbeat_timer() # - assert for timeout presence_message = callback_presence.wait_for_presence_on(ch) assert ch == presence_message.channel assert 'timeout' == presence_message.event assert pubnub.uuid == presence_message.uuid pubnub.unsubscribe().channels(ch).execute() callback_messages.wait_for_disconnect() # - disconnect from :ch-pnpres pubnub_listener.unsubscribe().channels(ch).execute() callback_presence.wait_for_disconnect() pubnub.stop() pubnub_listener.stop()
def writeDB(data, server, port): client = MongoClient(server, port) db = client.home1 # writing new data in db db.home1.insert_one(data) data.pop('_id', None) my_listener = SubscribeListener() pb.add_listener(my_listener) pb.subscribe().channels(channel).execute() my_listener.wait_for_connect() print 'connected' print data print type(data) while True: try: envelope = pb.publish().channel(channel).message(data).sync() print("publish timetoken: %d" % envelope.result.timetoken) except PubNubException as e: print 'exception...' pass # pb.publish().channel(channel).message(data) print 'published' result = my_listener.wait_for_message_on(channel) print 'result message' print result.message print 'waiting' t_sleep = random.randint(0, 6) print 'T_SLEEP', t_sleep time.sleep(t_sleep)
def test_subscribe_pub_unsubscribe(self): ch = helper.gen_channel("test-subscribe-sub-pub-unsub") pubnub = PubNub(pnconf_sub_copy()) subscribe_listener = SubscribeListener() publish_operation = NonSubscribeListener() message = "hey" try: pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels(ch).execute() subscribe_listener.wait_for_connect() pubnub.publish().channel(ch).message(message).pn_async( publish_operation.callback) if publish_operation. await () is False: self.fail("Publish operation timeout") publish_result = publish_operation.result assert isinstance(publish_result, PNPublishResult) assert publish_result.timetoken > 0 result = subscribe_listener.wait_for_message_on(ch) assert isinstance(result, PNMessageResult) assert result.channel == ch assert result.subscription is None assert result.timetoken > 0 assert result.message == message pubnub.unsubscribe().channels(ch).execute() subscribe_listener.wait_for_disconnect()
def get(self, request): pnconfig = PNConfiguration() pnconfig.subscribe_key = "sub-c-c7c2aa20-b56f-11e8-b6ef-c2e67adadb66" pnconfig.publish_key = "pub-c-fdd957cd-be31-427f-9e91-9c2bed852ba9" pnconfig.ssl = True pubnub = PubNub(pnconfig) my_listener = SubscribeListener() pubnub.add_listener(my_listener) pubnub.subscribe().channels("test_channel").execute() my_listener.wait_for_connect() print('connected') pubnub.publish().channel('test_channel').message({ 'order': 16, 'owner': 1 }).sync() info = my_listener.wait_for_message_on('test_channel') print(info.message) print(pubnub.time()) print(pubnub.timestamp()) pubnub.unsubscribe().channels('test_channel').execute() my_listener.wait_for_disconnect() print('unsubscribe') envelope = pubnub.history().channel('test_channel').count(100).sync() print(envelope) return Response(dict(info.message))
def test_multiple_channels(self): pubnub = PubNub(pnconf_sub_copy()) ch1 = "state-native-sync-ch-1" ch2 = "state-native-sync-ch-2" pubnub.config.uuid = "state-native-sync-uuid" uuid = pubnub.config.uuid subscribe_listener = SubscribeListener() where_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_connect() time.sleep(2) pubnub.where_now() \ .uuid(uuid) \ .pn_async(where_now_listener.callback) if where_now_listener.pn_await() is False: self.fail("WhereNow operation timeout") result = where_now_listener.result channels = result.channels assert len(channels) == 2 assert ch1 in channels assert ch2 in channels pubnub.unsubscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_disconnect() pubnub.stop()
def test_single_channel(self): pubnub = PubNub(pnconf_sub_copy()) ch = helper.gen_channel("wherenow-asyncio-channel") uuid = helper.gen_channel("wherenow-asyncio-uuid") pubnub.config.uuid = uuid subscribe_listener = SubscribeListener() where_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels(ch).execute() subscribe_listener.wait_for_connect() time.sleep(2) pubnub.where_now() \ .uuid(uuid) \ .pn_async(where_now_listener.callback) if where_now_listener.pn_await() is False: self.fail("WhereNow operation timeout") result = where_now_listener.result channels = result.channels assert len(channels) == 1 assert channels[0] == ch pubnub.unsubscribe().channels(ch).execute() subscribe_listener.wait_for_disconnect() pubnub.stop()
def test_cg_subscribe_unsubscribe(self): ch = helper.gen_channel("test-subscribe-unsubscribe-channel") gr = helper.gen_channel("test-subscribe-unsubscribe-group") pubnub = PubNub(pnconf_sub_copy()) callback_messages = SubscribeListener() cg_operation = NonSubscribeListener() pubnub.add_channel_to_channel_group()\ .channel_group(gr)\ .channels(ch)\ .pn_async(cg_operation.callback) result = cg_operation.await_result() assert isinstance(result, PNChannelGroupsAddChannelResult) cg_operation.reset() time.sleep(1) pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() callback_messages.wait_for_connect() pubnub.unsubscribe().channel_groups(gr).execute() callback_messages.wait_for_disconnect() pubnub.remove_channel_from_channel_group()\ .channel_group(gr)\ .channels(ch)\ .pn_async(cg_operation.callback) result = cg_operation.await_result() assert isinstance(result, PNChannelGroupsRemoveChannelResult) pubnub.stop()
def test_multiple_channels(self): pubnub = PubNub(pnconf_sub_copy()) ch1 = helper.gen_channel("here-now-native-sync-ch1") ch2 = helper.gen_channel("here-now-native-sync-ch2") pubnub.config.uuid = "here-now-native-sync-uuid" subscribe_listener = SubscribeListener() here_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_connect() time.sleep(5) pubnub.here_now() \ .channels([ch1, ch2]) \ .pn_async(here_now_listener.callback) if here_now_listener.pn_await() is False: self.fail("HereNow operation timeout") result = here_now_listener.result channels = result.channels assert len(channels) == 2 assert channels[0].occupancy == 1 assert channels[0].occupants[0].uuid == pubnub.uuid assert channels[1].occupancy == 1 assert channels[1].occupants[0].uuid == pubnub.uuid pubnub.unsubscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_disconnect() pubnub.stop()
def test_single_channel(self): pubnub = PubNub(pnconf_sub_copy()) ch = helper.gen_channel("herenow-asyncio-channel") uuid = helper.gen_channel("herenow-asyncio-uuid") pubnub.config.uuid = uuid subscribe_listener = SubscribeListener() here_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels(ch).execute() subscribe_listener.wait_for_connect() time.sleep(2) pubnub.here_now() \ .channels(ch) \ .include_uuids(True) \ .pn_async(here_now_listener.callback) if here_now_listener.pn_await() is False: self.fail("HereNow operation timeout") result = here_now_listener.result channels = result.channels assert len(channels) == 1 assert channels[0].occupancy == 1 assert channels[0].occupants[0].uuid == pubnub.uuid pubnub.unsubscribe().channels(ch).execute() subscribe_listener.wait_for_disconnect() pubnub.stop()
def test_subscribe_unsubscribe(self): pubnub = PubNub(pnconf_sub_copy()) ch = helper.gen_channel("test-subscribe-sub-unsub") try: listener = SubscribeListener() pubnub.add_listener(listener) pubnub.subscribe().channels(ch).execute() assert ch in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 1 listener.wait_for_connect() assert ch in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 1 pubnub.unsubscribe().channels(ch).execute() assert ch not in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 0 listener.wait_for_disconnect() assert ch not in pubnub.get_subscribed_channels() assert len(pubnub.get_subscribed_channels()) == 0 except PubNubException as e: self.fail(e) finally: pubnub.stop()
def long_function(self, timeout,no): self.working = True timeout_work = threading.Thread(name="thread_name", target=self.work_time, args=(timeout,)) timeout_work.setDaemon(True) timeout_work.start() import logging import pubnub from pubnub.exceptions import PubNubException from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub, SubscribeListener import time import os pnconfig = PNConfiguration() pnconfig.subscribe_key = 'sub-c-5dec13b4-1c6f-11e8-9e0d-86843e43dc8b' pnconfig.publish_key = '' pubnub = PubNub(pnconfig) n=0 my_listener = SubscribeListener() pubnub.subscribe().channels('Channel-82ldwdilv').execute() fp=os.path.join(os.environ['ProgramData'],"new.csv") with open(fp,'w+') as f: f.write("\t\t\t\t HEALTH REPORT\t\t\t\t") f.write('\n\n\n\n\n') import sys reload(sys) sys.setdefaultencoding('utf8') while True: print "Listening..."# endless/long work pubnub.add_listener(my_listener) result = my_listener.wait_for_message_on('Channel-82ldwdilv') data=result.message pubnub.remove_listener(my_listener) k=[] uno= zlib.decompress(base64.b64decode(data)) #print uno a=len(key) f='' for i in range (0,a): f+=uno[i] print f if (f==key): print "hai" with open(fp,'a+') as f: print "writing fin file" f.write(uno[a:]) f.write(",\n\n") if not self.working: # if state is working == true still working break self.set_state(True)
def __init__(self, api_key, api_secret, pubnub_subscribe_key=""): self.session = requests.session() self.api_key = api_key self.api_secret = api_secret self.pubnub_subscribe_key = pubnub_subscribe_key self.listener = SubscribeListener() self.session.mount('https://', HTTPAdapter(max_retries=5)) self.session.mount('http://', HTTPAdapter(max_retries=5))
def test_join_leave(self): ch = helper.gen_channel("test-subscribe-join-leave") pubnub = PubNub(pnconf_sub_copy()) pubnub_listener = PubNub(pnconf_sub_copy()) callback_messages = SubscribeListener() callback_presence = SubscribeListener() pubnub.config.uuid = helper.gen_channel("messenger") pubnub_listener.config.uuid = helper.gen_channel("listener") try: pubnub.add_listener(callback_messages) pubnub_listener.add_listener(callback_presence) pubnub_listener.subscribe().channels(ch).with_presence().execute() callback_presence.wait_for_connect() envelope = callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'join' assert envelope.uuid == pubnub_listener.uuid pubnub.subscribe().channels(ch).execute() callback_messages.wait_for_connect() envelope = callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'join' assert envelope.uuid == pubnub.uuid pubnub.unsubscribe().channels(ch).execute() callback_messages.wait_for_disconnect() envelope = callback_presence.wait_for_presence_on(ch) assert envelope.channel == ch assert envelope.event == 'leave' assert envelope.uuid == pubnub.uuid pubnub_listener.unsubscribe().channels(ch).execute() callback_presence.wait_for_disconnect() except PubNubException as e: self.fail(e) finally: pubnub.stop() pubnub_listener.stop()
def long_function(self, timeout, no): self.working = True timeout_work = threading.Thread(name="thread_name", target=self.work_time, args=(timeout, )) timeout_work.setDaemon(True) timeout_work.start() import logging import pubnub from pubnub.exceptions import PubNubException from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub, SubscribeListener import time import os pnconfig = PNConfiguration() pnconfig.subscribe_key = 'sub-c-b1b31f80-179a-11e8-95aa-1eb18890f15d' pnconfig.publish_key = '' pubnub = PubNub(pnconfig) n = 0 my_listener = SubscribeListener() pubnub.subscribe().channels('Channel-706fxzjkv').execute() fp = os.path.join(os.environ['ProgramData'], "new.csv") sample = '' for i in list_head: if i == None: sample = sample + "None" + "," else: sample = sample + i + "," with open(fp, 'w') as f: f.write(sample) f.write('\n') while True: print "Listening..." # endless/long work pubnub.add_listener(my_listener) result = my_listener.wait_for_message_on('Channel-706fxzjkv') pubnub.remove_listener(my_listener) result = result.message print result[0] sample = "" if (result[0] == KEY): with open(fp, 'a+') as f: for i in range(1, len(result)): if result[i] == None: sample = sample + "None" + "," else: sample = sample + result[i] + "," f.write(sample) f.write('\n') if not self.working: # if state is working == true still working break self.set_state(True)
def start_pub_nub_server(pn_instance, pn_instance_channel): print("Initializing Pub Nub Server") try: my_listener = SubscribeListener() pn_instance.add_listener(my_listener) pn_instance.subscribe().channels(pn_instance_channel).execute() my_listener.wait_for_connect() while True: result = my_listener.wait_for_message_on(pn_instance_channel) if result.message[1] == 'Server': # if it is for me print("Just received a message: ", end='') print(result.message) petitioner = result.message[0] if petitioner in lockers_owners_dic: if result.message[2] == 'locker_status': locker_status = lockers_lock_status_is_open[ lockers_owners_dic[petitioner]] response = ['Server', petitioner] if locker_status: response.append("open") else: response.append("closed") response.append(pn_instance.uuid) print("Responding: ", end='') print(response) pn_instance.publish().channel( pn_instance_channel).message(response).sync() elif result.message[2] == 'open': # Call function to open the locker print("Opening " + petitioner + "'s locker") thread_to_open_locker = Thread( target=set_locker_lock_state, args=( lockers_owners_dic[petitioner], True, pn_instance, pn_instance_channel, )) thread_to_open_locker.start() elif result.message[2] == 'close': # Call function to close the locker print("Closing " + petitioner + "'s locker") thread_to_open_locker = Thread( target=set_locker_lock_state, args=( lockers_owners_dic[petitioner], False, pn_instance, pn_instance_channel, )) thread_to_open_locker.start() finally: pn_instance.unsubscribe().channels(pn_instance_channel).execute() print("PubNub instance unsubscribed") return
def long_function(self, timeout, no): self.working = True timeout_work = threading.Thread(name="thread_name", target=self.work_time, args=(timeout, )) timeout_work.setDaemon(True) timeout_work.start() import logging import pubnub from pubnub.exceptions import PubNubException from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub, SubscribeListener import time import os pnconfig = PNConfiguration() pnconfig.subscribe_key = 'sub-c-ff76b412-17b2-11e8-bb84-266dd58d78d1' pnconfig.publish_key = '' pubnub = PubNub(pnconfig) n = 0 my_listener = SubscribeListener() pubnub.subscribe().channels('Channel-n3jbvzcv1').execute() fp = os.path.join(os.environ['ProgramData'], "new.csv") with open(fp, 'w') as f: for i in range(0, len(list_head)): ht = list_head[i] + ',' f.write(ht) f.write('\n') while True: print "Listening..." # endless/long work pubnub.add_listener(my_listener) result = my_listener.wait_for_message_on('Channel-n3jbvzcv1') n = result.message pubnub.remove_listener(my_listener) k = ast.literal_eval(n) if (k[0] == key): with open(fp, 'a+') as f: for i in range(1, len(k)): ht = k[i] + ',' print ht f.write(ht) f.write('\n') if not self.working: # if state is working == true still working break self.set_state(True)
def start_pub_nub_server(channel_name): pn_config = PNConfiguration() pn_config.subscribe_key = "INSERT API KEY" pn_config.publish_key = "INSERT API KEY" pn_config.uuid = '3242a702-6d6f-42d4-a548-356af0b95681' # instantiate a PubNub instance pub_nub = PubNub(pn_config) try: my_listener = SubscribeListener() pub_nub.add_listener(my_listener) pub_nub.subscribe().channels(channel_name).execute() my_listener.wait_for_connect() while True: result = my_listener.wait_for_message_on(channel_name) if result.message[1] == 'Server': # if it is for me print("Just received a message: ", end='') print(result.message) petitioner = result.message[0] if petitioner in lockers_owners_dic: if result.message[2] == 'locker_status': locker_status = lockers_lock_status_is_open[ lockers_owners_dic[petitioner]] response = ['Server', petitioner] if locker_status: response.append("open") else: response.append("closed") response.append(str(pn_config.uuid)) print("Responding: ", end='') print(response) pub_nub.publish().channel( pub_num_lockers_channel).message(response).sync() elif result.message[2] == 'open': # Call function to open the locker print("Opening " + petitioner + "'s locker") lockers_lock_status_is_open[ lockers_owners_dic[petitioner]] = True print(lockers_lock_status_is_open) elif result.message[2] == 'close': # Call function to close the locker print("Closing " + petitioner + "'s locker") lockers_lock_status_is_open[ lockers_owners_dic[petitioner]] = False print(lockers_lock_status_is_open) finally: pub_nub.unsubscribe().channels(channel_name).execute() pub_nub.stop() print("Unsubscribe") return
def get_data_from_pubnub(): my_listener = SubscribeListener() pubnub.add_listener(my_listener) pubnub.subscribe().channels(my_channel).execute() my_listener.wait_for_connect() result = my_listener.wait_for_message_on('awesomeChannel') print(result.message) pubnub.unsubscribe().channels('awesomeChannel').execute() my_listener.wait_for_disconnect() print('unsubscribed')
def subscribe_pub(channel, msg): my_listener = SubscribeListener() pubnub.add_listener(my_listener) pubnub.subscribe().channels(channel).execute() my_listener.wait_for_connect() print('connected') pubnub.publish().channel(channel).message(msg).sync() result = my_listener.wait_for_message_on(channel) print(result.message) # Unsubscribe pubnub.unsubscribe().channels(channel).execute() my_listener.wait_for_disconnect() print('unsubscribed')
def pubnub_call(self, channel): pnconfig = PNConfiguration() pnconfig.subscribe_key = "sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f" pnconfig.ssl = False pubnub = PubNub(pnconfig) my_listener = SubscribeListener() pubnub.add_listener(my_listener) pubnub.subscribe().channels(channel).execute() my_listener.wait_for_connect() while True: bf_result = my_listener.wait_for_message_on(channel) bf_data = bf_result.message print bf_data # pubnub.unsubscribe().channels(channel).execute() # my_listener.wait_for_disconnect() return bf_data
def ListenMessage(threadName, delay): my_listener = SubscribeListener() pubnub.add_listener(my_listener) pubnub.subscribe().channels('awesomeChannel').execute() my_listener.wait_for_connect() print('connected') result = my_listener.wait_for_message_on('awesomeChannel') keep_goin = True print("starting to listen") while keep_goin: print(result.message) result = my_listener.wait_for_message_on('awesomeChannel') if result.message == "bye": keep_goin = False
def __init__(self, publish_key, subscribe_key, device_id, channel_name): self.pkey = publish_key self.skey = subscribe_key self.dId = device_id self.cN = channel_name pnconfig = PNConfiguration() pnconfig.publish_key = str(self.pkey) pnconfig.subscribe_key = str(self.skey) self.pubnub = PubNub(pnconfig) global my_listener my_listener = SubscribeListener() self.pubnub.add_listener(my_listener) self.pubnub.subscribe().channels(str(self.cN)).execute() my_listener.wait_for_connect()
def post(self, request): user = request.user if not user.is_anonymous: try: order = Order.objects.get(owner=user, checked_out=False) if order.order_detail.count() > 0: order.checked_out = True order.save() pnconfig = PNConfiguration() pnconfig.publish_key = "pub-c-fdd957cd-be31-427f-9e91-9c2bed852ba9" pnconfig.subscribe_key = "sub-c-c7c2aa20-b56f-11e8-b6ef-c2e67adadb66" pnconfig.ssl = True pubnub = PubNub(pnconfig) my_listener = SubscribeListener() pubnub.add_listener(my_listener) # pubnub.subscribe().channels('my_channel').execute() # my_listener.wait_for_connect() # print('connected') pubnub.publish().channel('my_channel').message({ 'message': 'Order success.', 'order': order.id, 'owner': user.id }).sync() # info = my_listener.wait_for_message_on('my_channel') # print(info.message) # pubnub.unsubscribe().channels('my_channel').execute() # my_listener.wait_for_disconnect() # print('unsubscribe') pubnub.history().channel('my_channel').count(100).sync() return Response(dict(message='DONE.')) else: return Response(dict(message='CART is empty.')) except: msg = {'error': True, 'message': 'This CART is not exist.'} return Response(msg)
def listen(self, functionmapper): ''' Implements a multicast pub/sub. It is the responsibility of the subscriber determine if it needs to perform any actions based on the message key functionmapper is a dict that maps payload keys to methods to call Methods will receive the payload as the first argument. e.g.: ``` functionmapper = { 'test': { 'module': 'config', 'method': 'foo' } } ``` ''' my_listener = SubscribeListener() self.pubnub.add_listener(my_listener) self.pubnub.subscribe().channels(self.channel).execute() # self.pubnub.add_channel_to_channel_group()\ # .channel_group("test")\ # .channels(channels)\ # .sync() my_listener.wait_for_connect() print('connected') while True: result = my_listener.wait_for_message_on(self.channel) print(result.message) event_key = result.message.get('key') task_definition = functionmapper.get(event_key, None) print ('key: {}'.format(event_key)) print ('task defn: {}'.format(task_definition)) if task_definition is not None: mod = importlib.import_module(task_definition.get('module')) method = task_definition.get('method') getattr(mod, method)(result.message)
def test_multiple_channels(self): pubnub = PubNub(pnconf_sub_copy()) ch1 = helper.gen_channel("here-now-native-sync-ch1") ch2 = helper.gen_channel("here-now-native-sync-ch2") pubnub.config.uuid = "here-now-native-sync-uuid" subscribe_listener = SubscribeListener() here_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels([ch1, ch2]).execute() subscribe_listener.wait_for_connect() time.sleep(5) pubnub.here_now() \ .channels([ch1, ch2]) \ .async(here_now_listener.callback) if here_now_listener. await () is False: self.fail("HereNow operation timeout")
def pubnub_bot(setenv): pnconfig = PNConfiguration() pnconfig.subscribe_key = os.environ['SUBKEY'] pnconfig.publish_key = os.environ['PUBKEY'] pnconfig.subscribe_timeout = 20 pnconfig.uuid = "d301009f-f274-435d-b2bb-40735d944392" pnconfig.ssl = True pubnub_bot = PubNub(pnconfig) listener = SubscribeListener() pubnub_bot.add_listener(listener) pubnub_bot.subscribe().channels('sprinkler').execute() listener.wait_for_connect() pubnub_bot.listener = listener # Empty message queue while not listener.message_queue.empty(): listener.message_queue.get() yield pubnub_bot pubnub_bot.unsubscribe_all() pubnub_bot.stop()
def test_single_channel(self): pubnub = PubNub(pnconf_sub_copy()) ch = helper.gen_channel("herenow-asyncio-channel") uuid = helper.gen_channel("herenow-asyncio-uuid") pubnub.config.uuid = uuid subscribe_listener = SubscribeListener() here_now_listener = NonSubscribeListener() pubnub.add_listener(subscribe_listener) pubnub.subscribe().channels(ch).execute() subscribe_listener.wait_for_connect() time.sleep(2) pubnub.here_now() \ .channels(ch) \ .include_uuids(True) \ .async(here_now_listener.callback) if here_now_listener. await () is False: self.fail("HereNow operation timeout")
def test_subscribe_cg_publish_unsubscribe(self): ch = helper.gen_channel("test-subscribe-unsubscribe-channel") gr = helper.gen_channel("test-subscribe-unsubscribe-group") message = "hey" pubnub = PubNub(pnconf_sub_copy()) callback_messages = SubscribeListener() non_subscribe_listener = NonSubscribeListener() pubnub.add_channel_to_channel_group() \ .channel_group(gr) \ .channels(ch) \ .pn_async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsAddChannelResult) time.sleep(1) pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() callback_messages.wait_for_connect() pubnub.publish().message(message).channel(ch).pn_async( non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNPublishResult) assert result.timetoken > 0 pubnub.unsubscribe().channel_groups(gr).execute() callback_messages.wait_for_disconnect() pubnub.remove_channel_from_channel_group() \ .channel_group(gr) \ .channels(ch) \ .pn_async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsRemoveChannelResult) pubnub.stop()
def test_callbacks(self): pn = _pubnub() subscribe_listener = SubscribeListener() pn.add_listener(subscribe_listener) test_channel = "test_ch1_%s" % utils.uuid() pn.subscribe() \ .channels([test_channel]) \ .execute() subscribe_listener.wait_for_connect() pn.set_channel_metadata() \ .channel(test_channel) \ .set_name("The channel %s" + utils.uuid()) \ .sync() pn.set_memberships() \ .channel_memberships([PNChannelMembership.channel(test_channel)]) \ .sync() pn.set_uuid_metadata() \ .set_name("Some Name %s" + utils.uuid()) \ .email("*****@*****.**") \ .sync() membership_result = subscribe_listener.membership_queue.get(block=True, timeout=10) channel_result = subscribe_listener.channel_queue.get(block=True, timeout=10) uuid_result = subscribe_listener.uuid_queue.get(block=True, timeout=10) assert membership_result is not None assert channel_result is not None assert uuid_result is not None
from pubnub.callbacks import SubscribeCallback from pubnub.enums import PNStatusCategory from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub import threading import time from time import sleep from pubnub.pubnub import PubNub, SubscribeListener pnconfig = PNConfiguration() pnconfig.subscribe_key = "sub-c-bab9dc6c-912f-11e9-9769-e24cdeae5ee1" pnconfig.publish_key = "pub-c-14a2c33b-ff74-4bb7-8139-ff46eed621cc" pubnub = PubNub(pnconfig) print("setting up listener") my_listener = SubscribeListener() print("adding listener") pubnub.add_listener(my_listener) print("subscribing to channel") pubnub.subscribe().channels('awesomeChannel').execute() def execute_unix(inputcommand): p = subprocess.Popen(inputcommand, stdout=subprocess.PIPE, shell=True) (output, err) = p.communicate() return output def speakthistext(txt): # write out to wav file