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 main():
execute('send log Application subscriber_listener.py started')
logging.basicConfig(
filename='application_run.log',
level=logging.DEBUG,
format=
'%(asctime)s.%(msecs)03d %(levelname)s %(module)s - %(funcName)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
global IOS_XE_HOST_IP, DEVICE_HOSTNAME, DEVICE_LOCATION
# retrieve the ios xe device management ip address, Gi0/0
IOS_XE_HOST_IP = execute('sh run int gi1 | in ip address').split(' ')[3]
# retrieve the device hostname using RESTCONF
DEVICE_HOSTNAME = netconf_restconf.get_restconf_hostname(
IOS_XE_HOST_IP, IOS_XE_USER, IOS_XE_PASS)
print(str('\nThe device hostname: ' + DEVICE_HOSTNAME))
"""
The following commands are if Cisco DNA Center is available
# get DNA C AUth JWT token
dnac_token = dnac_apis.get_dnac_jwt_token(DNAC_AUTH)
DEVICE_LOCATION = dnac_apis.get_device_location(DEVICE_HOSTNAME, dnac_token)
print(str("\nDevice Location: " + DEVICE_LOCATION))
"""
# init the PubNub channel
pubnub = pubnub_init(DEVICE_HOSTNAME)
pubnub.add_listener(MySubscribeCallback())
pubnub.subscribe().channels(CHANNEL).execute()
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 = 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 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 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 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 message(self, pubnub, message) :
if message.message == 'ON' :
global flag
flag = 1
elif message.message == 'OFF' :
global flag
flag = 0
else:
message.message == 'WATER' :
pump.off()
sleep(5)
pump.on()
pubnub.add_listener(MySubscribeCallback())
pubnub.subscribe().channels('ch1').execute()
def main():
my_listener = SubscribeListener()
pubnub.add_listener(my_listener)
pubnub.subscribe().channels("awesomeChannel").execute()
yield my_listener.wait_for_connect()
print("connected")
yield pubnub.publish().channel("awesomeChannel").message({'fieldA': 'awesome', 'fieldB': 10}).future()
result = yield my_listener.wait_for_message_on("awesomeChannel")
print(result.message)
pubnub.unsubscribe().channels("awesomeChannel").execute()
yield 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_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_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")
async def main():
class MyListener(SubscribeCallback):
def status(self, pubnub, status):
if status.category == PNStatusCategory.PNConnectedCategory:
asyncio.ensure_future(
pubnub.publish().channel("awesomeChannel").message({
'fieldA':
'awesome',
'fieldB':
10
}).future())
def message(self, pubnub, message):
pass
def presence(self, pubnub, presence):
pass
my_listener = MyListener()
pubnub.add_listener(my_listener)
pubnub.subscribe().channels("awesomeChannel").execute()
await asyncio.sleep(10)
def main():
def publish_callback(*args):
pass
class MyListener(SubscribeCallback):
def status(self, pubnub, status):
if status.category == PNStatusCategory.PNConnectedCategory:
pubnub.ioloop.add_future(
pubnub.publish().channel("awesomeChannel").message({'fieldA': 'awesome', 'fieldB': 10}).future(),
publish_callback
)
def message(self, pubnub, message):
pass
def presence(self, pubnub, presence):
pass
my_listener = MyListener()
pubnub.add_listener(my_listener)
pubnub.subscribe().channels("awesomeChannel").execute()
yield gen.sleep(10)
def presence(self, pubnub, presence):
if presence.channel != self.admin_channel:
if presence.event == "join":
if presence.channel not in self.gateway_channels and presence.uuid != presence.channel and presence.uuid not in self.gateway_uuids:
print(
'2. UNAUTHORISED USER ({}) HAS JOINED THE UUID CHANNEL ({}).'
.format(presence.uuid, presence.channel))
self.gd.auth_blacklist(presence.channel, presence.uuid)
elif presence.channel == "gateway_auth" and presence.uuid not in self.gateway_uuids:
print("PRESENCE EVENT: " + str(presence.event))
print("[1] UUID JOINED AUTH CHANNEL: {}".format(
presence.uuid))
pubnub.grant().channels(
presence.uuid).read(True).write(True).sync()
print("GatewayAuth: Connecting the UUID channel {}".format(
presence.uuid))
pubnub.subscribe().channels(
presence.uuid).with_presence().execute()
# Send hashed UUID over the gateway, client will know its UUID so it can hash and compute it.
sha3_hash = hashlib.new("sha3_512")
encode = sha3_hash.update((presence.uuid).encode("UTF-8"))
pubnub.publish().channel('gateway_auth').message(
sha3_hash.hexdigest()). async (my_publish_callback)
# Check UUID channel info
envelope = pubnub.here_now().channels(
presence.uuid).include_uuids(True).include_state(
True).sync()
users_in_channel = envelope.result.total_occupancy
# Someone could be spying - at this point only the gateway should be here.
if users_in_channel > 1:
print("WARNING! Someone may be spying in the channel")
uuids_in_channel = []
users = envelope.result.channels[0].occupants
for occupant in users: # If there is indeed multiple people in the channel only then we bother to check who.
print(
occupant.uuid
) # - lists all uuids in channel, if more than one can later 'blacklist' ones not meant to be in the channel -> "do not serve, suspicious"
if occupant.uuid not in self.gateway_uuids and occupant.uuid != presence.uuid: # only blacklist if not gateway or the legit user
uuids_in_channel.append(occupant.uuid)
self.gd.auth_blacklist(
presence.channel,
occupant.uuid) # blacklist them
pubnub.publish().channel(presence.uuid).message({
"error":
"Too many occupants in channel, regenerate UUID."
}). async (my_publish_callback)
elif presence.channel not in self.gateway_channels and presence.uuid == presence.channel: # uuid channel presence
print(
'[2] REQUIRED USER ({}) HAS JOINED THE UUID CHANNEL ({}).'
.format(presence.uuid, presence.channel))
users_auth_key = idgen.id_generator()
channelName = "SECURE." + idgen.id_generator()
# Send auth key to user
pubnub.publish().channel(presence.uuid).message({
"channel":
channelName,
"auth_key":
users_auth_key,
"global_channel":
"gateway_global"
}). async (
my_publish_callback) # Send data over 1-1 channel
# Grant + Subscribe to new private channel.
pubnub.grant().channels([channelName]).auth_keys([
users_auth_key, self.receiver_auth_key
]).read(True).write(True).manage(True).ttl(0).sync()
print(
"GatewayReceiver: Connecting to private channel {}..".
format(channelName))
self.gr.subscribe_channels(
channelName
) # Receiver to subscribe to this private channel for function calls.
self.gd.gateway_subscriptions(channelName, presence.uuid)
if presence.event == "timeout" or presence.event == "leave" and presence.uuid not in self.gateway_uuids:
print(
"GatewayAuth: {} event on channel {} by user {}, unsubscribing."
.format(presence.event.title(), presence.channel,
presence.uuid))
pubnub.unsubscribe().channels(presence.uuid).execute()
pubnub = PubNub(pnconfig)
# subscribe_callback
class MyCallback(SubscribeCallback):
def status(self, pubnub, status):
if status.operation == PNOperationType.PNSubscribeOperation \
and status.category == PNStatusCategory.PNConnectedCategory:
print("connected")
def presence(self, pubnub, presence):
pass
def message(self, pubnub, message):
pass
my_listener = MyCallback()
pubnub.add_listener(my_listener)
pubnub.subscribe().channel("my_channel").execute()
# subscribe_listener
my_listener = SubscribeListener()
pubnub.add_listener(my_listener)
pubnub.subscribe().channel("my_channel").execute()
my_listener.wait_for_connect()
print('connected')
elif status.operation == PNOperationType.PNSubscribeOperation:
# Heartbeat operations can in fact have errors, so it is important to check first for an error.
# For more information on how to configure heartbeat notifications through the status
# PNObjectEventListener callback, consult <link to the PNCONFIGURATION heartbeart config>
if status.is_error():
pass
# There was an error with the heartbeat operation, handle here
else:
pass
# Heartbeat operation was successful
else:
pass
# Encountered unknown status type
def presence(self, pubnub, presence):
pass # handle incoming presence data
def message(self, pubnub, message):
print "incoming message", message.message # handle incoming messages
channel = "SmartPlantPi_Data"
def callback(message, channel):
print('[' + channel + ']: ' + str(message))
pubnub.add_listener(MySubscribeCallback())
pubnub.subscribe().channels(channel).execute()
else:
pass
def presence(self, pubnub, presence):
pass
def message(self, pubnub, message):
global flag
if message.message == 'ON':
flag = 1
elif message.message == 'OFF':
flag = 0
pubnub.add_listener(MySubscribeCallback())
pubnub.subscribe().channels('Ch2').execute()
def publish_callback(result, status):
pass
time.sleep(2)
while True:
if GPIO.input(pir) and flag == 1:
pubnub.publish().channel('Ch1').message("Intruder Detected!").pn_async(
publish_callback)
print("Intruder Detected!")
#End of Subscriber action
pubnub.publish().channel("Demo.2").message("End").pn_async(show)
def checkGoAhead(message):
if "End" in message:
DatabaseSync.goAhead()
elif "Final" in message:
global final
final = True
else:
print(message)
global messages
messages.append(message)
def message(self, pubnub, data):
self.Data = data
if final:
DatabaseSync.showResult(data.message)
else:
DatabaseSync.checkGoAhead(data.message)
#Shows message and status
def show(msg, stat):
if msg and stat: pass#print( "\n",msg.timetoken, stat.status_code )
else : print( "Error", stat and stat.status_code )
sync = DatabaseSync()
pubnub.add_listener(sync)
pubnub.subscribe().channels("Demo.1").execute()
requestLoans = []
def second():
pubnub.subscribe().channels(["my_channel1", "my_channel2"]).execute()
import pubnub
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub, SubscribeListener
class DatabaseSync(SubscribeListener):
def message( self, pubnub, data ):
print( "Saving to Database: ", data.message )
pnconfig = PNConfiguration()
pnconfig.subscribe_key = 'demo'
pnconfig.publish_key = 'demo'
pubnub = PubNub(pnconfig)
pubnub.add_listener(DatabaseSync())
pubnub.subscribe().channels("change_log").execute()
def main_without_pppd():
global index
global serverActivation
global userActivation
s1_last_seen = ""
idle_time = 0.0
active_time = 0.0
idle_flag = True
active_flag = True
for c in range(INIT_DELAY):
print ("Starting in T-minus {} second".format(INIT_DELAY-c))
sleep(1)
while True:
# start listening to the channel from incoming messages
pubnub.subscribe()\
.channels(CHANNEL_ID)\
.with_presence()\
.execute()
# pubnub.here_now()\
# .channels(CHANNEL_ID)\
# .include_uuids(True)\
# .pn_async(here_now_callback)
print("\n\nStream index:{} \n".format(index))
print("server act payload:{}".format(serverActivation))
print("user act payload:{}".format(userActivation))
# do the logic for anti-theft system here
# /__\ ( \( )(_ _)(_ _) (_ _)( )_( )( ___)( ___)(_ _)
# /( )\ ) ( )( _)(_ )( ) _ ( )__) )__) )(
#(__)(__)(_)\_) (__) (____) (__) (_) (_)(____)(_) (__)
scooter1_activated = (serverActivation and userActivation)
if scooter1_activated:
if not idle_flag:
idle_flag = True
idle_end = perf_counter()
idle_time = idle_end - idle_start
print("//////////////////////////Was Idling for {} sec".format(idle_time))
active_flag = True
if active_flag:
active_start = perf_counter()
active_flag = False
print("Scooter is now active for {:.1f} sec".format(perf_counter()-active_start))
else:
if idle_flag:
idle_start = perf_counter()
idle_flag = False
print("Scooter is now idle for {:.1f} sec".format(perf_counter()-idle_start))
if not active_flag:
active_end = perf_counter()
active_time = active_end - active_start
print("////////////////////////// Was Active for {} sec".format(active_time))
active_flag = True
print("ACTIVATION_S1:{}".format(scooter1_activated))
groundSpeed = getNavigationInfo()
gndSpeed = float(groundSpeed)
if gndSpeed is not 0.00:
scooter1_moved = True
else:
scooter1_moved = False
if not scooter1_activated and scooter1_moved:
scooterAlarm = True
else:
scooterAlarm = False
print("standby_alarm_S1:{}".format(scooterAlarm))
# Make sure there's a GPS fix
if checkForFix():
# Get lat and long
if getCoord():
index+=1
latitude, longitude = getCoord() # live coordinates
# in_activated = input("active-s1?:")
# scooter1_activated=str2bool_util(in_activated)
if not scooter1_activated:
s1_last_seen = float(longitude),float(latitude)
else:
s1_last_seen = ""
coord = "lat:" + str(latitude) + "," + "lng:" + str(longitude)
print (coord)
# create JSON dictionary
dictionary = {
"s1_index": float(index),
"s1_speed": float(gndSpeed+30),
"s1_latitude": float(latitude),
"s1_longitude": float(longitude),
"s1_activated": bool(scooter1_activated),
"s1_moved": bool(scooter1_moved),
"s1_last_known": s1_last_seen
}
pubnub.publish().channel(CHANNEL_ID).message(dictionary).pn_async(publish_callback)
print("\nNext stream in:\n")
for c in range(STREAM_DELAY):
# print(STREAM_DELAY-c, end = ' ')
# print ("{} second".format(STREAM_DELAY-c))
sleep(SECONDS_BETWEEN_READS)
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")
header = []
header.append('COMPUTER NAME')
header.append('IP ADDRESS')
for i in range(0, len(fnl_nf) - 3):
header.append('APPLICATION ' + str(i + 1))
with open(fp, 'w+') as f:
f.write(
"\t\t\t\tFIND THE SPECIFIC APPLICATION REPORT FOR ALL DEVICES\t\t\t\t\n"
)
for i in range(0, len(header)):
f.write(str(header[i]) + ',')
f.write('\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')
n = result.message
pubnub.remove_listener(my_listener)
if (n[0] == key):
with open(fp, 'a') as f:
for i in range(1, len(n)):
f.write(n[i] + ',')
f.write('\n')
if not self.working: # if state is working == true still working
break
self.set_state(True)
'fieldA': 'awesome',
'fieldB': 10
}).sync()
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:
def third():
pubnub.subscribe().channels("my_channel").with_presence().execute()
def recv():
count = 0
while True:
try:
data, server = sock.recvfrom(1518)
print(data.decode(encoding="utf-8"))
except Exception:
print ('\nExit . . .\n')
break
print ('\r\n\r\nFoGR Tello Demo.\r\n')
print ('Tello: command takeoff land flip forward back left right \r\n up down cw ccw speed speed?\r\n')
print ('end -- quit demo.\r\n')
#recvThread create
recvThread = threading.Thread(target=recv)
recvThread.start()
msg="command"
msg = msg.encode(encoding="utf-8")
sent = sock.sendto(msg, tello_address)
print("listening...")
pubnub.add_listener(MyListener())
pubnub.subscribe().channels("fogr").execute()
pass # handle incoming presence data
def message(self, pubnub, message):
global flag
if message.message == 'ON':
flag = 1
elif message.message == 'OFF':
flag = 0
elif message.message == 'WATER':
pump.off()
sleep(5)
pump.on()
pubnub.add_listener(MySubscribeCallback())
pubnub.subscribe().channels('ch1').execute()
def publish_callback(result, status):
pass
def get_status():
if soil.is_held:
print("dry")
return True
else:
print("wet")
return False
while True:
if flag ==1:
pubnub.set_stream_logger('pubnub', logging.DEBUG)
pnconfig = PNConfiguration()
pnconfig.publish_key = "demo"
pnconfig.subscribe_key = "demo"
pubnub = PubNub(pnconfig)
class MyListener(SubscribeCallback):
def status(self, pubnub, status):
if status.category == PNStatusCategory.PNConnectedCategory:
pubnub.publish().channel("awesomeChannel").message({
'fieldA': 'awesome',
'fieldB': 10
}).sync()
def message(self, pubnub, message):
pass
def presence(self, pubnub, presence):
pass
my_listener = MyListener()
pubnub.add_listener(my_listener)
pubnub.subscribe().channels("awesomeChannel").execute()
