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(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://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 __init__(self):
log.startLogging(sys.stdout)
self.factory = WebSocketServerFactory("ws://localhost:9000",
debug=False)
self.factory.protocol = WebDisplay
listenWS(self.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():
""" 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(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()
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()
l = 0
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)
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()
try:
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)
##
def initializeWebSocket(self):##Starts the WebSocket
log.startLogging(sys.stdout)##Create a logfile (not necessary)
self.factory = WebSocketServerFactory("ws://localhost:55555", debug = False)
self.factory.protocol = EchoServerProtocol ##assign our Protocol to send/receive Messages
listenWS(self.factory)
reactor.run(installSignalHandlers=0)##"installSignalHandlers=0" Necessary for Multithreading @UndefinedVariable
# 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()
class EchoServerProtocol(WebSocketServerProtocol):
def sendHello(self):
if self.send_hello:
for i in xrange(0, 3):
self.sendMessage("*" * (self.count * 5))
self.count += 1
reactor.callLater(1, self.sendHello)
def onOpen(self):
self.count = 1
self.send_hello = True
#self.sendHello()
def onMessage(self, msg, binary):
print msg
self.sendMessage(msg, binary)
def connectionLost(self, reason):
WebSocketServerProtocol.connectionLost(self, reason)
self.send_hello = False
if __name__ == '__main__':
log.startLogging(sys.stdout)
factory = WebSocketServerFactory(debug = True)
factory.protocol = EchoServerProtocol
reactor.listenTCP(9000, factory)
reactor.run()
def listen_redis():
redis_conn = redis.StrictRedis(host=args.redis, port=6379, db=0)
redis_listener = PubSubRedisListener(redis_conn,['realtime'])
redis_listener.daemon = True
redis_listener.start()
def listen_kafka():
kafka = KafkaClient("localhost", 9092)
consumer = SimpleConsumer(kafka,"socket","pyhackers-rt")
kafka_listener = PubSubKafkaListener(kafka, consumer)
kafka_listener.daemon = True
kafka_listener.start()
listen_redis()
l = task.LoopingCall(publish_to_tenants)
l.start(0.1)
factory = WebSocketServerFactory("ws://localhost:{}".format(args.wsport), debug=True)
factory.protocol = EchoServerProtocol
listenWS(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 __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("ws://localhost:%d" % wsPort,
debug=debug,
debugCodePaths=debug)
factory.protocol = EchoServerProtocol
factory.setProtocolOptions(allowHixie76=True)
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(wsPort)
reactor.listenTCP(843, flashPolicyFactory)
## Static Web server
##
class EchoServerProtocol(WebSocketServerProtocol):
def onConnect(self, connectionRequest):
print connectionRequest
print "Client connecting .."
print "URL", connectionRequest.path
print "Origin", connectionRequest.origin
print "Protocols", connectionRequest.protocols
if 'foo' in connectionRequest.protocols:
## accept WS, we will speak the 'foo' subprotocol
return 'foo'
else:
raise HttpException(HTTP_STATUS_CODE_BAD_REQUEST[0],
"This server only speaks the 'foo' protocol")
def onMessage(self, msg, binary):
self.sendMessage(msg, binary)
if __name__ == '__main__':
debug = True
log.startLogging(sys.stdout)
factory = WebSocketServerFactory("ws://127.0.0.1:9000", debug=debug)
factory.protocol = EchoServerProtocol
listenWS(factory)
reactor.run()
#!/usr/bin/env python2.7 -u -Wall
import sys
from twisted.internet import reactor
from twisted.python import log
from autobahn.websocket import WebSocketServerFactory, \
WebSocketServerProtocol, \
listenWS
class EchoServerProtocol(WebSocketServerProtocol):
def onMessage(self, msg, binary):
self.sendMessage(msg, binary)
def onClose(self, *args):
reactor.stop()
if __name__ == '__main__':
factory = WebSocketServerFactory("ws://localhost:9001",
debug=True,
debugCodePaths=True)
log.startLogging(sys.stdout)
factory.protocol = EchoServerProtocol
listenWS(factory)
print "Here we go"
sys.stdout.flush() # flush the line so that tests know we're up
sys.stderr.flush()
reactor.run()
WebSocketServerProtocol.connectionLost(self, reason)
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()
Send message to web socket
"""
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
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()
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()
import hashlib
from twisted.internet import reactor
from autobahn.websocket import WebSocketServerFactory, WebSocketServerProtocol
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):
self.sha256 = hashlib.sha256()
def onMessageFrame(self, frame, reserved):
self.sha256.update(str(frame))
digest = self.sha256.hexdigest()
self.sendMessage(digest)
print "Sent digest for frame: %s" % digest
def onMessageEnd(self):
pass
if __name__ == '__main__':
factory = WebSocketServerFactory()
factory.protocol = FrameBasedHashServerProtocol
reactor.listenTCP(9000, factory)
reactor.run()
from twisted.internet import reactor
from autobahn.websocket import WebSocketServerFactory, \
WebSocketServerProtocol, \
listenWS
class EchoServerProtocol(WebSocketServerProtocol):
def onMessage(self, msg, binary):
self.sendMessage(msg, binary)
if __name__ == '__main__':
factory = WebSocketServerFactory("ws://0.0.0.0:9000", debug=True)
factory.protocol = EchoServerProtocol
listenWS(factory)
reactor.run()
