def test_multiple_channels(self):
pubnub = PubNub(pnconf_sub_copy())
ch1 = helper.gen_channel("here-now-native-sync-ch1")
ch2 = helper.gen_channel("here-now-native-sync-ch2")
pubnub.config.uuid = "here-now-native-sync-uuid"
subscribe_listener = SubscribeListener()
here_now_listener = NonSubscribeListener()
pubnub.add_listener(subscribe_listener)
pubnub.subscribe().channels([ch1, ch2]).execute()
subscribe_listener.wait_for_connect()
time.sleep(5)
pubnub.here_now() \
.channels([ch1, ch2]) \
.pn_async(here_now_listener.callback)
if here_now_listener.pn_await() is False:
self.fail("HereNow operation timeout")
result = here_now_listener.result
channels = result.channels
assert len(channels) == 2
assert channels[0].occupancy == 1
assert channels[0].occupants[0].uuid == pubnub.uuid
assert channels[1].occupancy == 1
assert channels[1].occupants[0].uuid == pubnub.uuid
pubnub.unsubscribe().channels([ch1, ch2]).execute()
subscribe_listener.wait_for_disconnect()
pubnub.stop()
def test_single_channel(self):
pubnub = PubNub(pnconf_sub_copy())
ch = helper.gen_channel("herenow-asyncio-channel")
uuid = helper.gen_channel("herenow-asyncio-uuid")
pubnub.config.uuid = uuid
subscribe_listener = SubscribeListener()
here_now_listener = NonSubscribeListener()
pubnub.add_listener(subscribe_listener)
pubnub.subscribe().channels(ch).execute()
subscribe_listener.wait_for_connect()
time.sleep(2)
pubnub.here_now() \
.channels(ch) \
.include_uuids(True) \
.pn_async(here_now_listener.callback)
if here_now_listener.pn_await() is False:
self.fail("HereNow operation timeout")
result = here_now_listener.result
channels = result.channels
assert len(channels) == 1
assert channels[0].occupancy == 1
assert channels[0].occupants[0].uuid == pubnub.uuid
pubnub.unsubscribe().channels(ch).execute()
subscribe_listener.wait_for_disconnect()
pubnub.stop()
def test_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 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_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 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 writeDB(data, server, port):
client = MongoClient(server, port)
db = client.home1
# writing new data in db
db.home1.insert_one(data)
data.pop('_id', None)
my_listener = SubscribeListener()
pb.add_listener(my_listener)
pb.subscribe().channels(channel).execute()
my_listener.wait_for_connect()
print 'connected'
print data
print type(data)
while True:
try:
envelope = pb.publish().channel(channel).message(data).sync()
print("publish timetoken: %d" % envelope.result.timetoken)
except PubNubException as e:
print 'exception...'
pass
# pb.publish().channel(channel).message(data)
print 'published'
result = my_listener.wait_for_message_on(channel)
print 'result message'
print result.message
print 'waiting'
t_sleep = random.randint(0, 6)
print 'T_SLEEP', t_sleep
time.sleep(t_sleep)
def test_subscribe_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_multiple_channels(self):
pubnub = PubNub(pnconf_sub_copy())
ch1 = "state-native-sync-ch-1"
ch2 = "state-native-sync-ch-2"
pubnub.config.uuid = "state-native-sync-uuid"
uuid = pubnub.config.uuid
subscribe_listener = SubscribeListener()
where_now_listener = NonSubscribeListener()
pubnub.add_listener(subscribe_listener)
pubnub.subscribe().channels([ch1, ch2]).execute()
subscribe_listener.wait_for_connect()
time.sleep(2)
pubnub.where_now() \
.uuid(uuid) \
.pn_async(where_now_listener.callback)
if where_now_listener.pn_await() is False:
self.fail("WhereNow operation timeout")
result = where_now_listener.result
channels = result.channels
assert len(channels) == 2
assert ch1 in channels
assert ch2 in channels
pubnub.unsubscribe().channels([ch1, ch2]).execute()
subscribe_listener.wait_for_disconnect()
pubnub.stop()
def test_single_channel(self):
pubnub = PubNub(pnconf_sub_copy())
ch = helper.gen_channel("wherenow-asyncio-channel")
uuid = helper.gen_channel("wherenow-asyncio-uuid")
pubnub.config.uuid = uuid
subscribe_listener = SubscribeListener()
where_now_listener = NonSubscribeListener()
pubnub.add_listener(subscribe_listener)
pubnub.subscribe().channels(ch).execute()
subscribe_listener.wait_for_connect()
time.sleep(2)
pubnub.where_now() \
.uuid(uuid) \
.pn_async(where_now_listener.callback)
if where_now_listener.pn_await() is False:
self.fail("WhereNow operation timeout")
result = where_now_listener.result
channels = result.channels
assert len(channels) == 1
assert channels[0] == ch
pubnub.unsubscribe().channels(ch).execute()
subscribe_listener.wait_for_disconnect()
pubnub.stop()
def test_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 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 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 start_pub_nub_server(channel_name):
pn_config = PNConfiguration()
pn_config.subscribe_key = "INSERT API KEY"
pn_config.publish_key = "INSERT API KEY"
pn_config.uuid = '3242a702-6d6f-42d4-a548-356af0b95681'
# instantiate a PubNub instance
pub_nub = PubNub(pn_config)
try:
my_listener = SubscribeListener()
pub_nub.add_listener(my_listener)
pub_nub.subscribe().channels(channel_name).execute()
my_listener.wait_for_connect()
while True:
result = my_listener.wait_for_message_on(channel_name)
if result.message[1] == 'Server': # if it is for me
print("Just received a message: ", end='')
print(result.message)
petitioner = result.message[0]
if petitioner in lockers_owners_dic:
if result.message[2] == 'locker_status':
locker_status = lockers_lock_status_is_open[
lockers_owners_dic[petitioner]]
response = ['Server', petitioner]
if locker_status:
response.append("open")
else:
response.append("closed")
response.append(str(pn_config.uuid))
print("Responding: ", end='')
print(response)
pub_nub.publish().channel(
pub_num_lockers_channel).message(response).sync()
elif result.message[2] == 'open':
# Call function to open the locker
print("Opening " + petitioner + "'s locker")
lockers_lock_status_is_open[
lockers_owners_dic[petitioner]] = True
print(lockers_lock_status_is_open)
elif result.message[2] == 'close':
# Call function to close the locker
print("Closing " + petitioner + "'s locker")
lockers_lock_status_is_open[
lockers_owners_dic[petitioner]] = False
print(lockers_lock_status_is_open)
finally:
pub_nub.unsubscribe().channels(channel_name).execute()
pub_nub.stop()
print("Unsubscribe")
return
def get_data_from_pubnub():
my_listener = SubscribeListener()
pubnub.add_listener(my_listener)
pubnub.subscribe().channels(my_channel).execute()
my_listener.wait_for_connect()
result = my_listener.wait_for_message_on('awesomeChannel')
print(result.message)
pubnub.unsubscribe().channels('awesomeChannel').execute()
my_listener.wait_for_disconnect()
print('unsubscribed')
def 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 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 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_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 __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 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_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")
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_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
class BitflyerHelper:
api_key = ""
api_secret = ""
pubnub_subscribe_key = ""
error_count = 0
pubnub = None
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))
# リアルタイム(pubnub)で情報を取得するためのセットアップ
def setup_pubnub(self):
pnconfig = PNConfiguration()
pnconfig.subscribe_key = self.pubnub_subscribe_key
pnconfig.ssl = False
self.pubnub = PubNub(pnconfig)
self.pubnub.add_listener(self.listener)
# 板情報をリアルタイムで取得するためのセットアップ
def subscribe_board_pubnub(self):
self.pubnub.subscribe().channels(
'lightning_board_snapshot_FX_BTC_JPY').execute()
self.listener.wait_for_connect()
# 板情報の差分をリアルタイムで取得するためのセットアップ
def subscribe_board_diff_pubnub(self):
self.pubnub.subscribe().channels(
'lightning_board_FX_BTC_JPY').execute()
self.listener.wait_for_connect()
# 約定履歴をリアルタイムで取得するためのセットアップ
def subscribe_executions_pubnub(self):
self.pubnub.subscribe().channels(
'lightning_executions_FX_BTC_JPY').execute()
self.listener.wait_for_connect()
# 板情報をリアルタイムで取得
def get_board_pubnub(self):
return self.listener.wait_for_message_on(
"lightning_board_snapshot_FX_BTC_JPY").message
# 板情報の差分をリアルタイムで取得
def get_board_diff_pubnub(self):
return self.listener.wait_for_message_on(
"lightning_board_FX_BTC_JPY").message
# 約定履歴をリアルタイムで取得
def get_executions_pubnub(self):
return self.listener.wait_for_message_on(
'lightning_executions_FX_BTC_JPY').message
# 4本値の取得, period: n本足を秒数で表記, after: 指定したunixtime以降のデータを取得
"""
返り値 [UNIX timestamp, 始値, 高値, 安値, 終値, 出来高]
"""
def get_ohlc(self, period: int, after: int, before: int):
endpoint = "https://api.cryptowat.ch/markets/bitflyer/btcfxjpy/ohlc?" \
"periods={0}&after={1}&before={2}".format(str(period), str(after), str(before))
response = self.get_request(endpoint)
return response
# マーケットの一覧を取得
def get_markets(self):
response = self.get_request("/v1/getmarkets").json()
return response
# 板情報を取得
def get_board(self, product_code: ProductCode):
params = {"product_code": product_code.value}
response = self.get_request("/v1/getboard", params=params).json()
return response
# Tickerを取得
def get_ticker(self, product_code: ProductCode):
params = {"product_code": product_code.value}
response = self.get_request("/v1/getticker", params=params).json()
return response
# 約定履歴
def get_executions(self, product_code: ProductCode):
params = {"product_code": product_code.value}
response = self.get_request("/v1/getexecutions", params=params).json()
return response
# 板の状態
def get_board_state(self, product_code: ProductCode):
params = {"product_code": product_code.value}
response = self.get_request("/v1/getboardstate", params=params).json()
return response
# 取引所の状態
def get_health(self, product_code: ProductCode):
params = {"product_code": product_code.value}
response = self.get_request("/v1/gethealth", params=params).json()
return response
# チャットの取得
def get_chats(self, from_date: str = None):
params = {}
response = self.get_request("/v1/getchats", params=params).json()
return response
# APIキーの権限を取得
def get_permissions(self):
method = "GET"
endpoint = "/v1/me/getpermissions"
body = ""
headers = self.create_private_header(method=method,
endpoint=endpoint,
body=body)
response = self.get_request(endpoint=endpoint,
params=body,
headers=headers).json()
return response
# 資産残高を取得
def get_balance(self):
method = "GET"
endpoint = "/v1/me/getbalance"
body = ""
headers = self.create_private_header(method=method,
endpoint=endpoint,
body=body)
response = self.get_request(endpoint=endpoint,
params=body,
headers=headers).json()
return response
# 証拠金の状態を取得
def get_collateral(self):
method = "GET"
endpoint = "/v1/me/getcollateral"
body = ""
headers = self.create_private_header(method=method,
endpoint=endpoint,
body=body)
response = self.get_request(endpoint=endpoint,
params=body,
headers=headers).json()
return response
# 通貨別の証拠金の数量を取得
def get_collateralaccounts(self):
method = "GET"
endpoint = "/v1/me/getcollateralaccounts"
body = ""
headers = self.create_private_header(method=method,
endpoint=endpoint,
body=body)
response = self.get_request(endpoint=endpoint,
params=body,
headers=headers).json()
return response
# 新規注文を出す
def send_child_order(self, child_order: ChildOrder):
method = "POST"
endpoint = "/v1/me/sendchildorder"
body = child_order.to_body()
print(body)
body = json.dumps(body)
headers = self.create_private_header(method=method,
endpoint=endpoint,
body=body)
response = self.post_request(endpoint=endpoint,
params=body,
headers=headers).json()
print(response)
return response
# 注文をキャンセルする
def cancel_child_order(self, product_code: ProductCode,
child_order_acceptance_id: str):
method = "POST"
endpoint = "/v1/me/cancelchildorder"
body = {
"product_code": product_code.value,
"child_order_acceptance_id": child_order_acceptance_id
}
body = json.dumps(body)
headers = self.create_private_header(method=method,
endpoint=endpoint,
body=body)
response = self.post_request(endpoint=endpoint,
params=body,
headers=headers)
return response
# 新規の親注文を出す(特殊注文)
def send_parent_order(self, parent_order):
method = "POST"
endpoint = "/v1/me/sendparentorder"
body = parent_order.to_body()
body = json.dumps(body)
headers = self.create_private_header(method=method,
endpoint=endpoint,
body=body)
response = self.post_request(endpoint=endpoint,
params=body,
headers=headers).json()
print(response)
return response
# 注文の一覧を取得
def get_child_orders(self, product_code: ProductCode):
method = "GET"
endpoint = "/v1/me/getchildorders?product_code={}".format(
product_code.value)
headers = self.create_private_header(method=method,
endpoint=endpoint,
body="")
response = self.get_request(endpoint=endpoint, headers=headers).json()
return response
# 建玉の一覧を取得
def get_positions(self, product_code: ProductCode):
method = "GET"
endpoint = "/v1/me/getpositions?product_code={}".format(
product_code.value)
headers = self.create_private_header(method=method,
endpoint=endpoint,
body="")
response = self.get_request(endpoint=endpoint, headers=headers)
if response.status_code == 200:
return response.json()
else:
return None
# Private API用のヘッダーを作成
def create_private_header(self, method, endpoint, body):
if self.api_key and self.api_secret:
access_timestamp = str(time.time())
api_secret = str.encode(self.api_secret)
text = str.encode(access_timestamp + method + endpoint + body)
access_sign = hmac.new(api_secret, text,
hashlib.sha256).hexdigest()
auth_header = {
"ACCESS-KEY": self.api_key,
"ACCESS-TIMESTAMP": access_timestamp,
"ACCESS-SIGN": access_sign,
"Content-Type": "application/json"
}
return auth_header
else:
sys.exit()
# GETメソッド用
def get_request(self, endpoint, params=None, headers=None):
if endpoint[0] == "/":
url = BASE_URL.format(endpoint)
else:
url = endpoint
while True:
try:
response = self.session.get(url,
params=params,
timeout=5,
headers=headers)
if not (response.status_code == 200
or response.status_code == 404):
continue
self.error_count = 0
return response
except Exception as e:
if self.error_count < error_limit:
self.error_count += 1
continue
else:
sys.exit(e)
# POSTメソッド用
def post_request(self, endpoint, params=None, headers=None):
url = BASE_URL.format(endpoint)
while True:
try:
response = self.session.post(url,
data=params,
timeout=5,
headers=headers)
if response.status_code != 200:
continue
self.error_count = 0
return response
except Exception as e:
if self.error_count < error_limit:
self.error_count += 1
continue
else:
sys.exit(e)
def setup_listener(pubnub, channel_name):
listener = SubscribeListener()
pubnub.add_listener(listener)
pubnub.subscribe().channels(channel_name).execute()
listener.wait_for_connect()
return listener
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()
def message(self, pubnub, message):
print(message)
def presence(self, pubnub, presence):
pass
my_listener = SubscribeListener(
) # create listner_object to read the msg from the Broker/Server
pubnub.add_listener(
my_listener) # add listner_object to pubnub_object to subscribe it
pubnub.subscribe().channels(
channel).execute() # subscribe the channel (Runs in background)
my_listener.wait_for_connect(
) # wait for the listner_obj to connect to the Broker.Channel
print('connected') # print confirmation msg
pubnub.publish().channel(channel).message(
data).sync() # publish the data to the mentioned channel
while True: # Infinite loop
result = my_listener.wait_for_message_on(
channel) # Read the new msg on the channel
print(result.message) # print the new msg
for command in result.message.values():
# Check for PM command.
if command == pmx_str:
pm_instance = pt_pms5003('/dev/ttyAMA0')
pma, pmb, pmc = pm_instance.pt_pms5003_read()
data['message'] = "PM 1.0=" + str(pma) + " PM 2.5=" + str(
from key import get_pubnub_obj
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub, SubscribeListener
pixel_pin = board.D18
num_pixels = 60 * 5
ORDER = neopixel.GRB
pixels = neopixel.NeoPixel(pixel_pin, num_pixels, brightness=0.05, auto_write=False, pixel_order=ORDER)
pubnub = get_pubnub_obj()
my_listener = SubscribeListener()
pubnub.add_listener(my_listener)
pubnub.subscribe().channels('ledWall').execute()
my_listener.wait_for_connect()
color_index = 0
def get_clean_screen():
return [
'0000000000000000000000000000000000000000000000000000000000000',
'0000000000000000000000000000000000000000000000000000000000000',
'0000000000000000000000000000000000000000000000000000000000000',
'0000000000000000000000000000000000000000000000000000000000000',
'0000000000000000000000000000000000000000000000000000000000000'
]
def shiftLeft(numTimes, screen):
return [
screen[0][numTimes:],
