def make_middleware(wrapped, **args):
"""
Make middleware wsgi app
"""
_LOG.debug('Middleware function arguments is %r', args)
local_manager = LocalManager([NoAuth.LOCALS])
app = NoAuth(wrapped)
return local_manager.make_middleware(app)
def __init__(self, database_url: str, **options):
self._local = Local()
self._local_manager = LocalManager([self._local])
self._database_url = database_url
self._options = options
self.engine: Engine = self.create_engine()
self.metadata = MetaData()
self.session_mkr = sessionmaker(bind=self.engine)
self.session = self.session_mkr(autocommit=True) # type: Session
def __init__(self, app):
"""Initialize the middleware, and chain it to the given app.
app (function): a WSGI application.
"""
self._app = app
self._local = Local()
self._local_manager = LocalManager([self._local])
self.wsgi_app = self._local_manager.make_middleware(self.wsgi_app)
self._request = self._local("request")
self._cookie = self._local("cookie")
def create_application(from_file):
if from_file:
work_dir = os.path.dirname(os.path.abspath(from_file))
else:
work_dir = os.getcwd()
os.chdir(work_dir)
static_files = {'/static': os.path.join(work_dir, 'static')}
jam.context = Local()
local_manager = LocalManager([jam.context])
application = App(work_dir)
application = SharedDataMiddleware(application, static_files)
application = local_manager.make_middleware(application)
return application
def create_application(from_file=None, load_task=False, testing=False):
if from_file:
if os.path.isfile(from_file):
work_dir = os.path.dirname(from_file)
else:
work_dir = from_file
else:
work_dir = os.getcwd()
work_dir = os.path.realpath(work_dir)
os.chdir(work_dir)
static_files = {'/static': os.path.join(work_dir, 'static')}
jam.context = Local()
local_manager = LocalManager([jam.context])
application = App(work_dir, load_task)
if not testing:
application = SharedDataMiddleware(application, static_files)
application = local_manager.make_middleware(application)
return application
def create_application(from_file=None):
if from_file:
if os.path.isfile(from_file):
work_dir = os.path.dirname(from_file)
else:
work_dir = from_file
else:
work_dir = os.getcwd()
work_dir = os.path.realpath(work_dir)
os.chdir(work_dir)
static_files = {
'/static': os.path.join(work_dir, 'static')
}
jam.context = Local()
local_manager = LocalManager([jam.context])
application = App(work_dir)
application = SharedDataMiddleware(application, static_files)
application = local_manager.make_middleware(application)
return application
def __init__(self, app):
"""Initialize the middleware, and chain it to the given app.
app (function): a WSGI application.
"""
self._app = app
self._local = Local()
self._local_manager = LocalManager([self._local])
self.wsgi_app = self._local_manager.make_middleware(self.wsgi_app)
self._request = self._local("request")
self._cookie = self._local("cookie")
def __init__(self, debug=False):
# Application.__setattr__ depends on _properties so we need to set it
# using the parent implementation. A bit magic
super(Application, self).__setattr__('_properties', {})
self._methods = {}
self.debug = debug
# reference to the bottom of a stack of wsgi middleware wrapping
# :method:`_dispatch_request`. Invoked by :method:`__call__`.
# Essentially the real wsgi application.
self._stack = self._dispatch_request
# TODO provide a way of adding request specific variables. Need to be
# able to register name, `(Application, wsgi_env) -> value` pairs
# Alternatively get rid of this entirely as it's a massive hack
self._local = Local()
self._wsgi_env = self._local('wsgi_env')
self._map_adapter = self._local('map_adapter')
local_manager = LocalManager([self._local])
self.add_middleware(local_manager.make_middleware)
sys.path.insert(0, 'lib')
from werkzeug.wrappers import Request, Response
from werkzeug.local import LocalManager
from webnotes.middlewares import StaticDataMiddleware
from werkzeug.exceptions import HTTPException
from werkzeug.contrib.profiler import ProfilerMiddleware
from webnotes import get_config
import mimetypes
import webnotes
import webnotes.handler
import webnotes.auth
import webnotes.webutils
local_manager = LocalManager([webnotes.local])
@Request.application
def application(request):
webnotes.local.request = request
try:
site = webnotes.utils.get_site_name(request.host)
webnotes.init(site=site)
webnotes.local.form_dict = webnotes._dict({ k:v[0] if isinstance(v, (list, tuple)) else v \
for k, v in (request.form or request.args).iteritems() })
webnotes.local._response = Response()
def create_app():
local = Local()
local_manager = LocalManager([local])
app = local_manager.make_middleware(Olaf())
app = set_statics(app)
return app
from werkzeug.local import Local, LocalManager
local = Local()
local_manager = LocalManager()
request = local('request')
"""from werkzeug.local import Local, LocalManager
if __name__ == "__main__":
local = Local()
#request = LocalProxy(local, 'request')
request = ('request')
local_manager = LocalManager([local])
#request = LocalProxy(local, 'request')
#request = LocalManager([local])"""
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from __future__ import unicode_literals
from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
from builtins import * # noqa
from werkzeug.local import Local, LocalManager, release_local
# a per request context. Generally, this will be the equivelant of thread local
# storage, but if greenlets are being used, it will be a greenlet local.
request_context = Local()
# used in wsgi stack for clean up
_manager = LocalManager(request_context)
cleanup_middleware = _manager.make_middleware
def cleanup():
release_local(request_context)
class AWSAuthMiddleware(object):
"""Handler for the low-level tasks of admin authentication.
Intercepts all requests and responses to AWS, parses the auth
cookie to retrieve the admin, provides an interface for the rest of
the application to access and modify this information, and then
writes the headers to update the cookie.
A single instance of this class manages the cookies for all current
requests at the same time, using a Local object from Werkzeug.
"""
COOKIE = "awslogin"
def __init__(self, app):
"""Initialize the middleware, and chain it to the given app.
app (function): a WSGI application.
"""
self._app = app
self._local = Local()
self._local_manager = LocalManager([self._local])
self.wsgi_app = self._local_manager.make_middleware(self.wsgi_app)
self._request = self._local("request")
self._cookie = self._local("cookie")
@property
def admin_id(self):
"""Return the ID of the admin.
It's the value that has been read from the cookie and (if
modified by the rest of the application) will be written back.
returns (int or None): the ID of the admin, if logged in.
"""
return self._cookie.get("id", None)
def set(self, admin_id):
"""Set the admin ID that will be stored in the cookie.
admin_id (int): the ID of the admin (to unset don't pass None:
use clear()).
"""
self._cookie["id"] = admin_id
self._cookie["ip"] = self._request.remote_addr
self.refresh()
def refresh(self):
"""Update the timestamp that will be stored in the cookie.
"""
self._cookie["timestamp"] = make_timestamp()
def clear(self):
"""Remove all fields from the cookie.
This doesn't actually cause the client to remove the cookie, it
just makes it update the stored cookie to an empty value.
"""
self._cookie.clear()
def __call__(self, environ, start_response):
"""Invoke the class as a WSGI application.
environ (dict): the WSGI environment.
start_response (function): the WSGI start_response callable.
returns (iterable): the WSGI response data.
"""
return self.wsgi_app(environ, start_response)
def wsgi_app(self, environ, start_response):
"""Invoke the class as a WSGI application.
environ (dict): the WSGI environment.
start_response (function): the WSGI start_response callable.
returns (iterable): the WSGI response data.
"""
self._local.request = Request(environ)
self._local.cookie = JSONSecureCookie.load_cookie(
self._request, AWSAuthMiddleware.COOKIE, config.secret_key)
self._verify_cookie()
def my_start_response(status, headers, exc_info=None):
"""Wrapper for the server-provided start_response.
Once called by the application, modifies the received
parameters to add the Set-Cookie parameter (if needed)
and then forwards everything to the server.
"""
response = Response(status=status, headers=headers)
self._cookie.save_cookie(
response, AWSAuthMiddleware.COOKIE, httponly=True)
return start_response(
status, response.headers.to_wsgi_list(), exc_info)
return self._app(environ, my_start_response)
def _verify_cookie(self):
"""Check whether the cookie is valid, and if not clear it.
"""
# Clearing an empty cookie marks it as modified and causes it
# to be sent in the response. This check prevents it.
if len(self._cookie) == 0:
return
admin_id = self._cookie.get("id", None)
remote_addr = self._cookie.get("ip", None)
timestamp = self._cookie.get("timestamp", None)
if admin_id is None or remote_addr is None or timestamp is None:
self.clear()
return
if not isinstance(admin_id, int) or not isinstance(timestamp, float):
self.clear()
return
if remote_addr != self._request.remote_addr:
self.clear()
return
if make_timestamp() - timestamp > config.admin_cookie_duration:
self.clear()
return
class Db:
def __init__(self, database_url: str, **options):
self._local = Local()
self._local_manager = LocalManager([self._local])
self._database_url = database_url
self._options = options
self.engine: Engine = self.create_engine()
self.metadata = MetaData()
self.session_mkr = sessionmaker(bind=self.engine)
self.session = self.session_mkr(autocommit=True) # type: Session
def create_engine(self) -> Engine:
return create_engine(self._database_url, **self._options)
def connect(self):
try:
self._local.connection
except AttributeError:
return self._new_connection_context()
return self._reuse_connection_context()
@property
def s(self) -> Session:
return self.session
@contextmanager
def _new_connection_context(self):
logger.debug('[%s] Getting new connection from pool', self._local_manager.get_ident())
conn = self.engine.connect()
self._local.connection = conn
yield conn
logger.debug('[%s] Releasing connection to pool', self._local_manager.get_ident())
self._local.connection = None
release_local(self._local)
conn.close()
@contextmanager
def _reuse_connection_context(self):
logger.debug('[%s] Reusing connection', self._local_manager.get_ident())
yield self._local.connection
logger.debug('[%s] Finished using connection', self._local_manager.get_ident())
@contextmanager
def transaction(self, autocommit=True, rollback=False):
with self.connect() as conn:
logger.debug('[%s] Starting transaction', self._local_manager.get_ident())
trans = conn.begin_nested()
try:
yield conn
if autocommit:
logger.debug('[%s] Committing transaction', self._local_manager.get_ident())
trans.commit()
if rollback:
logger.debug('[%s] Rolling back transaction', self._local_manager.get_ident())
trans.rollback()
except Exception:
logger.debug('[%s] Rolling back transaction (exception)',
self._local_manager.get_ident())
trans.rollback()
raise
def execute(self, *args, **kwargs) -> ResultProxy:
with self.connect() as conn:
return conn.execute(*args, **kwargs)
def execute_batch(self, records: list) -> None:
with self.connect() as conn:
for r in records:
conn.execute(r)
from werkzeug.local import LocalManager
from werkzeug.exceptions import HTTPException, NotFound
from werkzeug.contrib.profiler import ProfilerMiddleware
from werkzeug.wsgi import SharedDataMiddleware
import mimetypes
import frappe
import frappe.handler
import frappe.auth
import frappe.api
import frappe.utils.response
import frappe.website.render
from frappe.utils import get_site_name
from frappe.middlewares import StaticDataMiddleware
local_manager = LocalManager([frappe.local])
_site = None
_sites_path = os.environ.get("SITES_PATH", ".")
logger = frappe.get_logger()
@Request.application
def application(request):
frappe.local.request = request
frappe.local.is_ajax = frappe.get_request_header("X-Requested-With")=="XMLHttpRequest"
response = None
try:
rollback = True
import dataent.api
import dataent.utils.response
import dataent.website.render
from dataent.utils import get_site_name
from dataent.middlewares import StaticDataMiddleware
from dataent.utils.error import make_error_snapshot
from dataent.core.doctype.communication.comment import update_comments_in_parent_after_request
from dataent import _
# imports - third-party imports
import pymysql
from pymysql.constants import ER
# imports - module imports
local_manager = LocalManager([dataent.local])
_site = None
_sites_path = os.environ.get("SITES_PATH", ".")
class RequestContext(object):
def __init__(self, environ):
self.request = Request(environ)
def __enter__(self):
init_request(self.request)
def __exit__(self, type, value, traceback):
dataent.destroy()
def configure(self) -> None:
self._locals = Local()
self._local_manager = LocalManager([self._locals])
self.prepare()
from datetime import datetime, timedelta
import os
import sys
from werkzeug.exceptions import HTTPException, BadRequestKeyError
from werkzeug.local import LocalManager
from werkzeug.serving import run_simple
from werkzeug.utils import import_string
from .config import ShakeSettings
from .routes import Map, Rule
from .helpers import local
from .serializers import to_json
from .wrappers import Request, Response
local_manager = LocalManager([local])
SECRET_KEY_MINLEN = 20
STATIC_DIR = 'static'
WELCOME_MESSAGE = "Welcome aboard. You're now using Shake!"
class Shake(object):
"""Implements a WSGI application and acts as the central
object.
:param url_map: Sequence of url rules.
:param settings: A module or dict with the custom settings.
Usually you create a :class:Shake instance in your main module or
in the `__init__.py` file of your package like this::
from werkzeug.exceptions import abort
from werkzeug.local import Local, LocalManager, LocalProxy
from werkzeug.routing import Map, Rule
from werkzeug.serving import run_simple
from werkzeug.wrappers import Request, Response
from .errors import get_status_code_from_error_code
__all__ = ["Server", "DebuggedJsonRpcApplication", "current_request"]
DEFAULT_API_ENDPOINT_NAME = "/api"
_CURRENT_REQUEST_KEY = "current_request"
_local = Local() # pylint: disable=invalid-name
_LOCAL_MANAGER = LocalManager([_local])
current_request = LocalProxy(_local, _CURRENT_REQUEST_KEY) # pylint: disable=invalid-name
"""A thread-local which stores the current request object when dispatching requests for
:class:`Server`.
Stores a :class:`werkzeug.wrappers.Request`.
.. versionadded:: 0.2.0
"""
class Server(object):
"""A basic WSGI-compatible server for typedjsonrpc endpoints.
:attribute registry: The registry for this server
def configure(self):
self._locals = Local()
self._local_manager = LocalManager([self._locals])
self.reset()
from werkzeug.local import Local, LocalManager
context = Local()
local_manager = LocalManager([context])
def release_context():
local_manager.cleanup()
# Soft dependency on Werkzeug
try:
from werkzeug.local import Local, LocalManager
from werkzeug.routing import Map, Rule
local = Local()
local_manager = LocalManager([local])
except:
from cubes.common import MissingPackage
_missing = MissingPackage("werkzeug", "Slicer server")
Local = LocalManager = _missing
Map = Rule = _missing
local = _missing
local_manager = _missing
class AWSAuthMiddleware(object):
"""Handler for the low-level tasks of admin authentication.
Intercepts all requests and responses to AWS, parses the auth
cookie to retrieve the admin, provides an interface for the rest of
the application to access and modify this information, and then
writes the headers to update the cookie.
A single instance of this class manages the cookies for all current
requests at the same time, using a Local object from Werkzeug.
"""
COOKIE = "awslogin"
def __init__(self, app):
"""Initialize the middleware, and chain it to the given app.
app (function): a WSGI application.
"""
self._app = app
self._local = Local()
self._local_manager = LocalManager([self._local])
self.wsgi_app = self._local_manager.make_middleware(self.wsgi_app)
self._request = self._local("request")
self._cookie = self._local("cookie")
@property
def admin_id(self):
"""Return the ID of the admin.
It's the value that has been read from the cookie and (if
modified by the rest of the application) will be written back.
returns (int or None): the ID of the admin, if logged in.
"""
return self._cookie.get("id", None)
def set(self, admin_id):
"""Set the admin ID that will be stored in the cookie.
admin_id (int): the ID of the admin (to unset don't pass None:
use clear()).
"""
self._cookie["id"] = admin_id
self._cookie["ip"] = self._request.remote_addr
self.refresh()
def refresh(self):
"""Update the timestamp that will be stored in the cookie.
"""
self._cookie["timestamp"] = make_timestamp()
def clear(self):
"""Remove all fields from the cookie.
This doesn't actually cause the client to remove the cookie, it
just makes it update the stored cookie to an empty value.
"""
self._cookie.clear()
def __call__(self, environ, start_response):
"""Invoke the class as a WSGI application.
environ (dict): the WSGI environment.
start_response (function): the WSGI start_response callable.
returns (iterable): the WSGI response data.
"""
return self.wsgi_app(environ, start_response)
def wsgi_app(self, environ, start_response):
"""Invoke the class as a WSGI application.
environ (dict): the WSGI environment.
start_response (function): the WSGI start_response callable.
returns (iterable): the WSGI response data.
"""
self._local.request = Request(environ)
self._local.cookie = JSONSecureCookie.load_cookie(
self._request, AWSAuthMiddleware.COOKIE,
hex_to_bin(config.secret_key))
self._verify_cookie()
def my_start_response(status, headers, exc_info=None):
"""Wrapper for the server-provided start_response.
Once called by the application, modifies the received
parameters to add the Set-Cookie parameter (if needed)
and then forwards everything to the server.
"""
response = Response(status=status, headers=headers)
self._cookie.save_cookie(response,
AWSAuthMiddleware.COOKIE,
httponly=True)
return start_response(status, response.headers.to_wsgi_list(),
exc_info)
return self._app(environ, my_start_response)
def _verify_cookie(self):
"""Check whether the cookie is valid, and if not clear it.
"""
# Clearing an empty cookie marks it as modified and causes it
# to be sent in the response. This check prevents it.
if len(self._cookie) == 0:
return
admin_id = self._cookie.get("id", None)
remote_addr = self._cookie.get("ip", None)
timestamp = self._cookie.get("timestamp", None)
if admin_id is None or remote_addr is None or timestamp is None:
self.clear()
return
if not isinstance(admin_id, int) or not isinstance(timestamp, float):
self.clear()
return
if remote_addr != self._request.remote_addr:
self.clear()
return
if make_timestamp() - timestamp > config.admin_cookie_duration:
self.clear()
return
import frappe
import frappe.handler
import frappe.auth
import frappe.api
import frappe.utils.response
import frappe.website.render
from frappe.utils import get_site_name, sanitize_html
from frappe.middlewares import StaticDataMiddleware
from frappe.utils.error import make_error_snapshot
from frappe.core.doctype.comment.comment import update_comments_in_parent_after_request
from frappe import _
import frappe.recorder
import frappe.monitor
import frappe.rate_limiter
local_manager = LocalManager([frappe.local])
_site = None
_sites_path = os.environ.get("SITES_PATH", ".")
class RequestContext(object):
def __init__(self, environ):
self.request = Request(environ)
def __enter__(self):
init_request(self.request)
def __exit__(self, type, value, traceback):
frappe.destroy()
import os
import sys
from werkzeug.exceptions import HTTPException, BadRequestKeyError
from werkzeug.local import LocalManager
from werkzeug.serving import run_simple
from werkzeug.utils import import_string
from .config import ShakeSettings
from .routes import Map, Rule
from .helpers import local
from .serializers import to_json
from .wrappers import Request, Response
local_manager = LocalManager([local])
SECRET_KEY_MINLEN = 20
STATIC_DIR = 'static'
WELCOME_MESSAGE = "Welcome aboard. You're now using Shake!"
class Shake(object):
"""Implements a WSGI application and acts as the central
object.
:param url_map: Sequence of url rules.
:param settings: A module or dict with the custom settings.
Usually you create a :class:Shake instance in your main module or
in the `__init__.py` file of your package like this::
