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 sendMessage(self, msg, binary):
global thismsg
global thisbinary
thismsg = msg
thisbinary = binary
logging.debug("Sending WS message...")
self.factory = WebSocketClientFactory("ws://%s:%s" %
(self.host, str(self.port)))
self.factory.protocol = EchoClientProtocol
connectWS(self.factory)
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 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()
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()
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()
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 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()
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()
def connectGephi(self):
wsClientFactory = WebSocketClientFactory(GEPHI_SERVER_URL)
wsClientFactory.protocol = GephiClientProtocol
wsClientFactory.broker = self
connectWS(wsClientFactory)
from twisted.internet import reactor
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()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
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://localhost:9000', debug=True)
factory.protocol = EchoClientProtocol
connectWS(factory)
reactor.run()
self.sendMessage("Hello, world!")
def onOpen(self):
self.sendHello()
def onMessage(self, msg, binary):
print "Got echo: " + msg
reactor.callLater(1, self.sendHello)
def onClose(self, wasClean, code, reason):
print "Connection closed."
print "wasClean", wasClean
print "code", code
print "reason", reason
reactor.stop()
if __name__ == '__main__':
debug = True
log.startLogging(sys.stdout)
factory = WebSocketClientFactory("ws://127.0.0.1:9000/wsecho",
origin="example.com",
protocols=["foo", "bar"],
debug=debug)
factory.protocol = EchoClientProtocol
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()
def onSessionOpen(self):
print "connected to WAMP server"
factory = WebSocketClientFactory(GEPHI_SERVER_URL)
factory.protocol = GephiClientProtocol
factory.forwarder = self
connectWS(factory)
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)
def runEverySecond():
print "A second has passed"
if __name__ == '__main__':
l = task.LoopingCall(runEverySecond)
l.start(1.0) # call every second
factory = WebSocketClientFactory("ws://192.168.0.15:9000", debug=False)
factory.protocol = EchoClientProtocol
connectWS(factory)
reactor.run()
self.sendHello()
def onMessage(self, msg, binary):
print "Got echo: " + msg
if msg == self.msg:
print("It works!")
else:
print("Wrong message!")
reactor.stop()
if __name__ == "__main__":
if len(sys.argv) < 2:
print "Need the WebSocket server address, i.e. ws://localhost:8081/echo/websocket"
sys.exit(1)
debug = False
if debug:
log.startLogging(sys.stdout)
print "Using Twisted reactor class %s" % str(reactor.__class__)
url = sys.argv[1]
factory = WebSocketClientFactory(url, debug = debug, debugCodePaths = debug)
factory.setProtocolOptions(version = 13)
factory.protocol = EchoClientProtocol
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()
def onOpen(self):
self.sendHello()
def onMessage(self, msg, binary):
print "Got echo: " + msg
reactor.callLater(1, self.sendHello)
if __name__ == '__main__':
log.startLogging(sys.stdout)
parser = OptionParser()
parser.add_option("-u", "--url", dest = "url", help = "The WebSocket URL", default = "wss://localhost:9000")
(options, args) = parser.parse_args()
## create a WS server factory with our protocol
##
factory = WebSocketClientFactory(options.url, debug = False)
factory.protocol = EchoClientProtocol
## SSL client context: default
##
if factory.isSecure:
contextFactory = ssl.ClientContextFactory()
else:
contextFactory = None
connectWS(factory, contextFactory)
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)
