def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> WSGIResponse: req = http.Request(environ) output_format = get_output_format( req.get_ascii_input_mandatory("output_format", "html").lower()) mime_type = get_mime_type_from_output_format(output_format) resp = Response(headers=default_response_headers(req), mimetype=mime_type) funnel = OutputFunnel(resp) timeout_manager = TimeoutManager() timeout_manager.enable_timeout(req.request_timeout) theme = Theme() config_obj = config_module.make_config_object( config_module.get_default_config()) with AppContext(self), RequestContext( req=req, resp=resp, funnel=funnel, config_obj=config_obj, user=LoggedInNobody(), html_obj=htmllib.html(req, resp, funnel, output_format), timeout_manager=timeout_manager, display_options=DisplayOptions(), theme=theme, ), patch_json(json): config_module.initialize() theme.from_config(config.ui_theme) return self.wsgi_app(environ, start_response)
def __call__(self, environ, start_response): req = http.Request(environ) with AppContext(self), RequestContext(req=req, html_obj=htmllib.html(req)): config.initialize() html.init_modes() return self.wsgi_app(environ, start_response)
def test_write_and_read_host_attributes(tmp_path, attributes, monkeypatch): folder_path = str(tmp_path) # Write/Read operations always require a valid user monkeypatch.setattr(config, "user", config.LoggedInSuperUser()) # Used to write the data write_data_folder = watolib.Folder("testfolder", folder_path=folder_path, parent_folder=None) # Used to read the previously written data read_data_folder = watolib.Folder("testfolder", folder_path=folder_path, parent_folder=None) environ = dict(create_environ(), REQUEST_URI='') with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(Request(environ))): # Write data # Note: The create_hosts function modifies the attributes dict, adding a meta_data key inplace write_data_folder.create_hosts([("testhost", attributes, [])]) write_folder_hosts = write_data_folder.hosts() assert len(write_folder_hosts) == 1 # Read data back read_folder_hosts = read_data_folder.hosts() assert len(read_folder_hosts) == 1 for _, host in read_folder_hosts.items(): assert host.attributes() == attributes
def mock_livestatus(with_context=False): live = MockLiveStatusConnection() env = EnvironBuilder().get_environ() req = http.Request(env) app_context: ContextManager req_context: ContextManager if with_context: app_context = AppContext(None) req_context = RequestContext( req=req, display_options=DisplayOptions(), prefix_logs_with_url=False, ) else: app_context = contextlib.nullcontext() req_context = contextlib.nullcontext() with app_context, req_context, \ mock.patch("cmk.gui.sites._get_enabled_and_disabled_sites", new=live.enabled_and_disabled_sites), \ mock.patch("livestatus.MultiSiteConnection.set_prepend_site", new=live.set_prepend_site), \ mock.patch("livestatus.MultiSiteConnection.expect_query", new=live.expect_query, create=True), \ mock.patch("livestatus.SingleSiteConnection._create_socket", new=live.create_socket), \ mock.patch.dict(os.environ, {'OMD_ROOT': '/', 'OMD_SITE': 'NO_SITE'}): yield live
def run(self): self._logger.log(VERBOSE, "Initializing application...") environ = dict(create_environ(), REQUEST_URI='') this_html = htmllib.html(Request(environ)) # Currently the htmllib.html constructor enables the timeout by default. This side effect # should really be cleaned up. this_html.disable_request_timeout() with AppContext(DummyApplication(environ, None)), \ RequestContext(this_html): self._initialize_gui_environment() self._logger.log(VERBOSE, "Updating Checkmk configuration...") for step_func, title in self._steps(): self._logger.log(VERBOSE, " + %s..." % title) try: step_func() except Exception: self._logger.log(VERBOSE, " + \"%s\" failed" % title, exc_info=True) if self._arguments.debug: raise self._logger.log(VERBOSE, "Done")
def test_load_group_information_empty(tmp_path): environ = dict(create_environ(), REQUEST_URI='') with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(Request(environ))): assert groups.load_contact_group_information() == {} assert gui_groups.load_host_group_information() == {} assert gui_groups.load_service_group_information() == {}
def test_del_vars(): environ = dict(create_environ(), REQUEST_URI='', QUERY_STRING='foo=foo&_username=foo&_password=bar&bar=bar') with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(Request(environ))): # First we hit the cached property so we can see that the underlying Request object # actually got replaced later. _ = request.args _ = html.request.args html.request.set_var("foo", "123") html.del_var_from_env("_username") html.del_var_from_env("_password") # Make test independent of dict sorting assert html.request.query_string in [ 'foo=foo&bar=bar', 'bar=bar&foo=foo' ] assert '_password' not in html.request.args assert '_username' not in html.request.args # Check the request local proxied version too. # Make test independent of dict sorting assert request.query_string in ['foo=foo&bar=bar', 'bar=bar&foo=foo'] assert '_password' not in request.args assert '_username' not in request.args assert html.request.var("foo") == "123"
def mock_livestatus(with_context=False): def enabled_and_disabled_sites(_user): return {'NO_SITE': {'socket': 'unix:'}}, {} live = MockLiveStatusConnection() env = EnvironBuilder().get_environ() req = http.Request(env) app_context: ContextManager req_context: ContextManager if with_context: app_context = AppContext(None) req_context = RequestContext(req=req) else: app_context = contextlib.nullcontext() req_context = contextlib.nullcontext() with app_context, req_context, \ mock.patch("cmk.gui.sites._get_enabled_and_disabled_sites", new=enabled_and_disabled_sites), \ mock.patch("livestatus.MultiSiteConnection.set_prepend_site", new=live.set_prepend_site), \ mock.patch("livestatus.MultiSiteConnection.expect_query", new=live.expect_query, create=True), \ mock.patch("livestatus.SingleSiteConnection._create_socket", new=live.create_socket), \ mock.patch.dict(os.environ, {'OMD_ROOT': '/', 'OMD_SITE': 'NO_SITE'}): yield live
def __call__(self, environ, start_response): req = http.Request(environ) output_format = get_output_format( req.get_ascii_input_mandatory("output_format", "html").lower()) mime_type = get_mime_type_from_output_format(output_format) resp = Response(headers=default_response_headers(req), mimetype=mime_type) funnel = OutputFunnel(resp) timeout_manager = TimeoutManager() timeout_manager.enable_timeout(req.request_timeout) theme = Theme() with AppContext(self), RequestContext( req=req, resp=resp, funnel=funnel, html_obj=htmllib.html(req, resp, funnel, output_format), timeout_manager=timeout_manager, display_options=DisplayOptions(), theme=theme, ), patch_json(json): config.initialize() theme.from_config(config.ui_theme, config.theme_choices()) return self.wsgi_app(environ, start_response)
def __call__(self, environ, start_response) -> Response: req = http.Request(environ) with AppContext(self), RequestContext(req=req, display_options=DisplayOptions(), html_obj=htmllib.html(req)): config.initialize() return _process_request(environ, start_response)
def with_context(environ, start_response): req = http.Request(environ) with AppContext(app), \ RequestContext(req=req, display_options=DisplayOptions()), \ cmk.utils.store.cleanup_locks(), \ sites.cleanup_connections(): config.initialize() return app(environ, start_response)
def module_wide_request_context(): # This one is kind of an hack because some other test-fixtures touch the user object AFTER the # request context has already ended. If we increase our scope this won't matter, but it is of # course wrong. These other fixtures have to be fixed. environ = create_environ() with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(Request(environ))): yield
def wsgi_app(self, environ, start_response): # pylint: disable=method-hidden """Is called by the WSGI server to serve the current page""" request = cmk.gui.http.Request(environ) response = cmk.gui.http.Response(is_secure=request.is_secure) with AppContext(self), RequestContext(cmk.gui.htmllib.html(request, response)),\ cleanup_locks(): self._process_request(request, response) return response(environ, start_response)
def with_context(environ, start_response): req = cmk.gui.http.Request(environ) resp = cmk.gui.http.Response(is_secure=req.is_secure) with AppContext(app), RequestContext(cmk.gui.htmllib.html(req, resp)): config.initialize() html.init_modes() return app(environ, start_response)
def with_request_context(): environ = create_environ() resp = Response() with AppContext(DummyApplication(environ, None)), \ RequestContext(req=Request(environ), resp=resp, funnel=OutputFunnel(resp), display_options=DisplayOptions()): yield
def fixture_pre_20_cookie(): environ = dict( create_environ(), HTTP_COOKIE= u"xyz=123; auth_stable=lärs:1534272374.61:1f59cac3fcd5bcc389e4f8397bed315b; abc=123".encode( "utf-8")) with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(http.Request(environ))): yield "auth_stable"
def fixture_current_cookie(with_user, session_id): user_id = with_user[0] cookie_name = login.auth_cookie_name() cookie_value = login._auth_cookie_value(user_id, session_id) environ = dict(create_environ(), HTTP_COOKIE=f"{cookie_name}={cookie_value}".encode("utf-8")) with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(http.Request(environ))): yield cookie_name
def mock_livestatus( with_context: bool = False, with_html: bool = False ) -> Generator[MockLiveStatusConnection, None, None]: live = MockLiveStatusConnection() env = EnvironBuilder().get_environ() req = http.Request(env) resp = http.Response() app_context: ContextManager req_context: ContextManager if with_html: html_obj = None else: html_obj = html( request=req, response=resp, output_funnel=OutputFunnel(resp), output_format="html", ) if with_context: app_context = AppContext(None) req_context = RequestContext( html_obj=html_obj, req=req, resp=resp, funnel=OutputFunnel(resp), config_obj=make_config_object(get_default_config()), user=LoggedInNobody(), display_options=DisplayOptions(), prefix_logs_with_url=False, ) else: app_context = contextlib.nullcontext() req_context = contextlib.nullcontext() with app_context, req_context, mock.patch( "cmk.gui.sites._get_enabled_and_disabled_sites", new=live.enabled_and_disabled_sites), mock.patch( "livestatus.MultiSiteConnection.expect_query", new=live.expect_query, create=True), mock.patch( "livestatus.SingleSiteConnection._create_socket", new=live.create_socket), mock.patch.dict( os.environ, { "OMD_ROOT": "/", "OMD_SITE": "NO_SITE" }): # We don't want to be polluted by other tests. omd_site.cache_clear() yield live # We don't want to pollute other tests. omd_site.cache_clear()
def with_request_context(): environ = create_environ() resp = Response() with AppContext(session_wsgi_app(debug=False)), RequestContext( req=Request(environ), resp=resp, funnel=OutputFunnel(resp), config_obj=make_config_object(get_default_config()), display_options=DisplayOptions(), ): yield
def with_context(environ, start_response): req = http.Request(environ) resp = http.Response() with AppContext(app), \ RequestContext(req=req, resp=resp, funnel=OutputFunnel(resp), config_obj=config.make_config_object(config.get_default_config()), display_options=DisplayOptions()), \ cmk.utils.store.cleanup_locks(), \ sites.cleanup_connections(): config.initialize() return app(environ, start_response)
def run(self): self._logger.log(VERBOSE, "Updating Checkmk configuration...") environ = dict(create_environ(), REQUEST_URI='') with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(Request(environ), Response(is_secure=False))): self._initialize_gui_environment() for step_func, title in self._steps(): self._logger.log(VERBOSE, " + %s..." % title) step_func() self._logger.log(VERBOSE, "Done")
def test_web_server_auth_session(user_id): environ = dict(create_environ(), REMOTE_USER=str(user_id)) with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(http.Request(environ))): assert user.id is None with login.authenticate(request) as authenticated: assert authenticated is True assert user.id == user_id assert session.user_id == user.id assert user.id is None
def test_flash(user_id): environ = create_environ() # Execute the first request flash some message with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(http.Request(environ))) as request, \ login.UserContext(user_id): session_id = on_succeeded_login(user_id) # Create and activate session assert request.session is not None flash("abc") assert session.session_info.flashes == ["abc"] # Now create the second request to get the previously flashed message with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(http.Request(environ))), \ login.UserContext(user_id): on_access(user_id, session_id) assert request.session is not None assert session.session_info.flashes == ["abc"] # Get the flashed messages removes the messages from the session # and subsequent calls to get_flashed_messages return the messages # over and over. assert get_flashed_messages() == [HTML("abc")] assert get_flashed_messages() == [HTML("abc")] assert session.session_info.flashes == [] # Now create the third request that should not have access to the flashed messages since the # second one consumed them. with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(http.Request(environ))), \ login.UserContext(user_id): on_access(user_id, session_id) assert request.session is not None assert session.session_info.flashes == [] assert get_flashed_messages() == []
def is_permitted(self, url: str) -> bool: is_host_url = "mode=edit_host" in url file_name, query_vars = file_name_and_query_vars_from_url(url) self._set_query_vars(query_vars) try: with AppContext(current_app), \ RequestContext(html_obj=html(self._request), req=self._request), \ UserContext(self._user_id): if is_host_url: self._try_host() else: self._try_page(file_name) return True except MKAuthException: return False
def run(self): self._logger.log(VERBOSE, "Initializing application...") environ = dict(create_environ(), REQUEST_URI='') this_html = htmllib.html(Request(environ), Response(is_secure=False)) # Currently the htmllib.html constructor enables the timeout by default. This side effect # should really be cleaned up. this_html.disable_request_timeout() with AppContext(DummyApplication(environ, None)), \ RequestContext(this_html): self._initialize_gui_environment() self._logger.log(VERBOSE, "Updating Checkmk configuration...") for step_func, title in self._steps(): self._logger.log(VERBOSE, " + %s..." % title) step_func() self._logger.log(VERBOSE, "Done")
def application_context(environ: Mapping[str, Any]) -> Iterator[None]: with AppContext(session_wsgi_app(debug=False)): yield
def register_builtin_html(): """This fixture registers a global htmllib.html() instance just like the regular GUI""" environ = create_environ() with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(Request(environ))): yield
def application_context(environ: Mapping[str, Any]) -> Iterator[None]: with AppContext(DummyApplication(environ, None)): yield
def with_context(environ, start_response): req = http.Request(environ) with AppContext(app), RequestContext(req=req): return app(environ, start_response)
def test_load_group_information(tmp_path): with open(cmk.utils.paths.check_mk_config_dir + "/wato/groups.mk", "w") as f: f.write("""# encoding: utf-8 if type(define_contactgroups) != dict: define_contactgroups = {} define_contactgroups.update({'all': u'Everything'}) if type(define_hostgroups) != dict: define_hostgroups = {} define_hostgroups.update({'all_hosts': u'All hosts :-)'}) if type(define_servicegroups) != dict: define_servicegroups = {} define_servicegroups.update({'all_services': u'All särvices'}) """) with open(cmk.utils.paths.default_config_dir + "/multisite.d/wato/groups.mk", "w") as f: f.write("""# encoding: utf-8 multisite_hostgroups = { "all_hosts": { "ding": "dong", }, } multisite_servicegroups = { "all_services": { "d1ng": "dong", }, } multisite_contactgroups = { "all": { "d!ng": "dong", }, } """) environ = dict(create_environ(), REQUEST_URI='') with AppContext(DummyApplication(environ, None)), \ RequestContext(htmllib.html(Request(environ))): assert groups.load_group_information() == { 'contact': { 'all': { 'alias': u'Everything', "d!ng": "dong", } }, 'host': { 'all_hosts': { 'alias': u'All hosts :-)', "ding": "dong", } }, 'service': { 'all_services': { 'alias': u'All s\xe4rvices', "d1ng": "dong", } }, } assert groups.load_contact_group_information() == { 'all': { 'alias': u'Everything', "d!ng": "dong", } } assert gui_groups.load_host_group_information() == { 'all_hosts': { 'alias': u'All hosts :-)', "ding": "dong", } } assert gui_groups.load_service_group_information() == { 'all_services': { 'alias': u'All s\xe4rvices', "d1ng": "dong", } }