sovereign 1.0.0b125__py3-none-any.whl → 1.0.0b127__py3-none-any.whl

sovereign/rendering.py

@@ -7,6 +7,8 @@ Functions used to render and return discovery responses to Envoy proxies.
 The templates are configurable. `todo See ref:Configuration#Templates`
 """
 
+import threading
+from multiprocessing import Process, Semaphore, cpu_count
 from typing import Any, Dict, List
 
 import yaml
@@ -27,6 +29,8 @@ from sovereign.schemas import (
     ProcessedTemplate,
 )
 
+# limit render jobs to number of cores
+RENDER_SEMAPHORE = Semaphore(cpu_count())
 
 type_urls = {
     "v2": {
@@ -54,39 +58,52 @@ class RenderJob(pydantic.BaseModel):
     request: DiscoveryRequest
     context: dict[str, Any]
 
+    def spawn(self):
+        t = threading.Thread(target=self._run)
+        t.start()
+
+    def _run(self):
+        with RENDER_SEMAPHORE:
+            proc = Process(target=generate, args=[self])
+            proc.start()
+            proc.join()
+
 
 def generate(job: RenderJob) -> None:
     request = job.request
     tags = [f"type:{request.resource_type}"]
-    stats.increment("template.render", tags=tags)
-    with stats.timed("template.render_ms", tags=tags):
-        content = request.template(
-            discovery_request=request,
-            host_header=request.desired_controlplane,
-            resource_names=request.resources,
-            **job.context,
-        )
-        if not request.template.is_python_source:
-            assert isinstance(content, str)
-            content = deserialize_config(content)
-        assert isinstance(content, dict)
-        resources = filter_resources(content["resources"], request.resources)
-        add_type_urls(request.api_version, request.resource_type, resources)
-        response = ProcessedTemplate(resources=resources)
-        cache.write(
-            job.id,
-            cache.Entry(
-                text=response.model_dump_json(indent=None),
-                len=len(response.resources),
-                version=response.version_info,
-                node=request.node,
-            ),
-        )
-
-
-def batch_generate(jobs: list[RenderJob]) -> None:
-    for job in jobs:
-        generate(job)
+    try:
+        with stats.timed("template.render_ms", tags=tags):
+            content = request.template(
+                discovery_request=request,
+                host_header=request.desired_controlplane,
+                resource_names=request.resources,
+                **job.context,
+            )
+            if not request.template.is_python_source:
+                assert isinstance(content, str)
+                content = deserialize_config(content)
+            assert isinstance(content, dict)
+            resources = filter_resources(content["resources"], request.resources)
+            add_type_urls(request.api_version, request.resource_type, resources)
+            response = ProcessedTemplate(resources=resources)
+            cache.write(
+                job.id,
+                cache.Entry(
+                    text=response.model_dump_json(indent=None),
+                    len=len(response.resources),
+                    version=response.version_info,
+                    node=request.node,
+                ),
+            )
+        tags.append("result:ok")
+    except Exception as e:
+        tags.append("result:err")
+        tags.append(f"error:{e.__class__.__name__.lower()}")
+        if SENTRY_INSTALLED and config.sentry_dsn:
+            sentry_sdk.capture_exception(e)
+    finally:
+        stats.increment("template.render", tags=tags)
 
 
 def deserialize_config(content: str) -> Dict[str, Any]:

sovereign/static/darkmode.js

@@ -0,0 +1,51 @@
+document.addEventListener('DOMContentLoaded', function() {
+    const darkmode = "theme-dark";
+    const lightmode = "theme-light";
+    const toggle = document.getElementById('dark-mode-toggle');
+    const htmlTag = document.documentElement;
+
+    function preferredTheme() {
+        const preference = localStorage.getItem("theme");
+        if (preference) {
+            return preference;
+        }
+        if (window.matchMedia("(prefers-color-scheme: dark)").matches) {
+            return "dark";
+        } else {
+            return "light";
+        };
+    }
+
+    function currentTheme() {
+        if (htmlTag.classList.contains(darkmode)) {
+            return "dark"
+        } else {
+            return "light"
+        }
+    }
+
+    function setTheme(theme) {
+        localStorage.setItem("theme", theme);
+        if (theme === "dark") {
+            htmlTag.classList.remove(lightmode);
+            htmlTag.classList.add(darkmode);
+            toggle.textContent = '🌘';
+        } else {
+            htmlTag.classList.remove(darkmode);
+            htmlTag.classList.add(lightmode);
+            toggle.textContent = '🌞';
+        }
+    }
+
+    setTheme(preferredTheme());
+
+    toggle.addEventListener("click", function() {
+        let current = currentTheme();
+        console.log("Current theme: " + current);
+        if (current === "dark") {
+            setTheme("light");
+        } else {
+            setTheme("dark");
+        }
+    });
+});

sovereign/static/node_expression.js

@@ -1,6 +1,15 @@
 const input = document.getElementById('filterInput');
+const inputMessage = document.getElementById('filterMessage');
 const form = document.getElementById('filterForm');
 
+function validateInput(inputString) {
+  if (!inputString || inputString.trim() === '') {
+    return "empty";
+  }
+  const validationRegex = /^(?:(?:id|cluster|metadata\.[\w\.\=\-]+|locality\.?(?:zone|sub_zone|region))=[a-zA-Z0-9_-]+ ?)*$/;
+  return validationRegex.test(inputString);
+}
+
 window.addEventListener('DOMContentLoaded', () => {
   const match = document.cookie.match(/(?:^|; )node_expression=([^;]*)/);
   if (match) {
@@ -8,6 +17,23 @@ window.addEventListener('DOMContentLoaded', () => {
   }
 });
 
+input.addEventListener('input', (event) => {
+  const result = validateInput(event.target.value);
+  if (result === "empty") {
+    input.className = "input is-dark";
+    inputMessage.className = "help is-dark";
+    inputMessage.innerHTML = "";
+  } else if (result === true) {
+    input.className = "input is-success";
+    inputMessage.className = "help is-success";
+    inputMessage.innerHTML = "Press enter to apply filter expression";
+  } else {
+    input.className = "input is-danger";
+    inputMessage.className = "help is-danger";
+    inputMessage.innerHTML = "The node filter expression may have no effect, or be invalid";
+  }
+});
+
 form.addEventListener('submit', (event) => {
   event.preventDefault();
   const value = input.value.trim();

sovereign/static/resources.css

@@ -0,0 +1,246 @@
+/* Resources page styles */
+#filterInput {
+    font-family: monospace;
+}
+
+.filtered {
+    display: none;
+}
+
+.tooltip {
+    position: relative;
+    display: inline-block;
+    cursor: help;
+}
+
+.tooltip .tooltip-text {
+    visibility: hidden;
+    width: 220px;
+    background-color: #363636;
+    color: #fff;
+    text-align: left;
+    padding: 0.5rem;
+    border-radius: 6px;
+    position: absolute;
+    z-index: 1;
+    top: 125%;
+    left: 50%;
+    margin-left: -110px;
+    opacity: 0;
+    transition: opacity 0.3s;
+    font-size: 0.875rem;
+}
+
+.tooltip:hover .tooltip-text {
+    visibility: visible;
+    opacity: 1;
+}
+
+/* Side panel styles - using Bulma-compatible approach */
+.side-panel {
+    position: fixed;
+    top: 0;
+    right: -100%;
+    width: 95%;
+    max-width: 1200px;
+    min-width: 400px;
+    height: 100vh;
+    z-index: 1000;
+    transition: right 0.3s ease-in-out;
+    overflow-y: auto;
+}
+
+.side-panel.is-active {
+    right: 0;
+}
+
+/* Responsive side panel sizing */
+@media (min-width: 768px) {
+    .side-panel { width: 75%; right: -75%; }
+}
+
+@media (min-width: 1024px) {
+    .side-panel { width: 65%; right: -65%; }
+}
+
+@media (min-width: 1400px) {
+    .side-panel { width: 55%; right: -55%; }
+}
+
+@media (min-width: 1600px) {
+    .side-panel { width: 50%; right: -50%; }
+}
+
+@media (max-width: 480px) {
+    .side-panel { width: 95%; min-width: 300px; right: -95%; }
+}
+
+.json-container {
+    position: relative;
+}
+
+.json-header {
+    padding: 1rem;
+    border-bottom: 1px solid #555;
+    background-color: #2d2d2d;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.json-content {
+    background-color: #1e1e1e;
+    border: none;
+    border-radius: 0;
+    padding: 1rem;
+    font-family: 'JetBrains Mono', 'Fira Code', 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', 'Source Code Pro', 'Menlo', 'Consolas', monospace;
+    font-size: 0.875rem;
+    line-height: 1.5;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    max-height: calc(100vh - 250px);
+    overflow-y: auto;
+    color: #d4d4d4;
+    margin: 0;
+}
+
+/* JSON Syntax Highlighting - VS Code Dark+ theme colors */
+.json-key {
+    color: #9cdcfe;
+    font-weight: 400;
+}
+
+.json-string {
+    color: #ce9178;
+}
+
+.json-number {
+    color: #b5cea8;
+}
+
+.json-boolean {
+    color: #569cd6;
+    font-weight: 500;
+}
+
+.json-null {
+    color: #569cd6;
+    font-weight: 500;
+    font-style: italic;
+}
+
+.json-punctuation {
+    color: #d4d4d4;
+}
+
+/* Improve readability */
+.json-content::-webkit-scrollbar {
+    width: 8px;
+}
+
+.json-content::-webkit-scrollbar-track {
+    background: #2d2d2d;
+}
+
+.json-content::-webkit-scrollbar-thumb {
+    background: #555;
+    border-radius: 4px;
+}
+
+.json-content::-webkit-scrollbar-thumb:hover {
+    background: #666;
+}
+
+/* Collapsible JSON */
+.json-toggle {
+    cursor: pointer;
+    user-select: none;
+    color: #808080;
+    margin-right: 0.25rem;
+    font-family: monospace;
+    font-size: 0.875rem;
+}
+
+.json-toggle:hover {
+    color: #fff;
+}
+
+.json-collapsible {
+    margin-left: 1rem;
+}
+
+.json-collapsed {
+    display: none;
+}
+
+.loading-spinner {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 3px solid #f3f3f3;
+    border-top: 3px solid #433fca;
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Prevent body scroll when side panel is open */
+body.side-panel-open {
+    overflow: hidden;
+}
+
+/* Backdrop overlay for side panel */
+.side-panel-backdrop {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: rgba(0, 0, 0, 0.5);
+    z-index: 999;
+    opacity: 0;
+    visibility: hidden;
+    transition: opacity 0.3s ease-in-out, visibility 0.3s ease-in-out;
+}
+
+.side-panel-backdrop.is-active {
+    opacity: 1;
+    visibility: visible;
+}
+
+/* Show backdrop on smaller screens */
+@media (max-width: 1024px) {
+    .side-panel-backdrop.is-active {
+        opacity: 1;
+        visibility: visible;
+    }
+}
+
+/* Minimal custom styles - using Bulma classes for most styling */
+.json-chunk-controls {
+    background-color: #2d2d2d;
+    border-bottom: 1px solid #555;
+}
+
+/* Preferences details styling */
+details summary {
+    list-style: none;
+}
+
+details summary::-webkit-details-marker {
+    display: none;
+}
+
+details summary::before {
+    content: "▶";
+    margin-right: 0.5rem;
+    transition: transform 0.2s;
+}
+
+details[open] summary::before {
+    transform: rotate(90deg);
+}