| 50 |
50 |
Auth = getattr(module, attr)
|
| 51 |
51 |
self.auth = Auth(env, self.mapper)
|
| 52 |
52 |
mapping = copy.deepcopy(default.mapping)
|
| 53 |
|
mapping.extend(self.mapper.mapping)
|
| 54 |
53 |
mapping.extend(self.auth.get_default_mapping())
|
|
54 |
mapping.extend(self.mapper.mapping)
|
| 55 |
55 |
logger.debug('Dispatcher mapping : %r', mapping)
|
| 56 |
56 |
self.req_mapping = self._parse_mapping(mapping)
|
| 57 |
57 |
|
| ... | ... | |
| 69 |
69 |
entry['filter'] = getattr(self.auth, entry['auth'])
|
| 70 |
70 |
req_mapping[hookname].append(entry)
|
| 71 |
71 |
else:
|
|
72 |
if isinstance(mapper[hookname], dict) and \
|
|
73 |
mapper[hookname].has_key('auth'):
|
|
74 |
mapper[hookname]['filter'] = getattr(self.auth, mapper[hookname]['auth'])
|
| 72 |
75 |
req_mapping[hookname] = mapper[hookname]
|
| 73 |
76 |
return req_mapping
|
| 74 |
77 |
|
| ... | ... | |
| 79 |
82 |
req_mapping = {
|
| 80 |
83 |
'on_request': [],
|
| 81 |
84 |
'on_response': [],
|
| 82 |
|
'response': [],
|
|
85 |
'response': None,
|
| 83 |
86 |
'target': None,
|
| 84 |
87 |
'redirect': None,
|
| 85 |
88 |
'decompress': config.auto_decompress
|
| ... | ... | |
| 105 |
108 |
values = hook.get('values')
|
| 106 |
109 |
if not values:
|
| 107 |
110 |
values = dict()
|
| 108 |
|
if hook.has_key('condition'):
|
|
111 |
if hook.has_key('condition') and type(hook['condition']) == str:
|
| 109 |
112 |
return hook['filter'](self.env, values, hook['condition'], *args)
|
| 110 |
113 |
else:
|
| 111 |
114 |
return hook['filter'](self.env, values, *args)
|
| ... | ... | |
| 113 |
116 |
logger.warning("%s hook failed (no filter option)" % self.env['PATH_INFO'])
|
| 114 |
117 |
return None
|
| 115 |
118 |
|
| 116 |
|
def get_target_url(self):
|
| 117 |
|
""" Return the destination url
|
|
119 |
def _is_cond_respected(self, hook, request, response):
|
|
120 |
if hook.has_key('condition') and \
|
|
121 |
type(hook['condition']) != str and \
|
|
122 |
not hook['condition'](self.env, request, response):
|
|
123 |
return False
|
|
124 |
return True
|
|
125 |
|
|
126 |
def set_request_target(self, request):
|
|
127 |
""" Add target url on not into the request
|
| 118 |
128 |
"""
|
| 119 |
|
url = None
|
| 120 |
|
if self.req_mapping['response'] or self.req_mapping['redirect']:
|
| 121 |
|
return None
|
|
129 |
request.target = self.target.geturl() + self.env['RAW_URI']
|
| 122 |
130 |
if self.req_mapping['target']:
|
| 123 |
|
if re.match("http://|https://", self.req_mapping['target']):
|
| 124 |
|
url = self.req_mapping['target']
|
|
131 |
if "//" in self.req_mapping['target']:
|
|
132 |
request.target = self.req_mapping['target']
|
| 125 |
133 |
else:
|
| 126 |
|
url = self.target.geturl() + self.req_mapping['target']
|
| 127 |
|
else:
|
| 128 |
|
url = self.target.geturl() + self.env['RAW_URI']
|
| 129 |
|
|
| 130 |
|
return url
|
|
134 |
request.target = self.target.geturl() + self.req_mapping['target']
|
|
135 |
elif self.req_mapping['response'] and \
|
|
136 |
self._is_cond_respected(self.req_mapping['response'],
|
|
137 |
request, None):
|
|
138 |
request.target = None
|
|
139 |
elif self.req_mapping['redirect']:
|
|
140 |
request.target = None
|
|
141 |
return request
|
| 131 |
142 |
|
| 132 |
143 |
def get_response(self, request):
|
| 133 |
144 |
""" Called if you have a response hook for this request
|
| 134 |
145 |
"""
|
| 135 |
146 |
if self.req_mapping['redirect']:
|
| 136 |
147 |
return _302(self.req_mapping['redirect'])
|
| 137 |
|
response = None
|
| 138 |
|
logger.debug("Loading response hook(s)")
|
| 139 |
|
for hook in self.req_mapping['response']:
|
| 140 |
|
new_response = self._call_hook(hook, request, response)
|
| 141 |
|
if new_response:
|
| 142 |
|
response = new_response
|
| 143 |
|
else:
|
| 144 |
|
logger.warning("%s Response hook %s failed" % (self.env['PATH_INFO'],
|
| 145 |
|
self.req_mapping['response']['filter']))
|
| 146 |
|
if not response:
|
| 147 |
|
return _500(self.env["PATH_INFO"], "The response hook failed")
|
|
148 |
elif self.req_mapping['response']:
|
|
149 |
logger.debug("Loading response hook(s)")
|
|
150 |
hook = self.req_mapping['response']
|
|
151 |
print hook
|
|
152 |
response = self._call_hook(hook, request, None)
|
|
153 |
if not response:
|
|
154 |
return _500(self.env["PATH_INFO"], "The response hook failed")
|
|
155 |
else:
|
|
156 |
return _500(self.env["PATH_INFO"], "no response and no target")
|
| 148 |
157 |
return response
|
| 149 |
158 |
|
| 150 |
159 |
def mod_request(self, request):
|
dispatcher: improved condition management and force response to be unique
Fixes #716