mirror of
https://github.com/janeczku/calibre-web
synced 2024-08-30 04:52:39 +00:00
![OzzieIsaacs](/assets/img/avatar_default.png)
Bugfix for feeds - removed categories related and up - load new books now working - category random now working login page is free of non accessible elements boolean custom column is vivible in UI books with only with certain languages can be shown book shelfs can be deleted from UI Anonymous user view is more resticted Added browse of series in sidebar Dependencys in vendor folder are updated to newer versions (licencs files are now present) Bugfix editing Authors names Made upload on windows working
359 lines
13 KiB
Python
359 lines
13 KiB
Python
#!/usr/bin/env python
|
|
#
|
|
# Copyright 2009 Facebook
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# 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.
|
|
|
|
"""WSGI support for the Tornado web framework.
|
|
|
|
WSGI is the Python standard for web servers, and allows for interoperability
|
|
between Tornado and other Python web frameworks and servers. This module
|
|
provides WSGI support in two ways:
|
|
|
|
* `WSGIAdapter` converts a `tornado.web.Application` to the WSGI application
|
|
interface. This is useful for running a Tornado app on another
|
|
HTTP server, such as Google App Engine. See the `WSGIAdapter` class
|
|
documentation for limitations that apply.
|
|
* `WSGIContainer` lets you run other WSGI applications and frameworks on the
|
|
Tornado HTTP server. For example, with this class you can mix Django
|
|
and Tornado handlers in a single server.
|
|
"""
|
|
|
|
from __future__ import absolute_import, division, print_function, with_statement
|
|
|
|
import sys
|
|
from io import BytesIO
|
|
import tornado
|
|
|
|
from tornado.concurrent import Future
|
|
from tornado import escape
|
|
from tornado import httputil
|
|
from tornado.log import access_log
|
|
from tornado import web
|
|
from tornado.escape import native_str
|
|
from tornado.util import unicode_type
|
|
|
|
|
|
try:
|
|
import urllib.parse as urllib_parse # py3
|
|
except ImportError:
|
|
import urllib as urllib_parse
|
|
|
|
# PEP 3333 specifies that WSGI on python 3 generally deals with byte strings
|
|
# that are smuggled inside objects of type unicode (via the latin1 encoding).
|
|
# These functions are like those in the tornado.escape module, but defined
|
|
# here to minimize the temptation to use them in non-wsgi contexts.
|
|
if str is unicode_type:
|
|
def to_wsgi_str(s):
|
|
assert isinstance(s, bytes)
|
|
return s.decode('latin1')
|
|
|
|
def from_wsgi_str(s):
|
|
assert isinstance(s, str)
|
|
return s.encode('latin1')
|
|
else:
|
|
def to_wsgi_str(s):
|
|
assert isinstance(s, bytes)
|
|
return s
|
|
|
|
def from_wsgi_str(s):
|
|
assert isinstance(s, str)
|
|
return s
|
|
|
|
|
|
class WSGIApplication(web.Application):
|
|
"""A WSGI equivalent of `tornado.web.Application`.
|
|
|
|
.. deprecated:: 4.0
|
|
|
|
Use a regular `.Application` and wrap it in `WSGIAdapter` instead.
|
|
"""
|
|
def __call__(self, environ, start_response):
|
|
return WSGIAdapter(self)(environ, start_response)
|
|
|
|
|
|
# WSGI has no facilities for flow control, so just return an already-done
|
|
# Future when the interface requires it.
|
|
_dummy_future = Future()
|
|
_dummy_future.set_result(None)
|
|
|
|
|
|
class _WSGIConnection(httputil.HTTPConnection):
|
|
def __init__(self, method, start_response, context):
|
|
self.method = method
|
|
self.start_response = start_response
|
|
self.context = context
|
|
self._write_buffer = []
|
|
self._finished = False
|
|
self._expected_content_remaining = None
|
|
self._error = None
|
|
|
|
def set_close_callback(self, callback):
|
|
# WSGI has no facility for detecting a closed connection mid-request,
|
|
# so we can simply ignore the callback.
|
|
pass
|
|
|
|
def write_headers(self, start_line, headers, chunk=None, callback=None):
|
|
if self.method == 'HEAD':
|
|
self._expected_content_remaining = 0
|
|
elif 'Content-Length' in headers:
|
|
self._expected_content_remaining = int(headers['Content-Length'])
|
|
else:
|
|
self._expected_content_remaining = None
|
|
self.start_response(
|
|
'%s %s' % (start_line.code, start_line.reason),
|
|
[(native_str(k), native_str(v)) for (k, v) in headers.get_all()])
|
|
if chunk is not None:
|
|
self.write(chunk, callback)
|
|
elif callback is not None:
|
|
callback()
|
|
return _dummy_future
|
|
|
|
def write(self, chunk, callback=None):
|
|
if self._expected_content_remaining is not None:
|
|
self._expected_content_remaining -= len(chunk)
|
|
if self._expected_content_remaining < 0:
|
|
self._error = httputil.HTTPOutputError(
|
|
"Tried to write more data than Content-Length")
|
|
raise self._error
|
|
self._write_buffer.append(chunk)
|
|
if callback is not None:
|
|
callback()
|
|
return _dummy_future
|
|
|
|
def finish(self):
|
|
if (self._expected_content_remaining is not None and
|
|
self._expected_content_remaining != 0):
|
|
self._error = httputil.HTTPOutputError(
|
|
"Tried to write %d bytes less than Content-Length" %
|
|
self._expected_content_remaining)
|
|
raise self._error
|
|
self._finished = True
|
|
|
|
|
|
class _WSGIRequestContext(object):
|
|
def __init__(self, remote_ip, protocol):
|
|
self.remote_ip = remote_ip
|
|
self.protocol = protocol
|
|
|
|
def __str__(self):
|
|
return self.remote_ip
|
|
|
|
|
|
class WSGIAdapter(object):
|
|
"""Converts a `tornado.web.Application` instance into a WSGI application.
|
|
|
|
Example usage::
|
|
|
|
import tornado.web
|
|
import tornado.wsgi
|
|
import wsgiref.simple_server
|
|
|
|
class MainHandler(tornado.web.RequestHandler):
|
|
def get(self):
|
|
self.write("Hello, world")
|
|
|
|
if __name__ == "__main__":
|
|
application = tornado.web.Application([
|
|
(r"/", MainHandler),
|
|
])
|
|
wsgi_app = tornado.wsgi.WSGIAdapter(application)
|
|
server = wsgiref.simple_server.make_server('', 8888, wsgi_app)
|
|
server.serve_forever()
|
|
|
|
See the `appengine demo
|
|
<https://github.com/tornadoweb/tornado/tree/stable/demos/appengine>`_
|
|
for an example of using this module to run a Tornado app on Google
|
|
App Engine.
|
|
|
|
In WSGI mode asynchronous methods are not supported. This means
|
|
that it is not possible to use `.AsyncHTTPClient`, or the
|
|
`tornado.auth` or `tornado.websocket` modules.
|
|
|
|
.. versionadded:: 4.0
|
|
"""
|
|
def __init__(self, application):
|
|
if isinstance(application, WSGIApplication):
|
|
self.application = lambda request: web.Application.__call__(
|
|
application, request)
|
|
else:
|
|
self.application = application
|
|
|
|
def __call__(self, environ, start_response):
|
|
method = environ["REQUEST_METHOD"]
|
|
uri = urllib_parse.quote(from_wsgi_str(environ.get("SCRIPT_NAME", "")))
|
|
uri += urllib_parse.quote(from_wsgi_str(environ.get("PATH_INFO", "")))
|
|
if environ.get("QUERY_STRING"):
|
|
uri += "?" + environ["QUERY_STRING"]
|
|
headers = httputil.HTTPHeaders()
|
|
if environ.get("CONTENT_TYPE"):
|
|
headers["Content-Type"] = environ["CONTENT_TYPE"]
|
|
if environ.get("CONTENT_LENGTH"):
|
|
headers["Content-Length"] = environ["CONTENT_LENGTH"]
|
|
for key in environ:
|
|
if key.startswith("HTTP_"):
|
|
headers[key[5:].replace("_", "-")] = environ[key]
|
|
if headers.get("Content-Length"):
|
|
body = environ["wsgi.input"].read(
|
|
int(headers["Content-Length"]))
|
|
else:
|
|
body = b""
|
|
protocol = environ["wsgi.url_scheme"]
|
|
remote_ip = environ.get("REMOTE_ADDR", "")
|
|
if environ.get("HTTP_HOST"):
|
|
host = environ["HTTP_HOST"]
|
|
else:
|
|
host = environ["SERVER_NAME"]
|
|
connection = _WSGIConnection(method, start_response,
|
|
_WSGIRequestContext(remote_ip, protocol))
|
|
request = httputil.HTTPServerRequest(
|
|
method, uri, "HTTP/1.1", headers=headers, body=body,
|
|
host=host, connection=connection)
|
|
request._parse_body()
|
|
self.application(request)
|
|
if connection._error:
|
|
raise connection._error
|
|
if not connection._finished:
|
|
raise Exception("request did not finish synchronously")
|
|
return connection._write_buffer
|
|
|
|
|
|
class WSGIContainer(object):
|
|
r"""Makes a WSGI-compatible function runnable on Tornado's HTTP server.
|
|
|
|
.. warning::
|
|
|
|
WSGI is a *synchronous* interface, while Tornado's concurrency model
|
|
is based on single-threaded asynchronous execution. This means that
|
|
running a WSGI app with Tornado's `WSGIContainer` is *less scalable*
|
|
than running the same app in a multi-threaded WSGI server like
|
|
``gunicorn`` or ``uwsgi``. Use `WSGIContainer` only when there are
|
|
benefits to combining Tornado and WSGI in the same process that
|
|
outweigh the reduced scalability.
|
|
|
|
Wrap a WSGI function in a `WSGIContainer` and pass it to `.HTTPServer` to
|
|
run it. For example::
|
|
|
|
def simple_app(environ, start_response):
|
|
status = "200 OK"
|
|
response_headers = [("Content-type", "text/plain")]
|
|
start_response(status, response_headers)
|
|
return ["Hello world!\n"]
|
|
|
|
container = tornado.wsgi.WSGIContainer(simple_app)
|
|
http_server = tornado.httpserver.HTTPServer(container)
|
|
http_server.listen(8888)
|
|
tornado.ioloop.IOLoop.instance().start()
|
|
|
|
This class is intended to let other frameworks (Django, web.py, etc)
|
|
run on the Tornado HTTP server and I/O loop.
|
|
|
|
The `tornado.web.FallbackHandler` class is often useful for mixing
|
|
Tornado and WSGI apps in the same server. See
|
|
https://github.com/bdarnell/django-tornado-demo for a complete example.
|
|
"""
|
|
def __init__(self, wsgi_application):
|
|
self.wsgi_application = wsgi_application
|
|
|
|
def __call__(self, request):
|
|
data = {}
|
|
response = []
|
|
|
|
def start_response(status, response_headers, exc_info=None):
|
|
data["status"] = status
|
|
data["headers"] = response_headers
|
|
return response.append
|
|
app_response = self.wsgi_application(
|
|
WSGIContainer.environ(request), start_response)
|
|
try:
|
|
response.extend(app_response)
|
|
body = b"".join(response)
|
|
finally:
|
|
if hasattr(app_response, "close"):
|
|
app_response.close()
|
|
if not data:
|
|
raise Exception("WSGI app did not call start_response")
|
|
|
|
status_code = int(data["status"].split()[0])
|
|
headers = data["headers"]
|
|
header_set = set(k.lower() for (k, v) in headers)
|
|
body = escape.utf8(body)
|
|
if status_code != 304:
|
|
if "content-length" not in header_set:
|
|
headers.append(("Content-Length", str(len(body))))
|
|
if "content-type" not in header_set:
|
|
headers.append(("Content-Type", "text/html; charset=UTF-8"))
|
|
if "server" not in header_set:
|
|
headers.append(("Server", "TornadoServer/%s" % tornado.version))
|
|
|
|
parts = [escape.utf8("HTTP/1.1 " + data["status"] + "\r\n")]
|
|
for key, value in headers:
|
|
parts.append(escape.utf8(key) + b": " + escape.utf8(value) + b"\r\n")
|
|
parts.append(b"\r\n")
|
|
parts.append(body)
|
|
request.write(b"".join(parts))
|
|
request.finish()
|
|
self._log(status_code, request)
|
|
|
|
@staticmethod
|
|
def environ(request):
|
|
"""Converts a `tornado.httputil.HTTPServerRequest` to a WSGI environment.
|
|
"""
|
|
hostport = request.host.split(":")
|
|
if len(hostport) == 2:
|
|
host = hostport[0]
|
|
port = int(hostport[1])
|
|
else:
|
|
host = request.host
|
|
port = 443 if request.protocol == "https" else 80
|
|
environ = {
|
|
"REQUEST_METHOD": request.method,
|
|
"SCRIPT_NAME": "",
|
|
"PATH_INFO": to_wsgi_str(escape.url_unescape(
|
|
request.path, encoding=None, plus=False)),
|
|
"QUERY_STRING": request.query,
|
|
"REMOTE_ADDR": request.remote_ip,
|
|
"SERVER_NAME": host,
|
|
"SERVER_PORT": str(port),
|
|
"SERVER_PROTOCOL": request.version,
|
|
"wsgi.version": (1, 0),
|
|
"wsgi.url_scheme": request.protocol,
|
|
"wsgi.input": BytesIO(escape.utf8(request.body)),
|
|
"wsgi.errors": sys.stderr,
|
|
"wsgi.multithread": False,
|
|
"wsgi.multiprocess": True,
|
|
"wsgi.run_once": False,
|
|
}
|
|
if "Content-Type" in request.headers:
|
|
environ["CONTENT_TYPE"] = request.headers.pop("Content-Type")
|
|
if "Content-Length" in request.headers:
|
|
environ["CONTENT_LENGTH"] = request.headers.pop("Content-Length")
|
|
for key, value in request.headers.items():
|
|
environ["HTTP_" + key.replace("-", "_").upper()] = value
|
|
return environ
|
|
|
|
def _log(self, status_code, request):
|
|
if status_code < 400:
|
|
log_method = access_log.info
|
|
elif status_code < 500:
|
|
log_method = access_log.warning
|
|
else:
|
|
log_method = access_log.error
|
|
request_time = 1000.0 * request.request_time()
|
|
summary = request.method + " " + request.uri + " (" + \
|
|
request.remote_ip + ")"
|
|
log_method("%d %s %.2fms", status_code, summary, request_time)
|
|
|
|
|
|
HTTPRequest = httputil.HTTPServerRequest
|