def main():
try:
# init
lModel = RangeManager(int(sys.argv[1]), int(sys.argv[2]))
monkey.patch_all()
lApp = Flask(__name__)
lApp.debug = True
lApi = Api(lApp)
FetchRange.sModel = lModel
Report.sModel = lModel
Progress.sModel = lModel
Reset.sModel = lModel
PushNamespace.sModel = lModel
# routes
lApp.add_url_rule('/', 'poll', poll)
lApp.add_url_rule('/socket.io/<path:path>', 'socket.io', run_socketio)
lApi.add_resource(FetchRange, '/fetch')
lApi.add_resource(Report, '/report')
lApi.add_resource(Progress, '/progress')
lApi.add_resource(Reset, '/reset')
# go
lApp = SharedDataMiddleware(lApp, {})
lServer = SocketIOServer(('0.0.0.0', 5000),
lApp,
resource="socket.io",
policy_server=False)
lServer.serve_forever()
except IndexError:
print "Usage: " + sys.argv[0] + \
" <number of ranges> <timeout per range>"
except KeyboardInterrupt:
lServer.stop()
def handle(self, addrport="", *args, **options):
if not addrport:
self.addr = ''
self.port = DEFAULT_PORT
else:
m = match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _, _, _, self.port = m.groups()
# Make the port available here for the path:
# socketio_tags.socketio ->
# socketio_scripts.html ->
# io.Socket JS constructor
# allowing the port to be set as the client-side default there.
environ["DJANGO_SOCKETIO_PORT"] = str(self.port)
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
print
print "SocketIOServer running on %s:%s" % bind
print
handler = self.get_handler(*args, **options)
server = SocketIOServer(bind, handler, resource="socket.io", policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
if RELOAD:
server.stop()
print "Reloading..."
restart_with_reloader()
else:
raise
def handle(self, addrport="", *args, **options):
if not addrport:
self.addr = ""
self.port = DEFAULT_PORT
else:
m = match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number ' "or address:port pair." % addrport)
self.addr, _, _, _, self.port = m.groups()
environ["DJANGO_SOCKETIO_PORT"] = str(self.port)
if options.get("use_reloader"):
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
print "SocketIOServer running on %s:%s\n\n" % bind
handler = self.get_handler(*args, **options)
server = SocketIOServer(bind, handler, resource="socket.io", policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
for key, sock in six.iteritems(server.sockets):
sock.kill(detach=True)
server.stop()
if RELOAD:
print "Reloading...\n\n"
restart_with_reloader()
def handle(self, addrport="", *args, **options):
if not addrport:
self.addr = ''
self.port = DEFAULT_PORT
else:
m = match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _, _, _, self.port = m.groups()
# Make the port available here for the path:
# socketio_tags.socketio ->
# socketio_scripts.html ->
# io.Socket JS constructor
# allowing the port to be set as the client-side default there.
environ["DJANGO_SOCKETIO_PORT"] = str(self.port)
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
print
print "SocketIOServer running on %s:%s" % bind
print
handler = self.get_handler(*args, **options)
server = SocketIOServer(bind, handler, resource="socket.io", policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
if RELOAD:
server.stop()
print "Reloading..."
restart_with_reloader()
else:
raise
def handle(self, *args, **options):
addrport = options["addrport"]
m = match(naiveip_re, addrport)
if m is None:
raise CommandError(
"%s is not a valid port number or address:port pair." %
addrport)
self.addr, _, _, _, self.port = m.groups()
# Make the port available allowing the port
# to be set as the client-side default
environ["DJANGO_SOCKETIO_PORT"] = str(self.port)
Thread(target=reload_watcher).start()
try:
print("\nSocketIOServer running on {addr}:{port}\n".format(
addr=self.addr, port=self.port))
handler = self.get_handler(*args, **options)
bind = (self.addr, int(self.port))
server = SocketIOServer(bind,
handler,
resource="socket.io",
policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
if RELOAD:
server.stop()
print("Reloading...")
restart_with_reloader()
else:
raise
def handle(self, addrport='', *args, **options):
"""
Parses all arguments and starts the server. Will reload on
SIGINT unless the --noreload flag is passed.
"""
if options.get('enable_coverage'):
print "Enabling coverage for socketio server."
coverage_omit = ['*/management/*',
'*/migrations/*']
cov = coverage.coverage(source=['deckr', 'engine'],
omit=coverage_omit,
data_suffix=True,
branch=True)
cov.start()
if not addrport:
self.addr = ''
self.port = DEFAULT_PORT
else:
address_match = match(naiveip_re, addrport)
if address_match is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _, _, _, self.port = address_match.groups()
environ['DJANGO_SOCKETIO_PORT'] = str(self.port)
if options.get('use_reloader'):
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
print 'SocketIOServer running on %s:%s\n\n' % bind
handler = get_handler(**options)
server = SocketIOServer(
bind, handler, resource='socket.io', policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
server.stop()
if options.get('enable_coverage'):
cov.stop()
cov.save()
if RELOAD:
print 'Reloading...\n\n'
restart_with_reloader()
def handle(self, addrport='', *args, **options):
"""
Parses all arguments and starts the server. Will reload on
SIGINT unless the --noreload flag is passed.
"""
if options.get('enable_coverage'):
print "Enabling coverage for socketio server."
coverage_omit = ['*/management/*',
'*/migrations/*']
cov = coverage.coverage(source=['deckr'],
omit=coverage_omit,
data_suffix=True)
cov.start()
if not addrport:
self.addr = ''
self.port = DEFAULT_PORT
else:
address_match = match(naiveip_re, addrport)
if address_match is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _, _, _, self.port = address_match.groups()
environ['DJANGO_SOCKETIO_PORT'] = str(self.port)
if options.get('use_reloader'):
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
print 'SocketIOServer running on %s:%s\n\n' % bind
handler = get_handler(**options)
server = SocketIOServer(
bind, handler, resource='socket.io', policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
server.stop()
if options.get('enable_coverage'):
cov.stop()
cov.save()
if RELOAD:
print 'Reloading...\n\n'
restart_with_reloader()
def go():
# must import namespace class here after os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
from namespaces import SimplePushNS, RootNamespace
# Dummy request object to maintain state between Namespace initialization.
# just for ChatNamespace share data
request = {'self_reported': False, 'pid': PID, 'ip': IP}
# here can assign several namespaces pair by key:value
application = NSWSGIHandler({'': RootNamespace, '/simplepush': SimplePushNS}, request)
sio = SocketIOServer(('0.0.0.0', PORT), application, resource="socket.io", log=None)
# log_file="request.log", handler_class=LogSocketIOHandler,) # JUST WRITE ACCESS LOG TO FILE
print 'SocketIOServer Listening on http://0.0.0.0:%s and on port 10843 (flash policy server)' % PORT
print 'PID is: %s' % PID
try:
sio.serve_forever()
except KeyboardInterrupt:
sio.stop()
print ' >>> SocketIO Server Stopped!'
def handle(self, addrport='', *args, **options):
if not addrport:
self.addr = ''
self.port = DEFAULT_PORT
else:
m = match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _, _, _, self.port = m.groups()
environ['DJANGO_SOCKETIO_PORT'] = str(self.port)
if options.get('use_psyco'):
try:
from psycogreen.gevent import patch_psycopg
except ImportError:
raise CommandError(
'Could not patch psycopg. '
'Is psycogreen installed?')
patch_psycopg()
if options.get('use_reloader'):
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
print 'SocketIOServer running on %s:%s\n\n' % bind
handler = self.get_handler(*args, **options)
server = SocketIOServer(
bind, handler, resource='socket.io', policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
socks = []
for key, sock in six.iteritems(server.sockets):
socks.append(sock)
for sock in socks:
sock.kill(detach=True)
server.stop()
if RELOAD:
print 'Reloading...\n\n'
restart_with_reloader()
def handle(self, addrport='', *args, **options):
if not addrport:
self.addr = ''
self.port = 8000
else:
m = match(naiveip_re, addrport)
if m is None:
raise CommandError('"%s" is not a valid port number '
'or address:port pair.' % addrport)
self.addr, _, _, _, self.port = m.groups()
environ['DJANGO_SOCKETIO_PORT'] = str(self.port)
if options.get('use_psyco'):
try:
from psycogreen.gevent import patch_psycopg
except ImportError:
raise CommandError('Could not patch psycopg. '
'Is psycogreen installed?')
patch_psycopg()
if options.get('use_reloader'):
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
print 'SocketIOServer running on %s:%s\n\n' % bind
handler = self.get_handler(*args, **options)
server = SocketIOServer(bind,
handler,
resource='socket.io',
policy_server=True)
server.serve_forever()
except KeyboardInterrupt:
for key, sock in six.iteritems(server.sockets):
sock.kill(detach=True)
server.stop()
if RELOAD:
print 'Reloading...\n\n'
restart_with_reloader()
def main():
try:
# init
# lModel = RangeManager(int(sys.argv[1]), int(sys.argv[2]))
monkey.patch_all()
lApp = Flask(__name__)
lApp.debug = True
lApi = Api(lApp)
# FetchRange.sModel = lModel
# Report.sModel = lModel
# Progress.sModel = lModel
# Reset.sModel = lModel
# PushNamespace.sModel = lModel
# routes
lApp.add_url_rule('/', 'start', start)
# lApp.add_url_rule('/socket.io/<path:path>', 'socket.io', run_socketio)
lApi.add_resource(Busses, '/busses')
lApi.add_resource(IOConfig, '/ioconfig')
lApi.add_resource(Set, '/set')
lApi.add_resource(Get, '/get')
lApi.add_resource(Dump, '/dump')
lApi.add_resource(Detect, '/detect')
# go
# lApp = SharedDataMiddleware(lApp, {})
lServer = SocketIOServer(
('0.0.0.0', 5000),
lApp,
resource="socket.io",
policy_server=False)
lServer.serve_forever()
except IndexError:
print "Usage: " + sys.argv[0] + \
" <number of ranges> <timeout per range>"
except KeyboardInterrupt:
lServer.stop()
def handle(self, addrport="", *args, **options):
if not addrport:
self.addr = "127.0.0.1"
self.port = DEFAULT_PORT
else:
m = re.match(naiveip_re, addrport)
if m is None:
raise CommandError("\"%s\" is not a valid port number "
"or address:port pair." % addrport)
self.addr, _, _, _, self.port = m.groups()
if self.addr is None:
self.addr = "0.0.0.0"
# Make the port available here for the path:
# socketio_tags.socketio ->
# socketio_scripts.html ->
# io.Socket JS constructor
# allowing the port to be set as the client-side default there.
os.environ["DJANGO_SOCKETIO_PORT"] = str(self.port)
start_new_thread(reload_watcher, ())
try:
bind = (self.addr, int(self.port))
self.stdout.write("Starting development SocketIO server at %s:%s\n" % bind)
handler = self.get_handler(*args, **options)
server = SocketIOServer(bind, handler, resource="socket.io", policy_server=True, policy_listener=None)
server.serve_forever()
except KeyboardInterrupt:
if RELOAD:
server.stop()
self.stdout.write("Reloading...")
restart_with_reloader()
else:
raise
except Exception as e:
raise
def main():
try:
# init
lModel = RangeManager(int(sys.argv[1]), int(sys.argv[2]))
monkey.patch_all()
lApp = Flask(__name__)
lApp.debug = True
lApi = Api(lApp)
FetchRange.sModel = lModel
Report.sModel = lModel
Progress.sModel = lModel
Reset.sModel = lModel
PushNamespace.sModel = lModel
# routes
lApp.add_url_rule('/', 'poll', poll)
lApp.add_url_rule('/socket.io/<path:path>', 'socket.io', run_socketio)
lApi.add_resource(FetchRange, '/fetch')
lApi.add_resource(Report, '/report')
lApi.add_resource(Progress, '/progress')
lApi.add_resource(Reset, '/reset')
# go
lApp = SharedDataMiddleware(lApp, {})
lServer = SocketIOServer(
('0.0.0.0', 5000),
lApp,
resource="socket.io",
policy_server=False)
lServer.serve_forever()
except IndexError:
print "Usage: " + sys.argv[0] + \
" <number of ranges> <timeout per range>"
except KeyboardInterrupt:
lServer.stop()
404 error handler
used if a non existant route
is requested
"""
return render_template('404.html'), 404
@app.errorhandler(500)
def page_not_found(exc):
"""
500 error handler
used if there is a server error
"""
return render_template('500.html'), 500
if __name__ == '__main__':
analyzer = Analyzer()
server = SocketIOServer(('', PORT), app, resource="socket.io")
tw_thread = TweetWeather(server, analyzer, name="Tweet-Weather-Thread")
tw_thread.daemon = True
gevent.spawn(tw_thread.new_post, server)
gevent.spawn(tw_thread.connexion_lost, server)
print "Application Started: http://localhost:5000"
try:
server.serve_forever()
except KeyboardInterrupt:
tw_thread.stop()
server.stop()
sys.exit()
class SocketIOTransportPlugin(Plugin):
"""This plugin provides a Socket.IO server.
The server is capable of handling incoming requests,
and reacting to requests with a target uri using the protocol 'sio:///'."""
default_host = "0.0.0.0"
default_port = 8080
transport_protocol = "sio"
def _init(self):
# self.api.register_transport_client(("sio", ), self.send_request_indication)
#
# self.api.register_client(("sio", ), self.send_request)
self._initialized()
def send_request_indication(self, request_indication):
self.logger.debug("send_request_indication: %s", request_indication)
p = Promise()
path = urlparse(request_indication.path).path[1:]
self.logger.debug("target sessid (path): %s", path)
target = namespace_data.global_namespaces.get(path, None)
def callback_handler(result):
self.logger.debug("got client response \'%s\' to request \'%s\'",
result, request_indication)
try:
response = util.unmarshal_response(result)
p.fulfill(response)
except Exception as e:
self.logger.warn(
"can't unmarshall response \'%s\', error: \'%s\'", result,
e)
p.fulfill(result)
target.emit("request",
util.marshal_request_indication(request_indication),
callback=callback_handler)
return p
def send_request(self, request):
self.logger.debug("send_request: %s", request)
# TODO (ren) implement send_request
def _start(self):
# add function to BaseNamespace it's callable from its context
BaseNamespace.handle_request_indication = self.api.handle_request_indication
BaseNamespace.register_client = self.api.register_client
BaseNamespace.config = self.config
kwargs = {}
# fill kwargs with config values
host = self.config.get("host", "0.0.0.0")
port = int(self.config.get("port", 8080))
kwargs["resource"] = self.config.get("resource", None)
kwargs["transports"] = self.config.get("transports", None)
kwargs["policyserver"] = self.config.get("policy_server", None)
policy_listener = self.config.get("policy_listener", None)
# policy_listener needs to be tuple
if policy_listener:
split_host = policy_listener.rsplit(":", 1)
kwargs["policy_listener"] = (split_host[0], split_host[1])
kwargs["heartbeat_interval"] = self.config.get("heartbeat_interval",
None)
kwargs["heartbeat_timeout"] = self.config.get("heartbeat_timeout",
None)
kwargs["close_timeout"] = self.config.get("close_timeout", None)
kwargs["log_file"] = self.config.get("log_file", None)
# remove all mappings with empty value
kwargs = {k: v for k, v in kwargs.items() if v}
self.logger.info("Starting SocketIO server on %s:%s with kwargs: %s",
host, port, kwargs)
self.server = SocketIOServer((host, port), Application(), **kwargs)
self.logger.debug("starting to serve socketio")
self.api.run_task(self._serve)
self._started()
def _serve(self):
"""Start server serving"""
self.server.serve_forever()
self.logger.debug("socketio done serving")
def _stop(self):
self.logger.debug("stopping socketio server")
self.server.stop()
self._stopped()
content_type = "text/css"
elif path.endswith(".png"):
content_type = "image/png"
elif path.endswith(".swf"):
content_type = "application/x-shockwave-flash"
else:
content_type = "text/html"
start_response('200 OK', [('Content-Type', content_type)])
return [data]
# socketIO request
if path.startswith('socket.io/'):
socketio_manage(env, {'': LogStreamNS})
else:
return http404(start_response)
if __name__ == '__main__':
""" Main command line run """
try:
server = SocketIOServer(
('0.0.0.0', 8000), application, resource='socket.io', policy_server=True, policy_listener=('0.0.0.0', 10843)
)
sub = gevent.spawn(SubLogger)
sub.link(server.stop)
server.serve_forever()
except KeyboardInterrupt:
server.stop()
class FlaskService(ServiceBase):
TYPE = 'FlaskService'
def __init__(self, name):
super(FlaskService, self).__init__(name)
self.app = None
self.api_list = {} # 注册api
self.db = None
self.blueprints = {}
self.logger = Logger(__name__)
self.isclosed = False
self.thread = None
self.server = None
def init(self, cfgs, **kwargs):
#from mantis.fundamental.application.app import instance
if kwargs.has_key('logger'):
self.logger = kwargs.get('logger')
self.cfgs = cfgs
if kwargs.has_key('app'):
self.app = kwargs.get('app')
else:
static_path = os.getcwd() + '/static'
template_path = os.getcwd() + '/templates'
self.app = Flask(
__name__,
static_folder=static_path,
template_folder=template_path
) # flask会自动将当前代码目录设置为项目根目录 root_path 导致读取templtes , sta它ic 目录失败
Compress(self.app) # okay
# gzip = Gzip(app) # error
active = self.getConfig().get('cfgs', {})
for k, v in active.items():
self.app.config[k] = v
self.initCors()
self.initDatabase()
self.setupRequestHooks()
self.initBlueprint()
self.setupTemplates()
def setupTemplates(self):
from werkzeug.routing import BaseConverter
from flask import Flask, send_file
class RegexConverter(BaseConverter):
def __init__(self, map, *args):
self.map = map
self.regex = args[0]
self.app.url_map.converters['regex'] = RegexConverter
@self.app.route('/<regex(".*\.html$"):template_name>')
def _template_render(template_name):
name = os.path.join(self.app.template_folder, template_name)
return send_file(name)
def initDatabase(self):
global db
if db.get() is None:
self.db = SQLAlchemy(self.app)
db.set(self.db)
def getDatabase(self):
return self.db
def initCors(self):
"""
https://flask-cors.readthedocs.io/en/latest/
:return:
"""
if self.getConfig().get('cors_enable', True):
CORS(self.app)
def getFlaskApp(self):
return self.app
def setupRequestHooks(self):
self.app.before_request(self.onRequestBefore)
self.app.teardown_request(self.onRequestTeardown)
# self.app.after_request(self._requestAfter) # todo. 导致 send_file 失败
# 当利用send_file发送二进制数据时，after_request对返回数据进行日志处理，导致数据返回失败
def _traceRequestInfo(self, opts):
import json
trace_data = {'url': request.url}
if opts.get('header'):
trace_data['headers'] = request.headers
if opts.get('body'):
trace_data['body'] = request.data.replace(
'\n', ' ')[:opts.get('max_size')]
return json.dumps(trace_data)
def _traceResponseInfo(self, opts, response):
import json
trace_data = {'url': request.url}
if opts.get('header'):
trace_data['headers'] = response.headers
if opts.get('body'):
trace_data['body'] = response.data.replace(
'\n', ' ')[:opts.get('max_size')]
return json.dumps(trace_data)
def onRequestBefore(self):
# pass
import time
g.start_time = time.time()
#
# trace = self.getConfig().get('http_trace',{}).get('request',{})
# options = trace.get('options',{'header':False,'body':False,'max_size':1024})
# urls = trace.get('urls',[])
# #sort urls by 'match' with desceding.
# urls = sorted(urls,cmp = lambda x,y: cmp(len(x.get('match')) , len(y.get('match')) ) )
# urls.reverse()
#
# text = ''
# for url in urls:
# m = url.get('match')
# if m:
# opts = options.copy()
# opts['header'] = url.get('header',options.get('header'))
# opts['body'] = url.get('body',options.get('body'))
# opts['max_size'] = url.get('max_size',options.get('max_size'))
# if request.url.find(m) !=-1:
# text = self._traceRequestInfo(opts)
# break
# level = self.getConfig().get('http_trace',{}).get('level','DEBUG')
# text = 'HttpRequest: '+text
# self.getLogger().log(level,text)
def onRequestTeardown(self, e):
pass
def _requestAfter(self, response):
trace = self.getConfig().get('http_trace', {}).get('response', {})
options = trace.get('options', {
'header': False,
'body': False,
'max_size': 1024
})
urls = trace.get('urls', [])
urls = sorted(
urls,
cmp=lambda x, y: cmp(len(x.get('match')), len(y.get('match'))))
urls.reverse()
text = ''
for url in urls:
m = url.get('match')
if m:
opts = options.copy()
opts['header'] = url.get('header', options.get('header'))
opts['body'] = url.get('body', options.get('body'))
opts['max_size'] = url.get('max_size', options.get('max_size'))
if request.url.find(m) != -1:
text = self._traceResponseInfo(opts, response)
break
level = self.getConfig().get('http_trace', {}).get('level', 'DEBUG')
remote_addr = ''
if request.headers.getlist("X-Forwarded-For"):
remote_addr = request.headers.getlist("X-Forwarded-For")[0]
else:
remote_addr = request.remote_addr
elapsed = int((time.time() - g.start_time) * 1000)
text = 'HTTP %s %s %s %sms ' % (remote_addr, request.method,
request.url, elapsed)
self.getLogger().log(level, text)
return response
def initBlueprint(self):
cfgs = self.getConfig().get('blueprints', [])
for cfg in cfgs:
# module = import_module( cfgs.get('module'))
if not cfg.get('register', True):
continue
package_name = cfg.get('name', '')
package = cfg.get('package')
package_url = cfg.get('url')
modules = cfg.get('modules', [])
for module in modules:
module_name = module.get('name', )
module_url = module.get("url", '')
path = '%s.%s' % (package, module_name)
load_module = import_module(path)
app = Blueprint(module_name, path)
self.blueprints[path] = app
# api_module = {'name': u'%s.%s'%(package_name,module_name),'api_list':[]}
module_name = u'%s.%s' % (package_name, module_name)
self.api_list[module_name] = []
routes = module.get('routes', [])
for route in routes:
url = route.get('url', '')
name = route.get('name', '')
methods = filter(
lambda x: len(x) > 0,
route.get('methods', '').strip().upper().split(','))
if hasattr(load_module, name):
func = getattr(load_module, name)
path = package_url + module_url
path = path.replace('//', '/')
if methods:
app.route(url, methods=methods)(func)
else:
app.route(url)(func)
self.registerBlueprint(app, path)
path = path + '/' + url
path = path.replace('//', '/')
self.logger.debug('registered blueprint route:' + path)
api = {'url': path, 'methods': ('GET', )}
if methods:
api['methods'] = methods
self.api_list[module_name].append(api)
def registerAPIs(self, manager):
manager.register_http_service(self.api_list)
# def _initLogger(self):
# from camel.biz.logging.logger import FlaskHttpRequestLogger
# return FlaskHttpRequestLogger(self.appId)
# def start(self,block = True):
# # Application.run(self)
# http = self.getConfig().get('http')
# if http:
# self.app.run(host=http.get('host','127.0.0.1'),
# port = http.get('port',5000),
# threaded = http.get('threaded',True),
# debug = http.get('debug',True),
# process = http.get('process',1))
def select_address(self):
"""
修正http侦听地址 ， 如果port未定义或者为0 ，则进行动态选定端口
:return:
"""
from mantis.fundamental.utils.network import select_address_port
http = self.cfgs.get('http')
if not http.get('port'): # port 未定义或者为0
start = 18900
end = 18950
address = select_address_port(http.get('host'), start, end)
self.cfgs.get('http')['port'] = address[1]
def start(self, block=True):
self.select_address()
http = self.getConfig().get('http')
host = http.get('host', '127.0.0.1')
port = http.get('port', 5000)
# app = self.app
# if http.get('debug', False):
# app.run(host,port,debug=True)
# else:
# self.server = wsgi.WSGIServer(( host, port), app)
#
# self.server.start()
# Application.run(self)
# self.server = pywsgi.WSGIServer((host,port),app)
# self.server.start()
self.initHttpServer()
if block:
self.logger.info('Service: %s started, Listen on %s:%s ...' %
(self.name, host, port))
self.server.serve_forever()
else:
self.thread = Thread(target=self.runThread)
self.thread.setDaemon(True)
self.thread.start()
def initHttpServer(self):
http = self.getConfig().get('http')
host = http.get('host', '127.0.0.1')
port = http.get('port', 5000)
app = self.app
from mantis.fundamental.application.use_gevent import USE_GEVENT
print '--' * 20
if USE_GEVENT:
from gevent import pywsgi
from socketio.server import SocketIOServer
if http.get('websocket', False):
self.server = SocketIOServer((host, port),
app,
resource="socket.io")
else:
self.server = pywsgi.WSGIServer((host, port), app)
self.server.start()
else:
from wsgiref.simple_server import make_server
self.server = make_server(host, port, app)
self.logger.info('Service: %s started, Listen on %s:%s ...' %
(self.name, host, port))
def runThread(self):
# print 'xxxx-Service: %s started, Listen on %s:%s ...' % (self.name, host, port)
self.server.serve_forever()
def stop(self):
from mantis.fundamental.application.use_gevent import USE_GEVENT
if self.server:
if USE_GEVENT:
self.server.stop()
else:
self.server.shutdown()
def registerBlueprint(self, bp, url):
self.app.register_blueprint(bp, url_prefix=url)
