def main():
parser = create_parser()
args = parser.parse_args()
if args.debug or (not args.logfile and not args.db):
print 'debug logging to console'
log.addObserver(log.FileLogObserver(sys.stdout).emit)
if not args.logfile and args.db:
con = sqlite3.connect(args.db)
try:
# checking if db exists
con.execute('select count(*) from revisions')
except sqlite3.OperationalError:
print 'creating db ' + args.db
create_db(args.db)
con = sqlite3.connect(args.db)
print 'logging to ' + args.db
log.addObserver(partial(db_observer, connection=con))
if isinstance(args.logfile, basestring):
log_file = open(args.logfile, 'a')
print 'logging to ' + str(log_file)
log.startLogging(log_file)
factory = WebSocketClientFactory(args.websocket)
factory.protocol = RecordClientProtocol
connectWS(factory)
reactor.run()
def main(argv=None):
"""Main routine of script"""
if argv is None:
argv = sys.argv
try:
# parse options and args
opts, args = getopt.getopt(argv[1:], "", ["help","node=","capability="])
print "Node/Capability WebSocket consumer."
for k,v in opts:
if k == "--help":
print "A simple python script for consuming readings for a specific Node/Capability pair.\nHit CTRL-C to stop script at any time.\nMust provide all of the parameters listed bellow :"
print "\t --node={node's URN}, define the node."
print "\t --capability={zone's ID}, define the node's zone."
elif k == "--node":
node = v
elif k == "--capability":
capability = v
if(not( vars().has_key("node") and vars().has_key("capability"))):
print >>sys.stderr, "You must specify --node and --capability"
return -1
# initialize WebSocketClientFactory object and make connection
PROTOCOL = [''.join([str(node),'@',str(capability)])]
factory = WebSocketClientFactory(WS_URL,None,PROTOCOL)
factory.protocol = NodeCapabilityConsumerProtocol
factory.setProtocolOptions(13)
connectWS(factory)
reactor.run()
except getopt.error, msg:
print >>sys.stderr, msg
print >>sys.stderr, "for help use -h or --help"
return -1
def playout_reload_schedule(host, port):
print ("Connecting to ws://%s:%s" % (host, port))
factory = WebSocketClientFactory("ws://%s:%s" % (host, port))
factory.protocol = SendCommandProtocol
point = TCP4ClientEndpoint(reactor, host, port)
d = point.connect(factory)
d.addErrback(failed)
return d
def playout_reload_schedule(host, port):
print("Connecting to ws://%s:%s" % (host, port))
factory = WebSocketClientFactory("ws://%s:%s" % (host, port))
factory.protocol = SendCommandProtocol
point = TCP4ClientEndpoint(reactor, host, port)
d = point.connect(factory)
d.addErrback(failed)
return d
def main(serial_port,
xbmc_uri,
xbmc_un,
xbmc_pw,
saged_uri=None,
toilet_ga=None):
print 'main(%r, %r, %r, %r, %r, %r)' % (serial_port, xbmc_uri, xbmc_un,
xbmc_pw, saged_uri, toilet_ga)
if not isinstance(serial_port, CPower1200):
s = CPower1200(serial_port)
s.send_window(
dict(x=0, y=0, h=8, w=32), # window 0: top left: time
dict(x=32, y=0, h=8, w=32), # window 1: top right: date
dict(x=0, y=8, h=8, w=64) # window 2: bottom: nowplaying
)
s.send_clock(0,
calendar=CALENDAR_GREGORIAN,
multiline=False,
display_year=False,
display_hour=False,
display_minute=False,
display_second=False)
s.send_clock(1,
calendar=CALENDAR_GREGORIAN,
multiline=False,
display_year=False,
display_month=False,
display_day=False,
display_second=False)
else:
s = serial_port
if saged_uri != None:
factory = WebSocketClientFactory(saged_uri, debug=True)
factory.protocol = SagedClientProtocol
factory.protocol.toilet_ga = toilet_ga # unicode(toilet_ga)
factory.protocol.sign = s
#factory.setProtocolOptions(allowHixie76=True)
#reactor.callLater(1, main, s, xbmc_uri, xbmc_un, xbmc_pw)
connectWS(factory)
#reactor.run()
if xbmc_un != None and xbmc_pw != None:
auth = (xbmc_un, xbmc_pw)
else:
auth = None
last_playing = False
if saged_uri == None:
while 1:
loop()
else:
reactor.callInThread(loop, xbmc_uri, auth, s, last_playing, True)
reactor.run()
def string_tester_server():
rospy.init_node('stringTesterNode')
factory = WebSocketClientFactory("ws://54.216.152.74:9000", debug = False)
factory.protocol = TestCenter
connectWS(factory)
def terminate():
reactor.callFromThread(reactor.stop)
rospy.on_shutdown(terminate)
reactor.run(installSignalHandlers=False)
def main(serial_port, xbmc_uri, xbmc_un, xbmc_pw, saged_uri=None, toilet_ga=None):
print "main(%r, %r, %r, %r, %r, %r)" % (serial_port, xbmc_uri, xbmc_un, xbmc_pw, saged_uri, toilet_ga)
if not isinstance(serial_port, CPower1200):
s = CPower1200(serial_port)
s.send_window(
dict(x=0, y=0, h=8, w=32), # window 0: top left: time
dict(x=32, y=0, h=8, w=32), # window 1: top right: date
dict(x=0, y=8, h=8, w=64), # window 2: bottom: nowplaying
)
s.send_clock(
0,
calendar=CALENDAR_GREGORIAN,
multiline=False,
display_year=False,
display_hour=False,
display_minute=False,
display_second=False,
)
s.send_clock(
1,
calendar=CALENDAR_GREGORIAN,
multiline=False,
display_year=False,
display_month=False,
display_day=False,
display_second=False,
)
else:
s = serial_port
if saged_uri != None:
factory = WebSocketClientFactory(saged_uri, debug=True)
factory.protocol = SagedClientProtocol
factory.protocol.toilet_ga = toilet_ga # unicode(toilet_ga)
factory.protocol.sign = s
# factory.setProtocolOptions(allowHixie76=True)
# reactor.callLater(1, main, s, xbmc_uri, xbmc_un, xbmc_pw)
connectWS(factory)
# reactor.run()
if xbmc_un != None and xbmc_pw != None:
auth = (xbmc_un, xbmc_pw)
else:
auth = None
last_playing = False
if saged_uri == None:
while 1:
loop()
else:
reactor.callInThread(loop, xbmc_uri, auth, s, last_playing, True)
reactor.run()
def score(self,ip,flag,cookie):
try:
factory = WebSocketClientFactory("ws://"+ip+":"+str(self.port)+"/stash",debug=True)
factory.flag = flag
factory.connections = []
factory.observer = self.flagObserver
factory.protocol = FlagClientProtocol
connectWS(factory)
reactor.run()
sys.exit(0)
except Exception as e:
print "exception",e
sys.exit(1)
def setUp(self):
self._server = Server()
port = self._server.start()
address = "ws://localhost:%d" % port
factory = WebSocketClientFactory(address)
factory.protocol = Protocol
factory.setProtocolOptions(openHandshakeTimeout=0)
self._connector = connectWS(factory)
self._client_factory = factory
def connect(self, username, password):
self.login_auth(username, password)
ws = WebSocketClientFactory(
self.settings['aps']['ws'][0],
useragent='rick astley',
debug=True,
debugCodePaths=True)
SpotifyClientProtocol.sp_settings = self.settings
SpotifyClientProtocol.login_callback = self.login_callback
ws.protocol = SpotifyClientProtocol
connectWS(ws)
reactor.run()
def main():
parser = create_parser()
args = parser.parse_args()
if args.debug or not args.logfile:
print 'debug logging to console'
log.addObserver(log.FileLogObserver(sys.stdout).emit)
if isinstance(args.logfile, basestring):
log_file = open(args.logfile, 'a')
print 'logging to ' + str(log_file)
log.startLogging(log_file)
ws_factory = WebSocketClientFactory(args.websocket)
ws_factory.protocol = RecordClientProtocol
connectWS(ws_factory)
wsgi_resource = WSGIResource(reactor, reactor.getThreadPool(), app)
site = Site(wsgi_resource)
web_service = internet.TCPServer(5000, site)
application = service.Application('BarnTown')
web_service.setServiceParent(application)
reactor.listenTCP(5000, site)
reactor.run()
def __init__(self, server, port, account, character, ticket, **kwargs):
self.account = unicode(account)
self.character = unicode(character)
self.ticket = unicode(ticket)
self.caching = kwargs.get('caching', True)
self.on_close = kwargs.get('connection_lost', lambda: None)
self.on_open = kwargs.get('connection_open', lambda: None)
self.callbacks = {}
self.handlers = []
self.client = None
self.pinger = None
class WebsocketClient(WebSocketClientProtocol):
def onOpen(cl_self):
logger.debug("Ready to introduce ourselves.!")
self.client = cl_self
self._introduce()
self.pinger = task.LoopingCall(lambda: cl_self.sendMessage(opcode.PING))
self.pinger.start(45, False)
self.on_open()
def connectionLost(cl_self, reason):
logger.debug("Connection closed with reason {reason}".format(reason=reason))
self.client = None
if self.pinger:
self.pinger.stop()
self.on_close()
WebSocketClientProtocol.connectionLost(cl_self, reason)
def onMessage(cl_self, message, binary):
if self.pinger:
self.pinger.stop()
self.pinger.start(45, False)
self.on_message(cl_self, message)
factory = WebSocketClientFactory("ws://{server}:{port}".format(server=server, port=port), debug=False)
factory.protocol = WebsocketClient
self.factory = factory
def main(argv):
try:
opts, args = getopt.getopt(argv, 'hw:o:',
['help', 'ws=', 'operation='])
except getopt.GetoptError:
usage()
ws = 'ws://localhost:9000'
op = 'p'
for opt, val in opts:
if opt in ('-h', '--help'):
usage()
elif opt in ('-o', '--operation'):
op = val
elif opt in ('-w', '--ws'):
ws = val
factory = WebSocketClientFactory(ws, debug=True)
factory.protocol = CountClientProtocol
connectWS(factory)
reactor.run()
"""
def sendOneBatch(self):
data = randomByteString(BATCH_SIZE)
# Note, that this could complete the frame, when the frame length is
# reached. Since the frame length here is 2^63, we don't bother, since
# it'll take _very_ long to reach that.
self.sendMessageFrameData(data)
def onOpen(self):
self.count = 0
self.beginMessage(opcode = WebSocketProtocol.MESSAGE_TYPE_BINARY)
# 2^63 - This is the maximum imposed by the WS protocol
self.beginMessageFrame(0x7FFFFFFFFFFFFFFF)
self.sendOneBatch()
def onMessage(self, message, binary):
print "Digest for batch %d computed by server: %s" \
% (self.count, message)
self.count += 1
self.sendOneBatch()
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://localhost:9000")
factory.protocol = StreamingHashClientProtocol
connectWS(factory)
reactor.run()
def connectGephi(self):
wsClientFactory = WebSocketClientFactory(GEPHI_SERVER_URL)
wsClientFactory.protocol = GephiClientProtocol
wsClientFactory.broker = self
connectWS(wsClientFactory)
self.sendOneFrame()
elif not self.finished:
self.endMessage()
self.finished = True
if self.count >= FRAME_COUNT:
self.sendClose()
def onClose(self, wasClean, code, reason):
reactor.stop()
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://localhost:9000")
factory.protocol = FrameBasedHashClientProtocol
enableCompression = True
if enableCompression:
from autobahn.compress import PerMessageDeflateOffer, \
PerMessageDeflateResponse, \
PerMessageDeflateResponseAccept
## The extensions offered to the server ..
offers = [PerMessageDeflateOffer()]
factory.setProtocolOptions(perMessageCompressionOffers=offers)
## Function to accept responses from the server ..
def accept(response):
if isinstance(response, PerMessageDeflateResponse):
return PerMessageDeflateResponseAccept(response)
def on_centrifuge_message(self, msg):
global COUNT
COUNT += 1
if COUNT == NUM_CLIENTS * NUM_CLIENTS:
stop = time.time()
print stop - self.start
reactor.stop()
def generate_token(secret_key, project_id, user_id):
sign = hmac.new(six.b(str(secret_key)))
sign.update(six.b(user_id))
sign.update(six.b(str(project_id)))
token = sign.hexdigest()
return token
if __name__ == '__main__':
if len(sys.argv) < 2:
print "Need the WebSocket server address, i.e. ws://localhost:9000"
sys.exit(1)
factory = WebSocketClientFactory(URL)
factory.protocol = ThroughputClientProtocol
for i in range(NUM_CLIENTS):
connectWS(factory)
reactor.run()
# initialize WebSocketClientFactory object and make connection
reconnect()
def reconnect():
while 1:
try:
urllib2.urlopen(http_URL)
except urllib2.HTTPError, e:
if e.code==406:
break
except urllib2.URLError, e:
logging.info("server unavailable")
else:
break
time.sleep(10)
# initialize WebSocketClientFactory object and make connection
PROTOCOL = [''.join(['SUB@',str(temperaturenode),'@',str(temperaturecapability)])]
factory = WebSocketClientFactory(WS_URL,None,PROTOCOL)
factory.protocol = NodeCapabilityConsumerProtocol
factory.setProtocolOptions(13)
connectWS(factory)
if (reactor.running):
logging.info("running")
else:
reactor.run()
if __name__ == '__main__':
sys.exit(main())
"""
def sendOneBatch(self):
data = randomByteString(BATCH_SIZE)
# Note, that this could complete the frame, when the frame length is reached.
# Since the frame length here is 2^63, we don't bother, since it'll take
# _very_ long to reach that.
self.sendMessageFrameData(data)
def onOpen(self):
self.count = 0
self.beginMessage(opcode=WebSocketProtocol.MESSAGE_TYPE_BINARY)
self.beginMessageFrame(
0x7FFFFFFFFFFFFFFF
) # 2^63 - This is the maximum imposed by the WS protocol
self.sendOneBatch()
def onMessage(self, message, binary):
print "Digest for batch %d computed by server: %s" % (self.count,
message)
self.count += 1
self.sendOneBatch()
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://localhost:9000")
factory.protocol = StreamingHashClientProtocol
connectWS(factory)
reactor.run()
# data = dict
# event = string
pub.sendMessage(event, msg=data)
# ----------------------------------------------------------------------------
if __name__ == '__main__':
host = 'localhost' #"jpd.es"
port = 8800
address = 'ws://' + host + ':' + str(port)
def pdump(msg):
if("event" in msg.keys()):
print "Event: %s", msg['event']
print msg['user'], ': ', msg['message']
pub.subscribe(pdump, 'message')
factory = WebSocketClientFactory(address, debug = True, debugCodePaths = True)
factory.protocol = ScalableServerProtocol
connectWS(factory)
reactor.run()
'''
from twisted.internet import reactor
from autobahn.websocket import WebSocketClientFactory, \
WebSocketClientProtocol, \
connectWS
import settings.py
import logger.py
class ClientProtocol(WebSocketClientProtocol):
def Register(self):
self.sendMessage("{\"command\":\"register\",\"DID\":" + DID + "\"")
def onOpen(self):
self.sendHello()
def onMessage(self, msg, binary):
print "Got echo: " + msg
reactor.callLater(1, self.sendHello)
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://localhost:9000", debug = DEBUG_COMMS)
factory.protocol = ClientProtocol
connectWS(factory)
reactor.run()
#return (skcoor + sk_res*0.5)/scale
def projekce(self,point, kalib_params, mode):
if mode=='ransac':
import cv2
pt = np.float32([ [point[0],point[1]]]).reshape(-1,1,2)
ip = cv2.perspectiveTransform(pt, kalib_params)
proj_point = ip[0,0]
return proj_point
def changeOfIndex(self,aglob,fileList):
if aglob == 0:
aglob += 1
else:
if aglob >= (len(fileList)-1):
aglob = 0
else:
aglob += 1
return aglob
if __name__ == '__main__':
pygame.init()
factory = WebSocketClientFactory(host, debug = False)
factory.protocol = KinectClientProtocol
connectWS(factory)
reactor.run()
print "konec"
def onSessionOpen(self):
print "connected to WAMP server"
factory = WebSocketClientFactory(GEPHI_SERVER_URL)
factory.protocol = GephiClientProtocol
factory.forwarder = self
connectWS(factory)
def connectGephi(self):
wsClientFactory = WebSocketClientFactory(GEPHI_SERVER_URL)
wsClientFactory.protocol = GephiClientProtocol
wsClientFactory.broker = self
connectWS(wsClientFactory)
class MessageBasedHashClientProtocol(WebSocketClientProtocol):
"""
Message-based WebSockets client that generates stream of random octets
sent to WebSockets server as a sequence of messages. The server will
respond to us with the SHA-256 computed over each message. When
we receive response, we repeat by sending a new message.
"""
def sendOneMessage(self):
data = randomByteString(MESSAGE_SIZE)
self.sendMessage(data, binary = True)
def onOpen(self):
self.count = 0
self.sendOneMessage()
def onMessage(self, message, binary):
print "Digest for message %d computed by server: %s" % (self.count, message)
self.count += 1
self.sendOneMessage()
if __name__ == '__main__':
factory = WebSocketClientFactory()
factory.protocol = MessageBasedHashClientProtocol
reactor.connectTCP("localhost", 9000, factory)
reactor.run()
def generate_message(message, message_text):
response = {
"action": "publish_message",
"data": {
"channel": message["channel"],
"message": message_text,
},
}
return response
def generate_signature(secret, method, path, body, params, exclude_params=["signature"]):
body = "" if body is None else body
signature = secret + method.upper() + path + prepare_query_string(params, exclude_params) + body
return urlsafe_b64encode(hashlib.sha256(signature).digest())[:43]
def prepare_query_string(params, exclude_params):
params = [(key, value) for key, value in params.iteritems() if key not in exclude_params]
params.sort(key=lambda x: x[0])
return "".join("%s=%s" % (key, value) for key, value in params)
if __name__ == '__main__':
expires = int(time.time()) + 300
params = { "api_key": API_KEY, "expires": str(expires) }
params["signature"] = generate_signature(SECRET, "GET", "/eventhub", "", params)
query_string = "&".join(key + "=" + value for key, value in params.iteritems())
factory = WebSocketClientFactory("ws://localhost:5000/eventhub?{0}".format(query_string))
factory.protocol = WebSocketHandler
connectWS(factory)
reactor.run()
self.seen = set()
def onMessage(self, msg, binary):
if binary:
log.warning('Binary message ignored {!r}'.format(msg))
return
jd = json.loads(msg)
jd['data'] = json.loads(jd['data'])
if jd['action'].startswith('1-questions-active'):
qid = do_something(jd)
if qid not in self.seen:
self.sendMessage('1-question-{}'.format(qid))
try:
qinfo = Site('stackoverflow').questions(qid).filter('withbody')[0]._data
qinfo['_id'] = qid
qinfo['datetime_seen'] = datetime.now()
posts.insert(qinfo)
self.seen.add(qid)
except Exception:
pass
else:
do_something_else(jd)
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://sockets.ny.stackexchange.com", debug=False)
factory.protocol = QuestionFeedProtocol
connectWS(factory)
reactor.run()
def on_centrifuge_message(self, msg):
global COUNT
COUNT += 1
if COUNT == NUM_CLIENTS*NUM_CLIENTS:
stop = time.time()
print stop - self.start
reactor.stop()
def generate_token(secret_key, project_id, user_id):
sign = hmac.new(six.b(str(secret_key)))
sign.update(six.b(user_id))
sign.update(six.b(str(project_id)))
token = sign.hexdigest()
return token
if __name__ == '__main__':
if len(sys.argv) < 2:
print "Need the WebSocket server address, i.e. ws://localhost:9000"
sys.exit(1)
factory = WebSocketClientFactory(URL)
factory.protocol = ThroughputClientProtocol
for i in range(NUM_CLIENTS):
connectWS(factory)
reactor.run()
def onSessionOpen(self):
print "connected to WAMP server"
factory = WebSocketClientFactory(GEPHI_SERVER_URL)
factory.protocol = GephiClientProtocol
factory.forwarder = self
connectWS(factory)
def onOpen(self):
self.sendMessage(MSG)
# get response from server
def onMessage(self, msg, binary):
typeMsg = msg[:3]
file_name = msg[4:16]
if typeMsg == '[O]':
message = msg[17:]
file_path = str(".\\read\\"+file_name)
f = open(file_path, 'w')
f.write(message)
f.close()
print "File %s successfully writen at /read/ catalog..." % file_name
elif typeMsg == '[C]':
print "File successfully writen at some DFS catalog..."
reactor.stop()
if __name__ == '__main__':
import sys
if len(sys.argv)<4:
sys.exit("Using client.py [IP] [PORT] [COMMAND]")
ADDRESS = sys.argv[1]
PORT = int(sys.argv[2])
MSG = sys.argv[3]
factory = WebSocketClientFactory("ws://" + ADDRESS + ":" + str(PORT), debug = False)
factory.protocol = DFSClientProtocol
connectWS(factory)
print 'connecting to %s port %s' % (ADDRESS, PORT)
reactor.run()
class MessageBasedHashClientProtocol(WebSocketClientProtocol):
"""
Message-based WebSockets client that generates stream of random octets
sent to WebSockets server as a sequence of messages. The server will
respond to us with the SHA-256 computed over each message. When
we receive response, we repeat by sending a new message.
"""
def sendOneMessage(self):
data = randomByteString(MESSAGE_SIZE)
self.sendMessage(data, binary=True)
def onOpen(self):
self.count = 0
self.sendOneMessage()
def onMessage(self, message, binary):
print "Digest for message %d computed by server: %s" % (self.count,
message)
self.count += 1
self.sendOneMessage()
if __name__ == '__main__':
factory = WebSocketClientFactory()
factory.protocol = MessageBasedHashClientProtocol
reactor.connectTCP("localhost", 9000, factory)
reactor.run()
def start_client():
factory = WebSocketClientFactory('ws://127.0.0.1:9000')
# uncomment to use Hixie-76 protocol
factory.setProtocolOptions(allowHixie76 = True, version = 0)
factory.protocol = EchoClientProtocol
connectWS(factory)
pass
class StreamingProducerHashClientProtocol(WebSocketClientProtocol):
"""
Streaming WebSockets client that generates stream of random octets
sent to streaming WebSockets server, which computes a running SHA-256,
which it will send every BATCH_SIZE octets back to us. This example
uses a Twisted producer to produce the byte stream as fast as the
receiver can consume, but not faster. Therefor, we don't need the
application-level flow control as with the other examples.
"""
def onOpen(self):
self.count = 0
producer = RandomByteStreamProducer(self)
self.registerProducer(producer, True)
producer.resumeProducing()
def onMessage(self, message, binary):
print "Digest for batch %d computed by server: %s" % (self.count, message)
self.count += 1
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://localhost:9000")
factory.protocol = StreamingProducerHashClientProtocol
connectWS(factory)
reactor.run()
class PingClientProtocol(WebSocketClientProtocol):
def onOpen(self):
self.pingsReceived = 0
self.pongsSent = 0
def onClose(self, wasClean, code, reason):
reactor.stop()
def onPing(self, payload):
self.pingsReceived += 1
print self.peerstr, "PING Received", self.pingsReceived
self.sendPong(payload)
self.pongsSent += 1
print self.peerstr, "PONG Sent", self.pongsSent
if __name__ == "__main__":
log.startLogging(sys.stdout)
if len(sys.argv) < 2:
print "Need the WebSocket server address, i.e. ws://localhost:9000"
sys.exit(1)
factory = WebSocketClientFactory(sys.argv[1], debug="debug" in sys.argv)
factory.protocol = PingClientProtocol
connectWS(factory)
reactor.run()
import os
import time
from random import shuffle
from twisted.internet import reactor
from autobahn.websocket import WebSocketClientFactory, WebSocketClientProtocol, connectWS
class FSClient(WebSocketClientProtocol):
# event on new connection with client
def onOpen(self):
self.sendMessage(OPERATION)
# get response from fileserver
def onMessage(self, msg, binary):
print "%s" % msg
reactor.stop()
if __name__ == '__main__':
import sys
if len(sys.argv)<3:
sys.exit("Using fsclient.py [PORT] [COMMAND]")
PORT = int(sys.argv[1])
OPERATION = sys.argv[2]
factory = WebSocketClientFactory("ws://" + ADDRESS + ":" + str(PORT), debug = False)
factory.protocol = FSClient
connectWS(factory)
reactor.run()
class PingClientProtocol(WebSocketClientProtocol):
def onOpen(self):
self.pingsReceived = 0
self.pongsSent = 0
def onClose(self, wasClean, code, reason):
reactor.stop()
def onPing(self, payload):
self.pingsReceived += 1
print self.peerstr, "PING Received", self.pingsReceived
self.sendPong(payload)
self.pongsSent += 1
print self.peerstr, "PONG Sent", self.pongsSent
if __name__ == '__main__':
log.startLogging(sys.stdout)
if len(sys.argv) < 2:
print "Need the WebSocket server address, i.e. ws://localhost:9000"
sys.exit(1)
factory = WebSocketClientFactory(sys.argv[1], debug='debug' in sys.argv)
factory.protocol = PingClientProtocol
connectWS(factory)
reactor.run()
from autobahn.websocket import WebSocketClientFactory, \
WebSocketClientProtocol, \
connectWS
class BroadcastClientProtocol(WebSocketClientProtocol):
"""
Simple client that connects to a WebSocket server, send a HELLO
message every 2 seconds and print everything it receives.
"""
def sendHello(self):
print "Send auth"
self.sendMessage('{"action":"auth","key":"foo"}')
#reactor.callLater(2, self.sendHello)
def onOpen(self):
self.sendHello()
def onMessage(self, msg, binary):
print "onMessage - Send read"
self.sendMessage('{"action":"read","id":"all"}')
if __name__ == '__main__':
#factory = WebSocketClientFactory("ws://localhost:8082")
factory = WebSocketClientFactory("ws://127.0.0.1:8082")
factory.protocol = BroadcastClientProtocol
connectWS(factory)
reactor.run()
class BroadcastClientProtocol(WebSocketClientProtocol):
"""
Simple client that connects to a WebSocket server, send a HELLO
message every 2 seconds and print everything it receives.
"""
def sendHello(self):
self.sendMessage("Hello from Python!")
reactor.callLater(2, self.sendHello)
def onOpen(self):
self.sendHello()
def onMessage(self, msg, binary):
print "Got message: " + msg
if __name__ == '__main__':
if len(sys.argv) < 2:
print "Need the WebSocket server address, i.e. ws://localhost:9000"
sys.exit(1)
factory = WebSocketClientFactory(sys.argv[1])
factory.protocol = BroadcastClientProtocol
connectWS(factory)
reactor.run()
num = random.random()
try:
r = requests.get("http://" + LOX_ADDR + "/jdev/sys/getkey?" + str(num))
pass
except Exception, e:
print "LOX_DEVICE::auth key request failed"
raise
else:
if r.status_code == 200:
protocol = (
hmac.new(r.json()["LL"]["value"].decode("hex"), LOX_USER + ":" + LOX_PASS, digestmod=hashlib.sha1)
.digest()
.encode("hex")
)
factory = WebSocketClientFactory("ws://" + LOX_ADDR + "/ws/", protocols=[protocol], debug=True)
factory.protocol = self.proxy
connectWS(factory)
self.isClosed = False
else:
print "LOX_DEVICE::Failed to Handshake with loxone:HTTP_STATUS_CODE:" + r.status_code
return
self.initialized = True
while not self.isClosed:
print random.choice(["(>'.')>", "<('.'<)", ":)", ":(", "XD", "oo", "||", "u"])
gevent.sleep(1) # don't block event loop
gevent.sleep(1)
print "End: create_socket"
# Put Reconnect code here???
finally:
pass
uses a Twisted producer to produce the byte stream as fast as the
receiver can consume, but not faster. Therefor, we don't need the
application-level flow control as with the other examples.
"""
def onOpen(self):
self.count = 0
self.producer = RandomByteStreamProducer(self)
self.registerProducer(self.producer, True)
self.producer.resumeProducing()
def onMessage(self, message, binary):
print "Digest for batch %d computed by server: %s" % (self.count,
message)
self.count += 1
if self.count >= BATCH_COUNT:
#self.producer.pauseProducing()
#reactor.stop()
#self.sendClose()
sys.exit(0)
def onClose(self, wasClean, code, reason):
reactor.stop()
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://localhost:9000")
factory.protocol = StreamingProducerHashClientProtocol
connectWS(factory)
reactor.run()
from twisted.internet import reactor
from autobahn.websocket import WebSocketClientFactory, \
WebSocketClientProtocol, \
connectWS
class EchoClientProtocol(WebSocketClientProtocol):
def sendHello(self):
self.sendMessage("Hello, world!")
def onOpen(self):
self.sendHello()
def onMessage(self, msg, binary):
print "Got echo: " + msg
reactor.callLater(1, self.sendHello)
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://mozart.kawigi.com:9000", debug = False)
factory.protocol = EchoClientProtocol
connectWS(factory)
reactor.run()
#print 'sending', text
session.post('http://chat.stackoverflow.com/chats/6/messages/new', data={'text': text, 'fkey': fkey})
class ChatFeedProtocol(WebSocketClientProtocol):
def onOpen(self):
log.msg('Connected to chat feed')
self.factory.message_counter = 0
send()
update.start(300, False)
def onMessage(self, msg, binary):
#log.msg(msg)
self.factory.message_counter += 1
if __name__ == '__main__':
log.msg('Attempting to connect to {}'.format(ws_url))
factory = WebSocketClientFactory(
ws_url + '?l=0',
useragent='sopython',
origin='http://chat.stackoverflow.com',
debug=False
)
factory.protocol = ChatFeedProtocol
connectWS(factory)
#reactor.callLater(5, send, 'Started: {!s} - cabbage to all'.format(datetime.now()))
update = task.LoopingCall(send)
reactor.run()
def onOpen(self):
self.sendHello()
def onMessage(self, msg, binary):
print "Got echo: " + msg
reactor.callLater(1, self.sendHello)
if __name__ == '__main__':
if len(sys.argv) < 2:
print "Need the WebSocket server address, i.e. ws://localhost:9000"
sys.exit(1)
if len(sys.argv) > 2 and sys.argv[2] == 'debug':
log.startLogging(sys.stdout)
debug = True
else:
debug = False
factory = WebSocketClientFactory(sys.argv[1],
debug=debug,
debugCodePaths=debug)
# uncomment to use Hixie-76 protocol
#factory.setProtocolOptions(allowHixie76 = True, version = 0)
factory.protocol = EchoClientProtocol
connectWS(factory)
reactor.run()
def start_client():
factory = WebSocketClientFactory('ws://127.0.0.1:9000')
# uncomment to use Hixie-76 protocol
factory.setProtocolOptions(allowHixie76=True, version=0)
factory.protocol = EchoClientProtocol
connectWS(factory)
