Source code for cobbler.templar

Cobbler uses Cheetah templates for lots of stuff, but there's some additional magic around that to deal with
snippets/etc. (And it's not spelled wrong!)

# SPDX-License-Identifier: GPL-2.0-or-later
# SPDX-FileCopyrightText: Copyright 2006-2009, Red Hat, Inc and Others
# SPDX-FileCopyrightText: Michael DeHaan <michael.dehaan AT gmail>

import logging
import os
import os.path
import pprint
import re
from typing import TYPE_CHECKING, Any, Dict, List, Optional, TextIO, Union

from cobbler import utils
from cobbler.cexceptions import CX
from cobbler.template_api import CobblerTemplate
from cobbler.utils import filesystem_helpers

    from cobbler.api import CobblerAPI

    import jinja2

except ModuleNotFoundError:
    # FIXME: log a message here
    JINJA2_AVAILABLE = False  # type: ignore

[docs]class Templar: """ Wrapper to encapsulate all logic of Cheetah vs. Jinja2. This also enables us to remove and add templating as desired via our self-defined API in this class. """ def __init__(self, api: "CobblerAPI"): """ Constructor :param api: The main API instance which is used by the current running server. """ self.settings = api.settings() self.last_errors: List[Any] = [] self.logger = logging.getLogger()
[docs] def check_for_invalid_imports(self, data: str) -> None: """ Ensure that Cheetah code is not importing Python modules that may allow for advanced privileges by ensuring we whitelist the imports that we allow. :param data: The Cheetah code to check. :raises CX: Raised in case there could be a pontentially insecure import in the template. """ lines = data.split("\n") for line in lines: if "#import" in line or "#from" in line: rest = ( line.replace("#import", "") .replace("#from", "") .replace("import", ".") .replace(" ", "") .strip() ) if self.settings and rest not in self.settings.cheetah_import_whitelist: raise CX(f"Potentially insecure import in template: {rest}")
[docs] def render( self, data_input: Union[TextIO, str], search_table: Dict[Any, Any], out_path: Optional[str], template_type: str = "default", ) -> str: """ Render data_input back into a file. :param data_input: is either a str or a TextIO object. :param search_table: is a dict of metadata keys and values. :param out_path: Optional parameter which (if present), represents the target path to write the result into. :param template_type: May currently be "cheetah" or "jinja2". "default" looks in the settings. :return: The rendered template. """ if not isinstance(data_input, str): raw_data = else: raw_data = data_input lines = raw_data.split("\n") if template_type is None: raise ValueError('"template_type" can\'t be "None"!') if not isinstance(template_type, str): # type: ignore raise TypeError('"template_type" must be of type "str"!') if template_type not in ("default", "jinja2", "cheetah"): return "# ERROR: Unsupported template type selected!" if template_type == "default": if self.settings and self.settings.default_template_type: template_type = self.settings.default_template_type else: template_type = "cheetah" if len(lines) > 0 and lines[0].find("#template=") == 0: # Pull the template type out of the first line and then drop it and rejoin them to pass to the template # language template_type = lines[0].split("=")[1].strip().lower() del lines[0] raw_data = "\n".join(lines) if template_type == "cheetah": data_out = self.render_cheetah(raw_data, search_table) elif template_type == "jinja2": if JINJA2_AVAILABLE: data_out = self.render_jinja2(raw_data, search_table) else: return "# ERROR: JINJA2 NOT AVAILABLE. Maybe you need to install python-jinja2?\n" else: return f"# ERROR: UNSUPPORTED TEMPLATE TYPE ({str(template_type)})" # Now apply some magic post-filtering that is used by "cobbler import" and some other places. Forcing folks to # double escape things would be very unwelcome. http_port = search_table.get("http_port", "80") server = search_table.get("server", self.settings.server) if http_port not in (80, "80"): repstr = f"{server}:{http_port}" else: repstr = server search_table["http_server"] = repstr # string replacements for @@xyz@@ in data_out with prior regex lookups of keys regex = r"@@[\S]*?@@" regex_matches = re.finditer(regex, data_out, re.MULTILINE) matches = { for _, match in enumerate(regex_matches, start=1)} for match in matches: data_out = data_out.replace(match, search_table[match.strip("@@")]) # remove leading newlines which apparently breaks AutoYAST ? if data_out.startswith("\n"): data_out = data_out.lstrip() # if requested, write the data out to a file if out_path is not None: filesystem_helpers.mkdir(os.path.dirname(out_path)) with open(out_path, "w", encoding="UTF-8") as file_descriptor: file_descriptor.write(data_out) return data_out
[docs] def render_cheetah(self, raw_data: str, search_table: Dict[Any, Any]) -> str: """ Render data_input back into a file. :param raw_data: Is the template code which is not rendered into the result. :param search_table: is a dict of metadata keys and values (though results are always returned) :return: The rendered Cheetah Template. :raises SyntaxError: Raised in case the NFS paths has an invalid syntax. :raises CX: Raised in case there was an error when templating. """ self.check_for_invalid_imports(raw_data) # Backward support for Cobbler's legacy (and slightly more readable) template syntax. raw_data = raw_data.replace("TEMPLATE::", "$") # HACK: the autoinstall_meta field may contain nfs://server:/mount in which case this is likely WRONG for # automated installation files, which needs the NFS directive instead. Do this to make the templates work. newdata = "" if "tree" in search_table and search_table["tree"].startswith("nfs://"): for line in raw_data.split("\n"): if line.find("--url") != -1 and line.find("url ") != -1: rest = search_table["tree"][6:] # strip off "nfs://" part try: (server, directory) = rest.split(":", 2) except Exception as error: raise SyntaxError( f"Invalid syntax for NFS path given during import: {search_table['tree']}" ) from error line = f"nfs --server {server} --dir {directory}" # But put the URL part back in so koan can still see what the original value was line += "\n" + f"#url --url={search_table['tree']}" newdata += line + "\n" raw_data = newdata # Tell Cheetah not to blow up if it can't find a symbol for something. raw_data = "#errorCatcher ListErrors\n" + raw_data table_copy = search_table.copy() # For various reasons we may want to call a module inside a template and pass it all of the template variables. # The variable "template_universe" serves this purpose to make it easier to iterate through all of the variables # without using internal Cheetah variables search_table.update({"template_universe": table_copy}) # Now do full templating scan, where we will also templatify the snippet insertions template = CobblerTemplate.compile( moduleName="cobbler.template_api", className="CobblerDynamicTemplate", source=raw_data, compilerSettings={"useStackFrame": False}, baseclass=CobblerTemplate, ) try: generated_template_class = template(searchList=[search_table]) # type: ignore data_out = str(generated_template_class) # type: ignore self.last_errors = generated_template_class.errorCatcher().listErrors() # type: ignore if self.last_errors: self.logger.warning("errors were encountered rendering the template") self.logger.warning("\n%s", pprint.pformat(self.last_errors)) # type: ignore except Exception as error: self.logger.error(utils.cheetah_exc(error)) raise CX( "Error templating file, check cobbler.log for more details" ) from error return data_out
[docs] def render_jinja2(self, raw_data: str, search_table: Dict[Any, Any]) -> str: """ Render data_input back into a file. :param raw_data: Is the template code which is not rendered into the result. :param search_table: is a dict of metadata keys and values :return: The rendered Jinja2 Template. """ try: if self.settings and self.settings.jinja2_includedir: template = jinja2.Environment( loader=jinja2.FileSystemLoader(self.settings.jinja2_includedir) ).from_string(raw_data) else: template = jinja2.Template(raw_data) data_out = template.render(search_table) except Exception as exc: self.logger.warning("errors were encountered rendering the template") self.logger.warning(str(exc)) data_out = "# EXCEPTION OCCURRED DURING JINJA2 TEMPLATE PROCESSING\n" return data_out