Esempio n. 1
0
    def _process_dynamic(self, webreq):
        self._prewikka_init_if_needed()

        # Some newly loaded plugin from another request may have modified globally loadeds
        # JS/CSS scripts. We thus need to call _process_static() again after _prewikka_init_if_needed()
        response = self._process_static(webreq)
        if response:
            return response

        autherr = None
        try:
            env.request.user = env.session.get_user(webreq)
            env.request.user.set_locale()
        except error.PrewikkaError as e:
            autherr = e
            pass

        if webreq.path == "/":
            return self._redirect_default(webreq)

        try:
            view_object = env.viewmanager.load_view(webreq, env.request.user)
        except Exception as err:
            raise autherr or err

        if view_object.view_require_session and autherr:
            view_object = autherr

        resolve.process(env.dns_max_delay)
        ret = view_object.respond()
        if env.request.user:
            env.request.user.sync_properties()

        return ret
Esempio n. 2
0
    def process(self, request):
        user = None
        http_rcode = 200
        view_object = None

        encoding = env.config.general.getOptionValue("encoding", "utf8")
        try:
            self._prewikka_init_if_needed()

            env.threadlocal.user = user = env.session.get_user(request)
            user.set_locale()

            if not all(env.hookmgr.trigger("HOOK_PROCESS_REQUEST", request, user)):
                return

            if not request.path or request.path == "/":
                raise error.RedirectionError("%salerts/alerts" % request.getBaseURL(), 302)

            view_object = env.viewmanager.loadView(request, user)
            if view_object.dataset is not None:
                self._setupDataSet(view_object.dataset, request, user)

            resolve.process(env.dns_max_delay)
            request.content = view_object.respond()

        except error.RedirectionError as err:
            return request.sendRedirect(err.location, err.code)

        except Exception, err:
            http_rcode = getattr(err, "code", 500)

            dataset = self.handleError(request, err, user)
            if dataset:
                request.content = dataset.render()
Esempio n. 3
0
    def render(self):
        DistributionStats.render(self)

        self.dataset["title"] = "Top Alert Targets"

        criteria = self._processCriteria()

        self._setPeriod()

        self._renderAddresses(criteria)
        self._renderPorts(criteria)
        self._renderUsers(criteria)

        resolve.process(self.env.dns_max_delay)
Esempio n. 4
0
    def render(self):
        DistributionStats.render(self)

        self.dataset["title"] = "Top Alert Sources"

        criteria = self._processCriteria()

        self._setPeriod()

        self._renderCountry(criteria)
        self._renderSourcesTrend(criteria)
        self._renderAddresses(criteria)
        self._renderUsers(criteria)

        resolve.process(self.env.dns_max_delay)
Esempio n. 5
0
    def process(self, webreq):
        env.request.init(webreq)
        view_object = autherr = None

        encoding = env.config.general.get("encoding", "utf8")
        try:
            self._prewikka_init_if_needed()

            try:
                env.request.user = env.session.get_user(webreq)
                env.request.user.set_locale()
            except Exception as autherr:
                pass

            if not all(hookmanager.trigger("HOOK_PROCESS_REQUEST", webreq, env.request.user)):
                return

            if webreq.path == "/":
                return self._redirect_default(webreq)

            view_object = env.viewmanager.loadView(webreq, env.request.user)
            if view_object.view_require_session and autherr:
                raise autherr

            resolve.process(env.dns_max_delay)
            response = view_object.respond()

        except error.RedirectionError as err:
            return webreq.send_redirect(err.location, err.code)

        except error.PrewikkaUserError as err:
            response = err.respond()

        except Exception, err:
            response = error.PrewikkaUserError(
                _("Prelude internal error"),
                err,
                display_traceback=env.config.general.get("enable_error_traceback") not in ('no', 'false')
            ).respond()
Esempio n. 6
0
def test_address_resolve():
    """
    Test `prewikka.resolve.AddressResolve` class.

    Test methods of the class AddressResolve (resolve() method is tested in dedicated tests).
    NOTE: Test skipped if Twisted is not installed.
    """
    # Skip test if Twisted is not installed
    pytest.importorskip('twisted')

    init()

    process()

    # change env.dns_max_delay
    backup_env_max_delay = env.dns_max_delay

    env.dns_max_delay = -1

    assert not init()

    # clean
    env.dns_max_delay = backup_env_max_delay
Esempio n. 7
0
            self._cleanupView(view_object)

        except Error.PrewikkaUserError, e:
            if e._log_priority:
                self._env.log.log(e._log_priority, unicode(e), request=request, user=login or e._log_user)

            self._setupDataSet(e.dataset, request, user, view=view)
            dataset, template_name = e.dataset, e.template

        except Exception, e:
            error = self.prepareError(e, request, user, login, view)
            dataset, template_name = error.dataset, error.template

        #self._printDataSet(dataset)
        template = load_template(template_name, dataset)

        # We check the character set after loading the template,
        # since the template might trigger a language change.
        dataset["document.charset"] = localization.getCurrentCharset()
        resolve.process(self._env.dns_max_delay)

        try:
                request.content = template.respond()
        except Exception, e:
            error = self.prepareError(e, request, user, login, view)
            request.content = load_template(error.template, error.dataset).respond()

        request.content = request.content.encode(encoding, "xmlcharrefreplace")
        request.sendResponse()