@mashroom/mashroom-remote-package-scanner-kubernetes 3.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) nonblocking.at gmbh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,137 @@
+
+# Mashroom Remote Package Scanner Kubernetes
+
+Plugin for [Mashroom Server](https://www.mashroom-server.com), a **Microfrontend Integration Platform**.
+
+This plugin scans for remote plugin packages in a Kubernetes cluster.
+It *watches* Kubernetes namespaces and services with given labels which will be checked for plugins.
+
+It also watches Pods for new image versions and removes plugin packages if no running Pod can be found.
+
+> [!IMPORTANT]
+> A remote plugin package **must** expose a definition file, typically */mashroom.json*.
+> You can use a *mashroom-server.com/remote-plugins-definition-path* annotation on the K8S service to tell Mashroom where to find it.
+
+Currently, only the following plugin types are known to be supported:
+
+* portal-app
+* portal-app2
+* portal-layouts
+* portal-page-enhancement (only if no bootstrap is defined)
+
+## Usage
+
+If *node_modules/@mashroom* is configured as a plugin path, add **@mashroom/mashroom-remote-package-scanner-kubernetes** as *dependency*.
+
+You can override the default config in your Mashroom server config like this:
+
+```json
+{
+  "plugins": {
+      "Mashroom Remote Package Scanner Kubernetes": {
+          "k8sNamespacesLabelSelector": ["microfrontends=true"],
+          "k8sNamespaces": null,
+          "k8sServiceLabelSelector": ["microfrontends=true"],
+          "serviceNameFilter": ".*"
+        }
+    }
+}
+```
+
+* _k8sNamespacesLabelSelector_: Label selector(s) for namespaces, can be a single string or an array, can also be null (Default: microfrontends=true)
+* _k8sNamespaces_: A distinct list of Kubernetes namespaces to check, can be null if _k8sNamespacesLabelSelector_ is set (Default: null)
+* _k8sServiceLabelSelector_: Label selector(s) for services, can be a single string or an array, can be null (Default: microfrontends=true)
+* _serviceNameFilter_: A regular expression for services that should be checked (case-insensitive). (Default: ".*")
+
+**A more complex example**
+
+Select all services with the label *microfrontend=true* and not label *channel=alpha* in all namespaces with label *environment=development* and *tier=frontend*:
+
+```json
+{
+  "plugins": {
+      "Mashroom Portal Remote App Kubernetes Background Job": {
+          "k8sNamespacesLabelSelector": ["environment=development,tier=frontend"],
+          "k8sServiceLabelSelector": ["microfrontend=true,channel!=alpha"]
+        }
+    }
+}
+```
+
+## Annotations
+
+You can use annotations on Kubernetes services to help Mashroom to understand the setup:
+
+| Annotation                                         | Description                                                                                                                                                           | Default                        |
+|----------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------|
+| mashroom-server.com/remote-plugins-definition-path | The path of the plugins definition                                                                                                                                    | /mashroom.json, /mashroom.yaml |
+| open-microfrontends.org/microfrontends             | The server actually contains OpenMicrofrontend compliant Apps, requires [mashroom-portal-open-microfrontends-support](../mashroom-portal-open-microfrontends-support) |                                |
+| open-microfrontends.org/description-path           | The path of the OpenMicrofrontends description                                                                                                                        | /microfrontends.yaml           |
+
+## Setup Kubernetes access
+
+This plugin uses the Kubernetes API and requires the following permissions:
+
+ * **watch** for namespaces cluster-wide
+ * **watch** for services in all namespaces with plugins (or cluster-wide)
+ * **watch** for pods in all namespaces with plugins (or cluster-wide)
+
+To allow this plugin to use the Kubernetes API you need to attach a Kubernetes **Service Account** with the correct permissions to the deployment.
+
+Here is a possible setup with cluster-wide permissions:
+
+```yaml
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: list-namespaces-services-cluster-role
+rules:
+  - apiGroups:
+      - ""
+    resources:
+      - services
+      - pods
+      - namespaces
+    verbs:
+      - watch
+```
+
+```yaml
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: mashroom-portal
+  namespace: default
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: mashroom-portal-role-binding
+subjects:
+  - kind: ServiceAccount
+    name: mashroom-portal
+    namespace: default
+roleRef:
+  kind: ClusterRole
+  name: list-namespaces-services-cluster-role
+  apiGroup: rbac.authorization.k8s.io
+```
+
+And in your deployment resource state the Service Account name:
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+    name: mashroom-portal
+    namespace: default
+spec:
+    # ...
+    template:
+        # ...
+        spec:
+            containers:
+                - name: mashroom-portal
+                # ...
+            serviceAccountName: mashroom-portal
+```

package/dist/context.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+let _namespaceLabelSelector = null;
+let _serviceLabelSelector = null;
+let _serviceNameFilter = '';
+let _watchedNamespaces = [];
+let _services = [];
+let _runningPods = [];
+let _errors = [];
+let _scannerCallback = null;
+let _initialScanDone = false;
+const context = {
+  get namespaceLabelSelector() {
+    return _namespaceLabelSelector;
+  },
+  set namespaceLabelSelector(namespaceLabelSelector) {
+    _namespaceLabelSelector = namespaceLabelSelector;
+  },
+  get serviceLabelSelector() {
+    return _serviceLabelSelector;
+  },
+  set serviceLabelSelector(serviceLabelSelector) {
+    _serviceLabelSelector = serviceLabelSelector;
+  },
+  get serviceNameFilter() {
+    return _serviceNameFilter;
+  },
+  set serviceNameFilter(serviceNameFilter) {
+    _serviceNameFilter = serviceNameFilter;
+  },
+  get watchedNamespaces() {
+    return _watchedNamespaces;
+  },
+  set watchedNamespaces(watchedNamespaces) {
+    _watchedNamespaces = watchedNamespaces;
+  },
+  get services() {
+    return _services;
+  },
+  set services(services) {
+    _services = services;
+  },
+  get runningPods() {
+    return _runningPods;
+  },
+  set runningPods(pods) {
+    _runningPods = pods;
+  },
+  get errors() {
+    return _errors;
+  },
+  set errors(errors) {
+    _errors = errors;
+  },
+  get scannerCallback() {
+    return _scannerCallback;
+  },
+  set scannerCallback(scannerCallback) {
+    _scannerCallback = scannerCallback;
+  },
+  get initialScanDone() {
+    return _initialScanDone;
+  },
+  set initialScanDone(done) {
+    _initialScanDone = done;
+  }
+};
+var _default = exports.default = context;

package/dist/health/health-probe.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _context = _interopRequireDefault(require("../context"));
+var _KubernetesRemotePluginPackagesScanner = require("../scanner/KubernetesRemotePluginPackagesScanner");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+let oneFullScanDone = false;
+var _default = pluginContextHolder => ({
+  async check() {
+    if (!oneFullScanDone) {
+      const pluginContext = pluginContextHolder.getPluginContext();
+      const logger = pluginContext.loggerFactory('mashroom.scanner.remotePackageKubernetes');
+      const pluginService = pluginContext.services.core.pluginService;
+      const services = _context.default.services;
+      const pluginPackages = pluginService.getPotentialPluginPackagesByScanner(_KubernetesRemotePluginPackagesScanner.SCANNER_NAME);
+      let done = true;
+      if (!_context.default.initialScanDone) {
+        done = false;
+      } else {
+        for (const service of services) {
+          const pluginPackage = pluginPackages.find(p => service.url && p.url.toString() === service.url.toString());
+          if (pluginPackage) {
+            if (!pluginPackage.processedOnce) {
+              done = false;
+              break;
+            }
+          } else {
+            logger.warn(`Found no registered plugin package for Kubernetes service: ${service.url}`);
+          }
+        }
+      }
+      if (done) {
+        oneFullScanDone = true;
+        return {
+          ready: true
+        };
+      }
+      return {
+        ready: false,
+        error: 'Initial Kubernetes plugin packages scan in progress'
+      };
+    }
+    return {
+      ready: true
+    };
+  }
+});
+exports.default = _default;

package/dist/k8s/DummyKubernetesConnector.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class KubernetesConnector {
+  async watchNamespaces(labelSelector, cb) {
+    if (labelSelector === 'environment=development') {
+      cb('ADDED', {
+        metadata: {
+          name: 'dev-namespace1',
+          labels: {
+            environment: 'development'
+          }
+        }
+      });
+      cb('ADDED', {
+        metadata: {
+          name: 'dev-namespace2',
+          labels: {
+            environment: 'development'
+          }
+        }
+      });
+    } else if (labelSelector === 'environment=development2') {
+      cb('ADDED', {
+        metadata: {
+          name: 'dev-namespace3',
+          labels: {
+            environment: 'dev2'
+          }
+        }
+      });
+    }
+    cb('ADDED', {
+      metadata: {
+        name: 'whata-namespace'
+      }
+    });
+    return new AbortController();
+  }
+  async watchServices(namespace, labelSelector, cb) {
+    if (namespace === 'dev-namespace1') {
+      throw new Error('Permission denied');
+    } else if (namespace === 'dev-namespace2' || labelSelector === 'environment=dev') {
+      cb('ADDED', {
+        metadata: {
+          name: 'my-remote-app',
+          namespace: 'dev-namespace2'
+        },
+        spec: {
+          clusterIP: '127.0.0.1',
+          ports: [{
+            port: 6066
+          }]
+        }
+      });
+    } else if (namespace === 'dev-namespace3') {
+      cb('ADDED', {
+        metadata: {
+          name: 'my-remote-app',
+          namespace: 'dev-namespace3'
+        },
+        spec: {
+          clusterIP: '127.0.0.1',
+          ports: [{
+            port: 6066
+          }]
+        }
+      });
+    }
+    cb('ADDED', {
+      metadata: {
+        name: 'mashroom-demo-remote-portal-app',
+        namespace: 'default'
+      },
+      spec: {
+        clusterIP: '127.0.0.1',
+        ports: [{
+          port: 6088
+        }]
+      }
+    });
+    cb('ADDED', {
+      metadata: {
+        name: 'unreachable-service',
+        namespace: 'default'
+      },
+      spec: {
+        clusterIP: '1.2.3.4',
+        ports: [{
+          port: 8080
+        }]
+      }
+    });
+    cb('ADDED', {
+      metadata: {
+        name: 'headless-service',
+        namespace: 'default'
+      },
+      spec: {
+        ports: [{
+          port: 8080
+        }]
+      }
+    });
+    return new AbortController();
+  }
+  async watchPods(namespace, cb) {
+    return new AbortController();
+  }
+}
+exports.default = KubernetesConnector;

package/dist/k8s/KubernetesConnector.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _WatchWithReconnect = _interopRequireDefault(require("./WatchWithReconnect"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class KubernetesConnector {
+  constructor(localConfig, loggerFactory) {
+    this.localConfig = localConfig;
+    this._logger = loggerFactory('mashroom.scanner.remotePackageKubernetes');
+  }
+  async watchNamespaces(labelSelector, cb) {
+    if (!this._watch) {
+      await this.#init();
+    }
+    return this._watch.watch('/api/v1/namespaces', {
+      labelSelector
+    }, cb);
+  }
+  async watchServices(namespace, labelSelector, cb) {
+    if (!this._watch) {
+      await this.#init();
+    }
+    return this._watch.watch(`/api/v1/namespaces/${namespace}/services`, {
+      labelSelector
+    }, cb);
+  }
+  async watchPods(namespace, cb) {
+    if (!this._watch) {
+      await this.#init();
+    }
+    return this._watch.watch(`/api/v1/namespaces/${namespace}/pods`, {}, cb);
+  }
+  async #init() {
+    // '@kubernetes/client-node' is an ESM only module
+    const {
+      KubeConfig
+    } = await import('@kubernetes/client-node');
+    const k8sClient = new KubeConfig();
+    if (!this.localConfig) {
+      // This only works if the Portal runs within a Kubernetes Pod with a valid service account attached
+      k8sClient.loadFromCluster();
+    } else {
+      // This uses the local kubectl config (only for test purposes!)
+      k8sClient.loadFromDefault();
+    }
+    this._watch = new _WatchWithReconnect.default(k8sClient, this._logger);
+  }
+}
+exports.default = KubernetesConnector;

package/dist/k8s/WatchWithReconnect.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _clientNode = require("@kubernetes/client-node");
+class WatchWithReconnect {
+  #watch;
+  constructor(k8sClient, logger) {
+    this.logger = logger;
+    this.#watch = new _clientNode.Watch(k8sClient);
+  }
+  async watch(path, queryParams, cb) {
+    let aborted = false;
+    let controller;
+    const startWatcher = async () => {
+      this.logger.info('Adding K8S watcher for path: ', path);
+      controller = await this.#watch.watch(path, queryParams, (phase, apiObj) => {
+        cb(phase, apiObj);
+      }, error => {
+        if (!error) {
+          this.logger.info(`K8S Watcher on ${path} lost connection`);
+        } else {
+          this.logger.error(`K8S Watcher error on ${path}:`, error);
+        }
+        if (!aborted) {
+          this.logger.info(`Reconnecting K8S Watcher on ${path}...`);
+          setTimeout(() => {
+            startWatcher();
+          }, 1000);
+        }
+      });
+    };
+    await startWatcher();
+    return {
+      abort() {
+        aborted = true;
+        if (controller) {
+          controller.abort();
+        }
+      }
+    };
+  }
+}
+exports.default = WatchWithReconnect;

package/dist/metrics/metrics.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unregisterKubernetesRemotePluginPackagesMetrics = exports.registerKubernetesRemotePluginPackagesMetrics = void 0;
+var _context = _interopRequireDefault(require("../context"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+let callbackRef;
+const registerKubernetesRemotePluginPackagesMetrics = pluginContextHolder => {
+  const register = async () => {
+    const pluginContext = pluginContextHolder.getPluginContext();
+    const collectorService = pluginContext.services.metrics?.service;
+    if (collectorService) {
+      callbackRef = await collectorService.addObservableCallback(asyncCollectorService => {
+        const services = _context.default.services;
+        const servicesTotal = services.length;
+        asyncCollectorService.gauge('mashroom_k8s_remote_plugin_packages_total', 'Mashroom Kubernetes Remote Plugin Packages Total').set(servicesTotal);
+      });
+    }
+  };
+  // Wait a few seconds until collectorService is available
+  setTimeout(register, 5000);
+};
+exports.registerKubernetesRemotePluginPackagesMetrics = registerKubernetesRemotePluginPackagesMetrics;
+const unregisterKubernetesRemotePluginPackagesMetrics = () => {
+  if (callbackRef) {
+    callbackRef.removeCallback();
+    callbackRef = undefined;
+  }
+};
+exports.unregisterKubernetesRemotePluginPackagesMetrics = unregisterKubernetesRemotePluginPackagesMetrics;

package/dist/scanner/KubernetesRemotePluginPackagesScanner.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SCANNER_NAME = void 0;
+var _context = _interopRequireDefault(require("../context"));
+var _serviceEventCallback = _interopRequireDefault(require("./serviceEventCallback"));
+var _podEventCallback = _interopRequireDefault(require("./podEventCallback"));
+var _removePluginPackageService = _interopRequireDefault(require("./removePluginPackageService"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const SCANNER_NAME = exports.SCANNER_NAME = 'Kubernetes Remote Portal Apps Plugin Scanner';
+class KubernetesRemotePluginPackagesScanner {
+  _namespaceWatchers = [];
+  constructor(_namespaceLabelSelector, _namespaces, _serviceLabelSelector, serviceNameFilterStr, _kubernetesConnector, loggerFactory) {
+    this._namespaceLabelSelector = _namespaceLabelSelector;
+    this._namespaces = _namespaces;
+    this._serviceLabelSelector = _serviceLabelSelector;
+    this._kubernetesConnector = _kubernetesConnector;
+    this._serviceNameFilter = new RegExp(serviceNameFilterStr || '.*', 'i');
+    this._logger = loggerFactory('mashroom.scanner.remotePackageKubernetes');
+  }
+  get name() {
+    return SCANNER_NAME;
+  }
+  setCallback(callback) {
+    _context.default.scannerCallback = callback;
+  }
+  async start() {
+    if (Array.isArray(this._namespaces)) {
+      this._namespaces.forEach(ns => {
+        this._startWatchNamespace(ns);
+      });
+    }
+    if (this._namespaceLabelSelector) {
+      const labelSelectors = Array.isArray(this._namespaceLabelSelector) ? this._namespaceLabelSelector : [this._namespaceLabelSelector];
+      for (const labelSelector of labelSelectors) {
+        try {
+          const abortController = await this._kubernetesConnector.watchNamespaces(labelSelector, this._namespaceEventCallback.bind(this));
+          this._namespaceWatchers.push(abortController);
+        } catch (e) {
+          this._logger.error(`Watching Kubernetes Namespace with labelSelector ${labelSelector} failed!`, e);
+        }
+      }
+    }
+
+    // Wait a few seconds until the initial services are added
+    setTimeout(() => {
+      _context.default.initialScanDone = true;
+    }, 3000);
+  }
+  async stop() {
+    // Abort all watches
+    for (const namespaceWatcher of this._namespaceWatchers) {
+      namespaceWatcher.abort();
+    }
+    for (const watchedNamespace of _context.default.watchedNamespaces) {
+      for (const watcher of watchedNamespace.servicesWatchers) {
+        watcher.abort();
+      }
+      for (const watcher of watchedNamespace.podsWatchers) {
+        watcher.abort();
+      }
+    }
+  }
+  async _startWatchNamespace(namespace) {
+    const existing = _context.default.watchedNamespaces.find(wn => wn.name === namespace);
+    if (existing) {
+      this._logger.debug(`Kubernetes Namespace ${namespace} already watched`);
+      return;
+    }
+    this._logger.info(`Start watching Kubernetes Services and Pods in Namespace: ${namespace}`);
+    const servicesWatchers = [];
+    const podsWatchers = [];
+    _context.default.watchedNamespaces.push({
+      name: namespace,
+      servicesWatchers,
+      podsWatchers
+    });
+    let serviceLabelSelectors = [undefined];
+    if (this._serviceLabelSelector) {
+      serviceLabelSelectors = Array.isArray(this._serviceLabelSelector) ? this._serviceLabelSelector : [this._serviceLabelSelector];
+    }
+    for (const serviceLabelSelector of serviceLabelSelectors) {
+      try {
+        servicesWatchers.push(await this._kubernetesConnector.watchServices(namespace, serviceLabelSelector, (0, _serviceEventCallback.default)(this._serviceNameFilter, this._logger)));
+      } catch (e) {
+        this._logger.error(`Watching Kubernetes Services in Namespace ${namespace} with labelSelector ${serviceLabelSelector} failed!`, e);
+      }
+    }
+    try {
+      podsWatchers.push(await this._kubernetesConnector.watchPods(namespace, (0, _podEventCallback.default)(this._logger)));
+    } catch (e) {
+      this._logger.error(`Watching Kubernetes Pods in Namespace ${namespace} failed!`, e);
+    }
+  }
+  _stopWatchNamespace(namespace) {
+    const existing = _context.default.watchedNamespaces.find(wn => wn.name === namespace);
+    if (!existing) {
+      return;
+    }
+    this._logger.info(`Stop watching and removing all remote plugin packages in Kubernetes Namespace: ${namespace}`);
+    for (const watcher of existing.servicesWatchers) {
+      watcher.abort();
+    }
+    for (const watcher of existing.podsWatchers) {
+      watcher.abort();
+    }
+    _context.default.watchedNamespaces = _context.default.watchedNamespaces.filter(wn => wn !== existing);
+    _context.default.runningPods = _context.default.runningPods.filter(pod => pod.namespace !== namespace);
+    const servicesInNamespace = _context.default.services.filter(service => service.namespace === namespace);
+    for (const sin of servicesInNamespace) {
+      (0, _removePluginPackageService.default)(sin, this._logger);
+    }
+  }
+  _namespaceEventCallback(event, namespace) {
+    if (!namespace.metadata?.name) {
+      return;
+    }
+    if (event === 'ADDED') {
+      this._startWatchNamespace(namespace.metadata.name);
+    } else if (event === 'DELETED') {
+      this._stopWatchNamespace(namespace.metadata.name);
+    }
+  }
+}
+exports.default = KubernetesRemotePluginPackagesScanner;

package/dist/scanner/mashroom-bootstrap-plugin-package-scanner.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _metrics = require("../metrics/metrics");
+var _healthProbe = _interopRequireDefault(require("../health/health-probe"));
+var _DummyKubernetesConnector = _interopRequireDefault(require("../k8s/DummyKubernetesConnector"));
+var _KubernetesConnector = _interopRequireDefault(require("../k8s/KubernetesConnector"));
+var _context = _interopRequireDefault(require("../context"));
+var _KubernetesRemotePluginPackagesScanner = _interopRequireDefault(require("./KubernetesRemotePluginPackagesScanner"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const bootstrap = async (pluginName, pluginConfig, pluginContextHolder) => {
+  const {
+    services: {
+      core: {
+        pluginService,
+        healthProbeService
+      }
+    },
+    loggerFactory
+  } = pluginContextHolder.getPluginContext();
+  const {
+    namespaceLabelSelector,
+    namespaces,
+    serviceLabelSelector,
+    serviceNameFilter
+  } = pluginConfig;
+  _context.default.namespaceLabelSelector = namespaceLabelSelector;
+  _context.default.serviceLabelSelector = serviceLabelSelector;
+  _context.default.serviceNameFilter = serviceNameFilter;
+  healthProbeService.registerProbe(pluginName, (0, _healthProbe.default)(pluginContextHolder));
+  (0, _metrics.registerKubernetesRemotePluginPackagesMetrics)(pluginContextHolder);
+  pluginService.onUnloadOnce(pluginName, () => {
+    healthProbeService.unregisterProbe(pluginName);
+    (0, _metrics.unregisterKubernetesRemotePluginPackagesMetrics)();
+  });
+  const kubernetesConnector = process.env.K8S_CONNECTOR_DUMMY ? new _DummyKubernetesConnector.default() : process.env.K8S_CONNECTOR_LOCAL_CONFIG ? new _KubernetesConnector.default(true, loggerFactory) : new _KubernetesConnector.default(false, loggerFactory);
+  return new _KubernetesRemotePluginPackagesScanner.default(namespaceLabelSelector, namespaces, serviceLabelSelector, serviceNameFilter, kubernetesConnector, loggerFactory);
+};
+var _default = exports.default = bootstrap;

package/dist/scanner/podEventCallback.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _context = _interopRequireDefault(require("../context"));
+var _updatePluginPackageService = _interopRequireDefault(require("./updatePluginPackageService"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = logger => (event, pod) => {
+  if (!pod.metadata || !pod.metadata.uid) {
+    return;
+  }
+
+  // IMPORTANT: we consider only Pods which are running and where all containers are ready
+  if (pod.status?.phase !== 'Running' || pod.status?.containerStatuses?.find(cs => !cs.ready)) {
+    event = 'DELETED';
+  }
+  if (event === 'ADDED' || event === 'MODIFIED') {
+    logger.debug(`Kubernetes Pod added or modified: ${pod.metadata.name}, namespace: ${pod.metadata.namespace}`);
+    let kubernetesPod = _context.default.runningPods.find(existingPod => existingPod.uid === pod.metadata?.uid);
+    if (!kubernetesPod) {
+      const containers = [];
+      if (pod.spec?.containers) {
+        pod.spec.containers.forEach(container => {
+          const containerPort = container.ports?.[0]?.containerPort;
+          const imageVersion = container.image ? container.image.split(':').pop() : undefined;
+          if (containerPort && imageVersion) {
+            containers.push({
+              containerPort: String(containerPort),
+              imageVersion
+            });
+          }
+        });
+      }
+      kubernetesPod = {
+        uid: pod.metadata.uid,
+        name: pod.metadata.name ?? pod.metadata.uid,
+        namespace: pod.metadata.namespace,
+        labels: {},
+        containers,
+        lastModified: Date.now()
+      };
+      _context.default.runningPods.push(kubernetesPod);
+    }
+    kubernetesPod.labels = pod.metadata.labels ?? {};
+    kubernetesPod.lastModified = Date.now();
+
+    // Update all services
+    _context.default.services.forEach(service => (0, _updatePluginPackageService.default)(service, undefined, logger));
+  } else if (event === 'DELETED') {
+    logger.debug(`Kubernetes Pod removed: ${pod.metadata.name}, namespace: ${pod.metadata.namespace}`);
+    const kubernetesPod = _context.default.runningPods.find(existingPid => existingPid.uid === pod.metadata?.uid);
+    if (kubernetesPod) {
+      _context.default.runningPods = _context.default.runningPods.filter(p => p.uid !== kubernetesPod.uid);
+
+      // Update all services
+      _context.default.services.forEach(service => (0, _updatePluginPackageService.default)(service, undefined, logger));
+    }
+  }
+};
+exports.default = _default;

package/dist/scanner/removePluginPackageService.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _context = _interopRequireDefault(require("../context"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = (service, logger) => {
+  _context.default.services = _context.default.services.filter(s => s.uid !== service.uid);
+  if (service.url) {
+    _context.default.scannerCallback?.removePackageUrl(service.url);
+  }
+  logger.info(`Kubernetes service with remote plugin package removed: ${service.name}`);
+};
+exports.default = _default;

package/dist/scanner/serviceEventCallback.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _url = require("url");
+var _context = _interopRequireDefault(require("../context"));
+var _updatePluginPackageService = _interopRequireDefault(require("./updatePluginPackageService"));
+var _removePluginPackageService = _interopRequireDefault(require("./removePluginPackageService"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = (serviceNameFilter, logger) => (event, service) => {
+  if (!service.metadata) {
+    return;
+  }
+  if (!service.metadata.name?.match(serviceNameFilter)) {
+    return;
+  }
+  const {
+    name,
+    namespace,
+    annotations = {}
+  } = service.metadata;
+  if (event === 'ADDED' || event === 'MODIFIED') {
+    logger.debug(`Kubernetes Service added or modified: ${service.metadata.name}, namespace: ${namespace}`);
+    let kubernetesService = _context.default.services.find(existingService => existingService.uid === service.metadata?.uid);
+    if (!kubernetesService) {
+      kubernetesService = {
+        uid: service.metadata.uid ?? service.metadata.name,
+        name,
+        namespace,
+        annotations,
+        firstSeen: Date.now(),
+        targetPort: undefined,
+        url: undefined,
+        selector: service.spec?.selector,
+        runningPods: 0,
+        imageVersion: undefined,
+        lastModified: Date.now(),
+        error: null
+      };
+      _context.default.services.push(kubernetesService);
+    }
+    const previousUrl = kubernetesService.url;
+    const headlessService = service?.spec?.clusterIP?.toLowerCase() === 'none';
+    const ports = service?.spec?.ports;
+    const port = ports && ports.length > 0 ? ports[0].port : undefined;
+    const targetPort = ports && ports.length > 0 ? String(ports[0].targetPort) : undefined;
+    let url;
+    if (!headlessService) {
+      let serviceUrl = `http://${name}`;
+      if (namespace) {
+        serviceUrl += `.${namespace}`;
+      }
+      if (port && port !== 80) {
+        serviceUrl += `:${port}`;
+      }
+      url = new _url.URL(serviceUrl);
+    }
+    kubernetesService.targetPort = targetPort;
+    kubernetesService.url = url;
+    kubernetesService.selector = service.spec?.selector;
+    kubernetesService.lastModified = Date.now();
+    if (headlessService) {
+      kubernetesService.error = 'Headless Service';
+    }
+    (0, _updatePluginPackageService.default)(kubernetesService, previousUrl, logger);
+  } else if (event === 'DELETED') {
+    logger.debug(`Kubernetes Service removed: ${service.metadata.name}, namespace: ${namespace}`);
+    const kubernetesService = _context.default.services.find(existingService => existingService.uid === service.metadata?.uid);
+    if (kubernetesService) {
+      (0, _removePluginPackageService.default)(kubernetesService, logger);
+    }
+  }
+};
+exports.default = _default;

package/dist/scanner/updatePluginPackageService.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _semver = _interopRequireDefault(require("semver"));
+var _context = _interopRequireDefault(require("../context"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = (service, previousUrl, logger) => {
+  if (!service.url) {
+    return;
+  }
+  const pods = _context.default.runningPods.filter(pod => {
+    if (!service.selector || Object.keys(service.selector).length === 0) {
+      return false;
+    }
+    return Object.keys(service.selector).every(key => pod.labels[key] === service.selector[key]);
+  });
+  const containers = pods.map(pod => pod.containers.find(c => c.containerPort === service.targetPort)).filter(c => !!c);
+  if (pods.length === 0) {
+    // No running pods found
+    if (service.runningPods > 0) {
+      _context.default.scannerCallback?.removePackageUrl(service.url);
+      logger.info(`Remote plugin package removed because not running Pods found for Kubernetes Service: ${service.name}`);
+    }
+    service.runningPods = 0;
+    service.imageVersion = undefined;
+    service.error = 'No running Pods';
+  } else {
+    const urlChange = previousUrl && previousUrl.toString() !== service.url.toString();
+    const highestImageVersion = containers.sort((p1, p2) => _semver.default.gt(p1.imageVersion, p2.imageVersion) ? -1 : 1)[0].imageVersion;
+    if (service.imageVersion !== highestImageVersion) {
+      logger.info(`Image version changed for Kubernetes Service: ${service.name}. Image version: ${service.imageVersion} -> ${highestImageVersion}`);
+    } else if (urlChange) {
+      logger.info(`URL changed for Kubernetes Service: ${service.name}. URL: ${previousUrl} -> ${service.url}`);
+    }
+    if (urlChange) {
+      _context.default.scannerCallback?.removePackageUrl(previousUrl);
+    }
+
+    // Add or update the remote package in any case, which is the safest approach
+    // (even if the number of Pods didn't change)
+    _context.default.scannerCallback?.addOrUpdatePackageUrl(service.url, {
+      packageName: service.name,
+      packageVersion: highestImageVersion,
+      ...service.annotations
+    });
+    service.lastModified = Date.now();
+    service.runningPods = pods.length;
+    service.imageVersion = highestImageVersion;
+    service.error = null;
+  }
+};
+exports.default = _default;

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/webapp/dev-server.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _url = require("url");
+var _express = _interopRequireDefault(require("express"));
+var _KubernetesRemotePluginPackagesScanner = require("../scanner/KubernetesRemotePluginPackagesScanner");
+var _context = _interopRequireDefault(require("../context"));
+var _webapp = _interopRequireDefault(require("./webapp"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const testServices = [{
+  uid: '1',
+  name: 'Service 1',
+  namespace: 'namespace1',
+  annotations: {},
+  targetPort: '1234',
+  url: new _url.URL('http://service1.namespace1:8080'),
+  selector: {},
+  firstSeen: Date.now(),
+  lastModified: Date.now(),
+  error: null,
+  imageVersion: undefined,
+  runningPods: 1
+}, {
+  uid: '2',
+  name: 'Service 2',
+  namespace: 'namespace1',
+  annotations: {},
+  targetPort: '1234',
+  url: new _url.URL('http://service2.namespace1:8080'),
+  selector: {},
+  firstSeen: Date.now(),
+  lastModified: Date.now(),
+  error: null,
+  imageVersion: '1.0.1',
+  runningPods: 1
+}, {
+  uid: '3',
+  name: 'Service 3',
+  namespace: 'namespace2',
+  annotations: {},
+  targetPort: '1234',
+  url: undefined,
+  selector: undefined,
+  firstSeen: Date.now(),
+  lastModified: Date.now(),
+  error: 'Headless Service',
+  imageVersion: undefined,
+  runningPods: 0
+}];
+_context.default.services = testServices;
+const testPackages = [{
+  url: new _url.URL('http://service1.namespace1:8080'),
+  scannerName: _KubernetesRemotePluginPackagesScanner.SCANNER_NAME,
+  definitionBuilderName: '',
+  processedOnce: false,
+  status: 'processing',
+  lastUpdate: Date.now(),
+  updateErrors: null,
+  foundPlugins: null
+}, {
+  url: new _url.URL('http://service2.namespace1:8080'),
+  scannerName: _KubernetesRemotePluginPackagesScanner.SCANNER_NAME,
+  definitionBuilderName: '',
+  processedOnce: true,
+  status: 'processed',
+  lastUpdate: Date.now(),
+  updateErrors: null,
+  foundPlugins: ['App1', 'App2']
+}];
+const contextHolder = {
+  getPluginContext: () => ({
+    loggerFactory: () => console,
+    serverConfig: {
+      externalPluginConfigFileNames: ['mashroom']
+    },
+    services: {
+      core: {
+        pluginService: {
+          getPotentialPluginPackagesByScanner() {
+            return testPackages;
+          },
+          onUnloadOnce: () => {
+            // no implementation required
+          }
+        }
+      }
+    }
+  })
+};
+const wrapperApp = (0, _express.default)();
+wrapperApp.use((req, res, next) => {
+  req.pluginContext = contextHolder.getPluginContext();
+  next();
+});
+wrapperApp.get('/', (req, res) => {
+  res.redirect('/remote-plugin-packages-kubernetes');
+});
+wrapperApp.use('/remote-plugin-packages-kubernetes', _webapp.default);
+wrapperApp.listen(8083, () => {
+  console.log('Listening on 8083');
+});
+wrapperApp.once('error', error => {
+  console.error('Failed to start server!', error);
+});

package/dist/webapp/mashroom-bootstrap-webapp.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _webapp = _interopRequireDefault(require("./webapp"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const bootstrap = async () => {
+  return _webapp.default;
+};
+var _default = exports.default = bootstrap;

package/dist/webapp/routes/services.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _context = _interopRequireDefault(require("../../context"));
+var _KubernetesRemotePluginPackagesScanner = require("../../scanner/KubernetesRemotePluginPackagesScanner");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const formatDate = ts => {
+  return new Date(ts).toISOString().replace(/T/, ' ').replace(/\..+/, '');
+};
+var _default = (request, response) => {
+  const pluginService = request.pluginContext.services.core.pluginService;
+  const pluginPackages = pluginService.getPotentialPluginPackagesByScanner(_KubernetesRemotePluginPackagesScanner.SCANNER_NAME);
+  const model = {
+    baseUrl: request.baseUrl,
+    hasErrors: _context.default.errors.length > 0,
+    errors: _context.default.errors,
+    namespaceLabelSelector: _context.default.namespaceLabelSelector,
+    watchedNamespaces: _context.default.watchedNamespaces.map(({
+      name
+    }) => name).join(', '),
+    serviceLabelSelector: _context.default.serviceLabelSelector,
+    serviceNameFilter: _context.default.serviceNameFilter,
+    services: _context.default.services.map(service => {
+      const pluginPackage = pluginPackages.find(p => service.url && p.url.toString() === service.url.toString());
+      const errors = service.error ?? pluginPackage?.updateErrors?.join(', ');
+      let status = 'Unknown';
+      if (pluginPackage) {
+        status = pluginPackage.processedOnce ? pluginPackage.status : 'pending';
+      }
+      let statusClass = 'pending';
+      if (errors) {
+        status = 'Error';
+        statusClass = 'error';
+      } else if (pluginPackage?.status === 'processing') {
+        status = 'Processing';
+        statusClass = 'processing';
+      } else if (pluginPackage?.status === 'processed') {
+        status = 'Processed';
+        statusClass = 'processed';
+      }
+      return {
+        name: service.name,
+        namespace: service.namespace ?? '',
+        url: service.url ? service.url.toString() : '',
+        runningPods: service.runningPods,
+        imageVersion: service.imageVersion,
+        status,
+        statusClass,
+        lastModified: formatDate(service.lastModified),
+        rowClass: errors ? 'row-error' : '',
+        portalApps: pluginPackage?.foundPlugins ?? undefined,
+        errors
+      };
+    })
+  };
+  response.render('services', model);
+};
+exports.default = _default;

package/dist/webapp/webapp.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _express = _interopRequireDefault(require("express"));
+var _expressHandlebars = require("express-handlebars");
+var _services = _interopRequireDefault(require("./routes/services"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const app = (0, _express.default)();
+app.engine('handlebars', (0, _expressHandlebars.engine)({
+  defaultLayout: ''
+}));
+app.set('view engine', 'handlebars');
+app.set('views', _path.default.resolve(__dirname, '../../views'));
+app.use(_express.default.static(_path.default.resolve(__dirname, '../../public')));
+app.get('/', _services.default);
+var _default = exports.default = app;

package/mashroom.json

@@ -0,0 +1,39 @@
+{
+    "$schema": "../../../node_modules/@mashroom/mashroom-json-schemas/schemas/mashroom-plugins.json",
+    "devModeBuildScript": "build",
+    "plugins": [
+        {
+            "name": "Mashroom Remote Package Scanner Kubernetes",
+            "type": "plugin-package-scanner",
+            "bootstrap": "./dist/scanner/mashroom-bootstrap-plugin-package-scanner.js",
+            "defaultConfig": {
+                "priority": 50,
+                "namespaceLabelSelector": ["microfrontends=true"],
+                "namespaces": null,
+                "serviceLabelSelector": ["microfrontends=true"],
+                "serviceNameFilter": ".*"
+            }
+        },
+        {
+            "name": "Mashroom Remote Package Scanner Kubernetes Admin Webapp",
+            "type": "web-app",
+            "bootstrap": "./dist/webapp/mashroom-bootstrap-webapp.js",
+            "defaultConfig": {
+                "path": "/remote-plugin-packages-kubernetes"
+            }
+        },
+        {
+            "name": "Mashroom Remote Package Scanner Kubernetes Admin Webapp Integration",
+            "type": "admin-ui-integration",
+            "requires": [
+                "Mashroom Remote Package Scanner Kubernetes Admin Webapp"
+            ],
+            "target": "Mashroom Remote Package Scanner Kubernetes Admin Webapp",
+            "defaultConfig": {
+                "order": 100,
+                "menuTitle": "Remote Plugin Packages K8S",
+                "path": "/remote-plugin-packages-kubernetes"
+            }
+        }
+    ]
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "@mashroom/mashroom-remote-package-scanner-kubernetes",
+    "description": "A Mashroom Portal plugin that scans for remote plugin packages in a Kubernetes cluster",
+    "homepage": "https://www.mashroom-server.com",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/nonblocking/mashroom.git"
+    },
+    "license": "MIT",
+    "version": "3.0.0-alpha.0",
+    "files": [
+        "dist/**",
+        "public/**",
+        "views/**",
+        "mashroom.json"
+    ],
+    "dependencies": {
+        "@kubernetes/client-node": "^1.4.0",
+        "express-handlebars": "^9.0.1",
+        "handlebars": "^4.7.9",
+        "semver": "^7.8.5"
+    },
+    "devDependencies": {
+        "@mashroom/mashroom": "3.0.0-alpha.0",
+        "@mashroom/mashroom-monitoring-metrics-collector": "3.0.0-alpha.0",
+        "@mashroom/mashroom-utils": "3.0.0-alpha.0",
+        "@types/semver": "^7.7.1"
+    },
+    "jest": {
+        "testEnvironment": "node",
+        "roots": [
+            "<rootDir>/test"
+        ],
+        "testRegex": "(\\.(test|spec))\\.ts",
+        "transform": {
+            "^.+\\.ts$": "ts-jest"
+        },
+        "reporters": [
+            "default",
+            "jest-junit"
+        ]
+    },
+    "jest-junit": {
+        "outputDirectory": "./test-reports"
+    },
+    "scripts": {
+        "lint": "eslint --fix",
+        "type-check": "tsc --noEmit",
+        "test": "jest",
+        "build": "babel src/js --extensions \".ts\" -d dist && sass --style compressed src/sass/style.scss public/style.css",
+        "dev": "nodemon --watch src -e ts,scss --exec \"npm run build && node dist/webapp/dev-server.js\""
+    }
+}

package/public/style.css

@@ -0,0 +1 @@
+body{text-rendering:optimizeLegibility;font-size:16px;line-height:1.5;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;min-height:800px;margin:16px}h2{font-size:1.2em;font-weight:normal}a,a:visited,a:focus{color:#4d487f;text-decoration:none;transition:color 500ms ease-out,background-color 500ms ease-out}a:hover,a:visited:hover,a:focus:hover{color:#3a365f}a:active,a:visited:active,a:focus:active{color:#3a365f}.errors{margin:20px 0;color:red}.errors ul{margin:5px 0}.errors li{padding:2px 0}.footnotes{margin-top:20px;font-size:.9em}table,th,td{border:none}table{border-spacing:0;border-collapse:collapse}tr:nth-child(even){background-color:#e2e2e2}th{padding:8px 10px;text-align:left;vertical-align:top;white-space:nowrap;font-weight:700}td{padding:8px 10px;vertical-align:top}tr.row-error{background-color:#fdd}tr.row-ignored{color:#666}.error{color:red}.pending,.processing{color:orange}/*# sourceMappingURL=style.css.map */

package/public/style.css.map

@@ -0,0 +1 @@
+{"version":3,"sourceRoot":"","sources":["../src/sass/style.scss"],"names":[],"mappings":"AAYA,KACI,kCACA,eACA,gBACA,YAVW,4CAWX,iBACA,YAGJ,GACI,gBACA,mBAGJ,oBACI,MA1BY,QA2BZ,qBAnBA,gEAsBA,sCACI,MA7Ba,QAgCjB,yCACI,MAjCa,QAqCrB,QACI,cACA,MAtCU,IAwCV,WACI,aAGJ,WACI,cAIR,WACI,gBACA,eAGJ,YACI,YAGJ,MACI,iBACA,yBAGJ,mBACI,yBAGJ,GACI,iBACA,gBACA,mBACA,mBACA,gBAGJ,GACI,iBACA,mBAIJ,aACE,sBAGF,eACE,WAGF,OACE,MA1FY,IA6Fd,qBACE","file":"style.css"}

package/views/services.handlebars

@@ -0,0 +1,100 @@
+<!doctype html>
+<html>
+<head>
+    <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+
+    <link rel="stylesheet" type="text/css" href="{{baseUrl}}/style.css">
+
+    <script type="application/javascript">
+        function openPlugin(pluginName) {
+            window.top.location.href = `/mashroom/admin/plugins?q=${encodeURIComponent(pluginName)}`;
+        }
+
+         var lastContentHeight = null;
+         function sendHeight() {
+             var contentHeight = document.body.offsetHeight;
+             if (lastContentHeight !== contentHeight) {
+                 parent.postMessage({
+                     height: contentHeight + 20
+                 }, "*");
+                 lastContentHeight = contentHeight;
+             }
+         }
+
+         if (parent !== window) {
+             setInterval(sendHeight, 1000);
+         }
+    </script>
+
+    <title>Mashroom Kubernetes Remote Packages</title>
+</head>
+<body>
+    <h2>Kubernetes Remote Packages</h2>
+
+    {{#if hasErrors}}
+        <div class="errors">
+            <div class="errors-header">Scan Errors:</div>
+            <ul>
+                {{#each errors}}
+                   <li>{{this}}</li>
+                {{/each}}
+            </ul>
+        </div>
+    {{/if}}
+
+    <div class="services">
+        <table>
+            <tr>
+                <th>Name</th>
+                <th>Namespace</th>
+                <th>URL</th>
+                <th>Valid Pods</th>
+                <th>Image Version</th>
+                <th>Last Modified</th>
+                <th>Status</th>
+                <th>Portal Apps</th>
+            </tr>
+            {{#each services}}
+                <tr class="{{this.rowClass}}">
+                    <td>{{this.name}}</td>
+                    <td>{{this.namespace}}</td>
+                    <td>{{this.url}}</td>
+                    <td>{{this.runningPods}}</td>
+                    <td>{{this.imageVersion}}</td>
+                    <td>{{this.lastModified}}</td>
+                    <td class="{{this.statusClass}}">{{this.status}}</td>
+                    <td>
+                        {{#if this.portalApps}}
+                            <div>
+                                {{#each this.portalApps}}
+                                    {{#if @index}}, {{/if}}<a href="javascript:void(0)" onclick="openPlugin('{{this}}')">{{this}}</a>
+                                {{/each}}
+                            </div>
+                        {{/if}}
+                        {{#if this.errors}}
+                            <div class="error">{{this.errors}}</div>
+                        {{/if}}
+                    </td>
+                </tr>
+            {{/each}}
+        </table>
+    </div>
+
+    <div class="footnotes">
+        {{#if namespaceLabelSelector}}
+            <strong>Namespace label selector:</strong> {{namespaceLabelSelector}}
+            <br/>
+        {{/if}}
+        <strong>Watched Namespaces:</strong> {{watchedNamespaces}}
+        <br/>
+        {{#if serviceLabelSelector}}
+            <strong>Service label selector:</strong> {{serviceLabelSelector}}
+            <br/>
+        {{/if}}
+        <strong>Service name filter:</strong> {{serviceNameFilter}}
+    </div>
+
+</body>
+</html>