aboutsummaryrefslogtreecommitdiffstats
path: root/common
diff options
context:
space:
mode:
Diffstat (limited to 'common')
-rw-r--r--common/PubnubBase.py404
-rw-r--r--common/PubnubCore.py135
-rw-r--r--common/PubnubCoreAsync.py190
-rw-r--r--common/PubnubCrypto.py93
4 files changed, 822 insertions, 0 deletions
diff --git a/common/PubnubBase.py b/common/PubnubBase.py
new file mode 100644
index 0000000..07dd27f
--- /dev/null
+++ b/common/PubnubBase.py
@@ -0,0 +1,404 @@
+## www.pubnub.com - PubNub Real-time push service in the cloud.
+# coding=utf8
+
+## PubNub Real-time Push APIs and Notifications Framework
+## Copyright (c) 2010 Stephen Blum
+## http://www.pubnub.com/
+
+## -----------------------------------
+## PubNub 3.0 Real-time Push Cloud API
+## -----------------------------------
+
+try: import json
+except ImportError: import simplejson as json
+
+import time
+import hashlib
+import urllib2
+import uuid
+from PubnubCrypto import PubnubCrypto
+
+class PubnubBase(object):
+ def __init__(
+ self,
+ publish_key,
+ subscribe_key,
+ secret_key = False,
+ cipher_key = False,
+ ssl_on = False,
+ origin = 'pubsub.pubnub.com',
+ UUID = None
+ ) :
+ """
+ #**
+ #* Pubnub
+ #*
+ #* Init the Pubnub Client API
+ #*
+ #* @param string publish_key required key to send messages.
+ #* @param string subscribe_key required key to receive messages.
+ #* @param string secret_key optional key to sign messages.
+ #* @param boolean ssl required for 2048 bit encrypted messages.
+ #* @param string origin PUBNUB Server Origin.
+ #* @param string pres_uuid optional identifier for presence (auto-generated if not supplied)
+ #**
+
+ ## Initiat Class
+ pubnub = Pubnub( 'PUBLISH-KEY', 'SUBSCRIBE-KEY', 'SECRET-KEY', False )
+
+ """
+ self.origin = origin
+ self.limit = 1800
+ self.publish_key = publish_key
+ self.subscribe_key = subscribe_key
+ self.secret_key = secret_key
+ self.cipher_key = cipher_key
+ self.ssl = ssl_on
+
+ if self.ssl :
+ self.origin = 'https://' + self.origin
+ else :
+ self.origin = 'http://' + self.origin
+
+ self.uuid = UUID or str(uuid.uuid4())
+
+ if not isinstance(self.uuid, basestring):
+ raise AttributeError("pres_uuid must be a string")
+
+ def sign(self, channel, message):
+ ## Sign Message
+ if self.secret_key:
+ signature = hashlib.md5('/'.join([
+ self.publish_key,
+ self.subscribe_key,
+ self.secret_key,
+ channel,
+ message
+ ])).hexdigest()
+ else:
+ signature = '0'
+ return signature
+
+ def encrypt(self, message):
+ if self.cipher_key:
+ pc = PubnubCrypto()
+ out = []
+ if type( message ) == type(list()):
+ for item in message:
+ encryptItem = pc.encrypt(self.cipher_key, item ).rstrip()
+ out.append(encryptItem)
+ message = json.dumps(out)
+ elif type( message ) == type(dict()):
+ outdict = {}
+ for k, item in message.iteritems():
+ encryptItem = pc.encrypt(self.cipher_key, item ).rstrip()
+ outdict[k] = encryptItem
+ out.append(outdict)
+ message = json.dumps(out[0])
+ else:
+ message = json.dumps(pc.encrypt(self.cipher_key, json.dumps(message)).replace('\n',''))
+ else :
+ message = json.dumps(message)
+
+ return message;
+
+ def decrypt(self, message):
+ if self.cipher_key:
+ pc = PubnubCrypto()
+ if type( message ) == type(list()):
+ for item in message:
+ encryptItem = pc.decrypt(self.cipher_key, item )
+ out.append(encryptItem)
+ message = out
+ elif type( message ) == type(dict()):
+ outdict = {}
+ for k, item in message.iteritems():
+ encryptItem = pc.decrypt(self.cipher_key, item )
+ outdict[k] = encryptItem
+ out.append(outdict)
+ message = out[0]
+ else:
+ message = pc.decrypt(self.cipher_key, message)
+
+ return message
+
+
+ def publish( self, args ) :
+ """
+ #**
+ #* Publish
+ #*
+ #* Send a message to a channel.
+ #*
+ #* @param array args with channel and message.
+ #* @return array success information.
+ #**
+
+ ## Publish Example
+ info = pubnub.publish({
+ 'channel' : 'hello_world',
+ 'message' : {
+ 'some_text' : 'Hello my World'
+ }
+ })
+ print(info)
+
+ """
+ ## Fail if bad input.
+ if not (args['channel'] and args['message']) :
+ return [ 0, 'Missing Channel or Message' ]
+
+ ## Capture User Input
+ channel = str(args['channel'])
+
+ ## Capture Callback
+ if args.has_key('callback') :
+ callback = args['callback']
+ else :
+ callback = None
+
+ #message = json.dumps(args['message'], separators=(',',':'))
+ message = self.encrypt(args['message'])
+
+ signature = self.sign(channel, message)
+
+ ## Send Message
+ return self._request({"urlcomponents": [
+ 'publish',
+ self.publish_key,
+ self.subscribe_key,
+ signature,
+ channel,
+ '0',
+ message
+ ]}, callback)
+
+ def presence( self, args ) :
+ """
+ #**
+ #* presence
+ #*
+ #* This is BLOCKING.
+ #* Listen for presence events on a channel.
+ #*
+ #* @param array args with channel and callback.
+ #* @return false on fail, array on success.
+ #**
+
+ ## Presence Example
+ def pres_event(message) :
+ print(message)
+ return True
+
+ pubnub.presence({
+ 'channel' : 'hello_world',
+ 'callback' : receive
+ })
+ """
+
+ ## Fail if missing channel
+ if not 'channel' in args :
+ raise Exception('Missing Channel.')
+ return False
+
+ ## Fail if missing callback
+ if not 'callback' in args :
+ raise Exception('Missing Callback.')
+ return False
+
+ ## Capture User Input
+ channel = str(args['channel'])
+ callback = args['callback']
+ subscribe_key = args.get('subscribe_key') or self.subscribe_key
+
+ return self.subscribe({'channel': channel+'-pnpres', 'subscribe_key':subscribe_key, 'callback': callback})
+
+
+ def here_now( self, args ) :
+ """
+ #**
+ #* Here Now
+ #*
+ #* Load current occupancy from a channel.
+ #*
+ #* @param array args with 'channel'.
+ #* @return mixed false on fail, array on success.
+ #*
+
+ ## Presence Example
+ here_now = pubnub.here_now({
+ 'channel' : 'hello_world',
+ })
+ print(here_now['occupancy'])
+ print(here_now['uuids'])
+
+ """
+ channel = str(args['channel'])
+
+ ## Capture Callback
+ if args.has_key('callback') :
+ callback = args['callback']
+ else :
+ callback = None
+
+ ## Fail if bad input.
+ if not channel :
+ raise Exception('Missing Channel')
+ return False
+
+ ## Get Presence Here Now
+ return self._request({"urlcomponents": [
+ 'v2','presence',
+ 'sub_key', self.subscribe_key,
+ 'channel', channel
+ ]}, callback);
+
+
+ def history( self, args ) :
+ """
+ #**
+ #* History
+ #*
+ #* Load history from a channel.
+ #*
+ #* @param array args with 'channel' and 'limit'.
+ #* @return mixed false on fail, array on success.
+ #*
+
+ ## History Example
+ history = pubnub.history({
+ 'channel' : 'hello_world',
+ 'limit' : 1
+ })
+ print(history)
+
+ """
+ ## Capture User Input
+ limit = args.has_key('limit') and int(args['limit']) or 10
+ channel = str(args['channel'])
+
+ ## Fail if bad input.
+ if not channel :
+ raise Exception('Missing Channel')
+ return False
+
+ ## Capture Callback
+ if args.has_key('callback') :
+ callback = args['callback']
+ else :
+ callback = None
+
+ ## Get History
+ return self._request({ "urlcomponents" : [
+ 'history',
+ self.subscribe_key,
+ channel,
+ '0',
+ str(limit)
+ ] }, callback);
+
+ def detailedHistory(self, args) :
+ """
+ #**
+ #* Detailed History
+ #*
+ #* Load Detailed history from a channel.
+ #*
+ #* @param array args with 'channel', optional: 'start', 'end', 'reverse', 'count'
+ #* @return mixed false on fail, array on success.
+ #*
+
+ ## History Example
+ history = pubnub.detailedHistory({
+ 'channel' : 'hello_world',
+ 'count' : 5
+ })
+ print(history)
+
+ """
+ ## Capture User Input
+ channel = str(args['channel'])
+
+ params = []
+ count = 100
+
+ if args.has_key('count'):
+ count = int(args['count'])
+
+ params.append('count' + '=' + str(count))
+
+ if args.has_key('reverse'):
+ params.append('reverse' + '=' + str(args['reverse']).lower())
+
+ if args.has_key('start'):
+ params.append('start' + '=' + str(args['start']))
+
+ if args.has_key('end'):
+ params.append('end' + '=' + str(args['end']))
+
+ ## Fail if bad input.
+ if not channel :
+ raise Exception('Missing Channel')
+ return False
+
+ ## Capture Callback
+ if args.has_key('callback') :
+ callback = args['callback']
+ else :
+ callback = None
+
+ ## Get History
+ return self._request([
+ 'v2',
+ 'history',
+ 'sub-key',
+ self.subscribe_key,
+ 'channel',
+ channel,
+ ],params=params , callback=callback);
+
+ def time(self, args = None) :
+ """
+ #**
+ #* Time
+ #*
+ #* Timestamp from PubNub Cloud.
+ #*
+ #* @return int timestamp.
+ #*
+
+ ## PubNub Server Time Example
+ timestamp = pubnub.time()
+ print(timestamp)
+
+ """
+ ## Capture Callback
+ if args and args.has_key('callback') :
+ callback = args['callback']
+ else :
+ callback = None
+ time = self._request([
+ 'time',
+ '0'
+ ], callback)
+ if time != None:
+ return time[0]
+
+
+ def _encode( self, request ) :
+ return [
+ "".join([ ' ~`!@#$%^&*()+=[]\\{}|;\':",./<>?'.find(ch) > -1 and
+ hex(ord(ch)).replace( '0x', '%' ).upper() or
+ ch for ch in list(bit)
+ ]) for bit in request]
+
+ def getUrl(self,request):
+ ## Build URL
+ url = self.origin + '/' + "/".join([
+ "".join([ ' ~`!@#$%^&*()+=[]\\{}|;\':",./<>?'.find(ch) > -1 and
+ hex(ord(ch)).replace( '0x', '%' ).upper() or
+ ch for ch in list(bit)
+ ]) for bit in request["urlcomponents"]])
+ if (request.has_key("urlparams")):
+ url = url + '?' + "&".join([ x + "=" + y for x,y in request["urlparams"].items()])
+ return url
diff --git a/common/PubnubCore.py b/common/PubnubCore.py
new file mode 100644
index 0000000..4bf143b
--- /dev/null
+++ b/common/PubnubCore.py
@@ -0,0 +1,135 @@
+## www.pubnub.com - PubNub Real-time push service in the cloud.
+# coding=utf8
+
+## PubNub Real-time Push APIs and Notifications Framework
+## Copyright (c) 2010 Stephen Blum
+## http://www.pubnub.com/
+
+## -----------------------------------
+## PubNub 3.0 Real-time Push Cloud API
+## -----------------------------------
+
+try: import json
+except ImportError: import simplejson as json
+
+import time
+import hashlib
+import urllib2
+import uuid
+from PubnubBase import PubnubBase
+
+class PubnubCore(PubnubBase):
+ def __init__(
+ self,
+ publish_key,
+ subscribe_key,
+ secret_key = False,
+ cipher_key = False,
+ ssl_on = False,
+ origin = 'pubsub.pubnub.com',
+ uuid = None
+ ) :
+ """
+ #**
+ #* Pubnub
+ #*
+ #* Init the Pubnub Client API
+ #*
+ #* @param string publish_key required key to send messages.
+ #* @param string subscribe_key required key to receive messages.
+ #* @param string secret_key optional key to sign messages.
+ #* @param boolean ssl required for 2048 bit encrypted messages.
+ #* @param string origin PUBNUB Server Origin.
+ #* @param string pres_uuid optional identifier for presence (auto-generated if not supplied)
+ #**
+
+ ## Initiat Class
+ pubnub = Pubnub( 'PUBLISH-KEY', 'SUBSCRIBE-KEY', 'SECRET-KEY', False )
+
+ """
+ super(PubnubCore, self).__init__(
+ publish_key=publish_key,
+ subscribe_key=subscribe_key,
+ secret_key=secret_key,
+ cipher_key=cipher_key,
+ ssl_on=ssl_on,
+ origin=origin,
+ UUID=uuid
+ )
+
+ self.subscriptions = {}
+ self.timetoken = 0
+ self.version = '3.4'
+ self.accept_encoding = 'gzip'
+
+
+
+ def subscribe( self, args ) :
+ """
+ #**
+ #* Subscribe
+ #*
+ #* This is BLOCKING.
+ #* Listen for a message on a channel.
+ #*
+ #* @param array args with channel and callback.
+ #* @return false on fail, array on success.
+ #**
+
+ ## Subscribe Example
+ def receive(message) :
+ print(message)
+ return True
+
+ pubnub.subscribe({
+ 'channel' : 'hello_world',
+ 'callback' : receive
+ })
+
+ """
+
+ ## Fail if missing channel
+ if not 'channel' in args :
+ raise Exception('Missing Channel.')
+ return False
+
+ ## Fail if missing callback
+ if not 'callback' in args :
+ raise Exception('Missing Callback.')
+ return False
+
+ ## Capture User Input
+ channel = str(args['channel'])
+ callback = args['callback']
+ subscribe_key = args.get('subscribe_key') or self.subscribe_key
+
+ ## Begin Subscribe
+ while True :
+
+ timetoken = 'timetoken' in args and args['timetoken'] or 0
+ try :
+ ## Wait for Message
+ response = self._request(self._encode([
+ 'subscribe',
+ subscribe_key,
+ channel,
+ '0',
+ str(timetoken)
+ ])+['?uuid='+self.uuid], encode=False)
+
+ messages = response[0]
+ args['timetoken'] = response[1]
+
+ ## If it was a timeout
+ if not len(messages) :
+ continue
+
+ ## Run user Callback and Reconnect if user permits.
+ for message in messages :
+ if not callback(message) :
+ return
+
+ except Exception:
+ time.sleep(1)
+
+ return True
diff --git a/common/PubnubCoreAsync.py b/common/PubnubCoreAsync.py
new file mode 100644
index 0000000..9c53c6e
--- /dev/null
+++ b/common/PubnubCoreAsync.py
@@ -0,0 +1,190 @@
+## www.pubnub.com - PubNub Real-time push service in the cloud.
+# coding=utf8
+
+## PubNub Real-time Push APIs and Notifications Framework
+## Copyright (c) 2010 Stephen Blum
+## http://www.pubnub.com/
+
+## -----------------------------------
+## PubNub 3.1 Real-time Push Cloud API
+## -----------------------------------
+import sys
+import json
+import time
+import hashlib
+import urllib2
+import uuid
+try:
+ from hashlib import sha256
+ digestmod = sha256
+except ImportError:
+ import Crypto.Hash.SHA256 as digestmod
+ sha256 = digestmod.new
+import hmac
+from PubnubCrypto import PubnubCrypto
+from PubnubBase import PubnubBase
+
+class PubnubCoreAsync(PubnubBase):
+
+ def start(self): pass
+ def stop(self): pass
+ def timeout( self, delay, callback ):
+ pass
+
+ def __init__(
+ self,
+ publish_key,
+ subscribe_key,
+ secret_key = False,
+ cipher_key = False,
+ ssl_on = False,
+ origin = 'pubsub.pubnub.com',
+ uuid = None
+ ) :
+ """
+ #**
+ #* Pubnub
+ #*
+ #* Init the Pubnub Client API
+ #*
+ #* @param string publish_key required key to send messages.
+ #* @param string subscribe_key required key to receive messages.
+ #* @param string secret_key required key to sign messages.
+ #* @param boolean ssl required for 2048 bit encrypted messages.
+ #* @param string origin PUBNUB Server Origin.
+ #**
+
+ ## Initiat Class
+ pubnub = Pubnub( 'PUBLISH-KEY', 'SUBSCRIBE-KEY', 'SECRET-KEY', False )
+
+ """
+ super(PubnubCoreAsync, self).__init__(
+ publish_key=publish_key,
+ subscribe_key=subscribe_key,
+ secret_key=secret_key,
+ cipher_key=cipher_key,
+ ssl_on=ssl_on,
+ origin=origin,
+ UUID=uuid
+ )
+
+ self.subscriptions = {}
+ self.timetoken = 0
+ self.version = '3.4'
+ self.accept_encoding = 'gzip'
+
+ def subscribe( self, args ) :
+ """
+ #**
+ #* Subscribe
+ #*
+ #* This is NON-BLOCKING.
+ #* Listen for a message on a channel.
+ #*
+ #* @param array args with channel and message.
+ #* @return false on fail, array on success.
+ #**
+
+ ## Subscribe Example
+ def receive(message) :
+ print(message)
+ return True
+
+ ## On Connect Callback
+ def connected() :
+ pubnub.publish({
+ 'channel' : 'hello_world',
+ 'message' : { 'some_var' : 'text' }
+ })
+
+ ## Subscribe
+ pubnub.subscribe({
+ 'channel' : 'hello_world',
+ 'connect' : connected,
+ 'callback' : receive
+ })
+
+ """
+ ## Fail if missing channel
+ if not 'channel' in args :
+ return 'Missing Channel.'
+
+ ## Fail if missing callback
+ if not 'callback' in args :
+ return 'Missing Callback.'
+
+ ## Capture User Input
+ channel = str(args['channel'])
+ callback = args['callback']
+ connectcb = args['connect']
+
+ if 'errorback' in args:
+ errorback = args['errorback']
+ else:
+ errorback = lambda x: x
+
+ ## New Channel?
+ if not (channel in self.subscriptions) :
+ self.subscriptions[channel] = {
+ 'first' : False,
+ 'connected' : False,
+ }
+
+ ## Ensure Single Connection
+ if self.subscriptions[channel]['connected'] :
+ return "Already Connected"
+
+ self.subscriptions[channel]['connected'] = 1
+ ## SUBSCRIPTION RECURSION
+ def _subscribe():
+ ## STOP CONNECTION?
+ if not self.subscriptions[channel]['connected']:
+ return
+
+ def sub_callback(response):
+ print response
+ response = json.loads(response)
+ ## STOP CONNECTION?
+ if not self.subscriptions[channel]['connected']:
+ return
+
+ ## CONNECTED CALLBACK
+ if not self.subscriptions[channel]['first'] :
+ self.subscriptions[channel]['first'] = True
+ connectcb()
+
+ ## PROBLEM?
+ if not response:
+ def time_callback(_time):
+ if not _time:
+ self.timeout( 1, _subscribe )
+ return errorback("Lost Network Connection")
+ else:
+ self.timeout( 1, _subscribe)
+
+ ## ENSURE CONNECTED (Call Time Function)
+ return self.time({ 'callback' : time_callback })
+
+ self.timetoken = response[1]
+ _subscribe()
+
+ pc = PubnubCrypto()
+ out = []
+ for message in response[0]:
+ callback(self.decrypt(message))
+
+ ## CONNECT TO PUBNUB SUBSCRIBE SERVERS
+ try:
+ self._request( { "urlcomponents" : [
+ 'subscribe',
+ self.subscribe_key,
+ channel,
+ '0',
+ str(self.timetoken)
+ ], "urlparams" : {"uuid":self.uuid} }, sub_callback )
+ except :
+ self.timeout( 1, _subscribe)
+ return
+
+ ## BEGIN SUBSCRIPTION (LISTEN FOR MESSAGES)
+ _subscribe()
diff --git a/common/PubnubCrypto.py b/common/PubnubCrypto.py
new file mode 100644
index 0000000..b7a57a1
--- /dev/null
+++ b/common/PubnubCrypto.py
@@ -0,0 +1,93 @@
+## www.pubnub.com - PubNub Real-time push service in the cloud.
+# coding=utf8
+
+## PubNub Real-time Push APIs and Notifications Framework
+## Copyright (c) 2010 Stephen Blum
+## http://www.pubnub.com/
+
+## -----------------------------------
+## PubNub 3.1 Real-time Push Cloud API
+## -----------------------------------
+
+from Crypto.Cipher import AES
+from Crypto.Hash import MD5
+from base64 import encodestring, decodestring
+import hashlib
+import hmac
+
+class PubnubCrypto() :
+ """
+ #**
+ #* PubnubCrypto
+ #*
+ #**
+
+ ## Initiate Class
+ pc = PubnubCrypto
+
+ """
+
+ def pad( self, msg, block_size=16 ):
+ """
+ #**
+ #* pad
+ #*
+ #* pad the text to be encrypted
+ #* appends a padding character to the end of the String
+ #* until the string has block_size length
+ #* @return msg with padding.
+ #**
+ """
+ padding = block_size - (len(msg) % block_size)
+ return msg + chr(padding)*padding
+
+ def depad( self, msg ):
+ """
+ #**
+ #* depad
+ #*
+ #* depad the decryptet message"
+ #* @return msg without padding.
+ #**
+ """
+ return msg[0:-ord(msg[-1])]
+
+ def getSecret( self, key ):
+ """
+ #**
+ #* getSecret
+ #*
+ #* hases the key to MD5
+ #* @return key in MD5 format
+ #**
+ """
+ return hashlib.sha256(key).hexdigest()
+
+ def encrypt( self, key, msg ):
+ """
+ #**
+ #* encrypt
+ #*
+ #* encrypts the message
+ #* @return message in encrypted format
+ #**
+ """
+ secret = self.getSecret(key)
+ Initial16bytes='0123456789012345'
+ cipher = AES.new(secret[0:32],AES.MODE_CBC,Initial16bytes)
+ enc = encodestring(cipher.encrypt(self.pad(msg)))
+ return enc
+ def decrypt( self, key, msg ):
+ """
+ #**
+ #* decrypt
+ #*
+ #* decrypts the message
+ #* @return message in decryped format
+ #**
+ """
+ secret = self.getSecret(key)
+ Initial16bytes='0123456789012345'
+ cipher = AES.new(secret[0:32],AES.MODE_CBC,Initial16bytes)
+ return self.depad((cipher.decrypt(decodestring(msg))))
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-31 20:12:02 +0000