def init_pubnub():
global pubnub
pnconfig = PNConfiguration()
pnconfig.subscribe_key = 'sub-c-f97a2b14-b03f-11e7-8d4b-66b981d3b880'
pnconfig.publish_key = 'pub-c-b7f324ac-e190-4bcf-ba5e-b860168f6f9b'
pnconfig.secret_key = 'sec-c-YjQ1ZDQwYzktYTY4YS00OWY0LWIzNDUtYTlkNjI4YTIxNDBj'
pubnub = PubNub(pnconfig)
pubnub.add_listener(MySubscribeCallback())
pubnub.subscribe().channels('magicmirror').execute()
print('pubnub subscription completed')
def subscribe(channels, keys):
print('subscribing now... {c}, {k}'.format(c=channels, k=keys))
pnconfig = PNConfiguration()
pnconfig.subscribe_key = keys[0]
pnconfig.publish_key = keys[1]
pnconfig.secret_key = keys[2]
pubnub = PubNub(pnconfig)
pubnub.add_listener(MySubscribeCallback())
pubnub.subscribe().channels(channels).execute()
def __init__(self, gdatabase = None, admin_channel = None):
self.gdatabase = gdatabase
self.admin_channel = admin_channel
if gdatabase is None:
password = input("Database password: "******"Rebuilding subscriptions..")
subscriptions = self.gdatabase.get_channels()
if subscriptions:
self.subscribe_channels(subscriptions)
self.default_channels = ["policy", "gateway_global", self.admin_channel, "embedded_devices"]
print("GatewayReceiver: Subscribing to the Policy server and Gateway global feed..")
self.pubnub.grant().channels(self.default_channels[0]).auth_keys([self.gdatabase.receivers_key(), self.gdatabase.policy_key()]).read(True).write(True).manage(True).ttl(0).sync()
self.pubnub.grant().channels(self.default_channels[1:]).read(True).write(True).manage(True).sync()
self.subscribe_channels(self.default_channels[:-1])
self.pastebin = PasteFetcher.PasteFetcher()
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()
import Adafruit_DHT from gpiozero import LED, Button from time import sleep import pubnub from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub from pubnub.callbacks import SubscribeCallback from pubnub.enums import PNOperationType, PNStatusCategory pnconfig = PNConfiguration() pnconfig.subscribe_key = "sub-c-7da197b0-a787-11ea-ae1a-36d49400aaff" pnconfig.publish_key = "pub-c-12ed66b1-705b-4eb4-aef6-4fe9dcf7b245" pnconfig.secret_key = "sec-c-ZGM5OWE4YmMtYzdlOC00MzljLTkxYmQtOTUzZmMyZTM4NmI2" pnconfig.ssl = False pubnub = PubNub(pnconfig) #Pump is connected to GPIO4 as an LED pump = LED(4) #DHT Sensor is connected to GPIO17 sensor = 22 pin = 17 #Soil Moisture sensor is connected to GPIO14 as a button soil = Button(14) flag = 1
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 = 'Enter your subscribe key here'
pnconfig.publish_key = 'Enter your publish key here'
pnconfig.secret_key = 'Enter your secret key here'
pubnub = PubNub(pnconfig)
def my_publish_callback(envelope, status):
if not status.is_error():
pass
else:
pass
class MySubscribeCallback(SubscribeCallback):
def presence(self, pubnub, presence):
pass
def status(self, pubnub, status):
if status.category == PNStatusCategory.PNUnexpectedDisconnectCategory:
pass
if status.category == PNStatusCategory.PNConnectedCategory:
pubnub.grant().read(True).write(True).channels('RP').auth_keys(
'Valid_key').ttl(2).sync()
from pubnub.pnconfiguration import PNConfiguration from pubnub.pubnub import PubNub from dotenv import load_dotenv # App creation app = Flask(__name__) CORS(app) # DB init db = FireDB() # Pubnub init load_dotenv() pnconfig = PNConfiguration() pnconfig.publish_key = os.environ['PN_PUBLISH_KEY'] pnconfig.subscribe_key = os.environ['PN_SUBSCRIBE_KEY'] pnconfig.secret_key = os.environ['PN_SECRET_KEY'] pnconfig.uuid = os.environ['PN_SERVER_UUID'] pubnub = PubNub(pnconfig) # Import blueprints from flaskr import home, users, friends, groups, auth app.register_blueprint(home.bp) app.register_blueprint(users.bp) app.register_blueprint(friends.bp) app.register_blueprint(groups.bp) app.register_blueprint(auth.bp)
pnconf_enc.publish_key = pub_key pnconf_enc.subscribe_key = sub_key pnconf_enc.cipher_key = "testKey" pnconf_enc.enable_subscribe = False pnconf_enc.uuid = uuid_mock pnconf_enc_sub = PNConfiguration() pnconf_enc_sub.publish_key = pub_key pnconf_enc_sub.subscribe_key = sub_key pnconf_enc_sub.cipher_key = "testKey" pnconf_enc_sub.uuid = uuid_mock pnconf_pam = PNConfiguration() pnconf_pam.publish_key = pub_key_pam pnconf_pam.subscribe_key = sub_key_pam pnconf_pam.secret_key = sec_key_pam pnconf_pam.enable_subscribe = False pnconf_pam.uuid = uuid_mock pnconf_pam_stub = PNConfiguration() pnconf_pam_stub.publish_key = "pub-stub" pnconf_pam_stub.subscribe_key = "sub-c-stub" pnconf_pam_stub.secret_key = "sec-c-stub" pnconf_pam_stub.uuid = uuid_mock pnconf_ssl = PNConfiguration() pnconf_ssl.publish_key = pub_key pnconf_ssl.subscribe_key = sub_key pnconf_ssl.ssl = True pnconf_ssl.uuid = uuid_mock
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')\
pnconf_enc = PNConfiguration() pnconf_enc.publish_key = pub_key pnconf_enc.subscribe_key = sub_key pnconf_enc.cipher_key = "testKey" pnconf_enc.enable_subscribe = False pnconf_enc_sub = PNConfiguration() pnconf_enc_sub.publish_key = pub_key pnconf_enc_sub.subscribe_key = sub_key pnconf_enc_sub.cipher_key = "testKey" pnconf_pam = PNConfiguration() pnconf_pam.publish_key = pub_key_pam pnconf_pam.subscribe_key = sub_key_pam pnconf_pam.secret_key = sec_key_pam pnconf_pam.enable_subscribe = False pnconf_ssl = PNConfiguration() pnconf_ssl.publish_key = pub_key pnconf_ssl.subscribe_key = sub_key pnconf_ssl.ssl = True message_count_config = PNConfiguration() message_count_config.publish_key = 'demo-36' message_count_config.subscribe_key = 'demo-36' message_count_config.origin = 'balancer1g.bronze.aws-pdx-1.ps.pn' objects_config = PNConfiguration() objects_config.publish_key = 'demo' objects_config.subscribe_key = 'demo'
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
server_UUID = "df89d8b2-358e-11eb-adc1-0242ac120002" # UUID Generated
cipherKey = "myCipherKey" # Cipher Key
myChannel = "Homesafe" # Channel Name
############################
pnconfig = PNConfiguration()
# Homesafe PubNub Connections - All members have access using these
pnconfig.subscribe_key = 'sub-c-12924b4c-2f48-11eb-9713-12bae088af96'
pnconfig.publish_key = 'pub-c-4c71c151-b075-498f-bfbc-c6f3221ed3b6'
pnconfig.secret_key = "sec-c-MTliZTg5YmItYjE3Zi00OGYxLTgwZDEtOTE5OGY5NDlmNWVk"
pnconfig.uuid = server_UUID
pnconfig.cipher_key = cipherKey
pubnub = PubNub(pnconfig)
def grant_access(auth_key, read, write):
if read is True and write is True:
grant_read_and_write_access(auth_key)
elif read is True:
grant_read_access(auth_key)
elif write is True:
grant_write_access(auth_key)
else:
revoke_access(auth_key)
def grant_read_and_write_access(auth_key):
pnconf_enc = PNConfiguration()
pnconf_enc.publish_key = pub_key
pnconf_enc.subscribe_key = sub_key
pnconf_enc.cipher_key = "testKey"
pnconf_enc.enable_subscribe = False
pnconf_enc_sub = PNConfiguration()
pnconf_enc_sub.publish_key = pub_key
pnconf_enc_sub.subscribe_key = sub_key
pnconf_enc_sub.cipher_key = "testKey"
pnconf_pam = PNConfiguration()
pnconf_pam.publish_key = pub_key_pam
pnconf_pam.subscribe_key = sub_key_pam
pnconf_pam.secret_key = sec_key_pam
pnconf_pam.enable_subscribe = False
pnconf_ssl = PNConfiguration()
pnconf_ssl.publish_key = pub_key
pnconf_ssl.subscribe_key = sub_key
pnconf_ssl.ssl = True
def pnconf_copy():
return copy(pnconf)
def pnconf_enc_copy():
return copy(pnconf_enc)
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
server_UUID = "server"
cipherKey = "myCipherKey"
myChannel = "RSPY"
############################
pnconfig = PNConfiguration()
pnconfig.subscribe_key = 'sub-c-c96cd480-3528-11e8-a218-f214888d2de6'
pnconfig.publish_key = 'pub-c-f141a42f-ae6d-4f11-bbaf-4bc7cb518b6c'
pnconfig.secret_key = "sec-c-YzhiNDQ0ZDEtODNmMS00M2NmLTgwMDktZmNlYjgzMDJkYjE5"
pnconfig.uuid = server_UUID
pnconfig.cipher_key = cipherKey
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
def grantAccess(auth_key, read, write):
if read is True and write is True:
grantReadAndWriteAccess(auth_key)
elif read is True:
grantReadAccess(auth_key)
elif write is True:
grantWriteAccess(auth_key)
else:
revokeAccess(auth_key)
def grantReadAndWriteAccess(auth_key):
import logging
import pubnub
from pubnub.callbacks import SubscribeCallback
from pubnub.enums import PNOperationType, PNStatusCategory, PNPushType
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub, SubscribeListener
pubnub.set_stream_logger('pubnub', logging.DEBUG)
pnconfig = PNConfiguration()
pnconfig.publish_key = "demo"
pnconfig.subscribe_key = "demo"
pnconfig.secret_key = "demo"
pubnub = PubNub(pnconfig)
def gcm_handler(result, status):
if status.is_error():
# handle error
return
print(result)
envelope = pubnub.add_channels_to_push()\
.push_type(PNPushType.GCM)\
.channels("ch1", "ch2", "ch3")\
.device_id("deviceId")\
.sync()
