def __call__(self, environ, start_response): request = Request(environ) path_info = request.path_info route_match = routing.mapping.match(path_info) if route_match is None: # If there's an equivalent URL that ends with /, redirect # to that. if not path_info.endswith('/') \ and request.method == 'GET' \ and routing.mapping.match(path_info + '/'): new_path_info = path_info + '/' if request.GET: new_path_info = '%s?%s' % (new_path_info, urllib.urlencode(request.GET)) redirect = exc.HTTPFound(location=new_path_info) return request.get_response(redirect)(environ, start_response) # Return a 404 response = util.generate_404_response(request, routing, environ, self.staticdirector) return response(environ, start_response) controller = load_controller(route_match['controller']) request.start_response = start_response request.matchdict = route_match request.urlgen = routes.URLGenerator(routing.mapping, environ) request.staticdirect = self.staticdirector return controller(request)(environ, start_response)
def __init__(self, core, runtime, method, group): Framework.CoreObject.__init__(self, core) self._method = method self._route_lock = runtime.lock() self._route_controllers = {} self._route_mapper = routes.Mapper() self._route_generator = routes.URLGenerator(self._route_mapper, {}) self._route_group = group self._arg_types = {}
def generate_404_response(request, routing, environ, staticdirector): """ Create a 'nice looking' 404 response. """ request.matchdict = {} request.urlgen = routes.URLGenerator(routing.mapping, environ) request.staticdirect = staticdirector target_lang = get_target_lang_from_request(request) context = {'page_style': 'bare'} context.update(rtl_context_stuff(target_lang)) return Response(render_template(request, target_lang, 'catalog_pages/404.html', context), status=404)
def __call__(self, req): ''' Glue. A WSGI app is a callable; thus in order to make this object an application, we define __call__ to make it callable. We then ask our Mapper to do some routing, and dispatch to the appropriate method. That method must return a webob.Response. ''' results = self.map.routematch(environ=req.environ) if not results: return webob.exc.HTTPNotFound() match, route = results link = routes.URLGenerator(self.map, req.environ) req.urlvars = ((), match) kwargs = match.copy() method = kwargs.pop('method') req.link = link return getattr(self, method)(req, **kwargs)
def __call__(self, req): results = self.map.routematch(environ=req.environ) if not results: oReply = {'responseCode': 404} return json.dumps(oReply) try: match, route = results link = routes.URLGenerator(self.map, req.environ) req.urlvars = ((), match) kwargs = match.copy() method = kwargs.pop('method') req.link = link return getattr(self, method)(req, **kwargs) except Exception as e: oReply = {'responseCode': 500, 'message': str(e)} return json.dumps(oReply)
def __call__(self, environ, start_response): request = Request(environ) path_info = request.path_info ## Routing / controller loading stuff route_match = self.routing.match(path_info) # No matching page? if route_match is None: # Try to do see if we have a match with a trailing slash # added and if so, redirect if not path_info.endswith('/') \ and request.method == 'GET' \ and self.routing.match(path_info + '/'): new_path_info = path_info + '/' if request.GET: new_path_info = '%s?%s' % (new_path_info, urllib.urlencode(request.GET)) redirect = exc.HTTPFound(location=new_path_info) return request.get_response(redirect)(environ, start_response) # Okay, no matches. 404 time! return exc.HTTPNotFound()(environ, start_response) controller = util.import_component(route_match['controller']) request.start_response = start_response ## Attach utilities to the request object request.matchdict = route_match request.urlgen = routes.URLGenerator(self.routing, environ) # Do we really want to load this via middleware? Maybe? request.session = request.environ['beaker.session'] # Attach self as request.app # Also attach a few utilities from request.app for convenience? request.app = self request.locale = util.get_locale_from_request(request) request.template_env = util.get_jinja_env(self.template_loader, request.locale) request.db = self.db request.staticdirect = self.staticdirector util.setup_user_in_request(request) return controller(request)(environ, start_response)
def __init__(self, **kwargs): """ Initialize session from cherrypy config. """ config = cherrypy.config prefix = self.name_prefix host = config['file_host'] urlgen = routes.URLGenerator(cherrypy.routes_mapper, { 'HTTP_HOST': host, 'HTTPS': 1 }) client_id = config[prefix + '_client_id'] redirect_uri = urlgen(prefix + '_callback', host=host) super(CloudOAuth2Session, self).__init__(client_id=client_id, scope=self.oauth2_scope, redirect_uri=redirect_uri, **kwargs) self.client_secret = config[prefix + '_client_secret'] self.ebook = None self.mount("http://", http_adapter) self.mount("https://", https_adapter)
from i18n_tool import ugettext as _ import BaseSearcher # pylint: disable=R0921 http_adapter = requests.adapters.HTTPAdapter () https_adapter = requests.adapters.HTTPAdapter () # Google Drive `bugĀ“ see: # https://github.com/idan/oauthlib/commit/ca4811b3087f9d34754d3debf839e247593b8a39 os.environ['OAUTHLIB_RELAX_TOKEN_SCOPE'] = '1' config = cherrypy.config urlgen = routes.URLGenerator (cherrypy.routes_mapper, { 'HTTP_HOST': config['file_host'], 'HTTPS': config['host_https'] }) def log (msg): """ Log an informational message. """ cherrypy.log (msg, context = 'CLOUDSTORAGE', severity = logging.INFO) def error_log (msg): """ Log an error message. """ cherrypy.log ('Error: ' + msg, context = 'CLOUDSTORAGE', severity = logging.ERROR) class CloudOAuth2Session (requests_oauthlib.OAuth2Session): # pylint: disable=R0904 """ An OAuth2 session. """
def __init__(self): self.format = None self.page = None self.template = None self.query = None self.id = None self.sort_order = None self.search_terms = None self.start_index = 1 self.items_per_page = 1 self.total_results = -1 self.page_mode = 'screen' self.user_dialog = ('', '') self.opensearch_support = 0 # 0 = none, 1 = full, 2 = fake(Stanza, Aldiko, ...) self.books_in_archive = babel.numbers.format_number( books_in_archive, locale=str(cherrypy.response.i18n.locale)) self.breadcrumbs = [ (_('Project Gutenberg'), _('Go to the Main page.'), '/'), (__('1 free ebook', '{count} free ebooks', books_in_archive).format(count=self.books_in_archive), _('Start a new search.'), '/ebooks/'), ] # default output formatting functions self.f_format_title = self.format_title self.f_format_subtitle = self.format_author self.f_format_extra = self.format_none # depends on sort order, set in fix_sortorder () self.f_format_url = self.format_bibrec_url self.f_format_thumb_url = self.format_thumb_url self.f_format_icon = self.format_icon # icon class self.user_agent = cherrypy.request.headers.get('User-Agent', '') cherrypy.request.os = self s = cherrypy.session k = cherrypy.request.params host = cherrypy.request.headers.get('X-Forwarded-Host', cherrypy.config['host']) self.host = host.split(',')[-1].strip() # keep only the last hub # turns out X-Forwarded-Protocol (X-Forwarded-Proto is the defacto standaard) # is not a thing and has to be set in HAProxy self.protocol = cherrypy.request.headers.get('X-Forwarded-Protocol', 'https') # sanity check if self.host not in (cherrypy.config['all_hosts']): self.host = cherrypy.config['host'] if self.protocol not in VALID_PROTOCOLS: self.protocol = 'https' self.urlgen = routes.URLGenerator(cherrypy.routes_mapper, {'HTTP_HOST': self.host}) self.set_format(k.get('format')) # query: this param is set when an actual query is requested self.query = '' if 'query' in k: self.query = SQLStatement.preprocess_query(k['query']) # search_terms: this is used to carry the last query # to display in the search input box self.search_terms = self.query or s.get('search_terms', '') self.sort_order = k.get('sort_order') or s.get( 'sort_order') or USER_SORT_ORDERS[0] if self.sort_order not in USER_SORT_ORDERS: raise cherrypy.HTTPError(400, 'Bad Request. Unknown sort order.') s['sort_order'] = self.sort_order try: self.id = int(k.get('id') or '0') self.start_index = int(k.get('start_index') or '1') self.items_per_page = min(100, int(k.get('items_per_page') or '25')) except ValueError as what: raise cherrypy.HTTPError(400, 'Bad Request. ' + str(what)) self.file_host = cherrypy.config['file_host'] self.now = datetime.datetime.utcnow().replace( microsecond=0).isoformat() + 'Z' self.do_animations = 'Kindle/' not in self.user_agent # no animations on e-ink self.ip = cherrypy.request.remote.ip self.type_opds = 'application/atom+xml;profile=opds-catalog' self.base_url = None self.canonical_url = None self.entries = [] # NOTE: For page titles etc. self.pg = self.title = _('Project Gutenberg') # NOTE: The tagline at the top of every page. self.tagline = _( 'Project Gutenberg offers {count} free ebooks to download.' ).format(count=self.books_in_archive) # NOTE: The site's description in the html meta tags. self.description = _( 'Project Gutenberg offers {count} free ebooks for ' 'Kindle, iPad, Nook, Android, and iPhone.').format( count=self.books_in_archive) # NOTE: The placeholder inside an empty search box. self.placeholder = _('Search Project Gutenberg.') # these need to be here because they have to be localized # NOTE: Msg to user indicating the order of the search results. self.sorted_msgs = { 'downloads': _("sorted by popularity"), 'release_date': _("sorted by release date"), 'quantity': _("sorted by quantity of books"), 'title': _("sorted alphabetically"), 'alpha': _("sorted alphabetically by title"), 'author': _("sorted alphabetically by author"), 'nentry': _("sorted by relevance"), 'random': _("in random order"), } self.snippet_image_url = self.url('/pics/logo-144x144.png', host=self.file_host) self.og_type = 'website' self.class_ = ClassAttr() self.title_icon = None self.icon = None self.sort_orders = [] self.alternate_sort_orders = [] lang = self.lang = s.get('_lang_', 'en_US') if len(lang) == 2: lang = self.lang_to_default_locale.get(lang, 'en_US') lang2 = self.lang[:2] self.paypal_lang = lang if lang in PAYPAL_LANGS else 'en_US' self.flattr_lang = lang if lang in FLATTR_LANGS else 'en_US' lang = lang.replace('_', '-') self.google_lang = lang if lang in GOOGLE_LANGS else ( lang2 if lang2 in GOOGLE_LANGS else 'en-US') lang = lang.lower() self.twitter_lang = lang if lang in TWITTER_LANGS else ( lang2 if lang2 in TWITTER_LANGS else 'en') self.viewport = "width=device-width" # , initial-scale=1.0" self.touch_icon = '/gutenberg/apple-icon.png' self.touch_icon_precomposed = None # not yet used if 'user_dialog' in s: self.user_dialog = s['user_dialog'] del s['user_dialog'] msg = k.get('msg') if msg is not None: if msg == 'welcome_stranger': self.user_dialog = (_( "Welcome to Project Gutenberg. " "You'll find here {count} ebooks completely free of charge." ).format(count=self.books_in_archive), _('Welcome'))
def __init__(self, mapper=None): if mapper is None: mapper = routes.Mapper() self._generator = routes.URLGenerator(mapper, {}) # XXX: environ self._mapper = mapper
content = self.get_history_dataset_association( trans, history, content_id, check_ownership=True, check_accessible=True) except Exception, e: return str(e) try: item = content.get_api_value(view='element') if trans.user_is_admin() or trans.app.config.expose_dataset_path: item['file_name'] = content.file_name if not item['deleted']: # Problem: Method url_for cannot use the dataset controller # Get the environment from DefaultWebTransaction and use default webapp mapper instead of webapp API mapper url = routes.URLGenerator(trans.webapp.mapper, trans.environ) # http://routes.groovie.org/generating.html # url_for is being phased out, so new applications should use url item['download_url'] = url(controller='dataset', action='display', dataset_id=trans.security.encode_id( content.id), to_ext=content.ext) item = self.encode_all_ids(trans, item) except Exception, e: item = "Error in history API at listing dataset" log.error(item + ": %s" % str(e)) trans.response.status = 500 return item @web.expose_api
def __init__(self): super().__init__() self.host = cherrypy.config['host'] self.urlgen = routes.URLGenerator(cherrypy.routes_mapper, {'HTTP_HOST': self.host}) self.formatter = formatters['html']
import routes import PMS routemap = routes.Mapper() routegen = routes.URLGenerator(routemap, {}) controllers = {} def ConnectRoute(path, action="__NONE__", **kwargs): def ConnectRoute_inner(f): if f.__name__ not in controllers: controllers[f.__name__] = f routemap.connect(None, path, controller=f.__name__, action=action, **kwargs) PMS.Log("(Framework) Created a new route: %s => %s" % (path, f.__name__)) return f return ConnectRoute_inner def GenerateRoute(f, action='__NONE__', **kwargs): return PMS.Plugin.CurrentPrefix() + routegen(controller=f.__name__, action=action, **kwargs) def MatchRoute(path): try: d = routemap.match(path) if not d: raise else: f = controllers[d["controller"]] del d["controller"] if d["action"] == "__NONE__": del d["action"] return f, d except: return None, None
new_path_info = path_info + '/' if request.GET: new_path_info = '%s?%s' % ( new_path_info, urllib.urlencode(request.GET)) redirect = exc.HTTPFound(location=new_path_info) return request.get_response(redirect)(environ, start_response) # Return a 404 response = util.generate_404_response( request, routing, environ, self.staticdirector) return response(environ, start_response) controller = load_controller(route_match['controller']) request.start_response = start_response request.matchdict = route_match request.urlgen = routes.URLGenerator(routing.mapping, environ) request.staticdirect = self.staticdirector return controller(request)(environ, start_response) def ccengine_app_factory(global_config, **kw): if kw.has_key('direct_remote_path'): staticdirector = staticdirect.RemoteStaticDirect( kw['direct_remote_path'].strip()) elif kw.has_key('direct_remote_paths'): staticdirector = staticdirect.MultiRemoteStaticDirect( dict([line.strip().split(' ', 1) for line in kw['direct_remote_paths'].strip().splitlines()])) else: raise ImproperlyConfigured(
def __init__(self): self.host = cherrypy.config['host'] self.urlgen = routes.URLGenerator(cherrypy.routes_mapper, {'HTTP_HOST': self.host})