class Server(object):
def __init__(self, methods=None):
self._endpoint = None
self._methods = methods
self._wsserver = None
def bind(self, endpoint):
self._endpoint = endpoint
def run(self):
methods = self._methods
endpoint = self._endpoint
class WampApplication(WebSocketApplication):
protocol_class = WampProtocol
def on_open(self):
wamp = self.protocol
if methods:
wamp.register_object(endpoint, methods)
ep = urlparse(self._endpoint)
resource = Resource({'^%s$' % ep.path: WampApplication})
self._wsserver = WebSocketServer(ep.netloc, resource, debug=True)
self._wsserver.serve_forever()
def run(self):
static_path = os.path.join(self.path, 'webui')
routes = [('^/static/', self.make_static_application('/static/', static_path)),
('^/$', self.serve_index),
('^/ws$', UIService)
]
data = {'handler': self.handler, # object
'registrars': self.registrars # list of topics
}
resource = _Resource(routes, extra=data)
server = WebSocketServer(("", self.port), resource, debug=True)
server.serve_forever()
def run(self):
static_path = os.path.join(self.path, 'static')
routes = [('^/static/',
self.make_static_application('/static/', static_path)),
('^/$', self.serve_index), ('^/ws$', UIService)]
data = {
'handler': self.handler, # object
'registrars': self.registrars # list of topics
}
resource = _Resource(routes, extra=data)
server = WebSocketServer(("", self.port), resource, debug=True)
server.serve_forever()
def run(self):
static_path = os.path.join(self.path, 'webui') # XXX naming
routes = [('^/static/',
self.make_static_application('/static/', static_path)),
('^/$', self.serve_index), ('^/ws$', WebSocketAPI)]
data = {
'raiden': self.raiden,
'port': self.port,
'events': self.events
}
resource = Resource(routes, extra=data)
server = WebSocketServer(("", self.port), resource, debug=True)
server.serve_forever()
def run(self):
static_path = os.path.join(self.path, 'webui') # XXX naming
routes = [('^/static/', self.make_static_application('/static/', static_path)),
('^/$', self.serve_index),
('^/ws$', WebSocketAPI)
]
data = {'raiden': self.raiden,
'port': self.port,
'events': self.events
}
resource = Resource(routes, extra=data)
server = WebSocketServer(("", self.port), resource, debug=True)
server.serve_forever()
class WSGHaven(GHaven):
stream_class = WSStream
def __init__(self, box_class, path_pattern, merge_wsgi_app=None, **kwargs):
super(WSGHaven, self).__init__(box_class, **kwargs)
self.path_pattern = path_pattern
self.merge_wsgi_app = merge_wsgi_app
def wsgi_app(self, environ, start_response):
"""
将原始的app，包装为包括websocket的app
"""
path = environ['PATH_INFO']
if re.match(self.path_pattern, path):
ws = environ['wsgi.websocket']
address = (environ.get('REMOTE_ADDR'), environ.get('REMOTE_PORT'))
self._handle_stream(ws, address)
else:
if self.merge_wsgi_app:
return self.merge_wsgi_app(environ, start_response)
else:
start_response("400 Bad Request", [])
return ['400 Bad Request']
def __call__(self, environ, start_response):
return self.wsgi_app(environ, start_response)
def _prepare_server(self, address):
import _socket
# 只有这样，才能保证在主进程里面，不会启动accept
listener = self.server_class.get_listener(address,
backlog=self.backlog,
family=_socket.AF_INET)
listener.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.server = WebSocketServer(listener, self.wsgi_app)
def _serve_forever(self):
self.server.serve_forever()
class WSGHaven(GHaven):
stream_class = WSStream
def __init__(self, box_class, path_pattern, merge_wsgi_app=None, **kwargs):
super(WSGHaven, self).__init__(box_class, **kwargs)
self.path_pattern = path_pattern
self.merge_wsgi_app = merge_wsgi_app
def wsgi_app(self, environ, start_response):
"""
将原始的app，包装为包括websocket的app
"""
path = environ['PATH_INFO']
if re.match(self.path_pattern, path):
ws = environ['wsgi.websocket']
address = (environ.get('REMOTE_ADDR'), environ.get('REMOTE_PORT'))
self._handle_stream(ws, address)
else:
if self.merge_wsgi_app:
return self.merge_wsgi_app(environ, start_response)
else:
start_response("400 Bad Request", [])
return ['400 Bad Request']
def __call__(self, environ, start_response):
return self.wsgi_app(environ, start_response)
def _prepare_server(self, address):
import _socket
# 只有这样，才能保证在主进程里面，不会启动accept
listener = self.server_class.get_listener(address, backlog=self.backlog, family=_socket.AF_INET)
listener.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.server = WebSocketServer(listener, self.wsgi_app)
def _serve_forever(self):
self.server.serve_forever()
def run(app, host=None, port=None, debug=None, logger=logger):
monkey.patch_all()
address = get_address(host, port, app.config['SERVER_NAME'])
if debug is not None:
app.debug = debug
if app.debug:
#app.wsgi_app = DebuggedApplication(app.wsgi_app, evalex=True)
server = WebSocketServer(address, app.wsgi_app, debug=debug)
server._logger = logger
logger.setLevel(logging.INFO)
def run_server():
server.serve_forever()
if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
server.logger.info(' * Running on http://%s:%d/' % address)
server.logger.info(' * WebSocket enabled')
run_with_reloader(run_server)
else:
server = WebSocketServer(address, app.wsgi_app, debug=debug)
server._logger = logger
server.serve_forever()
return server
RPCTestClass())
self.wamp.register_pubsub("http://localhost:8000/somechannel")
print "opened"
def on_message(self, message):
print "message: ", message
super(WampApplication, self).on_message(message)
def on_close(self):
print "closed"
def add(self, var, has):
has.update({'bloep': var})
return has
def build_protocol(self):
self.wamp = WampProtocol(self)
return self.wamp
@classmethod
def protocol(cls):
return WampProtocol.PROTOCOL_NAME
if __name__ == "__main__":
resource = Resource({'/': WampApplication})
server = WebSocketServer(("", 8000), resource, debug=True)
server.serve_forever()
def _prepare_server(self, address):
import _socket
# 只有这样，才能保证在主进程里面，不会启动accept
listener = self.server_class.get_listener(address, backlog=self.backlog, family=_socket.AF_INET)
listener.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.server = WebSocketServer(listener, self.wsgi_app)
def runserver():
http_server = WebSocketServer(('127.0.0.1', 5001), app)
http_server.serve_forever()
print("{0}: {1}".format(ex.__class__.__name__, ex))
except Exception as ex:
traceback.print_exc()
from pprint import pprint
def http_handler(environ, start_response):
pprint(environ)
path = os.path.join('./www', environ['PATH_INFO'].lstrip('/'))
print("looking for {}".format(path))
if os.path.exists(path):
print("found {}".format(path))
start_response("200 OK", [])
return [open(path, "rb").read()]
if environ["PATH_INFO"].strip("/") == "version":
start_response("200 OK", [])
return [agent]
else:
start_response("400 Bad Request", [])
return ["WebSocket connection is expected here."]
path = os.path.dirname(geventwebsocket.__file__)
agent = bytearray("gevent-websocket/%s" % (geventwebsocket.get_version()),
'latin-1')
print("Running %s from %s" % (agent, path))
WebSocketServer(("", 3000), echo_app, debug=True).serve_forever()
resp.header.result = 0
resp_data = resp.encode()
print(resp_data)
websocket.send(resp_data)
# print(proto.access_pb2.ConnectGameServerReq.ParseFromString(bytes(message[24:]).decode()))
# print('--->22')
# websocket.send(message)
websocket.close()
except geventwebsocket.WebSocketError as ex:
print("{0}: {1}".format(ex.__class__.__name__, ex))
def http_handler(environ, start_response):
if environ["PATH_INFO"].strip("/") == "version":
start_response("200 OK", [])
return [agent]
else:
start_response("400 Bad Request", [])
return ["WebSocket connection is expected here."]
path = os.path.dirname(geventwebsocket.__file__)
agent = bytearray("gevent-websocket/%s" % (geventwebsocket.get_version()),
'latin-1')
print("Running %s from %s" % (agent, path))
WebSocketServer(("0.0.0.0", 8800), echo_app, debug=True).serve_forever()
if websocket is None:
return http_handler(environ, start_response)
try:
while True:
message = websocket.receive()
websocket.send(message)
websocket.close()
except geventwebsocket.WebSocketError as ex:
print('{0}: {1}'.format(ex.__class__.__name__, ex))
def http_handler(environ, start_response):
if environ['PATH_INFO'].strip('/') == 'version':
start_response('200 OK', [])
return [agent]
else:
start_response('400 Bad Request', [])
return ['WebSocket connection is expected here.']
if __name__ == '__main__':
path = os.path.dirname(geventwebsocket.__file__)
agent = bytearray('gevent-websocket/%s' % (geventwebsocket.get_version()),
'latin-1')
print('Running %s from %s' % (agent, path))
ser = WebSocketServer(('', 8000), echo_app, debug=False)
ser.serve_forever()
websocket = environ.get("wsgi.websocket")
if websocket is None:
return http_handler(environ, start_response)
try:
while True:
message = websocket.receive()
websocket.send(message)
websocket.close()
except geventwebsocket.WebSocketError as ex:
print("{0}: {1}".format(ex.__class__.__name__, ex))
def http_handler(environ, start_response):
if environ["PATH_INFO"].strip("/") == "version":
start_response("200 OK", [])
return [agent]
else:
start_response("400 Bad Request", [])
return ["WebSocket connection is expected here."]
path = os.path.dirname(geventwebsocket.__file__)
agent = bytearray("gevent-websocket/%s" % (geventwebsocket.get_version()),
'latin-1')
print("Running %s from %s" % (agent, path))
WebSocketServer(("", 8000), echo_app, debug=False).serve_forever()
def on_open(self):
wamp = self.protocol
wamp.register_procedure("http://localhost:8000/calc#add", self.add)
wamp.register_object("http://localhost:8000/db#", KeyValue())
print "opened"
def on_message(self, message):
print "message: ", message
super(WampApplication, self).on_message(message)
def on_close(self, reason):
print "closed"
def add(self, x, y):
return int(x) + int(y)
def static_wsgi_app(environ, start_response):
start_response("200 OK", [("Content-Type", "text/html")])
return open("wamp_example.html").readlines()
if __name__ == "__main__":
resource = Resource({
'^/wamp_example$': WampApplication,
'^/$': static_wsgi_app
})
server = WebSocketServer(("", 8000), resource, debug=True)
server.serve_forever()
if websocket is None:
return http_handler(environ, start_response)
try:
websocket.send('hello you cool fool')
while True:
message = websocket.receive()
print('got %s' % message)
websocket.send(message)
websocket.close()
except geventwebsocket.WebSocketError, ex:
print "{0}: {1}".format(ex.__class__.__name__, ex)
def http_handler(environ, start_response):
if environ["PATH_INFO"].strip("/") == "version":
start_response("200 OK", [])
return [agent]
else:
start_response("400 Bad Request", [])
return ["WebSocket connection is expected here."]
path = os.path.dirname(geventwebsocket.__file__)
agent = "gevent-websocket/%s" % (geventwebsocket.get_version())
port = 8000
host = 'localhost'
print "Running on %s:%s" % (host, port)
WebSocketServer((host, port), echo_app, debug=False).serve_forever()
