First
This commit is contained in:
parent
b031a3a4a3
commit
928c7bad65
|
|
@ -0,0 +1,27 @@
|
|||
PubNub Real-time Cloud-Hosted Push API and Push Notification Client Frameworks
|
||||
Copyright (c) 2013 PubNub Inc.
|
||||
http://www.pubnub.com/
|
||||
http://www.pubnub.com/terms
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
|
||||
PubNub Real-time Cloud-Hosted Push API and Push Notification Client Frameworks
|
||||
Copyright (c) 2013 PubNub Inc.
|
||||
http://www.pubnub.com/
|
||||
http://www.pubnub.com/terms
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
## Contact support@pubnub.com for all questions
|
||||
|
||||
#### [PubNub](http://www.pubnub.com) Real-time Data Network
|
||||
##### Tornado Client
|
||||
|
||||
## IO Event Loop
|
||||
Be sure to eventually start the event loop or PubNub won't run!
|
||||
|
||||
```
|
||||
pubnub.start()
|
||||
```
|
||||
|
||||
#### Import
|
||||
```
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
```
|
||||
|
||||
#### Init
|
||||
```
|
||||
pubnub = Pubnub(publish_key="demo", subscribe_key="demo", ssl_on=False)
|
||||
```
|
||||
|
||||
#### Publish Example
|
||||
```
|
||||
channel = 'hello_world'
|
||||
message = 'Hello World !!!'
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.publish(channel, message, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### Subscribe Example
|
||||
```
|
||||
channel = 'hello_world'
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.subscribe(channel, callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
```
|
||||
|
||||
#### History Example
|
||||
```
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.history(channel, count=2, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### Here Now Example
|
||||
```
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.here_now(channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### Presence Example
|
||||
```
|
||||
channel = 'hello_world'
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
pubnub.presence(channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### Unsubscribe Example
|
||||
```
|
||||
pubnub.unsubscribe(channel='hello_world')
|
||||
```
|
||||
|
||||
#### Grant Example
|
||||
```
|
||||
authkey = "abcd"
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.grant(channel, authkey, True, True, callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
#### Audit Example
|
||||
```
|
||||
authkey = "abcd"
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.audit(channel, authkey, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### Revoke Example
|
||||
```
|
||||
authkey = "abcd"
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.revoke(channel, authkey, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
|
||||
#### IO Event Loop start
|
||||
```
|
||||
pubnub.start()
|
||||
```
|
||||
|
||||
## Contact support@pubnub.com for all questions
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
authkey = "abcd"
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.audit(channel, auth_key=authkey, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
authkey = "abcd"
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.grant(channel, authkey, True, True, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.here_now(channel, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'a'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.history(channel, count=2, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or 'abcd'
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
|
||||
channel = 'ab'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback_abc(message, channel, real_channel):
|
||||
print(str(message) + ' , ' + channel + ', ' + real_channel)
|
||||
# pubnub.unsubscribe_group(channel_group='abc')
|
||||
# pubnub.stop()
|
||||
|
||||
|
||||
def callback_d(message, channel):
|
||||
print(str(message) + ' , ' + channel)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect_abc(message):
|
||||
print("CONNECTED " + str(message))
|
||||
|
||||
|
||||
def connect_d(message):
|
||||
print("CONNECTED " + str(message))
|
||||
pubnub.unsubscribe(channel='d')
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED " + str(message))
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED " + str(message))
|
||||
|
||||
|
||||
print(pubnub.channel_group_add_channel(channel_group='abc', channel="bn"))
|
||||
|
||||
pubnub.presence_group(channel_group='abc', callback=callback_abc, error=error)
|
||||
|
||||
pubnub.presence(channel='d', callback=callback_d, error=error)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
message = 'Hello World !!!'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.publish(channel, message, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
authkey = "abcd"
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.revoke(channel, authkey, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
|
||||
channel = 'a'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.subscribe(channel, callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or 'abcd'
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
|
||||
channel = 'ab'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback_abc(message, channel, real_channel):
|
||||
print(str(message) + ' , ' + channel + ', ' + real_channel)
|
||||
pubnub.unsubscribe_group(channel_group='abc')
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
def callback_d(message, channel):
|
||||
print(str(message) + ' , ' + channel)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect_abc(message):
|
||||
print("CONNECTED " + str(message))
|
||||
|
||||
|
||||
def connect_d(message):
|
||||
print("CONNECTED " + str(message))
|
||||
pubnub.unsubscribe(channel='d')
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED " + str(message))
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED " + str(message))
|
||||
|
||||
|
||||
print(pubnub.channel_group_add_channel(channel_group='abc', channel="b"))
|
||||
|
||||
pubnub.subscribe_group(channel_groups='abc', callback=callback_abc, error=error,
|
||||
connect=connect_abc, reconnect=reconnect, disconnect=disconnect)
|
||||
|
||||
pubnub.subscribe(channels='d', callback=callback_d, error=error,
|
||||
connect=connect_d, reconnect=reconnect, disconnect=disconnect)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,205 @@
|
|||
## Contact support@pubnub.com for all questions
|
||||
|
||||
#### [PubNub](http://www.pubnub.com) Real-time Data Network
|
||||
##### Tornado Migration
|
||||
|
||||
#### Import
|
||||
|
||||
```
|
||||
# Pre 3.5:
|
||||
from pubnub import Pubnub
|
||||
|
||||
# New in 3.5+
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### Init
|
||||
|
||||
```
|
||||
|
||||
# Pre 3.5:
|
||||
pubnub = Pubnub(
|
||||
"demo", ## PUBLISH_KEY
|
||||
"demo", ## SUBSCRIBE_KEY
|
||||
False ## SSL_ON?
|
||||
)
|
||||
|
||||
# New in 3.5+
|
||||
pubnub = Pubnub(publish_key="demo", subscribe_key="demo", ssl_on=False)
|
||||
|
||||
```
|
||||
|
||||
#### PUBLISH
|
||||
|
||||
```
|
||||
channel = 'hello_world'
|
||||
message = 'Hello World !!!'
|
||||
|
||||
# Pre 3.5:
|
||||
def callback(messages):
|
||||
print(messages)
|
||||
|
||||
pubnub.publish( {
|
||||
'channel' : channel,
|
||||
'message' : message,
|
||||
'callback' : callback
|
||||
})
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.publish(channel, message, callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### SUBSCRIBE
|
||||
|
||||
```
|
||||
|
||||
# Listen for Messages
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
# Pre 3.5:
|
||||
def connected() :
|
||||
print('CONNECTED')
|
||||
|
||||
def message_received(message):
|
||||
print(message)
|
||||
|
||||
pubnub.subscribe({
|
||||
'channel' : channel,
|
||||
'connect' : connected,
|
||||
'callback' : message_received
|
||||
})
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.subscribe(channel, callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
```
|
||||
|
||||
#### Unsubscribe
|
||||
Once subscribed, you can easily, gracefully, unsubscribe:
|
||||
|
||||
```
|
||||
# Pre 3.5:
|
||||
pubnub.unsubscribe({
|
||||
'channel' : 'hello_world'
|
||||
})
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
pubnub.unsubscribe(channel='hello_world')
|
||||
```
|
||||
|
||||
#### PRESENCE
|
||||
|
||||
```
|
||||
|
||||
# Pre 3.5:
|
||||
#
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
# Listen for Presence Event Messages
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
pubnub.presence(channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### HERE_NOW
|
||||
|
||||
```
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
# Pre 3.5:
|
||||
def callback(messages):
|
||||
print(messages)
|
||||
|
||||
pubnub.here_now( {
|
||||
'channel' : channel,
|
||||
'callback' : callback
|
||||
})
|
||||
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
# Get info on who is here right now!
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.here_now(channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### HISTORY
|
||||
|
||||
```
|
||||
channel = 'hello_world'
|
||||
|
||||
# Pre 3.5:
|
||||
def history_complete(messages):
|
||||
print(messages)
|
||||
|
||||
pubnub.history( {
|
||||
'channel' : channel,
|
||||
'limit' : 2,
|
||||
'callback' : history_complete
|
||||
})
|
||||
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.history(channel, count=2, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### IO Event Loop
|
||||
|
||||
```
|
||||
|
||||
# Pre 3.5:
|
||||
tornado.ioloop.IOLoop.instance().start()
|
||||
|
||||
# New in 3.5+
|
||||
pubnub.start()
|
||||
```
|
||||
## Contact support@pubnub.com for all questions
|
||||
|
|
@ -0,0 +1,354 @@
|
|||
import time
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
subkey = "sub-c-9aeec0d4-cdf4-11e5-bcee-0619f8945a4f"
|
||||
pubkey = "pub-c-b3fdf8fc-4516-4ab2-8836-6fb22ba7870d"
|
||||
secretkey = "sec-c-ZDQwNTUwMDctZDViYi00MzhlLTg2NTctYjViZDcwNTA5Zjhj"
|
||||
pubnub = Pubnub(pubkey, subkey)
|
||||
pubnub_pam = Pubnub(pubkey, subkey, secretkey)
|
||||
|
||||
|
||||
# Grant permission read true, write true, on channel ( Async Mode )
|
||||
def test_1():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'auths': {'abcd': {'r': 1, 'w': 1, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': 'abcd', 'ttl': 1}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel="abcd", auth_key="abcd", read=True, write=True, ttl=1, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read false, write false, on channel ( Async Mode )
|
||||
def test_2():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'auths': {'abcd': {'r': 0, 'w': 0, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': 'abcd', 'ttl': 1}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
print("error")
|
||||
print(response)
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel="abcd", auth_key="abcd", read=False, write=False, ttl=1, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read True, write false, on channel ( Async Mode )
|
||||
def test_3():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'auths': {'abcd': {'r': 1, 'w': 0, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': 'abcd', 'ttl': 1}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel="abcd", auth_key="abcd", read=True, write=False, ttl=1, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read False, write True, on channel ( Async Mode )
|
||||
def test_4():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'auths': {'abcd': {'r': 0, 'w': 1, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': 'abcd', 'ttl': 1}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel="abcd", auth_key="abcd", read=False, write=True, ttl=1, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read False, write True, on channel ( Async Mode ), TTL 10
|
||||
def test_5():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'auths': {'abcd': {'r': 0, 'w': 1, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': 'abcd', 'ttl': 10}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel="abcd", auth_key="abcd", read=False, write=True, ttl=10, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read False, write True, without channel ( Async Mode ), TTL 10
|
||||
def test_6():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'r': 0, 'w': 1, 'm': 0,
|
||||
'subscribe_key': subkey,
|
||||
'level': 'subkey', 'ttl': 10}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
print(response)
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(read=False, write=True, ttl=10, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read False, write False, without channel ( Async Mode )
|
||||
def test_7():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'r': 0, 'w': 0, 'm': 0,
|
||||
'subscribe_key': subkey,
|
||||
'level': 'subkey', 'ttl': 1}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(read=False, write=False, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Complete flow , try publish on forbidden channel, grant permission to subkey and try again. ( Sync Mode)
|
||||
|
||||
def test_8():
|
||||
channel = "test_8-" + str(time.time())
|
||||
message = "Hello World"
|
||||
auth_key = "auth-" + channel
|
||||
pubnub.set_auth_key(auth_key)
|
||||
|
||||
def _cb2(resp):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'auths': {auth_key: {'r': 1, 'w': 1, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': channel, 'ttl': 10}
|
||||
}
|
||||
|
||||
def _cb3(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err3(resp):
|
||||
print(resp)
|
||||
assert False
|
||||
|
||||
time.sleep(7)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb3, error=_err3)
|
||||
|
||||
def _err2():
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel=channel, read=True, write=True, auth_key=auth_key, ttl=10, callback=_cb2, error=_err2)
|
||||
|
||||
|
||||
# Complete flow , try publish on forbidden channel, grant permission to authkey and try again.
|
||||
# then revoke and try again
|
||||
def test_9():
|
||||
channel = "test_9-" + str(time.time())
|
||||
message = "Hello World"
|
||||
auth_key = "auth-" + channel
|
||||
pubnub.set_auth_key(auth_key)
|
||||
|
||||
def _cb2(resp):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'auths': {auth_key: {'r': 1, 'w': 1, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': channel, 'ttl': 10}
|
||||
}
|
||||
|
||||
def _cb3(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _cb4(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'auths': {auth_key: {'r': 0, 'w': 0, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': channel, 'ttl': 1}
|
||||
}
|
||||
|
||||
def _cb5(resp, ch=None):
|
||||
print(resp)
|
||||
assert False
|
||||
|
||||
def _err5(resp):
|
||||
assert resp['message'] == 'Forbidden'
|
||||
assert resp['payload'] == {'channels': [channel]}
|
||||
|
||||
time.sleep(5)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb5, error=_err5)
|
||||
|
||||
def _err4(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.revoke(channel=channel, auth_key=auth_key, callback=_cb4, error=_err4)
|
||||
|
||||
def _err3(resp):
|
||||
assert False
|
||||
|
||||
time.sleep(7)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb3, error=_err3)
|
||||
|
||||
def _err2(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel=channel, read=True, write=True, auth_key=auth_key, ttl=10, callback=_cb2, error=_err2)
|
||||
|
||||
|
||||
# Complete flow , try publish on forbidden channel, grant permission channel level for subkey and try again.
|
||||
# then revoke and try again
|
||||
def test_10():
|
||||
channel = "test_10-" + str(time.time())
|
||||
message = "Hello World"
|
||||
auth_key = "auth-" + channel
|
||||
pubnub_pam.set_auth_key(auth_key)
|
||||
|
||||
def _cb2(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'channels': {channel: {'r': 1, 'w': 1, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'channel', 'ttl': 10}
|
||||
}
|
||||
|
||||
def _cb3(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _cb4(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'channels': {channel: {'r': 0, 'w': 0, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'channel', 'ttl': 1}
|
||||
}
|
||||
|
||||
def _cb5(resp, ch=None):
|
||||
assert False
|
||||
|
||||
def _err5(resp):
|
||||
assert resp['message'] == 'Forbidden'
|
||||
assert resp['payload'] == {'channels': [channel]}
|
||||
|
||||
time.sleep(5)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb5, error=_err5)
|
||||
|
||||
def _err4(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.revoke(channel=channel, callback=_cb4, error=_err4)
|
||||
|
||||
def _err3(resp):
|
||||
assert False
|
||||
|
||||
time.sleep(5)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb3, error=_err3)
|
||||
|
||||
def _err2(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel=channel, read=True, write=True, ttl=10, callback=_cb2, error=_err2)
|
||||
|
||||
|
||||
# Complete flow , try publish on forbidden channel, grant permission subkey level for subkey and try again.
|
||||
# then revoke and try again
|
||||
def test_11():
|
||||
channel = "test_11-" + str(time.time())
|
||||
message = "Hello World"
|
||||
auth_key = "auth-" + channel
|
||||
pubnub.set_auth_key(auth_key)
|
||||
|
||||
def _cb2(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'r': 1, 'w': 1, 'm': 0,
|
||||
'subscribe_key': subkey,
|
||||
'level': 'subkey', 'ttl': 10}
|
||||
}
|
||||
|
||||
def _cb3(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _cb4(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'r': 0, 'w': 0, 'm': 0,
|
||||
'subscribe_key': subkey,
|
||||
'level': 'subkey', 'ttl': 1}
|
||||
}
|
||||
|
||||
def _cb5(resp, ch=None):
|
||||
assert False
|
||||
|
||||
def _err5(resp):
|
||||
assert resp['message'] == 'Forbidden'
|
||||
assert resp['payload'] == {'channels': [channel]}
|
||||
|
||||
time.sleep(5)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb5, error=_err5)
|
||||
|
||||
def _err4(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.revoke(callback=_cb4, error=_err4)
|
||||
|
||||
def _err3(resp):
|
||||
assert False
|
||||
|
||||
time.sleep(5)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb3, error=_err3)
|
||||
|
||||
def _err2(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(read=True, write=True, ttl=10, callback=_cb2, error=_err2)
|
||||
|
||||
|
||||
x = 5
|
||||
|
||||
|
||||
def run_test(t):
|
||||
global x
|
||||
x += 5
|
||||
i = (x / 5) - 1
|
||||
|
||||
def _print():
|
||||
print('Running test ' + str(i))
|
||||
|
||||
pubnub.timeout(x, _print)
|
||||
pubnub.timeout(x + 1, t)
|
||||
|
||||
|
||||
def stop():
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
run_test(test_1)
|
||||
run_test(test_2)
|
||||
run_test(test_3)
|
||||
run_test(test_4)
|
||||
run_test(test_5)
|
||||
run_test(test_6)
|
||||
run_test(test_7)
|
||||
run_test(test_8)
|
||||
run_test(test_9)
|
||||
run_test(test_10)
|
||||
run_test(test_11)
|
||||
run_test(stop)
|
||||
|
||||
pubnub_pam.start()
|
||||
|
|
@ -0,0 +1,333 @@
|
|||
import time
|
||||
# from twisted.trial import unittest
|
||||
|
||||
from pubnub import PubnubTornado as Pubnub
|
||||
|
||||
pubkey = "pub-c-37d3c709-c35e-487a-8b33-2314d9b62b28"
|
||||
subkey = "sub-c-cd0b6288-cdf5-11e5-bcee-0619f8945a4f"
|
||||
pubnub = Pubnub(pubkey, subkey)
|
||||
pubnub_enc = Pubnub(pubkey, subkey, cipher_key="enigma")
|
||||
|
||||
|
||||
# class PublishTests(unittest.TestCase):
|
||||
def test_1():
|
||||
channel = "test_1-" + str(time.time())
|
||||
message = "I am a string"
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive array
|
||||
def test_2():
|
||||
channel = "test_2-" + str(time.time())
|
||||
message = [1, 2]
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
print(resp)
|
||||
assert False
|
||||
|
||||
pubnub.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive json object
|
||||
def test_3():
|
||||
channel = "test_2-" + str(time.time())
|
||||
message = {"a": "b"}
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive number
|
||||
def test_4():
|
||||
channel = "test_2-" + str(time.time())
|
||||
message = 100
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive number string
|
||||
def test_5():
|
||||
channel = "test_5-" + str(time.time())
|
||||
message = "100"
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive string (Encryption enabled)
|
||||
def test_6():
|
||||
channel = "test_6-" + str(time.time())
|
||||
message = "I am a string"
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive array (Encryption enabled)
|
||||
def test_7():
|
||||
channel = "test_7-" + str(time.time())
|
||||
message = [1, 2]
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive json object (Encryption enabled)
|
||||
def test_8():
|
||||
channel = "test_8-" + str(time.time())
|
||||
message = {"a": "b"}
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive number (Encryption enabled)
|
||||
def test_9():
|
||||
channel = "test_9-" + str(time.time())
|
||||
message = 100
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive number string (Encryption enabled)
|
||||
def test_10():
|
||||
channel = "test_10-" + str(time.time())
|
||||
message = "100"
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive object string (Encryption enabled)
|
||||
def test_11():
|
||||
channel = "test_11-" + str(time.time())
|
||||
message = '{"a" : "b"}'
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive array string (Encryption enabled)
|
||||
def test_12():
|
||||
channel = "test_12-" + str(time.time())
|
||||
message = '[1,2]'
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
x = 5
|
||||
|
||||
|
||||
def run_test(t):
|
||||
global x
|
||||
x += 5
|
||||
i = (x / 5) - 1
|
||||
|
||||
def _print():
|
||||
print('Running test ' + str(i))
|
||||
|
||||
pubnub.timeout(x, _print)
|
||||
pubnub.timeout(x + 1, t)
|
||||
|
||||
|
||||
def stop():
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
run_test(test_1)
|
||||
run_test(test_2)
|
||||
run_test(test_3)
|
||||
run_test(test_4)
|
||||
run_test(test_5)
|
||||
run_test(test_6)
|
||||
run_test(test_7)
|
||||
run_test(test_8)
|
||||
run_test(test_9)
|
||||
run_test(test_10)
|
||||
run_test(test_11)
|
||||
run_test(stop)
|
||||
|
||||
pubnub_enc.start()
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
PubNub Real-time Cloud-Hosted Push API and Push Notification Client Frameworks
|
||||
Copyright (c) 2013 PubNub Inc.
|
||||
http://www.pubnub.com/
|
||||
http://www.pubnub.com/terms
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
|
||||
PubNub Real-time Cloud-Hosted Push API and Push Notification Client Frameworks
|
||||
Copyright (c) 2013 PubNub Inc.
|
||||
http://www.pubnub.com/
|
||||
http://www.pubnub.com/terms
|
||||
|
|
@ -0,0 +1,137 @@
|
|||
## Contact support@pubnub.com for all questions
|
||||
|
||||
#### [PubNub](http://www.pubnub.com) Real-time Data Network
|
||||
##### Twisted Client
|
||||
|
||||
## IO Event Loop
|
||||
Be sure to eventually start the event loop or PubNub won't run!
|
||||
|
||||
```
|
||||
pubnub.start()
|
||||
```
|
||||
|
||||
#### Import
|
||||
```
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
```
|
||||
|
||||
#### Init
|
||||
```
|
||||
pubnub = Pubnub(publish_key="demo", subscribe_key="demo", ssl_on=False)
|
||||
```
|
||||
|
||||
#### Publish Example
|
||||
```
|
||||
channel = 'hello_world'
|
||||
message = 'Hello World !!!'
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.publish(channel, message, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### Subscribe Example
|
||||
```
|
||||
channel = 'hello_world'
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.subscribe(channel, callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
```
|
||||
|
||||
#### History Example
|
||||
```
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.history(channel, count=2, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### Here Now Example
|
||||
```
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.here_now(channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### Presence Example
|
||||
```
|
||||
channel = 'hello_world'
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
pubnub.presence(channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### Unsubscribe Example
|
||||
```
|
||||
pubnub.unsubscribe(channel='hello_world')
|
||||
```
|
||||
|
||||
#### Grant Example
|
||||
```
|
||||
authkey = "abcd"
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.grant(channel, authkey, True, True, callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
#### Audit Example
|
||||
```
|
||||
authkey = "abcd"
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.audit(channel, authkey, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### Revoke Example
|
||||
```
|
||||
authkey = "abcd"
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.revoke(channel, authkey, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
|
||||
#### IO Event Loop start
|
||||
```
|
||||
pubnub.start()
|
||||
```
|
||||
|
||||
## Contact support@pubnub.com for all questions
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
authkey = "abcd"
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.audit(channel, auth_key=authkey, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
# www.pubnub.com - PubNub - Data Stream Network
|
||||
# coding=utf8
|
||||
|
||||
# PubNub Real-time Push APIs and Notifications Framework
|
||||
# Copyright (c) 2010 Stephen Blum
|
||||
# http://www.pubnub.com/
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Import Libs
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Configuration
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
publish_key = 'pub-c-f6a20151-db8d-45af-ba42-def0edaa459f'
|
||||
subscribe_key = 'sub-c-b5ff3208-7f64-11e4-b601-02ee2ddab7fe'
|
||||
server_channel = 'echo-server'
|
||||
client_channel = 'echo-channel'
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Create PubNub Instance
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
pubnub = Pubnub(
|
||||
publish_key=publish_key,
|
||||
subscribe_key=subscribe_key,
|
||||
ssl_on=True
|
||||
)
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Error Log
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def error_log(data):
|
||||
print(data)
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Access Log
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def access_log(data):
|
||||
print(data)
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Respond
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def request():
|
||||
pubnub.publish(
|
||||
server_channel,
|
||||
{'response': client_channel, 'body': "Hello"},
|
||||
callback=access_log,
|
||||
error=error_log
|
||||
)
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Request Received
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def onResponse(data, channel):
|
||||
print("Channel: %s | Req: %s" % (channel, data))
|
||||
request()
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Ready to Receive Requests
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def onReady(message):
|
||||
print("Ready to Receive Requests on '%s'" % server_channel)
|
||||
request()
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Network Recovered
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def onReconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Network Failed
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def onDisconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Start Echo Server
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
pubnub.subscribe(
|
||||
client_channel,
|
||||
callback=onResponse,
|
||||
error=error_log,
|
||||
connect=onReady,
|
||||
reconnect=onReconnect,
|
||||
disconnect=onDisconnect
|
||||
)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,104 @@
|
|||
# www.pubnub.com - PubNub - Data Stream Network
|
||||
# coding=utf8
|
||||
|
||||
# PubNub Real-time Push APIs and Notifications Framework
|
||||
# Copyright (c) 2010 Stephen Blum
|
||||
# http://www.pubnub.com/
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Import Libs
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Configuration
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
publish_key = 'pub-c-f6a20151-db8d-45af-ba42-def0edaa459f'
|
||||
subscribe_key = 'sub-c-b5ff3208-7f64-11e4-b601-02ee2ddab7fe'
|
||||
server_channel = 'echo-server'
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Create PubNub Instance
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
pubnub = Pubnub(
|
||||
publish_key=publish_key,
|
||||
subscribe_key=subscribe_key,
|
||||
ssl_on=True
|
||||
)
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Error Log
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def error_log(data):
|
||||
print(data)
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Access Log
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def access_log(data):
|
||||
print(data)
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Respond
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def respond(channel, body):
|
||||
pubnub.publish(
|
||||
channel,
|
||||
body,
|
||||
callback=access_log,
|
||||
error=error_log
|
||||
)
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Request Received
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def onRequest(request, channel):
|
||||
response_channel = request['response']
|
||||
response_body = request['body']
|
||||
|
||||
print("Channel: %s | Req: %s" % (channel, request))
|
||||
|
||||
respond(
|
||||
channel=response_channel,
|
||||
body=response_body
|
||||
)
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Ready to Receive Requests
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def onReady(message):
|
||||
print("Ready to Receive Requests on '%s'" % server_channel)
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Network Recovered
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def onReconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Network Failed
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
def onDisconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
# Start Echo Server
|
||||
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
||||
pubnub.subscribe(
|
||||
server_channel,
|
||||
callback=onRequest,
|
||||
error=error_log,
|
||||
connect=onReady,
|
||||
reconnect=onReconnect,
|
||||
disconnect=onDisconnect
|
||||
)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
authkey = "abcd"
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.grant(channel, authkey, True, True, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.here_now(channel, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'a'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.history(channel, count=2, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
message = 'Hello World !!!'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.publish(channel, message, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
authkey = "abcd"
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
pubnub.revoke(channel, authkey, callback=callback, error=callback)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
|
||||
channel = 'a'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.subscribe(channel, callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or 'abcd'
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on, daemon=False)
|
||||
|
||||
channel = 'ab'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message, channel):
|
||||
print(str(message) + ' , ' + channel)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED " + str(message))
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED " + str(message))
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED " + str(message))
|
||||
|
||||
|
||||
print(pubnub.channel_group_add_channel(channel_group='abc', channel="a"))
|
||||
|
||||
pubnub.subscribe_group(channel_groups='abc', callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,205 @@
|
|||
## Contact support@pubnub.com for all questions
|
||||
|
||||
#### [PubNub](http://www.pubnub.com) Real-time Data Network
|
||||
##### Twisted Migration
|
||||
|
||||
#### Import
|
||||
|
||||
```
|
||||
# Pre 3.5:
|
||||
from pubnub import Pubnub
|
||||
|
||||
# New in 3.5+
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### Init
|
||||
|
||||
```
|
||||
|
||||
# Pre 3.5:
|
||||
pubnub = Pubnub(
|
||||
"demo", ## PUBLISH_KEY
|
||||
"demo", ## SUBSCRIBE_KEY
|
||||
False ## SSL_ON?
|
||||
)
|
||||
|
||||
# New in 3.5+
|
||||
pubnub = Pubnub(publish_key="demo", subscribe_key="demo", ssl_on=False)
|
||||
|
||||
```
|
||||
|
||||
#### PUBLISH
|
||||
|
||||
```
|
||||
channel = 'hello_world'
|
||||
message = 'Hello World !!!'
|
||||
|
||||
# Pre 3.5:
|
||||
def callback(messages):
|
||||
print(messages)
|
||||
|
||||
pubnub.publish( {
|
||||
'channel' : channel,
|
||||
'message' : message,
|
||||
'callback' : callback
|
||||
})
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.publish(channel, message, callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### SUBSCRIBE
|
||||
|
||||
```
|
||||
|
||||
# Listen for Messages
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
# Pre 3.5:
|
||||
def connected() :
|
||||
print('CONNECTED')
|
||||
|
||||
def message_received(message):
|
||||
print(message)
|
||||
|
||||
pubnub.subscribe({
|
||||
'channel' : channel,
|
||||
'connect' : connected,
|
||||
'callback' : message_received
|
||||
})
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.subscribe(channel, callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
```
|
||||
|
||||
#### Unsubscribe
|
||||
Once subscribed, you can easily, gracefully, unsubscribe:
|
||||
|
||||
```
|
||||
# Pre 3.5:
|
||||
pubnub.unsubscribe({
|
||||
'channel' : 'hello_world'
|
||||
})
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
pubnub.unsubscribe(channel='hello_world')
|
||||
```
|
||||
|
||||
#### PRESENCE
|
||||
|
||||
```
|
||||
|
||||
# Pre 3.5:
|
||||
#
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
# Listen for Presence Event Messages
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
pubnub.presence(channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### HERE_NOW
|
||||
|
||||
```
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
# Pre 3.5:
|
||||
def callback(messages):
|
||||
print(messages)
|
||||
|
||||
pubnub.here_now( {
|
||||
'channel' : channel,
|
||||
'callback' : callback
|
||||
})
|
||||
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
# Get info on who is here right now!
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.here_now(channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### HISTORY
|
||||
|
||||
```
|
||||
channel = 'hello_world'
|
||||
|
||||
# Pre 3.5:
|
||||
def history_complete(messages):
|
||||
print(messages)
|
||||
|
||||
pubnub.history( {
|
||||
'channel' : channel,
|
||||
'limit' : 2,
|
||||
'callback' : history_complete
|
||||
})
|
||||
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.history(channel, count=2, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### IO Event Loop
|
||||
|
||||
```
|
||||
|
||||
# Pre 3.5:
|
||||
reactor.run()
|
||||
|
||||
# New in 3.5+
|
||||
pubnub.start()
|
||||
```
|
||||
## Contact support@pubnub.com for all questions
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
# 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/
|
||||
|
||||
import datetime
|
||||
import sys
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or 'demo'
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
origin = len(sys.argv) > 6 and sys.argv[6] or 'pubsub.pubnub.com'
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiat Class
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(
|
||||
publish_key,
|
||||
subscribe_key,
|
||||
secret_key=secret_key,
|
||||
cipher_key=cipher_key,
|
||||
ssl_on=ssl_on,
|
||||
origin=origin
|
||||
)
|
||||
crazy = ' ~`!@#$%^&*( 顶顅 Ȓ)+=[]\\{}|;\':",./<>?abcd'
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# BENCHMARK
|
||||
# -----------------------------------------------------------------------
|
||||
def success(msg):
|
||||
print(msg)
|
||||
|
||||
|
||||
def connected(msg):
|
||||
pubnub.publish(crazy, {'Info': 'Connected!'}, error=error, callback=success)
|
||||
|
||||
|
||||
def error(err):
|
||||
print(err)
|
||||
|
||||
trips = {'last': None, 'current': None, 'max': 0, 'avg': 0}
|
||||
|
||||
|
||||
def received(message):
|
||||
current_trip = trips['current'] = str(datetime.datetime.now())[0:19]
|
||||
last_trip = trips['last'] = str(
|
||||
datetime.datetime.now() - datetime.timedelta(seconds=1)
|
||||
)[0:19]
|
||||
|
||||
# New Trip Span (1 Second)
|
||||
if current_trip not in trips:
|
||||
trips[current_trip] = 0
|
||||
|
||||
# Average
|
||||
if last_trip in trips:
|
||||
trips['avg'] = (trips['avg'] + trips[last_trip]) / 2
|
||||
|
||||
# Increment Trip Counter
|
||||
trips[current_trip] = trips[current_trip] + 1
|
||||
|
||||
# Update Max
|
||||
if trips[current_trip] > trips['max']:
|
||||
trips['max'] = trips[current_trip]
|
||||
|
||||
print(message)
|
||||
|
||||
pubnub.publish(crazy, current_trip +
|
||||
" Trip: " +
|
||||
str(trips[current_trip]) +
|
||||
" MAX: " +
|
||||
str(trips['max']) +
|
||||
"/sec " +
|
||||
" AVG: " +
|
||||
str(trips['avg']) +
|
||||
"/sec", error=error)
|
||||
|
||||
|
||||
pubnub.subscribe(crazy, received, connect=connected, error=error)
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# IO Event Loop
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
## www.pubnub.com - PubNub Real-time push service in the cloud.
|
||||
# coding=utf8
|
||||
|
||||
## PubNub Real-time Push APIs and Notifications Framework
|
||||
## Copyright (c) 2010 Stephen Blum
|
||||
## http://www.pubnub.com/
|
||||
|
||||
## -----------------------------------
|
||||
## PubNub 3.1 Real-time Push Cloud API
|
||||
## -----------------------------------
|
||||
|
||||
import sys
|
||||
import datetime
|
||||
import time
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Configuration
|
||||
## -----------------------------------------------------------------------
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or 'demo'
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
origin = len(sys.argv) > 6 and sys.argv[6] or 'pubsub.pubnub.com'
|
||||
origin = '184.72.9.220'
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Analytics
|
||||
## -----------------------------------------------------------------------
|
||||
analytics = {
|
||||
'publishes': 0, # Total Send Requests
|
||||
'received': 0, # Total Received Messages (Deliveries)
|
||||
'queued': 0, # Total Unreceived Queue (UnDeliveries)
|
||||
'successful_publishes': 0, # Confirmed Successful Publish Request
|
||||
'failed_publishes': 0, # Confirmed UNSuccessful Publish Request
|
||||
'failed_deliveries': 0, # (successful_publishes - received)
|
||||
'deliverability': 0 # Percentage Delivery
|
||||
}
|
||||
|
||||
trips = {
|
||||
'last': None,
|
||||
'current': None,
|
||||
'max': 0,
|
||||
'avg': 0
|
||||
}
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Initiat Class
|
||||
## -----------------------------------------------------------------------
|
||||
channel = 'deliverability-' + str(time.time())
|
||||
pubnub = Pubnub(
|
||||
publish_key,
|
||||
subscribe_key,
|
||||
secret_key=secret_key,
|
||||
cipher_key=cipher_key,
|
||||
ssl_on=ssl_on,
|
||||
origin=origin
|
||||
)
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## BENCHMARK
|
||||
## -----------------------------------------------------------------------
|
||||
|
||||
|
||||
def publish_sent(info=None):
|
||||
if info and info[0]:
|
||||
analytics['successful_publishes'] += 1
|
||||
else:
|
||||
analytics['failed_publishes'] += 1
|
||||
|
||||
analytics['publishes'] += 1
|
||||
analytics['queued'] += 1
|
||||
|
||||
pubnub.timeout(send, 0.1)
|
||||
|
||||
|
||||
def send():
|
||||
if analytics['queued'] > 100:
|
||||
analytics['queued'] -= 10
|
||||
return pubnub.timeout(send, 10)
|
||||
|
||||
pubnub.publish({
|
||||
'channel': channel,
|
||||
'callback': publish_sent,
|
||||
'message': "1234567890"
|
||||
})
|
||||
|
||||
|
||||
def received(message):
|
||||
analytics['queued'] -= 1
|
||||
analytics['received'] += 1
|
||||
current_trip = trips['current'] = str(datetime.datetime.now())[0:19]
|
||||
last_trip = trips['last'] = str(
|
||||
datetime.datetime.now() - datetime.timedelta(seconds=1)
|
||||
)[0:19]
|
||||
|
||||
## New Trip Span (1 Second)
|
||||
if current_trip not in trips:
|
||||
trips[current_trip] = 0
|
||||
|
||||
## Average
|
||||
if last_trip in trips:
|
||||
trips['avg'] = (trips['avg'] + trips[last_trip]) / 2
|
||||
|
||||
## Increment Trip Counter
|
||||
trips[current_trip] = trips[current_trip] + 1
|
||||
|
||||
## Update Max
|
||||
if trips[current_trip] > trips['max']:
|
||||
trips['max'] = trips[current_trip]
|
||||
|
||||
|
||||
def show_status():
|
||||
## Update Failed Deliveries
|
||||
analytics['failed_deliveries'] = \
|
||||
analytics['successful_publishes'] \
|
||||
- analytics['received']
|
||||
|
||||
## Update Deliverability
|
||||
analytics['deliverability'] = (
|
||||
float(analytics['received']) /
|
||||
float(analytics['successful_publishes'] or 1.0)
|
||||
) * 100.0
|
||||
|
||||
## Print Display
|
||||
print((
|
||||
"max:%(max)03d/sec " +
|
||||
"avg:%(avg)03d/sec " +
|
||||
"pubs:%(publishes)05d " +
|
||||
"received:%(received)05d " +
|
||||
"spub:%(successful_publishes)05d " +
|
||||
"fpub:%(failed_publishes)05d " +
|
||||
"failed:%(failed_deliveries)05d " +
|
||||
"queued:%(queued)03d " +
|
||||
"delivery:%(deliverability)03f%% " +
|
||||
""
|
||||
) % {
|
||||
'max': trips['max'],
|
||||
'avg': trips['avg'],
|
||||
'publishes': analytics['publishes'],
|
||||
'received': analytics['received'],
|
||||
'successful_publishes': analytics['successful_publishes'],
|
||||
'failed_publishes': analytics['failed_publishes'],
|
||||
'failed_deliveries': analytics['failed_deliveries'],
|
||||
'publishes': analytics['publishes'],
|
||||
'deliverability': analytics['deliverability'],
|
||||
'queued': analytics['queued']
|
||||
})
|
||||
pubnub.timeout(show_status, 1)
|
||||
|
||||
|
||||
def connected():
|
||||
show_status()
|
||||
pubnub.timeout(send, 1)
|
||||
|
||||
print("Connected: %s\n" % origin)
|
||||
pubnub.subscribe({
|
||||
'channel': channel,
|
||||
'connect': connected,
|
||||
'callback': received
|
||||
})
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## IO Event Loop
|
||||
## -----------------------------------------------------------------------
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,156 @@
|
|||
## www.pubnub.com - PubNub Real-time push service in the cloud.
|
||||
# coding=utf8
|
||||
|
||||
## PubNub Real-time Push APIs and Notifications Framework
|
||||
## Copyright (c) 2010 Stephen Blum
|
||||
## http://www.pubnub.com/
|
||||
|
||||
## -----------------------------------
|
||||
## PubNub 3.1 Real-time Push Cloud API
|
||||
## -----------------------------------
|
||||
|
||||
import sys
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
from functools import partial
|
||||
from threading import current_thread
|
||||
import threading
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or None
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Initiate Pubnub State
|
||||
## -----------------------------------------------------------------------
|
||||
#pubnub = Pubnub( publish_key, subscribe_key, secret_key, cipher_key, ssl_on )
|
||||
pubnub = Pubnub(publish_key, subscribe_key, secret_key, ssl_on)
|
||||
crazy = 'hello_world'
|
||||
|
||||
current = -1
|
||||
|
||||
errors = 0
|
||||
received = 0
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Subscribe Example
|
||||
## -----------------------------------------------------------------------
|
||||
|
||||
|
||||
def message_received(message):
|
||||
print(message)
|
||||
|
||||
|
||||
def check_received(message):
|
||||
global current
|
||||
global errors
|
||||
global received
|
||||
print(message)
|
||||
print(current)
|
||||
if message <= current:
|
||||
print('ERROR')
|
||||
#sys.exit()
|
||||
errors += 1
|
||||
else:
|
||||
received += 1
|
||||
print('active thread count : ', threading.activeCount())
|
||||
print('errors = ', errors)
|
||||
print(current_thread().getName(), ' , ', 'received = ', received)
|
||||
|
||||
if received != message:
|
||||
print('********** MISSED **************** ', message - received)
|
||||
current = message
|
||||
|
||||
|
||||
def connected_test(ch):
|
||||
print('Connected', ch)
|
||||
|
||||
|
||||
def connected(ch):
|
||||
pass
|
||||
|
||||
|
||||
'''
|
||||
pubnub.subscribe({
|
||||
'channel' : 'abcd1',
|
||||
'connect' : connected,
|
||||
'callback' : message_received
|
||||
})
|
||||
'''
|
||||
|
||||
|
||||
def cb1():
|
||||
pubnub.subscribe({
|
||||
'channel': 'efgh1',
|
||||
'connect': connected,
|
||||
'callback': message_received
|
||||
})
|
||||
|
||||
|
||||
def cb2():
|
||||
pubnub.subscribe({
|
||||
'channel': 'dsm-test',
|
||||
'connect': connected_test,
|
||||
'callback': check_received
|
||||
})
|
||||
|
||||
|
||||
def cb3():
|
||||
pubnub.unsubscribe({'channel': 'efgh1'})
|
||||
|
||||
|
||||
def cb4():
|
||||
pubnub.unsubscribe({'channel': 'abcd1'})
|
||||
|
||||
|
||||
def subscribe(channel):
|
||||
pubnub.subscribe({
|
||||
'channel': channel,
|
||||
'connect': connected,
|
||||
'callback': message_received
|
||||
})
|
||||
|
||||
|
||||
print(threading.activeCount())
|
||||
|
||||
|
||||
pubnub.timeout(15, cb1)
|
||||
|
||||
pubnub.timeout(30, cb2)
|
||||
|
||||
|
||||
pubnub.timeout(45, cb3)
|
||||
|
||||
pubnub.timeout(60, cb4)
|
||||
|
||||
#'''
|
||||
for x in range(1, 1000):
|
||||
#print x
|
||||
def y(t):
|
||||
subscribe('channel-' + str(t))
|
||||
|
||||
def z(t):
|
||||
pubnub.unsubscribe({'channel': 'channel-' + str(t)})
|
||||
|
||||
pubnub.timeout(x + 5, partial(y, x))
|
||||
pubnub.timeout(x + 25, partial(z, x))
|
||||
x += 10
|
||||
#'''
|
||||
|
||||
'''
|
||||
for x in range(1,1000):
|
||||
def cb(r): print r , ' : ', threading.activeCount()
|
||||
def y(t):
|
||||
pubnub.publish({
|
||||
'message' : t,
|
||||
'callback' : cb,
|
||||
'channel' : 'dsm-test'
|
||||
})
|
||||
|
||||
|
||||
pubnub.timeout(x + 1, partial(y,x))
|
||||
x += 1
|
||||
'''
|
||||
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,365 @@
|
|||
import time
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
subkey = "sub-c-9aeec0d4-cdf4-11e5-bcee-0619f8945a4f"
|
||||
pubkey = "pub-c-b3fdf8fc-4516-4ab2-8836-6fb22ba7870d"
|
||||
secretkey = "sec-c-ZDQwNTUwMDctZDViYi00MzhlLTg2NTctYjViZDcwNTA5Zjhj"
|
||||
pubnub = Pubnub(pubkey, subkey)
|
||||
pubnub_pam = Pubnub(pubkey, subkey, secretkey)
|
||||
|
||||
|
||||
# Grant permission read true, write true, on channel ( Async Mode )
|
||||
def test_1():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'auths': {u'abcd': {u'r': 1, u'w': 1}},
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'user', u'channel': u'abcd', u'ttl': 1}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel="abcd", auth_key="abcd", read=True, write=True, ttl=1, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read false, write false, on channel ( Async Mode )
|
||||
def test_2():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'auths': {u'abcd': {u'r': 0, u'm': 0, u'w': 0}},
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'user', u'channel': u'abcd', u'ttl': 1}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
print("error")
|
||||
print(response)
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel="abcd", auth_key="abcd", read=False, write=False, ttl=1, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read True, write false, on channel ( Async Mode )
|
||||
def test_3():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'auths': {u'abcd': {u'r': 1, u'm': 0, u'w': 0}},
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'user', u'channel': u'abcd', u'ttl': 1}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel="abcd", auth_key="abcd", read=True, write=False, ttl=1, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read False, write True, on channel ( Async Mode )
|
||||
def test_4():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'auths': {u'abcd': {u'r': 0, u'm': 0, u'w': 1}},
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'user', u'channel': u'abcd', u'ttl': 1}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel="abcd", auth_key="abcd", read=False, write=True, ttl=1, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read False, write True, on channel ( Async Mode ), TTL 10
|
||||
def test_5():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'auths': {u'abcd': {u'r': 0, u'm': 0, u'w': 1}},
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'user', u'channel': u'abcd', u'ttl': 10}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel="abcd", auth_key="abcd", read=False, write=True, ttl=10, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read False, write True, without channel ( Async Mode ), TTL 10
|
||||
def test_6():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'r': 0, u'm': 0, u'w': 1,
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'subkey', u'ttl': 10}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
print(response)
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(read=False, write=True, ttl=10, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Grant permission read False, write False, without channel ( Async Mode )
|
||||
def test_7():
|
||||
def _callback(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'r': 0, u'm': 0, u'w': 0,
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'subkey', u'ttl': 1}
|
||||
}
|
||||
|
||||
def _error(response):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(read=False, write=False, callback=_callback, error=_error)
|
||||
|
||||
|
||||
# Complete flow , try publish on forbidden channel, grant permission to subkey and try again. ( Sync Mode)
|
||||
|
||||
def test_8():
|
||||
channel = "test_8-" + str(time.time())
|
||||
message = "Hello World"
|
||||
auth_key = "auth-" + channel
|
||||
pubnub.set_auth_key(auth_key)
|
||||
|
||||
def _cb2(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'auths': {auth_key: {u'r': 1, u'm': 0, u'w': 1}},
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'user', u'channel': channel, u'ttl': 10}
|
||||
}
|
||||
|
||||
def _cb3(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err3(resp):
|
||||
print(resp)
|
||||
assert False
|
||||
|
||||
time.sleep(7)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb3, error=_err3)
|
||||
|
||||
def _err2(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel=channel, read=True, write=True, auth_key=auth_key, ttl=10, callback=_cb2, error=_err2)
|
||||
|
||||
|
||||
# Complete flow , try publish on forbidden channel, grant permission to authkey and try again.
|
||||
# then revoke and try again
|
||||
def test_9():
|
||||
channel = "test_9-" + str(time.time())
|
||||
message = "Hello World"
|
||||
auth_key = "auth-" + channel
|
||||
pubnub.set_auth_key(auth_key)
|
||||
|
||||
def _cb2(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'auths': {auth_key: {u'r': 1, u'm': 0, u'w': 1}},
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'user', u'channel': channel, u'ttl': 10}
|
||||
}
|
||||
|
||||
def _cb3(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _cb4(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'auths': {auth_key: {u'r': 0, u'm': 0, u'w': 0}},
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'user', u'channel': channel, u'ttl': 1}
|
||||
}
|
||||
|
||||
def _cb5(resp, ch=None):
|
||||
print(resp)
|
||||
assert False
|
||||
|
||||
def _err5(resp):
|
||||
assert resp['message'] == 'Forbidden'
|
||||
assert resp['payload'] == {u'channels': [channel]}
|
||||
|
||||
time.sleep(5)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb5, error=_err5)
|
||||
|
||||
def _err4(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.revoke(channel=channel, auth_key=auth_key, callback=_cb4, error=_err4)
|
||||
|
||||
def _err3(resp):
|
||||
assert False
|
||||
|
||||
time.sleep(7)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb3, error=_err3)
|
||||
|
||||
def _err2(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel=channel, read=True, write=True, auth_key=auth_key, ttl=10, callback=_cb2, error=_err2)
|
||||
|
||||
|
||||
# Complete flow , try publish on forbidden channel, grant permission channel level for subkey and try again.
|
||||
# then revoke and try again
|
||||
def test_10():
|
||||
channel = "test_10-" + str(time.time())
|
||||
message = "Hello World"
|
||||
auth_key = "auth-" + channel
|
||||
pubnub.set_auth_key(auth_key)
|
||||
|
||||
def _cb1(resp, ch=None):
|
||||
assert False
|
||||
|
||||
def _err1(resp):
|
||||
assert resp['message'] == 'Forbidden'
|
||||
assert resp['payload'] == {u'channels': [channel]}
|
||||
|
||||
def _cb2(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'channels': {channel: {u'r': 1, u'm': 0, u'w': 1}},
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'channel', u'ttl': 10}
|
||||
}
|
||||
|
||||
def _cb3(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _cb4(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'channels': {channel: {u'r': 0, u'm': 0, u'w': 0}},
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'channel', u'ttl': 1}
|
||||
}
|
||||
|
||||
def _cb5(resp, ch=None):
|
||||
print(resp)
|
||||
assert False
|
||||
|
||||
def _err5(resp):
|
||||
assert resp['message'] == 'Forbidden'
|
||||
assert resp['payload'] == {u'channels': [channel]}
|
||||
|
||||
time.sleep(5)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb5, error=_err5)
|
||||
|
||||
def _err4(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.revoke(channel=channel, callback=_cb4, error=_err4)
|
||||
|
||||
def _err3(resp):
|
||||
assert False
|
||||
|
||||
time.sleep(5)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb3, error=_err3)
|
||||
|
||||
def _err2(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(channel=channel, read=True, write=True, ttl=10, callback=_cb2, error=_err2)
|
||||
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb1, error=_err1)
|
||||
|
||||
|
||||
# Complete flow , try publish on forbidden channel, grant permission subkey level for subkey and try again.
|
||||
# then revoke and try again
|
||||
def test_11():
|
||||
channel = "test_11-" + str(time.time())
|
||||
message = "Hello World"
|
||||
auth_key = "auth-" + channel
|
||||
pubnub.set_auth_key(auth_key)
|
||||
|
||||
def _cb2(resp, ch=None):
|
||||
print(resp)
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'r': 1, u'm': 0, u'w': 1,
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'subkey', u'ttl': 10}
|
||||
}
|
||||
|
||||
def _cb3(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _cb4(resp, ch=None):
|
||||
assert resp == {
|
||||
'message': u'Success',
|
||||
'payload': {u'r': 0, u'm': 0, u'w': 0,
|
||||
u'subscribe_key': subkey,
|
||||
u'level': u'subkey', u'ttl': 1}
|
||||
}
|
||||
|
||||
def _cb5(resp, ch=None):
|
||||
assert False
|
||||
|
||||
def _err5(resp):
|
||||
assert resp['message'] == 'Forbidden'
|
||||
assert resp['payload'] == {u'channels': [channel]}
|
||||
|
||||
time.sleep(5)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb5, error=_err5)
|
||||
|
||||
def _err4(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.revoke(callback=_cb4, error=_err4)
|
||||
|
||||
def _err3(resp):
|
||||
assert False
|
||||
|
||||
time.sleep(5)
|
||||
pubnub.publish(channel=channel, message=message, callback=_cb3, error=_err3)
|
||||
|
||||
def _err2(resp):
|
||||
assert False
|
||||
|
||||
pubnub_pam.grant(read=True, write=True, ttl=10, callback=_cb2, error=_err2)
|
||||
|
||||
|
||||
x = 5
|
||||
|
||||
|
||||
def run_test(t):
|
||||
global x
|
||||
x += 5
|
||||
i = (x / 5) - 1
|
||||
|
||||
def _print():
|
||||
print('Running test ' + str(i))
|
||||
|
||||
pubnub.timeout(x, _print)
|
||||
pubnub.timeout(x + 1, t)
|
||||
|
||||
|
||||
def stop():
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
run_test(test_1)
|
||||
run_test(test_2)
|
||||
run_test(test_3)
|
||||
run_test(test_4)
|
||||
run_test(test_5)
|
||||
run_test(test_6)
|
||||
run_test(test_7)
|
||||
run_test(test_8)
|
||||
run_test(test_9)
|
||||
run_test(test_10)
|
||||
run_test(test_11)
|
||||
run_test(stop)
|
||||
|
||||
pubnub_pam.start()
|
||||
|
|
@ -0,0 +1,333 @@
|
|||
import time
|
||||
# from twisted.trial import unittest
|
||||
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
pubkey = "pub-c-37d3c709-c35e-487a-8b33-2314d9b62b28"
|
||||
subkey = "sub-c-cd0b6288-cdf5-11e5-bcee-0619f8945a4f"
|
||||
pubnub = Pubnub(pubkey, subkey)
|
||||
pubnub_enc = Pubnub(pubkey, subkey, cipher_key="enigma")
|
||||
|
||||
|
||||
# class PublishTests(unittest.TestCase):
|
||||
def test_1():
|
||||
channel = "test_1-" + str(time.time())
|
||||
message = "I am a string"
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive array
|
||||
def test_2():
|
||||
channel = "test_2-" + str(time.time())
|
||||
message = [1, 2]
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
print(resp)
|
||||
assert False
|
||||
|
||||
pubnub.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive json object
|
||||
def test_3():
|
||||
channel = "test_2-" + str(time.time())
|
||||
message = {"a": "b"}
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive number
|
||||
def test_4():
|
||||
channel = "test_2-" + str(time.time())
|
||||
message = 100
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive number string
|
||||
def test_5():
|
||||
channel = "test_5-" + str(time.time())
|
||||
message = "100"
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive string (Encryption enabled)
|
||||
def test_6():
|
||||
channel = "test_6-" + str(time.time())
|
||||
message = "I am a string"
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive array (Encryption enabled)
|
||||
def test_7():
|
||||
channel = "test_7-" + str(time.time())
|
||||
message = [1, 2]
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive json object (Encryption enabled)
|
||||
def test_8():
|
||||
channel = "test_8-" + str(time.time())
|
||||
message = {"a": "b"}
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive number (Encryption enabled)
|
||||
def test_9():
|
||||
channel = "test_9-" + str(time.time())
|
||||
message = 100
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive number string (Encryption enabled)
|
||||
def test_10():
|
||||
channel = "test_10-" + str(time.time())
|
||||
message = "100"
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive object string (Encryption enabled)
|
||||
def test_11():
|
||||
channel = "test_11-" + str(time.time())
|
||||
message = '{"a" : "b"}'
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
# Publish and receive array string (Encryption enabled)
|
||||
def test_12():
|
||||
channel = "test_12-" + str(time.time())
|
||||
message = '[1,2]'
|
||||
|
||||
def _cb(resp, ch=None):
|
||||
assert resp == message
|
||||
pubnub_enc.unsubscribe(channel)
|
||||
|
||||
def _connect(resp):
|
||||
def _cb1(resp, ch=None):
|
||||
assert resp[0] == 1
|
||||
|
||||
def _err1(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.publish(channel, message, callback=_cb1, error=_err1)
|
||||
|
||||
def _error(resp):
|
||||
assert False
|
||||
|
||||
pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
|
||||
|
||||
|
||||
x = 5
|
||||
|
||||
|
||||
def run_test(t):
|
||||
global x
|
||||
x += 5
|
||||
i = (x / 5) - 1
|
||||
|
||||
def _print():
|
||||
print('Running test ' + str(i))
|
||||
|
||||
pubnub.timeout(x, _print)
|
||||
pubnub.timeout(x + 1, t)
|
||||
|
||||
|
||||
def stop():
|
||||
pubnub.stop()
|
||||
|
||||
|
||||
run_test(test_1)
|
||||
run_test(test_2)
|
||||
run_test(test_3)
|
||||
run_test(test_4)
|
||||
run_test(test_5)
|
||||
run_test(test_6)
|
||||
run_test(test_7)
|
||||
run_test(test_8)
|
||||
run_test(test_9)
|
||||
run_test(test_10)
|
||||
run_test(test_11)
|
||||
run_test(stop)
|
||||
|
||||
pubnub_enc.start()
|
||||
|
|
@ -0,0 +1,230 @@
|
|||
## 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/
|
||||
|
||||
## TODO Tests
|
||||
##
|
||||
## - wait 20 minutes, send a message, receive and success.
|
||||
## -
|
||||
## -
|
||||
##
|
||||
##
|
||||
|
||||
## -----------------------------------
|
||||
## PubNub 3.1 Real-time Push Cloud API
|
||||
## -----------------------------------
|
||||
|
||||
import sys
|
||||
from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or None
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or None
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Command Line Options Supplied PubNub
|
||||
## -----------------------------------------------------------------------
|
||||
pubnub_user_supplied_options = Pubnub(
|
||||
publish_key, # OPTIONAL (supply None to disable)
|
||||
subscribe_key, # REQUIRED
|
||||
secret_key, # OPTIONAL (supply None to disable)
|
||||
cipher_key, # OPTIONAL (supply None to disable)
|
||||
ssl_on # OPTIONAL (supply None to disable)
|
||||
)
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## High Security PubNub
|
||||
## -----------------------------------------------------------------------
|
||||
pubnub_high_security = Pubnub(
|
||||
## Publish Key
|
||||
'pub-c-a30c030e-9f9c-408d-be89-d70b336ca7a0',
|
||||
|
||||
## Subscribe Key
|
||||
'sub-c-387c90f3-c018-11e1-98c9-a5220e0555fd',
|
||||
|
||||
## Secret Key
|
||||
'sec-c-MTliNDE0NTAtYjY4Ni00MDRkLTllYTItNDhiZGE0N2JlYzBl',
|
||||
|
||||
## Cipher Key
|
||||
'YWxzamRmbVjFaa05HVnGFqZHM3NXRBS73jxmhVMkjiwVVXV1d5UrXR1JLSkZFRr' +
|
||||
'WVd4emFtUm1iR0TFpUZvbiBoYXMgYmVlbxWkhNaF3uUi8kM0YkJTEVlZYVFjBYi' +
|
||||
'jFkWFIxSkxTa1pGUjd874hjklaTFpUwRVuIFNob3VsZCB5UwRkxUR1J6YVhlQWa' +
|
||||
'V1ZkNGVH32mDkdho3pqtRnRVbTFpUjBaeGUgYXNrZWQtZFoKjda40ZWlyYWl1eX' +
|
||||
'U4RkNtdmNub2l1dHE2TTA1jd84jkdJTbFJXYkZwWlZtRnKkWVrSRhhWbFpZVmFz' +
|
||||
'c2RkZmTFpUpGa1dGSXhTa3hUYTFwR1Vpkm9yIGluZm9ybWFNfdsWQdSiiYXNWVX' +
|
||||
'RSblJWYlRGcFVqQmFlRmRyYUU0MFpXbHlZV2wxZVhVNFJrTnR51YjJsMWRIRTJU' +
|
||||
'W91ciBpbmZvcm1hdGliBzdWJtaXR0ZWQb3UZSBhIHJlc3BvbnNlLCB3ZWxsIHJl' +
|
||||
'VEExWdHVybiB0am0aW9uIb24gYXMgd2UgcG9zc2libHkgY2FuLuhcFe24ldWVns' +
|
||||
'dSaTFpU3hVUjFKNllWaFdhRmxZUWpCaQo34gcmVxdWlGFzIHNveqQl83snBfVl3',
|
||||
|
||||
## 2048bit SSL ON - ENABLED TRUE
|
||||
True
|
||||
)
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Channel | Message Test Data (UTF-8)
|
||||
## -----------------------------------------------------------------------
|
||||
crazy = ' ~`â¦â§!@#$%^&*(顶顅Ȓ)+=[]\\{}|;\':",./<>?abcd'
|
||||
many_channels = [str(x) + '-many_channel_test' for x in range(10)]
|
||||
runthroughs = 0
|
||||
planned_tests = 2
|
||||
delivery_retries = 0
|
||||
max_retries = 10
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Unit Test Function
|
||||
## -----------------------------------------------------------------------
|
||||
|
||||
|
||||
def test(trial, name):
|
||||
if trial:
|
||||
print('PASS: ' + name)
|
||||
else:
|
||||
print('- FAIL - ' + name)
|
||||
|
||||
|
||||
def test_pubnub(pubnub):
|
||||
global runthroughs, planned_tests, delivery_retries, max_retries
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Many Channels
|
||||
## -----------------------------------------------------------------------
|
||||
def phase2():
|
||||
status = {
|
||||
'sent': 0,
|
||||
'received': 0,
|
||||
'connections': 0
|
||||
}
|
||||
|
||||
def received(message, chan):
|
||||
global runthroughs
|
||||
|
||||
test(status['received'] <= status['sent'], 'many sends')
|
||||
status['received'] += 1
|
||||
pubnub.unsubscribe({'channel': chan})
|
||||
if status['received'] == len(many_channels):
|
||||
runthroughs += 1
|
||||
if runthroughs == planned_tests:
|
||||
pubnub.stop()
|
||||
|
||||
def publish_complete(info, chan):
|
||||
global delivery_retries, max_retries
|
||||
status['sent'] += 1
|
||||
test(info, 'publish complete')
|
||||
test(info and len(info) > 2, 'publish response')
|
||||
if not info[0]:
|
||||
delivery_retries += 1
|
||||
if max_retries > delivery_retries:
|
||||
sendit(chan)
|
||||
|
||||
def sendit(chan):
|
||||
tchan = chan
|
||||
pubnub.publish({
|
||||
'channel': chan,
|
||||
'message': "Hello World",
|
||||
'callback': (lambda msg: publish_complete(msg, tchan))
|
||||
})
|
||||
|
||||
def connected(chan):
|
||||
status['connections'] += 1
|
||||
sendit(chan)
|
||||
|
||||
def delivered(info):
|
||||
if info and info[0]:
|
||||
status['sent'] += 1
|
||||
|
||||
def subscribe(chan):
|
||||
pubnub.subscribe({
|
||||
'channel': chan,
|
||||
'connect': (lambda: connected(chan + '')),
|
||||
'callback': (lambda msg: received(msg, chan))
|
||||
})
|
||||
|
||||
## Subscribe All Channels
|
||||
for chan in many_channels:
|
||||
subscribe(chan)
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Time Example
|
||||
## -----------------------------------------------------------------------
|
||||
def time_complete(timetoken):
|
||||
test(timetoken, 'timetoken fetch')
|
||||
test(isinstance(timetoken, int), 'timetoken int type')
|
||||
|
||||
pubnub.time({'callback': time_complete})
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Publish Example
|
||||
## -----------------------------------------------------------------------
|
||||
def publish_complete(info):
|
||||
test(info, 'publish complete')
|
||||
test(info and len(info) > 2, 'publish response')
|
||||
|
||||
pubnub.history({
|
||||
'channel': crazy,
|
||||
'limit': 10,
|
||||
'callback': history_complete
|
||||
})
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## History Example
|
||||
## -----------------------------------------------------------------------
|
||||
def history_complete(messages):
|
||||
test(messages and len(messages) > 0, 'history')
|
||||
test(messages, 'history')
|
||||
|
||||
pubnub.publish({
|
||||
'channel': crazy,
|
||||
'message': "Hello World",
|
||||
'callback': publish_complete
|
||||
})
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Subscribe Example
|
||||
## -----------------------------------------------------------------------
|
||||
def message_received(message):
|
||||
test(message, 'message received')
|
||||
pubnub.unsubscribe({'channel': crazy})
|
||||
|
||||
def done():
|
||||
pubnub.unsubscribe({'channel': crazy})
|
||||
pubnub.publish({
|
||||
'channel': crazy,
|
||||
'message': "Hello World",
|
||||
'callback': (lambda x: x)
|
||||
})
|
||||
|
||||
def dumpster(message):
|
||||
test(0, 'never see this')
|
||||
|
||||
pubnub.subscribe({
|
||||
'channel': crazy,
|
||||
'connect': done,
|
||||
'callback': dumpster
|
||||
})
|
||||
|
||||
def connected():
|
||||
pubnub.publish({
|
||||
'channel': crazy,
|
||||
'message': {'Info': 'Connected!'}
|
||||
})
|
||||
|
||||
pubnub.subscribe({
|
||||
'channel': crazy,
|
||||
'connect': connected,
|
||||
'callback': message_received
|
||||
})
|
||||
|
||||
phase2()
|
||||
|
||||
## -----------------------------------------------------------------------
|
||||
## Run Tests
|
||||
## -----------------------------------------------------------------------
|
||||
test_pubnub(pubnub_user_supplied_options)
|
||||
test_pubnub(pubnub_high_security)
|
||||
pubnub_high_security.start()
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
PubNub Real-time Cloud-Hosted Push API and Push Notification Client Frameworks
|
||||
Copyright (c) 2013 PubNub Inc.
|
||||
http://www.pubnub.com/
|
||||
http://www.pubnub.com/terms
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
|
||||
PubNub Real-time Cloud-Hosted Push API and Push Notification Client Frameworks
|
||||
Copyright (c) 2013 PubNub Inc.
|
||||
http://www.pubnub.com/
|
||||
http://www.pubnub.com/terms
|
||||
|
|
@ -0,0 +1,400 @@
|
|||
## Contact support@pubnub.com for all questions
|
||||
|
||||
#### [PubNub](http://www.pubnub.com) Real-time Data Network
|
||||
##### Standalone Python Client
|
||||
|
||||
#### Init
|
||||
|
||||
```
|
||||
pubnub = Pubnub(publish_key="demo", subscribe_key="demo", ssl_on=False)
|
||||
|
||||
```
|
||||
|
||||
#### PUBLISH
|
||||
|
||||
```
|
||||
channel = 'hello_world'
|
||||
message = 'Hello World !!!'
|
||||
|
||||
# Synchronous usage
|
||||
print pubnub.publish(channel=channel, message=message)
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.publish(channel=channel, message=message, callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### SUBSCRIBE
|
||||
|
||||
```
|
||||
# Listen for Messages
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.subscribe(channels=channel, callback=callback, error=error,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
```
|
||||
|
||||
#### SUBSCRIBE to group
|
||||
|
||||
```
|
||||
# Listen for Messages
|
||||
|
||||
channel_group = 'group1'
|
||||
|
||||
def callback(message, channel_group, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.subscribe_group(channel_groups=channel_group, callback=callback, error=error,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
```
|
||||
|
||||
#### SUBSCRIBE Synchronous ( compatible with pre-3.5 )
|
||||
Runs in tight loop if callback return True.
|
||||
Loop ends when callback return False
|
||||
```
|
||||
# Listen for Messages
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
return True
|
||||
|
||||
pubnub.subscribe_sync(channel=channel, callback=callback)
|
||||
```
|
||||
|
||||
|
||||
#### UNSUBSCRIBE
|
||||
|
||||
```
|
||||
# Listen for Messages
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
pubnub.unsubscribe(channel=channel)
|
||||
```
|
||||
|
||||
|
||||
#### PRESENCE
|
||||
|
||||
```
|
||||
# Listen for Presence Event Messages
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
|
||||
pubnub.presence(channel=channel, callback=callback, error=error)
|
||||
```
|
||||
|
||||
#### PRESENCE channel group
|
||||
|
||||
```
|
||||
# Listen for Presence Event Messages
|
||||
|
||||
channel_group = 'group1'
|
||||
|
||||
def callback(message, channel_group, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
|
||||
pubnub.presence_group(channel_group=channel_group, callback=callback, error=error)
|
||||
```
|
||||
|
||||
#### HERE_NOW
|
||||
|
||||
```
|
||||
# Get info on who is here right now!
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
# Synchronous usage
|
||||
print pubnub.here_now(channel=channel)
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.here_now(channel=channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### HISTORY
|
||||
|
||||
```
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.history(channel=channel, count=2)
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.history(channel=channel, count=2, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### HISTORY (including timetokens)
|
||||
|
||||
```
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.history(channel, count=2, include_token=True)
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.history(channel, count=2, include_token=True, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
|
||||
#### GRANT
|
||||
|
||||
```
|
||||
authkey = "abcd"
|
||||
|
||||
# Synchronous usage
|
||||
print pubnub.grant(channel=channel, auth_key=authkey, read=True, write=True)
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.grant(channel=channel, auth_key=authkey, read=True, write=True, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### AUDIT
|
||||
|
||||
```
|
||||
channel = "hello_world"
|
||||
authkey = "abcd"
|
||||
|
||||
# Synchronous usage
|
||||
print pubnub.audit(channel=channel, auth_key=authkey)
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.audit(channel=channel, auth_key=authkey, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### REVOKE
|
||||
|
||||
```
|
||||
channel = "hello_world"
|
||||
authkey = "abcd"
|
||||
|
||||
# Synchronous usage
|
||||
print pubnub.revoke(channel=channel, auth_key=authkey)
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.revoke(channel=channel, auth_key=authkey, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
### CHANNEL GROUP METHODS
|
||||
|
||||
#### List Groups
|
||||
|
||||
```
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.channel_group_list_groups(namespace='aaa')
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.channel_group_list_groups(namespace='aaa', callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
#### List Channels
|
||||
|
||||
```
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.channel_group_list_channels(channel_group='dev:abcd')
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.channel_group_list_channels(channel_group='dev:abcd', callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
#### Add Channel
|
||||
|
||||
```
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.channel_group_add_channel(channel_group='dev:abcd', channel="hi")
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.channel_group_add_channel(channel_group='dev:abcd', channel="hi", callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### Remove Channel
|
||||
|
||||
```
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.channel_group_remove_channel(channel_group='dev:abcd', channel="hi")
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.channel_group_remove_channel(channel_group='dev:abcd', channel="hi", callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### List Channels
|
||||
|
||||
```
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.channel_group_list_channels(channel_group='dev:abcd')
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.channel_group_add_channel(channel_group='dev:abcd', callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
#### Grant
|
||||
|
||||
|
||||
```
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.grant(channel_group='dev:abcd', read=True, write=True, manage=True, auth_key="abcd")
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.grant(channel_group='dev:abcd', read=True, write=True, manage=True, auth_key="abcd", callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
#### Revoke
|
||||
|
||||
```
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.revoke(channel_group='dev:abcd', auth_key="abcd")
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.revoke(channel_group='dev:abcd', auth_key="abcd", callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### Audit
|
||||
|
||||
```
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.audit(channel_group='dev:abcd')
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.audit(channel_group='dev:abcd', callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
|
||||
|
||||
## Contact support@pubnub.com for all questions
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
from pubnub import Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
authkey = "abcd"
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.audit(channel, authkey))
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.audit(channel, authkey, callback=callback, error=callback)
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
sessionname pubnub-console
|
||||
screen -t output tail -f ./pubnub-console.log
|
||||
split
|
||||
focus down
|
||||
screen -t console python console.py "set_output_file"
|
||||
split -v
|
||||
focus down
|
||||
screen -t help vi -R ./console-help.txt
|
||||
focus up
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
sessionname pubnub-console
|
||||
screen -t help vi -R ./console-help.txt
|
||||
split
|
||||
focus down
|
||||
screen -t output tail -f ./pubnub-console.log
|
||||
split
|
||||
focus down
|
||||
screen -t console python console.py "set_output_file"
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
********************** HELP ******************************
|
||||
|
||||
TO EXIT :
|
||||
Ctrl-A \ followed by y ( on linux )
|
||||
Ctrl-A Ctrl-\ followed by y ( on mac osx )
|
||||
|
||||
TO MOVE BETWEEN PANES . Ctrl-A TAB
|
||||
|
||||
**********************************************************
|
||||
|
||||
PUBLISH
|
||||
|
||||
Usage: publish [options] arg
|
||||
|
||||
Options:
|
||||
-h, --help show this help message and exit
|
||||
-c CHANNEL, --channel=CHANNEL
|
||||
Channel on which to publish
|
||||
|
||||
Examples:
|
||||
(1) publish -c hello_world hi how r u
|
||||
(2) pub -c hello_world [1,2]
|
||||
|
||||
|
||||
|
||||
SUBSCRIBE
|
||||
|
||||
Usage: subscribe [options] arg
|
||||
|
||||
Options:
|
||||
-h, --help show this help message and exit
|
||||
-c CHANNEL, --channel=CHANNEL
|
||||
Channel for subscribe
|
||||
|
||||
Examples:
|
||||
(1) subscribe -c hello_world
|
||||
(2) sub -c hello_world
|
||||
|
|
@ -0,0 +1,719 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import atexit
|
||||
import json
|
||||
import os
|
||||
import pygments
|
||||
import readline
|
||||
import sys
|
||||
import threading
|
||||
from cmd2 import Cmd, make_option, options
|
||||
from datetime import datetime
|
||||
from pygments.formatters import TerminalFormatter
|
||||
from pygments.lexers import JsonLexer
|
||||
|
||||
from pubnub import Pubnub
|
||||
|
||||
lexer = JsonLexer()
|
||||
formatter = TerminalFormatter()
|
||||
|
||||
|
||||
def highlight(msg):
|
||||
return pygments.highlight(msg, lexer, formatter)
|
||||
|
||||
|
||||
historyPath = os.path.expanduser("~/.pubnub_console_history")
|
||||
|
||||
|
||||
def save_history(historyPath=historyPath):
|
||||
import readline
|
||||
readline.write_history_file(historyPath)
|
||||
|
||||
|
||||
if os.path.exists(historyPath):
|
||||
readline.read_history_file(historyPath)
|
||||
|
||||
atexit.register(save_history)
|
||||
|
||||
of = sys.stdout
|
||||
|
||||
color = Cmd()
|
||||
|
||||
stop = None
|
||||
|
||||
full_date = False
|
||||
|
||||
|
||||
def stop_2(th):
|
||||
th._Thread__stop()
|
||||
|
||||
|
||||
def stop_3(th):
|
||||
th._stop()
|
||||
|
||||
|
||||
def print_console_2(of, message):
|
||||
print >> of, message
|
||||
|
||||
|
||||
def print_console_3(of, message):
|
||||
of.write(message)
|
||||
of.write("\n")
|
||||
|
||||
|
||||
print_console = None
|
||||
|
||||
if type(sys.version_info) is tuple:
|
||||
print_console = print_console_2
|
||||
stop = stop_2
|
||||
else:
|
||||
if sys.version_info.major == 2:
|
||||
print_console = print_console_2
|
||||
stop = stop_2
|
||||
else:
|
||||
print_console = print_console_3
|
||||
stop = stop_3
|
||||
|
||||
|
||||
def get_date():
|
||||
if full_date is True:
|
||||
return color.colorize(datetime.now().strftime(
|
||||
'%Y-%m-%d %H:%M:%S'), "magenta")
|
||||
else:
|
||||
return color.colorize(datetime.now().strftime(
|
||||
'%H:%M:%S'), "magenta")
|
||||
|
||||
|
||||
def print_ok_normal(msg, channel=None):
|
||||
if msg is None:
|
||||
return
|
||||
chstr = "[" + color.colorize(get_date(), "magenta") + "] "
|
||||
chstr += "[" + color.colorize("Channel : " + channel if channel is not None else "", "cyan") + "] "
|
||||
try:
|
||||
print_console(of, (chstr + color.colorize(str(msg), "green")))
|
||||
except UnicodeEncodeError:
|
||||
print_console(of, (msg))
|
||||
|
||||
of.flush()
|
||||
|
||||
|
||||
def print_error_normal(msg, channel=None):
|
||||
if msg is None:
|
||||
return
|
||||
chstr = "[" + color.colorize(get_date(), "magenta") + "] "
|
||||
chstr += "[" + color.colorize("Channel : " + channel if channel is not None else "", "cyan") + "] "
|
||||
try:
|
||||
print_console(of, (chstr + color.colorize(color.colorize(
|
||||
str(msg), "red"), "bold")))
|
||||
except UnicodeEncodeError:
|
||||
print_console(of, (msg))
|
||||
of.flush()
|
||||
|
||||
|
||||
def print_ok_pretty(msg, channel=None):
|
||||
if msg is None:
|
||||
return
|
||||
chstr = "[" + color.colorize(get_date(), "magenta") + "] "
|
||||
chstr += "[" + color.colorize("Channel : " + channel if channel is not None else "", "cyan") + "] "
|
||||
try:
|
||||
print_console(of, (chstr + highlight(json.dumps(msg, indent=2))))
|
||||
except UnicodeEncodeError:
|
||||
print_console(of, (msg))
|
||||
|
||||
of.flush()
|
||||
|
||||
|
||||
def print_error_pretty(msg, channel=None):
|
||||
if msg is None:
|
||||
return
|
||||
chstr = "[" + color.colorize(get_date(), "magenta") + "] "
|
||||
chstr += "[" + color.colorize("Channel : " + channel if channel is not None else "", "cyan") + "] "
|
||||
try:
|
||||
print_console(of, (chstr + color.colorize(color.colorize(
|
||||
"ERROR: ", "red"), "bold") + highlight(json.dumps(msg, indent=2))))
|
||||
except UnicodeEncodeError:
|
||||
print_console(of, (msg))
|
||||
of.flush()
|
||||
|
||||
|
||||
print_ok = print_ok_pretty
|
||||
print_error = print_error_pretty
|
||||
|
||||
|
||||
class DefaultPubnub(object):
|
||||
def handlerFunctionClosure(self, name):
|
||||
def handlerFunction(*args, **kwargs):
|
||||
print_error("Pubnub not initialized." +
|
||||
"Use init command to initialize")
|
||||
|
||||
return handlerFunction
|
||||
|
||||
def __getattr__(self, name):
|
||||
return self.handlerFunctionClosure(name)
|
||||
|
||||
|
||||
pubnub = DefaultPubnub()
|
||||
|
||||
|
||||
def kill_all_threads():
|
||||
for thread in threading.enumerate():
|
||||
if thread.isAlive():
|
||||
stop(thread)
|
||||
|
||||
|
||||
def get_input(message, t=None):
|
||||
while True:
|
||||
try:
|
||||
try:
|
||||
command = raw_input(message)
|
||||
except NameError:
|
||||
command = input(message)
|
||||
except KeyboardInterrupt:
|
||||
return None
|
||||
|
||||
command = command.strip()
|
||||
|
||||
if command is None or len(command) == 0:
|
||||
raise ValueError
|
||||
|
||||
if t is not None and t == bool:
|
||||
valid = ["True", "true", "1", 1, "y", "Y", "yes", "Yes", "YES"]
|
||||
if command in valid:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
if t is not None:
|
||||
command = t(command)
|
||||
else:
|
||||
command = eval("'" + command + "'")
|
||||
|
||||
return command
|
||||
except ValueError:
|
||||
print_error("Invalid input : " + command)
|
||||
|
||||
|
||||
def _publish_command_handler(channel, message, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.publish(channel, message,
|
||||
_callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def _subscribe_command_handler(channel):
|
||||
def _callback(r, ch):
|
||||
print_ok(r, ch)
|
||||
|
||||
def _error(r, ch=None):
|
||||
print_error(r, ch if ch is not None else channel)
|
||||
|
||||
def _disconnect(r):
|
||||
print_ok("DISCONNECTED", r)
|
||||
|
||||
def _reconnect(r):
|
||||
print_ok("RECONNECTED", r)
|
||||
|
||||
def _connect(r):
|
||||
print_ok("CONNECTED", r)
|
||||
|
||||
pubnub.subscribe(channel, _callback, _error, connect=_connect,
|
||||
disconnect=_disconnect, reconnect=_reconnect)
|
||||
|
||||
|
||||
def _unsubscribe_command_handler(channels):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
unsub_list = []
|
||||
current_channel_list = pubnub.get_channel_array()
|
||||
|
||||
for channel in channels:
|
||||
pubnub.unsubscribe(channel)
|
||||
if (channel in current_channel_list):
|
||||
unsub_list.append(channel)
|
||||
|
||||
# pubnub.unsubscribe(channel + '-pnpres')
|
||||
# if (channel + '-pnpres' in current_channel_list):
|
||||
# unsub_list.append(channel + ' (Presence)')
|
||||
|
||||
if len(unsub_list) > 0:
|
||||
print_ok('Unsubscribed from : ' + str(unsub_list))
|
||||
else:
|
||||
print_error('Not subscribed to : ' + str(channels))
|
||||
|
||||
|
||||
def _grant_command_handler(channel, auth_key, read, write, ttl, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.grant(channel, auth_key,
|
||||
read, write, ttl,
|
||||
_callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def _revoke_command_handler(channel, auth_key, ttl, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.revoke(channel, auth_key, ttl,
|
||||
_callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def _audit_command_handler(channel, auth_key, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.audit(channel, auth_key,
|
||||
_callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def _history_command_handler(channel, count, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.history(channel, count,
|
||||
_callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def _here_now_command_handler(channel, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.here_now(channel, _callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def get_channel_array():
|
||||
channels = pubnub.get_channel_array()
|
||||
|
||||
for channel in channels:
|
||||
if "-pnpres" in channel:
|
||||
chname = channel.split("-pnpres")[0]
|
||||
if chname not in channels:
|
||||
continue
|
||||
i = channels.index(chname)
|
||||
channels[i] = channels[i] + color.colorize("(P)", "blue")
|
||||
channels.remove(channel)
|
||||
return channels
|
||||
|
||||
|
||||
class DevConsole(Cmd):
|
||||
def __init__(self):
|
||||
Cmd.__init__(self)
|
||||
global pubnub
|
||||
self.intro = "For Help type ? or help . " + \
|
||||
"To quit/exit type exit" + "\n" + \
|
||||
"Commands can also be provided on command line while starting console (in quotes) ex. " + \
|
||||
"pubnub-console 'init -p demo -s demo'"
|
||||
self.default_channel = None
|
||||
self.async = False
|
||||
pubnub = Pubnub("demo", "demo")
|
||||
self.channel_truncation = 3
|
||||
self.prompt = self.get_prompt()
|
||||
self.publish_key = "demo"
|
||||
self.subscribe_key = "demo"
|
||||
self.origin = "pubsub.pubnub.com"
|
||||
self.auth_key = None
|
||||
self.cipher_key = None
|
||||
self.secret_key = "demo"
|
||||
self.ssl = False
|
||||
self.uuid = None
|
||||
self.disable_pretty = False
|
||||
|
||||
def get_channel_origin(self):
|
||||
cho = ""
|
||||
channels = get_channel_array()
|
||||
sl = self.channel_truncation
|
||||
if len(channels) > int(sl) and int(sl) > 0:
|
||||
cho += ",".join(channels[:int(sl)]) + " " + str(
|
||||
len(channels) - int(sl)) + " more..."
|
||||
else:
|
||||
cho += ",".join(channels)
|
||||
|
||||
if len(channels) > 0:
|
||||
cho = color.colorize(cho, "bold") + "@"
|
||||
|
||||
origin = pubnub.get_origin().split("://")[1]
|
||||
origin += color.colorize(" (SSL)", "green") if pubnub.get_origin(
|
||||
).split("://")[0] == "https" else ""
|
||||
return " [" + cho + color.colorize(origin, "blue") + "] > "
|
||||
|
||||
def get_prompt(self):
|
||||
prompt = "[" + get_date() + "]"
|
||||
|
||||
if self.default_channel is not None and len(self.default_channel) > 0:
|
||||
prompt += " [default channel: " + color.colorize(
|
||||
self.default_channel, "bold") + "]"
|
||||
|
||||
prompt += self.get_channel_origin()
|
||||
return prompt
|
||||
|
||||
def precmd(self, line):
|
||||
self.prompt = self.get_prompt()
|
||||
return line
|
||||
|
||||
# def emptyline(self):
|
||||
# self.prompt = self.get_prompt()
|
||||
|
||||
def cmdloop_with_keyboard_interrupt(self):
|
||||
try:
|
||||
self.cmdloop()
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
sys.stdout.write('\n')
|
||||
kill_all_threads()
|
||||
|
||||
@options([make_option('-p', '--publish-key', action="store",
|
||||
default=None, help="Publish Key"),
|
||||
make_option('-s', '--subscribe-key', action="store",
|
||||
default=None, help="Subscribe Key"),
|
||||
make_option('-k', '--secret-key', action="store",
|
||||
default=None, help="cipher Key"),
|
||||
make_option('-c', '--cipher-key', action="store",
|
||||
default=None, help="Secret Key"),
|
||||
make_option('-a', '--auth-key', action="store",
|
||||
default=None, help="Auth Key"),
|
||||
make_option('--ssl-on', dest='ssl', action='store_true',
|
||||
default=False, help="SSL Enabled ?"),
|
||||
make_option('-o', '--origin', action="store",
|
||||
default=None, help="Origin"),
|
||||
make_option('-u', '--uuid', action="store",
|
||||
default=None, help="UUID"),
|
||||
make_option('--disable-pretty-print', dest='disable_pretty', action='store_true',
|
||||
default=False, help="Disable Pretty Print ?")
|
||||
])
|
||||
def do_init(self, command, opts):
|
||||
global pubnub
|
||||
global print_ok
|
||||
global print_error
|
||||
global print_ok_normal
|
||||
global print_error_normal
|
||||
global print_error_pretty
|
||||
global print_ok_pretty
|
||||
|
||||
self.publish_key = opts.publish_key if opts.publish_key is not None else self.publish_key
|
||||
self.subscribe_key = opts.subscribe_key if opts.subscribe_key is not None else self.subscribe_key
|
||||
self.secret_key = opts.secret_key if opts.secret_key is not None else self.secret_key
|
||||
self.cipher_key = opts.cipher_key if opts.cipher_key is not None else self.cipher_key
|
||||
self.auth_key = opts.auth_key if opts.auth_key is not None else self.auth_key
|
||||
self.origin = opts.origin if opts.origin is not None else self.origin
|
||||
self.uuid = opts.uuid if opts.uuid is not None else self.uuid
|
||||
self.ssl = opts.ssl if opts.ssl is not None else self.ssl
|
||||
self.disable_pretty = opts.disable_pretty if opts.disable_pretty is not None else self.disable_pretty
|
||||
|
||||
pubnub = Pubnub(self.publish_key,
|
||||
self.subscribe_key,
|
||||
self.secret_key,
|
||||
self.cipher_key,
|
||||
self.auth_key,
|
||||
self.ssl,
|
||||
self.origin,
|
||||
self.uuid)
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
if opts.disable_pretty is True:
|
||||
print_ok = print_ok_normal
|
||||
print_error = print_error_normal
|
||||
else:
|
||||
print_ok = print_ok_pretty
|
||||
print_error = print_error_pretty
|
||||
|
||||
def do_set_sync(self, command):
|
||||
"""unset_async
|
||||
Unset Async mode"""
|
||||
self.async = False
|
||||
|
||||
def do_set_async(self, command):
|
||||
"""set_async
|
||||
Set Async mode"""
|
||||
self.async = True
|
||||
|
||||
@options([make_option('-n', '--count', action="store",
|
||||
default=3, help="Number of channels on prompt")
|
||||
])
|
||||
def do_set_channel_truncation(self, command, opts):
|
||||
"""set_channel_truncation
|
||||
Set Channel Truncation"""
|
||||
|
||||
self.channel_truncation = opts.count
|
||||
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
def do_unset_channel_truncation(self, command):
|
||||
"""unset_channel_truncation
|
||||
Unset Channel Truncation"""
|
||||
self.channel_truncation = 0
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
def do_set_full_date(self, command):
|
||||
global full_date
|
||||
"""do_set_full_date
|
||||
Set Full Date"""
|
||||
full_date = True
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
def do_unset_full_date(self, command):
|
||||
global full_date
|
||||
"""do_unset_full_date
|
||||
Unset Full Date"""
|
||||
full_date = False
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
@options([make_option('-c', '--channel',
|
||||
action="store", help="Default Channel")
|
||||
])
|
||||
def do_set_default_channel(self, command, opts):
|
||||
|
||||
if opts.channel is None:
|
||||
print_error("Missing channel")
|
||||
return
|
||||
self.default_channel = opts.channel
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
@options([make_option('-f', '--file', action="store",
|
||||
default="./pubnub-console.log", help="Output file")
|
||||
])
|
||||
def do_set_output_file(self, command, opts):
|
||||
global of
|
||||
try:
|
||||
of = open(opts.file, 'w+')
|
||||
except IOError as e:
|
||||
print_error("Could not set output file. " + e.reason)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel for here now data")
|
||||
])
|
||||
def do_here_now(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
if opts.channel is None:
|
||||
print_error("Missing channel")
|
||||
return
|
||||
|
||||
_here_now_command_handler(opts.channel, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel for history data"),
|
||||
make_option('-n', '--count', action="store",
|
||||
default=5, help="Number of messages")
|
||||
])
|
||||
def do_get_history(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
if opts.channel is None:
|
||||
print_error("Missing channel")
|
||||
return
|
||||
|
||||
_history_command_handler(opts.channel, opts.count, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel on which to publish")
|
||||
])
|
||||
def do_publish(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
if opts.channel is None:
|
||||
print_error("Missing channel")
|
||||
return
|
||||
|
||||
if command is None:
|
||||
print_error("Missing message")
|
||||
return
|
||||
|
||||
try:
|
||||
message = json.loads(str(command))
|
||||
except ValueError:
|
||||
message = str(command)
|
||||
|
||||
_publish_command_handler(opts.channel, message, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel on which to grant"),
|
||||
make_option('-a', '--auth-key', dest="auth_key",
|
||||
action="store",
|
||||
help="Auth Key"),
|
||||
make_option('-r', '--read-enabled', dest='read',
|
||||
action='store_true',
|
||||
default=False, help="Read ?"),
|
||||
make_option('-w', '--write-enabled', dest='write',
|
||||
action='store_true',
|
||||
default=False, help="Write ?"),
|
||||
make_option('-t', '--ttl', action="store",
|
||||
default=5, help="TTL"),
|
||||
make_option('-p', '--presence', action="store_true",
|
||||
dest="presence",
|
||||
default=False, help="Grant on presence channel ?")
|
||||
])
|
||||
def do_grant(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
|
||||
opts.auth_key = pubnub.auth_key \
|
||||
if opts.auth_key is None else opts.auth_key
|
||||
|
||||
_grant_command_handler(opts.channel, opts.auth_key,
|
||||
opts.read, opts.write,
|
||||
opts.ttl, async=self.async)
|
||||
|
||||
if opts.presence is True:
|
||||
_grant_command_handler(opts.channel + '-pnpres', opts.auth_key,
|
||||
opts.read, opts.write,
|
||||
opts.ttl, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel on which to revoke"),
|
||||
make_option('-a', '--auth-key', dest="auth_key", action="store",
|
||||
help="Auth Key"),
|
||||
make_option('-t', '--ttl', action="store",
|
||||
default=5, help="TTL"),
|
||||
make_option('-p', '--presence', action="store_true",
|
||||
dest="presence",
|
||||
default=False, help="Revoke on presence channel ?")
|
||||
])
|
||||
def do_revoke(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
|
||||
opts.auth_key = pubnub.auth_key \
|
||||
if opts.auth_key is None else opts.auth_key
|
||||
|
||||
_revoke_command_handler(
|
||||
opts.channel, opts.auth_key, opts.ttl, async=self.async)
|
||||
|
||||
if opts.presence is True:
|
||||
_revoke_command_handler(
|
||||
opts.channel + '-pnpres', opts.auth_key, opts.ttl, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel on which to revoke"),
|
||||
make_option('-a', '--auth-key', dest="auth_key", action="store",
|
||||
help="Auth Key")
|
||||
])
|
||||
def do_audit(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
|
||||
opts.auth_key = pubnub.auth_key \
|
||||
if opts.auth_key is None else opts.auth_key
|
||||
|
||||
_audit_command_handler(opts.channel, opts.auth_key, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel for unsubscribe"),
|
||||
make_option('-a', '--all', action="store_true", dest="all",
|
||||
default=False, help="Unsubscribe from all channels"),
|
||||
make_option('-p', '--presence', action="store_true",
|
||||
dest="presence",
|
||||
default=False, help="Unsubscribe from presence events ?")
|
||||
])
|
||||
def do_unsubscribe(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
|
||||
if (opts.all is True):
|
||||
opts.channel = []
|
||||
chs = pubnub.get_channel_array()
|
||||
for ch in chs:
|
||||
if '-pnpres' not in ch:
|
||||
opts.channel.append(ch)
|
||||
elif opts.presence is True:
|
||||
opts.channel.append(ch)
|
||||
|
||||
if opts.channel is None:
|
||||
print_error("Missing channel")
|
||||
return
|
||||
|
||||
if not isinstance(opts.channel, list):
|
||||
ch = []
|
||||
ch.append(opts.channel)
|
||||
opts.channel = ch
|
||||
|
||||
channels = []
|
||||
if opts.presence is True and opts.all is False:
|
||||
for c in opts.channel:
|
||||
if '-pnpres' not in c:
|
||||
channels.append(c + '-pnpres')
|
||||
|
||||
for c in opts.channel:
|
||||
channels.append(c)
|
||||
|
||||
_unsubscribe_command_handler(channels)
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel for subscribe"),
|
||||
make_option('-g', '--get-channel-list', action="store_true",
|
||||
dest="get",
|
||||
default=False, help="Get susbcribed channel list"),
|
||||
make_option('-p', '--presence', action="store_true",
|
||||
dest="presence",
|
||||
default=False, help="Presence events ?")
|
||||
])
|
||||
def do_subscribe(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
if opts is None:
|
||||
print_error("Missing argument")
|
||||
return
|
||||
|
||||
if opts.channel is not None:
|
||||
_subscribe_command_handler(opts.channel)
|
||||
|
||||
if opts.presence is True:
|
||||
_subscribe_command_handler(opts.channel + '-pnpres')
|
||||
|
||||
if opts.get is True:
|
||||
print_ok(get_channel_array())
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
def do_exit(self, args):
|
||||
kill_all_threads()
|
||||
return -1
|
||||
|
||||
# def do_EOF(self, args):
|
||||
# kill_all_threads()
|
||||
# return self.do_exit(args)
|
||||
|
||||
# def handler(self, signum, frame):
|
||||
# kill_all_threads()
|
||||
|
||||
|
||||
def main():
|
||||
app = DevConsole()
|
||||
app.cmdloop_with_keyboard_interrupt()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
from pubnub import Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on, auth_key="abcd")
|
||||
channel = 'hello_world'
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
print(pubnub.revoke(channel_group='dev:abcd', auth_key="abcd"))
|
||||
print(pubnub.audit(channel_group="dev:abcd"))
|
||||
print(pubnub.grant(channel_group='dev:abcd', read=True, write=True, manage=True, auth_key="abcd"))
|
||||
print(pubnub.channel_group_list_namespaces())
|
||||
print(pubnub.channel_group_list_groups(namespace='aaa'))
|
||||
print(pubnub.channel_group_list_groups(namespace='foo'))
|
||||
print(pubnub.channel_group_list_channels(channel_group='dev:abcd'))
|
||||
print(pubnub.channel_group_add_channel(channel_group='dev:abcd', channel="hi"))
|
||||
print(pubnub.channel_group_list_channels(channel_group='dev:abcd'))
|
||||
print(pubnub.channel_group_remove_channel(channel_group='dev:abcd', channel="hi"))
|
||||
print(pubnub.channel_group_list_channels(channel_group='dev:abcd'))
|
||||
|
||||
|
||||
pubnub.revoke(channel_group='dev:abcd', auth_key="abcd", callback=callback, error=callback)
|
||||
pubnub.audit(channel_group="dev:abcd", callback=callback, error=callback)
|
||||
pubnub.grant(channel_group='dev:abcd', read=True, write=True, manage=True, auth_key="abcd", callback=callback, error=callback)
|
||||
pubnub.channel_group_list_namespaces(callback=callback, error=callback)
|
||||
pubnub.channel_group_list_groups(namespace='aaa', callback=callback, error=callback)
|
||||
pubnub.channel_group_list_groups(namespace='foo', callback=callback, error=callback)
|
||||
pubnub.channel_group_list_channels(channel_group='dev:abcd', callback=callback, error=callback)
|
||||
pubnub.channel_group_add_channel(channel_group='dev:abcd', channel="hi", callback=callback, error=callback)
|
||||
pubnub.channel_group_list_channels(channel_group='dev:abcd', callback=callback, error=callback)
|
||||
pubnub.channel_group_remove_channel(channel_group='dev:abcd', channel="hi", callback=callback, error=callback)
|
||||
pubnub.channel_group_list_channels(channel_group='dev:abcd', callback=callback, error=callback)
|
||||
|
|
@ -0,0 +1,273 @@
|
|||
# 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/
|
||||
|
||||
from pubnub import Pubnub
|
||||
from optparse import OptionParser
|
||||
from datetime import datetime
|
||||
import threading
|
||||
|
||||
parser = OptionParser()
|
||||
|
||||
parser.add_option("--publish-key",
|
||||
dest="publish_key", default="demo",
|
||||
help="Publish Key ( default : 'demo' )")
|
||||
|
||||
parser.add_option("--subscribe-key",
|
||||
dest="subscribe_key", default="demo",
|
||||
help="Subscribe Key ( default : 'demo' )")
|
||||
|
||||
parser.add_option("--secret-key",
|
||||
dest="secret_key", default="demo",
|
||||
help="Secret Key ( default : 'demo' )")
|
||||
|
||||
parser.add_option("--cipher-key",
|
||||
dest="cipher_key", default="",
|
||||
help="Cipher Key")
|
||||
|
||||
parser.add_option("--auth-key",
|
||||
dest="auth_key", default=None,
|
||||
help="Auth Key")
|
||||
|
||||
parser.add_option("--origin",
|
||||
dest="origin", default="pubsub.pubnub.com",
|
||||
help="Origin ( default: pubsub.pubnub.com )")
|
||||
|
||||
parser.add_option("--ssl-on",
|
||||
action="store_false", dest="ssl", default=False,
|
||||
help="SSL")
|
||||
|
||||
parser.add_option("--uuid",
|
||||
dest="uuid", default=None,
|
||||
help="UUID")
|
||||
|
||||
(options, args) = parser.parse_args()
|
||||
|
||||
print(options)
|
||||
|
||||
pubnub = Pubnub(options.publish_key,
|
||||
options.subscribe_key,
|
||||
options.secret_key,
|
||||
options.cipher_key,
|
||||
options.auth_key,
|
||||
options.ssl,
|
||||
options.origin,
|
||||
options.uuid)
|
||||
|
||||
|
||||
class color(object):
|
||||
PURPLE = '\033[95m'
|
||||
CYAN = '\033[96m'
|
||||
DARKCYAN = '\033[36m'
|
||||
BLUE = '\033[94m'
|
||||
GREEN = '\033[92m'
|
||||
YELLOW = '\033[93m'
|
||||
RED = '\033[91m'
|
||||
BOLD = '\033[1m'
|
||||
UNDERLINE = '\033[4m'
|
||||
END = '\033[0m'
|
||||
|
||||
|
||||
def print_ok(msg, channel=None):
|
||||
chstr = color.PURPLE + "[" + datetime.now().strftime(
|
||||
'%Y-%m-%d %H:%M:%S') + "] " + color.END
|
||||
chstr += color.CYAN + "[Channel : " + channel + \
|
||||
"] " if channel is not None else "" + color.END
|
||||
try:
|
||||
print(chstr + color.GREEN + str(msg) + color.END)
|
||||
except UnicodeEncodeError:
|
||||
print(msg)
|
||||
|
||||
|
||||
def print_error(msg, channel=None):
|
||||
chstr = color.PURPLE + "[" + datetime.now().strftime(
|
||||
'%Y-%m-%d %H:%M:%S') + "] " + color.END
|
||||
chstr += color.CYAN + "[Channel : " + channel + \
|
||||
"] " if channel is not None else "" + color.END
|
||||
try:
|
||||
print(chstr + color.RED + color.BOLD + str(msg) + color.END)
|
||||
except UnicodeEncodeError:
|
||||
print(msg)
|
||||
|
||||
|
||||
def kill_all_threads():
|
||||
for thread in threading.enumerate():
|
||||
if thread.isAlive():
|
||||
thread._Thread__stop()
|
||||
|
||||
|
||||
def get_input(message, t=None):
|
||||
while True:
|
||||
try:
|
||||
try:
|
||||
command = raw_input(message)
|
||||
except NameError:
|
||||
command = input(message)
|
||||
except KeyboardInterrupt:
|
||||
return None
|
||||
|
||||
command = command.strip()
|
||||
|
||||
if command is None or len(command) == 0:
|
||||
raise ValueError
|
||||
|
||||
if t is not None and t == bool:
|
||||
valid = ["True", "true", "1", 1, "y", "Y", "yes", "Yes", "YES"]
|
||||
if command in valid:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
if t is not None:
|
||||
command = t(command)
|
||||
else:
|
||||
command = eval("'" + command + "'")
|
||||
|
||||
return command
|
||||
except ValueError:
|
||||
print_error("Invalid input : " + command)
|
||||
|
||||
|
||||
def _publish_command_handler():
|
||||
|
||||
channel = get_input("[PUBLISH] Enter Channel Name ", str)
|
||||
if channel is None:
|
||||
return
|
||||
while True:
|
||||
message = get_input("[PUBLISH] Enter Message \
|
||||
( QUIT or CTRL-C for exit from publish mode ) ")
|
||||
if message == 'QUIT' or message == 'quit' or message is None:
|
||||
return
|
||||
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
pubnub.publish(channel, message, _callback, _error)
|
||||
|
||||
|
||||
def _subscribe_command_handler():
|
||||
channel = get_input("[SUBSCRIBE] Enter Channel Name ", str)
|
||||
|
||||
def _callback(r):
|
||||
print_ok(r, channel)
|
||||
|
||||
def _error(r):
|
||||
print_error(r, channel)
|
||||
pubnub.subscribe(channel, _callback, _error)
|
||||
|
||||
|
||||
def _unsubscribe_command_handler():
|
||||
channel = get_input("[UNSUBSCRIBE] Enter Channel Name ", str)
|
||||
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
pubnub.unsubscribe(channel)
|
||||
|
||||
|
||||
def _grant_command_handler():
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
channel = get_input("[GRANT] Enter Channel Name ", str)
|
||||
auth_key = get_input("[GRANT] Enter Auth Key ", str)
|
||||
ttl = get_input("[GRANT] Enter ttl ", int)
|
||||
read = get_input("[GRANT] Read ? ", bool)
|
||||
write = get_input("[GRANT] Write ? ", bool)
|
||||
pubnub.grant(channel, auth_key, read, write, ttl, _callback)
|
||||
|
||||
|
||||
def _revoke_command_handler():
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
channel = get_input("[REVOKE] Enter Channel Name ", str)
|
||||
auth_key = get_input("[REVOKE] Enter Auth Key ", str)
|
||||
ttl = get_input("[REVOKE] Enter ttl ", int)
|
||||
|
||||
pubnub.revoke(channel, auth_key, ttl, _callback)
|
||||
|
||||
|
||||
def _audit_command_handler():
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
channel = get_input("[AUDIT] Enter Channel Name ", str)
|
||||
auth_key = get_input("[AUDIT] Enter Auth Key ", str)
|
||||
pubnub.audit(channel, auth_key, _callback)
|
||||
|
||||
|
||||
def _history_command_handler():
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
channel = get_input("[HISTORY] Enter Channel Name ", str)
|
||||
count = get_input("[HISTORY] Enter Count ", int)
|
||||
|
||||
pubnub.history(channel, count, callback=_callback, error=_error)
|
||||
|
||||
|
||||
def _here_now_command_handler():
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
channel = get_input("[HERE NOW] Enter Channel Name ", str)
|
||||
|
||||
pubnub.here_now(channel, callback=_callback, error=_error)
|
||||
|
||||
|
||||
commands = []
|
||||
commands.append({"command": "publish", "handler": _publish_command_handler})
|
||||
commands.append(
|
||||
{"command": "subscribe", "handler": _subscribe_command_handler})
|
||||
commands.append(
|
||||
{"command": "unsubscribe", "handler": _unsubscribe_command_handler})
|
||||
commands.append(
|
||||
{"command": "here_now", "handler": _here_now_command_handler})
|
||||
commands.append({"command": "history", "handler": _history_command_handler})
|
||||
commands.append({"command": "grant", "handler": _grant_command_handler})
|
||||
commands.append({"command": "revoke", "handler": _revoke_command_handler})
|
||||
commands.append({"command": "audit", "handler": _audit_command_handler})
|
||||
|
||||
# last command is quit. add new commands before this line
|
||||
commands.append({"command": "QUIT"})
|
||||
|
||||
|
||||
def get_help():
|
||||
help = ""
|
||||
help += "Channels currently subscribed to : "
|
||||
help += str(pubnub.get_channel_array())
|
||||
help += "\n"
|
||||
for i, v in enumerate(commands):
|
||||
help += "Enter " + str(i) + " for " + v['command'] + "\n"
|
||||
return help
|
||||
|
||||
|
||||
while True:
|
||||
command = get_input(color.BLUE + get_help(), int)
|
||||
if command == len(commands) - 1 or command is None:
|
||||
kill_all_threads()
|
||||
break
|
||||
if command >= len(commands):
|
||||
print_error("Invalid input " + str(command))
|
||||
continue
|
||||
|
||||
commands[command]['handler']()
|
||||
|
||||
# pubnub.start()
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
from pubnub import Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
authkey = "abcd"
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.grant(channel, authkey, True, True))
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.grant(channel, authkey, True, True, callback=callback, error=callback)
|
||||
|
|
@ -0,0 +1,106 @@
|
|||
# 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/
|
||||
|
||||
import gevent.monkey
|
||||
import random
|
||||
import sys
|
||||
from datetime import datetime
|
||||
from pubnub import Pubnub as Pubnub
|
||||
|
||||
gevent.monkey.patch_all()
|
||||
|
||||
# from pubnub import PubnubTornado as Pubnub
|
||||
# from pubnub import PubnubTwisted as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'ds'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'ds'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'ds'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on, uuid="test-" + str(random.random()))
|
||||
|
||||
|
||||
def x(url):
|
||||
print(url)
|
||||
|
||||
|
||||
# pubnub.set_http_debug(x)
|
||||
|
||||
channel = 'ab,cd,ef'
|
||||
channel_group = "abg,cdg"
|
||||
|
||||
|
||||
def set_heartbeat(*argv):
|
||||
print("Change Heartbeat to ", argv[0])
|
||||
pubnub.set_heartbeat(argv[0], argv[1], argv[2])
|
||||
|
||||
|
||||
def set_heartbeat_interval(*argv):
|
||||
pubnub.set_heartbeat_interval(argv[0])
|
||||
|
||||
|
||||
# pubnub.timeout(0, set_heartbeat, 8)
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.channel_group_add_channel("abg", "abcd")
|
||||
pubnub.channel_group_add_channel("cdg", "efgh")
|
||||
|
||||
pubnub.subscribe(channels=channel, callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
|
||||
pubnub.subscribe_group(channel_groups=channel_group, callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
|
||||
|
||||
def cb(resp):
|
||||
print(datetime.now().strftime('%H:%M:%S'), resp)
|
||||
|
||||
|
||||
def err(resp):
|
||||
print(datetime.now().strftime('%H:%M:%S'), resp)
|
||||
|
||||
|
||||
pubnub.timeout(5, set_heartbeat, 120, cb, err)
|
||||
pubnub.timeout(90, set_heartbeat, 60, cb, err)
|
||||
pubnub.timeout(180, set_heartbeat, 30, cb, err)
|
||||
pubnub.timeout(240, set_heartbeat, 15, cb, err)
|
||||
pubnub.timeout(300, set_heartbeat, 8, cb, err)
|
||||
# pubnub.timeout(360, pubnub.stop_heartbeat)
|
||||
|
||||
|
||||
'''
|
||||
import time
|
||||
while True:
|
||||
time.sleep(10)
|
||||
'''
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
from pubnub import Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.here_now(channel))
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.here_now(channel, callback=callback, error=callback)
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
from pubnub import Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'a'
|
||||
|
||||
# Synchronous usage
|
||||
|
||||
print(pubnub.history(channel, count=2))
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.history(channel, count=2, callback=callback, error=callback)
|
||||
|
||||
# Synchronous usage
|
||||
|
||||
print(pubnub.history(channel, count=2, include_token=True))
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.history(channel, count=2, include_token=True, callback=callback, error=callback)
|
||||
|
|
@ -0,0 +1,126 @@
|
|||
from gevent.monkey import patch_all
|
||||
from pubnub import Pubnub
|
||||
import random
|
||||
import json
|
||||
|
||||
patch_all()
|
||||
|
||||
rand = str(random.randint(1, 99999999))
|
||||
|
||||
|
||||
def get_unique(s):
|
||||
return 'str-' + rand + '-' + s
|
||||
|
||||
|
||||
# public channel
|
||||
# This is the channel all clients announce themselves on -- or more generally speaking, a channel you expect the client
|
||||
# to "check-in" on to announce his state
|
||||
|
||||
# channel_public = get_unique("channel_public")
|
||||
channel_public = "channel_public"
|
||||
|
||||
# server auth key
|
||||
# Only the server has/knows about this auth token. It will be used to grant read on the "check-in" Presence channel
|
||||
|
||||
# server_auth_token = get_unique("server_auth_token")
|
||||
server_auth_token = "server_auth_token"
|
||||
|
||||
# client auth key
|
||||
# only clients will use this authey -- it does not provide presence channel read access
|
||||
|
||||
# client_auth_token = get_unique("client_auth_token")
|
||||
client_auth_token = "client_auth_token"
|
||||
|
||||
# each client must have a unique id -- a UUID, for presence information/state to bind to
|
||||
|
||||
# client uuid
|
||||
client_uuid = get_unique("client_uuid")
|
||||
|
||||
# server uuid
|
||||
server_uuid = get_unique("server_uuid")
|
||||
|
||||
# For the demo, we'll implement a SERVER called server, who is the authoritative 'admin' entity in the system
|
||||
# We'll also implement a CLIENT called client, who is an arbitrary hardware device member of the network
|
||||
|
||||
# Please swap out the default 'pam' demo keys with your own PAM-enabled keys
|
||||
|
||||
# init server object
|
||||
server = Pubnub(publish_key="pam", subscribe_key="pam", secret_key="pam", auth_key=server_auth_token, uuid=server_uuid)
|
||||
|
||||
# init client object
|
||||
client = Pubnub(publish_key="pam", subscribe_key="pam", auth_key=client_auth_token, uuid=client_uuid)
|
||||
|
||||
# To access a Presence channel with PAM, its format is CHANNELNAME-pnpres
|
||||
|
||||
# Grant permission to server auth keys
|
||||
# grant r/w to public, and r/w public Presence (public-pnpres)
|
||||
|
||||
print(server.grant(channel=channel_public, auth_key=server_auth_token, read=True, write=True))
|
||||
print(server.grant(channel=channel_public + '-pnpres', auth_key=server_auth_token, read=True, write=True))
|
||||
|
||||
# Grant permission to client auth keys
|
||||
# grant r/w to public, and w-only access to public Presence (public-pnpres)
|
||||
print(server.grant(channel=channel_public, auth_key=client_auth_token, read=True, write=False))
|
||||
print(server.grant(channel=channel_public + '-pnpres', auth_key=client_auth_token, read=False, write=False))
|
||||
|
||||
|
||||
# Now, we'll run it to watch it work as advertised...
|
||||
|
||||
# Define some simple callabcks for the Server and Client
|
||||
|
||||
def _server_message_callback(message, channel):
|
||||
print("Server heard: " + json.dumps(message))
|
||||
|
||||
|
||||
def _client_message_callback(message, channel):
|
||||
print("Client heard: " + json.dumps(message))
|
||||
|
||||
|
||||
def _client_error_callback(error, channel):
|
||||
print("Client Error: " + error + " on channel " + channel)
|
||||
print("TTL on grant expired, or token was invalid, or revoked."
|
||||
" Client will now unsubscribe from this unauthorized channel.")
|
||||
client.unsubscribe(channel=channel)
|
||||
|
||||
|
||||
def _server_error_callback(error, channel):
|
||||
print("Server Error: " + error + " on channel " + channel)
|
||||
print("TTL on grant expired, or token was revoked. Server will now unsubscribe from this unauthorized channel.")
|
||||
server.unsubscribe(channel=channel)
|
||||
|
||||
|
||||
def _server_presence_callback(message, channel):
|
||||
print(message)
|
||||
if 'action' in message:
|
||||
if message['action'] == 'join' and message['uuid'] == client_uuid:
|
||||
print("Server can see that client with UUID " + message['uuid'] + " has a state of " + json.dumps(
|
||||
message['data']))
|
||||
|
||||
|
||||
def _client_presence_callback(message, channel):
|
||||
print(message)
|
||||
if 'action' in message:
|
||||
if message['action'] == 'join' and message['uuid'] == client_uuid:
|
||||
print("Client can see that client with UUID " + message['uuid'] + " has a state of " + json.dumps(
|
||||
message['data']))
|
||||
|
||||
|
||||
# server subscribes to public channel
|
||||
server.subscribe(channels=channel_public, callback=_server_message_callback, error=_server_error_callback)
|
||||
|
||||
# server subscribes to presence events on public channel
|
||||
# presence() is a convienence method that subscribes to channel-pnpres with special logic for handling
|
||||
# presence-event formatted messages
|
||||
|
||||
# uncomment out to see server able to read on presence channel
|
||||
server.presence(channel=channel_public, callback=_server_presence_callback, error=_server_error_callback)
|
||||
|
||||
# now if the client tried to subscribe on the presence channel, and therefore, get state info
|
||||
# he is explicitly denied!
|
||||
|
||||
# uncomment out to see client not able to read on presence channel
|
||||
client.presence(channel=channel_public, callback=_client_presence_callback, error=_client_error_callback)
|
||||
|
||||
# client subscribes to public channel
|
||||
client.subscribe(channels=channel_public, state={"myKey": get_unique("foo")}, callback=_client_message_callback,
|
||||
error=_client_error_callback)
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
from pubnub import Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on, daemon=False)
|
||||
|
||||
channel = 'b'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
pubnub.presence(channel, callback=callback)
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
from pubnub import Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on, pooling=False)
|
||||
channel = 'hello_world'
|
||||
message = 'Hello World !!!'
|
||||
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.publish(channel, message))
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.publish(channel, message, callback=callback, error=callback)
|
||||
|
|
@ -0,0 +1,724 @@
|
|||
## 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/
|
||||
|
||||
|
||||
import sys
|
||||
from pubnub import Pubnub
|
||||
import threading
|
||||
from datetime import datetime
|
||||
|
||||
from cmd2 import Cmd, make_option, options, Cmd2TestCase
|
||||
import optparse
|
||||
import json
|
||||
|
||||
import atexit
|
||||
import os
|
||||
import readline
|
||||
import rlcompleter
|
||||
|
||||
import pygments
|
||||
from pygments.lexers import JsonLexer
|
||||
from pygments.formatters import TerminalFormatter
|
||||
|
||||
lexer = JsonLexer()
|
||||
formatter = TerminalFormatter()
|
||||
def highlight(msg):
|
||||
return pygments.highlight(msg, lexer, formatter)
|
||||
|
||||
|
||||
|
||||
historyPath = os.path.expanduser("~/.pubnub_console_history")
|
||||
|
||||
|
||||
def save_history(historyPath=historyPath):
|
||||
import readline
|
||||
readline.write_history_file(historyPath)
|
||||
|
||||
if os.path.exists(historyPath):
|
||||
readline.read_history_file(historyPath)
|
||||
|
||||
atexit.register(save_history)
|
||||
|
||||
of = sys.stdout
|
||||
|
||||
color = Cmd()
|
||||
|
||||
stop = None
|
||||
|
||||
full_date = False
|
||||
|
||||
|
||||
def stop_2(th):
|
||||
th._Thread__stop()
|
||||
|
||||
|
||||
def stop_3(th):
|
||||
th._stop()
|
||||
|
||||
|
||||
def print_console_2(of, message):
|
||||
print >>of, message
|
||||
|
||||
|
||||
def print_console_3(of, message):
|
||||
of.write(message)
|
||||
of.write("\n")
|
||||
|
||||
print_console = None
|
||||
|
||||
if type(sys.version_info) is tuple:
|
||||
print_console = print_console_2
|
||||
stop = stop_2
|
||||
else:
|
||||
if sys.version_info.major == 2:
|
||||
print_console = print_console_2
|
||||
stop = stop_2
|
||||
else:
|
||||
print_console = print_console_3
|
||||
stop = stop_3
|
||||
|
||||
|
||||
def get_date():
|
||||
if full_date is True:
|
||||
return color.colorize(datetime.now().strftime(
|
||||
'%Y-%m-%d %H:%M:%S'), "magenta")
|
||||
else:
|
||||
return color.colorize(datetime.now().strftime(
|
||||
'%H:%M:%S'), "magenta")
|
||||
|
||||
def print_ok_normal(msg, channel=None):
|
||||
if msg is None:
|
||||
return
|
||||
chstr = "[" + color.colorize(get_date(), "magenta") + "] "
|
||||
chstr += "[" + color.colorize("Channel : " + channel if channel is not None else "", "cyan") + "] "
|
||||
try:
|
||||
print_console(of, (chstr + color.colorize(str(msg), "green")))
|
||||
except UnicodeEncodeError as e:
|
||||
print_console(of, (msg))
|
||||
|
||||
of.flush()
|
||||
|
||||
|
||||
def print_error_normal(msg, channel=None):
|
||||
if msg is None:
|
||||
return
|
||||
chstr = "[" + color.colorize(get_date(), "magenta") + "] "
|
||||
chstr += "[" + color.colorize("Channel : " + channel if channel is not None else "", "cyan") + "] "
|
||||
try:
|
||||
print_console(of, (chstr + color.colorize(color.colorize(
|
||||
str(msg), "red"), "bold")))
|
||||
except UnicodeEncodeError as e:
|
||||
print_console(of, (msg))
|
||||
of.flush()
|
||||
|
||||
def print_ok_pretty(msg, channel=None):
|
||||
if msg is None:
|
||||
return
|
||||
chstr = "[" + color.colorize(get_date(), "magenta") + "] "
|
||||
chstr += "[" + color.colorize("Channel : " + channel if channel is not None else "", "cyan") + "] "
|
||||
try:
|
||||
print_console(of, (chstr + highlight(json.dumps(msg, indent=2))))
|
||||
except UnicodeEncodeError as e:
|
||||
print_console(of, (msg))
|
||||
|
||||
of.flush()
|
||||
|
||||
|
||||
def print_error_pretty(msg, channel=None):
|
||||
if msg is None:
|
||||
return
|
||||
chstr = "[" + color.colorize(get_date(), "magenta") + "] "
|
||||
chstr += "[" + color.colorize("Channel : " + channel if channel is not None else "", "cyan") + "] "
|
||||
try:
|
||||
print_console(of, (chstr + color.colorize(color.colorize(
|
||||
"ERROR: ", "red"), "bold") +
|
||||
highlight(json.dumps(msg, indent=2))))
|
||||
except UnicodeEncodeError as e:
|
||||
print_console(of, (msg))
|
||||
of.flush()
|
||||
|
||||
print_ok = print_ok_pretty
|
||||
print_error = print_error_pretty
|
||||
|
||||
|
||||
class DefaultPubnub(object):
|
||||
def handlerFunctionClosure(self, name):
|
||||
def handlerFunction(*args, **kwargs):
|
||||
print_error("Pubnub not initialized." +
|
||||
"Use init command to initialize")
|
||||
return handlerFunction
|
||||
|
||||
def __getattr__(self, name):
|
||||
return self.handlerFunctionClosure(name)
|
||||
|
||||
pubnub = DefaultPubnub()
|
||||
|
||||
|
||||
def kill_all_threads():
|
||||
for thread in threading.enumerate():
|
||||
if thread.isAlive():
|
||||
stop(thread)
|
||||
|
||||
|
||||
def get_input(message, t=None):
|
||||
while True:
|
||||
try:
|
||||
try:
|
||||
command = raw_input(message)
|
||||
except NameError:
|
||||
command = input(message)
|
||||
except KeyboardInterrupt:
|
||||
return None
|
||||
|
||||
command = command.strip()
|
||||
|
||||
if command is None or len(command) == 0:
|
||||
raise ValueError
|
||||
|
||||
if t is not None and t == bool:
|
||||
valid = ["True", "true", "1", 1, "y", "Y", "yes", "Yes", "YES"]
|
||||
if command in valid:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
if t is not None:
|
||||
command = t(command)
|
||||
else:
|
||||
command = eval("'" + command + "'")
|
||||
|
||||
return command
|
||||
except ValueError:
|
||||
print_error("Invalid input : " + command)
|
||||
|
||||
|
||||
def _publish_command_handler(channel, message, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
print_ok(pubnub.publish(channel, message,
|
||||
_callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def _subscribe_command_handler(channel):
|
||||
|
||||
def _callback(r, ch):
|
||||
print_ok(r, ch)
|
||||
|
||||
def _error(r, ch=None):
|
||||
print_error(r, ch if ch is not None else channel)
|
||||
|
||||
def _disconnect(r):
|
||||
print_ok("DISCONNECTED", r)
|
||||
|
||||
def _reconnect(r):
|
||||
print_ok("RECONNECTED", r)
|
||||
|
||||
def _connect(r):
|
||||
print_ok("CONNECTED", r)
|
||||
|
||||
pubnub.subscribe(channel, _callback, _error, connect=_connect,
|
||||
disconnect=_disconnect, reconnect=_reconnect)
|
||||
|
||||
|
||||
def _unsubscribe_command_handler(channels):
|
||||
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
unsub_list = []
|
||||
current_channel_list = pubnub.get_channel_array()
|
||||
|
||||
for channel in channels:
|
||||
pubnub.unsubscribe(channel)
|
||||
if (channel in current_channel_list):
|
||||
unsub_list.append(channel)
|
||||
|
||||
#pubnub.unsubscribe(channel + '-pnpres')
|
||||
#if (channel + '-pnpres' in current_channel_list):
|
||||
# unsub_list.append(channel + ' (Presence)')
|
||||
|
||||
if len(unsub_list) > 0:
|
||||
print_ok('Unsubscribed from : ' + str(unsub_list))
|
||||
else:
|
||||
print_error('Not subscribed to : ' + str(channels))
|
||||
|
||||
|
||||
def _grant_command_handler(channel, auth_key, read, write, ttl, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.grant(channel, auth_key,
|
||||
read, write, ttl,
|
||||
_callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def _revoke_command_handler(channel, auth_key, ttl, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.revoke(channel, auth_key, ttl,
|
||||
_callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def _audit_command_handler(channel, auth_key, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.audit(channel, auth_key,
|
||||
_callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def _history_command_handler(channel, count, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.history(channel, count,
|
||||
_callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def _here_now_command_handler(channel, async=False):
|
||||
def _callback(r):
|
||||
print_ok(r)
|
||||
|
||||
def _error(r):
|
||||
print_error(r)
|
||||
|
||||
print_ok(pubnub.here_now(channel, _callback if async is True else None,
|
||||
_error if async is True else None))
|
||||
|
||||
|
||||
def kill_all_threads():
|
||||
for thread in threading.enumerate():
|
||||
if thread.isAlive():
|
||||
stop(thread)
|
||||
|
||||
|
||||
def get_channel_array():
|
||||
channels = pubnub.get_channel_array()
|
||||
|
||||
for channel in channels:
|
||||
if "-pnpres" in channel:
|
||||
chname = channel.split("-pnpres")[0]
|
||||
if chname not in channels:
|
||||
continue
|
||||
i = channels.index(chname)
|
||||
channels[i] = channels[i] + color.colorize("(P)", "blue")
|
||||
channels.remove(channel)
|
||||
return channels
|
||||
|
||||
|
||||
class DevConsole(Cmd):
|
||||
def __init__(self):
|
||||
Cmd.__init__(self)
|
||||
global pubnub
|
||||
self.intro = "For Help type ? or help . " + \
|
||||
"To quit/exit type exit" + "\n" + \
|
||||
"Commands can also be provided on command line while starting console (in quotes) ex. " + \
|
||||
"pubnub-console 'init -p demo -s demo'"
|
||||
self.default_channel = None
|
||||
self.async = False
|
||||
pubnub = Pubnub("demo", "demo")
|
||||
self.channel_truncation = 3
|
||||
self.prompt = self.get_prompt()
|
||||
self.publish_key = "demo"
|
||||
self.subscribe_key = "demo"
|
||||
self.origin = "pubsub.pubnub.com"
|
||||
self.auth_key = None
|
||||
self.cipher_key = None
|
||||
self.secret_key = "demo"
|
||||
self.ssl = False
|
||||
self.uuid = None
|
||||
self.disable_pretty = False
|
||||
|
||||
def get_channel_origin(self):
|
||||
cho = ""
|
||||
channels = get_channel_array()
|
||||
channels_str = ",".join(channels)
|
||||
sl = self.channel_truncation
|
||||
if len(channels) > int(sl) and int(sl) > 0:
|
||||
cho += ",".join(channels[:int(sl)]) + " " + str(
|
||||
len(channels) - int(sl)) + " more..."
|
||||
else:
|
||||
cho += ",".join(channels)
|
||||
|
||||
if len(channels) > 0:
|
||||
cho = color.colorize(cho, "bold") + "@"
|
||||
|
||||
origin = pubnub.get_origin().split("://")[1]
|
||||
origin += color.colorize(" (SSL)", "green") if pubnub.get_origin(
|
||||
).split("://")[0] == "https" else ""
|
||||
return " [" + cho + color.colorize(origin, "blue") + "] > "
|
||||
|
||||
def get_prompt(self):
|
||||
prompt = "[" + get_date() + "]"
|
||||
|
||||
if self.default_channel is not None and len(self.default_channel) > 0:
|
||||
prompt += " [default channel: " + color.colorize(
|
||||
self.default_channel, "bold") + "]"
|
||||
|
||||
prompt += self.get_channel_origin()
|
||||
return prompt
|
||||
|
||||
def precmd(self, line):
|
||||
self.prompt = self.get_prompt()
|
||||
return line
|
||||
|
||||
#def emptyline(self):
|
||||
# self.prompt = self.get_prompt()
|
||||
|
||||
def cmdloop_with_keyboard_interrupt(self):
|
||||
try:
|
||||
self.cmdloop()
|
||||
except KeyboardInterrupt as e:
|
||||
pass
|
||||
sys.stdout.write('\n')
|
||||
kill_all_threads()
|
||||
|
||||
@options([make_option('-p', '--publish-key', action="store",
|
||||
default=None, help="Publish Key"),
|
||||
make_option('-s', '--subscribe-key', action="store",
|
||||
default=None, help="Subscribe Key"),
|
||||
make_option('-k', '--secret-key', action="store",
|
||||
default=None, help="cipher Key"),
|
||||
make_option('-c', '--cipher-key', action="store",
|
||||
default=None, help="Secret Key"),
|
||||
make_option('-a', '--auth-key', action="store",
|
||||
default=None, help="Auth Key"),
|
||||
make_option('--ssl-on', dest='ssl', action='store_true',
|
||||
default=False, help="SSL Enabled ?"),
|
||||
make_option('-o', '--origin', action="store",
|
||||
default=None, help="Origin"),
|
||||
make_option('-u', '--uuid', action="store",
|
||||
default=None, help="UUID"),
|
||||
make_option('--disable-pretty-print', dest='disable_pretty', action='store_true',
|
||||
default=False, help="Disable Pretty Print ?")
|
||||
])
|
||||
def do_init(self, command, opts):
|
||||
global pubnub
|
||||
global print_ok
|
||||
global print_error
|
||||
global print_ok_normal
|
||||
global print_error_normal
|
||||
global print_error_pretty
|
||||
global print_ok_pretty
|
||||
|
||||
self.publish_key = opts.publish_key if opts.publish_key is not None else self.publish_key
|
||||
self.subscribe_key = opts.subscribe_key if opts.subscribe_key is not None else self.subscribe_key
|
||||
self.secret_key = opts.secret_key if opts.secret_key is not None else self.secret_key
|
||||
self.cipher_key = opts.cipher_key if opts.cipher_key is not None else self.cipher_key
|
||||
self.auth_key = opts.auth_key if opts.auth_key is not None else self.auth_key
|
||||
self.origin = opts.origin if opts.origin is not None else self.origin
|
||||
self.uuid = opts.uuid if opts.uuid is not None else self.uuid
|
||||
self.ssl = opts.ssl if opts.ssl is not None else self.ssl
|
||||
self.disable_pretty = opts.disable_pretty if opts.disable_pretty is not None else self.disable_pretty
|
||||
|
||||
pubnub = Pubnub(self.publish_key,
|
||||
self.subscribe_key,
|
||||
self.secret_key,
|
||||
self.cipher_key,
|
||||
self.auth_key,
|
||||
self.ssl,
|
||||
self.origin,
|
||||
self.uuid)
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
if opts.disable_pretty is True:
|
||||
print_ok = print_ok_normal
|
||||
print_error = print_error_normal
|
||||
else:
|
||||
print_ok = print_ok_pretty
|
||||
print_error = print_error_pretty
|
||||
|
||||
def do_set_sync(self, command):
|
||||
"""unset_async
|
||||
Unset Async mode"""
|
||||
self.async = False
|
||||
|
||||
def do_set_async(self, command):
|
||||
"""set_async
|
||||
Set Async mode"""
|
||||
self.async = True
|
||||
|
||||
@options([make_option('-n', '--count', action="store",
|
||||
default=3, help="Number of channels on prompt")
|
||||
])
|
||||
def do_set_channel_truncation(self, command, opts):
|
||||
"""set_channel_truncation
|
||||
Set Channel Truncation"""
|
||||
|
||||
self.channel_truncation = opts.count
|
||||
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
def do_unset_channel_truncation(self, command):
|
||||
"""unset_channel_truncation
|
||||
Unset Channel Truncation"""
|
||||
self.channel_truncation = 0
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
def do_set_full_date(self, command):
|
||||
global full_date
|
||||
"""do_set_full_date
|
||||
Set Full Date"""
|
||||
full_date = True
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
def do_unset_full_date(self, command):
|
||||
global full_date
|
||||
"""do_unset_full_date
|
||||
Unset Full Date"""
|
||||
full_date = False
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
@options([make_option('-c', '--channel',
|
||||
action="store", help="Default Channel")
|
||||
])
|
||||
def do_set_default_channel(self, command, opts):
|
||||
|
||||
if opts.channel is None:
|
||||
print_error("Missing channel")
|
||||
return
|
||||
self.default_channel = opts.channel
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
@options([make_option('-f', '--file', action="store",
|
||||
default="./pubnub-console.log", help="Output file")
|
||||
])
|
||||
def do_set_output_file(self, command, opts):
|
||||
global of
|
||||
try:
|
||||
of = file(opts.file, 'w+')
|
||||
except IOError as e:
|
||||
print_error("Could not set output file. " + e.reason)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel for here now data")
|
||||
])
|
||||
def do_here_now(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
if opts.channel is None:
|
||||
print_error("Missing channel")
|
||||
return
|
||||
|
||||
_here_now_command_handler(opts.channel, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel for history data"),
|
||||
make_option('-n', '--count', action="store",
|
||||
default=5, help="Number of messages")
|
||||
])
|
||||
def do_get_history(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
if opts.channel is None:
|
||||
print_error("Missing channel")
|
||||
return
|
||||
|
||||
_history_command_handler(opts.channel, opts.count, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel on which to publish")
|
||||
])
|
||||
def do_publish(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
if opts.channel is None:
|
||||
print_error("Missing channel")
|
||||
return
|
||||
|
||||
if command is None:
|
||||
print_error("Missing message")
|
||||
return
|
||||
|
||||
try:
|
||||
message = json.loads(str(command))
|
||||
except ValueError as ve:
|
||||
message = str(command)
|
||||
|
||||
_publish_command_handler(opts.channel, message, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel on which to grant"),
|
||||
make_option('-a', '--auth-key', dest="auth_key",
|
||||
action="store",
|
||||
help="Auth Key"),
|
||||
make_option('-r', '--read-enabled', dest='read',
|
||||
action='store_true',
|
||||
default=False, help="Read ?"),
|
||||
make_option('-w', '--write-enabled', dest='write',
|
||||
action='store_true',
|
||||
default=False, help="Write ?"),
|
||||
make_option('-t', '--ttl', action="store",
|
||||
default=5, help="TTL"),
|
||||
make_option('-p', '--presence', action="store_true",
|
||||
dest="presence",
|
||||
default=False, help="Grant on presence channel ?")
|
||||
])
|
||||
def do_grant(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
|
||||
opts.auth_key = pubnub.auth_key \
|
||||
if opts.auth_key is None else opts.auth_key
|
||||
|
||||
_grant_command_handler(opts.channel, opts.auth_key,
|
||||
opts.read, opts.write,
|
||||
opts.ttl, async=self.async)
|
||||
|
||||
if opts.presence is True:
|
||||
_grant_command_handler(opts.channel + '-pnpres', opts.auth_key,
|
||||
opts.read, opts.write,
|
||||
opts.ttl, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel on which to revoke"),
|
||||
make_option('-a', '--auth-key', dest="auth_key", action="store",
|
||||
help="Auth Key"),
|
||||
make_option('-t', '--ttl', action="store",
|
||||
default=5, help="TTL"),
|
||||
make_option('-p', '--presence', action="store_true",
|
||||
dest="presence",
|
||||
default=False, help="Revoke on presence channel ?")
|
||||
])
|
||||
def do_revoke(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
|
||||
opts.auth_key = pubnub.auth_key \
|
||||
if opts.auth_key is None else opts.auth_key
|
||||
|
||||
_revoke_command_handler(
|
||||
opts.channel, opts.auth_key, opts.ttl, async=self.async)
|
||||
|
||||
if opts.presence is True:
|
||||
_revoke_command_handler(
|
||||
opts.channel + '-pnpres', opts.auth_key,
|
||||
opts.ttl, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel on which to revoke"),
|
||||
make_option('-a', '--auth-key', dest="auth_key", action="store",
|
||||
help="Auth Key")
|
||||
])
|
||||
def do_audit(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
|
||||
opts.auth_key = pubnub.auth_key \
|
||||
if opts.auth_key is None else opts.auth_key
|
||||
|
||||
_audit_command_handler(opts.channel, opts.auth_key, async=self.async)
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel for unsubscribe"),
|
||||
make_option('-a', '--all', action="store_true", dest="all",
|
||||
default=False, help="Unsubscribe from all channels"),
|
||||
make_option('-p', '--presence', action="store_true",
|
||||
dest="presence",
|
||||
default=False, help="Unsubscribe from presence events ?")
|
||||
])
|
||||
def do_unsubscribe(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
|
||||
if (opts.all is True):
|
||||
opts.channel = []
|
||||
chs = pubnub.get_channel_array()
|
||||
for ch in chs:
|
||||
if '-pnpres' not in ch:
|
||||
opts.channel.append(ch)
|
||||
elif opts.presence is True:
|
||||
opts.channel.append(ch)
|
||||
|
||||
if opts.channel is None:
|
||||
print_error("Missing channel")
|
||||
return
|
||||
|
||||
if not isinstance(opts.channel, list):
|
||||
ch = []
|
||||
ch.append(opts.channel)
|
||||
opts.channel = ch
|
||||
|
||||
channels = []
|
||||
if opts.presence is True and opts.all is False:
|
||||
for c in opts.channel:
|
||||
if '-pnpres' not in c:
|
||||
channels.append(c + '-pnpres')
|
||||
|
||||
for c in opts.channel:
|
||||
channels.append(c)
|
||||
|
||||
_unsubscribe_command_handler(channels)
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
@options([make_option('-c', '--channel', action="store",
|
||||
help="Channel for subscribe"),
|
||||
make_option('-g', '--get-channel-list', action="store_true",
|
||||
dest="get",
|
||||
default=False, help="Get susbcribed channel list"),
|
||||
make_option('-p', '--presence', action="store_true",
|
||||
dest="presence",
|
||||
default=False, help="Presence events ?")
|
||||
])
|
||||
def do_subscribe(self, command, opts):
|
||||
opts.channel = self.default_channel \
|
||||
if opts.channel is None else opts.channel
|
||||
if opts is None:
|
||||
print_error("Missing argument")
|
||||
return
|
||||
|
||||
if opts.channel is not None:
|
||||
_subscribe_command_handler(opts.channel)
|
||||
|
||||
if opts.presence is True:
|
||||
_subscribe_command_handler(opts.channel + '-pnpres')
|
||||
|
||||
if opts.get is True:
|
||||
print_ok(get_channel_array())
|
||||
self.prompt = self.get_prompt()
|
||||
|
||||
def do_exit(self, args):
|
||||
kill_all_threads()
|
||||
return -1
|
||||
|
||||
#def do_EOF(self, args):
|
||||
# kill_all_threads()
|
||||
# return self.do_exit(args)
|
||||
|
||||
#def handler(self, signum, frame):
|
||||
# kill_all_threads()
|
||||
|
||||
|
||||
def main():
|
||||
app = DevConsole()
|
||||
app.cmdloop_with_keyboard_interrupt()
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
from setuptools import setup
|
||||
|
||||
setup(
|
||||
name='pubnub-console',
|
||||
version='3.5.2',
|
||||
description='PubNub Developer Console',
|
||||
author='Stephen Blum',
|
||||
author_email='support@pubnub.com',
|
||||
url='http://pubnub.com',
|
||||
scripts=['pubnub-console'],
|
||||
license='MIT',
|
||||
classifiers=(
|
||||
'Development Status :: 5 - Production/Stable',
|
||||
'Intended Audience :: Developers',
|
||||
'Programming Language :: Python',
|
||||
'License :: OSI Approved :: MIT License',
|
||||
'Operating System :: OS Independent',
|
||||
'Topic :: Internet :: WWW/HTTP',
|
||||
'Topic :: Software Development :: Libraries :: Python Modules',
|
||||
),
|
||||
install_requires=[
|
||||
'pubnub>=3.5.2',
|
||||
'cmd2>=0.6.7',
|
||||
'pygments >= 1.6'
|
||||
],
|
||||
zip_safe=False,
|
||||
)
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
pycrypto==2.6.1
|
||||
cmd2==0.6.7
|
||||
requests==2.2.1
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
from pubnub import Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'pam'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'pam'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'pam'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
channel = 'hello_world'
|
||||
authkey = "abcd"
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.revoke(channel, authkey))
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.revoke(channel, authkey, callback=callback, error=callback)
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#!/bin/bash
|
||||
|
||||
#!/bin/bash -e
|
||||
|
||||
BASEDIR=.
|
||||
|
||||
if [ ! -d "$BASEDIR/ve" ]; then
|
||||
virtualenv -q $BASEDIR/ve --no-site-packages
|
||||
$BASEDIR/ve/bin/activate
|
||||
echo "Virtualenv created."
|
||||
fi
|
||||
|
||||
chmod 755 $BASEDIR/ve/bin/activate
|
||||
$BASEDIR/ve/bin/activate
|
||||
|
||||
if [ ! -f "$BASEDIR/ve/updated" -o $BASEDIR/requirements.pip -nt $BASEDIR/ve/updated ]; then
|
||||
pip install -r $BASEDIR/requirements.pip -E $BASEDIR/ve
|
||||
touch $BASEDIR/ve/updated
|
||||
echo "Requirements installed."
|
||||
fi
|
||||
|
||||
|
||||
|
||||
if ! type "screen" > /dev/null; then
|
||||
echo "[ERROR] Screen is not installed. Please install screen to use this utility ."
|
||||
exit
|
||||
fi
|
||||
rm ./pubnub-console.log
|
||||
touch ./pubnub-console.log
|
||||
export PYTHONPATH=../..
|
||||
screen -X -S pubnub-console quit 2>&1 > /dev/null
|
||||
OS="`uname`"
|
||||
case $OS in
|
||||
[dD]'arwin')
|
||||
screen -c config_osx
|
||||
;;
|
||||
*) screen -c config ;;
|
||||
esac
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
import time
|
||||
from gevent import monkey
|
||||
from pubnub import Pubnub
|
||||
|
||||
monkey.patch_all()
|
||||
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
|
||||
|
||||
def log(a):
|
||||
print(a)
|
||||
|
||||
|
||||
pubnub.set_http_debug(log)
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.state(channel='abcd', uuid='33c72389-1110-4312-9444-4dd24ade1d57', state={'a': 'b'}))
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
|
||||
pubnub.state(channel='abcd', uuid='33c72389-1110-4312-9444-4dd24ade1d57', state={'a': 'b'}, callback=callback,
|
||||
error=callback)
|
||||
|
||||
time.sleep(5)
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.state(channel='abcd', uuid='33c72389-1110-4312-9444-4dd24ade1d57'))
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
|
||||
pubnub.state(channel='abcd', uuid='33c72389-1110-4312-9444-4dd24ade1d57', callback=callback, error=callback)
|
||||
|
||||
time.sleep(5)
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.state(channel='abcd'))
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
|
||||
pubnub.state(channel='abcd', callback=callback, error=callback)
|
||||
|
||||
time.sleep(5)
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.state(channel='abcd', state={'a': 'b'}))
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
|
||||
pubnub.state(channel='abcd', state={'a': 'b'}, callback=callback, error=callback)
|
||||
|
||||
time.sleep(5)
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.state(channel='abcd'))
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
|
||||
pubnub.state(channel='abcd', callback=callback, error=callback)
|
||||
|
||||
time.sleep(5)
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.state(channel='abcd'))
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
|
||||
pubnub.state(channel='abcd', callback=callback, error=callback)
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
import time
|
||||
from pubnub import Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on, daemon=True)
|
||||
|
||||
channel = 'a'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.subscribe(channels=channel, callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
|
||||
while True:
|
||||
time.sleep(10)
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
|
||||
from pubnub import Pubnub as Pubnub
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or 'abcd'
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
|
||||
channel = 'ab'
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback_abc(message, channel, real_channel):
|
||||
print(str(message) + ' , ' + channel + ', ' + real_channel)
|
||||
pubnub.unsubscribe_group(channel_group='abc')
|
||||
# pubnub.stop()
|
||||
|
||||
|
||||
def callback_d(message, channel):
|
||||
print(str(message) + ' , ' + channel)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect_abc(message):
|
||||
print("CONNECTED " + str(message))
|
||||
|
||||
|
||||
def connect_d(message):
|
||||
print("CONNECTED " + str(message))
|
||||
pubnub.unsubscribe(channel='d')
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED " + str(message))
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED " + str(message))
|
||||
|
||||
|
||||
print(pubnub.channel_group_add_channel(channel_group='abc', channel="b"))
|
||||
|
||||
pubnub.subscribe_group(channel_groups='abc', callback=callback_abc, error=error,
|
||||
connect=connect_abc, reconnect=reconnect, disconnect=disconnect)
|
||||
|
||||
pubnub.subscribe(channels='d', callback=callback_d, error=error,
|
||||
connect=connect_d, reconnect=reconnect, disconnect=disconnect)
|
||||
|
||||
pubnub.start()
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import sys
|
||||
from gevent import monkey
|
||||
from pubnub import Pubnub
|
||||
|
||||
monkey.patch_all()
|
||||
|
||||
publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
|
||||
subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
|
||||
secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
|
||||
cipher_key = len(sys.argv) > 4 and sys.argv[4] or ''
|
||||
ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Initiate Pubnub State
|
||||
# -----------------------------------------------------------------------
|
||||
pubnub = Pubnub(publish_key=publish_key, subscribe_key=subscribe_key,
|
||||
secret_key=secret_key, cipher_key=cipher_key, ssl_on=ssl_on)
|
||||
|
||||
# Synchronous usage
|
||||
print(pubnub.where_now(uuid='33c72389-1110-4312-9444-4dd24ade1d57'))
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
|
||||
pubnub.where_now(uuid='33c72389-1110-4312-9444-4dd24ade1d57', callback=callback, error=callback)
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
from gevent import monkey
|
||||
from pubnub import Pubnub
|
||||
|
||||
monkey.patch_all()
|
||||
|
||||
|
||||
pubnub = Pubnub(publish_key="ds", subscribe_key="ds",
|
||||
secret_key="ds", ssl_on=False)
|
||||
|
||||
|
||||
# Wildcard Subscribe without presence
|
||||
|
||||
def a():
|
||||
channel_wc = "a.*"
|
||||
channel = "a.b"
|
||||
|
||||
def callback(message1, channel1, real_channel=None):
|
||||
print(channel1 + " : " + real_channel + " : " + str(message1))
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
def connect(channel1=None):
|
||||
print("Connect on " + channel1)
|
||||
print(pubnub.publish(channel=channel, message="a"))
|
||||
|
||||
def disconnect(channel1=None):
|
||||
print("Disconnect on " + channel1)
|
||||
|
||||
def reconnect(channel1=None):
|
||||
print("Reconnect on " + channel1)
|
||||
|
||||
pubnub.subscribe(channels=channel_wc, callback=callback, error=callback,
|
||||
connect=connect, disconnect=disconnect, reconnect=reconnect)
|
||||
|
||||
|
||||
# Wildcard Subscribe with presence
|
||||
|
||||
def b():
|
||||
channel_wc = "b.*"
|
||||
channel = "b.c"
|
||||
|
||||
def callback(message1, channel1, real_channel=None):
|
||||
print(channel1 + " : " + real_channel + " : " + str(message1))
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
def presence(message1, channel1, real_channel=None):
|
||||
print(channel1 + " : " + real_channel + " : " + str(message1))
|
||||
|
||||
def connect(channel1=None):
|
||||
print("Connect on " + channel1)
|
||||
print(pubnub.publish(channel=channel, message="b"))
|
||||
|
||||
def disconnect(channel1=None):
|
||||
print("Disconnect on " + channel1)
|
||||
|
||||
def reconnect(channel1=None):
|
||||
print("Reconnect on " + channel1)
|
||||
|
||||
pubnub.subscribe(channels=channel_wc, callback=callback, error=callback,
|
||||
connect=connect, disconnect=disconnect, reconnect=reconnect, presence=presence)
|
||||
|
||||
|
||||
# Wildcard Subscribe and unsubscribe
|
||||
|
||||
def c():
|
||||
channel_wc = "c.*"
|
||||
channel = "c.d"
|
||||
|
||||
def callback(message1, channel1, real_channel=None):
|
||||
print(channel1 + " : " + real_channel + " : " + str(message1))
|
||||
pubnub.unsubscribe(channel="c.*")
|
||||
print(pubnub.publish(channel=channel, message="c1"))
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
def connect(channel1=None):
|
||||
print("Connect on " + channel1)
|
||||
print(pubnub.publish(channel=channel, message="c"))
|
||||
|
||||
def disconnect(channel1=None):
|
||||
print("Disconnect on " + channel1)
|
||||
|
||||
def reconnect(channel1=None):
|
||||
print("Reconnect on " + channel1)
|
||||
|
||||
pubnub.subscribe(channels=channel_wc, callback=callback, error=callback,
|
||||
connect=connect, disconnect=disconnect, reconnect=reconnect)
|
||||
|
||||
|
||||
a()
|
||||
b()
|
||||
c()
|
||||
|
|
@ -0,0 +1,205 @@
|
|||
## Contact support@pubnub.com for all questions
|
||||
|
||||
#### [PubNub](http://www.pubnub.com) Real-time Data Network
|
||||
##### Standalone Python Migration
|
||||
|
||||
#### Init
|
||||
|
||||
```
|
||||
|
||||
# Pre 3.5:
|
||||
pubnub = Pubnub(
|
||||
"demo", ## PUBLISH_KEY
|
||||
"demo", ## SUBSCRIBE_KEY
|
||||
False ## SSL_ON?
|
||||
)
|
||||
|
||||
# New in 3.5+
|
||||
pubnub = Pubnub(publish_key="demo", subscribe_key="demo", ssl_on=False)
|
||||
|
||||
```
|
||||
|
||||
#### PUBLISH
|
||||
|
||||
```
|
||||
channel = 'hello_world'
|
||||
message = 'Hello World !!!'
|
||||
|
||||
# Pre 3.5:
|
||||
info = pubnub.publish({
|
||||
'channel' : channel,
|
||||
'message' : message
|
||||
})
|
||||
print(info)
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
# Synchronous usage
|
||||
print pubnub.publish(channel='hello_world', message='Hello World !!!')
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.publish(channel, message, callback=callback, error=callback)
|
||||
|
||||
```
|
||||
|
||||
|
||||
#### SUBSCRIBE
|
||||
Pre 3.5.x, subscribe was blocking and would only be terminated via a false return from the callback. In our latest version of the SDK, subscribe is asyncronous, and because of this, usage is a bit different, but the experience is more like our other async SDKs.
|
||||
|
||||
```
|
||||
|
||||
# Listen for Messages
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
# Pre 3.5:
|
||||
# Listen for Messages *BLOCKING*
|
||||
def receive(message) :
|
||||
print(message)
|
||||
return True
|
||||
|
||||
pubnub.subscribe({
|
||||
'channel' : channel,
|
||||
'callback' : receive
|
||||
})
|
||||
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
def connect(message):
|
||||
print("CONNECTED")
|
||||
|
||||
|
||||
def reconnect(message):
|
||||
print("RECONNECTED")
|
||||
|
||||
|
||||
def disconnect(message):
|
||||
print("DISCONNECTED")
|
||||
|
||||
|
||||
pubnub.subscribe(channel, callback=callback, error=callback,
|
||||
connect=connect, reconnect=reconnect, disconnect=disconnect)
|
||||
```
|
||||
|
||||
#### Unsubscribe
|
||||
Once subscribed, you can easily, gracefully, unsubscribe:
|
||||
|
||||
```
|
||||
# Pre 3.5:
|
||||
#
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
pubnub.unsubscribe(channel='hello_world')
|
||||
```
|
||||
|
||||
#### PRESENCE
|
||||
|
||||
```
|
||||
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
# Pre 3.5:
|
||||
def pres_event(message) :
|
||||
print(message)
|
||||
return True
|
||||
|
||||
pubnub.presence({
|
||||
'channel' : channel,
|
||||
'callback' : receive
|
||||
})
|
||||
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
# Listen for Presence Event Messages
|
||||
|
||||
def callback(message, channel):
|
||||
print(message)
|
||||
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
|
||||
|
||||
pubnub.presence(channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### HERE_NOW
|
||||
|
||||
```
|
||||
|
||||
# Pre 3.5:
|
||||
# Get info on who is here right now!
|
||||
|
||||
here_now = pubnub.here_now({
|
||||
'channel' : 'hello_world',
|
||||
})
|
||||
|
||||
print(here_now['occupancy'])
|
||||
print(here_now['uuids'])
|
||||
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
# Get info on who is here right now!
|
||||
|
||||
channel = 'hello_world'
|
||||
|
||||
# Synchronous usage
|
||||
print pubnub.here_now(channel)
|
||||
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.here_now(channel, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
#### HISTORY
|
||||
|
||||
```
|
||||
|
||||
# Pre 3.5:
|
||||
# Load Previously Published Messages
|
||||
history = pubnub.detailedHistory({
|
||||
'channel' : 'my_channel',
|
||||
'end' : my_end_time_token, # Optional
|
||||
'start' : my_start_time_token, # Optional
|
||||
'count' : num_of_msgs_to_return # Optional, default is 100
|
||||
})
|
||||
print(history)
|
||||
|
||||
# New in 3.5+
|
||||
|
||||
# Synchronous usage
|
||||
|
||||
print pubnub.history(channel, count=2)
|
||||
|
||||
# Asynchronous usage
|
||||
|
||||
|
||||
def callback(message):
|
||||
print(message)
|
||||
|
||||
pubnub.history(channel, count=2, callback=callback, error=callback)
|
||||
```
|
||||
|
||||
## Contact support@pubnub.com for all questions
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
from pubnub import Pubnub
|
||||
import random
|
||||
|
||||
pubnub = Pubnub("demo", "demo")
|
||||
pubnub.set_u(True)
|
||||
|
||||
|
||||
def rand_str(s):
|
||||
return str(s) + '-' + str(random.randint(1, 100000000000))
|
||||
|
||||
|
||||
def test_1():
|
||||
channel = rand_str('channel')
|
||||
channel2 = rand_str('channel')
|
||||
channel_group = rand_str('group')
|
||||
channel_group2 = rand_str('group')
|
||||
namespace = rand_str('ns')
|
||||
|
||||
resp = pubnub.channel_group_add_channel(channel_group=namespace + ':' + channel_group, channel=channel)
|
||||
assert resp['status'] == 200
|
||||
assert resp['message'] == 'OK'
|
||||
assert resp['error'] == False
|
||||
|
||||
resp = pubnub.channel_group_add_channel(channel_group=namespace + ':' + channel_group, channel=channel2)
|
||||
assert resp['status'] == 200
|
||||
assert resp['message'] == 'OK'
|
||||
assert resp['error'] == False
|
||||
|
||||
resp = pubnub.channel_group_add_channel(channel_group=namespace + ':' + channel_group2, channel=channel)
|
||||
assert resp['status'] == 200
|
||||
assert resp['message'] == 'OK'
|
||||
assert resp['error'] == False
|
||||
|
||||
resp = pubnub.channel_group_add_channel(channel_group=namespace + ':' + channel_group2, channel=channel2)
|
||||
assert resp['status'] == 200
|
||||
assert resp['message'] == 'OK'
|
||||
assert resp['error'] == False
|
||||
|
||||
resp = pubnub.channel_group_list_channels(channel_group=namespace + ':' + channel_group)
|
||||
assert channel in resp['payload']['channels']
|
||||
assert channel2 in resp['payload']['channels']
|
||||
assert len(resp['payload']['channels']) == 2
|
||||
|
||||
resp = pubnub.channel_group_remove_channel(channel_group=namespace + ':' + channel_group, channel=channel2)
|
||||
print(resp)
|
||||
assert resp['status'] == 200
|
||||
assert resp['message'] == 'OK'
|
||||
assert resp['error'] == False
|
||||
|
||||
resp = pubnub.channel_group_list_channels(channel_group=namespace + ':' + channel_group)
|
||||
print(resp)
|
||||
assert channel in resp['payload']['channels']
|
||||
assert len(resp['payload']['channels']) == 1
|
||||
|
||||
resp = pubnub.channel_group_list_channels(channel_group=namespace + ':' + channel_group2)
|
||||
assert channel in resp['payload']['channels']
|
||||
assert channel2 in resp['payload']['channels']
|
||||
assert len(resp['payload']['channels']) == 2
|
||||
|
||||
resp = pubnub.channel_group_remove_channel(channel_group=namespace + ':' + channel_group2, channel=channel2)
|
||||
print(resp)
|
||||
assert resp['status'] == 200
|
||||
assert resp['message'] == 'OK'
|
||||
assert resp['error'] == False
|
||||
|
||||
resp = pubnub.channel_group_list_channels(channel_group=namespace + ':' + channel_group2)
|
||||
print(resp)
|
||||
assert channel in resp['payload']['channels']
|
||||
assert len(resp['payload']['channels']) == 1
|
||||
|
||||
resp = pubnub.channel_group_list_groups(namespace=namespace)
|
||||
assert channel_group in resp['payload']['groups']
|
||||
assert channel_group2 in resp['payload']['groups']
|
||||
assert len(resp['payload']['groups']) == 2
|
||||
|
||||
resp = pubnub.channel_group_remove_group(channel_group=namespace + ':' + channel_group2)
|
||||
print(resp)
|
||||
assert resp['status'] == 200
|
||||
assert resp['message'] == 'OK'
|
||||
assert resp['error'] == False
|
||||
|
||||
resp = pubnub.channel_group_list_groups(namespace=namespace)
|
||||
assert channel_group in resp['payload']['groups']
|
||||
assert len(resp['payload']['groups']) == 1
|
||||
|
||||
resp = pubnub.channel_group_list_namespaces()
|
||||
assert namespace in resp['payload']['namespaces']
|
||||
|
||||
resp = pubnub.channel_group_remove_namespace(namespace=namespace)
|
||||
print(resp)
|
||||
assert resp['status'] == 200
|
||||
assert resp['message'] == 'OK'
|
||||
assert resp['error'] == False
|
||||
|
||||
resp = pubnub.channel_group_list_namespaces()
|
||||
assert namespace not in resp['payload']['namespaces']
|
||||
|
|
@ -0,0 +1,90 @@
|
|||
from pubnub import Pubnub
|
||||
import time
|
||||
|
||||
subkey = "sub-c-9aeec0d4-cdf4-11e5-bcee-0619f8945a4f"
|
||||
pubkey = "pub-c-b3fdf8fc-4516-4ab2-8836-6fb22ba7870d"
|
||||
secretkey = "sec-c-ZDQwNTUwMDctZDViYi00MzhlLTg2NTctYjViZDcwNTA5Zjhj"
|
||||
pubnub = Pubnub(pubkey, subkey)
|
||||
pubnub_pam = Pubnub(pubkey, subkey, secretkey)
|
||||
pam_timeout = 10
|
||||
|
||||
|
||||
# Grant permission read true, write true, on channel ( Sync Mode )
|
||||
def test_1():
|
||||
resp = pubnub_pam.grant(channel="abcd", auth_key="abcd", read=True,
|
||||
write=True, ttl=1)
|
||||
print(resp)
|
||||
assert resp['message'] == 'Success'
|
||||
assert resp['payload'] == {
|
||||
'auths': {'abcd': {'r': 1, 'w': 1, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': 'abcd', 'ttl': 1
|
||||
}
|
||||
|
||||
|
||||
# Grant permission read false, write false, on channel ( Sync Mode )
|
||||
def test_2():
|
||||
resp = pubnub_pam.grant(channel="abcd", auth_key="abcd", read=False,
|
||||
write=False, ttl=1)
|
||||
assert resp['message'] == 'Success'
|
||||
assert resp['payload'] == {
|
||||
'auths': {'abcd': {'r': 0, 'w': 0, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': 'abcd', 'ttl': 1
|
||||
}
|
||||
|
||||
|
||||
# Grant permission read True, write false, on channel ( Sync Mode )
|
||||
def test_3():
|
||||
resp = pubnub_pam.grant(channel="abcd", auth_key="abcd", read=True,
|
||||
write=False, ttl=1)
|
||||
assert resp['message'] == 'Success'
|
||||
assert resp['payload'] == {
|
||||
'auths': {'abcd': {'r': 1, 'w': 0, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': 'abcd', 'ttl': 1
|
||||
}
|
||||
|
||||
|
||||
# Grant permission read False, write True, on channel ( Sync Mode )
|
||||
def test_4():
|
||||
resp = pubnub_pam.grant(channel="abcd", auth_key="abcd", read=True,
|
||||
write=False, ttl=1)
|
||||
assert resp['message'] == 'Success'
|
||||
assert resp['payload'] == {
|
||||
'auths': {'abcd': {'r': 1, 'w': 0, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': 'abcd', 'ttl': 1
|
||||
}
|
||||
|
||||
|
||||
# Grant permission read False, write True, on channel ( Sync Mode ), TTL 10
|
||||
def test_5():
|
||||
resp = pubnub_pam.grant(channel="abcd", auth_key="abcd", read=True,
|
||||
write=False, ttl=10)
|
||||
assert resp['message'] == 'Success'
|
||||
assert resp['payload'] == {
|
||||
'auths': {'abcd': {'r': 1, 'w': 0, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': 'abcd', 'ttl': 10
|
||||
}
|
||||
|
||||
|
||||
# Complete flow , try publish on forbidden channel, grant permission to
|
||||
# auth key and try again. ( Sync Mode)
|
||||
def test_8():
|
||||
channel = "test_8-" + str(time.time())
|
||||
message = "Hello World"
|
||||
auth_key = "auth-" + channel
|
||||
pubnub.set_auth_key(auth_key)
|
||||
resp = pubnub_pam.grant(channel=channel, read=True, write=True,
|
||||
auth_key=auth_key, ttl=10)
|
||||
assert resp == {
|
||||
'message': 'Success',
|
||||
'payload': {'auths': {auth_key: {'r': 1, 'w': 1, 'm': 0}},
|
||||
'subscribe_key': subkey,
|
||||
'level': 'user', 'channel': channel, 'ttl': 10}
|
||||
}
|
||||
time.sleep(pam_timeout)
|
||||
resp = pubnub.publish(channel=channel, message=message)
|
||||
assert resp[0] == 1
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
from pubnub import Pubnub
|
||||
import time
|
||||
import random
|
||||
from nose.tools import with_setup
|
||||
|
||||
|
||||
pubnub = Pubnub("ds", "ds")
|
||||
pubnub_enc = Pubnub(publish_key="ds", subscribe_key="ds", cipher_key="enigma")
|
||||
pubnub_pam = Pubnub(publish_key="pam", subscribe_key="pam", secret_key="pam")
|
||||
|
||||
|
||||
def rand(msg):
|
||||
return "rand-" + str(random.random()) + "-" + msg
|
||||
|
||||
channel = rand("channel")
|
||||
channel_enc = rand("channel_enc")
|
||||
channel_pam = rand("channel_pam")
|
||||
|
||||
messages = []
|
||||
|
||||
|
||||
def setup_func():
|
||||
pubnub_pam.grant(channel=channel_pam, read=True, write=True, ttl=144000)
|
||||
|
||||
for i in range(0, 20):
|
||||
msg = rand("message-" + str(i))
|
||||
messages.append(msg)
|
||||
print(pubnub.publish(channel=channel, message=msg))
|
||||
# Fails with Python 3
|
||||
# print(pubnub_enc.publish(channel=channel_enc, message=msg))
|
||||
print(pubnub_pam.publish(channel=channel_pam, message=msg))
|
||||
|
||||
|
||||
@with_setup(setup_func)
|
||||
def test_1():
|
||||
time.sleep(3)
|
||||
hresp = pubnub.history(channel=channel, count=20)
|
||||
# Fails with Python 3
|
||||
# hresp2 = pubnub_enc.history(channel=channel_enc, count=20)
|
||||
hresp3 = pubnub_pam.history(channel=channel_pam, count=20)
|
||||
hresp4 = pubnub_pam.history(channel=channel_pam + "no_rw", count=20)
|
||||
assert hresp[0] == messages
|
||||
# Fails with Python 3
|
||||
# assert hresp2[0] == messages
|
||||
assert hresp3[0] == messages
|
||||
assert hresp4['message'] == 'Forbidden'
|
||||
assert channel_pam + "no_rw" in hresp4['payload']['channels']
|
||||
|
||||
|
||||
def test_2():
|
||||
time.sleep(3)
|
||||
hresp = pubnub.history(channel=channel, count=20, include_token=True)
|
||||
# Fails with Python 3
|
||||
# hresp2 = pubnub_enc.history(channel=channel_enc, count=20, include_token=True)
|
||||
hresp3 = pubnub_pam.history(channel=channel_pam, count=20, include_token=True)
|
||||
hresp4 = pubnub_pam.history(channel=channel_pam + "no_rw", count=20, include_token=True)
|
||||
assert len(hresp[0]) == len(messages)
|
||||
assert hresp[0][0]['timetoken']
|
||||
# Fails with Python 3
|
||||
# assert len(hresp2[0]) == len(messages)
|
||||
# assert hresp2[0][0]['timetoken']
|
||||
assert len(hresp3[0]) == len(messages)
|
||||
assert hresp3[0][0]['timetoken']
|
||||
assert hresp4['message'] == 'Forbidden'
|
||||
assert channel_pam + "no_rw" in hresp4['payload']['channels']
|
||||
|
|
@ -0,0 +1,360 @@
|
|||
# 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/
|
||||
|
||||
|
||||
import time
|
||||
import random
|
||||
from pubnub import Pubnub
|
||||
from inspect import currentframe, getouterframes
|
||||
from gevent import monkey
|
||||
|
||||
monkey.patch_all()
|
||||
|
||||
|
||||
def get_line():
|
||||
# print getouterframes(currentframe())[3]
|
||||
return getouterframes(currentframe())[2][2]
|
||||
|
||||
|
||||
DELAY = 5
|
||||
|
||||
RESULTS = {}
|
||||
|
||||
|
||||
def check_tests():
|
||||
for i in RESULTS:
|
||||
test = RESULTS[i]
|
||||
if test['done'] is False:
|
||||
if test['expect'] == test['passed']:
|
||||
green(i + " PASSED " + str(test['passed']))
|
||||
else:
|
||||
red(i + " FAILED " + str(test['failed']))
|
||||
test['done'] = True
|
||||
|
||||
|
||||
def init(conf, name, expect):
|
||||
# check_tests()
|
||||
print("\n\n")
|
||||
RESULTS[name + conf] = {'passed': 0, 'failed': 0, 'expect': 0, 'done': False, 'conf': conf}
|
||||
RESULTS[name + conf]['expect'] = expect
|
||||
|
||||
|
||||
def get_random():
|
||||
return str(random.randint(1, 99999))
|
||||
|
||||
|
||||
def red(name):
|
||||
print('\033[1;31m' + name + '\033[1;m')
|
||||
|
||||
|
||||
def green(name):
|
||||
print('\033[1;92m' + name + '\033[1;m')
|
||||
|
||||
|
||||
def test(cond, desc=None, test_name=None, conf=None):
|
||||
if (cond):
|
||||
green("[" + test_name + " " + str(conf) + " ""][" + str(get_line()) + "] PASS : " + str(desc))
|
||||
RESULTS[test_name + conf]['passed'] = RESULTS[test_name + str(conf)]['passed'] + 1
|
||||
else:
|
||||
red("[" + test_name + " " + str(conf) + " ""][" + str(get_line()) + "] FAIL : " + str(desc))
|
||||
RESULTS[test_name + conf]['failed'] = RESULTS[test_name + str(conf)]['failed'] + 1
|
||||
# exit(0)
|
||||
|
||||
|
||||
def run_tests(tests):
|
||||
for test in tests:
|
||||
if len(test) > 4:
|
||||
test[1](test[2], test[3], test[0], test[4])
|
||||
else:
|
||||
test[1](test[2], test[3], test[0])
|
||||
time.sleep(DELAY)
|
||||
check_tests()
|
||||
|
||||
|
||||
def test_1(pubnub, pubnub2, conf=None, msg=None):
|
||||
init(conf, "test_1", 6)
|
||||
r = get_random()
|
||||
channel_wc = r + "-" + "test_1-ab.*"
|
||||
message = msg if msg is not None else (r + "-" + "test_1_hi")
|
||||
channel = r + "-" + "test_1-ab.d"
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message1, channel1, real_channel=None):
|
||||
# print(str(message1) + ' : ' + str(channel1) + ' : ' + str(real_channel))
|
||||
test(message1 == str(message, 'utf-8'), "message received", "test_1", conf)
|
||||
test(channel1 == channel_wc, "Channel == wildcard channel", "test_1", conf)
|
||||
test(real_channel == channel, "Real channel == publish channel", "test_1", conf)
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
def connect(channel1=None):
|
||||
test(True, "Connect Called", "test_1", conf)
|
||||
test(channel1 == channel_wc, "Channel param in Connect same as wildcard", "test_1", conf)
|
||||
|
||||
def _callback(message):
|
||||
test(message[0] == 1, "Publish Successful", "test_1", conf)
|
||||
|
||||
def _error(message):
|
||||
test(False, "Publish Successful", "test_1", conf)
|
||||
|
||||
pubnub.publish(channel=channel, message=message, callback=_callback, error=_error)
|
||||
|
||||
pubnub.subscribe(channels=channel_wc, callback=callback, error=callback, connect=connect)
|
||||
|
||||
|
||||
def test_2(pubnub, pubnub2, conf=None, msg=None):
|
||||
init(conf, "test_2", 8)
|
||||
r = get_random()
|
||||
channel_wc = r + "-" + "test_2-ab.*"
|
||||
message = msg if msg is not None else (r + "-" + "test_2_hi")
|
||||
channel = r + "-" + "test_2-ab.d"
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message1, channel1, real_channel=None):
|
||||
# print(str(message1) + ' : ' + str(channel1) + ' : ' + str(real_channel))
|
||||
test(message1 == str(message, 'utf-8'), "message received", "test_2", conf)
|
||||
test(channel1 == channel_wc, "Channel == wildcard channel", "test_2", conf)
|
||||
test(real_channel == channel, "Real channel == publish channel", "test_2", conf)
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
def presence(message, channel1, real_channel=None):
|
||||
if (pubnub.uuid == message['uuid']):
|
||||
test(channel_wc == real_channel, "On pubnub subscribe presence event as wildcard as real channel", "test_2",
|
||||
conf)
|
||||
elif (pubnub2.uuid == message['uuid']):
|
||||
test(channel == real_channel, "On pubnub2 subscribe presence event as channel as real channel", "test_2",
|
||||
conf)
|
||||
else:
|
||||
test(False, "Wrong presence event", "test_2", conf)
|
||||
|
||||
def connect(channel1=None):
|
||||
# print(channel1)
|
||||
test(True, "Connect Called", "test_2", conf)
|
||||
test(channel1 == channel_wc, "Channel param in Connect same as wildcard", "test_2", conf)
|
||||
|
||||
def _callback(message):
|
||||
test(message[0] == 1, "Publish Successful", "test_2", conf)
|
||||
|
||||
def _error(message):
|
||||
test(False, "Publish Successful", "test_2", conf)
|
||||
|
||||
pubnub.publish(channel=channel, message=message, callback=_callback, error=_error)
|
||||
|
||||
def _callback(message, channel1):
|
||||
pass
|
||||
|
||||
def _error(message):
|
||||
test(False, "Error in subscribe", "test_2", conf)
|
||||
|
||||
pubnub2.subscribe(channels=channel, callback=_callback, error=_error)
|
||||
|
||||
pubnub.subscribe(channels=channel_wc, callback=callback, error=callback, connect=connect, presence=presence)
|
||||
|
||||
|
||||
def test_3(pubnub, pubnub2, conf=None, msg=None):
|
||||
init(conf, "test_3", 6)
|
||||
|
||||
r = get_random()
|
||||
channel_wc = r + "-" + "test_3-ab.*"
|
||||
message = msg if msg is not None else (r + "-" + "test_3_hi")
|
||||
channel = r + "-" + "test_3-ab.d"
|
||||
|
||||
# Asynchronous usage
|
||||
def callback(message1, channel1, real_channel=None):
|
||||
if 'action' in message1:
|
||||
test(False, "Presence event received without presence callback", "test_3", conf)
|
||||
return
|
||||
|
||||
test(message1 == str(message, 'utf-8'), "message received", "test_3", conf)
|
||||
test(channel1 == channel_wc, "Channel == wildcard channel", "test_3", conf)
|
||||
test(real_channel == channel, "Real channel == publish channel", "test_3", conf)
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
def connect(channel1=None):
|
||||
# print(channel1)
|
||||
test(True, "Connect Called", "test_3", conf)
|
||||
test(channel1 == channel_wc, "Channel param in Connect same as wildcard", "test_3", conf)
|
||||
|
||||
def _callback(message):
|
||||
test(message[0] == 1, "Publish Successful", "test_3", conf)
|
||||
|
||||
def _error(message):
|
||||
test(False, "Publish Successful", "test_3", conf)
|
||||
|
||||
pubnub.publish(channel=channel, message=message, callback=_callback, error=_error)
|
||||
|
||||
def _callback(message, channel1):
|
||||
pass
|
||||
|
||||
def _error(message):
|
||||
test(False, "Error in subscribe", "test_3", conf)
|
||||
|
||||
pubnub2.subscribe(channels=channel, callback=_callback, error=_error)
|
||||
|
||||
pubnub.subscribe(channels=channel_wc, callback=callback, error=callback, connect=connect)
|
||||
|
||||
|
||||
def test_4(pubnub, pubnub2, conf=None, msg=None):
|
||||
init(conf, "test_4", 18)
|
||||
|
||||
r = get_random()
|
||||
channel_wc = r + "-" + "test_4-ab.*"
|
||||
channel_group = r + "-" + "test_4_group"
|
||||
channel_g = r + "-" + "test_4_group_channel"
|
||||
message = msg if msg is not None else (r + "-" + "test_4_hi")
|
||||
channel = r + "-" + "test_4-ab.d"
|
||||
channel_n = r + "-" + "test_4-a"
|
||||
|
||||
def _callback(resp):
|
||||
# Asynchronous usage
|
||||
def callback_wc(message1, channel1, real_channel=None):
|
||||
test(message1 == str(message, 'utf-8'), "message received", "test_4", conf)
|
||||
test(channel1 == channel_wc, "Channel == wildcard channel", "test_4", conf)
|
||||
test(real_channel == channel, "Real channel == publish channel", "test_4", conf)
|
||||
|
||||
def callback_group(message1, channel1, real_channel=None):
|
||||
test(message1 == str(message, 'utf-8'), "message received", "test_4", conf)
|
||||
test(channel1 == channel_group, "Channel == group", "test_4", conf)
|
||||
test(real_channel == channel_g, "Real channel == publish channel", "test_4", conf)
|
||||
|
||||
def callback_n(message1, channel1, real_channel=None):
|
||||
test(message1 == str(message, 'utf-8'), "message received", "test_4", conf)
|
||||
test(channel1 == channel_n, "Channel == channel", "test_4", conf)
|
||||
test(real_channel == channel_n, "Real channel == publish channel", "test_4", conf)
|
||||
|
||||
def error(message):
|
||||
print("ERROR : " + str(message))
|
||||
|
||||
def connect_wc(channel1=None):
|
||||
test(True, "Connect Called", "test_4", conf)
|
||||
test(channel1 == channel_wc, "Channel param in Connect same as wildcard", "test_4", conf)
|
||||
|
||||
def _callback(message):
|
||||
test(message[0] == 1, "Publish Successful", "test_4", conf)
|
||||
|
||||
def _error(message):
|
||||
test(False, "Publish Successful", "test_4", conf)
|
||||
|
||||
pubnub.publish(channel=channel, message=message, callback=_callback, error=_error)
|
||||
|
||||
def connect_group(channel1=None):
|
||||
# print(channel1)
|
||||
test(True, "Connect Called", "test_4", conf)
|
||||
test(channel1 == channel_group, "Channel param in Connect same as channel_group", "test_4", conf)
|
||||
|
||||
def _callback(message):
|
||||
test(message[0] == 1, "Publish Successful", "test_4", conf)
|
||||
|
||||
def _error(message):
|
||||
test(False, "Publish Successful", "test_4", conf)
|
||||
|
||||
pubnub.publish(channel=channel_g, message=message, callback=_callback, error=_error)
|
||||
|
||||
def connect_n(channel1=None):
|
||||
# print(channel1)
|
||||
test(True, "Connect Called", "test_4", conf)
|
||||
test(channel1 == channel_n, "Channel param in Connect same as channel_n", "test_4", conf)
|
||||
|
||||
def _callback(message):
|
||||
test(message[0] == 1, "Publish Successful", "test_4", conf)
|
||||
|
||||
def _error(message):
|
||||
test(False, "Publish Successful", "test_4", conf)
|
||||
|
||||
pubnub.publish(channel=channel_n, message=message, callback=_callback, error=_error)
|
||||
|
||||
pubnub.subscribe(channels=channel_wc, callback=callback_wc, error=error, connect=connect_wc)
|
||||
|
||||
pubnub.subscribe(channels=channel_n, callback=callback_n, error=error, connect=connect_n)
|
||||
|
||||
pubnub.subscribe_group(channel_groups=[channel_group], callback=callback_group, error=error,
|
||||
connect=connect_group)
|
||||
|
||||
def _error(message):
|
||||
test(False, "Channel Group Creation failed")
|
||||
|
||||
pubnub.channel_group_add_channel(channel_group=channel_group, channel=channel_g, callback=_callback, error=_error)
|
||||
|
||||
|
||||
pubnub = Pubnub(publish_key="ds", subscribe_key="ds",
|
||||
secret_key="ds", ssl_on=False)
|
||||
|
||||
pubnub2 = Pubnub(publish_key="ds", subscribe_key="ds",
|
||||
secret_key="ds", ssl_on=False)
|
||||
|
||||
pubnub_ssl = Pubnub(publish_key="ds", subscribe_key="ds",
|
||||
secret_key="ds", ssl_on=True)
|
||||
|
||||
pubnub_ssl_2 = Pubnub(publish_key="ds", subscribe_key="ds",
|
||||
secret_key="ds", ssl_on=True)
|
||||
|
||||
pubnub_enc = Pubnub(publish_key="ds", subscribe_key="ds",
|
||||
secret_key="ds", cipher_key="enigma", ssl_on=False)
|
||||
|
||||
pubnub_enc_2 = Pubnub(publish_key="ds", subscribe_key="ds",
|
||||
secret_key="ds", cipher_key="enigma", ssl_on=False, daemon=False)
|
||||
|
||||
pubnub_enc_ssl = Pubnub(publish_key="ds", subscribe_key="ds",
|
||||
secret_key="ds", cipher_key="enigma", ssl_on=False)
|
||||
|
||||
pubnub_enc_ssl_2 = Pubnub(publish_key="ds", subscribe_key="ds",
|
||||
secret_key="ds", cipher_key="enigma", ssl_on=False, daemon=False)
|
||||
|
||||
# run_tests([ ("[EMOJI][ENC]", test_4, pubnub_enc, pubnub_enc_2, "😀")])
|
||||
|
||||
|
||||
run_tests([
|
||||
("", test_1, pubnub, pubnub2),
|
||||
("[SSL]", test_1, pubnub_ssl, pubnub_ssl_2),
|
||||
("[ENC]", test_1, pubnub_enc, pubnub_enc_2),
|
||||
("[SSL][ENC]", test_1, pubnub_enc_ssl, pubnub_enc_ssl_2),
|
||||
("", test_2, pubnub, pubnub2),
|
||||
("[SSL]", test_2, pubnub_ssl, pubnub_ssl_2),
|
||||
("[ENC]", test_2, pubnub_enc, pubnub_enc_2),
|
||||
("[SSL][ENC]", test_2, pubnub_enc_ssl, pubnub_enc_ssl_2),
|
||||
("", test_3, pubnub, pubnub2),
|
||||
("[SSL]", test_3, pubnub_ssl, pubnub_ssl_2),
|
||||
("[ENC]", test_3, pubnub_enc, pubnub_enc_2),
|
||||
("[SSL][ENC]", test_3, pubnub_enc_ssl, pubnub_enc_ssl_2),
|
||||
("", test_3, pubnub, pubnub2),
|
||||
("[SSL]", test_3, pubnub_ssl, pubnub_ssl_2),
|
||||
("[ENC]", test_3, pubnub_enc, pubnub_enc_2),
|
||||
("[SSL][ENC]", test_3, pubnub_enc_ssl, pubnub_enc_ssl_2),
|
||||
("", test_4, pubnub, pubnub2),
|
||||
("[SSL]", test_4, pubnub_ssl, pubnub_ssl_2),
|
||||
("[ENC]", test_4, pubnub_enc, pubnub_enc_2),
|
||||
("[SSL][ENC]", test_4, pubnub_enc_ssl, pubnub_enc_ssl_2),
|
||||
("[EMOJI]", test_1, pubnub, pubnub2, "😀"),
|
||||
("[SSL][EMOJI]", test_1, pubnub_ssl, pubnub_ssl_2, "😀"),
|
||||
("[ENC][EMOJI]", test_1, pubnub_enc, pubnub_enc_2, "😀"),
|
||||
("[SSL][ENC][EMOJI]", test_1, pubnub_enc_ssl, pubnub_enc_ssl_2, "😀"),
|
||||
("[EMOJI]", test_2, pubnub, pubnub2, "😀"),
|
||||
("[SSL][EMOJI]", test_2, pubnub_ssl, pubnub_ssl_2, "😀"),
|
||||
("[ENC][EMOJI]", test_2, pubnub_enc, pubnub_enc_2, "😀"),
|
||||
("[SSL][ENC][EMOJI]", test_2, pubnub_enc_ssl, pubnub_enc_ssl_2, "😀"),
|
||||
("[EMOJI]", test_3, pubnub, pubnub2, "😀"),
|
||||
("[SSL][EMOJI]", test_3, pubnub_ssl, pubnub_ssl_2, "😀"),
|
||||
("[ENC][EMOJI]", test_3, pubnub_enc, pubnub_enc_2, "😀"),
|
||||
("[SSL][ENC][EMOJI]", test_3, pubnub_enc_ssl, pubnub_enc_ssl_2, "😀"),
|
||||
("[EMOJI]", test_3, pubnub, pubnub2, "😀"),
|
||||
("[SSL][EMOJI]", test_3, pubnub_ssl, pubnub_ssl_2, "😀"),
|
||||
("[ENC][EMOJI]", test_3, pubnub_enc, pubnub_enc_2, "😀"),
|
||||
("[SSL][ENC][EMOJI]", test_3, pubnub_enc_ssl, pubnub_enc_ssl_2, "😀"),
|
||||
("[EMOJI]", test_3, pubnub, pubnub2, "😀"),
|
||||
("[SSL][EMOJI]", test_3, pubnub_ssl, pubnub_ssl_2, "😀"),
|
||||
("[ENC][EMOJI]", test_3, pubnub_enc, pubnub_enc_2, "😀"),
|
||||
("[SSL][ENC][EMOJI]", test_3, pubnub_enc_ssl, pubnub_enc_ssl_2, "😀"),
|
||||
("[EMOJI]", test_4, pubnub, pubnub2, "😀"),
|
||||
("[SSL][EMOJI]", test_4, pubnub_ssl, pubnub_ssl_2, "😀"),
|
||||
("[ENC][EMOJI]", test_4, pubnub_enc, pubnub_enc_2, "😀"),
|
||||
("[SSL][ENC][EMOJI]", test_4, pubnub_enc_ssl, pubnub_enc_ssl_2, "😀")
|
||||
])
|
||||
Loading…
Reference in New Issue