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)