adding a test app for gae python

5 files changed, 685 insertions, 0 deletions

diff --git a/python/examples/pn-test-gae/Pubnub.py b/python/examples/pn-test-gae/Pubnub.py
new file mode 100644
index 0000000..59a38af
--- /dev/null
+++ b/python/examples/pn-test-gae/Pubnub.py
@@ -0,0 +1,618 @@
+## 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 PubnubCrypto() :
+    """
+    #**
+    #* PubnubCrypto
+    #*
+    #**
+
+    ## Initiate Class
+    pc = PubnubCrypto
+
+    """
+   
+    def pad( self, msg, block_size=16 ):
+        """
+        #**
+        #* pad
+        #*
+        #* pad the text to be encrypted
+        #* appends a padding character to the end of the String
+        #* until the string has block_size length
+        #* @return msg with padding.
+        #**
+        """
+        padding = block_size - (len(msg) % block_size)
+        return msg + chr(padding)*padding
+       
+    def depad( self, msg ):
+        """
+        #**
+        #* depad
+        #*
+        #* depad the decryptet message"
+        #* @return msg without padding.
+        #**
+        """
+        return msg[0:-ord(msg[-1])]
+
+    def getSecret( self, key ):
+        """
+        #**
+        #* getSecret
+        #*
+        #* hases the key to MD5
+        #* @return key in MD5 format
+        #**
+        """
+        return hashlib.sha256(key).hexdigest()
+
+    def encrypt( self, key, msg ):
+        """
+        #**
+        #* encrypt
+        #*
+        #* encrypts the message
+        #* @return message in encrypted format
+        #**
+        """
+        secret = self.getSecret(key)
+        Initial16bytes='0123456789012345'
+        cipher = AES.new(secret[0:32],AES.MODE_CBC,Initial16bytes)
+        enc = encodestring(cipher.encrypt(self.pad(msg)))
+        return enc
+    def decrypt( self, key, msg ):
+        """
+        #**
+        #* decrypt
+        #*
+        #* decrypts the message
+        #* @return message in decryped format
+        #**
+        """
+        secret = self.getSecret(key)
+        Initial16bytes='0123456789012345'
+        cipher = AES.new(secret[0:32],AES.MODE_CBC,Initial16bytes)
+        return self.depad((cipher.decrypt(decodestring(msg))))
+
+
+try: import json
+except ImportError: import simplejson as json
+
+import time
+import hashlib
+import urllib2
+import uuid 
+
+class PubnubBase(object):
+    def __init__(
+        self,
+        publish_key,
+        subscribe_key,
+        secret_key = False,
+        cipher_key = False,
+        ssl_on = False,
+        origin = 'pubsub.pubnub.com',
+        UUID = None
+    ) :
+        """
+        #**
+        #* Pubnub
+        #*
+        #* Init the Pubnub Client API
+        #*
+        #* @param string publish_key required key to send messages.
+        #* @param string subscribe_key required key to receive messages.
+        #* @param string secret_key optional key to sign messages.
+        #* @param boolean ssl required for 2048 bit encrypted messages.
+        #* @param string origin PUBNUB Server Origin.
+        #* @param string pres_uuid optional identifier for presence (auto-generated if not supplied)
+        #**
+
+        ## Initiat Class
+        pubnub = Pubnub( 'PUBLISH-KEY', 'SUBSCRIBE-KEY', 'SECRET-KEY', False )
+
+        """
+        self.origin        = origin
+        self.limit         = 1800
+        self.publish_key   = publish_key
+        self.subscribe_key = subscribe_key
+        self.secret_key    = secret_key
+        self.cipher_key    = cipher_key
+        self.ssl           = ssl_on
+        self.pc            = PubnubCrypto()
+
+        if self.ssl :
+            self.origin = 'https://' + self.origin
+        else :
+            self.origin = 'http://'  + self.origin
+        
+        self.uuid = UUID or str(uuid.uuid4())
+        
+        if not isinstance(self.uuid, basestring):
+            raise AttributeError("pres_uuid must be a string")
+
+    def sign(self, channel, message):
+        ## Sign Message
+        if self.secret_key:
+            signature = hashlib.md5('/'.join([
+                self.publish_key,
+                self.subscribe_key,
+                self.secret_key,
+                channel,
+                message
+            ])).hexdigest()
+        else:
+            signature = '0'
+        return signature
+
+    def encrypt(self, message):
+        if self.cipher_key:
+            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 publish( self, args ) :
+        """
+        #**
+        #* Publish
+        #*
+        #* Send a message to a channel.
+        #*
+        #* @param array args with channel and message.
+        #* @return array success information.
+        #**
+
+        ## Publish Example
+        info = pubnub.publish({
+            'channel' : 'hello_world',
+            'message' : {
+                'some_text' : 'Hello my World'
+            }
+        })
+        print(info)
+
+        """
+        ## Fail if bad input.
+        if not (args['channel'] and args['message']) :
+            return [ 0, 'Missing Channel or Message' ]
+
+        ## Capture User Input
+        channel = str(args['channel'])
+
+        ## Capture Callback
+        if args.has_key('callback') :
+            callback = args['callback']
+        else :
+            callback = None 
+
+        #message = json.dumps(args['message'], separators=(',',':'))
+        message = self.encrypt(args['message'])
+
+        signature = self.sign(channel, message)
+
+        ## Send Message
+        return self._request({"urlcomponents": [
+            'publish',
+            self.publish_key,
+            self.subscribe_key,
+            signature,
+            channel,
+            '0',
+            message
+        ]}, callback)
+    
+    def presence( self, args ) :
+        """
+        #**
+        #* presence
+        #*
+        #* This is BLOCKING.
+        #* Listen for presence events on a channel.
+        #*
+        #* @param array args with channel and callback.
+        #* @return false on fail, array on success.
+        #**
+
+        ## Presence Example
+        def pres_event(message) :
+            print(message)
+            return True
+
+        pubnub.presence({
+            'channel'  : 'hello_world',
+            'callback' : receive 
+        })
+        """
+
+        ## Fail if missing channel
+        if not 'channel' in args :
+            raise Exception('Missing Channel.')
+            return False
+
+        ## Fail if missing callback
+        if not 'callback' in args :
+            raise Exception('Missing Callback.')
+            return False
+
+        ## Capture User Input
+        channel   = str(args['channel'])
+        callback  = args['callback']
+        subscribe_key = args.get('subscribe_key') or self.subscribe_key
+        
+        return self.subscribe({'channel': channel+'-pnpres', 'subscribe_key':subscribe_key, 'callback': callback})
+    
+    
+    def here_now( self, args ) :
+        """
+        #**
+        #* Here Now
+        #*
+        #* Load current occupancy from a channel.
+        #*
+        #* @param array args with 'channel'.
+        #* @return mixed false on fail, array on success.
+        #*
+
+        ## Presence Example
+        here_now = pubnub.here_now({
+            'channel' : 'hello_world',
+        })
+        print(here_now['occupancy'])
+        print(here_now['uuids'])
+
+        """
+        channel = str(args['channel'])
+
+        ## Capture Callback
+        if args.has_key('callback') :
+            callback = args['callback']
+        else :
+            callback = None
+        
+        ## Fail if bad input.
+        if not channel :
+            raise Exception('Missing Channel')
+            return False
+        
+        ## Get Presence Here Now
+        return self._request({"urlcomponents": [
+            'v2','presence',
+            'sub_key', self.subscribe_key,
+            'channel', channel
+        ]}, callback);
+        
+        
+    def history( self, args ) :
+        """
+        #**
+        #* History
+        #*
+        #* Load history from a channel.
+        #*
+        #* @param array args with 'channel' and 'limit'.
+        #* @return mixed false on fail, array on success.
+        #*
+
+        ## History Example
+        history = pubnub.history({
+            'channel' : 'hello_world',
+            'limit'   : 1
+        })
+        print(history)
+
+        """
+        ## Capture User Input
+        limit   = args.has_key('limit') and int(args['limit']) or 10
+        channel = str(args['channel'])
+
+        ## Fail if bad input.
+        if not channel :
+            raise Exception('Missing Channel')
+            return False
+
+        ## Capture Callback
+        if args.has_key('callback') :
+            callback = args['callback']
+        else :
+            callback = None
+
+        ## Get History
+        return self._request({ "urlcomponents" : [
+            'history',
+            self.subscribe_key,
+            channel,
+            '0',
+            str(limit)
+        ] }, callback);
+
+    def detailedHistory(self, args) :
+        """
+        #**
+        #* Detailed History
+        #*
+        #* Load Detailed history from a channel.
+        #*
+        #* @param array args with 'channel', optional: 'start', 'end', 'reverse', 'count'
+        #* @return mixed false on fail, array on success.
+        #*
+
+        ## History Example
+        history = pubnub.detailedHistory({
+            'channel' : 'hello_world',
+            'count'   : 5
+        })
+        print(history)
+
+        """
+        ## Capture User Input
+        channel = str(args['channel'])
+
+        params = dict() 
+        count = 100    
+        
+        if args.has_key('count'):
+            count = int(args['count'])
+
+        params['count'] = str(count)    
+        
+        if args.has_key('reverse'):
+            params['reverse'] = str(args['reverse']).lower()
+
+        if args.has_key('start'):
+            params['start'] = str(args['start'])
+
+        if args.has_key('end'):
+            params['end'] = str(args['end'])
+
+        ## Fail if bad input.
+        if not channel :
+            raise Exception('Missing Channel')
+            return False
+
+        ## Capture Callback
+        if args.has_key('callback') :
+            callback = args['callback']
+        else :
+            callback = None 
+
+        ## Get History
+        return self._request({ 'urlcomponents' : [
+            'v2',
+            'history',
+            'sub-key',
+            self.subscribe_key,
+            'channel',
+            channel,
+        ],'urlparams' : params }, callback=callback);
+
+    def time(self, args = None) :
+        """
+        #**
+        #* Time
+        #*
+        #* Timestamp from PubNub Cloud.
+        #*
+        #* @return int timestamp.
+        #*
+
+        ## PubNub Server Time Example
+        timestamp = pubnub.time()
+        print(timestamp)
+
+        """
+        ## Capture Callback
+        if args and args.has_key('callback') :
+            callback = args['callback']
+        else :
+            callback = None 
+        time = self._request({'urlcomponents' : [
+            'time',
+            '0'
+        ]}, callback)
+        if time != None:
+            return time[0]
+
+
+    def _encode( self, request ) :
+        return [
+            "".join([ ' ~`!@#$%^&*()+=[]\\{}|;\':",./<>?'.find(ch) > -1 and
+                hex(ord(ch)).replace( '0x', '%' ).upper() or
+                ch for ch in list(bit)
+            ]) for bit in request]
+    
+    def getUrl(self,request):
+        ## Build URL
+        url = self.origin + '/' + "/".join([
+            "".join([ ' ~`!@#$%^&*()+=[]\\{}|;\':",./<>?'.find(ch) > -1 and
+                hex(ord(ch)).replace( '0x', '%' ).upper() or
+                ch for ch in list(bit)
+            ]) for bit in request["urlcomponents"]])
+        if (request.has_key("urlparams")):
+            url = url + '?' + "&".join([ x + "=" + y  for x,y in request["urlparams"].iteritems()])
+        return url
+
+
+class PubnubCore(PubnubBase):
+    def __init__(
+        self,
+        publish_key,
+        subscribe_key,
+        secret_key = False,
+        cipher_key = False,
+        ssl_on = False,
+        origin = 'pubsub.pubnub.com',
+        uuid = None
+    ) :
+        """
+        #**
+        #* Pubnub
+        #*
+        #* Init the Pubnub Client API
+        #*
+        #* @param string publish_key required key to send messages.
+        #* @param string subscribe_key required key to receive messages.
+        #* @param string secret_key optional key to sign messages.
+        #* @param boolean ssl required for 2048 bit encrypted messages.
+        #* @param string origin PUBNUB Server Origin.
+        #* @param string pres_uuid optional identifier for presence (auto-generated if not supplied)
+        #**
+
+        ## Initiat Class
+        pubnub = Pubnub( 'PUBLISH-KEY', 'SUBSCRIBE-KEY', 'SECRET-KEY', False )
+
+        """
+        super(PubnubCore, self).__init__(
+            publish_key=publish_key,
+            subscribe_key=subscribe_key,
+            secret_key=secret_key,
+            cipher_key=cipher_key,
+            ssl_on=ssl_on,
+            origin=origin,
+            UUID=uuid
+        )        
+
+        self.subscriptions = {}
+        self.timetoken     = 0
+        self.version       = '3.4'
+        self.accept_encoding = 'gzip'
+
+
+
+    def subscribe( self, args ) :
+        """
+        #**
+        #* Subscribe
+        #*
+        #* This is BLOCKING.
+        #* Listen for a message on a channel.
+        #*
+        #* @param array args with channel and callback.
+        #* @return false on fail, array on success.
+        #**
+
+        ## Subscribe Example
+        def receive(message) :
+            print(message)
+            return True
+
+        pubnub.subscribe({
+            'channel'  : 'hello_world',
+            'callback' : receive 
+        })
+
+        """
+
+        ## Fail if missing channel
+        if not 'channel' in args :
+            raise Exception('Missing Channel.')
+            return False
+
+        ## Fail if missing callback
+        if not 'callback' in args :
+            raise Exception('Missing Callback.')
+            return False
+
+        ## Capture User Input
+        channel   = str(args['channel'])
+        callback  = args['callback']
+        subscribe_key = args.get('subscribe_key') or self.subscribe_key
+
+        ## Begin Subscribe
+        while True :
+
+            timetoken = 'timetoken' in args and args['timetoken'] or 0
+            try :
+                ## Wait for Message
+                response = self._request({"urlcomponents" : [
+                    'subscribe',
+                    subscribe_key,
+                    channel,
+                    '0',
+                    str(timetoken)
+                ],"urlparams" : {"uuid" : self.uuid }})
+
+                messages          = response[0]
+                args['timetoken'] = response[1]
+
+                ## If it was a timeout
+                if not len(messages) :
+                    continue
+
+                ## Run user Callback and Reconnect if user permits.
+                for message in messages :
+                    if not callback(self.decrypt(message)) :
+                        return
+
+            except Exception:
+                time.sleep(1)
+
+        return True
+
+
+
+class Pubnub(PubnubCore):
+    def __init__(
+        self,
+        publish_key,
+        subscribe_key,
+        secret_key = False,
+        cipher_key = False,
+        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,
+            ssl_on = ssl_on,
+            origin = origin,
+            uuid = pres_uuid
+        )        
+
+    def _request( self, request, callback = None ) :
+        ## Build URL
+        url = self.getUrl(request)
+
+        ## Send Request Expecting JSONP Response
+        try:
+            try: usock = urllib2.urlopen( url, None, 310 )
+            except TypeError: usock = urllib2.urlopen( url, None )
+            response = usock.read()
+            usock.close()
+            resp_json = json.loads(response)
+        except:
+            return None
+            
+        if (callback):
+            callback(resp_json)
+        else:
+            return resp_json
diff --git a/python/examples/pn-test-gae/app.yaml b/python/examples/pn-test-gae/app.yaml
new file mode 100644
index 0000000..61beea7
--- /dev/null
+++ b/python/examples/pn-test-gae/app.yaml
@@ -0,0 +1,19 @@
+application: flash-moonlight-545
+version: 1
+runtime: python27
+api_version: 1
+threadsafe: yes
+
+handlers:
+- url: /favicon\.ico
+  static_files: favicon.ico
+  upload: favicon\.ico
+
+- url: .*
+  script: main.app
+
+libraries:
+- name: webapp2
+  version: "2.5.2"
+- name: pycrypto
+  version: "2.6"
diff --git a/python/examples/pn-test-gae/favicon.ico b/python/examples/pn-test-gae/favicon.ico
new file mode 100644
index 0000000..23c553a
--- /dev/null
+++ b/python/examples/pn-test-gae/favicon.ico
diff --git a/python/examples/pn-test-gae/index.yaml b/python/examples/pn-test-gae/index.yaml
new file mode 100644
index 0000000..8e6046d
--- /dev/null
+++ b/python/examples/pn-test-gae/index.yaml
@@ -0,0 +1,12 @@
+indexes:
+
+# AUTOGENERATED
+
+# This index.yaml is automatically updated whenever the dev_appserver
+# detects that a new type of query is run.  If you want to manage the
+# index.yaml file manually, remove the above marker line (the line
+# saying "# AUTOGENERATED").  If you want to manage some indexes
+# manually, move them above the marker line.  The index.yaml file is
+# automatically uploaded to the admin console when you next deploy
+# your application using appcfg.py.
+
diff --git a/python/examples/pn-test-gae/main.py b/python/examples/pn-test-gae/main.py
new file mode 100644
index 0000000..b3d2088
--- /dev/null
+++ b/python/examples/pn-test-gae/main.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+#
+# Copyright 2007 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import webapp2
+
+from Pubnub import Pubnub
+
+pubnub = Pubnub( publish_key='demo', subscribe_key='demo', cipher_key='enigma', ssl_on=False )
+
+class MainHandler(webapp2.RequestHandler):
+
+    def get(self):
+    	info = pubnub.publish({
+    		'channel' : 'hello_world',
+    		'message' : {
+        	'some_text' : 'Hello my World'
+    		}
+		})
+        self.response.write(info)
+
+app = webapp2.WSGIApplication([
+    ('/', MainHandler)
+], debug=True)