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_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_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 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_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 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_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_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_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_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_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 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_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 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 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 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()
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_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_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_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) \
.pn_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) \
.pn_async(non_subscribe_listener.callback)
result = non_subscribe_listener.await_result_and_reset()
assert isinstance(result, PNChannelGroupsRemoveChannelResult)
pubnub.stop()
pubnub_listener.stop()
from pubnub.enums import PNStatusCategory
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub, SubscribeListener
pnconfig = PNConfiguration()
pnconfig.publish_key = 'pub-c-c408ce7d-fe0d-4f9a-aae9-e67d5c9b6bd9'
pnconfig.subscribe_key = 'sub-c-efaf056a-75c7-11e9-b68a-fa5eae84dea0'
pubnub = PubNub(pnconfig)
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')
print(result.message)
pubnub.unsubscribe().channels('awesomeChannel').execute()
my_listener.wait_for_disconnect()
print('unsubscribed')
exit(0)
