def swagger_handlers():
prefix = default_settings.get('swagger_prefix', '/swagger')
if prefix[-1] != '/':
prefix += '/'
def _path(suffix):
return prefix + suffix
return [
URLSpec(
_path(r'spec.html$'),
SwaggerUIHandler,
default_settings,
name=SWAGGER_API_DOCS),
URLSpec(
_path(r'spec.json$'),
SwaggerResourcesHandler,
default_settings,
name=SWAGGER_API_LIST),
URLSpec(
_path(r'spec$'),
SwaggerApiHandler,
default_settings,
name=SWAGGER_API_SPEC),
(
_path(r'(.*\.(css|png|gif|js))'),
StaticFileHandler,
{'path': default_settings.get('static_path')}),
]
def swagger_handlers():
"""Returns the swagger UI handlers
Returns:
[(route, handler)] -- list of Tornado URLSpec
"""
prefix = settings.default_settings.get('swagger_prefix', '/swagger')
if prefix[-1] != '/':
prefix += '/'
# Le o arquivo
#
# dir_path = os.path.dirname(os.path.realpath(__file__))
# print(dir_path)
# index = open(dir_path + "/index.html", "r").read()
# # Muda o prefixo
# index.replace('{{prefix}}', prefix)
# # Salva no outro local
# # open(dir_path + "/static/index.html", "w").write(index)
return [
URLSpec(prefix + r'spec.html$', SwaggerUIHandler,
settings.default_settings, name=settings.URL_SWAGGER_API_DOCS),
URLSpec(prefix + r'spec$', SwaggerApiHandler,
name=settings.URL_SWAGGER_API_SPEC),
(prefix + r'(.*\.(css|png|gif|js))', StaticFileHandler,
{'path': settings.default_settings.get('static_path')}),
]
def build(self, prefix=None):
#logging.debug('\n build')
prefix = prefix or self.prefix or ''
res = []
for r in self.items:
route = '/' + '/'.join([prefix.strip('/')] +
r[0].strip('/').split('/')).strip('/')
if isinstance(r[1], HandlersList):
res += r[1].build(route)
elif isinstance(r[1], basestring):
m = r[1].split('.')
ms, m, h = '.'.join(m[:-1]), m[-2], m[-1]
m = __import__(ms, fromlist=[m], level=0)
handler = getattr(m, h)[0]
d = {'name': self.get_handler_name(handler, r)}
d.update(r[2:])
res.append(URLSpec(route, handler, **d))
else:
handler = r[1:][0]
d = {'name': self.get_handler_name(handler, r)}
if len(r) == 3:
d['kwargs'] = r[2]
res.append(URLSpec(route, handler, **d))
return res
def url_specs(cls, url_prefix):
"""
Return the URLSpecs to be register on the application.
This usually includes one URLSpec for the page itself, and one for
each datasource.
"""
url_specs = []
url_specs.append(
URLSpec(r"%s%s/" % (url_prefix, cls.base_url.strip("/")),
type(cls.__name__, (cls.dashboard_handler_cls, cls), {}), {
"template": cls.template,
"params": cls.params
},
name=cls.__name__))
for datasource in cls.datasources:
if datasource.data_url is None:
raise KeyError("A Datasource must have a data_url: %s" %
datasource.__name__)
url_specs.append(
URLSpec(r"%s%s/" %
(url_prefix, datasource.data_url.strip("/")),
type(datasource.__name__,
(datasource, datasource.datasource_handler_cls),
dict(datasource.__dict__)), {
"datasource": datasource,
"params": cls.params
},
name=datasource.url_name))
return url_specs
def _add_handlers(self, host_pattern, host_handlers, url_prefix=''):
handlers = []
for spec in host_handlers:
if isinstance(spec, type(())):
assert len(spec) in (2, 3)
pattern = spec[0]
handler = spec[1]
if isinstance(handler, str):
handler = import_object(handler)
if len(spec) == 3:
kwargs = spec[2]
else:
kwargs = {}
pattern = '%s%s' % (url_prefix, pattern)
spec = URLSpec(pattern, handler, kwargs)
elif isinstance(spec, URLSpec):
pattern = '%s%s' % (url_prefix, spec.regex.pattern)
spec = URLSpec(pattern, spec.handler_class,
spec.kwargs, spec.name)
handlers.append(spec)
if host_pattern:
self.sub_handlers.append((host_pattern, handlers))
else:
for handler in handlers:
self.add_handler(handler)
def build(self, prefix=None):
prefix = prefix or self.prefix or ''
res = []
for r in self.items:
if len(r) != 2:
raise Exception(
'Url item must be typle which length is 2. Invalid item is {}'
.format(r))
ro = '/' + '/'.join([prefix.strip('/')] +
r[0].strip('/').split('/')).strip('/')
if isinstance(r[1], Handlers):
res += r[1].build(ro)
elif isinstance(r[1], six.string_types):
m = r[1].split('.')
ms, m, h = '.'.join(m[:-1]), m[-2], m[-1]
m = __import__(ms, fromlist=[m], level=0)
handler = getattr(m, h)[0]
d = {'name': self.get_handler_name(handler, r)}
d.update(r[2:])
res.append(URLSpec(ro, handler, **d))
else:
handler = r[1:][0]
d = {'name': self.get_handler_name(handler, r)}
if len(r) == 3:
d['kwargs'] = r[2]
res.append(URLSpec(ro, handler, **d))
return res
def _register_app_handlers(self, app, url_prefix):
if not app.handlers:
return
for spec in app.handlers:
if isinstance(spec, tuple):
assert len(spec) in (2, 3)
pattern = spec[0]
handler = spec[1]
if isinstance(handler, str):
handler = import_object(handler)
if len(spec) == 3:
kwargs = spec[2]
else:
kwargs = {}
pattern = '%s%s' % (url_prefix, pattern)
spec = URLSpec(pattern, handler, kwargs)
elif isinstance(spec, URLSpec):
pattern = '%s%s' % (url_prefix, spec.regex.pattern)
spec = URLSpec(pattern, spec.handler_class,
spec.kwargs, spec.name)
self.add_handler(spec)
def criar_rotas():
"""Esta função é responsavel por criar as rotas do app do Tornado."""
routes = [
URLSpec(r'/garcom-sincrono', GarcomSincrono),
URLSpec(r'/garcom-assincrono', GarcomAssincrono)
]
return Application(routes, **options.as_dict())
def detectURL(self, headURL='', itertime=0):
"""
get url
:headURL :the former URL which need to be merged
:return: (url,url_module)
"""
from tornado.web import URLSpec
urlList = []
# print urlList
for it in self.patterns:
if isinstance(it, URLSpec):
urlList.append(it)
continue
else:
# compatible with native tornado url configuration
url, url_module = it[:2]
if len(it) > 2:
# there maybe some other configuration setting
other_config = it[2:]
else:
other_config = []
# iterable get the URL
if isinstance(url_module, urlPackage):
# BFS get URL then extend it
urlList.extend(
url_module.detectURL(headURL='%s%s' % (headURL, url),
itertime=itertime + 1))
elif isinstance(url_module, str):
# print url_module
# for individual one then add it to the list
if headURL:
assemblyURL = '%s%s' % (headURL, url)
else:
assemblyURL = '%s' % url
# convert it to URLSpec
urlList.append(
URLSpec(assemblyURL,
url_module,
*other_config,
name=url_module))
# set up mapper for
self.URLMapper[url_module] = assemblyURL
else:
# try to use directly
if headURL:
assemblyURL = '%s%s' % (headURL, url)
else:
assemblyURL = '%s' % url
urlList.append(
URLSpec(assemblyURL,
url_module,
*other_config,
name=str(url_module)))
# raise ImproperlyConfigured(
# 'URL only accept string or URLpackage object(you can use include)'
# )
return urlList
def create_app():
"""
Create instance of tornado.web.Application.
"""
routes = [
URLSpec(r'/async', MainHandlerAsync),
URLSpec(r"/block", MainHandlerBlocking)
]
return Application(routes, **options.as_dict())
def __init__(self, args):
handlers = [
URLSpec(r"/", UsersHandler, name="index"),
URLSpec(r"/user/([0-9a-f]+)", UserDetailHandler, name="userDetail"),
]
super(MonitorApp, self).__init__(handlers,
template_path="templates/monitor")
self.report_collector = ReportCollector(args.db)
def make_application(app, debug=False, wsgi=False, settings_path="", url_root="/", **keywords):
app_path = os.path.abspath(os.path.dirname(app.__file__))
conf = None
if settings_path != "":
#conf = app.settings
conf = Yaml_Config(app_path, settings_path, url_root=url_root)
#else:
# conf = Yaml_Config(app_path, os.path.join(app_path, 'settings.yaml'), url_root=url_root)
views_path = os.path.join(app_path, 'views')
module_list = []
def getModule(module):
if type(module) == tuple:
return getModule(module[0])
else:
return module
for module, name in get_modules([app.__name__, 'views'], views_path):
module = getModule(module)
#if type(module) == tuple:
# module = module[0]
# if type(module) == tuple:
# module = module[0]
m = __import__(module, {}, {}, name)
module_list.append(m)
from torweb.urls import url, except_url
def _set_debug(kw):
kw["debug"] = debug
return kw
url_handlers = url.handlers
url_handlers = [URLSpec(spec.regex.pattern, spec.handler_class, _set_debug(spec.kwargs), spec.name) for spec in url_handlers]
if hasattr(app, "url"):
app_url_handlers = app.url.handlers
app_url_handlers = [URLSpec(spec.regex.pattern, spec.handler_class, _set_debug(spec.kwargs), spec.name) for spec in app_url_handlers]
url_handlers.extend(app_url_handlers)
_static_urls = [spec.regex.pattern for spec in url.handlers if spec.kwargs.has_key("path") and hasattr(spec.handler_class, 'static_handler') and spec.handler_class.static_handler==True]
#url_handlers = [(u, c, _set_debug(kw)) for u, c, kw in url_handlers]
#_static_urls = [url for url, cls, kw in url.handlers if kw.has_key("path") and hasattr(cls, 'static_handler') and cls.static_handler==True]
url_handlers.extend(except_url.handlers)
keywords.update({"debug":debug})
if debug:
application = DebugApplication(url_handlers, **keywords)
else:
if wsgi == True:
application = _WSGIApplication(url_handlers, **keywords)
else:
application = WebApplication(url_handlers, **keywords)
application.url_handlers = url_handlers
application._static_urls = _static_urls
# 初始化session store
if conf:
application.session_store = conf.session_store
else:
from torweb.sessions import MemorySessionStore
application.session_store = MemorySessionStore()
return application
def init_handlers(self):
self.handlers = [
URLSpec(r'/', handlers.IndexHandler, name='Index'),
URLSpec(r'/data/(\d*)', handlers.DataHandler, name='Data'),
URLSpec(r'/nodeinfo', handlers.NodeInfoHandler, name='NodeInfo'),
URLSpec(r'/vis', handlers.VisHandler, name='Vis'),
URLSpec(r'/led',
handlers.LEDHandler,
dict(bat_mac=self.bat_mac),
name='LED')
]
def __init__(self):
handlers = [
URLSpec(r'/', IndexHandler),
URLSpec(r'/cat/(\d{1,2})', CatHandler, name="cat"),
URLSpec(r'/detail/(\w+)', DetailHandler),
URLSpec(r'/login', LoginHandler),
]
tornado.web.Application.__init__(self, handlers, **settings.settings)
self.db = torndb.Connection(host=settings.DBHOST,
database=settings.DATABASE,
user=settings.DBUSER,
password=settings.DBPWD)
def view_handlers():
prefix = default_settings.get('product_prefix', '/alipay')
if prefix[-1] != '/':
prefix += '/'
return [
URLSpec('/', views.DefaultHandler, default_settings),
URLSpec(prefix + r'home.html$', views.HomeHandler, default_settings),
(prefix + r'(.*\.(css|png|gif|jpg|js|ttf|woff|woff2))',
StaticFileHandler, {
'path': default_settings.get('static_path')
}),
]
def __init__(self):
handlers = [
URLSpec(r"/upload/", UploadHandler, name='upload'),
URLSpec(r"/download/([^/]+)?", DownloadHandler, name='download'),
]
settings = {
"template_path": os.path.join(os.path.dirname(__file__),
"templates"),
"static_path": os.path.join(os.path.dirname(__file__), "static"),
"debug": True,
}
tornado.web.Application.__init__(self, handlers, **settings)
def resolve(self):
if isinstance(self.patterns, str):
self.patterns = import_object(self.patterns)
for pattern in self.patterns:
if isinstance(pattern, dict):
yield URLSpec(**pattern)
elif isinstance(pattern, URLSpec):
yield pattern
elif isinstance(pattern, Resolver):
yield from pattern.resolve()
elif len(pattern) > 1 and isinstance(pattern[1], Resolver):
yield from self.include(*pattern)
else:
yield URLSpec(*pattern)
def get_handler(self, *args, **kwargs):
"""Return Tornado application with Django WSGI handlers"""
# Patch prepare method from Tornado's FallbackHandler
FallbackHandler.prepare = patches.patch_prepare(FallbackHandler.prepare)
django_app = wsgi.WSGIContainer(WSGIHandler())
handlers = (
URLSpec(r'/_', WelcomeHandler),
URLSpec(r'.*', FallbackHandler, dict(fallback=django_app)),
)
opts = {
"debug": settings.DEBUG,
"loglevel": settings.DEBUG and "debug" or "warn",
}
return Application(handlers, **opts)
def main():
parse_command_line(final=False)
parse_config_file(options.config)
handlers = [
URLSpec("/", MainHandler, name="root"),
URLSpec("/login", LoginHandler, name="login"),
URLSpec("/logout", LogoutHandler, name="logout")
]
app = Application(handlers,
login_url="/login",
**options.group_dict("application"))
app.listen(options.port)
logging.info("Listening on http://localhost:%d" % options.port)
IOLoop.current().start()
def detectURL(self, headURL = '', itertime=0):
"""
get url
:headURL :the former URL which need to be merged
:return: (url,url_module)
"""
from tornado.web import URLSpec
urlList = []
# print urlList
for it in self.patterns:
if isinstance(it,URLSpec):
urlList.append(it)
continue
else:
url,url_module = it
# iterable get the URL
if isinstance(url_module,urlPackage):
# BFS get URL then extend it
urlList.extend(url_module.detectURL(headURL='%s%s' %(headURL,url),itertime=itertime+1))
elif isinstance(url_module,str):
#print url_module
# for individual one then add it to the list
if headURL:
assemblyURL = '%s%s' %(headURL,url)
else:
assemblyURL = '%s' %url
# convert it to URLSpec
urlList.append(URLSpec(assemblyURL,url_module,name=url_module))
# set up mapper for
self.URLMapper[url_module] = assemblyURL
else:
raise ImproperlyConfigured('URL only accept string or URLpackage object(you can use include)')
return urlList
def add_handler(self, url_handler):
"""Appends the given url_handlers to our handler list.
"""
print(url_handler)
url_pattern = url_handler[0]
if not url_pattern.endswith("$"):
url_pattern += "$"
handlers = []
#wildcard .*$ should have lowest priority
#notice:first we only insert a empty handlers as a placeholder
if self.handlers and self.handlers[-1][0].pattern == '.*$':
self.handlers.insert(-1, (re.compile(url_pattern), handlers))
else:
self.handlers.append((re.compile(url_pattern), handlers))
spec = url_handler
if isinstance(
spec,
(tuple, list)): #the url_handler should be inited with some args
assert len(spec) in (2, 3, 4)
spec = URLSpec(*spec)
handlers.append(spec)
if spec.name:
if spec.name and self.named_handlers:
Log4Spider.warnLog(
"Multiple handlers named %s; replacing previous value",
spec.name)
self.named_handlers[spec.name] = spec
def new_urlSpec(self, pattern, handler, kwargs=None, name=None):
if name:
name = "%s:%s" % (self.name, name)
return URLSpec('%s%s' % (self.prefix, pattern),
handler,
kwargs=kwargs,
name=name)
def publish(self, base):
finalRoutes = []
base = [part for part in base.split('/') if part]
for route in self.routes:
route['pattern'] = '/' + '/'.join(base + route['pattern'])
finalRoutes.append(URLSpec(**route))
return finalRoutes
def load_jupyter_server_extension(nb_app):
'''Loads server extension.'''
nb_app.log.info('Loaded nb2kg extension')
# TODO: There is no clean way to override existing handlers that are already
# registered with the Tornado application. The first handler to match the
# URL will handle the request, so we must prepend our handlers to override
# the existing ones.
web_app = nb_app.web_app
# Detect tornado compatibility. The 'handlers' list was "moved" (and
# transformed) in tornado >= 4.5. Check for its existence and continue the
# load accordingly. In 4.5, a "rules" list is used and now resides under
# the wildcard_router. Fortunately, URLSpec derives from Rule (as of 4.5)
# so much of the previous code can be retained.
# Detect older version of tornado
if hasattr(web_app, 'handlers'): # tornado < 4.5
pattern, handlers = web_app.handlers[0]
else: # tornado >= 4.5
handlers = web_app.wildcard_router.rules
base_url = web_app.settings['base_url']
for handler in ext_handlers[::-1]:
pattern = url_path_join(base_url, handler[0])
new_handler = URLSpec(pattern, *handler[1:])
nb_app.log.info('Overriding handler %s' % new_handler)
handlers.insert(0, new_handler)
def add_handlers(self, host_pattern, host_handlers):
"""Appends the given handlers to our handler list.
Host patterns are processed sequentially in the order they were
added. All matching patterns will be considered.
"""
handlers = []
# The handlers with the wildcard host_pattern are a special
# case - they're added in the constructor but should have lower
# precedence than the more-precise handlers added later.
# If a wildcard handler group exists, it should always be last
# in the list, so insert new groups just before it.
if isinstance(host_pattern, basestring):
if not host_pattern.endswith('$'):
host_pattern += '$'
if self.handlers and self.handlers[-1][0].pattern == '.*$':
self.handlers.insert(-1, (re.compile(host_pattern), handlers))
else:
self.handlers.append((re.compile(host_pattern), handlers))
else:
self.handlers.append((host_pattern, handlers))
for spec in host_handlers:
if isinstance(spec, (tuple, list)):
assert len(spec) in (2, 3, 4)
spec = URLSpec(*spec)
handlers.append(spec)
if spec.name:
if spec.name in self.named_handlers:
app_log.warning(
'Multiple handlers named %s; replacing previous value',
spec.name)
self.named_handlers[spec.name] = spec
def _handlers():
prefix = default_settings.get('view_prefix', 'edu')
if prefix[-1] != '/':
prefix += '/'
return [
URLSpec('/', input.DefaultHandler, default_settings),
URLSpec(prefix + r'index.html', input.IndextHandler, default_settings),
URLSpec(prefix + r'login.html$', input.LoginViewHandler,
default_settings),
URLSpec(prefix + r'(?P<manage_obj>.+).html$', input.ManageViewHandler,
default_settings),
(prefix + r'(.*\.(css|png|gif|jpg|js|ttf|woff|woff2|xls))',
StaticFileHandler, {
'path': default_settings.get('static_path')
}),
]
def publish(self, base):
finalRoutes = []
base = [part for part in base.split("/") if part]
for route in self.routes:
route["pattern"] = "/" + "/".join(base + route["pattern"])
finalRoutes.append(URLSpec(**route))
return finalRoutes
def decorator(handler):
_name = name or handler.__name__
spec = URLSpec(self.url_prefix + route,
handler,
initialize,
name='%s.%s' % (self.name, _name))
self.ROUTES.append({'host': host, 'spec': spec})
return handler
def url(route=None, controller=None, action=None, name=None):
route = Route(name, route)
route.makeregexp('')
regexp = re.sub(r'(?<!\\)\\', '', route.regexp)
return URLSpec(regexp, controller, dict(action=action), name=name)
def __call__(self, handler):
"""
Called when we decorate a class.
"""
name = self.name or handler.__name__
spec = URLSpec(self.route, handler, self.initialize, name=name)
self._routes.append({'host': self.host, 'spec': spec})
return handler
