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_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 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)\ .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)\ .async(cg_operation.callback) result = cg_operation.await_result() assert isinstance(result, PNChannelGroupsRemoveChannelResult) pubnub.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 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 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 test_subscribe_cg_join_leave(self): ch = helper.gen_channel("test-subscribe-unsubscribe-channel") gr = helper.gen_channel("test-subscribe-unsubscribe-group") pubnub = PubNub(pnconf_sub_copy()) pubnub_listener = PubNub(pnconf_sub_copy()) non_subscribe_listener = NonSubscribeListener() pubnub.add_channel_to_channel_group() \ .channel_group(gr) \ .channels(ch) \ .async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsAddChannelResult) time.sleep(1) callback_messages = SubscribeListener() callback_presence = SubscribeListener() pubnub_listener.add_listener(callback_presence) pubnub_listener.subscribe().channel_groups(gr).with_presence().execute() callback_presence.wait_for_connect() prs_envelope = callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'join' assert prs_envelope.uuid == pubnub_listener.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub.add_listener(callback_messages) pubnub.subscribe().channel_groups(gr).execute() prs_envelope = callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'join' assert prs_envelope.uuid == pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub.unsubscribe().channel_groups(gr).execute() prs_envelope = callback_presence.wait_for_presence_on(ch) assert prs_envelope.event == 'leave' assert prs_envelope.uuid == pubnub.uuid assert prs_envelope.channel == ch assert prs_envelope.subscription == gr pubnub_listener.unsubscribe().channel_groups(gr).execute() callback_presence.wait_for_disconnect() pubnub.remove_channel_from_channel_group() \ .channel_group(gr) \ .channels(ch) \ .async(non_subscribe_listener.callback) result = non_subscribe_listener.await_result_and_reset() assert isinstance(result, PNChannelGroupsRemoveChannelResult) pubnub.stop() pubnub_listener.stop()
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 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 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_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 __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 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 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")
class BitflyerPubnub(object): """docstring for BitflyerPubnub""" def __init__(self, channel): pnconfig = PNConfiguration() pnconfig.subscribe_key = "sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f" self.pubnub = PubNub(pnconfig) self.listener = SubscribeListener() self.channel = channel def __enter__(self): self.pubnub.add_listener(self.listener) self.pubnub.subscribe().channels([self.channel]).execute() self.listener.wait_for_connect() return self def listen(self, key): return self.listener.wait_for_message_on(self.channel).message[key] def __exit__(self, type, value, traceback): self.pubnub.unsubscribe().channels([self.channel]).execute() self.listener.wait_for_disconnect()
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("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) \ .async(where_now_listener.callback) if where_now_listener.await() is False: self.fail("WhereNow operation timeout")
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).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 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_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_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_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_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) \ .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).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) \ .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
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 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 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 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()
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
import logging import pubnub from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub, SubscribeListener pubnub.set_stream_logger('pubnub', logging.DEBUG) pnconfig = PNConfiguration() pnconfig.subscribe_key = 'demo' pnconfig.publish_key = 'demo' pubnub = PubNub(pnconfig) pubnub.add_listener(SubscribeListener()) # 2 def second(): pubnub.subscribe().channels(["my_channel1", "my_channel2"]).execute() # 3 def third(): pubnub.subscribe().channels("my_channel").with_presence().execute() third()
from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub, SubscribeListener, SubscribeCallback, PNStatusCategory from pubnub.exceptions import PubNubException import pubnub pnconfig = PNConfiguration() pnconfig.publish_key = "publish key here" pnconfig.subscribe_key = "subscribe key here" pnconfig.ssl = False pubnub = PubNub(pnconfig) my_listener = SubscribeListener() pubnub.add_listener(my_listener) def publish_callback(channel, msg): try: envelope = pubnub.publish().channel(channel).message(msg).sync() print("Publish TimeToken: %d" % envelope.result.timetoken) except PubNubException as e: handle_exception(e) def subscribe_pub(channel, msg): my_listener = SubscribeListener() pubnub.add_listener(my_listener) pubnub.subscribe().channels(channel).execute()
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 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()