def __before__(self, action, **params): """ Here we see, what action is to be called and check the authorization """ log.debug("[__before__::%r] %r" % (action, params)) try: audit.initialize() c.audit["success"] = False c.audit["client"] = get_client() if action != "check_t": check_session() return response except webob.exc.HTTPUnauthorized as acc: ## the exception, when an abort() is called if forwarded log.exception("[__before__::%r] webob.exception %r" % (action, acc)) Session.rollback() Session.close() raise acc except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context="before") finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params): ''' Here we see, what action is to be called and check the authorization ''' log.debug("[__before__::%r] %r" % (action, params)) try: c.audit = request_context['audit'] c.audit['success'] = False c.audit['client'] = get_client(request) if action != "check_t": check_session(request) request_context['Audit'] = audit return response except webob.exc.HTTPUnauthorized as acc: ## the exception, when an abort() is called if forwarded log.exception("[__before__::%r] webob.exception %r" % (action, acc)) Session.rollback() Session.close() raise acc except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params): """ """ try: log.debug('[__before__::%r] %r', action, params) audit.initialize() c.audit['success'] = False c.audit['client'] = get_client(request) # Session handling check_session(request) self.request_context['Audit'] = audit return request except Exception as exception: log.exception(exception) Session.rollback() Session.close() return sendError(response, exception, context='before') finally: log.debug('[__before__::%r] done', action)
def __before__(self, action, **params): """ """ try: log.debug('[__before__::%r] %r', action, params) c.audit = request_context['audit'] c.audit['success'] = False c.audit['client'] = get_client(request) # Session handling check_session(request) request_context['Audit'] = audit checkAuthorisation(scope='monitoring', method=action) return request except Exception as exception: log.exception(exception) Session.rollback() Session.close() return sendError(response, exception, context='before') finally: log.debug('[__before__::%r] done', action)
def __before__(self, action, **params): """ """ try: log.debug("[__before__::%r] %r" % (action, params)) # Session handling check_session(request) checkToolsAuthorisation(action, params) c.audit = request_context['audit'] return request except PolicyException as exx: log.exception("policy failed %r" % exx) Session.rollback() Session.close() return sendError(response, exx, context='before') except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params): log.debug("[__before__::%r] %r" % (action, params)) try: audit.initialize() c.audit['success'] = False c.audit['client'] = get_client(request) c.version = get_version() c.licenseinfo = get_copyright_info() c.polDefs = getPolicyDefinitions() # Session handling for the functions, that show data: # Also exclude custom-style.css, since the CSRF check # will always fail and return a HTTP 401 anyway. # A HTTP 404 makes more sense. if request.path.lower() in [ '/manage/', '/manage', '/manage/logout', '/manage/audittrail', '/manage/policies', '/manage/tokenview', '/manage/userview', '/manage/help', '/manage/custom-style.css' ]: pass else: check_session(request) except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params): ''' Here we see, what action is to be called and check the authorization ''' log.debug("[__before__::%r] %r" % (action, params)) try: audit.initialize() c.audit['success'] = False c.audit['client'] = get_client() if action != "check_t": check_session() return response except webob.exc.HTTPUnauthorized as acc: ## the exception, when an abort() is called if forwarded log.error("[__before__::%r] webob.exception %r" % (action, acc)) log.error("[__before__] %s" % traceback.format_exc()) Session.rollback() Session.close() raise acc except Exception as exx: log.error("[__before__::%r] exception %r" % (action, exx)) log.error("[__before__] %s" % traceback.format_exc()) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, **params): """ __before__ is called before every action :param params: list of named arguments :return: -nothing- or in case of an error a Response created by sendError with the context info 'before' """ action = request_context['action'] try: c.audit = request_context['audit'] c.audit['success'] = False c.audit['client'] = get_client(request) c.version = get_version() c.version_ref = base64.encodebytes(c.version.encode())[:6] c.licenseinfo = get_copyright_info() c.polDefs = getPolicyDefinitions() c.display_provider = boolean( request_context['Config'].get('display_provider', True)) # -------------------------------------------------------------- -- # check for support of setting admin password c.admin_can_change_password = False if ('linotpadmin.user' in config and 'linotpadmin.password' in config): c.admin_can_change_password = True # -------------------------------------------------------------- -- # Session handling for the functions, that show data: # Also exclude custom-style.css, since the CSRF check # will always fail and return a HTTP 401 anyway. # A HTTP 404 makes more sense. if request.path.lower() in ['/manage/', '/manage', '/manage/logout', '/manage/audittrail', '/manage/policies', '/manage/tokenview', '/manage/userview', '/manage/help', '/manage/custom-style.css']: pass else: check_session(request) except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, **params): """ __before__ is called before every action :param params: list of named arguments :return: -nothing- or in case of an error a Response created by sendError with the context info 'before' """ action = request_context['action'] try: c.audit = request_context['audit'] c.audit['success'] = False c.audit['client'] = get_client(request) # Session handling check_session(request) audit = config.get('audit') request_context['Audit'] = audit checkAuthorisation(scope='monitoring', method=action) return except Exception as exception: log.exception(exception) Session.rollback() Session.close() return sendError(response, exception, context='before')
def __before__(self, **params): """ __before__ is called before every action :param params: list of named arguments :return: -nothing- or in case of an error a Response created by sendError with the context info 'before' """ action = request_context['action'] try: # Session handling check_session(request) checkToolsAuthorisation(action, params) c.audit = request_context['audit'] return except PolicyException as exx: log.exception("policy failed %r" % exx) Session.rollback() Session.close() return sendError(response, exx, context='before') except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before')
def __before__(self, action, **params): ''' Here we see, what action is to be called and check the authorization ''' try: c.audit = request_context['audit'] c.audit['success'] = False c.audit['client'] = get_client(request) if action != "check_t": check_session(request) request_context['Audit'] = audit return response except webob.exc.HTTPUnauthorized as acc: # the exception, when an abort() is called if forwarded log.exception("[__before__::%r] webob.exception %r" % (action, acc)) Session.rollback() Session.close() raise acc except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before')
def __before__(self, **params): """ __before__ is called before every action :param params: list of named arguments :return: -nothing- or in case of an error a Response created by sendError with the context info 'before' """ action = request_context["action"] try: g.audit["success"] = False g.audit["client"] = get_client(request) # Session handling check_session(request) audit = config.get("audit") request_context["Audit"] = audit checkAuthorisation(scope="monitoring", method=action) return except Exception as exception: log.error(exception) db.session.rollback() return sendError(response, exception, context="before")
def __before__(self, action): try: c.audit = request_context['audit'] c.audit['client'] = get_client(request) check_session(request) except Exception as exx: log.exception("[__before__::%r] exception %r", action, exx) Session.rollback() Session.close() return sendError(response, exx, context='before')
def __before__(self, action, **params): try: c.audit = request_context['audit'] c.audit['success'] = False c.audit['client'] = get_client(request) c.version = get_version() c.version_ref = base64.encodestring(c.version)[:6] c.licenseinfo = get_copyright_info() c.polDefs = getPolicyDefinitions() c.display_provider = boolean( request_context['Config'].get('display_provider', True)) # -------------------------------------------------------------- -- # check for support of setting admin password c.admin_can_change_password = False if ('linotpadmin.user' in config and 'linotpadmin.password' in config): c.admin_can_change_password = True # -------------------------------------------------------------- -- # Session handling for the functions, that show data: # Also exclude custom-style.css, since the CSRF check # will always fail and return a HTTP 401 anyway. # A HTTP 404 makes more sense. if request.path.lower() in ['/manage/', '/manage', '/manage/logout', '/manage/audittrail', '/manage/policies', '/manage/tokenview', '/manage/userview', '/manage/help', '/manage/custom-style.css']: pass else: check_session(request) except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action): log.debug("[__before__]") try: audit.initialize() c.audit['client'] = get_client(request) check_session(request) except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params): log.debug("[__before__]") try: audit.initialize() c.audit['client'] = get_client() check_session() except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action): log.debug("[__before__]") try: c.audit = self.request_context['audit'] c.audit['client'] = get_client(request) check_session(request) except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params): log.debug("[__before__]") try: audit.initialize() c.audit['client'] = get_client() check_session() except Exception as exx: log.error("[__before__::%r] exception %r" % (action, exx)) log.error("[__before__] %s" % traceback.format_exc()) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params): log.debug("[__before__::%r] %r" % (action, params)) try: c.audit = request_context['audit'] c.audit['client'] = get_client(request) check_session(request) request_context['Audit'] = audit except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params): log.debug("[__before__]") try: audit.initialize() c.audit["client"] = get_client() check_session() except Exception as exx: log.error("[__before__::%r] exception %r" % (action, exx)) log.error("[__before__] %s" % traceback.format_exc()) Session.rollback() Session.close() return sendError(response, exx, context="before") finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, **params): """ __before__ is called before every action :param params: list of named arguments :return: -nothing- or in case of an error a Response created by sendError with the context info 'before' """ action = request_context["action"] try: g.audit["client"] = get_client(request) check_session(request) except Exception as exx: log.error("[__before__::%r] exception %r", action, exx) db.session.rollback() return sendError(response, exx, context="before")
def __before__(self, **params): ''' ''' action = request_context['action'] try: g.audit['success'] = False g.audit['client'] = get_client(request) # Session handling if action not in ['getsession', 'dropsession']: check_session(request, scope='helpdesk') except Exception as exx: log.exception("[__before__::%r] exception", action) db.session.rollback() return sendError(None, exx, context='before')
def __before__(self, action, **params): log.debug("[__before__::%r] %r" % (action, params)) try: audit.initialize() c.audit["success"] = False c.audit["client"] = get_client() c.version = get_version() c.licenseinfo = get_copyright_info() c.polDefs = getPolicyDefinitions() # Session handling for the functions, that show data: # Also exclude custom-style.css, since the CSRF check # will always fail and return a HTTP 401 anyway. # A HTTP 404 makes more sense. if request.path.lower() in [ "/manage/", "/manage", "/manage/logout", "/manage/audittrail", "/manage/policies", "/manage/tokenview", "/manage/userview", "/manage/help", "/manage/custom-style.css", ]: pass else: check_session() except Exception as exx: log.error("[__before__::%r] exception %r" % (action, exx)) log.error("[__before__] %s" % traceback.format_exc()) Session.rollback() Session.close() return sendError(response, exx, context="before") finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, **params): """ __before__ is called before every action Here we see, what action is to be called and check the authorization :param params: list of named arguments :return: -nothing- or in case of an error a Response created by sendError with the context info 'before' """ action = request_context['action'] try: c.audit = request_context['audit'] c.audit['success'] = False c.audit['client'] = get_client(request) if action != "check_t": check_session(request) audit = config.get('audit') request_context['Audit'] = audit return except flap.HTTPUnauthorized as acc: # the exception, when an abort() is called if forwarded log.exception("[__before__::%r] webob.exception %r" % (action, acc)) Session.rollback() Session.close() raise acc except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before')
def __before__(self, action, **params): """ """ try: c.audit = request_context['audit'] c.audit['success'] = False c.audit['client'] = get_client(request) # Session handling check_session(request) request_context['Audit'] = audit checkAuthorisation(scope='reporting.access', method=action) return request except Exception as exception: log.exception(exception) Session.rollback() Session.close() return sendError(response, exception, context='before')
def __before__(self, **params): """ __before__ is called before every action :param params: list of named arguments :return: -nothing- or in case of an error a Response created by sendError with the context info 'before' """ action = request_context['action'] try: c.audit = request_context['audit'] c.audit['client'] = get_client(request) check_session(request) audit = config.get('audit') request_context['Audit'] = audit except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before')
def __before__(self, action, **params): log.debug("[__before__::%r] %r" % (action, params)) try: c.audit = request_context['audit'] c.audit['success'] = False c.audit['client'] = get_client(request) c.version = get_version() c.licenseinfo = get_copyright_info() c.polDefs = getPolicyDefinitions() # Session handling for the functions, that show data: # Also exclude custom-style.css, since the CSRF check # will always fail and return a HTTP 401 anyway. # A HTTP 404 makes more sense. if request.path.lower() in ['/manage/', '/manage', '/manage/logout', '/manage/audittrail', '/manage/policies', '/manage/tokenview', '/manage/userview', '/manage/help', '/manage/custom-style.css']: pass else: check_session(request) except Exception as exx: log.exception("[__before__::%r] exception %r" % (action, exx)) Session.rollback() Session.close() return sendError(response, exx, context='before') finally: log.debug("[__before__::%r] done" % (action))
def __before__(self, action, **params): ''' ''' try: c.audit = request_context['audit'] c.audit['success'] = False c.audit['client'] = get_client(request) request_context['Audit'] = audit # Session handling if action not in ['getsession', 'dropsession']: check_session(request, scope='helpdesk') return request except Exception as exx: log.exception("[__before__::%r] exception", action) Session.rollback() Session.close() return sendError(response, exx, context='before')
def __before__(self, **params): """ __before__ is called before every action :param params: list of named arguments :return: -nothing- or in case of an error a Response created by sendError with the context info 'before' """ action = request_context["action"] try: g.audit["success"] = False g.audit["client"] = get_client(request) c.version = get_version() c.version_ref = base64.encodebytes(c.version.encode())[:6] c.licenseinfo = get_copyright_info() c.polDefs = get_policy_definitions() c.display_provider = boolean( request_context["Config"].get("display_provider", True) ) # -------------------------------------------------------------- -- # check for support of setting admin password c.admin_can_change_password = False if ( "linotpadmin.user" in config and "linotpadmin.password" in config ): c.admin_can_change_password = True # -------------------------------------------------------------- -- # Session handling for the functions, that show data: # Also exclude custom-style.css, since the CSRF check # will always fail and return a HTTP 401 anyway. # A HTTP 404 makes more sense. if request.path.lower() in [ "/manage/", "/manage", "/manage/login", "/manage/audittrail", "/manage/policies", "/manage/tokenview", "/manage/userview", "/manage/help", "/manage/custom-style.css", ]: pass else: check_session(request) except Exception as exx: log.error("[__before__::%r] exception %r", action, exx) db.session.rollback() return sendError(response, exx, context="before") finally: log.debug("[__before__::%r] done", action)