def __init__(self, url): WebSocketServerFactory.__init__(self, url) self.clients = [] self.tickGap = 5 self.tickSetup() listenWS(self)
def bind(self): """ Start listening on the port specified """ factory = WebSocketServerFactory(debug=False) factory.noisy = False factory.server = self factory.protocol = MdcloudWebsocketServerProtocol web_resource = File(resource_filename(__name__, 'static/build/client')) rootResource = WSGIRootResource(web_resource, {'ws': WebSocketResource(factory)}) if not self.no_ssl and self.settings and self.settings.ssl.enabled: print '*' * 60 print 'Running in secure mode' print 'Ssl key: %s' % self.settings.ssl.key print 'Ssl certificate: %s' % self.settings.ssl.cert print '*' * 60 listen_ssl(self.port, Site(rootResource), interface=self.settings.websocket_ip) else: print '*' * 60 print 'Running on 0.0.0.0 without SSL' print '*' * 60 reactor.listenTCP(self.port, Site(rootResource), interface='0.0.0.0')
class WebSocketListenerService(service.Service): name = "WebSocketListenerService" logger = Logger() def __init__(self, server_uri, router_uri, debug=False): self.s_uri = server_uri self.s_address = urlparse(server_uri).hostname self.s_port = urlparse(server_uri).port self.r_uri = router_uri self.r_address = urlparse(router_uri).hostname self.r_port = urlparse(router_uri).port self.debug = debug self.s_factory = WebSocketServerFactory(server_uri) proto = WSServer proto.service = self self.s_factory.protocol = proto self.s_factory.setProtocolOptions(maxConnections=10) def startService(self): self.s_listener = reactor.listenTCP(self.s_port, self.s_factory, interface=self.s_address) self.logger.info("service started") def stopService(self): self.s_listener.stopListening() self.s_factory.stopFactory() self.logger.info("service stopped")
def __init__(self, url, mserver, kserver, debug=False, debugCodePaths=False): WebSocketServerFactory.__init__(self, url, debug=debug, debugCodePaths=debugCodePaths) self.mserver = mserver self.kserver = kserver self.db = mserver.db self.outstanding = {} self.clients = []
def main(reactor): log.startLogging(sys.stdout) factory = WebSocketServerFactory() factory.protocol = OpenFaceServerProtocol ctx_factory = DefaultOpenSSLContextFactory(tls_key, tls_crt) reactor.listenSSL(args.port, factory, ctx_factory) return defer.Deferred()
def startService(self): factory = WebSocketServerFactory(u"ws://127.0.0.1:%d" % self.port, debug=self.debug) factory.protocol = DispatcherProtocol factory.protocol.core = 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)
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, debug=config.get("debug", False), ) # transport configuration self._config = config # Jinja2 templates for 404 etc self._templates = templates # set WebSocket options set_websocket_options(self, options)
def __init__(self, url, debug = False, debugCodePaths = False): WebSocketServerFactory.__init__(self, url, debug = debug, debugCodePaths = debugCodePaths) self.clients = [] self.oldGifs = [] self.lastBroadcast = json.dumps({"url":"http://alexwglenn.com/brady/gifs/Alex.gif"}); self.time = time.time() reactor.callLater(gifLoopTime, self.broadcastRandom, ())
def __init__(self, url, debug = False, debugCodePaths = False): WebSocketServerFactory.__init__(self, url, debug = debug, debugCodePaths = debugCodePaths) self.clients = [] self.tickcount = 0 self.tick() self.time = "0" self.status = "-1"
def __init__(self, config, templates): """ Ctor. :param factory: WAMP session factory. :type factory: An instance of .. :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, debug = config.get('debug', False)) ## transport configuration self._config = config ## Jinja2 templates for 404 etc self._templates = templates ## set WebSocket options set_websocket_options(self, options)
def RPCEndpoint(method, debug = False): "why the debug param? because " f = WebSocketServerFactory(debug = debug, debugCodePaths = debug ) f.setSessionParameters(externalPort = 8080) #bug in autobahn f.protocol = lambda: RPCProtocol(method) return WebSocketResource(f)
def __init__(self, url, debug = False, debugCodePaths = False): WebSocketServerFactory.__init__(self, url, debug = debug, debugCodePaths = debugCodePaths) self.clients = [] self.nao = Nao() self.tickcount = 0 #self.tick() self.measure()
def start(self, launchBrowser=True, useBackgroundThread=False, selectedTab="capture"): # Initialize the websocket, and gets its port factory = WebSocketServerFactory() factory.protocol = makeSanityWebSocketClass(self.localTargets, {}, {}) log.startLogging(sys.stdout) twistedData = reactor.listenTCP(0, factory) websocketPort = twistedData.socket.getsockname()[1] # Start the server that hosts the html / CSS / javascript server = SocketServer.TCPServer(("", 0), makeRunnerRequestHandler(websocketPort, selectedTab)) serverThread = threading.Thread(target=server.serve_forever) serverThread.daemon = True serverThread.start() serverPort = server.socket.getsockname()[1] url = "http://localhost:%d/" % serverPort print "Navigate to %s" % url if launchBrowser: webbrowser.open(url) # Begin listening on the websocket if useBackgroundThread: t = threading.Thread(target=reactor.run, kwargs={"installSignalHandlers": 0}) t.daemon = True t.start() else: reactor.run()
def debugWS(): factory = WebSocketServerFactory(u"ws://"+HOST+":"+str(WS_PORT_NUMBER)) factory.protocol = MyServerProtocol # factory.setProtocolOptions(maxConnections=2) reactor.listenTCP(WS_PORT_NUMBER, factory) reactor.run()
def __init__(self, url, debug=False, debugCodePaths=False, externalPort=None): WebSocketServerFactory.__init__(self, url, debug=debug, debugCodePaths=debugCodePaths, externalPort=externalPort) reactor.callLater(5, self.gc_conns) reactor.callLater(60, self.gc_users)
def _init(queue_in, queue_out): """Initialize the module.""" global INPUT, OUTPUT, FACTORY, UDP_THREAD LOGGER.info("Initializing...") INPUT = queue_in OUTPUT = queue_out FACTORY = WebSocketServerFactory() FACTORY.protocol = Server reactor.listenTCP(19113, FACTORY) LOGGER.info("Listening for remote instances of Samantha on the network.") remote_address = _wait_for_server_ip() if remote_address == (None, None): LOGGER.info("I'm alone on the network.") else: LOGGER.info("Remote instance found at %s:%s", remote_address[0], remote_address[1]) UDP_THREAD = UDPThread(name="udp_thread") UDP_THREAD.daemon = True LOGGER.info("Initialisation complete.") return True
def __init__(self, url, gameList, updateLobby, wampdispatch, gamechannel, debug = False, debugCodePaths = False): WebSocketServerFactory.__init__(self, url, debug = debug, \ debugCodePaths = debugCodePaths) self.gameList = gameList self.wampdispatch = wampdispatch self.gamechannel = gamechannel self.updateLobby = updateLobby
def create_server(app, port): ## # create a Twisted Web resource for our WebSocket server ## ws_factory = WebSocketServerFactory(u"ws://127.0.0.1:5000", debug=app.debug, debugCodePaths=app.debug) ws_factory.protocol = NotificationService ws_resource = WebSocketResource(ws_factory) ## # create a Twisted Web WSGI resource for our Flask server ## wsgi_resource = WSGIResource(reactor, reactor.getThreadPool(), app) ## # create a root resource serving everything via WSGI/Flask, but # the path "/ws" served by our WebSocket stuff ## root_resource = WSGIRootResource(wsgi_resource, {'notification-service': ws_resource}) ## # create a Twisted Web Site and run everything ## site = Site(root_resource) reactor.listenTCP(port, site) reactor.run()
def __init__(self, mease, host, port, debug): self.host = host self.port = port self.address = 'ws://{host}:{port}'.format(host=host, port=self.port) WebSocketServerFactory.__init__(self, self.address, debug=debug) self.storage = {} self.clients_list = set() self.mease = mease # Connect to subscriber logger.debug("Connecting to backend ({backend_name})...".format( backend_name=self.mease.backend.name)) self.mease.subscriber.connect() self.mease.subscriber.factory = self # Log registered callbacks logger.debug("Registered callback functions :") logger.debug( "Openers : [%s]" % self.mease._get_registry_names('openers')) logger.debug( "Closers : [%s]" % self.mease._get_registry_names('closers')) logger.debug( "Receivers : [%s]" % self.mease._get_registry_names('receivers')) logger.debug( "Senders : [%s]" % self.mease._get_registry_names('senders'))
def makeWebsocketProxyResource( proxy_url, proxied_ws_endpoint_str, proxied_url, request, origin=None, reactor=None, verbose=False): proxy_url = _strip_query(proxy_url) headers = dict((k, ' '.join(v)) for k, v in request.requestHeaders.getAllRawHeaders() if k in ['Cookie']) factory = WebSocketServerFactory( proxy_url, debug=False, debugCodePaths=False) factory.protocol = lambda : WSProxyProtocol( proxied_ws_endpoint_str, proxied_url, origin=origin, headers=headers, verbose=verbose, reactor=reactor, ) resource = WebSocketResource(factory) return resource
def runtime(server, port): import sys log.startLogging(sys.stdout) factory = WebSocketServerFactory("ws://" + server + ":" + str(port), debug=False) factory.protocol = NoFloUiProtocol factory.runtime = WebSocketRuntime() debug["factory"] = factory debug["runtime"] = factory.runtime debug["networks"] = factory.runtime.network.networks debug["graphs"] = factory.runtime.graph.graphs # Required for Chromium ~33 and newer def accept(offers): for offer in offers: if isinstance(offer, PerMessageDeflateOffer): return PerMessageDeflateOfferAccept(offer) factory.setProtocolOptions(perMessageCompressionAccept=accept) reactor.listenTCP(port, factory) if not reactor.running: reactor.run()
def __init__(self, url, debug = True): WebSocketServerFactory.__init__(self, url, debug = debug, debugCodePaths = debug) self.clients = [] self.tc = 0 self.tick()
def __init__(self, url, debug = False, debugCodePaths = False): WebSocketServerFactory.__init__(self, url, debug = debug, debugCodePaths = debugCodePaths) self.clients = [] self.tickcount = 0 self.tempstatus=None self.sprinkler_status=spinklercontrol() reactor.callLater(5, self.tick)
def __init__(self, *args, **kwargs): WebSocketServerFactory.__init__( self, *args, **kwargs ) # can't use super(); twisted and autobahn do not derive their classes from `object` self._listeners = [] PubSubBroker._brokers[PubSubBroker._unused_broker_id] = self # debug only! PubSubBroker._unused_broker_id += 1
def __init__(self, socket_url, debug=False, debugCodePaths=False): WebSocketServerFactory.__init__( self, socket_url, debug=debug, debugCodePaths=debugCodePaths ) self.subscribers = []
def __init__(self, url, debug=False, debugCodePaths=False): WebSocketServerFactory.__init__(self, url, debug=debug, debugCodePaths=debugCodePaths) self.clients = [] self.tickcount = 0 self.data = [self.datagen.next()] self.lastbroadcast = 0 self.tick() self.acquiredata()
def run(): log.startLogging(sys.stdout) factory = WebSocketServerFactory('ws://localhost:9002', debug=False) factory.protocol = TspServerProtocol reactor.listenTCP(9002, factory) reactor.run()
def __init__(self, url, mserver, kserver, only_ip="127.0.0.1", debug=False, debugCodePaths=False): WebSocketServerFactory.__init__(self, url, debug=debug, debugCodePaths=debugCodePaths) self.mserver = mserver self.kserver = kserver self.db = mserver.db self.outstanding_listings = {} self.outstanding_vendors = {} self.clients = [] self.only_ip = only_ip
def __init__(self, url): WebSocketServerFactory.__init__(self, url) self.clients = [] # Bind zmq sockets bridge.bind() # thread the bridges bridge.startThreads()
def __init__(self,debug, port): # self.task = task_queue # self.notein = notein_queue self.debug = debug self.clients = [] self.lastmsg = "" WebSocketServerFactory.__init__(self, "ws://localhost:"+str(port), debug = debug, debugCodePaths = debug)
def listen(self, listen_ws_url, tls_info=None): if listen_ws_url.startswith("wss") and not tls_info: return "must specify tls_info to listen with TLS" if tls_info: logging.info("listening with TLS %s" % tls_info) contextFactory = ssl.DefaultOpenSSLContextFactory( tls_info['key_file'], tls_info['cert_file'], sslmethod=tls_info['sslmethod']) if tls_info['cert_chain_file']: ctx = contextFactory.getContext() ctx.use_certificate_chain_file(tls_info['cert_chain_file']) factory = WebSocketServerFactory(listen_ws_url) factory.protocol = IncomingSocket factory.setProtocolOptions(openHandshakeTimeout=30, autoPingInterval=30, autoPingTimeout=5) factory.ms_protocol_layer = self factory.ms_shared_seed = None self.listener = listenWS(factory, contextFactory) else: logging.info("listening without TLS") port = int(listen_ws_url.split(":")[-1]) factory = WebSocketServerFactory(listen_ws_url) factory.protocol = IncomingSocket factory.ms_protocol_layer = self factory.ms_shared_seed = None self.listener = reactor.listenTCP(port, factory) return None
def __init__(self): self.clients = [] WebSocketServerFactory.__init__(self)
def __init__(self, url): WebSocketServerFactory.__init__(self, url) self.clients = [] self.tickcount = 0 self.tick()
def __init__(self, manager, port, secure=False, key_path=None, crt_path=None, unix_socket_path=None): self.manager = manager from twisted.internet import reactor, ssl from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol class MyServerProtocol(WebSocketServerProtocol): def __init__(self): WebSocketServerProtocol.__init__(self) self.widget_id = "" def onConnect(self, request): pass def onOpen(self): log.info("WebSocket connection open") def onMessage(self, payload, isBinary): if isBinary: log.info(f"Binary message received: {len(payload)} bytes") else: with DBManager.create_session_scope() as db_session: try: message = json.loads(payload) except: self.sendClose() return switcher = { "auth": self._auth, "next_song": self._next_song, "ready": self._ready } if ("event" in message and "data" in message and message["event"] in switcher and switcher[message["event"]]( db_session, message["data"])): pass else: self.sendClose() def onClose(self, wasClean, code, reason): log.info( f"WebSocket {self.widget_id} connection closed: {reason}") try: WebSocketServer.clients.remove(self) except: pass def _auth(self, db_session, data): if "salt" not in data: return False ws = WebSocket._by_salt(db_session, data["salt"]) if not ws: return False self.widget_id = ws.widget_id WebSocketServer.clients.append(self) return True def _next_song(self, db_session, data): if "salt" not in data: return False if not WebSocket._by_salt(db_session, data["salt"]): return False manager.bot.songrequest_manager.load_song() return True def _ready(self, db_session, data): if "salt" not in data: return False if not WebSocket._by_salt(db_session, data["salt"]): return False manager.bot.songrequest_manager.ready() return True factory = WebSocketServerFactory() factory.setProtocolOptions(autoPingInterval=15, autoPingTimeout=5) factory.protocol = MyServerProtocol def reactor_run(reactor, factory, port, context_factory=None, unix_socket_path=None): if unix_socket_path: sock_file = Path(unix_socket_path) if sock_file.exists(): sock_file.unlink() reactor.listenUNIX(unix_socket_path, factory) else: if context_factory: log.info("wss secure") reactor.listenSSL(port, factory, context_factory) else: log.info("ws unsecure") reactor.listenTCP(port, factory) if secure: context_factory = ssl.DefaultOpenSSLContextFactory( key_path, crt_path) else: context_factory = None reactor_thread = threading.Thread(target=reactor_run, args=(reactor, factory, port, context_factory, unix_socket_path), name="WebSocketThread") reactor_thread.daemon = True reactor_thread.start()
class RadiusServer(object): def __init__(self, config, db_engine=None, daemon=False): self.config = config self.db_engine = db_engine self.daemon = daemon self.tasks = {} self.init_config() self.init_timezone() self.init_db_engine() self.init_protocol() self.init_task() def _check_ssl_config(self): self.use_ssl = False self.privatekey = None self.certificate = None if self.config.has_option('DEFAULT', 'ssl') and self.config.getboolean( 'DEFAULT', 'ssl'): self.privatekey = self.config.get('DEFAULT', 'privatekey') self.certificate = self.config.get('DEFAULT', 'certificate') if os.path.exists(self.privatekey) and os.path.exists( self.certificate): self.use_ssl = True def init_config(self): self.logfile = self.config.get('radiusd', 'logfile') self.standalone = self.config.has_option('DEFAULT','standalone') and \ self.config.getboolean('DEFAULT','standalone') or False self.secret = self.config.get('DEFAULT', 'secret') self.timezone = self.config.has_option( 'DEFAULT', 'tz') and self.config.get('DEFAULT', 'tz') or "CST-8" self.debug = self.config.getboolean('DEFAULT', 'debug') self.authport = self.config.getint('radiusd', 'authport') self.acctport = self.config.getint('radiusd', 'acctport') self.adminport = self.config.getint('radiusd', 'adminport') self.radiusd_host = self.config.has_option('radiusd','host') \ and self.config.get('radiusd','host') or '0.0.0.0' #parse dictfile self.dictfile = os.path.join( os.path.split(__file__)[0], 'dicts/dictionary') if self.config.has_option('radiusd', 'dictfile'): if os.path.exists(self.config.get('radiusd', 'dictfile')): self.dictfile = self.config.get('radiusd', 'dictfile') # update aescipher utils.aescipher.setup(self.secret) self.encrypt = utils.aescipher.encrypt self.decrypt = utils.aescipher.decrypt #parse ssl self._check_ssl_config() def init_timezone(self): try: os.environ["TZ"] = self.timezone time.tzset() except: pass def init_db_engine(self): if not self.db_engine: self.db_engine = get_engine(self.config) self.store = Store(self.config, self.db_engine) def reload_coa_clients(self): for bas in self.store.list_bas(): if bas['ip_addr'] in self.coa_clients: self.coa_clients[bas['ip_addr']].close() self.coa_clients[bas['ip_addr']] = CoAClient(bas, dictionary.Dictionary( self.dictfile), debug=self.debug) def init_protocol(self): # rundata self.trace = utils.UserTrace() self.runstat = utils.RunStat() self.midware = middleware.Middleware() # init coa clients self.coa_clients = {} for bas in self.store.list_bas(): self.coa_clients[bas['ip_addr']] = CoAClient(bas, dictionary.Dictionary( self.dictfile), debug=self.debug) self.auth_protocol = RADIUSAccess(self) self.acct_protocol = RADIUSAccounting(self) ws_url = "ws://%s:%s" % (self.radiusd_host, self.adminport) if self.use_ssl: ws_url = "wss://%s:%s" % (self.radiusd_host, self.adminport) self.admin_factory = WebSocketServerFactory(ws_url, debug=False) self.admin_factory.protocol = AdminServerProtocol self.admin_factory.setProtocolOptions(allowHixie76=True) self.admin_factory.protocol.radiusd = self def _check_online_over(self): reactor.callInThread(self.store.check_online_over) def init_task(self): _task = task.LoopingCall(self.auth_protocol.process_delay) _task.start(2.7) _online_task = task.LoopingCall(self._check_online_over) _online_task.start(3600 * 4) _msg_stat_task = task.LoopingCall(self.runstat.run_stat) _msg_stat_task.start(60) self.tasks['process_delay'] = _task self.tasks['check_online_over'] = _online_task def run_normal(self): if self.debug: log.startLogging(sys.stdout) else: log.startLogging(DailyLogFile.fromFullPath(self.logfile)) log.msg('server listen %s' % self.radiusd_host) reactor.listenUDP(self.authport, self.auth_protocol, interface=self.radiusd_host) reactor.listenUDP(self.acctport, self.acct_protocol, interface=self.radiusd_host) if self.use_ssl: log.msg('WS SSL Enable!') from twisted.internet import ssl sslContext = ssl.DefaultOpenSSLContextFactory( self.privatekey, self.certificate) reactor.listenSSL(self.adminport, self.admin_factory, contextFactory=sslContext, interface=self.radiusd_host) else: reactor.listenTCP(self.adminport, self.admin_factory, interface=self.radiusd_host) if not self.standalone: reactor.run() def get_coa_client(self, nasaddr): cli = self.coa_clients.get(nasaddr) if not cli: bas = self.store.get_bas(nasaddr) if bas: cli = CoAClient(bas, dictionary.Dictionary(self.dictfile), debug=self.debug) self.coa_clients[nasaddr] = cli return cli def get_service(self): from twisted.application import service, internet top_service = service.MultiService() internet.UDPServer( self.authport, self.auth_protocol, interface=self.radiusd_host).setServiceParent(top_service) internet.UDPServer( self.acctport, self.acct_protocol, interface=self.radiusd_host).setServiceParent(top_service) if self.use_ssl: log.msg('WS SSL Enable!') from twisted.internet import ssl sslContext = ssl.DefaultOpenSSLContextFactory( self.privatekey, self.certificate) internet.SSLServer( self.adminport, self.admin_factory, contextFactory=sslContext, interface=self.radiusd_host).setServiceParent(top_service) else: log.msg('WS SSL Disable!') internet.TCPServer( self.adminport, self.admin_factory, interface=self.radiusd_host).setServiceParent(top_service) return top_service
} switch_modes = { "on": False, "off": True } class HWRouter(WebSocketServerProtocol): def onConnect(self, request): print("Client connected") def onMessage(self, payload, isBinary): message = payload.decode('utf8').split(":") action, device = message[0], message[1] GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) GPIO.setup(hw_pin_layout[message[1]], GPIO.OUT) GPIO.output(hw_pin_layout[message[1]], switch_modes[action]) def onClose(self, wasClean, code, reason): print("Connection closed") factory = WebSocketServerFactory("ws://localhost:5000", debug=False) factory.protocol = HWRouter reactor.listenTCP(5000, factory) reactor.run()
def __init__(self, url): WebSocketServerFactory.__init__(self, url) # this dict has a key for each channel # values are list of clients. self.workspace_clients = defaultdict(list) self.tick()
print("WebSocket connection request: {}".format(request)) def onMessage(self, payload, isBinary): self.sendMessage(payload, isBinary) if __name__ == '__main__': if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False factory = WebSocketServerFactory("ws://127.0.0.1:8080", debug=debug, debugCodePaths=debug) factory.protocol = EchoServerProtocol factory.setProtocolOptions( allowHixie76=True) # needed if Hixie76 is to be supported resource = WebSocketResource(factory) # we server static files under "/" .. root = File(".") # and our WebSocket server under "/ws" root.putChild("ws", resource) # both under one Twisted Web Site
def __init__(self, url, ruleEnvironment): WebSocketServerFactory.__init__(self, url) self.ruleEnvironment = ruleEnvironment
grabber_1.addCallback(dictionary_com__handler) grabber_1.addErrback(dictionary_com__fail) # This code runs unconditionally upon message. May trigger grabber 1. # GET webpage, and involke callback upon reciept of data grabber_2 = client.getPage( 'http://www.collinsdictionary.com/dictionary/english/' + payload) grabber_2.addCallback(collinsdictionary_com__handler) grabber_2.addErrback(collinsdictionary_com__fail) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) if __name__ == '__main__': import sys from twisted.python import log from twisted.internet import reactor log.startLogging(sys.stdout) factory = WebSocketServerFactory(u"ws://127.0.0.1:9000") factory.protocol = MyServerProtocol # factory.setProtocolOptions(maxConnections=2) reactor.listenTCP(9000, factory) reactor.run()
class Server(object): _DEFAULT_PORT = 9000 _DEFAULT_KEYS_PATH = "../resources/keys" class Notifier(QtCore.QObject): different_user_requested = QtCore.Signal(str, int) def __init__( self, keys_path, encrypt, host, user_id, host_aliases, port=None, uses_intermediate_certificate_chain=False, ): """ Constructor. :param keys_path: Path to the keys. If the path is relative, it will be relative to the current working directory. Mandatory :param encrypt: If True, the communication with clients will be encrypted. :param host: Url of the host we're expecting requests from. :param user_id: Id of the user we're expecting requests from. :param host_aliases: List of aliases available for the current host. :param port: Port to listen for websocket requests from. :param low_level_debug: If True, wss traffic will be written to the console. """ self._port = port or self._DEFAULT_PORT self._keys_path = keys_path or self._DEFAULT_KEYS_PATH self._host = host self._user_id = user_id self._host_aliases = host_aliases self._uses_intermediate_certificate_chain = uses_intermediate_certificate_chain # If encryption is required, compute a server id and retrieve the secret associated to it. if encrypt: # urandom is considered cryptographically secure as it calls the OS's CSRNG, so we can # use that to generate our own server id. self._ws_server_id = six.ensure_str( base64.urlsafe_b64encode(os.urandom(16))) else: self._ws_server_id = None self.notifier = self.Notifier() if not os.path.exists(keys_path): raise MissingCertificateError(keys_path) twisted = get_logger("twisted") logger.debug("Browser integration using certificates at %s", self._keys_path) logger.debug("Encryption: %s", encrypt) # This will take the Twisted logging and forward it to Python's logging. self._observer = log.PythonLoggingObserver(twisted.name) self._observer.start() def get_logger(self): """ :returns: The python logger root for the framework. """ return logger def _raise_if_missing_certificate(self, certificate_path): """ Raises an exception is a certificate file is missing. :param certificate_path: Path to the certificate file. :raises Exception: Thrown if the certificate file is missing. """ if not os.path.exists(certificate_path): raise MissingCertificateError("Missing certificate file: %s" % certificate_path) def _start_server(self): """ Start shotgun web server, listening to websocket connections. :param debug: Boolean Show debug output. Will also Start local web server to test client pages. """ cert_crt_path, cert_key_path = certificates.get_certificate_file_names( self._keys_path) self._raise_if_missing_certificate(cert_key_path) self._raise_if_missing_certificate(cert_crt_path) if self._uses_intermediate_certificate_chain: ctx_factory = ChainedOpenSSLContextFactory else: ctx_factory = ssl.DefaultOpenSSLContextFactory self.context_factory = ctx_factory(cert_key_path, cert_crt_path) # FIXME: Seems like the debugging flags are gone from the initializer at the moment. # We should try to restore these. self.factory = WebSocketServerFactory("wss://localhost:%d" % self._port) self.factory.protocol = ServerProtocol self.factory.host = self._host self.factory.host_aliases = self._host_aliases self.factory.user_id = self._user_id self.factory.notifier = self.notifier self.factory.ws_server_id = self._ws_server_id self.factory.setProtocolOptions(echoCloseCodeReason=True) try: self.listener = listenWS(self.factory, self.context_factory) except error.CannotListenError as e: raise PortBusyError(str(e)) def _start_reactor(self): """ Starts the reactor in a Python thread. """ def start(): reactor.run(installSignalHandlers=0) self._reactor_thread = threading.Thread(target=start) self._reactor_thread.start() def start(self): """ Start shotgun web server, listening to websocket connections. """ self._start_server() self._start_reactor() def is_running(self): """ :returns: True if the server is up and running, False otherwise. """ return self._reactor_thread.isAlive() def tear_down(self): """ Tears down Twisted. """ reactor.callFromThread(reactor.stop) self._reactor_thread.join()
def onOpen(self): print("WebSocket connection open.") def onMessage(self, payload, isBinary): if isBinary: print("Binary message received: {0} bytes".format(len(payload))) else: print("Text message received: {0}".format(payload.decode('utf8'))) # echo back message verbatim self.sendMessage(payload, isBinary) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) if __name__ == '__main__': import sys from twisted.python import log from twisted.internet import reactor log.startLogging(sys.stdout) factory = WebSocketServerFactory("ws://localhost:9000", debug=False) factory.protocol = MyServerProtocol # factory.setProtocolOptions(maxConnections=2) reactor.listenTCP(9000, factory) reactor.run()
if __name__ == '__main__': if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False wsPort = 9000 # Our WebSocket server ## factory = WebSocketServerFactory(u"ws://127.0.0.1:%d" % wsPort, debug=debug, debugCodePaths=debug) factory.protocol = EchoServerProtocol listenWS(factory) # We need to start a "Flash Policy Server" on TCP/843 # which Adobe Flash player will contact to check if # it is allowed to connect to the WebSocket port. ## flashPolicyFactory = FlashPolicyFactory() reactor.listenTCP(843, flashPolicyFactory) # Static Web server ## webdir = File("./web")
def __init__(self, url): WebSocketServerFactory.__init__(self, url) self.client = None
else: yield sleep(1) returnValue(x * x) @inlineCallbacks def onMessage(self, payload, isBinary): if not isBinary: x = json.loads(payload.decode('utf8')) try: res = yield self.slowsquare(x) except Exception as e: self.sendClose(1000, "Exception raised: {0}".format(e)) else: self.sendMessage(json.dumps(res).encode('utf8')) if __name__ == '__main__': import sys from twisted.python import log from twisted.internet import reactor log.startLogging(sys.stdout) factory = WebSocketServerFactory(u"ws://127.0.0.1:9000") factory.protocol = SlowSquareServerProtocol reactor.listenTCP(9000, factory) reactor.run()
from twisted.python import log from twisted.web.server import Site from twisted.web.static import File from autobahn.twisted.websocket import WebSocketServerFactory, \ WebSocketServerProtocol, \ listenWS from autobahn.twisted.resource import WebSocketResource if __name__ == '__main__': log.startLogging(sys.stdout) factory = WebSocketServerFactory("ws://localhost:9000", debug=False, debugCodePaths=True) factory.protocol = WebSocketServerProtocol factory.setProtocolOptions(autoPingInterval=1, autoPingTimeout=3, autoPingSize=20) listenWS(factory) resource = WebSocketResource(factory) root = File(".") root.putChild("ws", resource) site = Site(root) reactor.listenTCP(8080, site) reactor.run()
def create_log_streaming_resource(): factory = WebSocketServerFactory() factory.protocol = TokenAuthenticatedWebSocketServerProtocol return WebSocketResource(factory)
def __init__(self, master): WebSocketServerFactory.__init__(self) self.master = master
def __init__(self, uri, debug=False, assets='./'): WebSocketServerFactory.__init__(self, uri, debug=debug) self._peers = WeakKeyDictionary() self.assets = assets
def onConnect(self, request): print("WebSocket connection request by {}".format(request.peer)) def onOpen(self): print("WebSocket extensions in use: {}".format(self.websocket_extensions_in_use)) def onMessage(self, payload, isBinary): self.sendMessage(payload, isBinary) if __name__ == '__main__': log.startLogging(sys.stdout) factory = WebSocketServerFactory("ws://127.0.0.1:9000") factory.protocol = EchoServerProtocol # Enable WebSocket extension "permessage-deflate". # Function to accept offers from the client .. def accept(offers): for offer in offers: if isinstance(offer, PerMessageDeflateOffer): return PerMessageDeflateOfferAccept(offer) factory.setProtocolOptions(perMessageCompressionAccept=accept) # run server listenWS(factory)
(epoch_time, int(data_parsed[2]))) sensor2.commit() if data_parsed[0] == "USERDATA": if data_parsed[1] in webClients: webClients[data_parsed[1]].sendMessage(data_parsed[2] + "-" + data_parsed[3]) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) if __name__ == '__main__': import sys from twisted.python import log from twisted.internet import reactor log.startLogging(sys.stdout) factory = WebSocketServerFactory(u"ws://sp.ebiw.com:9000") factory.protocol = MyServerProtocol reactor.listenTCP(9000, factory) reactor.run() sensor1.close() sensor2.close()
from autobahn.twisted.resource import WebSocketResource class EchoServerProtocol(WebSocketServerProtocol): def onMessage(self, payload, isBinary): self.sendMessage(payload, isBinary) if __name__ == '__main__': log.startLogging(sys.stdout) contextFactory = ssl.DefaultOpenSSLContextFactory('keys/server.key', 'keys/server.crt') factory = WebSocketServerFactory(u"wss://127.0.0.1:8080") factory.protocol = EchoServerProtocol resource = WebSocketResource(factory) # we server static files under "/" .. root = File(".") # and our WebSocket server under "/ws" (note that Twisted uses # bytes for URIs) root.putChild(b"ws", resource) # both under one Twisted Web Site site = Site(root) reactor.listenSSL(8080, site, contextFactory)
action="store_true", help="Enable debug output.") parser.add_argument( "--endpoint", default="tcp:8080", help= 'WebSocket server Twisted endpoint descriptor, e.g. "tcp:127.0.0.1:8080" or "unix:/tmp/mywebsocket".' ) parser.add_argument( "--url", default=u"ws://localhost:8080/ws", help= 'WebSocket URL (must suit the endpoint), e.g. ws://localhost:8080/ws.') args = parser.parse_args() if args.debug: txaio.start_logging(level='debug') else: txaio.start_logging(level='info') factory = WebSocketServerFactory(args.url, reactor=reactor) factory.protocol = MyServerProtocol server = serverFromString(reactor, args.endpoint) server.listen(factory) reactor.run()
def __init__(self, chute, *args, **kwargs): WebSocketServerFactory.__init__(self, *args, **kwargs) self.chute = chute
def connection_main(sysargs=None, use_files=True): """Main entry point to setup a connection node, aka the autopush script""" args, parser = _parse_connection(sysargs, use_files) log_format = "text" if args.human_logs else "json" log_level = args.log_level or ("debug" if args.debug else "info") sentry_dsn = bool(os.environ.get("SENTRY_DSN")) PushLogger.setup_logging( "Autopush", log_level=log_level, log_format=log_format, log_output=args.log_output, sentry_dsn=sentry_dsn, firehose_delivery_stream=args.firehose_stream_name) settings = make_settings( args, port=args.port, endpoint_scheme=args.endpoint_scheme, endpoint_hostname=args.endpoint_hostname, endpoint_port=args.endpoint_port, router_scheme="https" if args.router_ssl_key else "http", router_hostname=args.router_hostname, router_port=args.router_port, env=args.env, hello_timeout=args.hello_timeout, ) r = RouterHandler r.ap_settings = settings n = NotificationHandler n.ap_settings = settings # Internal HTTP notification router site = cyclone.web.Application([ (r"/push/([^\/]+)", r), (r"/notif/([^\/]+)(/([^\/]+))?", n), ], default_host=settings.router_hostname, debug=args.debug, log_function=skip_request_logging) mount_health_handlers(site, settings) # Public websocket server proto = "wss" if args.ssl_key else "ws" factory = WebSocketServerFactory( "%s://%s:%s/" % (proto, args.hostname, args.port), ) factory.protocol = PushServerProtocol factory.protocol.ap_settings = settings factory.setProtocolOptions( webStatus=False, openHandshakeTimeout=5, autoPingInterval=args.auto_ping_interval, autoPingTimeout=args.auto_ping_timeout, maxConnections=args.max_connections, closeHandshakeTimeout=args.close_handshake_timeout, ) settings.factory = factory settings.metrics.start() # Wrap the WebSocket server in a default resource that exposes the # `/status` handler, and delegates to the WebSocket resource for all # other requests. resource = DefaultResource(WebSocketResource(factory)) resource.putChild("status", StatusResource()) siteFactory = Site(resource) # Start the WebSocket listener. if args.ssl_key: contextFactory = AutopushSSLContextFactory(args.ssl_key, args.ssl_cert) if args.ssl_dh_param: contextFactory.getContext().load_tmp_dh(args.ssl_dh_param) reactor.listenSSL(args.port, siteFactory, contextFactory) else: reactor.listenTCP(args.port, siteFactory) # Start the internal routing listener. if args.router_ssl_key: contextFactory = AutopushSSLContextFactory(args.router_ssl_key, args.router_ssl_cert) if args.ssl_dh_param: contextFactory.getContext().load_tmp_dh(args.ssl_dh_param) reactor.listenSSL(args.router_port, site, contextFactory) else: reactor.listenTCP(args.router_port, site) reactor.suggestThreadPoolSize(50) l = task.LoopingCall(periodic_reporter, settings) l.start(1.0) # Start the table rotation checker/updater l = task.LoopingCall(settings.update_rotating_tables) l.start(60) reactor.run()
"w": w, "h": h, "ex": ex, "ey": ey, "ew": ew, "eh": eh } allEyes.append(eyeDict) #cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2) eyesDto = json.dumps(allEyes) self.sendMessage(eyesDto) #self.sendMessage("got it!", isBinary) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {0}".format(reason)) if __name__ == '__main__': import sys from twisted.python import log from twisted.internet import reactor log.startLogging(sys.stdout) factory = WebSocketServerFactory(u"ws://127.0.0.1:9000") factory.protocol = GooglySocketProtocol reactor.listenTCP(9000, factory) reactor.run()
): #Multiple Image displaying algorithms can be added below #Replace your own code here. Below is a simple example img = cv2.imread('res/facetest.jpg') #The code below sends the image to the Image viewer. DO NOT DELETE #the image is passed to the encoder as img, you can pass any other image matrix encode_param = [1, 90] res, image = cv2.imencode('.jpg', img, encode_param) sample = base64.b64encode(image) self.sendMessage(sample, isBinary) #if (message == '2'): #add extra algorithm like this def onClose(self, wasClean, code, reason): #Message displayed when there is an error print format(reason) #Start Websocket Server if __name__ == '__main__': import sys from twisted.internet import reactor factory = WebSocketServerFactory( "ws://localhost:5555") #Set debug false to save on processing time factory.protocol = MyServerProtocol reactor.listenTCP(5555, factory) reactor.run()
if __name__ == '__main__': if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False # SSL server context: load server key and certificate # We use this for both WS and Web! # contextFactory = ssl.DefaultOpenSSLContextFactory('keys/server.key', 'keys/server.crt') factory = WebSocketServerFactory(u"wss://127.0.0.1:9000", debug=debug, debugCodePaths=debug) factory.protocol = EchoServerProtocol listenWS(factory, contextFactory) webdir = File(".") webdir.contentTypes['.crt'] = 'application/x-x509-ca-cert' web = Site(webdir) # reactor.listenSSL(8080, web, contextFactory) reactor.listenTCP(8080, web) reactor.run()
def __init__(self, update, *args, **kwargs): WebSocketServerFactory.__init__(self, *args, **kwargs) self.update = update
def __init__(self, url, bridge): WebSocketServerFactory.__init__(self, url) self.frame = None self.connections = {} self.bridge = bridge self.rec = Recognition()