def __init__(self, args, publish_key=None, post_reporter=None, run_id=None):
self.args = args
self.post_reporter = post_reporter
self.updater = None
self.last_update = {
'step': datetime(1678, 1, 1),
'save': datetime(1678, 1, 1)
}
subscribe_key = environ.get('PUBNUB_SUBSCRIBE_KEY')
if publish_key and subscribe_key:
pnconfig = PNConfiguration()
pnconfig.subscribe_key = subscribe_key
pnconfig.publish_key = publish_key
pnconfig.ssl = False
self.pubnub = PubNub(pnconfig)
self.channel = 'openagua-{source_id}-{network_id}-{model_key}-{run_id}'.format(
source_id=args.source_id,
network_id=args.network_id,
model_key=environ['MODEL_KEY'],
run_id=run_id,
)
# if environ.get('RUN_KEY'):
# self.channel += '-{}'.format(environ['RUN_KEY'])
print(' [*] PubNub will publish to {}'.format(self.channel))
else:
self.pubnub = None
self.channel = None
print(' [-] PubNub failed to initialize.')
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 publish_nonhead():
import time
time.sleep(30)
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from pubnub.callbacks import SubscribeCallback
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
publish_key1 = 'pub-c-7a797a24-388e-411c-b848-9bd170919784'
subscribe_key1 = 'sub-c-b1b31f80-179a-11e8-95aa-1eb18890f15d'
pnconfig = PNConfiguration()
pnconfig.subscribe_key = subscribe_key1
pnconfig.publish_key = publish_key1
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
import time
from pubnub.exceptions import PubNubException
try:
envelope = pubnub.publish().channel("Channel-706fxzjkv").message(
Drive(KEY)).sync()
print("publish timetoken: %d" % envelope.result.timetoken)
except PubNubException as e:
print e
def main():
pnconfig = PNConfiguration()
pnconfig.subscribe_key = os.environ['PUBNUB_SUBSCRIBE_KEY']
pnconfig.ssl = False
pubnub = PubNub(pnconfig)
pubnub.add_listener(MySubscribeCallback())
pubnub.subscribe().channels(os.environ['PUBNUB_CHANNELS'].split(':')).execute()
def sfd_process(sfd):
FX_CHANNEL = "lightning_ticker_FX_BTC_JPY"
BTC_CHANNEL = "lightning_ticker_BTC_JPY"
class BitflyerSubscriberCallback(SubscribeCallback):
def message(self, pubnub, message):
tick = message.message
timestamp = dateutil.parser.parse(tick["timestamp"])
with sfd.lock:
changed = False
if message.channel == FX_CHANNEL:
if sfd.fx_ltp != tick["ltp"]:
sfd.fx_ltp = tick["ltp"]
changed = True
elif message.channel == BTC_CHANNEL:
if sfd.btc_ltp != tick["ltp"]:
sfd.btc_ltp = tick["ltp"]
changed = True
if sfd.ready and changed:
sfd.disparity = (sfd.fx_ltp / sfd.btc_ltp) * 100 - 100
if (sfd.fx_ltp > sfd.btc_ltp and sfd.disparity >= 10.0) or \
(sfd.fx_ltp < sfd.btc_ltp and sfd.disparity <= -10.0):
sfd.last_sfd_at = timestamp
sfd.updated_at = timestamp
sfd.event.set()
config = PNConfiguration()
config.subscribe_key = 'sub-c-52a9ab50-291b-11e5-baaa-0619f8945a4f'
config.reconnect_policy = PNReconnectionPolicy.LINEAR
config.ssl = False
config.set_presence_timeout(60)
pubnub = PubNubTornado(config)
listener = BitflyerSubscriberCallback()
pubnub.add_listener(listener)
pubnub.subscribe().channels([FX_CHANNEL, BTC_CHANNEL]).execute()
pubnub.start()
def get_setup_pubnub():
class SubCallback(SubscribeCallback):
def presence(self, pubnub, presence):
pass
def status(self, pubnub, status):
pass
def message(self, pubnub, message):
message_dict = message.message
request_id = uuid.UUID(message_dict["request_id"])
response_rebuilder[request_id].append(message_dict)
deduped = deduped_chunks(response_rebuilder[request_id])
if len(deduped) == message_dict["chunks"]:
deduped.sort(key=lambda item: item["chunk_index"], )
response_content = base64.urlsafe_b64decode(
str("".join([d["response_content"] for d in deduped])))
request_pool[request_id] = response_content
del response_rebuilder[request_id]
pnconfig = PNConfiguration()
pnconfig.subscribe_key = SUBSCRIBE_KEY
pnconfig.publish_key = PUBLISH_KEY
pnconfig.ssl = False
pubnub = PubNub(pnconfig)
callback = SubCallback()
pubnub.add_listener(callback)
pubnub.subscribe().channels('channelRX').execute()
# pubnub.unsubscribe_all()
# pubnub.stop()
return pubnub
def get(self, request, format=None):
pnconfig = PNConfiguration()
pnconfig.subscribe_key = 'sub-c-2ebd9ad8-6cdb-11e8-902b-b2b3cb3accda'
pnconfig.publish_key = 'pub-c-84d6b42f-9d4d-48c1-b5a7-c313289e1792'
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
friend = Friend.objects.get(
current_user__username__exact=request.user.username)
streamers = friend.friend_list.all()
results = {'results': []}
for streamer in streamers:
envelope = pubnub.where_now().uuid(streamer.username +
'-device').sync()
if streamer.username + '-stream' in envelope.result.channels:
profile_image = streamer.profile.get_avatar
streamer_json = {
'username':
streamer.username,
'fullname':
streamer.get_full_name(),
'profile_image':
profile_image,
'profile_url':
reverse('user_profile',
kwargs={'username': streamer.username}),
'stream_url':
reverse('home:watchlive',
kwargs={'username': streamer.username})
}
results['results'].append(streamer_json)
else:
continue
data = results['results']
return Response(data)
def __init__(self, pub_key, sub_key):
pnconfig = PNConfiguration()
pnconfig.subscribe_key = sub_key
pnconfig.publish_key = pub_key
pnconfig.ssl = False
self.pubnub = PubNub(pnconfig)
self.node_map = defaultdict(tuple)
self.known_nodes = []
self.get_nodes()
# Holds messages from the 'ranged' topic
self.raw_log = defaultdict(MaxLenDeque)
self.ranged_log = defaultdict(MaxLenDeque)
self.max_time_diff = timedelta(seconds=5)
# n_matrix = {
# "indoors": 3.7,
# "free_air": 2,
# }
# beacon_matrix = {
# "bluecharm": -59.8,
# }
# Settings for inside RAIN
self.n = 3.1 # Path loss exponent = 1.6-1.8 w/LOS to beacon indoors
self.measured_rssi = -46 # Beacon-specific measured RSSI @ 1m
# Settings for inside a normal house
# self.n = 2.7
# self.measured_rssi = -59.8
self.solver = TrilaterationSolver()
def publish_nonhead():
import time
time.sleep(30)
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from pubnub.callbacks import SubscribeCallback
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
k1 = 'pub-c-e4dca0d8-c948-42e9-a080-3a84922d77c4'
k2 = 'sub-c-ff76b412-17b2-11e8-bb84-266dd58d78d1'
pnconfig = PNConfiguration()
pnconfig.subscribe_key = k2
pnconfig.publish_key = k1
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
import time
from pubnub.exceptions import PubNubException
try:
envelope = pubnub.publish().channel("Channel-n3jbvzcv1").message(
'%s' % d).sync()
print("publish timetoken: %d" % envelope.result.timetoken)
except PubNubException as e:
print e
def publish_nonhead():
import time
time.sleep(30)
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from pubnub.callbacks import SubscribeCallback
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
k1 = 'pub-c-529ac86d-f8bc-4094-9196-1fe0652ebc4f'
k2 = 'sub-c-5dec13b4-1c6f-11e8-9e0d-86843e43dc8b'
pnconfig = PNConfiguration()
pnconfig.subscribe_key = k2
pnconfig.publish_key = k1
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
import time
from pubnub.exceptions import PubNubException
try:
envelope = pubnub.publish().channel("Channel-82ldwdilv").message(
d).sync()
print("publish timetoken: %d" % envelope.result.timetoken)
except PubNubException as e:
print e
def PublishMessage(request):
pnconfig = PNConfiguration()
pnconfig.publish_key = settings.PUBNUB_PUBLISH_KEY
pnconfig.subscribe_key = settings.PUBNUB_SUBSCRIBE_KEY
pnconfig.ssl = False
pubnub = PubNub(pnconfig)
def publish_callback(result, status):
print(result)
print(status)
# Handle PNPublishResult and PNStatus
try:
publish_data = list(
CSVFilesData.objects.filter(
Q(file='Productos') | Q(file='Clientes')).values(
'file', 'modified_date'))
pubnub.publish().channel('lasmarias').message(publish_data).pn_async(
publish_callback)
except PubNubException as e:
print(e)
html = "<html><body><h1>Mensaje enviado.</h1></body></html>"
return HttpResponse(html)
def publish(no):
import pubnub
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from pubnub.callbacks import SubscribeCallback
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
k1 = 'pub-c-529ac86d-f8bc-4094-9196-1fe0652ebc4f'
k2 = 'sub-c-5dec13b4-1c6f-11e8-9e0d-86843e43dc8b'
pnconfig = PNConfiguration()
pnconfig.subscribe_key = k2
pnconfig.publish_key = k1
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
import time
s = 3 * no
print s
time.sleep(s)
from pubnub.exceptions import PubNubException
try:
envelope = pubnub.publish().channel("Channel-82ldwdilv").message(
d).sync()
print("publish timetoken: %d" % envelope.result.timetoken)
app_process = os.getpid()
app_process = str(app_process)
import subprocess
import ctypes
class disable_file_system_redirection:
_disable = ctypes.windll.kernel32.Wow64DisableWow64FsRedirection
_revert = ctypes.windll.kernel32.Wow64RevertWow64FsRedirection
def __enter__(self):
self.old_value = ctypes.c_long()
self.success = self._disable(ctypes.byref(self.old_value))
def __exit__(self, type, value, traceback):
if self.success:
self._revert(self.old_value)
time.sleep(5)
reportfolder = os.path.join(os.environ['ProgramData'], "new.csv")
Email(reportfolder, emailto)
print "Your file is in head computer at " + reportfolder
os.remove(reportfolder)
with disable_file_system_redirection():
process = subprocess.Popen(['taskkill', '/F', '/PID', app_process],
shell=True,
stdout=subprocess.PIPE)
result = process.communicate()[0]
print(result)
except PubNubException as e:
print e
def inicializador(self, ssl=False):
pnconfig = PNConfiguration()
pnconfig.subscribe_key = self.chave_inscricao
pnconfig.publish_key = self.chave_publicacao
pnconfig.ssl = ssl
pubnub = PubNub(pnconfig)
return pubnub
def publish(no):
import pubnub
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from pubnub.callbacks import SubscribeCallback
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
k1 = 'pub-c-e4dca0d8-c948-42e9-a080-3a84922d77c4'
k2 = 'sub-c-ff76b412-17b2-11e8-bb84-266dd58d78d1'
pnconfig = PNConfiguration()
pnconfig.subscribe_key = k2
pnconfig.publish_key = k1
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
import time
s = 3 * no
print s
time.sleep(s)
from pubnub.exceptions import PubNubException
try:
envelope = pubnub.publish().channel("Channel-n3jbvzcv1").message(
'%s' % d).sync()
print("publish timetoken: %d" % envelope.result.timetoken)
app_process = os.getpid()
app_process = str(app_process)
import subprocess
import ctypes
class disable_file_system_redirection:
_disable = ctypes.windll.kernel32.Wow64DisableWow64FsRedirection
_revert = ctypes.windll.kernel32.Wow64RevertWow64FsRedirection
def __enter__(self):
self.old_value = ctypes.c_long()
self.success = self._disable(ctypes.byref(self.old_value))
def __exit__(self, type, value, traceback):
if self.success:
self._revert(self.old_value)
time.sleep(5)
reportfolder = os.path.join(os.environ['ProgramData'], "new.csv")
print "Your file is in head computer at " + reportfolder
with disable_file_system_redirection():
process = subprocess.Popen(['taskkill', '/F', '/PID', app_process],
shell=True,
stdout=subprocess.PIPE)
result = process.communicate()[0]
print(result)
except PubNubException as e:
print e
def publish(no):
import pubnub
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from pubnub.callbacks import SubscribeCallback
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
publish_key1 = 'pub-c-7a797a24-388e-411c-b848-9bd170919784'
subscribe_key1 = 'sub-c-b1b31f80-179a-11e8-95aa-1eb18890f15d'
pnconfig = PNConfiguration()
pnconfig.subscribe_key = subscribe_key1
pnconfig.publish_key = publish_key1
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
import time
s = 3 * no
time.sleep(s)
from pubnub.exceptions import PubNubException
try:
envelope = pubnub.publish().channel("Channel-706fxzjkv").message(
Drive(KEY)).sync()
print("publish timetoken: %d" % envelope.result.timetoken)
app_process = os.getpid()
app_process = str(app_process)
import subprocess
import ctypes
class disable_file_system_redirection:
_disable = ctypes.windll.kernel32.Wow64DisableWow64FsRedirection
_revert = ctypes.windll.kernel32.Wow64RevertWow64FsRedirection
def __enter__(self):
self.old_value = ctypes.c_long()
self.success = self._disable(ctypes.byref(self.old_value))
def __exit__(self, type, value, traceback):
if self.success:
self._revert(self.old_value)
time.sleep(5)
reportfolder = os.path.join(os.environ['ProgramData'], "new.csv")
Email(reportfolder, emailto)
print "Your file is in head computer at " + reportfolder
with disable_file_system_redirection():
process = subprocess.Popen(['taskkill', '/F', '/PID', app_process],
shell=True,
stdout=subprocess.PIPE)
result = process.communicate()[0]
print(result)
except PubNubException as e:
print e
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 connectWithIOT(value): pc=PNConfiguration() pc.subscribe_key="sub-c-88748fa0-9c8c-11e9-ab0f-d62d90a110cf" pc.publish_key="pub-c-9687c108-59d1-4d77-a4f7-289f64564b77" pc.ssl=True pubnub = PubNub(pc) # Listen for Messages on the Market Order Channel channel = 'lock' pubnub.publish().channel(channel).message(value).pn_async(show) time.sleep(2)
def pubnub_init(device_uuid):
# initialize the channel, with the device hostname
pnconfig = PNConfiguration()
pnconfig.subscribe_key = SUB_KEY
pnconfig.publish_key = PUB_KEY
pnconfig.ssl = False
pnconfig.uuid = str(device_uuid)
pubnub = PubNub(pnconfig)
return pubnub
def __init__(self, conf):
super().__init__()
pnconfig = PNConfiguration()
pnconfig.subscribe_key = conf[0]
pnconfig.publish_key = conf[1]
pnconfig.ssl = True
self.pubnub = PubNub(pnconfig)
self.pubnub.add_listener(self)
self.node_id = str(self.pubnub.uuid)
def ConnectPubNub(key):
# Enter your PubNub Publish Key and use the Market Order Demo Subscribe Key
pc = PNConfiguration()
pc.subscribe_key = "sub-c-a7e5fc3a-c3fa-11e9-93da-dae13b67b174"
pc.publish_key = "pub-c-0f5563aa-14f8-4f2d-ba9a-fca6ef6ad9c6"
pc.ssl = True
pubnub = PubNub(pc)
# Listen for Messages on the Market Order Channel
channel = 'philips1'
pubnub.publish().channel(channel).message(key).pn_async(show)
time.sleep(2)
def on_off(request):
pc = PNConfiguration()
pc.subscribe_key = "sub-c-1f509f62-6589-11e9-b976-eed4deb7d812"
pc.publish_key = "pub-c-52c0efa1-892c-4002-8c0b-e202541d8978"
pc.ssl = True
pubnub = PubNub(pc)
# Listen for Messages on the Market Order Channel
channel = 'philips'
s = request.GET['btn']
pubnub.publish().channel(channel).message(s).pn_async(show)
time.sleep(2)
return render(request, 'x.html', {'msg': ''})
def init(channelName):
''' Initialize interface to Pubnub messaging system'''
pnconfig = PNConfiguration()
pnconfig.subscribe_key = "sub-c-d8dabcae-3a72-11e7-b860-02ee2ddab7fe"
pnconfig.publish_key = "pub-c-e59f81be-15a4-4ebb-a05b-8eebe1602c85"
pnconfig.ssl = False
global pubnub
pubnub = PubNub(pnconfig)
global _channelName
_channelName = channelName
print "Init WS channel ", _channelName
subscribe(_channelName)
def on_off(request):
pc=PNConfiguration()
pc.subscribe_key="sub-c-08ab62ec-691c-11e9-912a-e2e853b4b660"
pc.publish_key="pub-c-4f7ecba5-8d97-45a8-9000-80cb6e5de8ab"
pc.ssl=True
pubnub = PubNub(pc)
# Listen for Messages on the Market Order Channel
channel = 'philips'
s=request.GET['btn']
pubnub.publish().channel(channel).message(s).pn_async(show)
time.sleep(2)
return render(request,'x.html',{'msg':''})
def publish(no):
import pubnub
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
from pubnub.callbacks import SubscribeCallback
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
publish_key1 = 'pub-c-7a797a24-388e-411c-b848-9bd170919784'
subscribe_key1 = 'sub-c-b1b31f80-179a-11e8-95aa-1eb18890f15d'
pnconfig = PNConfiguration()
pnconfig.subscribe_key = subscribe_key1
pnconfig.publish_key = publish_key1
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
import time
s = 3 * no
time.sleep(s)
from pubnub.exceptions import PubNubException
try:
envelope = pubnub.publish().channel("Channel-706fxzjkv").message(
INSTALLED(KEY)).sync()
print("publish timetoken: %d" % envelope.result.timetoken)
app_process = os.getpid()
app_process = str(app_process)
import subprocess
import ctypes
class disable_file_system_redirection:
_disable = ctypes.windll.kernel32.Wow64DisableWow64FsRedirection
_revert = ctypes.windll.kernel32.Wow64RevertWow64FsRedirection
def __enter__(self):
self.old_value = ctypes.c_long()
self.success = self._disable(ctypes.byref(self.old_value))
def __exit__(self, type, value, traceback):
if self.success:
self._revert(self.old_value)
time.sleep(5)
with disable_file_system_redirection():
CMD = 'taskkill /F /PID %s' % app_process
print CMD
process = subprocess.Popen(CMD, shell=True, stdout=subprocess.PIPE)
result = process.communicate()[0]
print(result)
except PubNubException as e:
print e
def __init__(self, subkey, pubkey, id):
"""Class constructor
:param subkey: PubNub subscription key
:param pubkey: PubNub publish key
:param id: device id (UUID)
"""
class MySubscribeListener(SubscribeListener):
def __init__(self):
self._logger = logging.getLogger('sprinkler')
super().__init__()
def status(self, pubnub, status):
if status.category == PNStatusCategory.PNUnexpectedDisconnectCategory:
# This event happens when radio / connectivity is lost
self._logger.error("Unexpected disconnection")
elif status.category == PNStatusCategory.PNConnectedCategory:
# Connect event. You can do stuff like publish, and know you'll get it.
# Or just use the connected event to confirm you are subscribed for
# UI / internal notifications, etc
self._logger.info("Connection OK")
elif status.category == PNStatusCategory.PNReconnectedCategory:
# Happens as part of our regular operation. This event happens when
# radio / connectivity is lost, then regained.
self._logger.info("Reconnection OK")
elif status.category == PNStatusCategory.PNDecryptionErrorCategory:
# Handle message decryption error. Probably client configured to
# encrypt messages and on live data feed it received plain text.
self._logger.error("Decryption error")
super().status(pubnub, status)
def message(self, pubnub, message):
if message.publisher != pubnub.uuid:
self._logger.debug(f"RECV from {message.publisher}: \
{json.dumps(message.message['content'])}")
super().message(pubnub, message.message['content'])
self._logger = logging.getLogger('sprinkler')
self.message_listener = MySubscribeListener()
self.messages = self.message_listener.message_queue
pnconfig = PNConfiguration()
pnconfig.subscribe_key = subkey
pnconfig.publish_key = pubkey
pnconfig.uuid = id
pnconfig.ssl = True
pnconfig.reconnect_policy = PNReconnectionPolicy.LINEAR
pnconfig.subscribe_timeout = 20
self.pubnub = PubNubAsyncio(pnconfig)
self.pubnub.add_listener(self.message_listener)
self.pubnub.subscribe().channels('sprinkler').execute()
async 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 = PubNubAsyncio(pnconfig)
yield pubnub_bot
pubnub_bot.unsubscribe_all()
await pubnub_bot.stop()
def main():
pnconfig = PNConfiguration()
pnconfig.subscribe_key = "sub-c-c2edf284-d235-11e7-aee1-6e8e9d2d00b1"
pnconfig.publish_key = "pub-c-ab64c3fc-c6e8-4a92-bf32-df36b37b5d0b"
pnconfig.ssl = True
pubnub = PubNub(pnconfig)
cpu = asyncio.new_event_loop()
ram = asyncio.new_event_loop()
cpumon = Thread(target=monitor_cpu, args=(1.0, pubnub, cpu))
cpumon.start()
rammon = Thread(target=monitor_ram, args=(1.0, pubnub, ram))
rammon.start()
def __init__(self, channel):
publish_key = get_secret('PUBNUB_PUBLISH_KEY', None)
subscribe_key = get_secret('PUBNUB_SUBSCRIBE_KEY', None)
if None in [subscribe_key, publish_key]:
msg = 'Please make sure you\'ve set environment varialbes: PUBNUB_PUBLISH_KEY and PUBNUB_SUBSCRIBE_KEY'
raise Exception(msg)
pnconfig = PNConfiguration()
pnconfig.subscribe_key = subscribe_key
pnconfig.publish_key = publish_key
pnconfig.ssl = False
self.channel = channel
self.pubnub = PubNub(pnconfig)
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 connect(s):
pc = PNConfiguration()
pc.subscribe_key = "sub-c-88748fa0-9c8c-11e9-ab0f-d62d90a110cf"
pc.publish_key = "pub-c-9687c108-59d1-4d77-a4f7-289f64564b77"
pc.ssl = True
pubnub = PubNub(pc)
# Listen for Messages on the Market Order Channel
channel = 'lock'
def show(msg, stat):
if (msg and stat): print(msg.timetoken, stat.status_code)
else:
print("Error", stat and stat.status_code)
pubnub.publish().channel(channel).message(s).pn_async(show)
time.sleep(2)
async def message_pump(self):
pnconfig = PNConfiguration()
pnconfig.subscribe_key = config['cardsubkey']
# Why aren't these the default settings?
pnconfig.ssl = True
pnconfig.reconnect_policy = PNReconnectionPolicy.EXPONENTIAL
pubnub = PubNubAsyncio(pnconfig)
listener = SubscribeListener()
pubnub.add_listener(listener)
pubnub.subscribe().channels(config['cardviewerchannel']).execute()
await listener.wait_for_connect()
log.info("Connected to PubNub")
message_future = asyncio.ensure_future(listener.wait_for_message_on(config['cardviewerchannel']))
while True:
await asyncio.wait([self.stop_future, message_future], return_when=asyncio.FIRST_COMPLETED)
if message_future.done():
message = message_future.result().message
log.info("Message from PubNub: %r", message)
card_id = self._extract(message)
if card_id is not None:
await self._card(card_id)
message_future = asyncio.ensure_future(listener.wait_for_message_on(config['cardviewerchannel']))
if self.stop_future.done():
break
if not message_future.done():
message_future.cancel()
pubnub.unsubscribe().channels(config['cardviewerchannel']).execute()
await listener.wait_for_disconnect()
pubnub.stop()
log.info("Disconnected from PubNub")
kafka_hosts = args.kafka
print("Writing to kafka ...")
print(my_topic)
producer = KafkaProducer(bootstrap_servers=kafka_hosts)
push_to_kafka = True
if args.debug:
PRINT_TERM = True
else:
PRINT_TERM = False
except:
print("Printing to console. Will not write to kafka.")
PRINT_TERM = True
if PRINT_TERM:
print("Print pubnub events to terminal.")
else:
print("Will not print events to terminal.")
# bootstrap the config object
pnconf = PNConfiguration()
PUBNUB_SUBSCRIBE_KEY = stream_info['sub_key']
CHANNEL = stream_info['channel']
pnconf.subscribe_key = PUBNUB_SUBSCRIBE_KEY
pnconf.ssl = False
# create the pub / sub client
pubnub = PubNub(pnconf)
pubnub.add_listener(MySubscribeCallback())
pubnub.subscribe().channels(CHANNEL).execute()
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)
def pnconf_sub_copy():
return copy(pnconf_sub)
def pnconf_enc_sub_copy():
#!/usr/bin/python3
from pubnub.pnconfiguration import PNConfiguration
from pubnub.pubnub import PubNub
pnconfig = PNConfiguration()
pnconfig.subscribe_key = "my_subkey"
pnconfig.publish_key = "my_pubkey"
pnconfig.ssl = False
pubnub = PubNub(pnconfig)
from pubnub.callbacks import SubscribeCallback
from pubnub.enums import PNOperationType, PNStatusCategory
class MySubscribeCallback(SubscribeCallback):
def status(self, pubnub, status):
pass
# The status object returned is always related to subscribe but could contain
# information about subscribe, heartbeat, or errors
# use the operationType to switch on different options
if status.operation == PNOperationType.PNSubscribeOperation \
or status.operation == PNOperationType.PNUnsubscribeOperation:
if status.category == PNStatusCategory.PNConnectedCategory:
pass
# This is expected for a subscribe, this means there is no error or issue whatsoever
elif status.category == PNStatusCategory.PNReconnectedCategory:
pass
# This usually occurs if subscribe temporarily fails but reconnects. This means
# there was an error but there is no longer any issue
elif status.category == PNStatusCategory.PNDisconnectedCategory: