From 493e29a108255eb3ae3166dc920f40e2f4e5c4c4 Mon Sep 17 00:00:00 2001 From: Devendra Date: Thu, 24 Apr 2014 00:16:57 +0530 Subject: adding single file for all platforms --- Pubnub.py | 2405 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2405 insertions(+) create mode 100644 Pubnub.py (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py new file mode 100644 index 0000000..bd00709 --- /dev/null +++ b/Pubnub.py @@ -0,0 +1,2405 @@ +try: + import json +except ImportError: + import simplejson as json + +import time +import hashlib +import uuid +import sys + +try: + from urllib.parse import quote +except ImportError: + from urllib2 import quote + +from base64 import urlsafe_b64encode +from hashlib import sha256 + + +import hmac + + + +from Crypto.Cipher import AES +from Crypto.Hash import MD5 +from base64 import encodestring, decodestring +import hashlib +import hmac + + +class PubnubCrypto2(): + """ + #** + #* 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)))) + + +class PubnubCrypto3(): + """ + #** + #* 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).encode('utf-8') + + 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.encode("utf-8")).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) + return encodestring( + cipher.encrypt(self.pad(msg.encode('utf-8')))).decode('utf-8') + + 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 (cipher.decrypt( + decodestring(msg.encode('utf-8')))).decode('utf-8') + + +class PubnubBase(object): + def __init__( + self, + publish_key, + subscribe_key, + secret_key=False, + cipher_key=False, + auth_key=None, + 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 + self.auth_key = auth_key + + if self.ssl: + self.origin = 'https://' + self.origin + else: + self.origin = 'http://' + self.origin + + self.uuid = UUID or str(uuid.uuid4()) + + if type(sys.version_info) is tuple: + self.python_version = 2 + self.pc = PubnubCrypto2() + else: + if sys.version_info.major == 2: + self.python_version = 2 + self.pc = PubnubCrypto2() + else: + self.python_version = 3 + self.pc = PubnubCrypto3() + + if not isinstance(self.uuid, str): + 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 _pam_sign(self, msg): + """Calculate a signature by secret key and message.""" + + return urlsafe_b64encode(hmac.new( + self.secret_key.encode("utf-8"), + msg.encode("utf-8"), + sha256 + ).digest()) + + def _pam_auth(self, query, apicode=0, callback=None): + """Issue an authenticated request.""" + + if 'timestamp' not in query: + query['timestamp'] = int(time.time()) + + ## Global Grant? + if 'auth' in query and not query['auth']: + del query['auth'] + + if 'channel' in query and not query['channel']: + del query['channel'] + + params = "&".join([ + x + "=" + quote( + str(query[x]), safe="" + ) for x in sorted(query) + ]) + sign_input = "{subkey}\n{pubkey}\n{apitype}\n{params}".format( + subkey=self.subscribe_key, + pubkey=self.publish_key, + apitype="audit" if (apicode) else "grant", + params=params + ) + + query['signature'] = self._pam_sign(sign_input) + + return self._request({"urlcomponents": [ + 'v1', 'auth', "audit" if (apicode) else "grant", + 'sub-key', + self.subscribe_key + ], 'urlparams': query}, + self._return_wrapped_callback(callback)) + + def grant(self, channel, authkey=False, read=True, + write=True, ttl=5, callback=None): + """Grant Access on a Channel.""" + + return self._pam_auth({ + "channel": channel, + "auth": authkey, + "r": read and 1 or 0, + "w": write and 1 or 0, + "ttl": ttl + }, callback=callback) + + def revoke(self, channel, authkey=False, ttl=1, callback=None): + """Revoke Access on a Channel.""" + + return self._pam_auth({ + "channel": channel, + "auth": authkey, + "r": 0, + "w": 0, + "ttl": ttl + }, callback=callback) + + def audit(self, channel=False, authkey=False, callback=None): + return self._pam_auth({ + "channel": channel, + "auth": authkey + }, 1, callback=callback) + + def encrypt(self, message): + if self.cipher_key: + message = json.dumps(self.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: + message = self.pc.decrypt(self.cipher_key, message) + + return message + + def _return_wrapped_callback(self, callback=None): + def _new_format_callback(response): + if 'payload' in response: + if (callback is not None): + callback({'message': response['message'], + 'payload': response['payload']}) + else: + if (callback is not None): + callback(response) + if (callback is not None): + return _new_format_callback + else: + return None + + def publish(channel, message, callback=None, error=None): + """ + #** + #* 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) + + """ + + message = self.encrypt(message) + + ## Send Message + return self._request({"urlcomponents": [ + 'publish', + self.publish_key, + self.subscribe_key, + '0', + channel, + '0', + message + ], 'urlparams': {'auth': self.auth_key}}, + callback=self._return_wrapped_callback(callback), + error=self._return_wrapped_callback(error)) + + def presence(self, channel, callback, error=None): + """ + #** + #* 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 + }) + """ + return self.subscribe({ + 'channel': channel + '-pnpres', + 'subscribe_key': self.subscribe_key, + 'callback': self._return_wrapped_callback(callback)}) + + def here_now(self, channel, callback, error=None): + """ + #** + #* 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']) + + """ + + ## Get Presence Here Now + return self._request({"urlcomponents": [ + 'v2', 'presence', + 'sub_key', self.subscribe_key, + 'channel', channel + ], 'urlparams': {'auth': self.auth_key}}, + callback=self._return_wrapped_callback(callback), + error=self._return_wrapped_callback(error)) + + def history(self, channel, count=100, reverse=False, + start=None, end=None, callback=None, error=None): + """ + #** + #* History + #* + #* Load history from a channel. + #* + + ## History Example + history = pubnub.detailedHistory({ + 'channel' : 'hello_world', + 'count' : 5 + }) + print(history) + + """ + + params = dict() + + params['count'] = count + params['reverse'] = reverse + params['start'] = start + params['end'] = end + + ## Get History + return self._request({'urlcomponents': [ + 'v2', + 'history', + 'sub-key', + self.subscribe_key, + 'channel', + channel, + ], 'urlparams': {'auth': self.auth_key}}, + callback=self._return_wrapped_callback(callback), + error=self._return_wrapped_callback(error)) + + def time(self, callback=None): + """ + #** + #* Time + #* + #* Timestamp from PubNub Cloud. + #* + #* @return int timestamp. + #* + + ## PubNub Server Time Example + timestamp = pubnub.time() + print(timestamp) + + """ + + time = self._request({'urlcomponents': [ + 'time', + '0' + ]}, callback) + if time is not 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 ("urlparams" in request): + url = url + '?' + "&".join([x + "=" + str(y) for x, y in request[ + "urlparams"].items() if y is not None]) + return url + + +try: + from hashlib import sha256 + digestmod = sha256 +except ImportError: + import Crypto.Hash.SHA256 as digestmod + sha256 = digestmod.new +import hmac + + +class EmptyLock(): + def __enter__(self): + pass + + def __exit__(self, a, b, c): + pass + +empty_lock = EmptyLock() + + +class PubnubCoreAsync(PubnubBase): + + def start(self): + pass + + def stop(self): + pass + + def __init__( + self, + publish_key, + subscribe_key, + secret_key=False, + cipher_key=False, + auth_key=None, + ssl_on=False, + origin='pubsub.pubnub.com', + uuid=None, + _tt_lock=empty_lock, + _channel_list_lock=empty_lock + ): + """ + #** + #* 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, + auth_key=auth_key, + ssl_on=ssl_on, + origin=origin, + UUID=uuid + ) + + self.subscriptions = {} + self.timetoken = 0 + self.last_timetoken = 0 + self.version = '3.3.4' + self.accept_encoding = 'gzip' + self.SUB_RECEIVER = None + self._connect = None + self._tt_lock = _tt_lock + self._channel_list_lock = _channel_list_lock + self._connect = lambda: None + + def get_channel_list(self, channels): + channel = '' + first = True + with self._channel_list_lock: + for ch in channels: + if not channels[ch]['subscribed']: + continue + if not first: + channel += ',' + else: + first = False + channel += ch + return channel + + def get_channel_array(self): + channels = self.subscriptions + channel = [] + with self._channel_list_lock: + for ch in channels: + if not channels[ch]['subscribed']: + continue + channel.append(ch) + return channel + + def each(l, func): + if func is None: + return + for i in l: + func(i) + + def subscribe(self, channel, callback, error=None, + connect=None, disconnect=None, reconnect=None, sync=False): + """ + #** + #* 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 + }) + + """ + + with self._tt_lock: + self.last_timetoken = self.timetoken if self.timetoken != 0 \ + else self.last_timetoken + self.timetoken = 0 + + if sync is True and self.susbcribe_sync is not None: + self.susbcribe_sync(args) + return + + def _invoke(func, msg=None): + if func is not None: + if msg is not None: + func(msg) + else: + func() + + def _invoke_connect(): + if self._channel_list_lock: + with self._channel_list_lock: + for ch in self.subscriptions: + chobj = self.subscriptions[ch] + if chobj['connected'] is False: + chobj['connected'] = True + _invoke(chobj['connect'], chobj['name']) + + def _invoke_error(channel_list=None, err=None): + if channel_list is None: + for ch in self.subscriptions: + chobj = self.subscriptions[ch] + _invoke(chobj['error'], err) + else: + for ch in channel_list: + chobj = self.subscriptions[ch] + _invoke(chobj['error'], err) + + def _get_channel(): + for ch in self.subscriptions: + chobj = self.subscriptions[ch] + if chobj['subscribed'] is True: + return chobj + + ## New Channel? + if not channel in self.subscriptions or \ + self.subscriptions[channel]['subscribed'] is False: + with self._channel_list_lock: + self.subscriptions[channel] = { + 'name': channel, + 'first': False, + 'connected': False, + 'subscribed': True, + 'callback': callback, + 'connect': connect, + 'disconnect': disconnect, + 'reconnect': reconnect, + 'error': error + } + + ## return if already connected to channel + if channel in self.subscriptions and \ + 'connected' in self.subscriptions[channel] and \ + self.subscriptions[channel]['connected'] is True: + _invoke(error, "Already Connected") + return + + ## SUBSCRIPTION RECURSION + def _connect(): + + self._reset_offline() + + def error_callback(response): + ## ERROR ? + if not response or \ + ('message' in response and + response['message'] == 'Forbidden'): + _invoke_error(response['payload'][ + 'channels'], response['message']) + _connect() + return + if 'message' in response: + _invoke_error(err=response['message']) + + + def sub_callback(response): + ## ERROR ? + if not response or \ + ('message' in response and + response['message'] == 'Forbidden'): + _invoke_error(response['payload'][ + 'channels'], response['message']) + _connect() + return + + _invoke_connect() + + with self._tt_lock: + self.timetoken = \ + self.last_timetoken if self.timetoken == 0 and \ + self.last_timetoken != 0 else response[1] + if len(response) > 2: + channel_list = response[2].split(',') + response_list = response[0] + for ch in enumerate(channel_list): + if ch[1] in self.subscriptions: + chobj = self.subscriptions[ch[1]] + _invoke(chobj['callback'], + self.decrypt(response_list[ch[0]])) + else: + response_list = response[0] + chobj = _get_channel() + for r in response_list: + if chobj: + _invoke(chobj['callback'], self.decrypt(r)) + + _connect() + + channel_list = self.get_channel_list(self.subscriptions) + if len(channel_list) <= 0: + return + + ## CONNECT TO PUBNUB SUBSCRIBE SERVERS + #try: + self.SUB_RECEIVER = self._request({"urlcomponents": [ + 'subscribe', + self.subscribe_key, + channel_list, + '0', + str(self.timetoken) + ], "urlparams": {"uuid": self.uuid, "auth": self.auth_key}}, + sub_callback, + error_callback, + single=True) + ''' + except Exception as e: + print(e) + self.timeout(1, _connect) + return + ''' + + self._connect = _connect + + ## BEGIN SUBSCRIPTION (LISTEN FOR MESSAGES) + _connect() + + def _reset_offline(self): + if self.SUB_RECEIVER is not None: + self.SUB_RECEIVER() + self.SUB_RECEIVER = None + + def CONNECT(self): + self._reset_offline() + self._connect() + + def unsubscribe(self, channel): + + if channel in self.subscriptions is False: + return False + + ## DISCONNECT + with self._channel_list_lock: + if channel in self.subscriptions: + self.subscriptions[channel]['connected'] = 0 + self.subscriptions[channel]['subscribed'] = False + self.subscriptions[channel]['timetoken'] = 0 + self.subscriptions[channel]['first'] = False + self.CONNECT() + + +class PubnubCore(PubnubCoreAsync): + def __init__( + self, + publish_key, + subscribe_key, + secret_key=False, + cipher_key=False, + auth_key=None, + 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, + auth_key=auth_key, + ssl_on=ssl_on, + origin=origin, + UUID=uuid + ) + + self.subscriptions = {} + self.timetoken = 0 + self.version = '3.4' + self.accept_encoding = 'gzip' + + def subscribe_sync(self, channel, callback, timetoken=0): + """ + #** + #* 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 + }) + + """ + + subscribe_key = self.subscribe_key + + ## Begin Subscribe + while True: + + try: + ## Wait for Message + response = self._request({"urlcomponents": [ + 'subscribe', + subscribe_key, + channel, + '0', + str(timetoken) + ], "urlparams": {"uuid": self.uuid}}) + + messages = response[0] + 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(self.decrypt(message)): + return + + except Exception: + time.sleep(1) + + return True + + +try: + import urllib.request +except ImportError: + import urllib2 + +import threading +import json +import time +import threading +from threading import current_thread + +latest_sub_callback_lock = threading.RLock() +latest_sub_callback = {'id': None, 'callback': None} + + +class HTTPClient: + def __init__(self, url, urllib_func=None, + callback=None, error=None, id=None): + self.url = url + self.id = id + self.callback = callback + self.error = error + self.stop = False + self._urllib_func = urllib_func + + def cancel(self): + self.stop = True + self.callback = None + self.error = None + + def run(self): + + def _invoke(func, data): + if func is not None: + func(data) + + if self._urllib_func is None: + return + + ''' + try: + resp = urllib2.urlopen(self.url, timeout=320) + except urllib2.HTTPError as http_error: + resp = http_error + ''' + resp = self._urllib_func(self.url, timeout=320) + data = resp[0] + code = resp[1] + + if self.stop is True: + return + if self.callback is None: + global latest_sub_callback + global latest_sub_callback_lock + with latest_sub_callback_lock: + if latest_sub_callback['id'] != self.id: + return + else: + if latest_sub_callback['callback'] is not None: + latest_sub_callback['id'] = 0 + print data + try: + data = json.loads(data) + except ValueError as e: + _invoke(latest_sub_callback['error'], + {'error': 'json decoding error'}) + return + print code + if code != 200: + print 'ERROR' + _invoke(latest_sub_callback['error'], data) + else: + print 'CALLBACK' + _invoke(latest_sub_callback['callback'], data) + else: + try: + data = json.loads(data) + except ValueError: + _invoke(self.error, {'error': 'json decoding error'}) + return + + if code != 200: + _invoke(self.error, data) + else: + _invoke(self.callback, data) + + +def _urllib_request_2(url, timeout=320): + try: + resp = urllib2.urlopen(url, timeout=timeout) + except urllib2.HTTPError as http_error: + resp = http_error + except urllib2.URLError as error: + #print error.reason + msg = { "message" : str(error.reason)} + #print str(msg) + return (json.dumps(msg),0) + + return (resp.read(), resp.code) + + +def _urllib_request_3(url, timeout=320): + #print(url) + try: + resp = urllib.request.urlopen(url, timeout=timeout) + except (urllib.request.HTTPError, urllib.request.URLError) as http_error: + resp = http_error + r = resp.read().decode("utf-8") + #print(r) + return (r, resp.code) + +_urllib_request = None + + +class PubnubAsync(PubnubCoreAsync): + def __init__( + self, + publish_key, + subscribe_key, + secret_key=False, + cipher_key=False, + auth_key=None, + ssl_on=False, + origin='pubsub.pubnub.com', + pres_uuid=None + ): + super(Pubnub, self).__init__( + publish_key=publish_key, + subscribe_key=subscribe_key, + secret_key=secret_key, + cipher_key=cipher_key, + auth_key=auth_key, + ssl_on=ssl_on, + origin=origin, + uuid=pres_uuid, + _tt_lock=threading.RLock(), + _channel_list_lock=threading.RLock() + ) + global _urllib_request + if self.python_version == 2: + _urllib_request = _urllib_request_2 + else: + _urllib_request = _urllib_request_3 + + def timeout(self, interval, func): + def cb(): + time.sleep(interval) + func() + thread = threading.Thread(target=cb) + thread.start() + + def _request_async(self, request, callback=None, error=None, single=False): + global _urllib_request + ## Build URL + url = self.getUrl(request) + if single is True: + id = time.time() + client = HTTPClient(url=url, urllib_func=_urllib_request, + callback=None, error=None, id=id) + with latest_sub_callback_lock: + latest_sub_callback['id'] = id + latest_sub_callback['callback'] = callback + latest_sub_callback['error'] = error + else: + client = HTTPClient(url=url, urllib_func=_urllib_request, + callback=callback, error=error) + + thread = threading.Thread(target=client.run) + thread.start() + + def abort(): + client.cancel() + return abort + + def _request_sync(self, request): + global _urllib_request + ## Build URL + url = self.getUrl(request) + ## Send Request Expecting JSONP Response + response = _urllib_request(url, timeout=320) + try: + resp_json = json.loads(response[0]) + except ValueError: + return [0, "JSON Error"] + + if response[1] != 200 and 'status' in resp_json: + return {'message': resp_json['message'], + 'payload': resp_json['payload']} + + return resp_json + + def _request(self, request, callback=None, error=None, single=False): + if callback is None: + return self._request_sync(request) + else: + self._request_async(request, callback, error, single=single) + +''' + + def _request3_sync( self, request) : + ## Build URL + url = self.getUrl(request) + ## Send Request Expecting JSONP Response + try: + response = urllib.request.urlopen(url,timeout=310) + resp_json = json.loads(response.read().decode("utf-8")) + except Exception as e: + return None + + return resp_json + + def _request3_async( self, request, callback, single=False ) : + pass + + def _request3(self, request, callback=None, single=False): + if callback is None: + return self._request3_sync(request,single=single) + else: + self._request3_async(request, callback, single=single) + ''' + + +import tornado.httpclient + +try: + from hashlib import sha256 + digestmod = sha256 +except ImportError: + import Crypto.Hash.SHA256 as digestmod + sha256 = digestmod.new + +import hmac +import tornado.ioloop +from tornado.stack_context import ExceptionStackContext + +ioloop = tornado.ioloop.IOLoop.instance() + + +class PubnubTornado(PubnubCoreAsync): + + def stop(self): + ioloop.stop() + + def start(self): + ioloop.start() + + def timeout(self, delay, callback): + ioloop.add_timeout(time.time() + float(delay), callback) + + def __init__( + self, + publish_key, + subscribe_key, + secret_key=False, + cipher_key=False, + auth_key=False, + ssl_on=False, + origin='pubsub.pubnub.com' + ): + super(Pubnub, self).__init__( + publish_key=publish_key, + subscribe_key=subscribe_key, + secret_key=secret_key, + cipher_key=cipher_key, + auth_key=auth_key, + ssl_on=ssl_on, + origin=origin, + ) + self.headers = {} + self.headers['User-Agent'] = 'Python-Tornado' + self.headers['Accept-Encoding'] = self.accept_encoding + self.headers['V'] = self.version + self.http = tornado.httpclient.AsyncHTTPClient(max_clients=1000) + self.id = None + + def _request(self, request, callback=None, error=None, + single=False, read_timeout=5, connect_timeout=5): + + def _invoke(func, data): + if func is not None: + func(data) + + url = self.getUrl(request) + request = tornado.httpclient.HTTPRequest( + url, 'GET', + self.headers, + connect_timeout=connect_timeout, + request_timeout=read_timeout) + if single is True: + id = time.time() + self.id = id + + def responseCallback(response): + if single is True: + if not id == self.id: + return None + + body = response._get_body() + + if body is None: + return + + def handle_exc(*args): + return True + if response.error is not None: + with ExceptionStackContext(handle_exc): + if response.code in [403, 401]: + response.rethrow() + else: + _invoke(error, {"message": response.reason}) + return + + try: + data = json.loads(body) + except TypeError as e: + try: + data = json.loads(body.decode("utf-8")) + except ValueError as ve: + _invoke(error, {'error': 'json decode error'}) + + if 'error' in data and 'status' in data and 'status' != 200: + _invoke(error, data) + else: + _invoke(callback, data) + + self.http.fetch( + request=request, + callback=responseCallback + ) + + def abort(): + pass + + return abort + +## 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.3.5 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 PubnubCrypto2(): + """ + #** + #* 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)))) + + +class PubnubCrypto3(): + """ + #** + #* 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).encode('utf-8') + + 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.encode("utf-8")).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) + return encodestring( + cipher.encrypt(self.pad(msg.encode('utf-8')))).decode('utf-8') + + 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 (cipher.decrypt( + decodestring(msg.encode('utf-8')))).decode('utf-8') + + +try: + import json +except ImportError: + import simplejson as json + +import time +import hashlib +import uuid +import sys + +try: + from urllib.parse import quote +except ImportError: + from urllib2 import quote + +from base64 import urlsafe_b64encode +from hashlib import sha256 + + +import hmac + + +class PubnubBase(object): + def __init__( + self, + publish_key, + subscribe_key, + secret_key=False, + cipher_key=False, + auth_key=None, + 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 + self.auth_key = auth_key + + if self.ssl: + self.origin = 'https://' + self.origin + else: + self.origin = 'http://' + self.origin + + self.uuid = UUID or str(uuid.uuid4()) + + if type(sys.version_info) is tuple: + self.python_version = 2 + self.pc = PubnubCrypto2() + else: + if sys.version_info.major == 2: + self.python_version = 2 + self.pc = PubnubCrypto2() + else: + self.python_version = 3 + self.pc = PubnubCrypto3() + + if not isinstance(self.uuid, str): + 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 _pam_sign(self, msg): + """Calculate a signature by secret key and message.""" + + return urlsafe_b64encode(hmac.new( + self.secret_key.encode("utf-8"), + msg.encode("utf-8"), + sha256 + ).digest()) + + def _pam_auth(self, query, apicode=0, callback=None): + """Issue an authenticated request.""" + + if 'timestamp' not in query: + query['timestamp'] = int(time.time()) + + ## Global Grant? + if 'auth' in query and not query['auth']: + del query['auth'] + + if 'channel' in query and not query['channel']: + del query['channel'] + + params = "&".join([ + x + "=" + quote( + str(query[x]), safe="" + ) for x in sorted(query) + ]) + sign_input = "{subkey}\n{pubkey}\n{apitype}\n{params}".format( + subkey=self.subscribe_key, + pubkey=self.publish_key, + apitype="audit" if (apicode) else "grant", + params=params + ) + + query['signature'] = self._pam_sign(sign_input) + + return self._request({"urlcomponents": [ + 'v1', 'auth', "audit" if (apicode) else "grant", + 'sub-key', + self.subscribe_key + ], 'urlparams': query}, + self._return_wrapped_callback(callback)) + + def grant(self, channel, authkey=False, read=True, + write=True, ttl=5, callback=None): + """Grant Access on a Channel.""" + + return self._pam_auth({ + "channel": channel, + "auth": authkey, + "r": read and 1 or 0, + "w": write and 1 or 0, + "ttl": ttl + }, callback=callback) + + def revoke(self, channel, authkey=False, ttl=1, callback=None): + """Revoke Access on a Channel.""" + + return self._pam_auth({ + "channel": channel, + "auth": authkey, + "r": 0, + "w": 0, + "ttl": ttl + }, callback=callback) + + def audit(self, channel=False, authkey=False, callback=None): + return self._pam_auth({ + "channel": channel, + "auth": authkey + }, 1, callback=callback) + + def encrypt(self, message): + if self.cipher_key: + message = json.dumps(self.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: + message = self.pc.decrypt(self.cipher_key, message) + + return message + + def _return_wrapped_callback(self, callback=None): + def _new_format_callback(response): + if 'payload' in response: + if (callback is not None): + callback({'message': response['message'], + 'payload': response['payload']}) + else: + if (callback is not None): + callback(response) + if (callback is not None): + return _new_format_callback + else: + return None + + def publish(channel, message, callback=None, error=None): + """ + #** + #* 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) + + """ + + message = self.encrypt(message) + + ## Send Message + return self._request({"urlcomponents": [ + 'publish', + self.publish_key, + self.subscribe_key, + '0', + channel, + '0', + message + ], 'urlparams': {'auth': self.auth_key}}, + callback=self._return_wrapped_callback(callback), + error=self._return_wrapped_callback(error)) + + def presence(self, channel, callback, error=None): + """ + #** + #* 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 + }) + """ + return self.subscribe({ + 'channel': channel + '-pnpres', + 'subscribe_key': self.subscribe_key, + 'callback': self._return_wrapped_callback(callback)}) + + def here_now(self, channel, callback, error=None): + """ + #** + #* 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']) + + """ + + ## Get Presence Here Now + return self._request({"urlcomponents": [ + 'v2', 'presence', + 'sub_key', self.subscribe_key, + 'channel', channel + ], 'urlparams': {'auth': self.auth_key}}, + callback=self._return_wrapped_callback(callback), + error=self._return_wrapped_callback(error)) + + def history(self, channel, count=100, reverse=False, + start=None, end=None, callback=None, error=None): + """ + #** + #* History + #* + #* Load history from a channel. + #* + + ## History Example + history = pubnub.detailedHistory({ + 'channel' : 'hello_world', + 'count' : 5 + }) + print(history) + + """ + + params = dict() + + params['count'] = count + params['reverse'] = reverse + params['start'] = start + params['end'] = end + + ## Get History + return self._request({'urlcomponents': [ + 'v2', + 'history', + 'sub-key', + self.subscribe_key, + 'channel', + channel, + ], 'urlparams': {'auth': self.auth_key}}, + callback=self._return_wrapped_callback(callback), + error=self._return_wrapped_callback(error)) + + def time(self, callback=None): + """ + #** + #* Time + #* + #* Timestamp from PubNub Cloud. + #* + #* @return int timestamp. + #* + + ## PubNub Server Time Example + timestamp = pubnub.time() + print(timestamp) + + """ + + time = self._request({'urlcomponents': [ + 'time', + '0' + ]}, callback) + if time is not 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 ("urlparams" in request): + url = url + '?' + "&".join([x + "=" + str(y) for x, y in request[ + "urlparams"].items() if y is not None]) + return url + + +try: + from hashlib import sha256 + digestmod = sha256 +except ImportError: + import Crypto.Hash.SHA256 as digestmod + sha256 = digestmod.new +import hmac + + +class EmptyLock(): + def __enter__(self): + pass + + def __exit__(self, a, b, c): + pass + +empty_lock = EmptyLock() + + +class PubnubCoreAsync(PubnubBase): + + def start(self): + pass + + def stop(self): + pass + + def __init__( + self, + publish_key, + subscribe_key, + secret_key=False, + cipher_key=False, + auth_key=None, + ssl_on=False, + origin='pubsub.pubnub.com', + uuid=None, + _tt_lock=empty_lock, + _channel_list_lock=empty_lock + ): + """ + #** + #* 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, + auth_key=auth_key, + ssl_on=ssl_on, + origin=origin, + UUID=uuid + ) + + self.subscriptions = {} + self.timetoken = 0 + self.last_timetoken = 0 + self.version = '3.3.4' + self.accept_encoding = 'gzip' + self.SUB_RECEIVER = None + self._connect = None + self._tt_lock = _tt_lock + self._channel_list_lock = _channel_list_lock + self._connect = lambda: None + + def get_channel_list(self, channels): + channel = '' + first = True + with self._channel_list_lock: + for ch in channels: + if not channels[ch]['subscribed']: + continue + if not first: + channel += ',' + else: + first = False + channel += ch + return channel + + def get_channel_array(self): + channels = self.subscriptions + channel = [] + with self._channel_list_lock: + for ch in channels: + if not channels[ch]['subscribed']: + continue + channel.append(ch) + return channel + + def each(l, func): + if func is None: + return + for i in l: + func(i) + + def subscribe(self, channel, callback, error=None, + connect=None, disconnect=None, reconnect=None, sync=False): + """ + #** + #* 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 + }) + + """ + + with self._tt_lock: + self.last_timetoken = self.timetoken if self.timetoken != 0 \ + else self.last_timetoken + self.timetoken = 0 + + if sync is True and self.susbcribe_sync is not None: + self.susbcribe_sync(args) + return + + def _invoke(func, msg=None): + if func is not None: + if msg is not None: + func(msg) + else: + func() + + def _invoke_connect(): + if self._channel_list_lock: + with self._channel_list_lock: + for ch in self.subscriptions: + chobj = self.subscriptions[ch] + if chobj['connected'] is False: + chobj['connected'] = True + _invoke(chobj['connect'], chobj['name']) + + def _invoke_error(channel_list=None, err=None): + if channel_list is None: + for ch in self.subscriptions: + chobj = self.subscriptions[ch] + _invoke(chobj['error'], err) + else: + for ch in channel_list: + chobj = self.subscriptions[ch] + _invoke(chobj['error'], err) + + def _get_channel(): + for ch in self.subscriptions: + chobj = self.subscriptions[ch] + if chobj['subscribed'] is True: + return chobj + + ## New Channel? + if not channel in self.subscriptions or \ + self.subscriptions[channel]['subscribed'] is False: + with self._channel_list_lock: + self.subscriptions[channel] = { + 'name': channel, + 'first': False, + 'connected': False, + 'subscribed': True, + 'callback': callback, + 'connect': connect, + 'disconnect': disconnect, + 'reconnect': reconnect, + 'error': error + } + + ## return if already connected to channel + if channel in self.subscriptions and \ + 'connected' in self.subscriptions[channel] and \ + self.subscriptions[channel]['connected'] is True: + _invoke(error, "Already Connected") + return + + ## SUBSCRIPTION RECURSION + def _connect(): + + self._reset_offline() + + def sub_callback(response): + ## ERROR ? + if not response or \ + ('message' in response and + response['message'] == 'Forbidden'): + _invoke_error(response['payload'][ + 'channels'], response['message']) + _connect() + return + + _invoke_connect() + + with self._tt_lock: + self.timetoken = \ + self.last_timetoken if self.timetoken == 0 and \ + self.last_timetoken != 0 else response[1] + if len(response) > 2: + channel_list = response[2].split(',') + response_list = response[0] + for ch in enumerate(channel_list): + if ch[1] in self.subscriptions: + chobj = self.subscriptions[ch[1]] + _invoke(chobj['callback'], + self.decrypt(response_list[ch[0]])) + else: + response_list = response[0] + chobj = _get_channel() + for r in response_list: + if chobj: + _invoke(chobj['callback'], self.decrypt(r)) + + _connect() + + channel_list = self.get_channel_list(self.subscriptions) + if len(channel_list) <= 0: + return + + ## CONNECT TO PUBNUB SUBSCRIBE SERVERS + #try: + self.SUB_RECEIVER = self._request({"urlcomponents": [ + 'subscribe', + self.subscribe_key, + channel_list, + '0', + str(self.timetoken) + ], "urlparams": {"uuid": self.uuid, "auth": self.auth_key}}, + sub_callback, + sub_callback, + single=True) + ''' + except Exception as e: + print(e) + self.timeout(1, _connect) + return + ''' + + self._connect = _connect + + ## BEGIN SUBSCRIPTION (LISTEN FOR MESSAGES) + _connect() + + def _reset_offline(self): + if self.SUB_RECEIVER is not None: + self.SUB_RECEIVER() + self.SUB_RECEIVER = None + + def CONNECT(self): + self._reset_offline() + self._connect() + + def unsubscribe(self, channel): + + if channel in self.subscriptions is False: + return False + + ## DISCONNECT + with self._channel_list_lock: + if channel in self.subscriptions: + self.subscriptions[channel]['connected'] = 0 + self.subscriptions[channel]['subscribed'] = False + self.subscriptions[channel]['timetoken'] = 0 + self.subscriptions[channel]['first'] = False + self.CONNECT() + + +try: + from twisted.web.client import getPage + from twisted.internet import reactor + from twisted.internet.defer import Deferred + from twisted.internet.protocol import Protocol + from twisted.web.client import Agent, ContentDecoderAgent + from twisted.web.client import RedirectAgent, GzipDecoder + from twisted.web.client import HTTPConnectionPool + from twisted.web.http_headers import Headers + from twisted.internet.ssl import ClientContextFactory + from twisted.internet.task import LoopingCall + import twisted + + from twisted.python.compat import ( + _PY3, unicode, intToBytes, networkString, nativeString) + + pnconn_pool = HTTPConnectionPool(reactor, persistent=True) + pnconn_pool.maxPersistentPerHost = 100000 + pnconn_pool.cachedConnectionTimeout = 15 + pnconn_pool.retryAutomatically = True +except ImportError: + pass + +from hashlib import sha256 +import time +import json + +import traceback + + + + +class PubnubTwisted(PubnubCoreAsync): + + def start(self): + reactor.run() + + def stop(self): + reactor.stop() + + def timeout(self, delay, callback): + reactor.callLater(delay, callback) + + def __init__( + self, + publish_key, + subscribe_key, + secret_key=False, + cipher_key=False, + auth_key=None, + ssl_on=False, + origin='pubsub.pubnub.com' + ): + super(Pubnub, self).__init__( + publish_key=publish_key, + subscribe_key=subscribe_key, + secret_key=secret_key, + cipher_key=cipher_key, + auth_key=auth_key, + ssl_on=ssl_on, + origin=origin, + ) + self.headers = {} + self.headers['User-Agent'] = ['Python-Twisted'] + #self.headers['Accept-Encoding'] = [self.accept_encoding] + self.headers['V'] = [self.version] + + def _request(self, request, callback=None, error=None, single=False): + global pnconn_pool + + def _invoke(func, data): + if func is not None: + func(data) + + ## Build URL + + url = self.getUrl(request) + + agent = ContentDecoderAgent(RedirectAgent(Agent( + reactor, + contextFactory=WebClientContextFactory(), + pool=self.ssl and None or pnconn_pool + )), [('gzip', GzipDecoder)]) + + try: + request = agent.request( + 'GET', url, Headers(self.headers), None) + except TypeError as te: + request = agent.request( + 'GET', url.encode(), Headers(self.headers), None) + + if single is True: + id = time.time() + self.id = id + + def received(response): + if not isinstance(response, twisted.web._newclient.Response): + _invoke(error, {"message" : "Not Found"}) + return + + finished = Deferred() + if response.code in [401,403]: + response.deliverBody(PubNubPamResponse(finished)) + else: + response.deliverBody(PubNubResponse(finished)) + + return finished + + def complete(data): + if single is True: + if id != self.id: + return None + try: + data = json.loads(data) + except ValueError as e: + try: + data = json.loads(data.decode("utf-8")) + except ValueError as e: + _invoke(error, {'error': 'json decode error'}) + + if 'error' in data and 'status' in data and 'status' != 200: + _invoke(error, data) + else: + _invoke(callback, data) + + def abort(): + pass + + request.addCallback(received) + request.addCallback(complete) + + return abort + + +class WebClientContextFactory(ClientContextFactory): + def getContext(self, hostname, port): + return ClientContextFactory.getContext(self) + + +class PubNubPamResponse(Protocol): + def __init__(self, finished): + self.finished = finished + + def dataReceived(self, bytes): + self.finished.callback(bytes) + + +class PubNubResponse(Protocol): + def __init__(self, finished): + self.finished = finished + + def dataReceived(self, bytes): + self.finished.callback(bytes) + + +import tornado.httpclient + +try: + from hashlib import sha256 + digestmod = sha256 +except ImportError: + import Crypto.Hash.SHA256 as digestmod + sha256 = digestmod.new + +try: + import hmac + import tornado.ioloop + from tornado.stack_context import ExceptionStackContext + ioloop = tornado.ioloop.IOLoop.instance() +except ImportError: + pass + + +class PubnubTornado(PubnubCoreAsync): + + def stop(self): + ioloop.stop() + + def start(self): + ioloop.start() + + def timeout(self, delay, callback): + ioloop.add_timeout(time.time() + float(delay), callback) + + def __init__( + self, + publish_key, + subscribe_key, + secret_key=False, + cipher_key=False, + auth_key=False, + ssl_on=False, + origin='pubsub.pubnub.com' + ): + super(PubnubTornado, self).__init__( + publish_key=publish_key, + subscribe_key=subscribe_key, + secret_key=secret_key, + cipher_key=cipher_key, + auth_key=auth_key, + ssl_on=ssl_on, + origin=origin, + ) + self.headers = {} + self.headers['User-Agent'] = 'Python-Tornado' + self.headers['Accept-Encoding'] = self.accept_encoding + self.headers['V'] = self.version + self.http = tornado.httpclient.AsyncHTTPClient(max_clients=1000) + self.id = None + + def _request(self, request, callback=None, error=None, + single=False, read_timeout=5, connect_timeout=5): + + def _invoke(func, data): + if func is not None: + func(data) + + url = self.getUrl(request) + request = tornado.httpclient.HTTPRequest( + url, 'GET', + self.headers, + connect_timeout=connect_timeout, + request_timeout=read_timeout) + if single is True: + id = time.time() + self.id = id + + def responseCallback(response): + if single is True: + if not id == self.id: + return None + + body = response._get_body() + + if body is None: + return + + def handle_exc(*args): + return True + if response.error is not None: + with ExceptionStackContext(handle_exc): + if response.code in [403, 401]: + response.rethrow() + else: + _invoke(error, {"message": response.reason}) + return + + try: + data = json.loads(body) + except TypeError as e: + try: + data = json.loads(body.decode("utf-8")) + except ValueError as ve: + _invoke(error, {'error': 'json decode error'}) + + if 'error' in data and 'status' in data and 'status' != 200: + _invoke(error, data) + else: + _invoke(callback, data) + + self.http.fetch( + request=request, + callback=responseCallback + ) + + def abort(): + pass + + return abort + -- cgit v1.2.3 From c98286f500b77dcf426367df0b688f536b77ea9b Mon Sep 17 00:00:00 2001 From: Devendra Date: Thu, 24 Apr 2014 01:33:45 +0530 Subject: fixing imports --- Pubnub.py | 853 +------------------------------------------------------------- 1 file changed, 3 insertions(+), 850 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index bd00709..92a6822 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -1077,7 +1077,7 @@ class PubnubAsync(PubnubCoreAsync): origin='pubsub.pubnub.com', pres_uuid=None ): - super(Pubnub, self).__init__( + super(PubnubAsync, self).__init__( publish_key=publish_key, subscribe_key=subscribe_key, secret_key=secret_key, @@ -1210,7 +1210,7 @@ class PubnubTornado(PubnubCoreAsync): ssl_on=False, origin='pubsub.pubnub.com' ): - super(Pubnub, self).__init__( + super(PubnubTornado, self).__init__( publish_key=publish_key, subscribe_key=subscribe_key, secret_key=secret_key, @@ -1286,853 +1286,6 @@ class PubnubTornado(PubnubCoreAsync): return abort -## 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.3.5 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 PubnubCrypto2(): - """ - #** - #* 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)))) - - -class PubnubCrypto3(): - """ - #** - #* 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).encode('utf-8') - - 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.encode("utf-8")).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) - return encodestring( - cipher.encrypt(self.pad(msg.encode('utf-8')))).decode('utf-8') - - 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 (cipher.decrypt( - decodestring(msg.encode('utf-8')))).decode('utf-8') - - -try: - import json -except ImportError: - import simplejson as json - -import time -import hashlib -import uuid -import sys - -try: - from urllib.parse import quote -except ImportError: - from urllib2 import quote - -from base64 import urlsafe_b64encode -from hashlib import sha256 - - -import hmac - - -class PubnubBase(object): - def __init__( - self, - publish_key, - subscribe_key, - secret_key=False, - cipher_key=False, - auth_key=None, - 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 - self.auth_key = auth_key - - if self.ssl: - self.origin = 'https://' + self.origin - else: - self.origin = 'http://' + self.origin - - self.uuid = UUID or str(uuid.uuid4()) - - if type(sys.version_info) is tuple: - self.python_version = 2 - self.pc = PubnubCrypto2() - else: - if sys.version_info.major == 2: - self.python_version = 2 - self.pc = PubnubCrypto2() - else: - self.python_version = 3 - self.pc = PubnubCrypto3() - - if not isinstance(self.uuid, str): - 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 _pam_sign(self, msg): - """Calculate a signature by secret key and message.""" - - return urlsafe_b64encode(hmac.new( - self.secret_key.encode("utf-8"), - msg.encode("utf-8"), - sha256 - ).digest()) - - def _pam_auth(self, query, apicode=0, callback=None): - """Issue an authenticated request.""" - - if 'timestamp' not in query: - query['timestamp'] = int(time.time()) - - ## Global Grant? - if 'auth' in query and not query['auth']: - del query['auth'] - - if 'channel' in query and not query['channel']: - del query['channel'] - - params = "&".join([ - x + "=" + quote( - str(query[x]), safe="" - ) for x in sorted(query) - ]) - sign_input = "{subkey}\n{pubkey}\n{apitype}\n{params}".format( - subkey=self.subscribe_key, - pubkey=self.publish_key, - apitype="audit" if (apicode) else "grant", - params=params - ) - - query['signature'] = self._pam_sign(sign_input) - - return self._request({"urlcomponents": [ - 'v1', 'auth', "audit" if (apicode) else "grant", - 'sub-key', - self.subscribe_key - ], 'urlparams': query}, - self._return_wrapped_callback(callback)) - - def grant(self, channel, authkey=False, read=True, - write=True, ttl=5, callback=None): - """Grant Access on a Channel.""" - - return self._pam_auth({ - "channel": channel, - "auth": authkey, - "r": read and 1 or 0, - "w": write and 1 or 0, - "ttl": ttl - }, callback=callback) - - def revoke(self, channel, authkey=False, ttl=1, callback=None): - """Revoke Access on a Channel.""" - - return self._pam_auth({ - "channel": channel, - "auth": authkey, - "r": 0, - "w": 0, - "ttl": ttl - }, callback=callback) - - def audit(self, channel=False, authkey=False, callback=None): - return self._pam_auth({ - "channel": channel, - "auth": authkey - }, 1, callback=callback) - - def encrypt(self, message): - if self.cipher_key: - message = json.dumps(self.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: - message = self.pc.decrypt(self.cipher_key, message) - - return message - - def _return_wrapped_callback(self, callback=None): - def _new_format_callback(response): - if 'payload' in response: - if (callback is not None): - callback({'message': response['message'], - 'payload': response['payload']}) - else: - if (callback is not None): - callback(response) - if (callback is not None): - return _new_format_callback - else: - return None - - def publish(channel, message, callback=None, error=None): - """ - #** - #* 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) - - """ - - message = self.encrypt(message) - - ## Send Message - return self._request({"urlcomponents": [ - 'publish', - self.publish_key, - self.subscribe_key, - '0', - channel, - '0', - message - ], 'urlparams': {'auth': self.auth_key}}, - callback=self._return_wrapped_callback(callback), - error=self._return_wrapped_callback(error)) - - def presence(self, channel, callback, error=None): - """ - #** - #* 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 - }) - """ - return self.subscribe({ - 'channel': channel + '-pnpres', - 'subscribe_key': self.subscribe_key, - 'callback': self._return_wrapped_callback(callback)}) - - def here_now(self, channel, callback, error=None): - """ - #** - #* 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']) - - """ - - ## Get Presence Here Now - return self._request({"urlcomponents": [ - 'v2', 'presence', - 'sub_key', self.subscribe_key, - 'channel', channel - ], 'urlparams': {'auth': self.auth_key}}, - callback=self._return_wrapped_callback(callback), - error=self._return_wrapped_callback(error)) - - def history(self, channel, count=100, reverse=False, - start=None, end=None, callback=None, error=None): - """ - #** - #* History - #* - #* Load history from a channel. - #* - - ## History Example - history = pubnub.detailedHistory({ - 'channel' : 'hello_world', - 'count' : 5 - }) - print(history) - - """ - - params = dict() - - params['count'] = count - params['reverse'] = reverse - params['start'] = start - params['end'] = end - - ## Get History - return self._request({'urlcomponents': [ - 'v2', - 'history', - 'sub-key', - self.subscribe_key, - 'channel', - channel, - ], 'urlparams': {'auth': self.auth_key}}, - callback=self._return_wrapped_callback(callback), - error=self._return_wrapped_callback(error)) - - def time(self, callback=None): - """ - #** - #* Time - #* - #* Timestamp from PubNub Cloud. - #* - #* @return int timestamp. - #* - - ## PubNub Server Time Example - timestamp = pubnub.time() - print(timestamp) - - """ - - time = self._request({'urlcomponents': [ - 'time', - '0' - ]}, callback) - if time is not 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 ("urlparams" in request): - url = url + '?' + "&".join([x + "=" + str(y) for x, y in request[ - "urlparams"].items() if y is not None]) - return url - - -try: - from hashlib import sha256 - digestmod = sha256 -except ImportError: - import Crypto.Hash.SHA256 as digestmod - sha256 = digestmod.new -import hmac - - -class EmptyLock(): - def __enter__(self): - pass - - def __exit__(self, a, b, c): - pass - -empty_lock = EmptyLock() - - -class PubnubCoreAsync(PubnubBase): - - def start(self): - pass - - def stop(self): - pass - - def __init__( - self, - publish_key, - subscribe_key, - secret_key=False, - cipher_key=False, - auth_key=None, - ssl_on=False, - origin='pubsub.pubnub.com', - uuid=None, - _tt_lock=empty_lock, - _channel_list_lock=empty_lock - ): - """ - #** - #* 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, - auth_key=auth_key, - ssl_on=ssl_on, - origin=origin, - UUID=uuid - ) - - self.subscriptions = {} - self.timetoken = 0 - self.last_timetoken = 0 - self.version = '3.3.4' - self.accept_encoding = 'gzip' - self.SUB_RECEIVER = None - self._connect = None - self._tt_lock = _tt_lock - self._channel_list_lock = _channel_list_lock - self._connect = lambda: None - - def get_channel_list(self, channels): - channel = '' - first = True - with self._channel_list_lock: - for ch in channels: - if not channels[ch]['subscribed']: - continue - if not first: - channel += ',' - else: - first = False - channel += ch - return channel - - def get_channel_array(self): - channels = self.subscriptions - channel = [] - with self._channel_list_lock: - for ch in channels: - if not channels[ch]['subscribed']: - continue - channel.append(ch) - return channel - - def each(l, func): - if func is None: - return - for i in l: - func(i) - - def subscribe(self, channel, callback, error=None, - connect=None, disconnect=None, reconnect=None, sync=False): - """ - #** - #* 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 - }) - - """ - - with self._tt_lock: - self.last_timetoken = self.timetoken if self.timetoken != 0 \ - else self.last_timetoken - self.timetoken = 0 - - if sync is True and self.susbcribe_sync is not None: - self.susbcribe_sync(args) - return - - def _invoke(func, msg=None): - if func is not None: - if msg is not None: - func(msg) - else: - func() - - def _invoke_connect(): - if self._channel_list_lock: - with self._channel_list_lock: - for ch in self.subscriptions: - chobj = self.subscriptions[ch] - if chobj['connected'] is False: - chobj['connected'] = True - _invoke(chobj['connect'], chobj['name']) - - def _invoke_error(channel_list=None, err=None): - if channel_list is None: - for ch in self.subscriptions: - chobj = self.subscriptions[ch] - _invoke(chobj['error'], err) - else: - for ch in channel_list: - chobj = self.subscriptions[ch] - _invoke(chobj['error'], err) - - def _get_channel(): - for ch in self.subscriptions: - chobj = self.subscriptions[ch] - if chobj['subscribed'] is True: - return chobj - - ## New Channel? - if not channel in self.subscriptions or \ - self.subscriptions[channel]['subscribed'] is False: - with self._channel_list_lock: - self.subscriptions[channel] = { - 'name': channel, - 'first': False, - 'connected': False, - 'subscribed': True, - 'callback': callback, - 'connect': connect, - 'disconnect': disconnect, - 'reconnect': reconnect, - 'error': error - } - - ## return if already connected to channel - if channel in self.subscriptions and \ - 'connected' in self.subscriptions[channel] and \ - self.subscriptions[channel]['connected'] is True: - _invoke(error, "Already Connected") - return - - ## SUBSCRIPTION RECURSION - def _connect(): - - self._reset_offline() - - def sub_callback(response): - ## ERROR ? - if not response or \ - ('message' in response and - response['message'] == 'Forbidden'): - _invoke_error(response['payload'][ - 'channels'], response['message']) - _connect() - return - - _invoke_connect() - - with self._tt_lock: - self.timetoken = \ - self.last_timetoken if self.timetoken == 0 and \ - self.last_timetoken != 0 else response[1] - if len(response) > 2: - channel_list = response[2].split(',') - response_list = response[0] - for ch in enumerate(channel_list): - if ch[1] in self.subscriptions: - chobj = self.subscriptions[ch[1]] - _invoke(chobj['callback'], - self.decrypt(response_list[ch[0]])) - else: - response_list = response[0] - chobj = _get_channel() - for r in response_list: - if chobj: - _invoke(chobj['callback'], self.decrypt(r)) - - _connect() - - channel_list = self.get_channel_list(self.subscriptions) - if len(channel_list) <= 0: - return - - ## CONNECT TO PUBNUB SUBSCRIBE SERVERS - #try: - self.SUB_RECEIVER = self._request({"urlcomponents": [ - 'subscribe', - self.subscribe_key, - channel_list, - '0', - str(self.timetoken) - ], "urlparams": {"uuid": self.uuid, "auth": self.auth_key}}, - sub_callback, - sub_callback, - single=True) - ''' - except Exception as e: - print(e) - self.timeout(1, _connect) - return - ''' - - self._connect = _connect - - ## BEGIN SUBSCRIPTION (LISTEN FOR MESSAGES) - _connect() - - def _reset_offline(self): - if self.SUB_RECEIVER is not None: - self.SUB_RECEIVER() - self.SUB_RECEIVER = None - - def CONNECT(self): - self._reset_offline() - self._connect() - - def unsubscribe(self, channel): - - if channel in self.subscriptions is False: - return False - - ## DISCONNECT - with self._channel_list_lock: - if channel in self.subscriptions: - self.subscriptions[channel]['connected'] = 0 - self.subscriptions[channel]['subscribed'] = False - self.subscriptions[channel]['timetoken'] = 0 - self.subscriptions[channel]['first'] = False - self.CONNECT() - - try: from twisted.web.client import getPage from twisted.internet import reactor @@ -2186,7 +1339,7 @@ class PubnubTwisted(PubnubCoreAsync): ssl_on=False, origin='pubsub.pubnub.com' ): - super(Pubnub, self).__init__( + super(PubnubTwisted, self).__init__( publish_key=publish_key, subscribe_key=subscribe_key, secret_key=secret_key, -- cgit v1.2.3 From 98242257846e9276dd83adbea950f83e25a4f2b6 Mon Sep 17 00:00:00 2001 From: Devendra Date: Thu, 24 Apr 2014 02:07:56 +0530 Subject: pep8 compliance, removing redundant files --- Pubnub.py | 295 +++++++++++++++++--------------------------------------------- 1 file changed, 81 insertions(+), 214 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 92a6822..1802774 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -1,3 +1,17 @@ + +## 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.3.4 Real-time Push Cloud API +## ----------------------------------- + + + try: import json except ImportError: @@ -7,25 +21,75 @@ import time import hashlib import uuid import sys +from base64 import urlsafe_b64encode +import hmac +from Crypto.Cipher import AES +from Crypto.Hash import MD5 + +try: + from hashlib import sha256 + digestmod = sha256 +except ImportError: + import Crypto.Hash.SHA256 as digestmod + sha256 = digestmod.new + + +##### vanilla python imports ##### try: from urllib.parse import quote except ImportError: from urllib2 import quote +try: + import urllib.request +except ImportError: + import urllib2 -from base64 import urlsafe_b64encode -from hashlib import sha256 +import threading +from threading import current_thread -import hmac +################################## +##### Tornado imports and globals ##### +try: + import tornado.httpclient + import tornado.ioloop + from tornado.stack_context import ExceptionStackContext + ioloop = tornado.ioloop.IOLoop.instance() +except ImportError: + pass -from Crypto.Cipher import AES -from Crypto.Hash import MD5 -from base64 import encodestring, decodestring -import hashlib -import hmac +####################################### + + +##### Twisted imports and globals ##### +try: + from twisted.web.client import getPage + from twisted.internet import reactor + from twisted.internet.defer import Deferred + from twisted.internet.protocol import Protocol + from twisted.web.client import Agent, ContentDecoderAgent + from twisted.web.client import RedirectAgent, GzipDecoder + from twisted.web.client import HTTPConnectionPool + from twisted.web.http_headers import Headers + from twisted.internet.ssl import ClientContextFactory + from twisted.internet.task import LoopingCall + import twisted + + from twisted.python.compat import ( + _PY3, unicode, intToBytes, networkString, nativeString) + + pnconn_pool = HTTPConnectionPool(reactor, persistent=True) + pnconn_pool.maxPersistentPerHost = 100000 + pnconn_pool.cachedConnectionTimeout = 15 + pnconn_pool.retryAutomatically = True +except ImportError: + pass + + +####################################### class PubnubCrypto2(): @@ -246,23 +310,6 @@ class PubnubBase(object): if not isinstance(self.uuid, str): 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 _pam_sign(self, msg): """Calculate a signature by secret key and message.""" @@ -537,15 +584,6 @@ class PubnubBase(object): return url -try: - from hashlib import sha256 - digestmod = sha256 -except ImportError: - import Crypto.Hash.SHA256 as digestmod - sha256 = digestmod.new -import hmac - - class EmptyLock(): def __enter__(self): pass @@ -760,7 +798,6 @@ class PubnubCoreAsync(PubnubBase): return if 'message' in response: _invoke_error(err=response['message']) - def sub_callback(response): ## ERROR ? @@ -951,17 +988,6 @@ class PubnubCore(PubnubCoreAsync): return True -try: - import urllib.request -except ImportError: - import urllib2 - -import threading -import json -import time -import threading -from threading import current_thread - latest_sub_callback_lock = threading.RLock() latest_sub_callback = {'id': None, 'callback': None} @@ -1045,10 +1071,10 @@ def _urllib_request_2(url, timeout=320): resp = http_error except urllib2.URLError as error: #print error.reason - msg = { "message" : str(error.reason)} + msg = {"message": str(error.reason)} #print str(msg) - return (json.dumps(msg),0) - + return (json.dumps(msg), 0) + return (resp.read(), resp.code) @@ -1065,6 +1091,8 @@ def _urllib_request_3(url, timeout=320): _urllib_request = None +# PubnubAsync + class PubnubAsync(PubnubCoreAsync): def __init__( self, @@ -1173,150 +1201,7 @@ class PubnubAsync(PubnubCoreAsync): ''' -import tornado.httpclient - -try: - from hashlib import sha256 - digestmod = sha256 -except ImportError: - import Crypto.Hash.SHA256 as digestmod - sha256 = digestmod.new - -import hmac -import tornado.ioloop -from tornado.stack_context import ExceptionStackContext - -ioloop = tornado.ioloop.IOLoop.instance() - - -class PubnubTornado(PubnubCoreAsync): - - def stop(self): - ioloop.stop() - - def start(self): - ioloop.start() - - def timeout(self, delay, callback): - ioloop.add_timeout(time.time() + float(delay), callback) - - def __init__( - self, - publish_key, - subscribe_key, - secret_key=False, - cipher_key=False, - auth_key=False, - ssl_on=False, - origin='pubsub.pubnub.com' - ): - super(PubnubTornado, self).__init__( - publish_key=publish_key, - subscribe_key=subscribe_key, - secret_key=secret_key, - cipher_key=cipher_key, - auth_key=auth_key, - ssl_on=ssl_on, - origin=origin, - ) - self.headers = {} - self.headers['User-Agent'] = 'Python-Tornado' - self.headers['Accept-Encoding'] = self.accept_encoding - self.headers['V'] = self.version - self.http = tornado.httpclient.AsyncHTTPClient(max_clients=1000) - self.id = None - - def _request(self, request, callback=None, error=None, - single=False, read_timeout=5, connect_timeout=5): - - def _invoke(func, data): - if func is not None: - func(data) - - url = self.getUrl(request) - request = tornado.httpclient.HTTPRequest( - url, 'GET', - self.headers, - connect_timeout=connect_timeout, - request_timeout=read_timeout) - if single is True: - id = time.time() - self.id = id - - def responseCallback(response): - if single is True: - if not id == self.id: - return None - - body = response._get_body() - - if body is None: - return - - def handle_exc(*args): - return True - if response.error is not None: - with ExceptionStackContext(handle_exc): - if response.code in [403, 401]: - response.rethrow() - else: - _invoke(error, {"message": response.reason}) - return - - try: - data = json.loads(body) - except TypeError as e: - try: - data = json.loads(body.decode("utf-8")) - except ValueError as ve: - _invoke(error, {'error': 'json decode error'}) - - if 'error' in data and 'status' in data and 'status' != 200: - _invoke(error, data) - else: - _invoke(callback, data) - - self.http.fetch( - request=request, - callback=responseCallback - ) - - def abort(): - pass - - return abort - -try: - from twisted.web.client import getPage - from twisted.internet import reactor - from twisted.internet.defer import Deferred - from twisted.internet.protocol import Protocol - from twisted.web.client import Agent, ContentDecoderAgent - from twisted.web.client import RedirectAgent, GzipDecoder - from twisted.web.client import HTTPConnectionPool - from twisted.web.http_headers import Headers - from twisted.internet.ssl import ClientContextFactory - from twisted.internet.task import LoopingCall - import twisted - - from twisted.python.compat import ( - _PY3, unicode, intToBytes, networkString, nativeString) - - pnconn_pool = HTTPConnectionPool(reactor, persistent=True) - pnconn_pool.maxPersistentPerHost = 100000 - pnconn_pool.cachedConnectionTimeout = 15 - pnconn_pool.retryAutomatically = True -except ImportError: - pass - -from hashlib import sha256 -import time -import json - -import traceback - - - +# Pubnub Twisted class PubnubTwisted(PubnubCoreAsync): @@ -1383,11 +1268,11 @@ class PubnubTwisted(PubnubCoreAsync): def received(response): if not isinstance(response, twisted.web._newclient.Response): - _invoke(error, {"message" : "Not Found"}) + _invoke(error, {"message": "Not Found"}) return finished = Deferred() - if response.code in [401,403]: + if response.code in [401, 403]: response.deliverBody(PubNubPamResponse(finished)) else: response.deliverBody(PubNubResponse(finished)) @@ -1441,24 +1326,7 @@ class PubNubResponse(Protocol): self.finished.callback(bytes) -import tornado.httpclient - -try: - from hashlib import sha256 - digestmod = sha256 -except ImportError: - import Crypto.Hash.SHA256 as digestmod - sha256 = digestmod.new - -try: - import hmac - import tornado.ioloop - from tornado.stack_context import ExceptionStackContext - ioloop = tornado.ioloop.IOLoop.instance() -except ImportError: - pass - - +# PubnubTornado class PubnubTornado(PubnubCoreAsync): def stop(self): @@ -1555,4 +1423,3 @@ class PubnubTornado(PubnubCoreAsync): pass return abort - -- cgit v1.2.3 From ad6a453a0f00d20f0668b17b61668cb7fa5ee4e4 Mon Sep 17 00:00:00 2001 From: Devendra Date: Fri, 25 Apr 2014 03:26:09 +0530 Subject: v1 of console --- Pubnub.py | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 1802774..62a401d 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -411,7 +411,7 @@ class PubnubBase(object): else: return None - def publish(channel, message, callback=None, error=None): + def publish(self, channel, message, callback=None, error=None): """ #** #* Publish @@ -1037,19 +1037,15 @@ class HTTPClient: else: if latest_sub_callback['callback'] is not None: latest_sub_callback['id'] = 0 - print data try: data = json.loads(data) except ValueError as e: _invoke(latest_sub_callback['error'], {'error': 'json decoding error'}) return - print code if code != 200: - print 'ERROR' _invoke(latest_sub_callback['error'], data) else: - print 'CALLBACK' _invoke(latest_sub_callback['callback'], data) else: try: @@ -1070,22 +1066,18 @@ def _urllib_request_2(url, timeout=320): except urllib2.HTTPError as http_error: resp = http_error except urllib2.URLError as error: - #print error.reason msg = {"message": str(error.reason)} - #print str(msg) return (json.dumps(msg), 0) return (resp.read(), resp.code) def _urllib_request_3(url, timeout=320): - #print(url) try: resp = urllib.request.urlopen(url, timeout=timeout) except (urllib.request.HTTPError, urllib.request.URLError) as http_error: resp = http_error r = resp.read().decode("utf-8") - #print(r) return (r, resp.code) _urllib_request = None -- cgit v1.2.3 From 44aee82f3eadea1241ac4350b4f9f34daf58eb87 Mon Sep 17 00:00:00 2001 From: Devendra Date: Fri, 25 Apr 2014 19:42:21 +0530 Subject: improvements to console --- Pubnub.py | 41 +++++++++++++++++++++-------------------- 1 file changed, 21 insertions(+), 20 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 62a401d..cefe50b 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -22,6 +22,7 @@ import hashlib import uuid import sys from base64 import urlsafe_b64encode +from base64 import encodestring, decodestring import hmac from Crypto.Cipher import AES from Crypto.Hash import MD5 @@ -85,6 +86,26 @@ try: pnconn_pool.maxPersistentPerHost = 100000 pnconn_pool.cachedConnectionTimeout = 15 pnconn_pool.retryAutomatically = True + + class WebClientContextFactory(ClientContextFactory): + def getContext(self, hostname, port): + return ClientContextFactory.getContext(self) + + + class PubNubPamResponse(Protocol): + def __init__(self, finished): + self.finished = finished + + def dataReceived(self, bytes): + self.finished.callback(bytes) + + + class PubNubResponse(Protocol): + def __init__(self, finished): + self.finished = finished + + def dataReceived(self, bytes): + self.finished.callback(bytes) except ImportError: pass @@ -1297,26 +1318,6 @@ class PubnubTwisted(PubnubCoreAsync): return abort -class WebClientContextFactory(ClientContextFactory): - def getContext(self, hostname, port): - return ClientContextFactory.getContext(self) - - -class PubNubPamResponse(Protocol): - def __init__(self, finished): - self.finished = finished - - def dataReceived(self, bytes): - self.finished.callback(bytes) - - -class PubNubResponse(Protocol): - def __init__(self, finished): - self.finished = finished - - def dataReceived(self, bytes): - self.finished.callback(bytes) - # PubnubTornado class PubnubTornado(PubnubCoreAsync): -- cgit v1.2.3 From 7568c30242ae3a9f4163248a29a596fab5902601 Mon Sep 17 00:00:00 2001 From: Devendra Date: Fri, 25 Apr 2014 23:46:57 +0530 Subject: adding sync async mode to console --- Pubnub.py | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index cefe50b..6c082dc 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -340,7 +340,7 @@ class PubnubBase(object): sha256 ).digest()) - def _pam_auth(self, query, apicode=0, callback=None): + def _pam_auth(self, query, apicode=0, callback=None, error=None): """Issue an authenticated request.""" if 'timestamp' not in query: @@ -364,7 +364,6 @@ class PubnubBase(object): apitype="audit" if (apicode) else "grant", params=params ) - query['signature'] = self._pam_sign(sign_input) return self._request({"urlcomponents": [ @@ -372,10 +371,11 @@ class PubnubBase(object): 'sub-key', self.subscribe_key ], 'urlparams': query}, - self._return_wrapped_callback(callback)) + self._return_wrapped_callback(callback), + self._return_wrapped_callback(error)) def grant(self, channel, authkey=False, read=True, - write=True, ttl=5, callback=None): + write=True, ttl=5, callback=None, error=None): """Grant Access on a Channel.""" return self._pam_auth({ @@ -384,9 +384,9 @@ class PubnubBase(object): "r": read and 1 or 0, "w": write and 1 or 0, "ttl": ttl - }, callback=callback) + }, callback=callback, error=error) - def revoke(self, channel, authkey=False, ttl=1, callback=None): + def revoke(self, channel, authkey=False, ttl=1, callback=None, error=None): """Revoke Access on a Channel.""" return self._pam_auth({ @@ -395,13 +395,13 @@ class PubnubBase(object): "r": 0, "w": 0, "ttl": ttl - }, callback=callback) + }, callback=callback, error=error) - def audit(self, channel=False, authkey=False, callback=None): + def audit(self, channel=False, authkey=False, callback=None, error=None): return self._pam_auth({ "channel": channel, "auth": authkey - }, 1, callback=callback) + }, 1, callback=callback, error=error) def encrypt(self, message): if self.cipher_key: @@ -627,8 +627,8 @@ class PubnubCoreAsync(PubnubBase): self, publish_key, subscribe_key, - secret_key=False, - cipher_key=False, + secret_key=None, + cipher_key=None, auth_key=None, ssl_on=False, origin='pubsub.pubnub.com', @@ -910,8 +910,8 @@ class PubnubCore(PubnubCoreAsync): self, publish_key, subscribe_key, - secret_key=False, - cipher_key=False, + secret_key=None, + cipher_key=None, auth_key=None, ssl_on=False, origin='pubsub.pubnub.com', @@ -1111,8 +1111,8 @@ class PubnubAsync(PubnubCoreAsync): self, publish_key, subscribe_key, - secret_key=False, - cipher_key=False, + secret_key=None, + cipher_key=None, auth_key=None, ssl_on=False, origin='pubsub.pubnub.com', @@ -1231,8 +1231,8 @@ class PubnubTwisted(PubnubCoreAsync): self, publish_key, subscribe_key, - secret_key=False, - cipher_key=False, + secret_key=None, + cipher_key=None, auth_key=None, ssl_on=False, origin='pubsub.pubnub.com' -- cgit v1.2.3 From 10f345fcf4edb489cf9b86039c030baa62a6881c Mon Sep 17 00:00:00 2001 From: Devendra Date: Wed, 30 Apr 2014 17:14:09 +0530 Subject: adding persistent connectino support --- Pubnub.py | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 6c082dc..06a594b 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -46,6 +46,11 @@ try: except ImportError: import urllib2 +try: + import requests +except ImportError: + pass + import threading from threading import current_thread @@ -1092,6 +1097,18 @@ def _urllib_request_2(url, timeout=320): return (resp.read(), resp.code) +s = requests.Session() +def _requests_request(url, timeout=320): + try: + resp = s.get(url) + except requests.exceptions.HTTPError as http_error: + resp = http_error + except requests.exceptions.ConnectionError as error: + msg = {"message": str(error.reason)} + return (json.dumps(msg), 0) + + return (resp.text, resp.status_code) + def _urllib_request_3(url, timeout=320): try: @@ -1116,7 +1133,8 @@ class PubnubAsync(PubnubCoreAsync): auth_key=None, ssl_on=False, origin='pubsub.pubnub.com', - pres_uuid=None + pres_uuid=None, + pooling=True ): super(PubnubAsync, self).__init__( publish_key=publish_key, @@ -1136,6 +1154,9 @@ class PubnubAsync(PubnubCoreAsync): else: _urllib_request = _urllib_request_3 + if pooling is True: + _urllib_request = _requests_request + def timeout(self, interval, func): def cb(): time.sleep(interval) -- cgit v1.2.3 From 06511b3849e80cb5692ed92f7da31043c85556a0 Mon Sep 17 00:00:00 2001 From: Devendra Date: Thu, 1 May 2014 00:14:25 +0530 Subject: more chagnes to console --- Pubnub.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 06a594b..1bf31e9 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -379,6 +379,9 @@ class PubnubBase(object): self._return_wrapped_callback(callback), self._return_wrapped_callback(error)) + def get_origin(self): + return self.origin + def grant(self, channel, authkey=False, read=True, write=True, ttl=5, callback=None, error=None): """Grant Access on a Channel.""" -- cgit v1.2.3 From 8a642ab92c537c84960ef3943b34aac95bc39121 Mon Sep 17 00:00:00 2001 From: Devendra Date: Fri, 2 May 2014 01:58:21 +0530 Subject: modifications for susbcribe loop events, connect, disconnect, reconnect --- Pubnub.py | 32 ++++++++++++++++++++++++++++---- 1 file changed, 28 insertions(+), 4 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 1bf31e9..3e8fd64 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -381,7 +381,7 @@ class PubnubBase(object): def get_origin(self): return self.origin - + def grant(self, channel, authkey=False, read=True, write=True, ttl=5, callback=None, error=None): """Grant Access on a Channel.""" @@ -770,7 +770,22 @@ class PubnubCoreAsync(PubnubBase): chobj = self.subscriptions[ch] if chobj['connected'] is False: chobj['connected'] = True + chobj['disconnected'] = False _invoke(chobj['connect'], chobj['name']) + else: + if chobj['disconnected'] is True: + chobj['disconnected'] = False + _invoke(chobj['reconnect'], chobj['name']) + + def _invoke_disconnect(): + if self._channel_list_lock: + with self._channel_list_lock: + for ch in self.subscriptions: + chobj = self.subscriptions[ch] + if chobj['connected'] is True: + if chobj['disconnected'] is False: + chobj['disconnected'] = True + _invoke(chobj['disconnect'], chobj['name']) def _invoke_error(channel_list=None, err=None): if channel_list is None: @@ -796,6 +811,7 @@ class PubnubCoreAsync(PubnubBase): 'name': channel, 'first': False, 'connected': False, + 'disconnected': True, 'subscribed': True, 'callback': callback, 'connect': connect, @@ -823,10 +839,13 @@ class PubnubCoreAsync(PubnubBase): response['message'] == 'Forbidden'): _invoke_error(response['payload'][ 'channels'], response['message']) - _connect() + self.timeout(1, _connect) return if 'message' in response: _invoke_error(err=response['message']) + else: + _invoke_disconnect() + self.timeout(1, _connect) def sub_callback(response): ## ERROR ? @@ -1103,11 +1122,16 @@ def _urllib_request_2(url, timeout=320): s = requests.Session() def _requests_request(url, timeout=320): try: - resp = s.get(url) + resp = s.get(url, timeout=timeout) except requests.exceptions.HTTPError as http_error: resp = http_error except requests.exceptions.ConnectionError as error: - msg = {"message": str(error.reason)} + msg = str(error) + return (json.dumps(msg), 0) + except requests.exceptions.Timeout as error: + #print(error); + #print('timeout'); + msg = str(error) return (json.dumps(msg), 0) return (resp.text, resp.status_code) -- cgit v1.2.3 From ca29b41c781c3a9861141811b208432fbda8aa0a Mon Sep 17 00:00:00 2001 From: Devendra Date: Fri, 2 May 2014 20:19:57 +0530 Subject: enahancements to dev console --- Pubnub.py | 52 +++++++++++++++++++++++++++------------------------- 1 file changed, 27 insertions(+), 25 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 3e8fd64..fc822f7 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -713,7 +713,7 @@ class PubnubCoreAsync(PubnubBase): for i in l: func(i) - def subscribe(self, channel, callback, error=None, + def subscribe(self, channels, callback, error=None, connect=None, disconnect=None, reconnect=None, sync=False): """ #** @@ -756,11 +756,13 @@ class PubnubCoreAsync(PubnubBase): self.susbcribe_sync(args) return - def _invoke(func, msg=None): + def _invoke(func, msg=None, channel=None): if func is not None: - if msg is not None: + if msg is not None and channel is not None: + func(msg,channel) + elif msg is not None: func(msg) - else: + else : func() def _invoke_connect(): @@ -802,31 +804,32 @@ class PubnubCoreAsync(PubnubBase): chobj = self.subscriptions[ch] if chobj['subscribed'] is True: return chobj - - ## New Channel? - if not channel in self.subscriptions or \ - self.subscriptions[channel]['subscribed'] is False: - with self._channel_list_lock: - self.subscriptions[channel] = { - 'name': channel, - 'first': False, - 'connected': False, - 'disconnected': True, - 'subscribed': True, - 'callback': callback, - 'connect': connect, - 'disconnect': disconnect, - 'reconnect': reconnect, - 'error': error - } - + channels = channels if isinstance(channels,list) else channels.split(",") + for channel in channels: + ## New Channel? + if not channel in self.subscriptions or \ + self.subscriptions[channel]['subscribed'] is False: + with self._channel_list_lock: + self.subscriptions[channel] = { + 'name': channel, + 'first': False, + 'connected': False, + 'disconnected': True, + 'subscribed': True, + 'callback': callback, + 'connect': connect, + 'disconnect': disconnect, + 'reconnect': reconnect, + 'error': error + } + ''' ## return if already connected to channel if channel in self.subscriptions and \ 'connected' in self.subscriptions[channel] and \ self.subscriptions[channel]['connected'] is True: _invoke(error, "Already Connected") return - + ''' ## SUBSCRIPTION RECURSION def _connect(): @@ -845,6 +848,7 @@ class PubnubCoreAsync(PubnubBase): _invoke_error(err=response['message']) else: _invoke_disconnect() + self.timetoken = 0 self.timeout(1, _connect) def sub_callback(response): @@ -1129,8 +1133,6 @@ def _requests_request(url, timeout=320): msg = str(error) return (json.dumps(msg), 0) except requests.exceptions.Timeout as error: - #print(error); - #print('timeout'); msg = str(error) return (json.dumps(msg), 0) -- cgit v1.2.3 From e0207efea24574bc6dac3e0aadb2d53cebe2a307 Mon Sep 17 00:00:00 2001 From: Devendra Date: Fri, 2 May 2014 22:45:17 +0530 Subject: console enhancements --- Pubnub.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index fc822f7..75e2243 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -874,13 +874,13 @@ class PubnubCoreAsync(PubnubBase): if ch[1] in self.subscriptions: chobj = self.subscriptions[ch[1]] _invoke(chobj['callback'], - self.decrypt(response_list[ch[0]])) + self.decrypt(response_list[ch[0]]), chobj['name']) else: response_list = response[0] chobj = _get_channel() for r in response_list: if chobj: - _invoke(chobj['callback'], self.decrypt(r)) + _invoke(chobj['callback'], self.decrypt(r), chobj['name']) _connect() @@ -1133,6 +1133,8 @@ def _requests_request(url, timeout=320): msg = str(error) return (json.dumps(msg), 0) except requests.exceptions.Timeout as error: + #print(error); + #print('timeout'); msg = str(error) return (json.dumps(msg), 0) -- cgit v1.2.3 From a38e680ae11453c2f3d5082c2ad39004366a9ad7 Mon Sep 17 00:00:00 2001 From: Devendra Date: Tue, 6 May 2014 20:08:46 +0530 Subject: fixing history api --- Pubnub.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 75e2243..a759f75 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -504,7 +504,7 @@ class PubnubBase(object): 'subscribe_key': self.subscribe_key, 'callback': self._return_wrapped_callback(callback)}) - def here_now(self, channel, callback, error=None): + def here_now(self, channel, callback=None, error=None): """ #** #* Here Now @@ -557,6 +557,7 @@ class PubnubBase(object): params['reverse'] = reverse params['start'] = start params['end'] = end + params['auth_key'] = self.auth_key ## Get History return self._request({'urlcomponents': [ @@ -566,7 +567,7 @@ class PubnubBase(object): self.subscribe_key, 'channel', channel, - ], 'urlparams': {'auth': self.auth_key}}, + ], 'urlparams': params}, callback=self._return_wrapped_callback(callback), error=self._return_wrapped_callback(error)) @@ -1137,7 +1138,6 @@ def _requests_request(url, timeout=320): #print('timeout'); msg = str(error) return (json.dumps(msg), 0) - return (resp.text, resp.status_code) -- cgit v1.2.3 From 1b49e712e12ba833f460324b95969b162d464edf Mon Sep 17 00:00:00 2001 From: Devendra Date: Wed, 7 May 2014 12:13:17 +0530 Subject: console changes and pep8 compliance --- Pubnub.py | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index a759f75..9cd33af 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -1,5 +1,5 @@ -## www.pubnub.com - PubNub Real-time push service in the cloud. +## www.pubnub.com - PubNub Real-time push service in the cloud. # coding=utf8 ## PubNub Real-time Push APIs and Notifications Framework @@ -11,7 +11,6 @@ ## ----------------------------------- - try: import json except ImportError: @@ -96,7 +95,6 @@ try: def getContext(self, hostname, port): return ClientContextFactory.getContext(self) - class PubNubPamResponse(Protocol): def __init__(self, finished): self.finished = finished @@ -104,7 +102,6 @@ try: def dataReceived(self, bytes): self.finished.callback(bytes) - class PubNubResponse(Protocol): def __init__(self, finished): self.finished = finished @@ -760,10 +757,10 @@ class PubnubCoreAsync(PubnubBase): def _invoke(func, msg=None, channel=None): if func is not None: if msg is not None and channel is not None: - func(msg,channel) + func(msg, channel) elif msg is not None: func(msg) - else : + else: func() def _invoke_connect(): @@ -779,7 +776,7 @@ class PubnubCoreAsync(PubnubBase): if chobj['disconnected'] is True: chobj['disconnected'] = False _invoke(chobj['reconnect'], chobj['name']) - + def _invoke_disconnect(): if self._channel_list_lock: with self._channel_list_lock: @@ -805,7 +802,8 @@ class PubnubCoreAsync(PubnubBase): chobj = self.subscriptions[ch] if chobj['subscribed'] is True: return chobj - channels = channels if isinstance(channels,list) else channels.split(",") + channels = channels if isinstance( + channels, list) else channels.split(",") for channel in channels: ## New Channel? if not channel in self.subscriptions or \ @@ -1125,6 +1123,8 @@ def _urllib_request_2(url, timeout=320): return (resp.read(), resp.code) s = requests.Session() + + def _requests_request(url, timeout=320): try: resp = s.get(url, timeout=timeout) @@ -1370,7 +1370,6 @@ class PubnubTwisted(PubnubCoreAsync): return abort - # PubnubTornado class PubnubTornado(PubnubCoreAsync): -- cgit v1.2.3 From 4ab1fa41e1a10efc88909bceb78222ffb406145a Mon Sep 17 00:00:00 2001 From: Devendra Date: Wed, 7 May 2014 13:01:21 +0530 Subject: pep 8 compliance --- Pubnub.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 9cd33af..ee9371a 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -873,13 +873,15 @@ class PubnubCoreAsync(PubnubBase): if ch[1] in self.subscriptions: chobj = self.subscriptions[ch[1]] _invoke(chobj['callback'], - self.decrypt(response_list[ch[0]]), chobj['name']) + self.decrypt(response_list[ch[0]]), + chobj['name']) else: response_list = response[0] chobj = _get_channel() for r in response_list: if chobj: - _invoke(chobj['callback'], self.decrypt(r), chobj['name']) + _invoke(chobj['callback'], self.decrypt(r), + chobj['name']) _connect() -- cgit v1.2.3 From 4a14f1f57546a7ccb24b9ced41f5743c3f49f96e Mon Sep 17 00:00:00 2001 From: Devendra Date: Wed, 7 May 2014 18:11:35 +0530 Subject: check for channel length 0 in subscribe --- Pubnub.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index ee9371a..4ae27ab 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -806,8 +806,9 @@ class PubnubCoreAsync(PubnubBase): channels, list) else channels.split(",") for channel in channels: ## New Channel? - if not channel in self.subscriptions or \ - self.subscriptions[channel]['subscribed'] is False: + if len(channel) > 0 and \ + (not channel in self.subscriptions or + self.subscriptions[channel]['subscribed'] is False): with self._channel_list_lock: self.subscriptions[channel] = { 'name': channel, @@ -1131,12 +1132,14 @@ def _requests_request(url, timeout=320): try: resp = s.get(url, timeout=timeout) except requests.exceptions.HTTPError as http_error: + print http_error resp = http_error except requests.exceptions.ConnectionError as error: + print error msg = str(error) return (json.dumps(msg), 0) except requests.exceptions.Timeout as error: - #print(error); + print(error) #print('timeout'); msg = str(error) return (json.dumps(msg), 0) -- cgit v1.2.3 From 1607828ef5d2ef6c3ce357f83f53ea109be02182 Mon Sep 17 00:00:00 2001 From: Devendra Date: Thu, 8 May 2014 04:12:28 +0530 Subject: updating package urls --- Pubnub.py | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 4ae27ab..e00ebb7 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -115,6 +115,13 @@ except ImportError: ####################################### +def get_data_for_user(data): + if 'message' in data and 'payload' in data: + return {'message': data['message'], 'payload': data['payload']} + else: + return data + + class PubnubCrypto2(): """ #** @@ -757,9 +764,9 @@ class PubnubCoreAsync(PubnubBase): def _invoke(func, msg=None, channel=None): if func is not None: if msg is not None and channel is not None: - func(msg, channel) + func(get_data_for_user(msg), channel) elif msg is not None: - func(msg) + func(get_data_for_user(msg)) else: func() @@ -1065,7 +1072,7 @@ class HTTPClient: def _invoke(func, data): if func is not None: - func(data) + func(get_data_for_user(data)) if self._urllib_func is None: return @@ -1132,15 +1139,11 @@ def _requests_request(url, timeout=320): try: resp = s.get(url, timeout=timeout) except requests.exceptions.HTTPError as http_error: - print http_error resp = http_error except requests.exceptions.ConnectionError as error: - print error msg = str(error) return (json.dumps(msg), 0) except requests.exceptions.Timeout as error: - print(error) - #print('timeout'); msg = str(error) return (json.dumps(msg), 0) return (resp.text, resp.status_code) @@ -1242,7 +1245,7 @@ class PubnubAsync(PubnubCoreAsync): def _request(self, request, callback=None, error=None, single=False): if callback is None: - return self._request_sync(request) + return get_data_for_user(self._request_sync(request)) else: self._request_async(request, callback, error, single=single) @@ -1313,7 +1316,7 @@ class PubnubTwisted(PubnubCoreAsync): def _invoke(func, data): if func is not None: - func(data) + func(get_data_for_user(data)) ## Build URL @@ -1418,7 +1421,7 @@ class PubnubTornado(PubnubCoreAsync): def _invoke(func, data): if func is not None: - func(data) + func(get_data_for_user(data)) url = self.getUrl(request) request = tornado.httpclient.HTTPRequest( -- cgit v1.2.3 From ca4b031be0c0964fd1dbfa952f23c5537ca02336 Mon Sep 17 00:00:00 2001 From: Devendra Date: Tue, 13 May 2014 04:03:30 +0530 Subject: adding comments for docs --- Pubnub.py | 719 ++++++++++++++++++++++++++++++++++++++------------------------ 1 file changed, 446 insertions(+), 273 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index e00ebb7..52091ad 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -3,11 +3,11 @@ # coding=utf8 ## PubNub Real-time Push APIs and Notifications Framework -## Copyright (c) 2010 Stephen Blum +## Copyright (c) 2014-15 Stephen Blum ## http://www.pubnub.com/ ## ----------------------------------- -## PubNub 3.3.4 Real-time Push Cloud API +## PubNub 3.5.0-beta Real-time Push Cloud API ## ----------------------------------- @@ -123,62 +123,22 @@ def get_data_for_user(data): class PubnubCrypto2(): - """ - #** - #* 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) @@ -186,14 +146,7 @@ class PubnubCrypto2(): 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) @@ -201,62 +154,22 @@ class PubnubCrypto2(): class PubnubCrypto3(): - """ - #** - #* 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).encode('utf-8') 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.encode("utf-8")).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) @@ -264,14 +177,7 @@ class PubnubCrypto3(): cipher.encrypt(self.pad(msg.encode('utf-8')))).decode('utf-8') 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) @@ -291,25 +197,20 @@ class PubnubBase(object): origin='pubsub.pubnub.com', UUID=None ): + """Pubnub Class + + Provides methods to communicate with Pubnub cloud + + Attributes: + publish_key: Publish Key + subscribe_key: Subscribe Key + secret_key: Secret Key + cipher_key: Cipher Key + auth_key: Auth Key (used with Pubnub Access Manager i.e. PAM) + ssl: SSL enabled ? + origin: Origin """ - #** - #* 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 @@ -341,7 +242,6 @@ class PubnubBase(object): raise AttributeError("pres_uuid must be a string") def _pam_sign(self, msg): - """Calculate a signature by secret key and message.""" return urlsafe_b64encode(hmac.new( self.secret_key.encode("utf-8"), @@ -350,7 +250,6 @@ class PubnubBase(object): ).digest()) def _pam_auth(self, query, apicode=0, callback=None, error=None): - """Issue an authenticated request.""" if 'timestamp' not in query: query['timestamp'] = int(time.time()) @@ -384,38 +283,226 @@ class PubnubBase(object): self._return_wrapped_callback(error)) def get_origin(self): + return self.origin - def grant(self, channel, authkey=False, read=True, + def grant(self, channel, auth_key=False, read=True, write=True, ttl=5, callback=None, error=None): - """Grant Access on a Channel.""" + """Method for granting permissions. + + This function establishes subscribe and/or write permissions for + PubNub Access Manager (PAM) by setting the read or write attribute + to true. A grant with read or write set to false (or not included) + will revoke any previous grants with read or write set to true. + + Permissions can be applied to any one of three levels: + 1. Application level privileges are based on subscribe_key applying to all associated channels. + 2. Channel level privileges are based on a combination of subscribe_key and channel name. + 3. User level privileges are based on the combination of subscribe_key, channel and auth_key. + + Args: + channel: (string) (optional) + Specifies channel name to grant permissions to. + If channel is not specified, the grant applies to all + channels associated with the subscribe_key. If auth_key + is not specified, it is possible to grant permissions to + multiple channels simultaneously by specifying the channels + as a comma separated list. + + auth_key: (string) (optional) + Specifies auth_key to grant permissions to. + It is possible to specify multiple auth_keys as comma + separated list in combination with a single channel name. + If auth_key is provided as the special-case value "null" + (or included in a comma-separated list, eg. "null,null,abc"), + a new auth_key will be generated and returned for each "null" value. + + read: (boolean) (default: True) + Read permissions are granted by setting to True. + Read permissions are removed by setting to False. + + write: (boolean) (default: True) + Write permissions are granted by setting to true. + Write permissions are removed by setting to false. + + ttl: (int) (default: 1440 i.e 24 hrs) + Time in minutes for which granted permissions are valid. + Max is 525600 , Min is 1. + Setting ttl to 0 will apply the grant indefinitely. + + callback: (function) (optional) + A callback method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado + + error: (function) (optional) + An error method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + + Returns: + Returns a dict in sync mode i.e. when callback argument is not given + The dict returned contains values with keys 'message' and 'payload' + + Sample Response: + { + "message":"Success", + "payload":{ + "ttl":5, + "auths":{ + "my_ro_authkey":{"r":1,"w":0} + }, + "subscribe_key":"my_subkey", + "level":"user", + "channel":"my_channel" + } + } + """ return self._pam_auth({ "channel": channel, - "auth": authkey, + "auth": auth_key, "r": read and 1 or 0, "w": write and 1 or 0, "ttl": ttl }, callback=callback, error=error) - def revoke(self, channel, authkey=False, ttl=1, callback=None, error=None): - """Revoke Access on a Channel.""" + def revoke(self, channel, auth_key=False, ttl=1, callback=None, error=None): + """Method for revoking permissions. + + Args: + channel: (string) (optional) + Specifies channel name to revoke permissions to. + If channel is not specified, the revoke applies to all + channels associated with the subscribe_key. If auth_key + is not specified, it is possible to grant permissions to + multiple channels simultaneously by specifying the channels + as a comma separated list. + + auth_key: (string) (optional) + Specifies auth_key to revoke permissions to. + It is possible to specify multiple auth_keys as comma + separated list in combination with a single channel name. + If auth_key is provided as the special-case value "null" + (or included in a comma-separated list, eg. "null,null,abc"), + a new auth_key will be generated and returned for each "null" value. + + ttl: (int) (default: 1440 i.e 24 hrs) + Time in minutes for which granted permissions are valid. + Max is 525600 , Min is 1. + Setting ttl to 0 will apply the grant indefinitely. + + callback: (function) (optional) + A callback method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado + + error: (function) (optional) + An error method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + + Returns: + Returns a dict in sync mode i.e. when callback argument is not given + The dict returned contains values with keys 'message' and 'payload' + + Sample Response: + { + "message":"Success", + "payload":{ + "ttl":5, + "auths":{ + "my_authkey":{"r":0,"w":0} + }, + "subscribe_key":"my_subkey", + "level":"user", + "channel":"my_channel" + } + } + + """ return self._pam_auth({ "channel": channel, - "auth": authkey, + "auth": auth_key, "r": 0, "w": 0, "ttl": ttl }, callback=callback, error=error) - def audit(self, channel=False, authkey=False, callback=None, error=None): + def audit(self, channel=False, auth_key=False, callback=None, error=None): + """Method for fetching permissions from pubnub servers. + + This method provides a mechanism to reveal existing PubNub Access Manager attributes + for any combination of subscribe_key, channel and auth_key. + + Args: + channel: (string) (optional) + Specifies channel name to return PAM + attributes optionally in combination with auth_key. + If channel is not specified, results for all channels + associated with subscribe_key are returned. + If auth_key is not specified, it is possible to return + results for a comma separated list of channels. + + auth_key: (string) (optional) + Specifies the auth_key to return PAM attributes for. + If only a single channel is specified, it is possible to return + results for a comma separated list of auth_keys. + + callback: (function) (optional) + A callback method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado + + error: (function) (optional) + An error method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + + Returns: + Returns a dict in sync mode i.e. when callback argument is not given + The dict returned contains values with keys 'message' and 'payload' + + Sample Response + { + "message":"Success", + "payload":{ + "channels":{ + "my_channel":{ + "auths":{"my_ro_authkey":{"r":1,"w":0}, + "my_rw_authkey":{"r":0,"w":1}, + "my_admin_authkey":{"r":1,"w":1} + } + } + }, + } + + Usage: + + pubnub.audit ('my_channel'); # Sync Mode + + """ + return self._pam_auth({ "channel": channel, - "auth": authkey + "auth": auth_key }, 1, callback=callback, error=error) def encrypt(self, message): + """Method for encrypting data. + + This method takes plaintext as input and returns encrypted data. + This need not be called directly as enncryption/decryption is + taken care of transparently by Pubnub class if cipher key is + provided at time of initializing pubnub object + + Args: + message: Message to be encrypted. + + Returns: + Returns encrypted message if cipher key is set + """ if self.cipher_key: message = json.dumps(self.pc.encrypt( self.cipher_key, json.dumps(message)).replace('\n', '')) @@ -425,6 +512,19 @@ class PubnubBase(object): return message def decrypt(self, message): + """Method for decrypting data. + + This method takes ciphertext as input and returns decrypted data. + This need not be called directly as enncryption/decryption is + taken care of transparently by Pubnub class if cipher key is + provided at time of initializing pubnub object + + Args: + message: Message to be decrypted. + + Returns: + Returns decrypted message if cipher key is set + """ if self.cipher_key: message = self.pc.decrypt(self.cipher_key, message) @@ -445,24 +545,43 @@ class PubnubBase(object): return None def publish(self, channel, message, callback=None, error=None): - """ - #** - #* 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) + """Publishes data on a channel. + + The publish() method is used to send a message to all subscribers of a channel. + To publish a message you must first specify a valid publish_key at initialization. + A successfully published message is replicated across the PubNub Real-Time Network + and sent simultaneously to all subscribed clients on a channel. + Messages in transit can be secured from potential eavesdroppers with SSL/TLS by + setting ssl to True during initialization. + + Published messages can also be encrypted with AES-256 simply by specifying a cipher_key + during initialization. + + Args: + channel: (string) + Specifies channel name to publish messages to. + message: (string/int/double/dict/list) + Message to be published + callback: (optional) + A callback method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado + error: (optional) + An error method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado + + Returns: + Sync Mode : list + Async Mode : None + + The function returns the following formatted response: + + [ Number, "Status", "Time Token"] + + The output below demonstrates the response to a successful call: + + [1,"Sent","13769558699541401"] """ @@ -482,26 +601,21 @@ class PubnubBase(object): error=self._return_wrapped_callback(error)) def presence(self, channel, callback, error=None): - """ - #** - #* 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 - }) + """Subscribe to presence data on a channel. + + Only works in async mode + + Args: + channel: Channel name ( string ) on which to publish message + callback: A callback method should be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + error: Optional variable. An error method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + + Returns: + None """ return self.subscribe({ 'channel': channel + '-pnpres', @@ -509,23 +623,51 @@ class PubnubBase(object): 'callback': self._return_wrapped_callback(callback)}) def here_now(self, channel, callback=None, error=None): - """ - #** - #* Here Now - #* - #* Load current occupancy from a channel. - #* - #* @param array args with 'channel'. - #* @return mixed false on fail, array on success. - #* + """Get here now data. - ## Presence Example - here_now = pubnub.here_now({ - 'channel' : 'hello_world', - }) - print(here_now['occupancy']) - print(here_now['uuids']) + You can obtain information about the current state of a channel including + a list of unique user-ids currently subscribed to the channel and the total + occupancy count of the channel by calling the here_now() function in your + application. + + + Args: + channel: (string) (optional) + Specifies the channel name to return occupancy results. + If channel is not provided, here_now will return data for all channels. + + callback: (optional) + A callback method should be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + error: (optional) + Optional variable. An error method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + + Returns: + Sync Mode: list + Async Mode: None + + Response Format: + + The here_now() method returns a list of uuid s currently subscribed to the channel. + + uuids:["String","String", ... ,"String"] - List of UUIDs currently subscribed to the channel. + + occupancy: Number - Total current occupancy of the channel. + + Example Response: + { + occupancy: 4, + uuids: [ + '123123234t234f34fq3dq', + '143r34f34t34fq34q34q3', + '23f34d3f4rq34r34rq23q', + 'w34tcw45t45tcw435tww3', + ] + } """ ## Get Presence Here Now @@ -537,22 +679,54 @@ class PubnubBase(object): callback=self._return_wrapped_callback(callback), error=self._return_wrapped_callback(error)) + def history(self, channel, count=100, reverse=False, start=None, end=None, callback=None, error=None): - """ - #** - #* History - #* - #* Load history from a channel. - #* + """This method fetches historical messages of a channel. - ## History Example - history = pubnub.detailedHistory({ - 'channel' : 'hello_world', - 'count' : 5 - }) - print(history) + PubNub Storage/Playback Service provides real-time access to an unlimited + history for all messages published to PubNub. Stored messages are replicated + across multiple availability zones in several geographical data center + locations. Stored messages can be encrypted with AES-256 message encryption + ensuring that they are not readable while stored on PubNub's network. + + It is possible to control how messages are returned and in what order, + for example you can: + + Return messages in the order newest to oldest (default behavior). + + Return messages in the order oldest to newest by setting reverse to true. + + Page through results by providing a start or end time token. + + Retrieve a "slice" of the time line by providing both a start and end time token. + + Limit the number of messages to a specific quantity using the count parameter. + + + + Args: + channel: (string) + Specifies channel to return history messages from + + count: (int) (default: 100) + Specifies the number of historical messages to return + + callback: (optional) + A callback method should be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + error: (optional) + An error method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + + Returns: + Returns a list in sync mode i.e. when callback argument is not given + + Sample Response: + [["Pub1","Pub2","Pub3","Pub4","Pub5"],13406746729185766,13406746845892666] """ params = dict() @@ -576,19 +750,20 @@ class PubnubBase(object): error=self._return_wrapped_callback(error)) def time(self, callback=None): - """ - #** - #* Time - #* - #* Timestamp from PubNub Cloud. - #* - #* @return int timestamp. - #* + """This function will return a 17 digit precision Unix epoch. + + Args: + + callback: (optional) + A callback method should be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . - ## PubNub Server Time Example - timestamp = pubnub.time() - print(timestamp) + Returns: + Returns a 17 digit number in sync mode i.e. when callback argument is not given + Sample: + 13769501243685161 """ time = self._request({'urlcomponents': [ @@ -649,23 +824,16 @@ class PubnubCoreAsync(PubnubBase): _tt_lock=empty_lock, _channel_list_lock=empty_lock ): - """ - #** - #* 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. - #** + """Summary of class here. - ## Initiat Class - pubnub = Pubnub( 'PUBLISH-KEY', 'SUBSCRIBE-KEY', 'SECRET-KEY', False ) + Longer class information.... + Longer class information.... + Attributes: + likes_spam: A boolean indicating if we like SPAM or not. + eggs: An integer count of the eggs we have laid. """ + super(PubnubCoreAsync, self).__init__( publish_key=publish_key, subscribe_key=subscribe_key, @@ -703,6 +871,14 @@ class PubnubCoreAsync(PubnubBase): return channel def get_channel_array(self): + """Get List of currently subscribed channels + + Returns: + Returns a list containing names of channels subscribed + + Sample return value: + ["a","b","c] + """ channels = self.subscriptions channel = [] with self._channel_list_lock: @@ -720,36 +896,37 @@ class PubnubCoreAsync(PubnubBase): def subscribe(self, channels, callback, error=None, connect=None, disconnect=None, reconnect=None, sync=False): - """ - #** - #* 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 - }) - + """Subscribe to data on a channel. + + This function causes the client to create an open TCP socket to the + PubNub Real-Time Network and begin listening for messages on a specified channel. + To subscribe to a channel the client must send the appropriate subscribe_key at + initialization. + + Only works in async mode + + Args: + channel: (string/list) + Specifies the channel to subscribe to. It is possible to specify + multiple channels as a comma separated list or andarray. + + callback: (function) + This callback is called on receiving a message from the channel. + + error: (function) (optional) + This callback is called on an error event + + connect: (function) (optional) + This callback is called on a successful connection to the PubNub cloud + + disconnect: (function) (optional) + This callback is called on client disconnect from the PubNub cloud + + reconnect: (function) (optional) + This callback is called on successfully re-connecting to the PubNub cloud + + Returns: + None """ with self._tt_lock: @@ -931,7 +1108,22 @@ class PubnubCoreAsync(PubnubBase): self._connect() def unsubscribe(self, channel): - + """Subscribe to presence data on a channel. + Only works in async mode + + Args: + channel: Channel name ( string ) on which to publish message + message: Message to be published ( String / int / double / dict / list ). + callback: A callback method should be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + error: Optional variable. An error method can be passed to the method. + If set, the api works in async mode. + Required argument when working with twisted or tornado . + + Returns: + Returns a list in sync mode i.e. when callback argument is not given + """ if channel in self.subscriptions is False: return False @@ -957,25 +1149,6 @@ class PubnubCore(PubnubCoreAsync): 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, -- cgit v1.2.3 From 9dda9200997330b686bdb26495bed1023a1d8f7e Mon Sep 17 00:00:00 2001 From: Devendra Date: Thu, 15 May 2014 12:06:49 +0530 Subject: adding sync and async tests for grant and revoke --- Pubnub.py | 59 ++++++++++++----------------------------------------------- 1 file changed, 12 insertions(+), 47 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 52091ad..d75b452 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -283,10 +283,15 @@ class PubnubBase(object): self._return_wrapped_callback(error)) def get_origin(self): - return self.origin - def grant(self, channel, auth_key=False, read=True, + def set_auth_key(self, auth_key): + self.auth_key = auth_key + + def get_auth_key(self): + return auth_key + + def grant(self, channel=None, auth_key=False, read=True, write=True, ttl=5, callback=None, error=None): """Method for granting permissions. @@ -367,7 +372,7 @@ class PubnubBase(object): "ttl": ttl }, callback=callback, error=error) - def revoke(self, channel, auth_key=False, ttl=1, callback=None, error=None): + def revoke(self, channel=None, auth_key=None, ttl=1, callback=None, error=None): """Method for revoking permissions. Args: @@ -430,7 +435,7 @@ class PubnubBase(object): "ttl": ttl }, callback=callback, error=error) - def audit(self, channel=False, auth_key=False, callback=None, error=None): + def audit(self, channel=None, auth_key=None, callback=None, error=None): """Method for fetching permissions from pubnub servers. This method provides a mechanism to reveal existing PubNub Access Manager attributes @@ -790,6 +795,7 @@ class PubnubBase(object): if ("urlparams" in request): url = url + '?' + "&".join([x + "=" + str(y) for x, y in request[ "urlparams"].items() if y is not None]) + print url return url @@ -824,15 +830,6 @@ class PubnubCoreAsync(PubnubBase): _tt_lock=empty_lock, _channel_list_lock=empty_lock ): - """Summary of class here. - - Longer class information.... - Longer class information.... - - Attributes: - likes_spam: A boolean indicating if we like SPAM or not. - eggs: An integer count of the eggs we have laid. - """ super(PubnubCoreAsync, self).__init__( publish_key=publish_key, @@ -1250,12 +1247,6 @@ class HTTPClient: if self._urllib_func is None: return - ''' - try: - resp = urllib2.urlopen(self.url, timeout=320) - except urllib2.HTTPError as http_error: - resp = http_error - ''' resp = self._urllib_func(self.url, timeout=320) data = resp[0] code = resp[1] @@ -1335,7 +1326,7 @@ _urllib_request = None # PubnubAsync -class PubnubAsync(PubnubCoreAsync): +class Pubnub(PubnubCoreAsync): def __init__( self, publish_key, @@ -1348,7 +1339,7 @@ class PubnubAsync(PubnubCoreAsync): pres_uuid=None, pooling=True ): - super(PubnubAsync, self).__init__( + super(Pubnub, self).__init__( publish_key=publish_key, subscribe_key=subscribe_key, secret_key=secret_key, @@ -1422,31 +1413,6 @@ class PubnubAsync(PubnubCoreAsync): else: self._request_async(request, callback, error, single=single) -''' - - def _request3_sync( self, request) : - ## Build URL - url = self.getUrl(request) - ## Send Request Expecting JSONP Response - try: - response = urllib.request.urlopen(url,timeout=310) - resp_json = json.loads(response.read().decode("utf-8")) - except Exception as e: - return None - - return resp_json - - def _request3_async( self, request, callback, single=False ) : - pass - - def _request3(self, request, callback=None, single=False): - if callback is None: - return self._request3_sync(request,single=single) - else: - self._request3_async(request, callback, single=single) - ''' - - # Pubnub Twisted class PubnubTwisted(PubnubCoreAsync): @@ -1481,7 +1447,6 @@ class PubnubTwisted(PubnubCoreAsync): ) self.headers = {} self.headers['User-Agent'] = ['Python-Twisted'] - #self.headers['Accept-Encoding'] = [self.accept_encoding] self.headers['V'] = [self.version] def _request(self, request, callback=None, error=None, single=False): -- cgit v1.2.3 From 3faa087aca856d14e4dca7b3ec41a691f8d468f2 Mon Sep 17 00:00:00 2001 From: Devendra Date: Thu, 15 May 2014 18:33:10 +0530 Subject: adding unit tests --- Pubnub.py | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index d75b452..acc680b 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -116,9 +116,12 @@ except ImportError: def get_data_for_user(data): - if 'message' in data and 'payload' in data: - return {'message': data['message'], 'payload': data['payload']} - else: + try: + if 'message' in data and 'payload' in data: + return {'message': data['message'], 'payload': data['payload']} + else: + return data + except TypeError: return data @@ -138,7 +141,6 @@ class PubnubCrypto2(): return hashlib.sha256(key).hexdigest() def encrypt(self, key, msg): - secret = self.getSecret(key) Initial16bytes = '0123456789012345' cipher = AES.new(secret[0:32], AES.MODE_CBC, Initial16bytes) @@ -150,8 +152,11 @@ class PubnubCrypto2(): secret = self.getSecret(key) Initial16bytes = '0123456789012345' cipher = AES.new(secret[0:32], AES.MODE_CBC, Initial16bytes) - return self.depad((cipher.decrypt(decodestring(msg)))) - + plain = self.depad(cipher.decrypt(decodestring(msg))) + try: + return eval(plain) + except SyntaxError: + return plain class PubnubCrypto3(): @@ -795,7 +800,7 @@ class PubnubBase(object): if ("urlparams" in request): url = url + '?' + "&".join([x + "=" + str(y) for x, y in request[ "urlparams"].items() if y is not None]) - print url + #print url return url -- cgit v1.2.3 From 646fdda7abbd997925e83a497ed70ca27fb64654 Mon Sep 17 00:00:00 2001 From: Devendra Date: Sat, 14 Jun 2014 02:12:38 +0530 Subject: fixing issue where subscribe in two separate pubnub objects was not working correctly --- Pubnub.py | 76 +++++++++++++++++++++++++++++++-------------------------------- 1 file changed, 38 insertions(+), 38 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index acc680b..3a4f59b 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -47,6 +47,7 @@ except ImportError: try: import requests + from requests.adapters import HTTPAdapter except ImportError: pass @@ -800,7 +801,6 @@ class PubnubBase(object): if ("urlparams" in request): url = url + '?' + "&".join([x + "=" + str(y) for x, y in request[ "urlparams"].items() if y is not None]) - #print url return url @@ -1087,7 +1087,7 @@ class PubnubCoreAsync(PubnubBase): ], "urlparams": {"uuid": self.uuid, "auth": self.auth_key}}, sub_callback, error_callback, - single=True) + single=True, timeout=320) ''' except Exception as e: print(e) @@ -1224,19 +1224,17 @@ class PubnubCore(PubnubCoreAsync): return True -latest_sub_callback_lock = threading.RLock() -latest_sub_callback = {'id': None, 'callback': None} - - class HTTPClient: - def __init__(self, url, urllib_func=None, - callback=None, error=None, id=None): + def __init__(self, pubnub, url, urllib_func=None, + callback=None, error=None, id=None, timeout=5): self.url = url self.id = id self.callback = callback self.error = error self.stop = False self._urllib_func = urllib_func + self.timeout = timeout + self.pubnub = pubnub def cancel(self): self.stop = True @@ -1252,31 +1250,29 @@ class HTTPClient: if self._urllib_func is None: return - resp = self._urllib_func(self.url, timeout=320) + resp = self._urllib_func(self.url, timeout=self.timeout) data = resp[0] code = resp[1] if self.stop is True: return if self.callback is None: - global latest_sub_callback - global latest_sub_callback_lock - with latest_sub_callback_lock: - if latest_sub_callback['id'] != self.id: + with self.pubnub.latest_sub_callback_lock: + if self.pubnub.latest_sub_callback['id'] != self.id: return else: - if latest_sub_callback['callback'] is not None: - latest_sub_callback['id'] = 0 + if self.pubnub.latest_sub_callback['callback'] is not None: + self.pubnub.latest_sub_callback['id'] = 0 try: data = json.loads(data) except ValueError as e: - _invoke(latest_sub_callback['error'], + _invoke(self.pubnub.latest_sub_callback['error'], {'error': 'json decoding error'}) return if code != 200: - _invoke(latest_sub_callback['error'], data) + _invoke(self.pubnub.latest_sub_callback['error'], data) else: - _invoke(latest_sub_callback['callback'], data) + _invoke(self.pubnub.latest_sub_callback['callback'], data) else: try: data = json.loads(data) @@ -1290,7 +1286,7 @@ class HTTPClient: _invoke(self.callback, data) -def _urllib_request_2(url, timeout=320): +def _urllib_request_2(url, timeout=5): try: resp = urllib2.urlopen(url, timeout=timeout) except urllib2.HTTPError as http_error: @@ -1302,9 +1298,10 @@ def _urllib_request_2(url, timeout=320): return (resp.read(), resp.code) s = requests.Session() +s.mount('http://pubsub.pubnub.com', HTTPAdapter(max_retries=1)) +s.mount('https://pubsub.pubnub.com', HTTPAdapter(max_retries=1)) - -def _requests_request(url, timeout=320): +def _requests_request(url, timeout=5): try: resp = s.get(url, timeout=timeout) except requests.exceptions.HTTPError as http_error: @@ -1318,7 +1315,7 @@ def _requests_request(url, timeout=320): return (resp.text, resp.status_code) -def _urllib_request_3(url, timeout=320): +def _urllib_request_3(url, timeout=5): try: resp = urllib.request.urlopen(url, timeout=timeout) except (urllib.request.HTTPError, urllib.request.URLError) as http_error: @@ -1365,6 +1362,9 @@ class Pubnub(PubnubCoreAsync): if pooling is True: _urllib_request = _requests_request + self.latest_sub_callback_lock = threading.RLock() + self.latest_sub_callback = {'id': None, 'callback': None} + def timeout(self, interval, func): def cb(): time.sleep(interval) @@ -1372,21 +1372,21 @@ class Pubnub(PubnubCoreAsync): thread = threading.Thread(target=cb) thread.start() - def _request_async(self, request, callback=None, error=None, single=False): + def _request_async(self, request, callback=None, error=None, single=False, timeout=5): global _urllib_request ## Build URL url = self.getUrl(request) if single is True: id = time.time() - client = HTTPClient(url=url, urllib_func=_urllib_request, - callback=None, error=None, id=id) - with latest_sub_callback_lock: - latest_sub_callback['id'] = id - latest_sub_callback['callback'] = callback - latest_sub_callback['error'] = error + client = HTTPClient(self, url=url, urllib_func=_urllib_request, + callback=None, error=None, id=id, timeout=timeout) + with self.latest_sub_callback_lock: + self.latest_sub_callback['id'] = id + self.latest_sub_callback['callback'] = callback + self.latest_sub_callback['error'] = error else: - client = HTTPClient(url=url, urllib_func=_urllib_request, - callback=callback, error=error) + client = HTTPClient(self, url=url, urllib_func=_urllib_request, + callback=callback, error=error, timeout=timeout) thread = threading.Thread(target=client.run) thread.start() @@ -1395,12 +1395,12 @@ class Pubnub(PubnubCoreAsync): client.cancel() return abort - def _request_sync(self, request): + def _request_sync(self, request, timeout=5): global _urllib_request ## Build URL url = self.getUrl(request) ## Send Request Expecting JSONP Response - response = _urllib_request(url, timeout=320) + response = _urllib_request(url, timeout=timeout) try: resp_json = json.loads(response[0]) except ValueError: @@ -1412,11 +1412,11 @@ class Pubnub(PubnubCoreAsync): return resp_json - def _request(self, request, callback=None, error=None, single=False): + def _request(self, request, callback=None, error=None, single=False, timeout=5): if callback is None: - return get_data_for_user(self._request_sync(request)) + return get_data_for_user(self._request_sync(request, timeout=timeout)) else: - self._request_async(request, callback, error, single=single) + self._request_async(request, callback, error, single=single, timeout=timeout) # Pubnub Twisted @@ -1560,7 +1560,7 @@ class PubnubTornado(PubnubCoreAsync): self.id = None def _request(self, request, callback=None, error=None, - single=False, read_timeout=5, connect_timeout=5): + single=False, timeout=5, connect_timeout=5): def _invoke(func, data): if func is not None: @@ -1571,7 +1571,7 @@ class PubnubTornado(PubnubCoreAsync): url, 'GET', self.headers, connect_timeout=connect_timeout, - request_timeout=read_timeout) + request_timeout=timeout) if single is True: id = time.time() self.id = id -- cgit v1.2.3 From 75033e11a429b52b0366d63bdd8f81b795a7145d Mon Sep 17 00:00:00 2001 From: Devendra Date: Sun, 15 Jun 2014 10:23:16 +0530 Subject: fixing customer issue, making changes to dev console to print pretty --- Pubnub.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 3a4f59b..18f1b38 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -1406,7 +1406,7 @@ class Pubnub(PubnubCoreAsync): except ValueError: return [0, "JSON Error"] - if response[1] != 200 and 'status' in resp_json: + if response[1] != 200 and 'message' in resp_json and 'payload' in resp_json: return {'message': resp_json['message'], 'payload': resp_json['payload']} -- cgit v1.2.3 From 6e67486e8e2333e6f7b0128df9bc4f1da8db2bfc Mon Sep 17 00:00:00 2001 From: Devendra Date: Mon, 16 Jun 2014 23:33:20 +0530 Subject: return json array with code and reason in sync mode error --- Pubnub.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 18f1b38..5c19109 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -1410,6 +1410,9 @@ class Pubnub(PubnubCoreAsync): return {'message': resp_json['message'], 'payload': resp_json['payload']} + if response[1] == 0: + return [0, resp_json] + return resp_json def _request(self, request, callback=None, error=None, single=False, timeout=5): -- cgit v1.2.3 From 819dbedf0904b81e866ea6d27219608167d8b8ca Mon Sep 17 00:00:00 2001 From: Devendra Date: Mon, 16 Jun 2014 23:40:07 +0530 Subject: version changes --- Pubnub.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'Pubnub.py') diff --git a/Pubnub.py b/Pubnub.py index 5c19109..e39dd06 100644 --- a/Pubnub.py +++ b/Pubnub.py @@ -7,7 +7,7 @@ ## http://www.pubnub.com/ ## ----------------------------------- -## PubNub 3.5.0-beta Real-time Push Cloud API +## PubNub 3.5.0 Real-time Push Cloud API ## ----------------------------------- @@ -218,6 +218,7 @@ class PubnubBase(object): """ self.origin = origin + self.version = '3.5.0' self.limit = 1800 self.publish_key = publish_key self.subscribe_key = subscribe_key @@ -850,7 +851,6 @@ class PubnubCoreAsync(PubnubBase): self.subscriptions = {} self.timetoken = 0 self.last_timetoken = 0 - self.version = '3.3.4' self.accept_encoding = 'gzip' self.SUB_RECEIVER = None self._connect = None @@ -1164,7 +1164,6 @@ class PubnubCore(PubnubCoreAsync): self.subscriptions = {} self.timetoken = 0 - self.version = '3.4' self.accept_encoding = 'gzip' def subscribe_sync(self, channel, callback, timetoken=0): -- cgit v1.2.3