Exemplo n.º 1
0
   def run(self):
      self._factories = []
      for i in xrange(self.config.clients):
         factory = LoadLatencySubscriberFactory(self.config)
         connectWS(factory)
         self._factories.append(factory)

      publisherFactory = LoadLatencyPublisherFactory(self.config)
      connectWS(publisherFactory)

      def printstats():
         publishedCnt = publisherFactory.publishedCnt
         receivedCnt = sum([x.receivedCnt for x in self._factories])
         receivedSumRtts = 1000. * sum([sum(x.receivedRtts) for x in self._factories])

         if receivedCnt:
            rttAvg = float(receivedSumRtts) / float(receivedCnt)
         else:
            rttAvg = 0

         publisherFactory.publishedCnt = 0
         for f in self._factories:
            f.receivedCnt = 0
            f.receivedRtts = []

         self.publishedCntTotal += publishedCnt
         self.receivedCntTotal += receivedCnt

         print "%d, %d, %d, %d, %f" % (publishedCnt, receivedCnt, self.publishedCntTotal, self.receivedCntTotal, rttAvg)

         reactor.callLater(1, printstats)

      print "Messages:"
      print "sent_last, recv_last, sent_total, recv_total, rtt"
      printstats()
Exemplo n.º 2
0
    def init_batch(self):
        print "BATCH STARTED"

        self.numReceived = 0
        self.numReceivedPerClient = {}
        if app.iteration == 0:
            # Don't reset data on failed connections between iterations
            # In the future this could be configurable via a flag
            self.connectionsLost = []
            self.connectionsFailed = []

        # Either "ACTIVE" or "DONE"
        self.state = "ACTIVE"
        self.startTime = datetime.now()
        self.check_batchTask = task.LoopingCall(self.check_batch)
        self.check_batchTask.start(1.0)
        self.lastResortCall = reactor.callLater(ARGS.max_runtime, self.terminate_batch)
        self.errors = {}
        if app.iteration == 0:
            self.senders = []

            for i in xrange(ARGS.num_senders):
                sender = SenderClientFactory(self, clientId=i)
                connectWS(sender, timeout=ARGS.websocket_timeout)
                self.senders.append(sender)
        else:
            # Reuse senders between iterations (except for those that failed)
            for sender in self.senders:
                if sender.protocol:
                    sender.protocol.publish_bundle()
Exemplo n.º 3
0
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()
Exemplo n.º 4
0
def test_server(wsuri, wsuri2 = None):

   dealer = Dealer()

   if wsuri2 is None:
      calculator = Calculator()
      dealer.register("http://myapp.com/", calculator)


   broker = Broker()

   class MyPubSubServerProtocol(WampServerProtocol):

      def onSessionOpen(self):
         self.setBroker(broker)
         self.setDealer(dealer)

   wampFactory = WampServerFactory(wsuri)
   wampFactory.protocol = MyPubSubServerProtocol
   listenWS(wampFactory)

   if wsuri2:
      class MyPubSubClientProtocol(WampClientProtocol):

         def onSessionOpen(self):
            self.setBroker(broker)
            self.setDealer(dealer)

      factory = WampClientFactory(wsuri2)
      factory.protocol = MyPubSubClientProtocol
      connectWS(factory)
Exemplo n.º 5
0
 def connect(cls, uri, debug=False):
     global client_factory
     client_factory = ClientFactory(uri)
     client_factory.uri = uri
     client_factory.protocol = cls
     connectWS(client_factory)
     return client_factory
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
Exemplo n.º 7
0
 def clientConnectionFailed(self, connector, reason):
    print "Connection to %s failed (%s)" % (self.spec["servers"][self.currServer]["url"], reason.getErrorMessage())
    if self.nextServer():
       if self.nextCase():
          connectWS(self)
    else:
       self.createReports()
       reactor.stop()
Exemplo n.º 8
0
 def buildProtocol(self, addr):
     proto = ReveilleClientFactory.buildProtocol(self, addr)
     factory = proto.factory_class(self,
         #"ws://192.168.1.2:9876/reveille",
         "ws://127.0.0.1:9876/reveille",
         #debug=debug,
         #debugCodePaths=debug,
     )
     connectWS(factory)
Exemplo n.º 9
0
def test_client(wsuri, dopub):

   dorpc = False

   class MyPubSubClientProtocol(WampClientProtocol):

      def onSessionOpen(self):

         print "Connected!"

         def onMyEvent1(topic, event):
            print "Received event", topic, event

         d = self.subscribe("http://example.com/myEvent1", onMyEvent1)

         def subscribeSuccess(subscriptionid):
            print "Subscribe Success", subscriptionid

         def subscribeError(error):
            print "Subscribe Error", error

         d.addCallbacks(subscribeSuccess, subscribeError)

         self.counter = 0

         def sendMyEvent1():
            self.counter += 1
            self.publish("http://example.com/myEvent1",
               {
                  "msg": "Hello from Python!",
                  "counter": self.counter
               }
            )
            reactor.callLater(2, sendMyEvent1)

         if dopub:
            sendMyEvent1()

         if dorpc:
            def writeln(res):
               print res

            d = self.call("http://myapp.com/add", 23, 7)
            d.addBoth(writeln)

            d = self.call("http://myapp2.com/add", 40, 2)
            d.addBoth(writeln)


      def onClose(self, wasClean, code, reason):
         print "Connection closed", reason
         reactor.stop()

   factory = WampClientFactory(wsuri)
   factory.protocol = MyPubSubClientProtocol
   connectWS(factory)
Exemplo n.º 10
0
 def __init__(self, host=host, save_data=None, loop_time=LOOP_TIME, reactor=reactor): 
     if save_data is None:
         save_data=self.save_data            
     factory = ClientFactory(host, save_data)
     factory.protocol = KinectClient
     connectWS(factory)
     self.reactor=reactor
     self.data = [{'RightHand':{"X":0, "Y":0}, 'RightShoulder':{"X":0, "Y":0}}]
     self.kk = None
     self.kin_parameter = None
Exemplo n.º 11
0
def start_tracker(data_source_id, args):
    twilio_client = twilio.Twilio(args.sid, args.token)

    tracker =  DucksboardTracker(
        data_source_id, twilio_client, args.sid, args.from_, args.to)

    factory = DucksboardWebSocketClientFactory(
        args.api_key, tracker, 'wss://api.ducksboard.com/websocket')
    factory.protocol = DucksboardNotificationProtocol
    connectWS(factory)
Exemplo n.º 12
0
def main(reactor, passes, ip):
    measurement = Measurement(passes)

    d = Deferred()
    d.addCallback(measurement.run)

    factory = ConnectionFactory('ws://{0}:9000'.format(ip), reactor, d)
    connectWS(factory)

    reactor.run()
Exemplo n.º 13
0
 def clientConnectionLost(self, connector, reason):
    if self.nextCase():
       connector.connect()
    else:
       if self.nextServer():
          if self.nextCase():
             connectWS(self)
       else:
          self.createReports()
          reactor.stop()
Exemplo n.º 14
0
def run_admin_command(options):
   """
   Monitor a Crossbar.io server.
   """
   from choosereactor import install_reactor
   reactor = install_reactor(options.reactor, options.verbose)

   factory = CrossbarCLIFactory(options, reactor)
   connectWS(factory)
   reactor.run()
Exemplo n.º 15
0
    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)
Exemplo n.º 16
0
 def start_comm(self):
     """Starts the communication using websockets"""
     from autobahn.websocket import connectWS, WebSocketClientFactory, WebSocketClientProtocol
     
     from KinectPlanes.modules.comm import ClientFactory, ClientProtocol
     
     self.main_window.btn_connect.setEnabled(False)
     self.comm_factory = ClientFactory(self.main_window.edit_add.toPlainText(), self)
     self.comm_factory.protocol = ClientProtocol
     #self.comm_factory.protocol.set_app(self)
     connectWS(self.comm_factory)
Exemplo n.º 17
0
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()
Exemplo n.º 18
0
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)
Exemplo n.º 19
0
   def start(self):
      ## the directory watcher
      ##
      self.watcher = DirWatcher(dir = self.directory)

      ## start directory watcher on _background_ thread
      ##
      reactor.callInThread(self.watcher.loop, self.onDirEvent)

      ## start WAMP client (on main reactor thread)
      ##
      self.client = DirWatchClientFactory(self)
      connectWS(self.client)
Exemplo n.º 20
0
 def initialize_ws(ignored):
     #cookie = "session_key=%s; session_id=%s" % \
     #    (self.session_key, self.session_id)
     cookie = "session_key=%s; session_id=%s" % \
         (self.session_key, self.session_id)
     factory = KatoWebsocketFactory(KATO_API_WS_URL,
             self,
             cookie = cookie,
             debug = self.debug,
             debugCodePaths = self.debug,
             origin = KATO_API_ORIGIN)
     connectWS(factory)
     return None
Exemplo n.º 21
0
    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()
Exemplo n.º 22
0
 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)
Exemplo n.º 23
0
 def connectBunch(self):
    if self.currentCnt + self.batchsize < self.targetCnt:
       c = self.batchsize
       redo = True
    else:
       c = self.targetCnt - self.currentCnt
       redo = False
    for i in xrange(0, c):
       factory = MassConnectFactory(self.uri)
       factory.test = self
       factory.retrydelay = self.retrydelay
       connectWS(factory)
       self.currentCnt += 1
    if redo:
       reactor.callLater(float(self.batchdelay)/1000., self.connectBunch)
Exemplo n.º 24
0
def start():
    
    
    log.startLogging(sys.stdout)
    factory = SpiderClientFactory("ws://{}:9000".format(ADMIN_HOST))
    factory.protocol = TaskClientProtocol
    connectWS(factory)
    
    def killGroup():
        for pid, kw in factory.spiders.iteritems():
            try:
                p = psutil.Process(int(pid))
                p.terminate()
            except Exception, e:
                print e
Exemplo n.º 25
0
    def reconnect(self):
        """Attempt to reconnect the ARI WebSocket.

        This call will give up after timeout_secs has been exceeded.
        """
        self.attempts += 1
        LOGGER.debug("WebSocket attempt #%d", self.attempts)
        if not self.start:
            self.start = datetime.datetime.now()
        runtime = (datetime.datetime.now() - self.start).seconds
        if runtime >= self.timeout_secs:
            LOGGER.error("  Giving up after %d seconds", self.timeout_secs)
            raise Exception("Failed to connect after %d seconds" %
                            self.timeout_secs)

        connectWS(self)
Exemplo n.º 26
0
    def _robotConnect(self, resp):
        """ Internally used method to connect to the Robot manager.
        """
        # Read the response
        url = resp["url"]
        current = resp.get("current", None)

        if current:
            print("Warning: There is a newer client (version: '{0}') " "available.".format(current))

        print("Connect to Robot Manager on: {0}".format(url))

        # Make websocket connection to Robot Manager
        args = urlencode(self._argList + [("key", resp["key"])])
        factory = RCERobotFactory("{0}?{1}".format(url, args), self)
        connectWS(factory)
Exemplo n.º 27
0
def main():
	if USE_SSL:
		uri_type = "wss"
	else:
		uri_type = "ws"

	server_url = "%s://%s:%d/rpi/" % (uri_type, SERVER, PORT)

	if DEBUG:
		log.startLogging(sys.stdout)

	factory = ReconnectingWebSocketClientFactory(server_url, useragent = settings.RPI_USER_AGENT, debug = DEBUG)
	factory.protocol = RPIClientProtocol

	connectWS(factory)
	reactor.run()
Exemplo n.º 28
0
    def _robotConnect(self, resp):
        """ Internally used method to connect to the Robot process.
        """
        # Read the response
        url = resp['url']
        current = resp.get('current', None)

        if current:
            print("Warning: There is a newer client (version: '{0}') "
                  'available.'.format(current))

        print('Connect to Robot Process on: {0}'.format(url))

        # Make WebSocket connection to Robot Manager
        args = urlencode((('userID', self._userID), ('robotID', self._robotID),
                          ('password', self._password)))
        factory = RCERobotFactory('{0}?{1}'.format(url, args), self)
        connectWS(factory)
Exemplo n.º 29
0
 def connect(self, masterUrl, deferred):
     """ Connect to RCE.
         
         @param masterUrl:   URL of Authentication Handler of Master Manager
         @type  masterUrl:   str
         
         @param deferred:    Deferred which is called as soon as the
                             connection was successfully established.
         @type  deferred:    twisted::Deferred
         
         @raise:     ConnectionError, if no connection could be established.
     """
     print('Connect to Master Manager on: {0}'.format(masterUrl))
     
     # First make a HTTP request to the Master to get a temporary key
     argList = [('userID', self._userID), ('robotID', self._robotID)]
     url = '{0}?{1}'.format(masterUrl,
                            urlencode(argList+[('version', _VERSION)]))
     
     try:
         f = urlopen(url)
     except HTTPError as e:
         raise ConnectionError('HTTP Error {0}: {1} - '
                               '{2}'.format(e.getcode(), e.msg, e.read()))
     
     self._connectedDeferred = deferred
     
     # Read the response
     resp = json.loads(f.read())
     url = resp['url']
     current = resp.get('current', None)
     
     if current:
         print("Warning: There is a newer client (version: '{0}') "
               'available.'.format(current))
     
     print('Connect to Robot Manager on: {0}'.format(url))
     
     # Make websocket connection to Robot Manager
     url = '{0}?{1}'.format(url, urlencode(argList+[('key', resp['key'])]))
     factory = RCERobotFactory(url, self)
     connectWS(factory)
Exemplo n.º 30
0
def publisher(c_name="all", debug=True):
    log.startLogging(sys.stdout)
    if c_name != "all":
        channel_name = "notifications:%s" % c_name
    else:
        channel_name = "notifications:all"
    #print "user name in Publisher: ", channel_name

    PUBSUB.subscribe(channel_name)

    '''
    factory = WampClientFactory("ws://%s:9000" % socket.gethostname(),
                                debugWamp=debug)
    '''

    factory = WampClientFactory("ws://localhost:9000", debugWamp=debug)
    factory.protocol = PubSubClient1
    connectWS(factory)

    reactor.run()
Exemplo n.º 31
0
   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()
Exemplo n.º 32
0
 def getProtocol(self):
     d = self._get_prot = Deferred()
     connectWS(self)
     return d
Exemplo n.º 33
0
 def connect(self):
     contextFactory = ssl.ClientContextFactory(
     )  # necessary for SSL; harmless otherwise
     connectWS(self, contextFactory)
Exemplo n.º 34
0
    def run(self):
        assert (self.factory)
        assert (self.index)
        assert (self.params)

        result = TestResult()
        finished = Deferred()

        result.passed = None
        result.observed = {}
        result.expected = {}
        result.log = []

        def log(msg, sessionIndex=None, sessionId=None):
            ts = perf_counter()
            result.log.append(
                (ts, sessionIndex, sessionId, msg.encode('utf8')))
            return ts

        result.started = log("Test started.")

        clients = []
        peersready = []
        peersgone = []
        i = 1
        for peerIndex in xrange(self.params.peerCount):
            ready = Deferred()
            gone = Deferred()
            client = self.factory(peerIndex, ready, gone, self, result)
            clients.append(client)
            peersready.append(ready)
            peersgone.append(gone)
            connectWS(client)
            i += 1

        def shutdown(_):
            for client in clients:
                client.proto.sendClose()
                log("Test client closing ...", client.peerIndex,
                    client.proto.session_id)

        def launch(_):
            wait = 2.5 * self._rtt

            def afterwait():
                log("Continuing test ..")
                d = maybeDeferred(self.test, log, result, clients)
                d.addCallback(shutdown)

            def beforewait():
                log("Sleeping for  <strong>%s ms</strong> ..." %
                    (1000. * wait))
                reactor.callLater(wait, afterwait)

            beforewait()

        def error(err):
            ## FIXME
            print "ERROR", err
            shutdown()
            finished.errback(err)

        def done(res):
            result.ended = log("Test ended.")

            for r in res:
                if not r[0]:
                    log("Client error: %s" % r[1].value)

            #assert(result.passed is not None)

            finished.callback(result)

        DeferredList(peersready).addCallbacks(launch, error)
        DeferredList(peersgone).addCallbacks(done, error)

        return finished
Exemplo n.º 35
0
def startClient(wsuri, debug=False):
    factory = BroadcastClientFactory(wsuri, debug)
    connectWS(factory)
    return True
Exemplo n.º 36
0

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()
Exemplo n.º 37
0
        options.parseOptions()
    except usage.UsageError, errortext:
        print '%s %s' % (sys.argv[0], errortext)
        print 'Try %s --help for usage details' % sys.argv[0]
        sys.exit(1)

    log.startLogging(sys.stdout)

    wsuri = options.opts['wsuri']
    debug = True if options['debug'] else False
    padsAsRpcs = True if options['rpc'] else False

    ## MIDI connector to Launchpad
    ##
    launchpadConnector = LaunchpadConnector()
    launchpadConnector.padsAsRpcs = padsAsRpcs
    reactor.callInThread(launchpadConnector.run)

    ## WAMP client factory
    ##
    log.msg("Connecting to %s" % wsuri)
    wampClientFactory = LaunchpadClientFactory(wsuri, debugWamp=debug)
    wampClientFactory.launchpad = launchpadConnector
    connectWS(wampClientFactory)

    webdir = File(".")
    web = Site(webdir)
    reactor.listenTCP(8095, web)

    reactor.run()
Exemplo n.º 38
0
 def connectGephi(self):
     wsClientFactory = WebSocketClientFactory(GEPHI_SERVER_URL)
     wsClientFactory.protocol = GephiClientProtocol
     wsClientFactory.broker = self
     connectWS(wsClientFactory)
Exemplo n.º 39
0
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)
Exemplo n.º 40
0
 def onSessionOpen(self):
     print "connected to WAMP server"
     factory = WebSocketClientFactory(GEPHI_SERVER_URL)
     factory.protocol = GephiClientProtocol
     factory.forwarder = self
     connectWS(factory)