def _sql_profiler_view(request: pyramid.request.Request) -> Mapping[str, Any]: auth.auth_view(request) enable = request.params.get("enable") if enable is not None: broadcast.broadcast("c2c_sql_profiler", params={"enable": enable}, expect_answers=True) return {"status": 200, "enabled": repository is not None}
def _sql_profiler_view(request: pyramid.request.Request) -> Mapping[str, Any]: global repository auth.auth_view(request) enable = request.params.get('enable') if enable is not None: broadcast.broadcast('c2c_sql_profiler', params={'enable': enable}, expect_answers=True) return {'status': 200, 'enabled': repository is not None}
def memory(request): auth_view(request) return _memory( with_others=request.params.get("with_others", "false").lower() in ["1", "on", "true"], with_all=request.params.get("with_all", "false").lower() in ["1", "on", "true"], with_repr=request.params.get("with_repr", "false").lower() in ["1", "on", "true"], )
def _db_maintenance(request: pyramid.request.Request) -> Mapping[str, Any]: auth.auth_view(request) readonly_param = cast(str, request.params.get("readonly")) if readonly_param is not None: readonly = readonly_param.lower() == "true" LOG.critical("Readonly DB status changed from %s to %s", db.force_readonly, readonly) _set_readonly(value=readonly) _store(request.registry.settings, readonly) return {"status": 200, "readonly": readonly} else: readonly = _get_redis_value(request.registry.settings) if readonly is not None: readonly = readonly == "true" return {"status": 200, "current_readonly": readonly}
def run(self): auth_view(self.request) if "command" not in self.request.POST: raise pyramid.httpexceptions.HTTPBadRequest( "The POST argument 'command' is required") command = shlex.split(self.request.POST["command"]) if command[0] not in self.gene.config.get("server", {}).get( "allowed_commands", ["generate_tiles", "generate_controller"]): raise pyramid.httpexceptions.HTTPBadRequest( "The given executable '{}' is not allowed".format(command[0])) log_thread = LogThread(command) log_thread.start() return pyramid.httpexceptions.HTTPFound( self.request.route_url("admin"))
def run(self): auth_view(self.request) if 'command' not in self.request.POST: raise pyramid.httpexceptions.HTTPBadRequest("The POST argument 'command' is required") command = shlex.split(self.request.POST['command']) if command[0] not in self.gene.config.get('server', {}).get('allowed_commands', [ 'generate_tiles', 'generate_controller' ]): raise pyramid.httpexceptions.HTTPBadRequest( "The given executable '{}' is not allowed".format(command[0]) ) lt = LogThread(command) lt.start() return pyramid.httpexceptions.HTTPFound(self.request.route_url('admin'))
def _dump_memory_diff(request: pyramid.request.Request) -> List[Any]: auth.auth_view(request) limit = int(request.params.get("limit", "30")) if "path" in request.matchdict: # deprecated path = "/" + "/".join(request.matchdict["path"]) else: path = request.params["path"] sub_request = request.copy() split_path = path.split("?") sub_request.path_info = split_path[0] if len(split_path) > 1: sub_request.query_string = split_path[1] # warmup run try: if "no_warmup" not in request.params: request.invoke_subrequest(sub_request) except Exception: # nosec # pylint: disable=broad-except pass LOG.debug("checking memory growth for %s", path) peak_stats: Dict[Any, Any] = {} for i in range(3): gc.collect(i) objgraph.growth(limit=limit, peak_stats=peak_stats, shortnames=False) response = None try: response = request.invoke_subrequest(sub_request) LOG.debug("response was %d", response.status_code) except HTTPException as ex: LOG.debug("response was %s", str(ex)) del response for i in range(3): gc.collect(i) return objgraph.growth(limit=limit, peak_stats=peak_stats, shortnames=False) # type: ignore
def _dump_memory(request: pyramid.request.Request) -> List[Mapping[str, Any]]: auth.auth_view(request) limit = int(request.params.get("limit", "30")) analyze_type = request.params.get("analyze_type") python_internals_map = request.params.get("python_internals_map", "0").lower() in ("", "1", "true", "on") result = broadcast.broadcast( "c2c_dump_memory", params={ "limit": limit, "analyze_type": analyze_type, "python_internals_map": python_internals_map }, expect_answers=True, timeout=70, ) assert result is not None return result
def _headers(request: pyramid.request.Request) -> Mapping[str, Any]: auth.auth_view(request) result = { "headers": dict(request.headers), "client_info": { "client_addr": request.client_addr, "host": request.host, "host_port": request.host_port, "http_version": request.http_version, "path": request.path, "path_info": request.path_info, "remote_addr": request.remote_addr, "remote_host": request.remote_host, "scheme": request.scheme, "server_name": request.server_name, "server_port": request.server_port, }, } if "status" in request.params: raise exception_response(int(request.params["status"]), detail=result) else: return result
def _show_refs(request: pyramid.request.Request) -> pyramid.response.Response: auth.auth_view(request) for generation in range(3): gc.collect(generation) objs: List[Any] = [] if "analyze_type" in request.params: objs = objgraph.by_type(request.params["analyze_type"]) elif "analyze_id" in request.params: objs = [objgraph.by(int(request.params["analyze_id"]))] args: Dict[str, Any] = { "refcounts": True, } if request.params.get("max_depth", "") != "": args["max_depth"] = int(request.params["max_depth"]) if request.params.get("too_many", "") != "": args["too_many"] = int(request.params["too_many"]) if request.params.get("min_size_kb", "") != "": args["filter"] = lambda obj: get_size(obj) > (int(request.params[ "min_size_kb"]) * 1024) if request.params.get("no_extra_info", "") == "": args[ "extra_info"] = lambda obj: f"{get_size(obj) / 1024:.3f} kb\n{id(obj)}" result = StringIO() if request.params.get("backrefs", "") != "": objgraph.show_backrefs(objs, output=result, **args) else: objgraph.show_refs(objs, output=result, filter=lambda x: not objgraph.inspect.isclass(x), **args) request.response.content_type = "text/vnd.graphviz" request.response.text = result.getvalue() result.close() return request.response
def _logging_change_level( request: pyramid.request.Request) -> Mapping[str, Any]: auth.auth_view(request) name = request.params.get('name') if name is not None: level = request.params.get('level') logger = logging.getLogger(name) if level is not None: LOG.critical("Logging of %s changed from %s to %s", name, logging.getLevelName(logger.level), level) _set_level(name=name, level=level) _store_override(request.registry.settings, name, level) return { 'status': 200, 'name': name, 'level': logging.getLevelName(logger.level), 'effective_level': logging.getLevelName(logger.getEffectiveLevel()) } else: return { 'status': 200, 'overrides': dict(_list_overrides(request.registry.settings)) }
def memory(request: pyramid.request.Request) -> Dict[str, Any]: auth_view(request) return cast(Dict[str, Any], _memory())
def _dump_stacks(request: pyramid.request.Request) -> List[Mapping[str, Any]]: auth.auth_view(request) result = broadcast.broadcast("c2c_dump_stacks", expect_answers=True) assert result is not None return _beautify_stacks(result)
def _dump_memory_maps( request: pyramid.request.Request) -> List[Dict[str, Any]]: auth.auth_view(request) return sorted(dump_memory_maps(), key=lambda i: cast(int, -i.get("pss_kb", 0)))
def _error(request: pyramid.request.Request) -> Any: auth.auth_view(request) raise exception_response(int(request.params["status"]), detail="Test")
def _sleep(request: pyramid.request.Request) -> pyramid.response.Response: auth.auth_view(request) timeout = float(request.params["time"]) time.sleep(timeout) request.response.status_code = 204 return request.response
def run(self) -> pyramid.response.Response: """Run the command given by the user.""" assert self.gene auth_view(self.request) if "command" not in self.request.POST: self.request.response.status_code = 400 return {"error": "The POST argument 'command' is required"} commands = shlex.split(self.request.POST["command"]) command = commands[0].replace("_", "-") allowed_commands = (self.gene.get_main_config().config.get( "server", {}).get( "allowed_commands", ["generate-tiles", "generate-controller", "generate-cost"])) if command not in allowed_commands: return { "error": f"The given command '{command}' is not allowed, allowed command are: " f"{', '.join(allowed_commands)}" } add_role = False arguments = {c.split("=")[0]: c.split("=")[1:] for c in commands[1:]} if command == "generate-tiles": add_role = "--get-hash" not in arguments and "--get-bbox" not in arguments allowed_arguments = (self.gene.get_main_config().config.get( "server", {}).get( "allowed_arguments", [ "--layer", "--get-hash", "--generate-legend-images", "--dump-config", "--get-bbox", ], )) for arg in arguments.keys(): if arg.startswith("-") and arg not in allowed_arguments: self.request.response.status_code = 400 return { "error": (f"The argument {arg} is not allowed, allowed arguments are: " f"{', '.join(allowed_arguments)}") } final_command = [ command, f"--config={self.gene.get_host_config_file(self.request.host)}" ] if add_role: final_command += ["--role=master"] final_command += commands[1:] display_command = " ".join([shlex.quote(arg) for arg in final_command]) LOG.info("Run the command `%s`", display_command) env: Dict[str, str] = {} env.update(os.environ) env["FRONTEND"] = "noninteractive" completed_process = subprocess.run( # nosec # pylint: disable=subprocess-run-check final_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, ) if completed_process.returncode != 0: LOG.warning( "The command `%s` exited with an error code: %s\nstdout:\n%s\nstderr:\n%s", display_command, completed_process.returncode, completed_process.stdout.decode(), completed_process.stderr.decode(), ) return { "stdout": _limit_length( completed_process.stdout.decode(), int(os.environ.get("TILECLOUD_CHAIN_MAX_OUTPUT_LENGTH", 1000)), ), "stderr": _limit_length( completed_process.stderr.decode(), int(os.environ.get("TILECLOUD_CHAIN_MAX_OUTPUT_LENGTH", 1000)), ), "returncode": completed_process.returncode, }
def invalidate_cache(self) -> Dict[str, bool]: auth_view(self.request) models.cache_invalidate_cb() return {"success": True}
def invalidate_cache(self): # pragma: no cover auth_view(self.request) main.cache_invalidate_cb() return {"success": True}
def memory(request: pyramid.request.Request) -> Dict[str, Any]: """Offer an authenticated view throw c2cwsgiutils to provide some memory information.""" auth_view(request) return cast(Dict[str, Any], _memory())