def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
controller = environ['pylons.routes_dict']['controller']
if controller == 'template':
return WSGIController.__call__(self, environ, start_response)
username = environ.get('REMOTE_USER')
if not username and controller != 'config':
return WSGIResponse(content='please log in', code=401)
if environ.get('AUTHENTICATION_METHOD') != 'WSSE':
if controller == 'watch' or controller == 'user':
c.user = User.get_or_create(username)
else:
if (environ.get('REMOTE_ADDR').startswith('127.0.0.1') and controller == 'config') or controller == 'error':
#local users can configure Twirlip and see errors
pass
else:
#all other authentication must be by wsse
return WSGIResponse(code=403, content='You need to authenticate with wsse to access %s ' % controller)
if controller == 'page':
#json
self.params = {}
for param, value in request.params.items():
self.params[param] = loads(value)
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
def check_url():
if ('format' in environ['pylons.routes_dict'] and
environ['pylons.routes_dict']['format'] in ['csv', 'pdf']):
return False
if environ['PATH_INFO'] == '/jsi18n.js':
return False
return True
self.identity = environ.get('repoze.who.identity')
# raise ValueError(self.identity)
# if 'baruwa.auth.plugin' in self.identity:
# session['baruwa.auth.plugin'] = self.identity['baruwa.auth.plugin']
# session.save()
if (not self.identity is None and 'user' in self.identity and
environ['pylons.routes_dict']['controller'] != 'error' and
check_url()):
if self.identity['user']:
totals = DailyTotals(Session, self.identity['user'])
mailq = MailQueue(Session, self.identity['user'])
c.baruwa_totals = totals.get()
c.baruwa_inbound = mailq.get(1)[0]
c.baruwa_outbound = mailq.get(2)[0]
if self.identity['user'].is_admin:
c.baruwa_status = cluster_status()
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
start = time.time()
try:
self.ip_addr = _get_ip_addr(environ)
# make sure that we update permissions each time we call controller
api_key = request.GET.get("api_key")
cookie_store = CookieStoreWrapper(session.get("rhodecode_user"))
user_id = cookie_store.get("user_id", None)
username = get_container_username(environ, config)
auth_user = AuthUser(user_id, api_key, username)
request.user = auth_user
self.rhodecode_user = c.rhodecode_user = auth_user
if not self.rhodecode_user.is_authenticated and self.rhodecode_user.user_id is not None:
self.rhodecode_user.set_authenticated(cookie_store.get("is_authenticated"))
log.info("IP: %s User: %s accessed %s" % (self.ip_addr, auth_user, safe_unicode(_get_access_path(environ))))
return WSGIController.__call__(self, environ, start_response)
finally:
log.info(
"IP: %s Request to %s time: %.3fs"
% (_get_ip_addr(environ), safe_unicode(_get_access_path(environ)), time.time() - start)
)
meta.Session.remove()
def __call__(self, environ, start_response):
# Insert any code to be run per request here. The Routes match
# is under environ['pylons.routes_dict'] should you want to check
# the action or route vars here
# Grab Domain Info
self.domain = request.environ['REMOTE_USER']
self.dominfo = get_domain_info(self.domain)
# Don't allow Locked Domains to make any changes
if self.dominfo['ispmanDomainLocked'] == 'true' and \
request.path_info != '/locked':
h.redirect_to('/locked')
elif request.path_info == '/':
h.redirect_to('/domain')
ccache = cache.get_cache('navigation')
c.menus = ccache.get_value('i18n_menus',
createfunc=self.__create_i18n_menus,
type='memory', expiretime=3600)
c.controller = request.environ['pylons.routes_dict']['controller']
c.action = request.environ['pylons.routes_dict']['action']
c.imgs_list = self.__images_list()
if 'message' in session and session['message'] != '':
c.message = session['message']
session['message'] = ''
session.save()
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
# Insert any code to be run per request here.
# hg parents --template="r{rev} {date|date} by {author}\n"
hg_args = ['hg', 'parents', '--template="r{rev} {date|date} by {author}\n"']
hg_process = subprocess.Popen(hg_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=os.path.dirname(__file__))
c.revision = hg_process.stdout.readline().strip()[1:]
if request.environ['HTTP_HOST'].startswith("comoto") and h.get_user(request.environ).superuser: #we are running on the production server and we are a superuser
hg_args = ['hg', 'incoming', '--template="{rev}\n"']
hg_process = subprocess.Popen(hg_args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=os.path.dirname(__file__))
incoming_changesets = -2 #start with -4 because of extra lines printed
while True:
output = hg_process.stdout.readline()
if len(output) > 2:
incoming_changesets+=1
if output.startswith("no"):
incoming_changesets = 0
break
if output == '' or hg_process.poll() != None:
break
c.incoming_changesets = incoming_changesets
try:
return WSGIController.__call__(self, environ, start_response)
finally:
model.Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
# Moved here from index controller so that all views that import the news.mako template
# have access to c.db_content_news and c.db_content_press
news = DbContentType.find_by_name("News", abort_404=False)
if news:
c.db_content_news = meta.Session.query(DbContent).filter_by(
type_id=news.id, published=True).order_by(
DbContent.creation_timestamp.desc()).limit(4).all()
c.db_content_news_all = meta.Session.query(DbContent).filter_by(
type_id=news.id,
published=True).order_by(DbContent.creation_timestamp.desc(
)).all() #use all to find featured items
press = DbContentType.find_by_name("In the press", abort_404=False)
if press:
c.db_content_press = meta.Session.query(DbContent).filter_by(
type_id=press.id, published=True).order_by(
DbContent.creation_timestamp.desc()).limit(4).all()
try:
return WSGIController.__call__(self, environ, start_response)
finally:
meta.Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
tmpl_context.current_navtab = 'blah'
tmpl_context.current_subnavtab = 'blakj'
tmpl_context.status = 1
tmpl_context.messagebar_text = ''
tmpl_context.message = ''
tmpl_context.username = ''
beaker = environ.get('beaker.session') or {}
try:
timeout = int(config.get('cw.timeout'))
except Exception:
timeout = 0
if timeout and beaker.get('user_id'):
last_access = beaker.get('last_accessed') or False
if last_access and datetime.now() - last_access > timedelta(minutes=timeout):
try:
return "Your session has timed out. You have been logged out for security."
finally:
Session.remove()
beaker['last_accessed'] = datetime.now()
beaker.save()
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
# Clean out any old cookies as they may contain api keys etc
# This also improves the cachability of our pages as cookies
# prevent proxy servers from caching content unless they have
# been configured to ignore them.
for cookie in request.cookies:
if cookie.startswith('ckan') and cookie not in ['ckan']:
response.delete_cookie(cookie)
# Remove the ckan session cookie if not used e.g. logged out
elif cookie == 'ckan' and not c.user and not h.are_there_flash_messages(
):
if session.id:
if not session.get('lang'):
session.delete()
else:
response.delete_cookie(cookie)
# Remove auth_tkt repoze.who cookie if user not logged in.
elif cookie == 'auth_tkt' and not session.id:
response.delete_cookie(cookie)
try:
return WSGIController.__call__(self, environ, start_response)
finally:
model.Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
environ = request.environ
controller = environ['pylons.routes_dict'].get('controller')
if request.method == "POST" and controller != "auth" and controller != "hookbox" and controller != 'error':
params = request.params
submitted_token = params.get(secure_form.token_key)
if submitted_token != secure_form.authentication_token():
#raise RuntimeError("Not secure")
pass #FIXME: uncomment above
user_id = session.get("user_id")
if user_id:
c.user = self.user = User.get(user_id)
if not self.user.is_logged_in():
del session["user_id"]
c.user = self.user = None
else:
c.user = self.user = None
#generate hookbox server url
hookbox_server = url('/', qualified=True)
parsed = urlparse(hookbox_server)
#a really fancy way of saying host:8001
c.hookbox_server = parsed.scheme + "://" + parsed.hostname + ":" + config["hookbox_js_port"]
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# Before we do anything, is there a "REMOTE USER"?
# If not, we've not been authenticated!
if not environ.get('REMOTE_USER') and 'login' not in environ.get('PATH_INFO'):
raise httpexceptions.HTTPUnauthorized()
# Redirect to a canonical form of the URL if necessary.
self._redirect_noncanonical_url(environ)
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict'
if 'login' not in environ.get('PATH_INFO'):
self.current_user = self._user_service.get_user_by_username(environ.get('REMOTE_USER'))
if not self.current_user:
raise httpexceptions.HTTPUnauthorized()
if self.current_user.access_level == "Admin":
c.admin_user = True
else:
c.admin_user = False
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
response.headers['content-type'] = 'application/json;charset=utf-8'
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
response.headers["content-type"] = "application/json;charset=utf-8"
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
person = h.signed_in_person()
if person and not person.activated:
msg = ("Your account (%s) hasn't been confirmed. Check your email"
" for activation instructions." %
(person.email_address))
h.flash(msg, category="warning")
# Moved here from index controller so that all views that import the news.mako template
# have access to c.db_content_news and c.db_content_press
news = DbContentType.find_by_name("News", abort_404 = False)
if news:
c.db_content_news = meta.Session.query(DbContent).filter_by(type_id=news.id).filter(DbContent.publish_timestamp <= datetime.datetime.now()).order_by(DbContent.creation_timestamp.desc()).limit(4).all()
c.db_content_news_all = meta.Session.query(DbContent).filter_by(type_id=news.id).filter(DbContent.publish_timestamp <= datetime.datetime.now()).order_by(DbContent.creation_timestamp.desc()).all() #use all to find featured items
press = DbContentType.find_by_name("In the press", abort_404 = False)
if press:
c.db_content_press = meta.Session.query(DbContent).filter_by(type_id=press.id).order_by(DbContent.creation_timestamp.desc()).filter(DbContent.publish_timestamp <= datetime.datetime.now()).limit(4).all()
try:
return WSGIController.__call__(self, environ, start_response)
finally:
meta.Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
self.ip_addr = _get_ip_addr(environ)
# make sure that we update permissions each time we call controller
api_key = request.GET.get('api_key')
cookie_store = CookieStoreWrapper(session.get('rhodecode_user'))
user_id = cookie_store.get('user_id', None)
username = get_container_username(environ, config)
try:
auth_user = AuthUser(user_id, api_key, username, self.ip_addr)
except UserCreationError, e:
from rhodecode.lib import helpers as h
h.flash(e, 'error')
# container auth or other auth functions that create users on
# the fly can throw this exception signaling that there's issue
# with user creation, explanation should be provided in
# Exception itself
auth_user = AuthUser(ip_addr=self.ip_addr)
request.user = auth_user
self.rhodecode_user = c.rhodecode_user = auth_user
if not self.rhodecode_user.is_authenticated and \
self.rhodecode_user.user_id is not None:
self.rhodecode_user.set_authenticated(
cookie_store.get('is_authenticated')
)
log.info('IP: %s User: %s accessed %s' % (
self.ip_addr, auth_user, safe_unicode(_get_access_path(environ)))
)
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
start = time.time()
try:
# make sure that we update permissions each time we call controller
api_key = request.GET.get('api_key')
cookie_store = CookieStoreWrapper(session.get('rhodecode_user'))
user_id = cookie_store.get('user_id', None)
username = get_container_username(environ, config)
auth_user = AuthUser(user_id, api_key, username)
request.user = auth_user
self.rhodecode_user = c.rhodecode_user = auth_user
if not self.rhodecode_user.is_authenticated and \
self.rhodecode_user.user_id is not None:
self.rhodecode_user.set_authenticated(
cookie_store.get('is_authenticated')
)
log.info('User: %s accessed %s' % (
auth_user, safe_unicode(environ.get('PATH_INFO')))
)
return WSGIController.__call__(self, environ, start_response)
finally:
log.info('Request to %s time: %.3fs' % (
safe_unicode(environ.get('PATH_INFO')), time.time() - start)
)
meta.Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
# we override this here to ensure that this header, and only this
# header, is trusted to reduce the number of potential
# misconfigurations between wsgi application servers (e.g. gunicorn
# which trusts three different headers out of the box for this) and
# haproxy (which won't clean out bad headers by default)
forwarded_proto = environ.get("HTTP_X_FORWARDED_PROTO", "http").lower()
assert forwarded_proto in ("http", "https")
request.environ["wsgi.url_scheme"] = forwarded_proto
true_client_ip = environ.get('HTTP_TRUE_CLIENT_IP')
ip_hash = environ.get('HTTP_TRUE_CLIENT_IP_HASH')
forwarded_for = environ.get('HTTP_X_FORWARDED_FOR', ())
remote_addr = environ.get('REMOTE_ADDR')
if (g.ip_hash
and true_client_ip
and ip_hash
and hashlib.md5(true_client_ip + g.ip_hash).hexdigest() \
== ip_hash.lower()):
request.ip = true_client_ip
elif g.trust_local_proxies and forwarded_for and is_local_address(remote_addr):
request.ip = forwarded_for.split(',')[-1]
else:
request.ip = environ['REMOTE_ADDR']
#if x-dont-decode is set, pylons won't unicode all the paramters
if environ.get('HTTP_X_DONT_DECODE'):
request.charset = None
request.get = storify(request.GET)
request.post = storify(request.POST)
request.referer = environ.get('HTTP_REFERER')
request.user_agent = environ.get('HTTP_USER_AGENT')
request.fullpath = environ.get('FULLPATH', request.path)
request.fullurl = request.host_url + request.fullpath
request.port = environ.get('request_port')
if_modified_since = environ.get('HTTP_IF_MODIFIED_SINCE')
if if_modified_since:
request.if_modified_since = read_http_date(if_modified_since)
else:
request.if_modified_since = None
#set the function to be called
action = request.environ['pylons.routes_dict'].get('action')
if action:
meth = request.method.upper()
if meth == 'HEAD':
meth = 'GET'
if meth != 'OPTIONS':
handler_name = meth + '_' + action
else:
handler_name = meth
request.environ['pylons.routes_dict']['action_name'] = action
request.environ['pylons.routes_dict']['action'] = handler_name
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller."""
# set the language fallback to english
add_fallback("en")
# define the language based on browser preference
user_agent_language = request.languages[0][0:2]
set_lang(user_agent_language)
formencode.api.set_stdtranslation(user_agent_language)
# common values mostly inherited from config file
c.version = __version__ # TODO move this into the development.ini file
c.site_full_name = config["site_full_name"] # TODO move this into the development.ini file
c.site_short_name = config["site_short_name"] # TODO move this into the development.ini file
# controler and action named for use in templates
#c.controller = request.environ['pylons.routes_dict']['controller']
#c.action = request.environ['pylons.routes_dict']['action']
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
return WSGIController.__call__(self, environ, start_response)
finally:
meta.Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
def check_url():
"check if user should have totals calculated"
if ('format' in environ['pylons.routes_dict'] and
environ['pylons.routes_dict']['format'] in ['csv', 'pdf']):
return False
if environ['PATH_INFO'] == '/jsi18n.js':
return False
return True
self.identity = environ.get('repoze.who.identity')
if (self.identity is not None and 'user' in self.identity and
environ['pylons.routes_dict']['controller'] != 'error' and
check_url()):
if self.identity['user']:
totals = DailyTotals(Session, self.identity['user'])
mailq = MailQueue(Session, self.identity['user'])
c.baruwa_totals = totals.get()
c.baruwa_inbound = mailq.get(1)[0]
c.baruwa_outbound = mailq.get(2)[0]
if self.identity['user'].is_admin:
c.baruwa_status = cluster_status()
tzinfo = self.identity['user'].timezone or UTC
c.tzinfo = make_tz(tzinfo)
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
def check_url():
"check if user should have totals calculated"
if ('format' in environ['pylons.routes_dict'] and
environ['pylons.routes_dict']['format'] in ['csv', 'pdf']):
return False
if environ['PATH_INFO'] == '/jsi18n.js':
return False
return True
self.identity = environ.get('repoze.who.identity')
if (self.identity is not None and 'user' in self.identity
and environ['pylons.routes_dict']['controller'] != 'error'
and check_url()):
if self.identity['user']:
totals = DailyTotals(Session, self.identity['user'])
mailq = MailQueue(Session, self.identity['user'])
c.baruwa_totals = totals.get()
c.baruwa_inbound = mailq.get(1)[0]
c.baruwa_outbound = mailq.get(2)[0]
if self.identity['user'].is_admin:
c.baruwa_status = cluster_status()
tzinfo = self.identity['user'].timezone or UTC
c.tzinfo = make_tz(tzinfo)
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
person = h.signed_in_person()
if person and not person.activated:
msg = ("Your account (%s) hasn't been confirmed. Check your email"
" for activation instructions. %s" %
(person.email_address, 'link-to-reset'))
h.flash(msg, category="warning")
# Moved here from index controller so that all views that import the news.mako template
# have access to c.db_content_news and c.db_content_press
news = DbContentType.find_by_name("News", abort_404 = False)
if news:
c.db_content_news = meta.Session.query(DbContent).filter_by(type_id=news.id).filter(DbContent.publish_timestamp <= datetime.datetime.now()).order_by(DbContent.creation_timestamp.desc()).limit(4).all()
c.db_content_news_all = meta.Session.query(DbContent).filter_by(type_id=news.id).filter(DbContent.publish_timestamp <= datetime.datetime.now()).order_by(DbContent.creation_timestamp.desc()).all() #use all to find featured items
press = DbContentType.find_by_name("In the press", abort_404 = False)
if press:
c.db_content_press = meta.Session.query(DbContent).filter_by(type_id=press.id).order_by(DbContent.creation_timestamp.desc()).filter(DbContent.publish_timestamp <= datetime.datetime.now()).limit(4).all()
try:
return WSGIController.__call__(self, environ, start_response)
finally:
meta.Session.remove()
def __call__(self, environ, start_response):
# we override this here to ensure that this header, and only this
# header, is trusted to reduce the number of potential
# misconfigurations between wsgi application servers (e.g. gunicorn
# which trusts three different headers out of the box for this) and
# haproxy (which won't clean out bad headers by default)
forwarded_proto = environ.get("HTTP_X_FORWARDED_PROTO", "http").lower()
assert forwarded_proto in ("http", "https")
request.environ["wsgi.url_scheme"] = forwarded_proto
true_client_ip = environ.get('HTTP_TRUE_CLIENT_IP')
ip_hash = environ.get('HTTP_TRUE_CLIENT_IP_HASH')
forwarded_for = environ.get('HTTP_X_FORWARDED_FOR', ())
remote_addr = environ.get('REMOTE_ADDR')
request.via_cdn = False
if (g.secrets["true_ip"]
and true_client_ip
and ip_hash
and hashlib.md5(true_client_ip + g.secrets["true_ip"]).hexdigest() \
== ip_hash.lower()):
request.ip = true_client_ip
request.via_cdn = True
elif g.trust_local_proxies and forwarded_for and is_local_address(remote_addr):
request.ip = forwarded_for.split(',')[-1]
else:
request.ip = environ['REMOTE_ADDR']
#if x-dont-decode is set, pylons won't unicode all the parameters
if environ.get('HTTP_X_DONT_DECODE'):
request.charset = None
request.referer = environ.get('HTTP_REFERER')
request.user_agent = environ.get('HTTP_USER_AGENT')
request.fullpath = environ.get('FULLPATH', request.path)
request.fullurl = request.host_url + request.fullpath
request.port = environ.get('request_port')
if_modified_since = environ.get('HTTP_IF_MODIFIED_SINCE')
if if_modified_since:
request.if_modified_since = read_http_date(if_modified_since)
else:
request.if_modified_since = None
#set the function to be called
action = request.environ['pylons.routes_dict'].get('action')
if action:
meth = request.method.upper()
if meth == 'HEAD':
meth = 'GET'
if meth != 'OPTIONS':
handler_name = meth + '_' + action
else:
handler_name = meth
request.environ['pylons.routes_dict']['action_name'] = action
request.environ['pylons.routes_dict']['action'] = handler_name
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
def check_url():
if ('format' in environ['pylons.routes_dict'] and
environ['pylons.routes_dict']['format'] in ['csv', 'pdf']):
return False
if environ['PATH_INFO'] == '/jsi18n.js':
return False
return True
self.identity = environ.get('repoze.who.identity')
# raise ValueError(self.identity)
# if 'baruwa.auth.plugin' in self.identity:
# session['baruwa.auth.plugin'] = self.identity['baruwa.auth.plugin']
# session.save()
if (not self.identity is None and 'user' in self.identity
and environ['pylons.routes_dict']['controller'] != 'error'
and check_url()):
if self.identity['user']:
totals = DailyTotals(Session, self.identity['user'])
mailq = MailQueue(Session, self.identity['user'])
c.baruwa_totals = totals.get()
c.baruwa_inbound = mailq.get(1)[0]
c.baruwa_outbound = mailq.get(2)[0]
if self.identity['user'].is_admin:
c.baruwa_status = cluster_status()
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
# Clean out any old cookies as they may contain api keys etc
# This also improves the cachability of our pages as cookies
# prevent proxy servers from caching content unless they have
# been configured to ignore them.
for cookie in request.cookies:
if cookie.startswith("ckan") and cookie not in ["ckan"]:
response.delete_cookie(cookie)
# Remove the ckan session cookie if not used e.g. logged out
elif cookie == "ckan" and not c.user and not h.are_there_flash_messages():
if session.id:
if not session.get("lang"):
session.delete()
else:
response.delete_cookie(cookie)
# Remove auth_tkt repoze.who cookie if user not logged in.
elif cookie == "auth_tkt" and not session.id:
response.delete_cookie(cookie)
try:
return WSGIController.__call__(self, environ, start_response)
finally:
model.Session.remove()
def __call__(self, environ, start_response):
# we override this here to ensure that this header, and only this
# header, is trusted to reduce the number of potential
# misconfigurations between wsgi application servers (e.g. gunicorn
# which trusts three different headers out of the box for this) and
# haproxy (which won't clean out bad headers by default)
forwarded_proto = environ.get("HTTP_X_FORWARDED_PROTO", "http").lower()
assert forwarded_proto in ("http", "https")
request.environ["wsgi.url_scheme"] = forwarded_proto
forwarded_for = environ.get('HTTP_X_FORWARDED_FOR', ())
remote_addr = environ.get('REMOTE_ADDR')
request.via_cdn = False
cdn_ip = g.cdn_provider.get_client_ip(environ)
if cdn_ip:
request.ip = cdn_ip
request.via_cdn = True
elif g.trust_local_proxies and forwarded_for and is_local_address(remote_addr):
request.ip = forwarded_for.split(',')[-1]
else:
request.ip = environ['REMOTE_ADDR']
#if x-dont-decode is set, pylons won't unicode all the parameters
if environ.get('HTTP_X_DONT_DECODE'):
request.charset = None
request.referer = environ.get('HTTP_REFERER')
request.user_agent = environ.get('HTTP_USER_AGENT')
request.fullpath = environ.get('FULLPATH', request.path)
request.fullurl = request.host_url + request.fullpath
request.port = environ.get('request_port')
if_modified_since = environ.get('HTTP_IF_MODIFIED_SINCE')
if if_modified_since:
request.if_modified_since = read_http_date(if_modified_since)
else:
request.if_modified_since = None
#set the function to be called
action = request.environ['pylons.routes_dict'].get('action')
if (request.environ.get('r2.controller.exception') and action == 'document'
and request.environ.get('render_style') == 'api'):
action = 'api_error'
if action:
meth = request.method.upper()
if meth == 'HEAD':
meth = 'GET'
if (meth == 'OPTIONS' and
self._get_action_handler(action, meth) is None):
handler_name = meth
else:
handler_name = meth + '_' + action
request.environ['pylons.routes_dict']['action_name'] = action
request.environ['pylons.routes_dict']['action'] = handler_name
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
res = WSGIController.__call__(self, environ, start_response)
finally:
model.Session.remove()
for cookie in request.cookies:
# Remove the ckan session cookie if not used e.g. logged out
if cookie == "ckan" and not c.user:
# Check session for valid data (including flash messages)
# (DGU also uses session for a shopping basket-type behaviour)
is_valid_cookie_data = False
for key, value in session.items():
if not key.startswith("_") and value:
is_valid_cookie_data = True
break
if not is_valid_cookie_data:
if session.id:
self.log.debug("No valid session data - " "deleting session")
self.log.debug("Session: %r", session.items())
session.delete()
else:
self.log.debug("No session id - " "deleting session cookie")
response.delete_cookie(cookie)
# Remove auth_tkt repoze.who cookie if user not logged in.
elif cookie == "auth_tkt" and not session.id:
response.delete_cookie(cookie)
return res
def __call__(self, environ, start_response):
true_client_ip = environ.get('HTTP_TRUE_CLIENT_IP')
ip_hash = environ.get('HTTP_TRUE_CLIENT_IP_HASH')
forwarded_for = environ.get('HTTP_X_FORWARDED_FOR', ())
remote_addr = environ.get('REMOTE_ADDR')
if (g.ip_hash
and true_client_ip
and ip_hash
and hashlib.md5(true_client_ip + g.ip_hash).hexdigest() \
== ip_hash.lower()):
request.ip = true_client_ip
elif g.trust_local_proxies and forwarded_for and is_local_address(remote_addr):
request.ip = forwarded_for.split(',')[-1]
else:
request.ip = environ['REMOTE_ADDR']
#if x-dont-decode is set, pylons won't unicode all the paramters
if environ.get('HTTP_X_DONT_DECODE'):
request.charset = None
request.get = storify(request.GET)
request.post = storify(request.POST)
request.referer = environ.get('HTTP_REFERER')
request.user_agent = environ.get('HTTP_USER_AGENT')
request.fullpath = environ.get('FULLPATH', request.path)
request.port = environ.get('request_port')
if_modified_since = environ.get('HTTP_IF_MODIFIED_SINCE')
if if_modified_since:
request.if_modified_since = read_http_date(if_modified_since)
else:
request.if_modified_since = None
#set the function to be called
action = request.environ['pylons.routes_dict'].get('action')
if action:
meth = request.method.upper()
if meth == 'HEAD':
meth = 'GET'
if meth != 'OPTIONS':
handler_name = meth + '_' + action
else:
handler_name = meth
request.environ['pylons.routes_dict']['action_name'] = action
request.environ['pylons.routes_dict']['action'] = handler_name
try:
res = WSGIController.__call__(self, environ, start_response)
except Exception as e:
if g.exception_logging and not isinstance(e, OPERATIONAL_EXCEPTIONS):
try:
log_exception(e, *sys.exc_info())
except Exception as f:
print "log_exception() freaked out: %r" % f
print "sorry for breaking the stack trace:"
raise
return res
def __call__(self, environ, start_response):
conn = meta.engine.connect()
meta.Session.configure(bind=conn)
try:
return WSGIController.__call__(self, environ, start_response)
finally:
meta.Session.remove()
conn.close()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
pylons.tmpl_context.db = self.db = Database(pylons.config['couchdb_uri'])
self._setup()
pylons.tmpl_context.use_minified_assets = asbool(
pylons.config.get('use_minified_assets', 'false'))
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
true_client_ip = environ.get("HTTP_TRUE_CLIENT_IP")
ip_hash = environ.get("HTTP_TRUE_CLIENT_IP_HASH")
forwarded_for = environ.get("HTTP_X_FORWARDED_FOR", ())
remote_addr = environ.get("REMOTE_ADDR")
if (
g.ip_hash
and true_client_ip
and ip_hash
and hashlib.md5(true_client_ip + g.ip_hash).hexdigest() == ip_hash.lower()
):
request.ip = true_client_ip
elif remote_addr in g.proxy_addr and forwarded_for:
request.ip = forwarded_for.split(",")[-1]
else:
request.ip = environ["REMOTE_ADDR"]
# if x-dont-decode is set, pylons won't unicode all the paramters
if environ.get("HTTP_X_DONT_DECODE"):
request.charset = None
request.get = storify(request.GET)
request.post = storify(request.POST)
request.referer = environ.get("HTTP_REFERER")
request.path = environ.get("PATH_INFO")
request.user_agent = environ.get("HTTP_USER_AGENT")
request.fullpath = environ.get("FULLPATH", request.path)
request.port = environ.get("request_port")
if_modified_since = environ.get("HTTP_IF_MODIFIED_SINCE")
if if_modified_since:
request.if_modified_since = read_http_date(if_modified_since)
else:
request.if_modified_since = None
# set the function to be called
action = request.environ["pylons.routes_dict"].get("action")
if action:
meth = request.method.upper()
if meth == "HEAD":
meth = "GET"
request.environ["pylons.routes_dict"]["action"] = meth + "_" + action
c.thread_pool = environ["paste.httpserver.thread_pool"]
c.response = Response()
try:
res = WSGIController.__call__(self, environ, start_response)
except Exception as e:
if g.exception_logging:
try:
log_exception(e, *sys.exc_info())
except Exception as f:
print "log_exception() freaked out: %r" % f
print "sorry for breaking the stack trace:"
raise
return res
def __call__(self, environ, start_response):
true_client_ip = environ.get('HTTP_TRUE_CLIENT_IP')
ip_hash = environ.get('HTTP_TRUE_CLIENT_IP_HASH')
forwarded_for = environ.get('HTTP_X_FORWARDED_FOR', ())
remote_addr = environ.get('REMOTE_ADDR')
if (g.ip_hash
and true_client_ip
and ip_hash
and hashlib.md5(true_client_ip + g.ip_hash).hexdigest() \
== ip_hash.lower()):
request.ip = true_client_ip
elif remote_addr in g.proxy_addr and forwarded_for:
request.ip = forwarded_for.split(',')[-1]
else:
request.ip = environ['REMOTE_ADDR']
#if x-dont-decode is set, pylons won't unicode all the paramters
if environ.get('HTTP_X_DONT_DECODE'):
request.charset = None
request.get = storify(request.GET)
request.post = storify(request.POST)
request.referer = environ.get('HTTP_REFERER')
request.path = environ.get('PATH_INFO')
request.user_agent = environ.get('HTTP_USER_AGENT')
request.fullpath = environ.get('FULLPATH', request.path)
request.port = environ.get('request_port')
if_modified_since = environ.get('HTTP_IF_MODIFIED_SINCE')
if if_modified_since:
request.if_modified_since = read_http_date(if_modified_since)
else:
request.if_modified_since = None
#set the function to be called
action = request.environ['pylons.routes_dict'].get('action')
if action:
meth = request.method.upper()
if meth == 'HEAD':
meth = 'GET'
request.environ['pylons.routes_dict']['action'] = \
meth + '_' + action
c.thread_pool = environ['paste.httpserver.thread_pool']
c.response = Response()
try:
res = WSGIController.__call__(self, environ, start_response)
except Exception as e:
if g.exception_logging:
try:
log_exception(e, *sys.exc_info())
except Exception as f:
print "log_exception() freaked out: %r" % f
print "sorry for breaking the stack trace:"
raise
return res
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
self._session = Session
auth.authenticate_basic_auth()
if '_debug_frontend' in request.params:
#now we can force this no matter the environment.
c.debug_frontend = request.params['_debug_frontend'] == 'True'
else:
c.debug_frontend = not h.is_production()
#this is used by timer proxy and the templates
c.show_debug = bool(session.get('show_debug'))
request.environ['USER'] = session.get('username', '')
request.environ['REAL_USER'] = session.get('real_username', '')
# set the start of the rendering
c.render_start = time.time()
c.requested_url = request.environ.get('PATH_INFO')
if request.environ.get('QUERY_STRING'):
c.requested_url += '?' + request.environ['QUERY_STRING']
logger.info(c.requested_url)
# Capture IP address in non-ssl mode, so we can use it in SSL mode see ticket #2275
ip = auth.get_user_ip()
if not session.get('IP_ADDRESS') and ip:
session['IP_ADDRESS'] = ip
elif not session.get('IP_ADDRESS') and request.environ.get(
'HTTP_RLNCLIENTIPADDR'):
session['IP_ADDRESS'] = request.environ.get(
'HTTP_RLNCLIENTIPADDR')
elif not session.get('IP_ADDRESS') and request.environ.get(
'REMOTE_ADDR'):
session['IP_ADDRESS'] = request.environ.get('REMOTE_ADDR')
# Save the first referer we see to store in user record when/if we create one.
if not session.get('referer'):
session['referer'] = environ.get('HTTP_REFERER',
'').decode('utf-8', 'ignore')
session.save()
if session.get('notify'):
c._notify = session['notify']
del session['notify']
session.save()
return WSGIController.__call__(self, environ, start_response)
finally:
if 'paste.testing_variables' not in request.environ:
Session.remove()
def __call__(self, environ, start_response):
"""Invoke the WSGI controller."""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
return WSGIController.__call__(self, environ, start_response)
finally:
model.Session.remove()
def __call__(self, environ, start_response):
# Update the user header information (Content found on the very top-right of the GUI)
self.BaseController_UpdateUserHeader()
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
return WSGIController.__call__(self, environ, start_response)
except NotImplementedError, e:
abort(501)
def __call__(self, environ, start_response): try: c.cats = model.Category.query.filter(model.and_( model.Category.category!="Default", model.Category.category!="Uncategorized" )).all() return WSGIController.__call__(self, environ, start_response) finally: model.Session.remove()
def __call__(self, environ, start_response):
# Insert any code to be run per request here. The Routes match
# is under environ['pylons.routes_dict'] should you want to check
# the action or route vars here
# Force Paste not to set the Content-Length to 0 before cgi.FieldStorage
# can read the request body
environ['CONTENT_LENGTH'] = '-1'
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
# environ['paste.content_type'] = 'application/json'
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
self._setup()
return WSGIController.__call__(self, environ, start_response)
finally:
meta.Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
return WSGIController.__call__(self, environ, start_response)
finally:
if not 'paste.testing_variables' in request.environ:
model.Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# Set up the database object
c.db = self.db = Database(config["couchdb_uri"])
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response): # Update the user header information (Content found on the very top-right of the GUI) self.BaseController_UpdateUserHeader() """Invoke the Controller""" # WSGIController.__call__ dispatches to the Controller method # the request is routed to. This routing information is # available in environ['pylons.routes_dict'] return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
'''Invoke the Controller'''
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
# we add a unique request id to the request enviroment
# so we can trace individual requests in the logging
environ['REQUEST_ID'] = str(uuid4())
environ['REQUEST_START_TIMESTAMP'] = datetime.now()
with request_context_safety():
try:
self._parse_request_params(request)
except UnicodeDecodeError as exx:
# we supress Exception here as it will be handled in the
# controller which will return corresponding response
log.warning('Failed to access request parameters: %r' % exx)
self.create_context(request, environ)
try:
try:
user_desc = getUserFromRequest(request)
self.base_auth_user = user_desc.get('login', '')
except UnicodeDecodeError as exx:
# we supress Exception here as it will be handled in the
# controller which will return corresponding response
log.warning('Failed to identify user due to %r' % exx)
ret = WSGIController.__call__(self, environ, start_response)
log.debug("Request reply: %r", ret)
finally:
meta.Session.remove()
# free the lock on the scurityPovider if any
if self.sep:
self.sep.dropSecurityModule()
closeResolvers()
# hint for the garbage collector to make the dishes
data_objects = [
"resolvers_loaded", "resolver_clazzes", "linotpConfig",
"audit", "hsm"
]
for data_obj in data_objects:
if hasattr(c, data_obj):
data = getattr(c, data_obj)
del data
log_request_timedelta(log)
return ret
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
# before setting anything new, first reset the old values from previous request if any
contextutils.resetcontext(self)
#LOG.debug(environ)
if 'service' in environ['pylons.routes_dict']:
servicename = environ['pylons.routes_dict']['service']
#if not registered, agent will not try to replace
if servicename is not None and servicename.count('.') == 2:
servicename = manifestutil.expandServiceName(servicename)
LOG.info('service name expanded %s ' % servicename)
environ['pylons.routes_dict']['service'] = servicename
contextutils.injectcontext(self, {'service': servicename})
# get correlationid into context
if 'X-CORRELATIONID' in request.headers and request.headers[
'X-CORRELATIONID'] is not None:
contextutils.injectcontext(
self, {'guid': request.headers['X-CORRELATIONID']})
else:
contextutils.injectcontext(self, {'guid': ''})
# get timeouts and inject into context
if 'X-THREAD_TIMEOUT' in request.headers and request.headers[
'X-THREAD_TIMEOUT'] is not None:
contextutils.injectcontext(
self,
{'thread_timeout': request.headers['X-AGENT_THREAD_TIMEOUT']})
# get progress timeouts and inject into context
if 'X-THREAD_PROGRESS_TIMEOUT' in request.headers and request.headers[
'X-THREAD_PROGRESS_TIMEOUT'] is not None:
contextutils.injectcontext(
self, {
'thread_progress_timeout':
request.headers['X-THREAD_PROGRESS_TIMEOUT']
})
# get remote address from request
remoteAddr = request.environ.get("X_FORWARDED_FOR",
request.environ.get("REMOTE_ADDR"))
contextutils.injectcontext(self, {'remote_addr': remoteAddr})
reqChecksum = '%s,%s,%s' % (request.method, request.url, request.body)
contextutils.injectcontext(self, {'reqChecksum': reqChecksum})
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
user = session.get('user')
if user:
request.environ['REMOTE_USER'] = user.email
try:
return WSGIController.__call__(self, environ, start_response)
finally:
Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
# Insert any code to be run per request here.
try:
return WSGIController.__call__(self, environ, start_response)
finally:
model.clean_local()
kcd_model.clean_local()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
config['pylons.g'].loginurl = 'http://' + environ[
'HTTP_HOST'] + config['jvkk.login.url']
return WSGIController.__call__(self, environ, start_response)
finally:
model.Session.close()
model.Session.remove()
def __call__(self, environ, start_response):
true_client_ip = environ.get('HTTP_TRUE_CLIENT_IP')
ip_hash = environ.get('HTTP_TRUE_CLIENT_IP_HASH')
forwarded_for = environ.get('HTTP_X_FORWARDED_FOR', ())
remote_addr = environ.get('REMOTE_ADDR')
if (g.ip_hash
and true_client_ip
and ip_hash
and hashlib.md5(true_client_ip + g.ip_hash).hexdigest() \
== ip_hash.lower()):
request.ip = true_client_ip
elif g.trust_local_proxies and forwarded_for and is_local_address(
remote_addr):
request.ip = forwarded_for.split(',')[-1]
else:
request.ip = environ['REMOTE_ADDR']
#if x-dont-decode is set, pylons won't unicode all the paramters
if environ.get('HTTP_X_DONT_DECODE'):
request.charset = None
request.get = storify(request.GET)
request.post = storify(request.POST)
request.referer = environ.get('HTTP_REFERER')
request.user_agent = environ.get('HTTP_USER_AGENT')
request.fullpath = environ.get('FULLPATH', request.path)
request.fullurl = environ.get('FULLURL', request.url)
request.port = environ.get('request_port')
if_modified_since = environ.get('HTTP_IF_MODIFIED_SINCE')
if if_modified_since:
request.if_modified_since = read_http_date(if_modified_since)
else:
request.if_modified_since = None
#set the function to be called
action = request.environ['pylons.routes_dict'].get('action')
if action:
meth = request.method.upper()
if meth == 'HEAD':
meth = 'GET'
if meth != 'OPTIONS':
handler_name = meth + '_' + action
else:
handler_name = meth
request.environ['pylons.routes_dict']['action_name'] = action
request.environ['pylons.routes_dict']['action'] = handler_name
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
return WSGIController.__call__(self, environ, start_response)
finally:
model.Session.remove()
# For whatever reason, query log isn't reliably gc'd, so nuke
# it manually here
c.query_log = None
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
begin = time()
try:
return WSGIController.__call__(self, environ, start_response)
finally:
db.session.remove()
db.session.close()
log.debug("Request to %s took %sms" %
(request.path, int((time() - begin) * 1000)))
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
c.lang = environ['pylons.routes_dict'].get('_lang')
if c.lang:
set_lang(c.lang)
try:
return WSGIController.__call__(self, environ, start_response)
finally:
meta.Session.remove()
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
try:
response = WSGIController.__call__(self, environ, start_response)
if isinstance(response, types.GeneratorType):
response = DestroySessionWhenDone(response)
else:
Session.remove()
return response
except:
Session.remove()
raise
def __call__(self, environ, start_response):
action = request.environ['pylons.routes_dict'].get('action')
if action:
method = request.method.upper()
if method == 'HEAD':
method = 'GET'
handler_name = method + '_' + action
#request.environ['pylons.routes_dict']['action_name'] = action
request.environ['pylons.routes_dict']['action'] = handler_name
self.environ = environ
ret = WSGIController.__call__(self, environ, start_response)
return ret
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
from rhodecode.lib import helpers as h
# Provide the Pylons context to Pyramid's debugtoolbar if it asks
if environ.get('debugtoolbar.wants_pylons_context', False):
environ['debugtoolbar.pylons_context'] = c._current_obj()
_route_name = '.'.join([environ['pylons.routes_dict']['controller'],
environ['pylons.routes_dict']['action']])
self.rc_config = SettingsModel().get_all_settings(cache=True)
self.ip_addr = get_ip_addr(environ)
# The rhodecode auth user is looked up and passed through the
# environ by the pylons compatibility tween in pyramid.
# So we can just grab it from there.
auth_user = environ['rc_auth_user']
# set globals for auth user
request.user = auth_user
c.rhodecode_user = self._rhodecode_user = auth_user
log.info('IP: %s User: %s accessed %s [%s]' % (
self.ip_addr, auth_user, safe_unicode(get_access_path(environ)),
_route_name)
)
# TODO: Maybe this should be move to pyramid to cover all views.
# check user attributes for password change flag
user_obj = auth_user.get_instance()
if user_obj and user_obj.user_data.get('force_password_change'):
h.flash('You are required to change your password', 'warning',
ignore_duplicate=True)
skip_user_check_urls = [
'error.document', 'login.logout', 'login.index',
'admin/my_account.my_account_password',
'admin/my_account.my_account_password_update'
]
if _route_name not in skip_user_check_urls:
return self._dispatch_redirect(
url('my_account_password'), environ, start_response)
return WSGIController.__call__(self, environ, start_response)
def __call__(self, environ, start_response):
'''Invoke the Controller'''
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
path = ""
with request_context_safety():
self.create_context(request)
try:
if environ:
path = environ.get("PATH_INFO", "") or ""
try:
user_desc = getUserFromRequest(request)
self.base_auth_user = user_desc.get('login', '')
except UnicodeDecodeError as exx:
# we supress Exception here as it will be handled in the
# controller which will return corresponding response
log.info('Failed to identify user due to %r' % exx)
log.debug("request %r" % path)
ret = WSGIController.__call__(self, environ, start_response)
log.debug("reply %r" % ret)
finally:
meta.Session.remove()
# free the lock on the scurityPovider if any
if self.sep:
self.sep.dropSecurityModule()
closeResolvers()
# hint for the garbage collector to make the dishes
data_objects = [
"resolvers_loaded", "resolver_types", "resolver_clazzes",
"linotpConfig", "audit", "hsm"
]
for data_obj in data_objects:
if hasattr(c, data_obj):
data = getattr(c, data_obj)
del data
log.debug("request %r done!" % path)
return ret
def __call__(self, environ, start_response):
# Insert any code to be run per request here. The Routes match
# is under environ['pylons.routes_dict'] should you want to check
# the action or route vars here
try:
return WSGIController.__call__(self, environ, start_response)
except Exception, e:
if isinstance(e, _httpexceptions.HTTPFound):
raise
c.error_title = "Generic Internal Error :("
c.error = "%s: %s" % (e.__class__.__name__, e)
c.traceback = _traceback.format_exc()
return render_response('error.myt')
def __call__(self, environ, start_response):
"""Invoke the Controller"""
# WSGIController.__call__ dispatches to the Controller method
# the request is routed to. This routing information is
# available in environ['pylons.routes_dict']
# make available any detailed login information we want on all requests
# if there's no user set, just setup a blank instance
tpl.current_user = auth.get_user(User())
try:
return WSGIController.__call__(self, environ, start_response)
finally:
# auto commit at the end of a request
Session.commit()
Session.remove()
