def test_get_members():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.auth_key = AUTH
membership = PubNub(config).get_members()
membership.include(['a', 'b']).limit(30).end('XXX')
with pytest.raises(PubNubException):
membership.validate_params()
membership.space_id('foo')
assert membership.build_path() == GetMembers.GET_MEMBERS_PATH % (SUB_KEY, 'foo')
params = membership.custom_params()
assert params['include'] == 'a,b'
assert params['limit'] == 30
assert params['end'] == 'XXX'
assert 'count' not in params
membership.start('YYY').count(True)
params = membership.custom_params()
assert 'end' not in params
assert params['start'] == 'YYY'
assert params['count'] is True
assert AUTH == membership.build_params_callback()({})['auth']
def test_manage_memberships():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.auth_key = AUTH
membership = PubNub(config).manage_memberships()
membership.include(['custom']).limit(30).end('XXX')
with pytest.raises(PubNubException):
membership.validate_params()
membership.user_id('foo')
assert membership.build_path(
) == ManageMemberships.MANAGE_MEMBERSHIPS_PATH % (SUB_KEY, 'foo')
params = membership.custom_params()
assert params['include'] == 'custom'
assert params['limit'] == 30
assert params['end'] == 'XXX'
assert 'count' not in params
membership.start('YYY').count(True)
params = membership.custom_params()
assert 'end' not in params
assert params['start'] == 'YYY'
assert params['count'] is True
assert AUTH == membership.build_params_callback()({})['auth']
membership.data({"add": [{"id": "my-channel"}]})
assert membership.build_data() == '{"add": [{"id": "my-channel"}]}'
def _pubnub_config(self):
channel_config = self.client.channels.list()
channels = [channel['name'] for channel in channel_config['channels']]
pnconfig = PNConfiguration()
pnconfig.subscribe_key = channel_config['subscribe_key']
pnconfig.cipher_key = channel_config['cipher_key']
pnconfig.auth_key = channel_config['auth_key']
pnconfig.ssl = True
pnconfig.reconnect_policy = PNReconnectionPolicy.LINEAR
return pnconfig, channels
def test_delete_user():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.auth_key = AUTH
user = PubNub(config).delete_user()
with pytest.raises(PubNubException):
user.build_path()
user.user_id('foo')
assert user.build_path() == DeleteUser.DELETE_USER_PATH % (SUB_KEY, 'foo')
assert AUTH == user.build_params_callback()({})['auth']
def test_delete_space():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.auth_key = AUTH
space = PubNub(config).delete_space()
with pytest.raises(PubNubException):
space.build_path()
space.space_id('foo')
assert space.build_path() == DeleteSpace.DELETE_DELETE_PATH % (SUB_KEY,
'foo')
assert AUTH == space.build_params_callback()({})['auth']
def test_get_user():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.auth_key = AUTH
user = PubNub(config).get_user()
user.include(['a', 'b'])
with pytest.raises(PubNubException):
user.build_path()
user.user_id('foo')
assert user.build_path() == GetUser.GET_USER_PATH % (SUB_KEY, 'foo')
params = user.custom_params()
assert params['include'] == ['a', 'b']
assert AUTH == user.build_params_callback()({})['auth']
def test_get_space():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.auth_key = AUTH
space = PubNub(config).get_space()
space.include(['a', 'b'])
with pytest.raises(PubNubException):
space.build_path()
space.space_id('foo')
assert space.build_path() == GetSpace.GET_SPACE_PATH % (SUB_KEY, 'foo')
params = space.custom_params()
assert params['include'] == ['a', 'b']
assert AUTH == space.build_params_callback()({})['auth']
def test_update_space():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.auth_key = AUTH
space = PubNub(config).update_space()
space.include('custom')
with pytest.raises(PubNubException):
space.build_path()
space.space_id('foo')
assert space.build_path() == UpdateSpace.UPDATE_SPACE_PATH % (SUB_KEY,
'foo')
with pytest.raises(PubNubException):
space.validate_params()
space.data({'name': 'bar'})
assert json.loads(space.build_data()) == {'name': 'bar'}
assert AUTH == space.build_params_callback()({})['auth']
def test_signal():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.publish_key = PUB_KEY
config.auth_key = AUTH
signal = PubNub(config).signal()
with pytest.raises(PubNubException):
signal.validate_params()
signal.message(MSG)
with pytest.raises(PubNubException):
signal.validate_params()
signal.channel(CHAN)
assert signal.build_path() == Signal.SIGNAL_PATH % (PUB_KEY, SUB_KEY, CHAN,
MSG_ENCODED)
assert 'auth' in signal.build_params_callback()({})
assert AUTH == signal.build_params_callback()({})['auth']
def __init__(self):
password = raw_input("Database password: ")
host = 'ephesus.cs.cf.ac.uk'
user = '******'
database = 'c1312433'
self.db = db.DB(host, user, password, database)
pnconfig = PNConfiguration()
pnconfig.subscribe_key = 'sub-c-12c2dd92-860f-11e7-8979-5e3a640e5579'
pnconfig.publish_key = 'pub-c-85d5e576-5d92-48b0-af83-b47a7f21739f'
pnconfig.reconnect_policy = PNReconnectionPolicy.LINEAR
pnconfig.subscribe_timeout = pnconfig.connect_timeout = pnconfig.non_subscribe_timeout = 9^99
pnconfig.auth_key = self.db.embedded_devices_key()
self.pubnub = PubNub(pnconfig)
self.pubnub.add_listener(self)
self.pubnub.subscribe().channels('embedded_devices').execute()
def __init__(self, host, user, password, database):
print("GatewayAuth: Starting gateway database..")
self.gd = gateway_database.GatewayDatabase(host, user, password,
database)
pnconfig = PNConfiguration()
pnconfig.subscribe_key = self.gd.sub_key()
pnconfig.publish_key = self.gd.pub_key()
pnconfig.secret_key = self.gd.sec_key()
pnconfig.subscribe_timeout = 9 ^ 99
pnconfig.connect_timeout = 9 ^ 99
pnconfig.non_subscribe_timeout = 9 ^ 99
pnconfig.ssl = True
pnconfig.reconnect_policy = PNReconnectionPolicy.LINEAR
pnconfig.uuid = 'GA'
pnconfig.auth_key = idgen.id_generator(size=42)
self.pubnub = PubNub(pnconfig)
self.pubnub.add_listener(self)
self.pubnub.unsubscribe_all()
self.admin_channel = idgen.id_generator(size=255)
self.pubnub.grant().channels(self.admin_channel).auth_keys(
[self.gd.receivers_key(),
pnconfig.auth_key]).read(True).write(True).manage(True).sync()
print("GatewayAuth: Starting the receiver..")
self.gr = gateway_receiver.Receiver(self.gd, self.admin_channel)
self.gateway_uuids = [pnconfig.uuid, self.gr.uuid]
self.gateway_channels = ["gateway_auth", "gateway_global"]
self.pubnub.grant().channels(
self.gateway_channels).read(True).write(True).manage(True).sync()
print(
"GatewayAuth: Connecting to gateway channel and gateway global feed.."
)
self.pubnub.subscribe().channels(
self.gateway_channels +
[self.admin_channel]).with_presence().execute()
self.receiver_auth_key = self.gd.receivers_key()
def test_fire():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.publish_key = PUB_KEY
config.auth_key = AUTH
fire = PubNub(config).fire()
fire.channel(CHAN).message(MSG)
assert fire.build_path() == Fire.FIRE_GET_PATH % (PUB_KEY, SUB_KEY, CHAN, 0, MSG_ENCODED)
fire.use_post(True)
assert fire.build_path() == Fire.FIRE_POST_PATH % (PUB_KEY, SUB_KEY, CHAN, 0)
params = fire.custom_params()
assert params['store'] == '0'
assert params['norep'] == '1'
fire.meta(META)
assert 'meta' in fire.build_params_callback()({})
assert json.dumps(META) == fire.build_params_callback()({})['meta']
assert 'auth' in fire.build_params_callback()({})
assert AUTH == fire.build_params_callback()({})['auth']
def test_create_space():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.auth_key = AUTH
space = PubNub(config).create_space()
with pytest.raises(PubNubException):
space.validate_params()
space.include({'name': 'a'})
with pytest.raises(PubNubException):
space.validate_params()
space.include({'id': 'x'})
with pytest.raises(PubNubException):
space.validate_params()
space.include('custom')
with pytest.raises(PubNubException):
space.validate_params()
space.data({'id': 'x', 'name': 'a'})
space.validate_params()
assert space.build_path() == CreateSpace.CREATE_SPACE_PATH % SUB_KEY
assert AUTH == space.build_params_callback()({})['auth']
assert json.loads(space.build_data()) == {'id': 'x', 'name': 'a'}
def test_create_user():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.auth_key = AUTH
user = PubNub(config).create_user()
with pytest.raises(PubNubException):
user.validate_params()
user.include({'name': 'a'})
with pytest.raises(PubNubException):
user.validate_params()
user.include({'id': 'x'})
with pytest.raises(PubNubException):
user.validate_params()
user.include('id')
with pytest.raises(PubNubException):
user.validate_params()
user.data({'id': 'user', 'name': 'username'})
user.validate_params()
assert user.build_path() == CreateUser.CREATE_USER_PATH % SUB_KEY
assert AUTH == user.build_params_callback()({})['auth']
assert json.loads(user.build_data()) == {'id': 'user', 'name': 'username'}
def test_get_spaces():
config = PNConfiguration()
config.subscribe_key = SUB_KEY
config.auth_key = AUTH
spaces = PubNub(config).get_spaces()
spaces.include(['a', 'b']).limit(30).end('XXX')
assert spaces.build_path() == GetSpaces.GET_SPACES_PATH % SUB_KEY
params = spaces.custom_params()
assert params['include'] == ['a', 'b']
assert params['limit'] == 30
assert params['end'] == 'XXX'
assert 'count' not in params
spaces.start('YYY').count(True)
params = spaces.custom_params()
assert 'end' not in params
assert params['start'] == 'YYY'
assert params['count'] is True
assert AUTH == spaces.build_params_callback()({})['auth']
Makeshift client for testcases + videos recorded.
'''
import json
import time
from pubnub.enums import PNStatusCategory
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pnconfiguration import PNConfiguration, PNReconnectionPolicy
from pubnub.pubnub import PubNub, SubscribeListener
pnconfig = PNConfiguration()
pnconfig.uuid = 'speedtestClient'
pnconfig.publish_key = 'pub-c-85d5e576-5d92-48b0-af83-b47a7f21739f'
pnconfig.subscribe_key = 'sub-c-12c2dd92-860f-11e7-8979-5e3a640e5579'
pnconfig.auth_key = 'V575MH48KA'
# pnconfig.auth_key = '0F2D18PV1CTA4JIM98MX9FTZ87Q9IZ4FW53LRHXT3R' # admin key
pnconfig.ssl = True
pnconfig.reconnect_policy = PNReconnectionPolicy.LINEAR
pnconfig.subscribe_timeout = pnconfig.connect_timeout = pnconfig.non_subscribe_timeout = 9 ^ 99
pubnub = PubNub(pnconfig)
pubnub = PubNub(pnconfig)
my_listener = SubscribeListener()
pubnub.add_listener(my_listener)
pubnub.subscribe().channels('SECURE.BN9NDS0PFC').execute()
my_listener.wait_for_connect()
print("Test #18")
msg = json.loads(
from pubnub.enums import PNStatusCategory, PNOperationType
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
import Adafruit_DHT
PIR_pin = 23
Buzzer_pin = 24
dht11_pin = 16
myChannel = "Homesafe"
sensorList = ["buzzer"]
data = {}
pnconfig = PNConfiguration()
pnconfig.cipher_key = 'myCipherKey'
pnconfig.auth_key = 'Homesafe-Roisin-Raspberry-Pi'
pnconfig.subscribe_key = 'sub-c-12924b4c-2f48-11eb-9713-12bae088af96'
pnconfig.publish_key = 'pub-c-4c71c151-b075-498f-bfbc-c6f3221ed3b6'
pnconfig.uuid = 'c26f2970-3fc1-11eb-b378-0242ac130002'
pubnub = PubNub(pnconfig)
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(PIR_pin, GPIO.IN)
GPIO.setup(Buzzer_pin, GPIO.OUT)
def beep(repeat):
for i in range(0, repeat):
for pulse in range(60):
GPIO.output(Buzzer_pin, True)
import logging
import asyncio
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub_asyncio import PubNubAsyncio
pnconfig = PNConfiguration()
pnconfig.publish_key = "pub-c-98863562-19a6-4760-bf0b-d537d1f5c582"
pnconfig.subscribe_key = "sub-c-7ba2ac4c-4836-11e6-85a4-0619f8945a4f"
pnconfig.secret_key = "sec-c-MGFkMjQxYjMtNTUxZC00YzE3LWFiZGYtNzUwMjdjNmM3NDhk"
pnconfig.auth_key = "blah"
pnconfig.enable_subscribe = False
pubnub = PubNubAsyncio(pnconfig)
async def grant():
envelope = await pubnub.grant().auth_keys("blah").channels(
"history_channel").read(True).write(True).ttl(0).future()
print("Grant access: %r" % envelope.status.is_error())
logger = logging.getLogger("pubnub")
async def publish500():
for i in range(0, 500):
envelope = await pubnub.publish()\
.message(['message#', i])\
.channel('history_channel')\
import RPi.GPIO as GPIO
import Adafruit_DHT
import time, threading, spidev
from pubnub.callbacks import SubscribeCallback
from pubnub.enums import PNStatusCategory
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
pnconfig = PNConfiguration()
pnconfig.subscribe_key = 'sub-c-c96cd480-3528-11e8-a218-f214888d2de6'
pnconfig.publish_key = 'pub-c-f141a42f-ae6d-4f11-bbaf-4bc7cb518b6c'
##########################
pnconfig.cipher_key = 'myCipherKey'
pnconfig.auth_key = 'raspberry-pi'
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
myChannel = "RSPY"
PIR_pin = 23
Buzzer_pin = 24
LED = 18
dht11_pin = 5
sensorsList = ["buzzer"]
data = {}
# Define MCP3008 channels
light_channel = 0
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(PIR_pin, GPIO.IN)
__author__ = "@sgript"
'''
from pubnub.enums import PNStatusCategory
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pnconfiguration import PNConfiguration, PNReconnectionPolicy
from pubnub.pubnub import PubNub, SubscribeListener
import sys
sys.path.append("..")
from helpers import id_generator as idgen
pnconfig = PNConfiguration()
pnconfig.publish_key = 'pub-c-85d5e576-5d92-48b0-af83-b47a7f21739f'
pnconfig.subscribe_key = 'sub-c-12c2dd92-860f-11e7-8979-5e3a640e5579'
pnconfig.auth_key = 'EMB_48391'
pnconfig.ssl = True
pnconfig.reconnect_policy = PNReconnectionPolicy.LINEAR
pnconfig.subscribe_timeout = pnconfig.connect_timeout = pnconfig.non_subscribe_timeout = 9 ^ 99
pubnub = PubNub(pnconfig)
my_listener = SubscribeListener()
pubnub.add_listener(my_listener)
pubnub.subscribe().channels('embedded_devices').execute()
# series of functions to control LEDs
def LED_on(colour, auth_key=None):
"""colour: E.g. red"""
pnconfig.auth_key = auth_key
from pubnub.enums import PNStatusCategory, PNOperationType
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
MQTT_ADDRESS = '192.168.178.25'
MQTT_USER = '******'
MQTT_PASSWORD = '******'
MQTT_TOPIC = 'home/+/+'
myChannel = "Homesafe"
sensorList = ["buzzer"]
data = {}
pnconfig = PNConfiguration()
pnconfig.cipher_key = 'myCipherKey'
pnconfig.auth_key = 'Homesafe-Finbar-Raspberry-Pi'
pnconfig.subscribe_key = 'sub-c-12924b4c-2f48-11eb-9713-12bae088af96'
pnconfig.publish_key = 'pub-c-4c71c151-b075-498f-bfbc-c6f3221ed3b6'
pnconfig.uuid = '62d358a1-ee39-4aba-8950-2677d2dd5bcd' #'8f255df0-3657-11eb-adc1-0242ac120002'
pubnub = PubNub(pnconfig)
def publish(custom_channel, msg):
pubnub.publish().channel(custom_channel).message(msg).pn_async(
my_publish_callback)
def my_publish_callback(envelope, status):
# Check whether request successfully completed or not
if not status.is_error():
pass # Message successfully published to specified channel.
