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)
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 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)