def parse_path_info(path_info, av=False):
"""
Parse path info formatted like a/c/f where c and f are optional
and a leading / accepted.
Return tuple (a, c, f). If invalid path_info a is set to None.
If c or f are omitted they are set to None.
If av=True, parse args and vars
"""
if av:
vars = None
if '?' in path_info:
path_info, query = path_info.split('?', 2)
vars = Storage()
for var in query.split('&'):
(var, val) = var.split('=', 2) if '=' in var else (var, None)
vars[var] = val
items = List(path_info.split('/'))
args = List(items[3:]) if len(items) > 3 else None
return (items(0), items(1), items(2), args, vars)
mo = re.match(r'^/?(?P<a>\w+)(/(?P<c>\w+)(/(?P<f>\w+))?)?$', path_info)
if mo:
return (mo.group('a'), mo.group('c'), mo.group('f'))
else:
return (None, None, None)
def __call__(self, c=None, f='index', args=[], vars={},
extension=None, target=None,ajax=False,ajax_trap=False,
url=None):
import globals
target = target or 'c'+str(random.random())[2:]
request = self.environment['request']
if '.' in f:
f, extension = f.split('.',1)
if c and not url and not ajax:
other_environment = copy.copy(self.environment)
other_request = globals.Request()
other_request.application = request.application
other_request.controller = c
other_request.function = f
other_request.extension = extension or request.extension
other_request.args = List(args)
other_request.folder = request.folder
other_request.env = request.env
if not ajax_trap:
other_request.vars = request.vars
other_request.get_vars = request.get_vars
other_request.post_vars = request.post_vars
else:
other_request.vars = vars
other_environment['request'] = other_request
other_response = globals.Response()
other_environment['response'] = other_response
other_response._view_environment = other_environment
other_request.env.http_web2py_component_location = \
request.env.path_info
other_request.env.http_web2py_component_element = target
other_response.view = '%s/%s.%s' % (c,f, other_request.extension)
page = run_controller_in(c, f, other_environment)
if isinstance(page, dict):
other_response._vars = page
for key in page:
other_response._view_environment[key] = page[key]
run_view_in(other_response._view_environment)
page = other_response.body.getvalue()
script = ''
if ajax_trap:
script += "web2py_trap_form('%s','%s');" % \
(html.URL(request.application,c,f,
args=args,vars=vars,
extension=extension),target)
#for (name,value) in other_response.headers:
# if name == 'web2py-component-command':
# script += value
return html.TAG[''](html.DIV(html.XML(page),_id=target),
html.SCRIPT(script,_type="text/javascript"))
else:
url = url or html.URL(request.application,c,
f, args=args,vars=vars,
extension=extension)
return html.TAG[''](html.SCRIPT('web2py_component("%s","%s")' % \
(url,target),
_type="text/javascript"),
html.DIV('loading...',_id=target))
def map_prefix(self):
"strip path prefix, if present in its entirety"
prefix = routers.BASE.path_prefix
if prefix:
prefixlen = len(prefix)
if prefixlen > len(self.args):
return
for i in xrange(prefixlen):
if prefix[i] != self.args[i]:
return # prefix didn't match
self.args = List(self.args[prefixlen:]) # strip the prefix
def test_listcall(self):
a = List((1, 2, 3))
self.assertEqual(a(1), 2)
self.assertEqual(a[1], 2)
self.assertEqual(a(3), None)
self.assertEqual(a[3], None)
self.assertEqual(a(-1), 3)
self.assertEqual(a(-5), None)
self.assertEqual(a[-5], None)
self.assertEqual(a(-5, default='x'), 'x')
self.assertEqual(a(-3, cast=str), '1')
a.append('1234')
self.assertEqual(a(3), '1234')
self.assertEqual(a(3, cast=int), 1234)
a.append('x')
self.assertRaises(HTTP, a, 4, cast=int)
b = List()
self.assertEqual(b(0, cast=int, default=None), None)
self.assertEqual(b(0, cast=int, default=None, otherwise='something'),
None)
def test_listcall(self):
a = List((1, 2, 3))
self.assertEqual(a(1), 2)
self.assertEqual(a(-1), 3)
self.assertEqual(a(-5), None)
self.assertEqual(a(-5, default='x'), 'x')
self.assertEqual(a(-3, cast=str), '1')
a.append('1234')
self.assertEqual(a(3), '1234')
self.assertEqual(a(3, cast=int), 1234)
a.append('x')
self.assertRaises(HTTP, a, 4, cast=int)
def __init__(self, request=None, env=None):
"initialize a map-in object"
self.request = request
self.env = env
self.router = None
self.application = None
self.language = None
self.controller = None
self.function = None
self.extension = 'html'
self.controllers = set()
self.functions = dict()
self.languages = set()
self.default_language = None
self.map_hyphen = False
self.exclusive_domain = False
path = self.env['PATH_INFO']
self.query = self.env.get('QUERY_STRING', None)
path = path.lstrip('/')
self.env['PATH_INFO'] = '/' + path
self.env['WEB2PY_ORIGINAL_URI'] = self.env['PATH_INFO'] + (
self.query and ('?' + self.query) or '')
# to handle empty args, strip exactly one trailing slash, if present
# .../arg1// represents one trailing empty arg
#
if path.endswith('/'):
path = path[:-1]
self.args = List(path and path.split('/') or [])
# see http://www.python.org/dev/peps/pep-3333/#url-reconstruction for URL composition
self.remote_addr = self.env.get('REMOTE_ADDR', 'localhost')
self.scheme = self.env.get('wsgi.url_scheme', 'http').lower()
self.method = self.env.get('REQUEST_METHOD', 'get').lower()
self.host = self.env.get('HTTP_HOST')
self.port = None
if not self.host:
self.host = self.env.get('SERVER_NAME')
self.port = self.env.get('SERVER_PORT')
if not self.host:
self.host = 'localhost'
self.port = '80'
if ':' in self.host:
(self.host, self.port) = self.host.split(':')
if not self.port:
if self.scheme == 'https':
self.port = '443'
else:
self.port = '80'
def __init__(self):
self.wsgi = Storage() # hooks to environ and start_response
self.env = Storage()
self.cookies = Cookie.SimpleCookie()
self.get_vars = Storage()
self.post_vars = Storage()
self.vars = Storage()
self.folder = None
self.application = None
self.function = None
self.args = List()
self.extension = None
self.now = datetime.datetime.today()
def __init__(self, input_string, storage='list', basetype=None):
"""
Creates new graph
:param input_string: string representation of graph
:param storage: list or matrix
:param basetype: type of values stored in nodes
"""
if storage == 'list':
self.storage = List(input_string, basetype)
elif storage == 'matrix':
self.storage = Matrix(input_string, basetype)
self.vertices, self.edges = self.storage.vertices, self.storage.edges
def test_listcall(self):
a = List((1, 2, 3))
self.assertEqual(a(1), 2)
self.assertEqual(a(-1), 3)
self.assertEqual(a(-5), None)
self.assertEqual(a(-5, default='x'), 'x')
self.assertEqual(a(-3, cast=str), '1')
a.append('1234')
self.assertEqual(a(3), '1234')
self.assertEqual(a(3, cast=int), 1234)
a.append('x')
self.assertRaises(HTTP, a, 4, cast=int)
b = List()
# default is always returned when especified
self.assertEqual(b(0, cast=int, default=None), None)
self.assertEqual(b(0, cast=int, default=None, otherwise='teste'), None)
self.assertEqual(b(0, cast=int, default='a', otherwise='teste'), 'a')
# if don't have value and otherwise is especified it will called
self.assertEqual(b(0, otherwise=lambda: 'something'), 'something')
self.assertEqual(b(0, cast=int, otherwise=lambda: 'something'),
'something')
# except if default is especified
self.assertEqual(b(0, default=0, otherwise=lambda: 'something'), 0)
def __init__(self):
Storage.__init__(self)
self.env = Storage()
self.cookies = Cookie.SimpleCookie()
self.get_vars = Storage()
self.post_vars = Storage()
self.vars = Storage()
self.folder = None
self.application = None
self.function = None
self.args = List()
self.extension = 'html'
self.now = datetime.datetime.now()
self.utcnow = datetime.datetime.utcnow()
self.is_restful = False
self.is_https = False
self.is_local = False
self.global_settings = settings.global_settings
def __init__(self, env):
Storage.__init__(self)
self.env = Storage(env)
self.env.web2py_path = global_settings.applications_parent
self.env.update(global_settings)
self.cookies = Cookie.SimpleCookie()
self._get_vars = None
self._post_vars = None
self._vars = None
self.folder = None
self.application = None
self.function = None
self.args = List()
self.extension = 'html'
self.now = datetime.datetime.now()
self.utcnow = datetime.datetime.utcnow()
self.is_restful = False
self.is_https = False
self.is_local = False
self.global_settings = settings.global_settings
def __call__(self, c=None, f='index', args=None, vars=None,
extension=None, target=None,ajax=False,ajax_trap=False,
url=None,user_signature=False, content='loading...',**attr):
if args is None: args = []
vars = Storage(vars or {})
import globals
target = target or 'c'+str(random.random())[2:]
attr['_id']=target
request = self.environment['request']
if '.' in f:
f, extension = f.rsplit('.',1)
if url or ajax:
url = url or html.URL(request.application, c, f, r=request,
args=args, vars=vars, extension=extension,
user_signature=user_signature)
script = html.SCRIPT('web2py_component("%s","%s")' % (url, target),
_type="text/javascript")
return html.TAG[''](script, html.DIV(content,**attr))
else:
if not isinstance(args,(list,tuple)):
args = [args]
c = c or request.controller
other_request = Storage(request)
other_request['env'] = Storage(request.env)
other_request.controller = c
other_request.function = f
other_request.extension = extension or request.extension
other_request.args = List(args)
other_request.vars = vars
other_request.get_vars = vars
other_request.post_vars = Storage()
other_response = globals.Response()
other_request.env.path_info = '/' + \
'/'.join([request.application,c,f] + \
map(str, other_request.args))
other_request.env.query_string = \
vars and html.URL(vars=vars).split('?')[1] or ''
other_request.env.http_web2py_component_location = \
request.env.path_info
other_request.cid = target
other_request.env.http_web2py_component_element = target
other_response.view = '%s/%s.%s' % (c,f, other_request.extension)
other_environment = copy.copy(self.environment)
other_response._view_environment = other_environment
other_response.generic_patterns = \
copy.copy(current.response.generic_patterns)
other_environment['request'] = other_request
other_environment['response'] = other_response
## some magic here because current are thread-locals
original_request, current.request = current.request, other_request
original_response, current.response = current.response, other_response
page = run_controller_in(c, f, other_environment)
if isinstance(page, dict):
other_response._vars = page
other_response._view_environment.update(page)
run_view_in(other_response._view_environment)
page = other_response.body.getvalue()
current.request, current.response = original_request, original_response
js = None
if ajax_trap:
link = html.URL(request.application, c, f, r=request,
args=args, vars=vars, extension=extension,
user_signature=user_signature)
js = "web2py_trap_form('%s','%s');" % (link, target)
script = js and html.SCRIPT(js,_type="text/javascript") or ''
return html.TAG[''](html.DIV(html.XML(page),**attr),script)
def LOAD(c=None, f='index', args=None, vars=None,
extension=None, target=None,ajax=False,ajax_trap=False,
url=None,user_signature=False, timeout=None, times=1,
content='loading...',**attr):
""" LOAD a component into the action's document
Timing options:
-times: An integer or string ("infinity"/"continuous")
specifies how many times the component is requested
-timeout (milliseconds): specifies the time to wait before
starting the request or the frequency if times is greater than
1 or "infinity".
Timing options default to the normal behavior. The component
is added on page loading without delay.
"""
from html import TAG, DIV, URL, SCRIPT, XML
if args is None: args = []
vars = Storage(vars or {})
target = target or 'c'+str(random.random())[2:]
attr['_id']=target
request = current.request
if '.' in f:
f, extension = f.rsplit('.',1)
if url or ajax:
url = url or URL(request.application, c, f, r=request,
args=args, vars=vars, extension=extension,
user_signature=user_signature)
# timing options
if isinstance(times, basestring):
if times.upper() in ("INFINITY", "CONTINUOUS"):
times = "Infinity"
else:
raise TypeError("Unsupported times argument %s" % times)
elif isinstance(times, int):
if times <= 0:
raise ValueError("Times argument must be greater than zero, 'Infinity' or None")
else:
raise TypeError("Unsupported times argument type %s" % type(times))
if timeout is not None:
if not isinstance(timeout, (int, long)):
raise ValueError("Timeout argument must be an integer or None")
elif timeout <= 0:
raise ValueError("Timeout argument must be greater than zero or None")
statement = "web2py_component('%s','%s', %s, %s);" \
% (url, target, timeout, times)
else:
statement = "web2py_component('%s','%s');" % (url, target)
script = SCRIPT(statement, _type="text/javascript")
if not content is None:
return TAG[''](script, DIV(content,**attr))
else:
return TAG[''](script)
else:
if not isinstance(args,(list,tuple)):
args = [args]
c = c or request.controller
other_request = Storage(request)
other_request['env'] = Storage(request.env)
other_request.controller = c
other_request.function = f
other_request.extension = extension or request.extension
other_request.args = List(args)
other_request.vars = vars
other_request.get_vars = vars
other_request.post_vars = Storage()
other_response = Response()
other_request.env.path_info = '/' + \
'/'.join([request.application,c,f] + \
map(str, other_request.args))
other_request.env.query_string = \
vars and URL(vars=vars).split('?')[1] or ''
other_request.env.http_web2py_component_location = \
request.env.path_info
other_request.cid = target
other_request.env.http_web2py_component_element = target
other_response.view = '%s/%s.%s' % (c,f, other_request.extension)
other_environment = copy.copy(current.globalenv) ### NASTY
other_response._view_environment = other_environment
other_response.generic_patterns = \
copy.copy(current.response.generic_patterns)
other_environment['request'] = other_request
other_environment['response'] = other_response
## some magic here because current are thread-locals
original_request, current.request = current.request, other_request
original_response, current.response = current.response, other_response
page = run_controller_in(c, f, other_environment)
if isinstance(page, dict):
other_response._vars = page
other_response._view_environment.update(page)
run_view_in(other_response._view_environment)
page = other_response.body.getvalue()
current.request, current.response = original_request, original_response
js = None
if ajax_trap:
link = URL(request.application, c, f, r=request,
args=args, vars=vars, extension=extension,
user_signature=user_signature)
js = "web2py_trap_form('%s','%s');" % (link, target)
script = js and SCRIPT(js,_type="text/javascript") or ''
return TAG[''](DIV(XML(page),**attr),script)
def wsgibase(environ, responder):
"""
this is the gluon wsgi application. the first function called when a page
is requested (static or dynamic). it can be called by paste.httpserver
or by apache mod_wsgi.
- fills request with info
- the environment variables, replacing '.' with '_'
- adds web2py path and version info
- compensates for fcgi missing path_info and query_string
- validates the path in url
The url path must be either:
1. for static pages:
- /<application>/static/<file>
2. for dynamic pages:
- /<application>[/<controller>[/<function>[/<sub>]]][.<extension>]
- (sub may go several levels deep, currently 3 levels are supported:
sub1/sub2/sub3)
The naming conventions are:
- application, controller, function and extension may only contain
[a-zA-Z0-9_]
- file and sub may also contain '-', '=', '.' and '/'
"""
if rewrite.params.routes_in:
environ = rewrite.filter_in(environ)
request = Request()
response = Response()
session = Session()
try:
try:
# ##################################################
# parse the environment variables
# ##################################################
for (key, value) in environ.items():
request.env[key.lower().replace('.', '_')] = value
request.env.web2py_path = web2py_path
request.env.web2py_version = web2py_version
request.env.update(settings)
# ##################################################
# validate the path in url
# ##################################################
if not request.env.path_info and request.env.request_uri:
# for fcgi, decode path_info and query_string
items = request.env.request_uri.split('?')
request.env.path_info = items[0]
if len(items) > 1:
request.env.query_string = items[1]
else:
request.env.query_string = ''
path = request.env.path_info.replace('\\', '/')
# ##################################################
# serve if a static file
# ##################################################
match = regex_static.match(regex_space.sub('_', path))
if match and match.group('x'):
static_file = os.path.join(request.env.web2py_path,
'applications', match.group('b'),
'static', match.group('x'))
if request.env.get('query_string', '')[:10] == 'attachment':
response.headers['Content-Disposition'] = 'attachment'
response.stream(static_file, request=request)
# ##################################################
# parse application, controller and function
# ##################################################
path = re.sub('%20', ' ', path)
match = regex_url.match(path)
if not match or match.group('c') == 'static':
raise HTTP(400,
rewrite.params.error_message,
web2py_error='invalid path')
request.application = \
regex_space.sub('_', match.group('a') or 'init')
request.controller = \
regex_space.sub('_', match.group('c') or 'default')
request.function = \
regex_space.sub('_', match.group('f') or 'index')
group_e = match.group('e')
raw_extension = group_e and regex_space.sub('_', group_e) or None
request.extension = raw_extension or 'html'
request.raw_args = match.group('r')
request.args = List([])
if request.application in rewrite.params.routes_apps_raw:
# application is responsible for parsing args
request.args = None
elif request.raw_args:
match = regex_args.match(request.raw_args)
if match:
group_s = match.group('s')
request.args = \
List((group_s and group_s.split('/')) or [])
else:
raise HTTP(400,
rewrite.params.error_message,
web2py_error='invalid path')
request.client = get_client(request.env)
request.folder = os.path.join(request.env.web2py_path,
'applications',
request.application) + '/'
# ##################################################
# access the requested application
# ##################################################
if not os.path.exists(request.folder):
if request.application == 'init':
request.application = 'welcome'
redirect(URL(r=request))
elif rewrite.params.error_handler:
redirect(
URL(rewrite.params.error_handler['application'],
rewrite.params.error_handler['controller'],
rewrite.params.error_handler['function'],
args=request.application))
else:
raise HTTP(400,
rewrite.params.error_message,
web2py_error='invalid application')
request.url = URL(r=request,
args=request.args,
extension=raw_extension)
# ##################################################
# build missing folder
# ##################################################
if not request.env.web2py_runtime_gae:
for subfolder in [
'models', 'views', 'controllers', 'databases',
'modules', 'cron', 'errors', 'sessions', 'languages',
'static', 'private', 'uploads'
]:
path = os.path.join(request.folder, subfolder)
if not os.path.exists(path):
os.mkdir(path)
# ##################################################
# get the GET and POST data
# ##################################################
parse_get_post_vars(request, environ)
# ##################################################
# expose wsgi hooks for convenience
# ##################################################
request.wsgi.environ = environ_aux(environ, request)
request.wsgi.start_response = lambda status='200', headers=[], \
exec_info=None, response=response: \
start_response_aux(status, headers, exec_info, response)
request.wsgi.middleware = lambda *a: middleware_aux(
request, response, *a)
# ##################################################
# load cookies
# ##################################################
if request.env.http_cookie:
try:
request.cookies.load(request.env.http_cookie)
except Cookie.CookieError, e:
pass # invalid cookies
# ##################################################
# try load session or create new session file
# ##################################################
session.connect(request, response)
# ##################################################
# set no-cache headers
# ##################################################
response.headers['Content-Type'] = contenttype('.' +
request.extension)
response.headers['Cache-Control'] = \
'no-store, no-cache, must-revalidate, post-check=0, pre-check=0'
response.headers['Expires'] = \
time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.gmtime())
response.headers['Pragma'] = 'no-cache'
# ##################################################
# run controller
# ##################################################
serve_controller(request, response, session)
except HTTP, http_response:
if request.body:
request.body.close()
# ##################################################
# on success, try store session in database
# ##################################################
session._try_store_in_db(request, response)
# ##################################################
# on success, commit database
# ##################################################
if response._custom_commit:
response._custom_commit()
else:
BaseAdapter.close_all_instances(BaseAdapter.commit)
# ##################################################
# if session not in db try store session on filesystem
# this must be done after trying to commit database!
# ##################################################
session._try_store_on_disk(request, response)
# ##################################################
# store cookies in headers
# ##################################################
if session._forget:
del response.cookies[response.session_id_name]
elif session._secure:
response.cookies[response.session_id_name]['secure'] = True
if len(response.cookies) > 0:
http_response.headers['Set-Cookie'] = \
[str(cookie)[11:] for cookie in response.cookies.values()]
ticket = None
def test_listgetitem(self):
'''Mantains list behaviour.'''
a = List((1, 2, 3))
self.assertEqual(a[0], 1)
self.assertEqual(a[::-1], [3, 2, 1])
def __call__(self, c=None, f='index', args=[], vars={},
extension=None, target=None,ajax=False,ajax_trap=False,
url=None,user_signature=False, content='loading...',**attr):
import globals
target = target or 'c'+str(random.random())[2:]
attr['_id']=target
request = self.environment['request']
if '.' in f:
f, extension = f.split('.',1)
if url or ajax:
url = url or html.URL(request.application, c, f, r=request,
args=args, vars=vars, extension=extension,
user_signature=user_signature)
script = html.SCRIPT('web2py_component("%s","%s")' % (url, target),
_type="text/javascript")
return html.TAG[''](script, html.DIV(content,**attr))
else:
if not isinstance(args,(list,tuple)):
args = [args]
c = c or request.controller
other_request = globals.Request()
other_request.application = request.application
other_request.controller = c
other_request.function = f
other_request.extension = extension or request.extension
other_request.args = List(args)
other_request.folder = request.folder
other_request.env = request.env
other_request.vars = request.vars
other_request.get_vars = request.get_vars
other_request.post_vars = request.post_vars
other_response = globals.Response()
other_request.env.http_web2py_component_location = \
request.env.path_info
other_request.env.http_web2py_component_element = target
other_response.view = '%s/%s.%s' % (c,f, other_request.extension)
other_environment = copy.copy(self.environment)
other_response._view_environment = other_environment
other_environment['request'] = other_request
other_environment['response'] = other_response
page = run_controller_in(c, f, other_environment)
if isinstance(page, dict):
other_response._vars = page
for key in page:
other_response._view_environment[key] = page[key]
run_view_in(other_response._view_environment)
page = other_response.body.getvalue()
js = None
if ajax_trap:
link = html.URL(request.application, c, f, r=request,
args=args, vars=vars, extension=extension,
user_signature=user_signature)
js = "web2py_trap_form('%s','%s');" % (link, target)
# not sure about this
# for (name,value) in other_response.headers:
# if name == 'web2py-component-command':
# js += value
script = js and html.SCRIPT(js,_type="text/javascript") or ''
return html.TAG[''](html.DIV(html.XML(page),**attr),script)
def regex_url_in(request, environ):
"rewrite and parse incoming URL"
# ##################################################
# select application
# rewrite URL if routes_in is defined
# update request.env
# ##################################################
regex_select(env=environ, request=request)
if thread.routes.routes_in:
environ = regex_filter_in(environ)
for (key, value) in environ.items():
request.env[key.lower().replace('.', '_')] = value
path = request.env.path_info.replace('\\', '/')
# ##################################################
# serve if a static file
# ##################################################
match = regex_static.match(regex_space.sub('_', path))
if match and match.group('x'):
static_file = os.path.join(request.env.applications_parent,
'applications', match.group('b'), 'static',
match.group('x'))
return (static_file, environ)
# ##################################################
# parse application, controller and function
# ##################################################
path = re.sub('%20', ' ', path)
match = regex_url.match(path)
if not match or match.group('c') == 'static':
raise HTTP(400,
thread.routes.error_message % 'invalid request',
web2py_error='invalid path')
request.application = \
regex_space.sub('_', match.group('a') or thread.routes.default_application)
request.controller = \
regex_space.sub('_', match.group('c') or thread.routes.default_controller)
request.function = \
regex_space.sub('_', match.group('f') or thread.routes.default_function)
group_e = match.group('e')
request.raw_extension = group_e and regex_space.sub('_', group_e) or None
request.extension = request.raw_extension or 'html'
request.raw_args = match.group('r')
request.args = List([])
if request.application in thread.routes.routes_apps_raw:
# application is responsible for parsing args
request.args = None
elif request.raw_args:
match = regex_args.match(request.raw_args.replace(' ', '_'))
if match:
group_s = match.group('s')
request.args = \
List((group_s and group_s.split('/')) or [])
if request.args and request.args[-1] == '':
request.args.pop() # adjust for trailing empty arg
else:
raise HTTP(400,
thread.routes.error_message % 'invalid request',
web2py_error='invalid path (args)')
return (None, environ)
def parse_url(request, environ):
"parse and rewrite the incoming URL"
# ##################################################
# validate the path in url
# ##################################################
if not request.env.path_info and request.env.request_uri:
# for fcgi, decode path_info and query_string
items = request.env.request_uri.split('?')
request.env.path_info = items[0]
if len(items) > 1:
request.env.query_string = items[1]
else:
request.env.query_string = ''
path = request.env.path_info.replace('\\', '/')
# ##################################################
# serve if a static file
# ##################################################
match = regex_static.match(regex_space.sub('_', path))
if match and match.group('x'):
static_file = os.path.join(request.env.web2py_path, 'applications',
match.group('b'), 'static',
match.group('x'))
return static_file
# ##################################################
# parse application, controller and function
# ##################################################
path = re.sub('%20', ' ', path)
match = regex_url.match(path)
if not match or match.group('c') == 'static':
raise HTTP(400,
rewrite.thread.routes.error_message % 'invalid request',
web2py_error='invalid path')
request.application = \
regex_space.sub('_', match.group('a') or rewrite.thread.routes.default_application)
request.controller = \
regex_space.sub('_', match.group('c') or rewrite.thread.routes.default_controller)
request.function = \
regex_space.sub('_', match.group('f') or rewrite.thread.routes.default_function)
group_e = match.group('e')
raw_extension = group_e and regex_space.sub('_', group_e) or None
request.extension = raw_extension or 'html'
request.raw_args = match.group('r')
request.args = List([])
if request.application in rewrite.thread.routes.routes_apps_raw:
# application is responsible for parsing args
request.args = None
elif request.raw_args:
match = regex_args.match(request.raw_args.replace(' ', '_'))
if match:
group_s = match.group('s')
request.args = \
List((group_s and group_s.split('/')) or [])
else:
raise HTTP(400,
rewrite.thread.routes.error_message % 'invalid request',
web2py_error='invalid path')
request.client = get_client(request.env)
request.folder = os.path.join(request.env.web2py_path, 'applications',
request.application) + '/'
request.ajax = str(
request.env.http_x_requested_with).lower() == 'xmlhttprequest'
request.cid = request.env.http_web2py_component_element
# ##################################################
# access the requested application
# ##################################################
if not os.path.exists(request.folder):
if request.application == rewrite.thread.routes.default_application:
request.application = 'welcome'
redirect(Url(r=request))
elif rewrite.thread.routes.error_handler:
redirect(
Url(rewrite.thread.routes.error_handler['application'],
rewrite.thread.routes.error_handler['controller'],
rewrite.thread.routes.error_handler['function'],
args=request.application))
else:
raise HTTP(400,
rewrite.thread.routes.error_message % 'invalid request',
web2py_error='invalid application')
request.url = Url(r=request, args=request.args, extension=raw_extension)
return None
