Python Site.protocol方法代码示例

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
    def startService(self):

        factory = WebSocketServerFactory("ws://localhost:%d" % self.port, debug=self.debug)

        factory.protocol = EchoServerProtocol
        factory.setProtocolOptions(allowHixie76=True)  # needed if Hixie76 is to be supported

        # FIXME: Site.start/stopFactory should start/stop factories wrapped as Resources
        factory.startFactory()

        resource = WebSocketResource(factory)

        # we server static files under "/" ..
        webdir = os.path.abspath(pkg_resources.resource_filename("echows", "web"))
        root = File(webdir)

        # and our WebSocket server under "/ws"
        root.putChild("ws", resource)

        # both under one Twisted Web Site
        site = Site(root)
        site.protocol = HTTPChannelHixie76Aware  # needed if Hixie76 is to be supported

        self.site = site
        self.factory = factory

        self.listener = reactor.listenTCP(self.port, site)

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
def run_dev_server():
  global sender
  global ws_handler

  app.secret_key = "SECRET"
  app.debug = True

  ## create a Twisted Web resource for our WebSocket server
  wsFactory = BroadcastServerFactory(ws_url, debug=True, debugCodePaths=True)

  wsFactory.protocol = EchoServerProtocol
  wsFactory.setProtocolOptions(allowHixie76=True)

  wsResource = WebSocketResource(wsFactory)

  ## create a Twisted Web WSGI resource for our Flask server
  wsgiResource = WSGIResource(reactor, reactor.getThreadPool(), app)

  ## create a root resource serving everything via WSGI/Flask, but
  ## the path "/ws" served by our WebSocket stuff
  rootResource = WSGIRootResource(wsgiResource, {'ws': wsResource})

  ## create a Twisted Web Site and run everything
  site = Site(rootResource)
  site.protocol = HTTPChannelHixie76Aware

  sender = MessageSender(wsFactory)
  wsFactory.sender = sender
  ws_handler = wsFactory

  reactor.listenTCP(port, site)
  reactor.run()

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
    def start(self):
        """ start websocket server """
        logger.info('start websocket server at %s', self._url)
        self._factory = MyWebSocketServerFactory(
            self._url,
            debug=self._debug
        )

        self._factory.protocol = MyWebSocketServerProtocol
        self._factory.setProtocolOptions(allowHixie76=True)

        self._resource = WebSocketResource(self._factory)

        # we server static files under "/" ..
        root = File('.')

        # and our WebSocket server under "/websocket"
        root.putChild('websocket', self._resource)

        # both under one Twisted Web Site
        site = Site(root)
        site.protocol = HTTPChannelHixie76Aware
        reactor.listenTCP(self._port, site)
        self._thread = threading.Thread(target=reactor.run, args=(False,))
        self._thread.start()

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
def startup():
	if not os.path.exists('data/firmware'):
		os.makedirs('data/firmware')
	if not os.path.exists('data/static'):
		os.makedirs('data/static')
	if not os.path.exists('data/cert'):
		os.makedirs('data/cert')
	# Check the certificate file
	host = getHost()
	validateCertHost('data/cert/key.pem', 'data/cert/cert.pem', 'data/static/thumb.txt', host)
	
	# Start up the HTTPS server
	web_port = 443
	root_handler = File('./data/static/')	
	firmware_handler = FirmwareHandler('data/firmware/')
	root_handler.putChild('firmware', firmware_handler)
	site = Site(root_handler)
	site.protocol = MyHttpChannel
	reactor.listenTCP(web_port, site)
	
	# Start up the HTTP server
	root_handler_http = File("./data/static/")
	config_handler = File("./config.html")
	root_handler_http.putChild('config.html', config_handler)
	site_http = Site(root_handler_http)
	reactor.listenTCP(8080, site_http)

	reactor.suggestThreadPoolSize(50)

	printStatus("Startup complete, running main loop...")

	# Run the main loop, this never returns:
	reactor.run()

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
def setUp():
    if len(sys.argv) > 1 and sys.argv[1] == 'debug':
        log.startLogging(sys.stdout)
        debug = True
    else:
        debug = False
    try:
        import autobahn
        import twisted
    except ImportError:
        sys.exit("Install all dependencies")
    root = Resource()
    # root.putChild(constants.WEB_DYNAMIC_BRANCH, resource)
    from autobahn.twisted.resource import WebSocketResource, HTTPChannelHixie76Aware
    from twisted.web.server import Site

    factory = BroadcastServerFactory("ws://127.0.0.1:8888", debug=debug, debugCodePaths=debug)
    #если используется proxy
    #factory.proxy={'host': '192.168.200.105', 'port': '8088'}
    factory.protocol = BroadcastServerProtocol
    factory.setProtocolOptions(allowHixie76=True)
    ws_resource = WebSocketResource(factory)
    root.putChild("ws", ws_resource)
    site = Site(root)
    site.protocol = HTTPChannelHixie76Aware
    listenWS(factory)
    reactor.run()

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
def setUp():
    if len(sys.argv) > 1 and sys.argv[1] == 'debug':
        log.startLogging(sys.stdout)
        debug = True
    else:
        debug = False
    try:
        import autobahn
        import twisted
    except ImportError:
        sys.exit("Install all dependencies")
    from orm.database_init import init_db, db_session
    from apps.web import constants
    init_db()
    from pdb import set_trace
    set_trace()
    from apps.web import main_resource
    root = main_resource.Root()
    reactor.listenTCP(8000, server.Site(main_resource.Root()))
    factory = BroadcastServerFactory("ws://127.0.0.1:8011", debug=debug, debugCodePaths=debug)
    factory.protocol = BroadcastServerProtocol
    factory.setProtocolOptions(allowHixie76=True)
    ws_resource = WebSocketResource(factory)
    root.putChild("ws", ws_resource)
    site = Site(root)
    site.protocol = HTTPChannelHixie76Aware
    listenWS(factory)
    reactor.run()

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
def run_twisted_server(ip, port):
    rootResource = WSGIRootResource(createDjangoEndPoint(),{})
    site = Site(rootResource)
    site.protocol = HTTPChannelHixie76Aware
    from twisted.python import log as log_twisted
    log_twisted.startLogging(sys.stdout)
    reactor.listenTCP(port, site, interface=ip)
    reactor.run()

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
def boot(listen_addr='127.0.0.1', port=8080, session_bus=False, sage_www_root=DEFAULT_SAGE_ROOT, auth_realm=None, auth_passwd=None, allow_ga=None, deny_ga=None, no_www=False):

	assert not (allow_ga and deny_ga), 'Must not specify both deny and allow rules for group addresses'
	global api
	global factory
	DBusGMainLoop(set_as_default=True)
	
	if session_bus:
		bus = dbus.SessionBus()
	else:
		bus = dbus.SystemBus()
		
	obj = bus.get_object(DBUS_SERVICE, DBUS_PATH)
	api = dbus.Interface(obj, DBUS_INTERFACE)
	
	uri = createWsUrl(listen_addr, port)
	factory = SageProtocolFactory(uri, debug=False, api=api, allow_ga=allow_ga, deny_ga=deny_ga)
	factory.setProtocolOptions(allowHixie76=True, webStatus=False)
	factory.protocol = SageProtocol
	factory.clients = []
	
	resource = WebSocketResource(factory)
	
	if no_www:
		root = resource
	else:
		root = File(sage_www_root)
		root.putChild('saged', resource)
	
	if auth_realm != None and auth_passwd != None:
		portal = Portal(SageRealm(root), [ApachePasswordDB(auth_passwd)])
		credentialFactories = [BasicCredentialFactory(auth_realm),]
		root = HTTPAuthSessionWrapper(portal, credentialFactories)
		
	
	site = Site(root)
	site.protocol = HTTPChannelHixie76Aware
	reactor.listenTCP(port, site, interface=listen_addr)
	
	reactor.run()

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
def main():
   writelog('starting server')
   if len(sys.argv) > 1 and sys.argv[1] == 'debug':
      log.startLogging(sys.stdout)
      debug = True
	  #print 'debuggin'
   else:
      debug = False
   log.startLogging(DailyLogFile.fromFullPath("/var/log/sprinkler.log"))
   debug = True
   contextFactory = ssl.DefaultOpenSSLContextFactory('/home/pi/cron/keys/server.key',
			'/home/pi/cron/keys/server.crt')
   ServerFactory = BroadcastServerFactory
   #ServerFactory = BroadcastPreparedServerFactory

   factory = ServerFactory("wss://localhost:5000",
                           debug = debug,
                           debugCodePaths = debug)
   factory2 = ServerFactory("ws://localhost:5001",
                           debug = debug,
                           debugCodePaths = debug)

   factory.protocol = BroadcastServerProtocol
   factory.setProtocolOptions(allowHixie76 = True)
   factory2.protocol = BroadcastServerProtocol
   factory2.setProtocolOptions(allowHixie76 = True)
   listenWS(factory2)
   listenWS(factory,contextFactory)
   webdir = File("/home/pi/cron/sprinklerwww/")
   web = Site(webdir)
   web.protocol = HTTPChannelHixie76Aware
   webdir.contentTypes['.crt'] = 'application/x-x509-ca-cert'
   print 'starting server'
   webdir.putChild("sChange",sChange())
   webdir.putChild("schedule",schedule())
   webdir.putChild("manual",manual())
   #reactor.listenTCP(8080, web)
   reactor.listenSSL(8081,web,contextFactory)
   reactor.run()

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
    def _site_init(self, debug):
        # Twisted Web resource for our WAMP factory
        ws_resource = WebSocketResource(self.factory)

        # Write hardwire settings to JS file
        with open(os.path.join(self._hw_dir, 'static', 'js', 'hw-settings.js'), 'w+') as f:
           f.write('var hw_settings = {port: %d}' % self._port) 
   
        # Twisted Web resource for static assets
        hw_static_resource = File(os.path.join(self._hw_dir, 'static'))

        # Create root resource from either the user's WSGI app, the user's
        # index.html, or the Hardwire default index.html
        if self._app:
            print "Using user-supplied WSGI app..."
            wsgi_resource = WSGIResource(reactor, reactor.getThreadPool(), self._app)

            child_resources = {'hw_static': hw_static_resource, \
                               'static': static_resource, \
                               settings.WSURI_SUFFIX: ws_resource}
            root_resource = WSGIRootResource(wsgi_resource, child_resources)
        else:
            user_index_path = os.path.join(self._user_dir, 'index.html')
            if os.path.isfile(user_index_path):
                print "Using user-supplied index.html..."
                index_path = self._user_dir
            else:
                print "Using Hardwire default index.html..."
                index_path = os.path.join(self._hw_dir, 'templates')

            root_resource = File(index_path)
            root_resource.putChild("hw_static", hw_static_resource)   
            root_resource.putChild(settings.WSURI_SUFFIX, ws_resource)

        if debug:
            log.startLogging(sys.stdout)
        site = Site(root_resource)
        site.protocol = HTTPChannelHixie76Aware # needed if Hixie76 is supported
        reactor.listenTCP(self._port, site)

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
    def makeService(self, options):
        """
        Construct a TCPServer from a factory defined in myproject.
        """

        ws_factory = ReveilleServerFactory("ws://localhost:%d" % options["port"])
        ws_factory.setProtocolOptions(allowHixie76=True)
        ## need to start manually, see https://github.com/tavendo/AutobahnPython/issues/133
        ws_factory.startFactory()
        #listenWS(ws_factory)

        ## Twisted Web resource for our WAMP factory
        ws_resource = WebSocketResource(ws_factory)

        stream_factory = WscpServerFactory("ws://localhost:%d" % options["port"],
                                           #'/data/music_archive',
                                           '/Users/davidb/src')
        stream_factory.setProtocolOptions(allowHixie76=True)
        ## need to start manually, see https://github.com/tavendo/AutobahnPython/issues/133
        stream_factory.startFactory()
        #listenWS(stream_factory)

        ## Twisted Web resource for our WAMP factory
        stream_resource = WebSocketResource(stream_factory)

        ## we server static files under "/" ..
        root = File(".")

        ## and our WAMP server under "/reveille"
        root.putChild("reveille", ws_resource)

        ## and our WebSocket server under "/stream"
        root.putChild("stream", stream_resource)

        ## both under one Twisted Web Site
        site = Site(root)
        site.protocol = HTTPChannelHixie76Aware  # needed if Hixie76 is to be supported
        return internet.TCPServer(int(options["port"]), site)

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
def startup():
	if not os.path.exists('data/firmware'):
		os.makedirs('data/firmware')
	if not os.path.exists('data/static'):
		os.makedirs('data/static')
	if not os.path.exists('data/cert'):
		os.makedirs('data/cert')
	# Check the certificate file
	host = getHost()
	validateCertHost('data/cert/key.pem', 'data/cert/cert.pem', 'data/static/thumb.txt', host)
	
	# Start up the HTTPS server
	web_port = 443
	root_handler = File('./data/static/')	
	firmware_handler = FirmwareHandler('data/firmware/')
	root_handler.putChild('firmware', firmware_handler)
	site = Site(root_handler)
	site.protocol = MyHttpChannel
	reactor.listenTCP(web_port, site)
	
	# Start up the HTTP server
	root_handler_http = File("./data/static/")
	#config_handler = File("./config.html")
	#root_handler_http.putChild('config.html', config_handler)
	site_http = Site(root_handler_http)
	reactor.listenTCP(8080, site_http)

	reactor.suggestThreadPoolSize(50)

	#printStatus("Startup complete, running main loop...")
	print ""
	print "Using another WiFi capable device (NOT this machine) connect to your network, open a browser and go to: http://"+host+":8080 and follow the instructions to update your Oak."
	print ""
	print "NOTE: You must use the config app at that address, it is configured specifically for this local update. Status messages will print here during the update. Do not close this window until you have finished updating."
	# Run the main loop, this never returns:
	reactor.run()

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
   ## create a Twisted Web resource for our WebSocket server
   ##
   wsFactory = WebSocketServerFactory("ws://localhost:8080",
                                      debug = debug,
                                      debugCodePaths = debug)

   wsFactory.protocol = EchoServerProtocol
   wsFactory.setProtocolOptions(allowHixie76 = True) # needed if Hixie76 is to be supported

   wsResource = WebSocketResource(wsFactory)

   ##
   ## create a Twisted Web WSGI resource for our Flask server
   ##
   wsgiResource = WSGIResource(reactor, reactor.getThreadPool(), app)

   ##
   ## create a root resource serving everything via WSGI/Flask, but
   ## the path "/ws" served by our WebSocket stuff
   ##
   rootResource = WSGIRootResource(wsgiResource, {'ws': wsResource})

   ##
   ## create a Twisted Web Site and run everything
   ##
   site = Site(rootResource)
   site.protocol = HTTPChannelHixie76Aware # needed if Hixie76 is to be supported

   reactor.listenTCP(8080, site)
   reactor.run()

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
def websocket_func(logger, host, port):
    cons = list()

    # noinspection PyUnusedLocal
    def sigint_handler(signum, frame):
        reactor.stop()

    signal.signal(signal.SIGINT, sigint_handler)

    def send_to_all(msg, except_connection=None):
        if except_connection:
            logger.debug("Sending to all except %d message: %s", id(except_connection), msg)
        else:
            logger.debug("Sending to all: %s", msg)
        json_msg = json.dumps(msg)
        for con in cons:
            if con == except_connection:
                continue
            logger.debug("Sending to %d message: %s", id(con), msg)
            con.sendMessage(json_msg, False)

    class EchoServerProtocol(WebSocketServerProtocol):

        def __init__(self):
            pass

        def send_error(self, error_message):
            logger.error(error_message)
            self.send_to_self({"type": "error", "response": error_message})

        def send_to_self(self, msg):
            logger.debug("Sending to self: %s", msg)
            json_msg = json.dumps(msg)
            self.sendMessage(json_msg, False)

        def send_to_others(self, msg):
            send_to_all(msg, self)

        def onMessage(self, msg, binary):
            if binary:
                return
            try:
                data = json.loads(msg)
                data_type = str(data["type"])
                if "ping" == data_type:
                    self.on_message_ping(data)
                elif "register" == data_type:
                    self.on_message_register(data)
                elif "data" == data_type:
                    self.on_message_data(data)
                else:
                    self.send_error("Received unknown message type: %s" % data_type)
            except Exception as e:
                self.send_error("Error: %s, in message: %s" % (str(e), msg))

        def on_message_data(self, data):
            self.send_to_self({
                "type": "data",
                "id": data["id"],
                "message": base64.b64encode(data["message"])
            })
            self.send_to_others({
                "type": "chat",
                "from": str(id(self)),
                "message": data["message"]
            })

        def on_message_register(self, data):
            auth_token = data["auth_token"]
            if auth_token in VALID_AUTH_TOKENS:
                cons.append(self)
                self.send_to_self({"type": "registered", "response": "you are cool"})
            else:
                self.send_error("Wrong auth token")

        def on_message_ping(self, data):
            self.send_to_self({"type": "pong", "message": data["message"]})

        def onClose(self, was_clean, code, reason):
            logger.debug("Disconnected: %s" % id(self))
            if self in cons:
                cons.remove(self)

        def onOpen(self):
            logger.debug("Connected: %s" % id(self))

    url = "ws://%s:%d" % (host, port)

    factory = WebSocketServerFactory(url)
    factory.protocol = EchoServerProtocol
    factory.setProtocolOptions(allowHixie76=True)

    resource = WebSocketResource(factory)

    root = Resource()
    root.putChild("ws", resource)

    site = Site(root)
    site.protocol = HTTPChannelHixie76Aware

#.........这里部分代码省略.........

# 需要导入模块: from twisted.web.server import Site [as 别名]
# 或者: from twisted.web.server.Site import protocol [as 别名]
   def startService(self):
      log.msg("Starting %s service ..." % self.SERVICENAME)

      issecure = self.services["config"]["hub-websocket-tls"]
      port = self.services["config"]["hub-websocket-port"]
      acceptqueue = self.services["config"]["ws-accept-queue-size"]

      if issecure:
         contextFactory = TlsContextFactory(self.services["config"]["hub-websocket-tlskey-pem"],
                                            self.services["config"]["hub-websocket-tlscert-pem"],
                                            dhParamFilename = self.services['master'].dhParamFilename)

         uri = "wss://localhost:%d" % port
      else:
         contextFactory = None

         uri = "ws://localhost:%d" % port

      self.wsfactory = HubWebSocketFactory(uri, self.dbpool, self.services)
      #self.wsfactory.trackTimings = True

      self.enableAppWeb = self.services["config"]["service-enable-appweb"]

      if self.enableAppWeb:
         ## FIXME: Site.start/stopFactory should start/stop factories wrapped as Resources
         self.wsfactory.startFactory()
         resource = WebSocketResource(self.wsfactory)
         appwebDir = self.services["master"].webdata
         root = File(appwebDir)
         root.putChild(self.services["config"]["ws-websocket-path"], resource)

         ## CGI
         ##
         cgienable = self.services["config"]["appweb-cgi-enable"]
         cgipath = self.services["config"]["appweb-cgi-path"]
         cgiprocessor = self.services["config"]["appweb-cgi-processor"]
         if cgienable and cgipath is not None and cgipath.strip() != "" and cgiprocessor is not None and cgiprocessor.strip() != "":
            cgipath = cgipath.strip()
            cgidir = os.path.join(appwebDir, cgipath)
            cgiprocessor = cgiprocessor.strip()
            cgiresource = CgiDirectory(cgidir, cgiprocessor)
            root.putChild(cgipath, cgiresource)
            log.msg("CGI configured on path '%s' using processor '%s'" % (cgipath, cgiprocessor))
         else:
            log.msg("No CGI configured")

         factory = Site(root)
         factory.log = lambda _: None # disable any logging
         factory.protocol = HTTPChannelHixie76Aware # needed if Hixie76 is to be supported

         ## REST interface to get config values
         ##
         configPath = self.services["config"]["ws-websocket-path"] + "config"
         addPortConfigResource(self.services["config"], root, configPath)
      else:
         factory = self.wsfactory

      self.factory = factory

      if issecure:
         self.listener = reactor.listenSSL(port, factory, contextFactory, backlog = acceptqueue)
      else:
         self.listener = reactor.listenTCP(port, factory, backlog = acceptqueue)

      self.isRunning = True