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