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)
def startService(self): factory = WebSocketServerFactory(u"ws://127.0.0.1:%d" % self.port) factory.protocol = EchoServerProtocol # 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" (note that Twisted uses # bytes for URIs) root.putChild(b"ws", resource) # both under one Twisted Web Site site = Site(root) self.site = site self.factory = factory self.listener = reactor.listenTCP(self.port, site)
def main(curDir): class WhiteboardServerProtocol(WebSocketServerProtocol): def onConnect(self, connectionRequest): whiteboard.addClient(self) return None def onMessage(self, msg, binary): whiteboard.processMessage(self, msg) os.chdir(curDir) #log.startLogging(sys.stdout) debugWS = False debugWhiteboard = False whiteboard = WhiteboardServer(debugWhiteboard) factory = WebSocketServerFactory("ws://localhost:9000", debug = debugWS, debugCodePaths = debugWS) factory.protocol = WhiteboardServerProtocol #factory.setProtocolOptions(allowHixie76 = True) listenWS(factory) webdir = File(".") web = Site(webdir) reactor.listenTCP(8080, web) #threading.Thread(None, reactor.run, None).start() print "Starting websocket server" reactor.run() whiteboard.shutdown()
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)
def main(): """ Main method for the websocket server """ LOG.info('main: Start') udp_steward = UDPConnectionSteward() udp_steward.start() # Uncomment these two to get log from twisted #import sys #log.startLogging(sys.stdout) # Create context factor with key and certificate context_factory = ssl.DefaultOpenSSLContextFactory( '/home/kenni/Dokumenter/websockets/autobahn/keys/server.key', '/home/kenni/Dokumenter/websockets/autobahn/keys/server.crt' ) # Form the webserver factory factory = WebSocketServerFactory("wss://localhost:9001", debug=True) # Set the handler factory.protocol = CinfWebSocketHandler # Listen for incoming WebSocket connections: wss://localhost:9001 listenWS(factory, context_factory) try: reactor.run() # pylint: disable=E1101 time.sleep(1) LOG.info('main: Keyboard interrupt, websocket reactor stopped') udp_steward.stop() time.sleep(1) LOG.info('main: UPD Steward stopped') except Exception as exception_: LOG.exception(exception_) raise exception_ LOG.info('main: Ended') raw_input('All stopped. Press enter to exit')
def startService(self): factory = WebSocketServerFactory("ws://127.0.0.1:%d" % self.port) factory.protocol = EchoServerProtocol # 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" (note that Twisted uses # bytes for URIs) root.putChild(b"ws", resource) # both under one Twisted Web Site site = Site(root) self.site = site self.factory = factory self.listener = reactor.listenTCP(self.port, site)
def main(curDir): class WhiteboardServerProtocol(WebSocketServerProtocol): def onConnect(self, connectionRequest): whiteboard.addClient(self) return None def onMessage(self, msg, binary): whiteboard.processMessage(self, msg) os.chdir(curDir) #log.startLogging(sys.stdout) debugWS = False debugWhiteboard = False whiteboard = WhiteboardServer(debugWhiteboard) factory = WebSocketServerFactory("ws://localhost:9000", debug=debugWS, debugCodePaths=debugWS) factory.protocol = WhiteboardServerProtocol #factory.setProtocolOptions(allowHixie76 = True) listenWS(factory) webdir = File(".") web = Site(webdir) reactor.listenTCP(8080, web) #threading.Thread(None, reactor.run, None).start() print "Starting websocket server" reactor.run() whiteboard.shutdown()
def serve_wss(self): """Start a web socket server over SSL, used by the web UI to get notifications about updates.""" import os from .events import SystemEvent # Start a web socket server if the web UI is enabled if not self._config['web-ui-enabled']: return if not self._config['wss-enabled']: return if not os.path.isfile(self._config['ssl-cert']): self._startup_event.log_critical("Unable to activate SSL: File does not exist: %s" % self._config['ssl-cert']) return try: import os from autobahn.websocket import WebSocketServerProtocol, WebSocketServerFactory from twisted.internet import reactor, ssl from twisted.internet.error import BindError # Create a WebSocketClientHandler instance WebSocketClientHandler = WebSocketClientHandlerFactory(self._config, self._ws_clients, self._event_store, self._server_status) uri = u"ws://%s:%s" % (self._config['wss-host'], self._config['wss-port']) factory = WebSocketServerFactory(uri) factory.protocol = WebSocketClientHandler # factory.setProtocolOptions(maxConnections=2) # note to self: if using putChild, the child must be bytes... if self._config['ssl-key'] and self._config['ssl-cert']: contextFactory = ssl.DefaultOpenSSLContextFactory(privateKeyFileName=self._config['ssl-key'], certificateFileName=self._config['ssl-cert']) else: contextFactory = ssl.DefaultOpenSSLContextFactory(privateKeyFileName=self._config['ssl-cert'], certificateFileName=self._config['ssl-cert']) self._ws_server_port = reactor.listenSSL(self._config['wss-port'], factory, contextFactory) # self._ws_server_port = reactor.listenTCP(self._config['wss-port'], factory) self._server_status['wss-uri'] = "wss://%s:%s" % (self._config['wss-host'], self._config['wss-port']) self._startup_event.log_info("Listening for connections on %s" % self._server_status['wss-uri']) self._startup_event.ws_address = self._config['wss-host'] self._startup_event.ws_port = self._config['wss-port'] self._startup_event.set_ws_started(True) # Serve forever (until reactor.stop()) reactor.run(installSignalHandlers=False) except BindError as e: self._startup_event.log_critical("Unable to start web socket server: %s" % e) except ImportError: self._startup_event.log_error("Unable to start web socket server due to missing dependency.") event = SystemEvent() self._event_store.register_action(event) event.log_info('WSS server did quit')
def main(): log.startLogging(sys.stdout) factory = WebSocketServerFactory("ws://localhost:9000", debug = False) factory.protocol = EchoServerProtocol listenWS(factory) reactor.run()
def __init__(self): global kwizz kwizz=self self.players=[] self.games=[] factory = WebSocketServerFactory("ws://localhost:9000", debug = False) factory.protocol = KwizzLiveProtocol reactor.listenTCP(9000, factory) reactor.run()
def serve_wss(self): """Start a web socket server over SSL, used by the web UI to get notifications about updates.""" import os from .events import SystemEvent from autobahn.websocket import WebSocketServerProtocol, WebSocketServerFactory from twisted.internet import reactor from twisted.internet.error import BindError # Start a web socket server if the web UI is enabled if not self._config['web-ui-enabled']: return if not self._config['wss-enabled']: return if not os.path.isfile(self._config['ssl-cert']): self._startup_event.log_critical("Unable to activate SSL: File does not exist: %s" % self._config['ssl-cert']) return from twisted.internet import ssl try: # Create a WebSocketClientHandler instance WebSocketClientHandler = WebSocketClientHandlerFactory(self._config, self._ws_clients, self._event_store, self._server_status) uri = u"ws://%s:%s" % (self._config['wss-host'], self._config['wss-port']) factory = WebSocketServerFactory(uri) factory.protocol = WebSocketClientHandler # factory.setProtocolOptions(maxConnections=2) # note to self: if using putChild, the child must be bytes... if self._config['ssl-key'] and self._config['ssl-cert']: contextFactory = ssl.DefaultOpenSSLContextFactory(privateKeyFileName=self._config['ssl-key'], certificateFileName=self._config['ssl-cert']) else: contextFactory = ssl.DefaultOpenSSLContextFactory(privateKeyFileName=self._config['ssl-cert'], certificateFileName=self._config['ssl-cert']) self._ws_server_port = reactor.listenSSL(self._config['wss-port'], factory, contextFactory) self._server_status['wss-uri'] = "wss://%s:%s" % (self._config['wss-host'], self._config['wss-port']) self._startup_event.log_info(u"Escutando conexões em %s" % self._server_status['wss-uri']) self._startup_event.ws_address = self._config['wss-host'] self._startup_event.ws_port = self._config['wss-port'] self._startup_event.set_ws_started(True) # Serve forever (until reactor.stop()) reactor.run(installSignalHandlers=False) except BindError as e: self._startup_event.log_critical("Unable to start web socket server: %s" % e) except ImportError: self._startup_event.log_error("Unable to start web socket server due to missing dependency.") event = SystemEvent() self._event_store.register_action(event) event.log_info('WSS server did quit')
def startServer(): output = getoutput('ifconfig wlan0') if 'inet addr:' in output: print 'wlan0 already connected!' return factory = WebSocketServerFactory(u"ws://127.0.0.1:9000") factory.protocol = SetupWifiWebsocketProtocol reactor.listenTCP(9000, factory) reactor.run()
def run ( self ): log.startLogging(sys.stdout) factory = WebSocketServerFactory("ws://localhost:9000", debug = False) factory.protocol = PushServerProtocol listenWS(factory) reactor.run()
def main(): parser = argparse.ArgumentParser() parser.add_argument("-p", "--port", metavar="PORT=3000", type=int, default=3000) myapp.setup_argparser(parser) args = parser.parse_args() myapp.setup_app(args) factory = WebSocketServerFactory("ws://localhost:%d" % args.port) factory.protocol = WebSocketWrapperProtocol root = Root() root.putChild("ws", WebSocketResource(factory)) reactor.listenTCP(args.port, Site(root)) reactor.run()
def start_server(port, appmanager, protocol, apprate, netrate): port = 9999 manager = Manager(appmanager, apprate, netrate) # TODO remove manager = ? DefaultConnection.__bases__ += (Protocol, protocol, Sender) # WTF inheritance echofactory = Factory() echofactory.protocol = DefaultConnection reactor.listenTCP(port, echofactory) # WEBSOOOOOCKKEEEET WSConnection.__bases__ += (WebSocketServerProtocol, protocol, Sender) factory = WebSocketServerFactory("ws://localhost:" + str(port + 1)) factory.protocol = WSConnection listenWS(factory) print "Server initialized" reactor.run()
def getAutoBahn(core, port=80): #from twisted.python import log as tlog #tlog.startLogging(sys.stdout) wsuri = "ws://localhost" if not port in ['80','443']: wsuri+=":"+str(port) #factory = WebSocketServerFactory(wsuri, debug=True, debugCodePaths=True) factory = WebSocketServerFactory(wsuri) factory.core = core factory.protocol = AutobahnProtocolWrapper factory.setProtocolOptions(allowHixie76 = True) resource = WebSocketResource(factory) log.debug("AutoBahn started") return resource
def start_web(localEPG=None, playout_service=None, playout=None, port=8888, schedule=None): root = File('web') if schedule: root.putChild("schedules", SchedulesPage(schedule)) root.putChild("player_snapshots", File('cache/snapshots')) root.putChild("stills", StillsListPage("stills")) wrapper = simple_guard_resource(root) site = Site(wrapper) reactor.listenTCP(port, site) factory = WebSocketServerFactory() factory.protocol = lambda: PlayoutWebsocketProtocol (playout_service, playout, schedule) reactor.listenTCP(8889, factory) """
def _setUpListener(self, serviceName, port, protocol, handler=None): url = "ws://localhost:%d"%(port) factory = WebSocketServerFactory(url, debug=True, debugCodePaths=True) factory.protocol = protocol factory.setProtocolOptions(allowHixie76=True) #HACK: add an array for observing messages factory.observers = [] #called for every message; for the ui to listen if handler !=None: factory.observers.append(handler) factory.connections = [] #all connections that are active; for the protocol to send data self.frontEndListeners[serviceName] = factory listenWS(self.frontEndListeners[serviceName])
def main(): """ Main method for the websocket server """ # Uncomment these two to get log from twisted #import sys #log.startLogging(sys.stdout) # Create context factor with key and certificate # Start UDP server thread udp_server = ReceiveDataUDPServer() udp_server.start() # Start load monitor thread load_monitor = LoadMonitor() load_monitor.start() # Start the data sender thread data_sender = DataSender() data_sender.start() ####### SSL IMPLEMENTATION context_factory = ssl.DefaultOpenSSLContextFactory( '/home/kenni/certs/fysik.dtu.dk.key', '/home/kenni/certs/fysik.dtu.dk-NEW.crt' ) # Form the webserver factory factory = WebSocketServerFactory("wss://localhost:9002", debug=True) # Set the handler factory.protocol = CinfWebSocketHandler # Listen for incoming WebSocket connections: wss://localhost:9002 listenWS(factory, context_factory) ######## SSL IMPLEMENTATION END try: LOG.info('run reactor') reactor.run() # pylint: disable=E1101 except Exception as exception_: LOG.exception(exception_) raise exception_ # Stop all three threads udp_server.stop() load_monitor.stop() data_sender.stop() LOG.info('main: Ended') #raw_input('All stopped. Press enter to exit') print('All stopped. Press enter to exit')
def serve_ws(self): """Start a web socket server, used by the web UI to get notifications about updates.""" import os from .events import SystemEvent from autobahn.websocket import WebSocketServerProtocol, WebSocketServerFactory from twisted.internet import reactor from twisted.internet.error import BindError # Start a web socket server if the web UI is enabled if not self._config['web-ui-enabled']: return if not self._config['ws-enabled']: return try: # Create a WebSocketClientHandler instance WebSocketClientHandler = WebSocketClientHandlerFactory(self._config, self._ws_clients, self._event_store, self._server_status) uri = u"ws://%s:%s" % (self._config['ws-host'], self._config['ws-port']) factory = WebSocketServerFactory(uri) factory.protocol = WebSocketClientHandler # factory.setProtocolOptions(maxConnections=2) self._ws_server_port = reactor.listenTCP(self._config['ws-port'], factory) self._server_status['wss-uri'] = "ws://%s:%s" % (self._config['ws-host'], self._config['ws-port']) self._startup_event.log_info(u"Escutando conexões em %s" % self._server_status['wss-uri']) self._startup_event.ws_address = self._config['ws-host'] self._startup_event.ws_port = self._config['ws-port'] self._startup_event.set_ws_started(True) # Serve forever (until reactor.stop()) reactor.run(installSignalHandlers=False) except BindError as e: self._startup_event.log_critical("Unable to start web socket server: %s" % e) except ImportError: self._startup_event.log_error("Unable to start web socket server due to missing dependency.") event = SystemEvent() self._event_store.register_action(event) event.log_info('WS server did quit')
def main(): try: #initializing serial flashing etc utilities socket ServerFactory = BroadcastServerFactory factory = ServerFactory("ws://localhost:9000") # factory = WebSocketServerFactory("ws://localhost:9000", debug = False) factory.protocol = EchoServerProtocol listenWS(factory) factory2 = WebSocketServerFactory("ws://localhost:9001") factory2.protocol = WebSerialProtocol listenWS(factory2) reactor.run() except error.CannotListenError, e: print "Port is already used. Exiting..." os._exit(0)
def main(): """ Main method for the websocket server """ LOG.info('main: Start') global LIVESOCKET # pylint: disable=global-statement names = ['wss_hosts_defined', 'wss_hosts', 'wss_clients'] LIVESOCKET = LiveSocket('websocketserver', names, sane_interval=1.0) LIVESOCKET.start() udp_steward = UDPConnectionSteward() udp_steward.start() # Uncomment these two to get log from twisted #import sys #log.startLogging(sys.stdout) # Create context factor with key and certificate context_factory = ssl.DefaultOpenSSLContextFactory( '/home/kenni/certs/fysik.dtu.dk.key', '/home/kenni/certs/fysik.dtu.dk-NEW.crt' ) # Form the webserver factory factory = WebSocketServerFactory("wss://localhost:9001", debug=True) # Set the handler factory.protocol = CinfWebSocketHandler # Listen for incoming WebSocket connections: wss://localhost:9001 listenWS(factory, context_factory) try: reactor.run() # pylint: disable=E1101 time.sleep(1) LOG.info('main: Keyboard interrupt, websocket reactor stopped') udp_steward.stop() time.sleep(1) LOG.info('main: UPD Steward stopped') LIVESOCKET.stop() time.sleep(1) LOG.info('main: Own livesocket stoppped') except Exception as exception_: LOG.exception(exception_) raise exception_ LOG.info('main: Ended') raw_input('All stopped. Press enter to exit')
def main(): """ Main method for the websocket server """ LOG.info('main: Start') global LIVESOCKET # pylint: disable=global-statement names = ['wss_hosts_defined', 'wss_hosts', 'wss_clients'] LIVESOCKET = LiveSocket('websocketserver', names, sane_interval=1.0) LIVESOCKET.start() udp_steward = UDPConnectionSteward() udp_steward.start() # Uncomment these two to get log from twisted #import sys #log.startLogging(sys.stdout) # Create context factor with key and certificate context_factory = ssl.DefaultOpenSSLContextFactory( '/home/kenni/certs/fysik.dtu.dk.key', '/home/kenni/certs/fysik.dtu.dk.crt' ) # Form the webserver factory factory = WebSocketServerFactory("wss://localhost:9001", debug=True) # Set the handler factory.protocol = CinfWebSocketHandler # Listen for incoming WebSocket connections: wss://localhost:9001 listenWS(factory, context_factory) try: reactor.run() # pylint: disable=E1101 time.sleep(1) LOG.info('main: Keyboard interrupt, websocket reactor stopped') udp_steward.stop() time.sleep(1) LOG.info('main: UPD Steward stopped') LIVESOCKET.stop() time.sleep(1) LOG.info('main: Own livesocket stoppped') except Exception as exception_: LOG.exception(exception_) raise exception_ LOG.info('main: Ended') raw_input('All stopped. Press enter to exit')
def main(argv): try: opts, args = getopt.getopt(argv, 'h', ['help']) except getopt.GetoptError: usage() for opt, val in opts: if opt in ('-h', '--help'): usage() print 'The count server is gonna start ...' factory = WebSocketServerFactory('ws://localhost:9000') factory.protocol = CountServerProtocol listenWS(factory) reactor.callWhenRunning(countForEver) reactor.run()
for data in payload: l += len(data) self.sha256.update(data) digest = self.sha256.hexdigest() print "Received frame with payload length %7d, compute digest: %s" % ( l, digest) self.sendMessage(digest) def onMessageEnd(self): self.sha256 = None if __name__ == '__main__': factory = WebSocketServerFactory("ws://localhost:9000") factory.protocol = FrameBasedHashServerProtocol enableCompression = True if enableCompression: from autobahn.compress import PerMessageDeflateOffer, \ PerMessageDeflateOfferAccept ## 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) listenWS(factory)
def onMessage(self, msg, binary): self.sendMessage("Echo 2 - " + msg) if __name__ == '__main__': if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False factory1 = WebSocketServerFactory("ws://localhost:9000", debug=debug, debugCodePaths=debug) factory1.protocol = Echo1ServerProtocol resource1 = WebSocketResource(factory1) factory2 = WebSocketServerFactory("ws://localhost:9000", debug=debug, debugCodePaths=debug) factory2.protocol = Echo2ServerProtocol resource2 = WebSocketResource(factory2) ## Establish a dummy root resource root = Data("", "text/plain") ## and our WebSocket servers under different paths .. root.putChild("echo1", resource1) root.putChild("echo2", resource2)
def isTyping(self): self.chatWith.sendMessage("typ:\n") def isNotTyping(self): self.chatWith.sendMessage("pyt:\n") def message(self, message): self.sendMessage("ann:" + message + '\n') def chatAll(self, message): self.sendMessage("out:" + message + '\n') self.chatWith.sendMessage("in:" + message + '\n') def messageAll(self, message): self.sendMessage("ann:" + message + '\n') self.chatWith.sendMessage("ann:" + message + '\n') def enableAll(self, message): self.sendMessage("con:" + message + '\n') self.chatWith.sendMessage("con:" + message + '\n') urlString = "ws://localhost:" + port factory = WebSocketServerFactory(urlString) factory.protocol = Chat factory.unusedClients = [] factory.chatting = [] listenWS(factory) print "Chat server started in port " + port log.msg("Chat server started in port " + port) reactor.run()
from twisted.internet import reactor, ssl from autobahn.websocket import WebSocketServerFactory, WebSocketServerProtocol, listenWS class WebSocketTestServerProtocol(WebSocketServerProtocol): def onMessage(self, msg, binary): self.sendMessage(msg, binary) if __name__ == '__main__': log.startLogging(sys.stdout) ## SSL server context: load server key and certificate ## contextFactory = ssl.DefaultOpenSSLContextFactory('keys/server.key', 'keys/server.crt') ## create a WS server factory with our protocol ## factory = WebSocketServerFactory("wss://localhost:9000", debug = False) factory.setProtocolOptions(failByDrop = False) factory.protocol = WebSocketTestServerProtocol ## Listen for incoming WebSocket connections: wss://localhost:9000 ## listenWS(factory, contextFactory) log.msg("Using Twisted reactor class %s" % str(reactor.__class__)) reactor.run()
reactor.stop() ## Handle the CTRL+C signal to shutdown signal.signal(signal.SIGINT, KeyboardInterruptHandler) ## Create and initialize the NeoPixel library logger.info('Loading NeoPixel library...') neopixelStrip = neopixel.Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS) neopixelStrip.begin() ## Startup animation colorWhite = neopixel.Color(255, 255, 255) colorBlack = neopixel.Color(0, 0, 0) slideFromLeft(neopixelStrip, colorWhite) slideFromRight(neopixelStrip, colorBlack) slideFromRight(neopixelStrip, colorWhite) pulseBrightness(neopixelStrip, 255, 10) logger.info('Starting websocket server...') factory = WebSocketServerFactory('ws://' + GATEWAY_ADDRESS + ':' + str(GATEWAY_PORT), debug=False) factory.protocol = VibeLightGatewayProtocol logger.info('Listening...') reactor.listenTCP(GATEWAY_PORT, factory) reactor.run()
p = Popen(["python", "fsclient.py", str(SERVERS_PORT[index]), msg], stdout=PIPE, stdin=PIPE, stderr=STDOUT) result = p.communicate()[0] self.sendMessage(result) elif typeMsg == '[R]': index = self.__balancer_read(file_name) print "[R][%s] Read %s file from DFS" % (time.strftime("%H:%M:%S"), file_name) p = Popen(["python", "fsclient.py", str(SERVERS_PORT[index]), msg], stdout=PIPE, stdin=PIPE, stderr=STDOUT) result = p.communicate()[0] self.sendMessage(result) if __name__ == '__main__': import sys if len(sys.argv) < 2: sys.exit("Using server.py [SERVERS]") factory = WebSocketServerFactory("ws://" + ADDRESS + ":" + str(PORT), debug=False) SERVERS = int(sys.argv[1]) factory.protocol = DFS listenWS(factory) print 'Server starting up on %s port %s' % (ADDRESS, PORT) reactor.run()
self.send_hello = False if __name__ == '__main__': log.startLogging(sys.stdout) ## 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') ## create a WS server factory with our protocol ## factory = WebSocketServerFactory("wss://localhost:9000", debug = False) factory.protocol = EchoServerProtocol ## Listen for incoming WebSocket connections: wss://localhost:9000 ## listenWS(factory, contextFactory) ## Setup Web serving (for convenience): https://localhost:9090/ ## webdir = File(".") web = Site(webdir) reactor.listenSSL(9090, web, contextFactory) ## Run everything .. ## reactor.run()
#print "...applying POS TAG" #part_of_speech_tagging(string_to_write) else : subprocess.call(["espeak","who you are taking to"]) def display_to_console(msg): print "\r" + msg class SpeechServer(WebSocketServerProtocol): def onMessage(self,msg,binary): display_to_console(msg) apply_nlp(msg) #if(re.search("yes",msg,re.IGNORECASE)): # text=re.sub(r'yes',"",msg) class Agent_rescue: def __init__(self,file_location,id,name): self.file_location=file_location self.id=id self.name=name self.clips=clips.Environment() factory=WebSocketServerFactory("ws://localhost:9000",debug=False); factory.protocol=SpeechServer listenWS(factory) reactor.run()
# now that envs are totally complete show results. if (len(self.pending_envs) == 0): self.on_envs_complete() def onOpen(self): self.increment = self.increment + 1 tests = sys.argv[1:len(sys.argv)] self.run_tests(tests) def run_tests(self, tests): def format(value): if (value[0] != '/'): value = '/' + value return value tests = map(format, tests) self.emit('run tests', {'tests': tests}) def onMessage(self, data, binary): command = json.loads(data) # test agent protocol always uses the [event, data] format. self.handle_event(command[0], [command[1]]) if __name__ == '__main__': factory = WebSocketServerFactory("ws://localhost:8789") factory.protocol = TestAgentServer listenWS(factory) reactor.run()
file_path = FILES_PATH + file_name f = open(file_path, 'w') f.write(message) f.close() print "File %s successfully writen..." % file_name self.sendMessage('[C][' + file_name + ']OK') elif typeMsg == '[R]': print "[R][%s] Read %s file from %s" % (time.strftime("%H:%M:%S"), file_name, CATALOG_NAME) print "File %s successfully read..." % file_name file_path = FILES_PATH + file_name f = open(file_path, 'r') message = '[O][' + file_name + ']' + f.read() f.close() self.sendMessage(message) if __name__ == '__main__': import sys if len(sys.argv) < 4: sys.exit("Using fileserver.py [IP] [PORT] [file_catalog_name]") ADDRESS = str(sys.argv[1]) PORT = int(sys.argv[2]) CATALOG_NAME = str(sys.argv[3]) FILES_PATH = '.\\data\\' + CATALOG_NAME + '\\' factory = WebSocketServerFactory("ws://" + ADDRESS + ":" + str(PORT), debug=False) factory.protocol = FS listenWS(factory) print 'Server starting up on %s port %s' % (ADDRESS, PORT) reactor.run()
## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ## See the License for the specific language governing permissions and ## limitations under the License. ## ############################################################################### import hashlib from twisted.internet import reactor from autobahn.websocket import WebSocketServerFactory, WebSocketServerProtocol class MessageBasedHashServerProtocol(WebSocketServerProtocol): """ Message-based WebSockets server that computes a SHA-256 for every message it receives and sends back the computed digest. """ def onMessage(self, message, binary): sha256 = hashlib.sha256() sha256.update(message) digest = sha256.hexdigest() self.sendMessage(digest) print "Sent digest for message: %s" % digest if __name__ == '__main__': factory = WebSocketServerFactory() factory.protocol = MessageBasedHashServerProtocol reactor.listenTCP(9000, factory) reactor.run()
## ## http://www.apache.org/licenses/LICENSE-2.0 ## ## Unless required by applicable law or agreed to in writing, software ## distributed under the License is distributed on an "AS IS" BASIS, ## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ## See the License for the specific language governing permissions and ## limitations under the License. ## ############################################################################### import sys from twisted.python import log from twisted.internet import reactor from autobahn.websocket import WebSocketServerFactory, WebSocketServerProtocol class WebSocketTestServerProtocol(WebSocketServerProtocol): def onMessage(self, msg, binary): self.sendMessage(msg, binary) if __name__ == '__main__': log.startLogging(sys.stdout) factory = WebSocketServerFactory(debug=False) factory.failByDrop = False factory.protocol = WebSocketTestServerProtocol reactor.listenTCP(9000, factory) reactor.run()
if (len(self.pending_envs) == 0): self.on_envs_complete(); def onOpen(self): self.increment = self.increment + 1; tests = sys.argv[1:len(sys.argv)]; self.run_tests(tests); def run_tests(self, tests): def format(value): if (value[0] != '/'): value = '/' + value return value tests = map(format, tests) self.emit('run tests', { 'tests': tests }); def onMessage(self, data, binary): command = json.loads(data) # test agent protocol always uses the [event, data] format. self.handle_event(command[0], [command[1]]) if __name__ == '__main__': factory = WebSocketServerFactory("ws://localhost:8789") factory.protocol = TestAgentServer listenWS(factory) reactor.run()
# Creating the web stuff resource_wsgi = wsgi.WSGIResource(reactor, tps.pool, WSGIHandler()) root = libs.Root(resource_wsgi) staticrsrc = static.File(os.path.normpath(os.path.join(os.path.abspath("."), "web/weblisa/static"))) root.putChild("static", staticrsrc) # Create the websocket if configuration['enable_secure_mode']: socketfactory = WebSocketServerFactory("wss://" + configuration['lisa_url'] + ":" + str(configuration['lisa_web_port_ssl']),debug=False) else: socketfactory = WebSocketServerFactory("ws://" + configuration['lisa_url'] + ":" + str(configuration['lisa_web_port']),debug=False) socketfactory.protocol = libs.WebSocketProtocol socketfactory.protocol.configuration, socketfactory.protocol.dir_path = configuration, dir_path socketresource = WebSocketResource(socketfactory) root.putChild("websocket", socketresource) # Configuring servers to launch if configuration['enable_secure_mode'] or configuration['enable_unsecure_mode']: if configuration['enable_secure_mode']: SSLContextFactoryEngine = ssl.DefaultOpenSSLContextFactory( os.path.normpath(dir_path + '/' + 'configuration/ssl/server.key'), os.path.normpath(dir_path + '/' + 'configuration/ssl/server.crt') ) SSLContextFactoryWeb = ssl.DefaultOpenSSLContextFactory( os.path.normpath(dir_path + '/' + 'configuration/ssl/server.key'), os.path.normpath(dir_path + '/' + 'configuration/ssl/server.crt') )
self.closeConnection('%02.f' % RESULT_FILE_TOO_LARGE) return elif length == self.maxFramePayloadSize: error_code = None try: result_tlv = self._handler.handle_upload(self._file_content) except FileHashError: error_code = RESULT_HASH_ERROR except Exception: log.error(traceback.format_exc()) error_code = RESULT_FS_ERROR if error_code: self.closeConnection('%02.f' % error_code) return result = '%02.f' % RESULT_UPLOAD_SUCCESS result += self.unformat_tlv(result_tlv) self.closeConnection(result) if __name__ == '__main__': # log.startLogging(sys.stdout) ''' factory_echo = WebSocketServerFactory("ws://localhost:9000", debug=settings.DEBUG) factory_echo.protocol = EchoServerProtocol # UploadFileProtocal listenWS(factory_echo)''' factory_upload = WebSocketServerFactory("ws://localhost:9001", debug=settings.DEBUG) factory_upload.protocol = UploadFileProtocal listenWS(factory_upload) reactor.run()
class FrameBasedHashServerProtocol(WebSocketServerProtocol): """ Frame-based WebSockets server that computes a running SHA-256 for message data received. It will respond after every frame received with the digest computed up to that point. It can receive messages of unlimited number of frames. Digest is reset upon new message. """ def onMessageBegin(self, opcode): WebSocketServerProtocol.onMessageBegin(self, opcode) self.sha256 = hashlib.sha256() def onMessageFrame(self, payload, reserved): data = ''.join(payload) self.sha256.update(data) digest = self.sha256.hexdigest() self.sendMessage(digest) print "Sent digest for frame: %s" % digest def onMessageEnd(self): pass if __name__ == '__main__': factory = WebSocketServerFactory("ws://localhost:9000") factory.protocol = FrameBasedHashServerProtocol listenWS(factory) reactor.run()
user = User(username=user_name,password=password,email="",role=400,active=1) db.session.add(user) db.session.commit() except IntegrityError: return "IntegrityError" except:return "ServerError" return "true" @app.route('/scriptcam.lic') def static_from_root(): return redirect('/static/ScriptCam/scriptcam.lic') ## ## create a Twisted Web resource for our WebSocket server ## msgFactory = WebSocketServerFactory(IP,debug = debug,debugCodePaths = debug) msgFactory.protocol = MsgServerProtocol msgFactory.setProtocolOptions(allowHixie76 = True) # needed if Hixie76 is to be supported msgResource = WebSocketResource(msgFactory) imgFactory = WebSocketServerFactory(IP,debug = debug,debugCodePaths = debug) imgFactory.protocol = ImgServerProtocol imgFactory.setProtocolOptions(allowHixie76 = True) # needed if Hixie76 is to be supported imgResource = WebSocketResource(imgFactory) ## ## 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
""" log.msg('Sending message to connections: %s' % data) payload = data.encode('utf8') # Send message through all connections for c in set(cls.connections): reactor.callFromThread(cls.sendMessage, c, payload) # Log to standard output log.startLogging(sys.stdout) # The actual web socket factory = WebSocketServerFactory(u'ws://localhost:9000', debug=False) factory.protocol = WebSocket # Initialize readers r = readers() valid_reader_index = -1 # Check if any valid readers are connected for i in range(len(r)): for valid_card_reader in VALID_CARD_READERS: if str(r[i]).find(valid_card_reader) > -1: valid_reader_index = i break # Only start the server if any valid readers are connected if valid_reader_index >= 0:
def onMessage(self, msg, isBinary): if self.service: self.service.onMessage(msg, isBinary) def onClose(self, wasClean, code, reason): if self.service: self.service.onClose(wasClean, code, reason) 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://localhost:9000", debug=debug, debugCodePaths=debug) factory.protocol = ServiceServerProtocol factory.setProtocolOptions(allowHixie76=True, failByDrop=False) listenWS(factory) webdir = File(".") web = Site(webdir) reactor.listenTCP(8080, web) reactor.run()
rest = length - (self.received - self.next) self.sha256.update(str(data[:rest])) ## send digest digest = self.sha256.hexdigest() self.sendMessage(digest) print "Sent digest for batch %d : %s" % (self.count, digest) ## advance to next batch self.next += BATCH_SIZE self.count += 1 ## .. and update the digest for the rest self.sha256.update(str(data[rest:])) else: ## otherwise we just update the digest for received data self.sha256.update(str(data)) def onMessageFrameEnd(self): pass def onMessageEnd(self): pass if __name__ == '__main__': factory = WebSocketServerFactory("ws://localhost:9000") factory.protocol = StreamingHashServerProtocol listenWS(factory) reactor.run()
rest = length - (self.received - self.next) self.sha256.update(data[:rest]) ## send digest digest = self.sha256.hexdigest() self.sendMessage(digest) print "Sent digest for batch %d : %s" % (self.count, digest) ## advance to next batch self.next += BATCH_SIZE self.count += 1 ## .. and update the digest for the rest self.sha256.update(data[rest:]) else: ## otherwise we just update the digest for received data self.sha256.update(data) def onMessageFrameEnd(self): pass def onMessageEnd(self): pass if __name__ == '__main__': factory = WebSocketServerFactory("ws://localhost:9000") factory.protocol = StreamingHashServerProtocol listenWS(factory) reactor.run()
def onMessage(self, msg, binary): self.sendMessage("Echo 2 - " + msg) if __name__ == '__main__': if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False factory1 = WebSocketServerFactory("ws://localhost:9000", debug = debug, debugCodePaths = debug) factory1.protocol = Echo1ServerProtocol resource1 = WebSocketResource(factory1) factory2 = WebSocketServerFactory("ws://localhost:9000", debug = debug, debugCodePaths = debug) factory2.protocol = Echo2ServerProtocol resource2 = WebSocketResource(factory2) ## Establish a dummy root resource root = Data("", "text/plain") ## and our WebSocket servers under different paths .. root.putChild("echo1", resource1) root.putChild("echo2", resource2)
self.sendMessage(msg, binary) # # To run the demo: # # Open a WebSocket-enabled browser to http://localhost:8080/demo # - open the Javascript console to see the echo text # - click the [Send] button # if __name__ == '__main__': log.startLogging(sys.stdout) # Set up an Autobahn echo server ws = WebSocketServerFactory("ws://localhost:8080", debug = True) ws.protocol = EchoServerProtocol root = resource.Resource() root.putChild("demo", DemoResource()) site = server.Site(root) factory = BufferingProxyFactory() factory.buffer_Factory = PacketBuffer # Route /demo urls to our website ExampleDispatcher.prefix1 = "/demo" ExampleDispatcher.site1 = site # Route "/" to the Autobahn websocket server ExampleDispatcher.prefix2 = "/" ExampleDispatcher.site2 = ws
def tick_flames(): traceerr(GAME._flames_process) reactor.callLater(FLAME_TICK_TIME, tick_flames) def tick_actions(): traceerr(GAME._actions_process) reactor.callLater(ACTION_TICK_TIME, tick_actions) def tick_bombs(): traceerr(GAME._bombs_process) reactor.callLater(BOMB_TICK_TIME, tick_bombs) factory = WebSocketServerFactory() # TODO: choose a more sensible port # TODO: add a REST interface to get the port factory.port = 9000 # ugh, why do I have to do this twice? factory.protocol = GameProtocol reactor.listenTCP(interface=hostname, port=9000, factory=factory) reactor.listenTCP(factory=server.Site(ServerRoot(None)), interface=hostname, port=port) reactor.callWhenRunning(tick_flames) reactor.callWhenRunning(tick_actions) reactor.callWhenRunning(tick_bombs) print "Listening on: http://%s:%d" % (hostname, port) print "Admin uid:", ADMIN_UID reactor.run()
listenWS import settings.py import logger.py class ServerProtocol(WebSocketServerProtocol): def onConnect(self, request): print("Client connecting: {}".format(request.peer)) def onOpen(self): print("WebSocket connection open.") def onMessage(self, payload, isBinary): if isBinary: print("Binary message received: {} bytes".format(len(payload))) else: print("Text message received: {}".format(payload.decode('utf8'))) # Add command parsing ## echo back message verbatim self.sendMessage(payload, isBinary) def onClose(self, wasClean, code, reason): print("WebSocket connection closed: {}".format(reason)) if __name__ == '__main__': factory = WebSocketServerFactory("ws:"+API_URL) factory.protocol = ServerProtocol listenWS(factory) reactor.run()
# print 'get file size:', length if length > self.maxFramePayloadSize: self.closeConnection('%02.f' %RESULT_FILE_TOO_LARGE) return elif length == self.maxFramePayloadSize: error_code = None try: result_tlv = self._handler.handle_upload(self._file_content) except FileHashError: error_code = RESULT_HASH_ERROR except Exception: log.error(traceback.format_exc()) error_code = RESULT_FS_ERROR if error_code: self.closeConnection('%02.f' %error_code) return result = '%02.f' %RESULT_UPLOAD_SUCCESS result += self.unformat_tlv(result_tlv) self.closeConnection(result) if __name__ == '__main__': # log.startLogging(sys.stdout) ''' factory_echo = WebSocketServerFactory("ws://localhost:9000", debug=settings.DEBUG) factory_echo.protocol = EchoServerProtocol # UploadFileProtocal listenWS(factory_echo)''' factory_upload = WebSocketServerFactory("ws://localhost:9001", debug=settings.DEBUG) factory_upload.protocol = UploadFileProtocal listenWS(factory_upload) reactor.run()
listenWS class EchoServerProtocol(WebSocketServerProtocol): def onMessage(self, msg, binary): self.sendMessage(msg, binary) 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://localhost:9000", debug = debug, debugCodePaths = debug) factory.protocol = EchoServerProtocol factory.setProtocolOptions(allowHixie76 = True) listenWS(factory) webdir = File(".") web = Site(webdir) reactor.listenTCP(8080, web) reactor.run()
stickY = self.state.get("LEFT_STICK_Y") if stickX is not None and stickY is not None: self.robot.setVelocity(stickX, -stickY) class UglyProtocol(WebSocketServerProtocol): def onGamepadCommand(self, command): self.gamepadController.onGamepadState(command) def onMessage(self, msg, binary): command = json.loads(msg) cmd = command.get("cmd") if cmd: method = "on" + cmd.capitalize() + "Command" try: getattr(self, method)(command) except AttributeError: print("Unknown command received: " + cmd.capitalize) def onOpen(self): self.robot = UglyRobot() self.gamepadController = UglyGamepadController(self.robot) if __name__ == '__main__': url = "ws://0.0.0.0:9000" factory = WebSocketServerFactory(url) factory.protocol = UglyProtocol listenWS(factory) print("UglyRobot server listening on " + url) reactor.run()
# # This is the server runtime. It creates a server that listens on port configured in config. # from twisted.internet import reactor from autobahn.websocket import WebSocketServerFactory, listenWS from server import VectorServerProtocol import config factory = WebSocketServerFactory(config.SERVER_ADDRESS) factory.protocol = VectorServerProtocol listenWS(factory) reactor.run()
def start_server(): factory = WebSocketServerFactory("ws://127.0.0.1:9000") factory.protocol = EchoServerProtocol factory.setProtocolOptions(allowHixie76=True) listenWS(factory)