How to use autobahn - 10 common examples

import txaio
txaio.use_twisted()

from twisted.internet import reactor

import autobahn

from autobahn.twisted.websocket import connectWS, WebSocketClientFactory, \
    WebSocketClientProtocol

from autobahn.websocket.compress import PerMessageDeflateOffer, \
    PerMessageDeflateResponse, PerMessageDeflateResponseAccept


class TesteeClientProtocol(WebSocketClientProtocol):

    def onOpen(self):
        if self.factory.endCaseId is None:
            self.log.info("Getting case count ..")
        elif self.factory.currentCaseId <= self.factory.endCaseId:
            self.log.info("Running test case {case_id}/{last_case_id} as user agent {agent} on peer {peer}",
                          case_id=self.factory.currentCaseId,
                          last_case_id=self.factory.endCaseId,
                          agent=self.factory.agent,
                          peer=self.peer)

    def onMessage(self, msg, binary):
        if self.factory.endCaseId is None:
            self.factory.endCaseId = int(msg)
            self.log.info("Ok, will run {case_count} cases", case_count=self.factory.endCaseId)
        else:

def startClient(wsuri, debug = False):
   factory = BroadcastClientFactory(wsuri, debug)
   connectWS(factory)
   return True

def __init__(self, config, templates):
        """
        :param config: Crossbar transport configuration.
        :type config: dict
        """
        options = config.get('options', {})

        server = "Crossbar/{}".format(crossbar.__version__)
        externalPort = options.get('external_port', None)

        WebSocketServerFactory.__init__(self,
                                        url=config.get('url', None),
                                        server=server,
                                        externalPort=externalPort)

        # transport configuration
        self._config = config

        # Jinja2 templates for 404 etc
        self._templates = templates

        # set WebSocket options
        set_websocket_options(self, options)

def onJoin(self, details):

        def on_event(i):
            print("Got event: {}".format(i))

        yield self.subscribe(on_event, 'com.myapp.topic1')

        counter = 0
        while True:
            self.publish('com.myapp.topic1', counter, options=types.PublishOptions(excludeMe=False))
            counter += 1
            yield sleep(1)

if payload["server"]:
                    print("bu mesaj serverdan gelmis demek")
                    addnewnode(payload["host"])
                else:
                    print(payload["message"])
                    payload["host"] = ip
                    payload = json.dumps(payload) #tekrar şifreleyip server ile paykaş
                    self.factory.broadcast(payload)

    def connectionLost(self, reason):
        WebSocketServerProtocol.connectionLost(self, reason)
        self.factory.unregister(self)

clients = []

class BroadcastServerFactory(WebSocketServerFactory):
    def __init__(self, url):
        WebSocketServerFactory.__init__(self, url)
    def register(self, client):
        if client not in clients:
            print("registered client {}".format(client.peer))
            print(clients)
            tcp, host, port = client.peer.split(":")
            print(host)
            clients.append(client)

    def unregister(self, client):
        if client in clients:
            print("unregistered client {}".format(client.peer))
            clients.remove(client)

    @classmethod

"service-enable-extdirectremoter": False,
          }

      if not scratchMode:
         CONFIG.update({"database-created": created,
                        "admin-password": "secret"})

      ## default global configuration
      ##
      for k in CONFIG:
         cur.execute("INSERT INTO config (key, value) VALUES (?, ?)", [k, json_dumps(CONFIG[k])])
      db.commit()

      ## default client permission: allow everything for anynonymous
      cur.execute("INSERT INTO clientperm (id, created, topic_uri, match_by_prefix, allow_publish, allow_subscribe) VALUES (?, ?, ?, ?, ?, ?)",
                  [newid(), utcnow(), "http://", 1, 1, 1])
      db.commit()

      if self.checkForOracleXE():
         log.msg("Inserting initial configuration for 'Tavendo WebMQ with Oracle XE'")
         oraConnectId = newid()
         now = utcnow()
         cur.execute("INSERT INTO oraconnect (id, created, label, host, port, sid, user, password, demo_user, demo_password, connection_timeout) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                     [oraConnectId, now, "WebMQ", "127.0.0.1", 1521, "XE", "WEBMQ", "webmq", "WEBMQDEMO", "webmqdemo", 5])
         cur.execute("INSERT INTO orapushrule (id, created, oraconnect_id, topic_uri, match_by_prefix) VALUES (?, ?, ?, ?, ?)",
                     [newid(), now, oraConnectId, "http://", 1])
         cur.execute("INSERT INTO oraremote (id, created, oraconnect_id, schema_list, rpc_base_uri, connection_pool_min_size, connection_pool_max_size, connection_timeout, request_timeout) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
                     [newid(), now, oraConnectId, "", "http://", 3, 10, 5, 2])
         db.commit()

      log.msg("database initialized.")

## CONFIG table
      ##
      cur.execute("""
                  CREATE TABLE config
                  (
                     key                 VARCHAR2(30)                     PRIMARY KEY,
                     value               VARCHAR2(4000)                   NOT NULL
                  )
                  """)
      log.msg("database table '%s' created" % "config")

      ## store database schema version
      ##
      config = [('schema-category', 'demo'),
                ('schema-version', SCHEMAVERSION),
                ('schema-created', utcnow())]
      for key, value in config:
         cur.execute("INSERT INTO config (key, value) VALUES (:1, :2)", [key, json_dumps(value)])
      conn.commit()

      log.msg("crossbar.io Demo schema created (version %d)!" % SCHEMAVERSION)

   else:

      log.msg("crossbar.io Demo schema dropped!")

   return dbschema.getSchemaVersion(conn, oraschema.LATESTVERSIONS)

self.log.info(msg)

        # scroll informational message
        msg = u'     '.join(msgs)
        yield self._display.scroll_message(msg)

        # write the ZOLLHOF logo
        self._display.set_raw_digit(0, 0b0001001)
        self._display.set_raw_digit(1, 0b0111111)
        self._display.set_raw_digit(2, 0b0110110)
        self._display.set_raw_digit(3, 0b1110000)
        self._display.set_raw_digit(4, 0b0111111)
        self._display.set_raw_digit(5, 0b1110001)
        self._display.write_display()

        yield sleep(5)

# this function gets called every time connectWS is called (once per WebSocket connection/session)
   def buildProtocol(self, addr):

      try:
         utt = self.queueProto.get_nowait()
         proto = WSInterfaceProtocol(self, self.queue, self.summary, self.contentType)         
         proto.setUtterance(utt)
         return proto 
      except Queue.Empty:
         print "queue should not be empty, otherwise this function should not have been called"
         return None

# WebSockets interface to the STT service
# note: an object of this class is created for each WebSocket connection, every time we call connectWS
class WSInterfaceProtocol(WebSocketClientProtocol):

   def __init__(self, factory, queue, summary, contentType):
      self.factory = factory
      self.queue = queue
      self.summary = summary
      self.contentType = contentType 
      self.packetRate = 20
      self.listeningMessages = 0
      self.timeFirstInterim = -1
      self.bytesSent = 0
      self.chunkSize = 2000    # in bytes
      super(self.__class__, self).__init__()
      # print "contentType: " + str(self.contentType) + " queueSize: " + str(self.queue.qsize())

   def setUtterance(self, utt):

from autobahn.twisted.websocket import WebSocketClientFactory, \
    WebSocketClientProtocol, \
    connectWS


if __name__ == '__main__':

    log.startLogging(sys.stdout)

    if len(sys.argv) < 2:
        print("Need the WebSocket server address, i.e. ws://127.0.0.1:9000")
        sys.exit(1)

    factory = WebSocketClientFactory(sys.argv[1])
    factory.protocol = WebSocketClientProtocol
    connectWS(factory)

    reactor.run()