nyl 0.1.1__tar.gz → 0.2.0__tar.gz

{nyl-0.1.1 → nyl-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nyl
-Version: 0.1.1
+Version: 0.2.0
 Summary: Advanced templating engine for Kubernetes and GitOps.
 Author-email: Niklas Rosenstein <rosensteinniklas@gmail.com>
 License: MIT

{nyl-0.1.1 → nyl-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nyl"
-version = "0.1.1"  # sed'ed on publish in CI
+version = "0.2.0"  # sed'ed on publish in CI
 description = "Advanced templating engine for Kubernetes and GitOps."
 authors = [
     {name = "Niklas Rosenstein", email = "rosensteinniklas@gmail.com"},

{nyl-0.1.1 → nyl-0.2.0}/src/nyl/commands/__init__.py

@@ -29,12 +29,14 @@ from . import profile  # noqa: E402
 from . import run  # noqa: F401, E402
 from . import secrets  # noqa: E402
 from . import template  # noqa: F401,E402
+from . import tools  # noqa: E402
 from . import tun  # noqa: E402
 
 app.add_typer(argocd.app)
 app.add_typer(new.app)
 app.add_typer(profile.app)
 app.add_typer(secrets.app)
+app.add_typer(tools.app)
 app.add_typer(tun.app)
 
 

nyl-0.2.0/src/nyl/commands/secrets.py

@@ -0,0 +1,61 @@
+"""
+Interact with the secrets providers configured in `nyl-secrets.yaml`.
+"""
+
+import json
+
+from typer import Option
+from nyl.secrets.config import SecretsConfig
+from nyl.tools.typer import new_typer
+
+
+app = new_typer(name="secrets", help=__doc__)
+
+# Initialized from callback for access by subcommands.
+provider: str
+
+
+@app.callback()
+def callback(
+    _provider: str = Option(
+        "default",
+        "--provider",
+        help="The name of the configured secrets provider to use.",
+        envvar="NYL_SECRETS",
+    ),
+) -> None:
+    """
+    Interact with the secrets providers configured in `nyl-secrets.yaml`.
+    """
+
+    global provider
+    provider = _provider
+
+
+@app.command()
+def list(
+    providers: bool = Option(
+        False, help="List the configured secrets providers instead of the current provider's available keys."
+    ),
+) -> None:
+    """
+    List the keys for all secrets in the provider.
+    """
+
+    secrets = SecretsConfig.load()
+    if providers:
+        for alias, impl in secrets.providers.items():
+            print(alias, impl)
+    else:
+        for key in secrets.providers[provider].keys():
+            print(key)
+
+
+@app.command()
+def get(key: str, pretty: bool = False) -> None:
+    """
+    Get the value of a secret as JSON.
+    """
+
+    secrets = SecretsConfig.load()
+    print(json.dumps(secrets.providers[provider].get(key), indent=4 if pretty else None))

{nyl-0.1.1 → nyl-0.2.0}/src/nyl/commands/template.py

@@ -66,6 +66,18 @@ def template(
         "This option must be disabled when passing the generated manifests to `kubectl apply --applyset=...`, as it "
         "would otherwise cause an error due to the label being present on the input data.",
     ),
+    default_namespace: Optional[str] = Option(
+        None,
+        help="The name of the Kubernetes namespace to fill in to Kubernetes resource that don't have a namespace set. "
+        "If this is not specified as an argument or via environment variables, it will default to the stem of the "
+        "manifest source filename. Note that if a manifest defines a Namespace resource, that namespace is used "
+        "instead, regardless of the value of this option. If a manifest source file defines multiple namespaces and a "
+        "resource without namespace is encountered, this option is considered if it matches one of the namespaces "
+        "defined in the file. Note that this option is usually problematic when rendering multiple files, as often "
+        "a single file is intended to deploy into a single namespace.\n\n"
+        "Note that Nyl's detection for cluster-scoped vs. namespace-scoped resources is not very good, yet.",
+        envvar="ARGOCD_APP_NAMESPACE",
+    ),
     inline: bool = Option(True, help="Evaluate Nyl inlined resources."),
     state_dir: Optional[Path] = Option(
         None, help="The directory to store state in (such as kubeconfig files).", envvar="NYL_STATE_DIR"
@@ -168,10 +180,10 @@ def template(
             )
 
         # Find the namespaces that are defined in the file. If we find any manifests without a namespace, we will
-        # inject that namespace name into them.
-        # Also find the applyset defined in the file.
+        # inject that namespace name into them. Also find the applyset defined in the file.
         namespaces: set[str] = set()
         applyset: ApplySet | None = None
+
         for manifest in list(source.manifests):
             if is_namespace_resource(manifest):
                 namespaces.add(manifest["metadata"]["name"])
@@ -185,23 +197,40 @@ def template(
                 applyset = ApplySet.load(manifest)
                 source.manifests.remove(manifest)
 
+        # Determine what namespace to fill in if we encounter resources without it.
+        current_default_namespace = default_namespace
+        if current_default_namespace is None:
+            if len(namespaces) == 1:
+                current_default_namespace = next(iter(namespaces))
+            elif len(namespaces) == 0:
+                current_default_namespace = source.file.stem
+        elif len(namespaces) > 2 and current_default_namespace not in namespaces:
+            logger.error(
+                "The specified --default-namespace='{}' is not defined in manifest source file '{}', despite it "
+                "defining {} namespaces. If your manifest source file defines multiple namespaces, the specified "
+                "--default-namespace must be one of the namespaces defined in it (the file current defines "
+                "the following namespaces: {})",
+                default_namespace,
+                source.file,
+                len(namespaces),
+                ", ".join(namespaces),
+            )
+            exit(1)
+
         if not applyset and project.config.settings.generate_applysets:
-            if len(namespaces) > 1:
+            if not current_default_namespace:
                 logger.opt(ansi=True).error(
-                    "Multiple namespaces defined in <yellow>{}</>, but automatic ApplySet generation is enabled. "
-                    "There can only be one namespace per source in this case.",
+                    "No default namespace defined for <yellow>{}</>, but it is required for the automatically "
+                    "generated nyl.io/v1/ApplySet resource (the ApplySet is named after the default namespace).",
                     source.file,
                 )
                 exit(1)
-            elif len(namespaces) == 1:
-                applyset_name = next(iter(namespaces))
-            else:
-                applyset_name = source.file.stem
 
+            applyset_name = current_default_namespace
+            applyset = ApplySet.new(applyset_name)
             logger.opt(ansi=True).info(
                 "Automatically creating ApplySet for <blue>{}</> (name: <magenta>{}</>).", source.file, applyset_name
             )
-            applyset = ApplySet.new(applyset_name)
 
         if applyset is not None:
             applyset.set_group_kinds(source.manifests)
@@ -236,7 +265,7 @@ def template(
 
             if "metadata" not in manifest:
                 logger.opt(ansi=True).error(
-                    "Manifest in <yellow>'{}'</> has no <cyan>metadata</> key:\n\n{}",
+                    "A manifest in <yellow>'{}'</> has no <cyan>metadata</> key:\n\n{}",
                     source.file,
                     indent(yaml.safe_dump(manifest), "  "),
                 )
@@ -247,30 +276,23 @@ def template(
                     labels[APPLYSET_LABEL_PART_OF] = applyset.id
 
             if not is_cluster_scoped_resource(manifest) and "namespace" not in manifest["metadata"]:
-                if len(namespaces) > 1:
+                if not current_default_namespace:
                     logger.error(
-                        "Multiple namespaces defined in '{}', but manifest {}/{} does not have a namespace.",
+                        "A namespace-scoped manifest in '{}' has no namespace, and no default namespace is defined. "
+                        "Try defining a single namespace in the manifest source file, naming the manifest source file "
+                        "the same as that default namespace or passing the --default-namespace option.",
                         source.file,
-                        manifest["kind"],
-                        manifest["metadata"]["name"],
                     )
                     exit(1)
-                elif len(namespaces) == 0:
-                    logger.warning(
-                        "No namespaces defined in '{}', injecting 'default' into manifest {}/{}.",
-                        source.file,
-                        manifest["kind"],
-                        manifest["metadata"]["name"],
-                    )
-                    manifest["metadata"]["namespace"] = "default"
-                else:
-                    logger.trace(
-                        "Injecting namespace '{}' into manifest {}/{}.",
-                        next(iter(namespaces)),
-                        manifest["kind"],
-                        manifest["metadata"]["name"],
-                    )
-                    manifest["metadata"]["namespace"] = next(iter(namespaces))
+
+                logger.trace(
+                    "Injecting namespace '{}' into manifest {}/{}.",
+                    current_default_namespace,
+                    manifest["kind"],
+                    manifest["metadata"]["name"],
+                )
+                manifest["metadata"]["namespace"] = current_default_namespace
+
             elif not is_cluster_scoped_resource(manifest) and manifest["metadata"]["namespace"] not in namespaces:
                 logger.warning(
                     "Resource '{}/{}' in '{}' references namespace '{}', which is not defined in the file.",

nyl-0.2.0/src/nyl/commands/tools/__init__.py

@@ -0,0 +1,13 @@
+"""
+Swiss-army-knife for various common operations in conjunction with Nyl (Kubernetes, secrets management, etc).
+"""
+
+from nyl.tools.typer import new_typer
+
+
+app = new_typer(name="tools", help=__doc__)
+
+from . import sops  # noqa: E402
+from . import bcrypt  # noqa: F401,E402
+
+app.add_typer(sops.app)

nyl-0.2.0/src/nyl/commands/tools/bcrypt.py

@@ -0,0 +1,17 @@
+import sys
+from typing import Optional
+
+from bcrypt import gensalt, hashpw
+from . import app
+
+
+@app.command()
+def bcrypt(text: Optional[str] = None) -> None:
+    """
+    Bcrypt-hash the specified text. If no argument is specified, read from stdin.
+    """
+
+    if text is None:
+        text = sys.stdin.read()
+
+    print(hashpw(text.encode("utf-8"), gensalt()).decode("utf-8"))

nyl-0.1.1/src/nyl/commands/secrets.py → nyl-0.2.0/src/nyl/commands/tools/sops.py

@@ -1,8 +1,7 @@
 """
-Interact with the secrets providers configured in `nyl-secrets.yaml`.
+Utilities for SOPS files.
 """
 
-import json
 from pathlib import Path
 from shlex import quote
 import sys
@@ -17,60 +16,17 @@ from nyl.tools.logging import lazy_str
 from nyl.tools.typer import new_typer
 
 
-app = new_typer(name="secrets", help=__doc__)
-
-sops = new_typer(name="sops", help=__doc__)
-app.add_typer(sops)
-
-# Initialized from callback for access by subcommands.
-provider: str
-
-
-@app.callback()
-def callback(
-    _provider: str = Option(
-        "default", "--provider", help="The name of the configured secrets provider to use.", envvar="NYL_SECRETS"
-    ),
-) -> None:
-    """
-    Interact with the secrets providers configured in `nyl-secrets.yaml`.
-    """
-
-    global provider
-    provider = _provider
-
-
-@app.command()
-def list(
-    providers: bool = Option(
-        False, help="List the configured secrets providers instead of the current provider's available keys."
-    ),
-) -> None:
-    """
-    List the keys for all secrets in the provider.
-    """
-
-    secrets = SecretsConfig.load()
-    if providers:
-        for alias, impl in secrets.providers.items():
-            print(alias, impl)
-    else:
-        for key in secrets.providers[provider].keys():
-            print(key)
+app = new_typer(name="sops", help=__doc__)
 
 
 @app.command()
-def get(key: str, pretty: bool = False) -> None:
-    """
-    Get the value of a secret as JSON.
-    """
-
-    secrets = SecretsConfig.load()
-    print(json.dumps(secrets.providers[provider].get(key), indent=4 if pretty else None))
-
-
-@sops.command()
 def re_encrypt(
+    provider: str = Option(
+        "default",
+        "--provider",
+        help="The name of the configured secrets provider to use.",
+        envvar="NYL_SECRETS",
+    ),
     file: Optional[Path] = Option(
         None,
         help="The SOPS-file to re-encrypt. Defaults to the SOPS file mentioned in `nyl-secrets.yaml` "
@@ -110,7 +66,7 @@ def re_encrypt(
     sops.save(file_type)
 
 
-@sops.command()
+@app.command()
 def export_dotenv(
     file: Path,
     prefix: str = Option("", help="Only export keys with the given prefix, and strip the prefix."),

{nyl-0.1.1 → nyl-0.2.0}/src/nyl/resources/placeholder.py

@@ -51,6 +51,16 @@ class Placeholder(NylResource, api_version=API_VERSION_K8S):
                             "properties": {
                                 "spec": {
                                     "type": "object",
+                                    "properties": {
+                                        "message": {
+                                            "type": "string",
+                                            "description": "A message that describes the missing resource.",
+                                        },
+                                        "reason": {
+                                            "type": "string",
+                                            "description": "The reason why the resource is missing (e.g. 'NotFound').",
+                                        },
+                                    },
                                 },
                             },
                         }

{nyl-0.1.1 → nyl-0.2.0}/src/nyl/templating.py

@@ -93,6 +93,12 @@ def lookup(api_version: str, kind: str, name: str, namespace: str) -> Any:
     return obj
 
 
+class LookupError(Exception):
+    """
+    Raised when a `lookup()` call fails because the resource was not found.
+    """
+
+
 @dataclass
 class NylTemplateEngine:
     """