Python resource.WebSocketResource方法代码示例

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def hostapd_control(self, request, chute, network):
        try:
            chute_obj = ChuteStorage.chuteList[chute]
            if not chute_access_allowed(request, chute_obj):
                return permission_denied(request)
            networkInterfaces = chute_obj.getCache('networkInterfaces')
        except KeyError:
            request.setResponseCode(404)
            return ""

        ifname = None
        for iface in networkInterfaces:
            if iface['name'] == network:
                ifname = iface['externalIntf']
                break

        ctrl_iface = os.path.join(settings.PDCONFD_WRITE_DIR, "hostapd", ifname)
        factory = hostapd_control.HostapdControlWSFactory(ctrl_iface)
        factory.setProtocolOptions(autoPingInterval=10, autoPingTimeout=5)
        return WebSocketResource(factory) 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def logs(self, request, name):
        #cors.config_cors(request)
        chute = ChuteStorage.get_chute(name)
        factory = LogSockJSFactory(chute)
        factory.setProtocolOptions(autoPingInterval=5, autoPingTimeout=2)
        return WebSocketResource(factory) 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def status(self, request):
        #cors.config_cors(request)
        factory = StatusSockJSFactory(self.system_status)
        factory.setProtocolOptions(autoPingInterval=5, autoPingTimeout=2)
        return WebSocketResource(factory) 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def chute_logs(self, request, name):
        #cors.config_cors(request)
        chute = ChuteStorage.get_chute(name)
        factory = ChuteLogWsFactory(chute)
        factory.setProtocolOptions(autoPingInterval=10, autoPingTimeout=5)
        return WebSocketResource(factory) 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def airshark_analyzer(self, request):
        #cors.config_cors(request)
        factory = AirsharkAnalyzerFactory(self.airshark_manager)
        factory.setProtocolOptions(autoPingInterval=10, autoPingTimeout=5)
        return WebSocketResource(factory) 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def airshark_spectrum(self, request):
        #cors.config_cors(request)
        factory = AirsharkSpectrumFactory(self.airshark_manager)
        factory.setProtocolOptions(autoPingInterval=10, autoPingTimeout=5)
        return WebSocketResource(factory) 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def change_stream(self, request, change_id):
        change = self.update_manager.find_change(change_id)
        if change is not None:
            factory = ChangeStreamFactory(change)
            factory.setProtocolOptions(autoPingInterval=10, autoPingTimeout=5)
            return WebSocketResource(factory)
        else:
            request.setResponseCode(404)
            return "{}" 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def startService(self):

        factory = WebSocketServerFactory(u"ws://127.0.0.1:%d" % self.port,
                                         debug=self.debug)
        factory.protocol = DispatcherProtocol
        factory.protocol.dispatcher = CommandDispatcher(self._core)

        # 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('leap.bitmask.core', 'web'))
        root = File(webdir)

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

        # both under one Twisted Web Site
        site = Site(root)

        self.site = site
        self.factory = factory

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

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def __init__(self, conf, ws_factory):
        # type: (AutopushConfig, PushServerFactory) -> None
        self.conf = conf
        self.noisy = conf.debug

        resource = DefaultResource(WebSocketResource(ws_factory))
        resource.putChild("status", StatusResource())
        Site.__init__(self, resource) 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def make_web_server(server, log_requests, websocket_protocol_options=()):
    root = Root()
    wsrf = WebSocketServerFactory(None, server)
    wsrf.setProtocolOptions(**dict(websocket_protocol_options))
    root.putChild(b"v1", WebSocketResource(wsrf))

    site = PrivacyEnhancedSite(root)
    site.logRequests = log_requests

    return site 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def setUp(self):
    market_factory = WebSocketServerFactory('ws://localhost:8080/market_stream')
    user_factory = WebSocketServerFactory('ws://localhost:8080/user_stream')
    market_factory.protocol = MarketStreamServerProtocol
    user_factory.protocol = UserStreamServerProtocol
    market_factory.startFactory()
    user_factory.startFactory()
    root = Data('', 'text/plain')
    root.putChild(b'market_stream', WebSocketResource(market_factory))
    root.putChild(b'user_stream', WebSocketResource(user_factory))
    site = Site(root)
    reactor.listenTCP(8080, site)
    def run_server():
      reactor.run(installSignalHandlers=False)
    Thread(target=run_server).start() 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def start(self, session):
        server = self
        with enamlnative.imports():
            from twisted.internet import reactor
            from twisted.web import resource
            from twisted.web.static import File
            from twisted.web.server import Site
            from autobahn.twisted.websocket import (
                WebSocketServerFactory, WebSocketServerProtocol
            )
            from autobahn.twisted.resource import WebSocketResource

        class DevWebSocketHandler(WebSocketServerProtocol):
            def onConnect(self, request):
                print("Client connecting: {}".format(request.peer))

            def onOpen(self):
                print("WebSocket connection open.")

            def onMessage(self, payload, isBinary):
                r = session.handle_message(payload)
                self.sendMessage(json.dumps(r))

            def onClose(self, wasClean, code, reason):
                print("WebSocket connection closed: {}".format(reason))

        class MainHandler(resource.Resource):
            def render_GET(self, req):
                return server.render_editor()

            def render_POST(self, req):
                #: Allow posting events
                r = session.handle_message(req.content.getvalue())
                return json.dumps(r)

        factory = WebSocketServerFactory(
            u"ws://0.0.0.0:{}".format(session.port))
        factory.protocol = DevWebSocketHandler
        root = resource.Resource()
        root.putChild("", MainHandler())
        root.putChild("dev", WebSocketResource(factory))
        root.putChild("source", File(sys.path[0]))
        root.putChild("tmp", File(os.environ.get('TMP',sys.path[0])))
        site = Site(root)
        reactor.listenTCP(session.port, site)
        print("Twisted dev server started on {}".format(session.port)) 

# 需要导入模块: from autobahn.twisted import resource [as 别名]
# 或者: from autobahn.twisted.resource import WebSocketResource [as 别名]
def __init__(self, config, controller):
        super(WebApp, self).__init__()
        self.config = config
        self.controller = controller
        self.children = {}

        #-----------------------------------------------------------------------
        # Register web modules
        #-----------------------------------------------------------------------
        web_modules = config.get_options('web-modules')

        for mod_name, mod_class_name in web_modules:
            mod_class = get_object(mod_class_name)
            self.putChild(mod_name.encode('utf-8'), mod_class(self))

        #-----------------------------------------------------------------------
        # Set up the websocket
        #-----------------------------------------------------------------------
        ws_factory = WSFactory(controller=self.controller)
        ws_factory.protocol = WSProtocol
        ws_resource = WebSocketResource(ws_factory)
        self.putChild(b'ws', ws_resource)

        #-----------------------------------------------------------------------
        # Register UI modules
        #-----------------------------------------------------------------------
        assets = None
        try:
            assets = get_data(__package__, 'ui/asset-manifest.json')
            assets = assets.decode('utf-8')
        except FileNotFoundError:
            self.index = self

        if assets is not None:
            self.index = UIResource('ui/index.html')
            self.putChild(b'', self.index)

            children = [
                '/favicon.png',
                '/manifest.json',
                '/scrapy-do-logo.png'
            ]
            for child in children:
                self.register_child(child, UIResource('ui' + child))

            assets = json.loads(assets)
            for _, asset in assets['files'].items():
                if asset.startswith('/'):
                    asset = asset[1:]
                self.register_child('/' + asset, UIResource('ui/' + asset))

    #---------------------------------------------------------------------------