Refactor dashboard server logic to electron main (#146)

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

src/main/routes/config.ts

@@ -0,0 +1,66 @@
+import { LensApiRequest } from "../router"
+import { LensApi } from "../lens-api"
+import { userStore } from "../../common/user-store"
+import { getAppVersion } from "../../common/app-utils"
+import { CoreV1Api, AuthorizationV1Api } from "@kubernetes/client-node"
+import { Cluster } from "../cluster"
+
+
+function selfSubjectAccessReview(authApi: AuthorizationV1Api, namespace: string) {
+  return authApi.createSelfSubjectAccessReview({
+    apiVersion: "authorization.k8s.io/v1",
+    kind: "SelfSubjectAccessReview",
+    spec: {
+      resourceAttributes: {
+        namespace: namespace,
+        resource: "pod",
+        verb: "list",
+      }
+    }
+  })
+}
+
+async function getAllowedNamespaces(cluster: Cluster) {
+  const api = cluster.contextHandler.kc.makeApiClient(CoreV1Api)
+  const authApi = cluster.contextHandler.kc.makeApiClient(AuthorizationV1Api)
+  try {
+    const namespaceList = await api.listNamespace()
+    const nsAccessStatuses = await Promise.all(
+      namespaceList.body.items.map(ns => {
+        return selfSubjectAccessReview(authApi, ns.metadata.name)
+      })
+    )
+    return namespaceList.body.items
+      .filter((ns, i) => nsAccessStatuses[i].body.status.allowed)
+      .map(ns => ns.metadata.name)
+  } catch(error) {
+    const kc = cluster.contextHandler.kc
+    const ctx = kc.getContextObject(kc.currentContext)
+    if (ctx.namespace) {
+      return [ctx.namespace]
+    } else {
+      return []
+    }
+  }
+}
+
+class ConfigRoute extends LensApi {
+
+  public async routeConfig(request: LensApiRequest) {
+    const { params, response, cluster} = request
+
+    const data = {
+      clusterName: cluster.contextName,
+      lensVersion: getAppVersion(),
+      lensTheme: `kontena-${userStore.getPreferences().colorTheme}`,
+      kubeVersion: cluster.version,
+      chartsEnabled: true,
+      isClusterAdmin: cluster.isAdmin,
+      allowedNamespaces: await getAllowedNamespaces(cluster)
+    };
+
+    this.respondJson(response, data)
+  }
+}
+
+export const configRoute = new ConfigRoute()

src/main/routes/kubeconfig.ts

@@ -0,0 +1,58 @@
+import { LensApiRequest } from "../router"
+import { LensApi } from "../lens-api"
+import { Cluster } from "../cluster"
+import { CoreV1Api, V1Secret } from "@kubernetes/client-node"
+
+function generateKubeConfig(username: string, secret: V1Secret, cluster: Cluster) {
+  const tokenData = new Buffer(secret.data["token"], "base64")
+  return {
+    'apiVersion': 'v1',
+    'kind': 'Config',
+    'clusters': [
+      {
+        'name': cluster.contextName,
+        'cluster': {
+          'server': cluster.contextHandler.kc.getCurrentCluster().server,
+          'certificate-authority-data': secret.data["ca.crt"]
+        }
+      }
+    ],
+    'users': [
+      {
+        'name': username,
+        'user': {
+          'token': tokenData.toString("utf8"),
+        }
+      }
+    ],
+    'contexts': [
+      {
+        'name': cluster.contextName,
+        'context': {
+          'user': username,
+          'cluster': cluster.contextName,
+          'namespace': secret.metadata.namespace,
+        }
+      }
+    ],
+    'current-context': cluster.contextName
+  }
+}
+
+class KubeconfigRoute extends LensApi {
+
+  public async routeServiceAccountRoute(request: LensApiRequest) {
+    const { params, response, cluster} = request
+
+    const client = cluster.contextHandler.kc.makeApiClient(CoreV1Api);
+    const secretList = await client.listNamespacedSecret(params.namespace)
+    const secret = secretList.body.items.find(secret => {
+      const { annotations } = secret.metadata;
+      return annotations && annotations["kubernetes.io/service-account.name"] == params.account;
+    });
+    const data = generateKubeConfig(params.account, secret, cluster);
+    this.respondJson(response, data)
+  }
+}
+
+export const kubeconfigRoute = new KubeconfigRoute()

src/main/routes/metrics.ts

@@ -0,0 +1,75 @@
+import { LensApiRequest } from "../router"
+import { LensApi } from "../lens-api"
+import * as requestPromise from "request-promise-native"
+
+type MetricsQuery = string | string[] | {
+  [metricName: string]: string;
+}
+
+class MetricsRoute extends LensApi {
+
+  public async routeMetrics(request: LensApiRequest) {
+    const { response, cluster} = request
+    const query: MetricsQuery = request.payload;
+    const serverUrl = `http://127.0.0.1:${cluster.port}/api-kube`
+    const metricsUrl = `${serverUrl}/api/v1/namespaces/${cluster.contextHandler.getPrometheusPath()}/proxy/api/v1/query_range`
+    const headers = {
+      "Host": `${cluster.id}.localhost:${cluster.port}`,
+      "Content-type": "application/json",
+    }
+    const queryParams: MetricsQuery = {}
+    request.query.forEach((value: string, key: string) => {
+      queryParams[key] = value
+    })
+
+    // prometheus metrics loader
+    const attempts: { [query: string]: number } = {};
+    const maxAttempts = 5;
+    const loadMetrics = (orgQuery: string): Promise<any> => {
+      const query = orgQuery.trim()
+      const attempt = attempts[query] = (attempts[query] || 0) + 1;
+      return requestPromise(metricsUrl, {
+        resolveWithFullResponse: false,
+        headers: headers,
+        json: true,
+        qs: {
+          query: query,
+          ...queryParams
+        }
+      }).catch(async (error) => {
+        if (attempt < maxAttempts) {
+          await new Promise(resolve => setTimeout(resolve, attempt * 1000)); // add delay before repeating request
+          return loadMetrics(query);
+        }
+        return {
+          status: error.toString(),
+          data: {
+            result: []
+          }
+        }
+      })
+    };
+
+    // return data in same structure as query
+    let data: any;
+    if (typeof query === "string") {
+      data = await loadMetrics(query)
+    }
+    else if (Array.isArray(query)) {
+      data = await Promise.all(query.map(loadMetrics));
+    }
+    else {
+      data = {};
+      const result = await Promise.all(
+        Object.values(query).map(loadMetrics)
+      );
+      Object.keys(query).forEach((metricName, index) => {
+        data[metricName] = result[index];
+      });
+    }
+
+    this.respondJson(response, data)
+  }
+}
+
+export const metricsRoute = new MetricsRoute()

src/main/routes/watch.ts

@@ -0,0 +1,108 @@
+import { LensApiRequest } from "../router"
+import { LensApi } from "../lens-api"
+import { Watch, KubeConfig, RuntimeRawExtension } from "@kubernetes/client-node"
+import { ServerResponse } from "http"
+import { Request } from "request"
+import logger from "../logger"
+
+class ApiWatcher {
+  private apiUrl: string
+  private response: ServerResponse
+  private watchRequest: Request
+  private watch: Watch
+  private processor: NodeJS.Timeout
+  private eventBuffer: any[] = []
+
+  constructor(apiUrl: string, kubeConfig: KubeConfig, response: ServerResponse) {
+    this.apiUrl = apiUrl
+    this.watch = new Watch(kubeConfig)
+    this.response = response
+  }
+
+  public start() {
+    if (this.processor) {
+      clearInterval(this.processor)
+    }
+    this.processor = setInterval(() => {
+      const events = this.eventBuffer.splice(0)
+      events.map(event => this.sendEvent(event))
+      this.response.flushHeaders()
+    }, 50)
+    this.watchRequest = this.watch.watch(this.apiUrl, {}, this.watchHandler.bind(this), this.doneHandler.bind(this))
+  }
+
+  public stop() {
+    if (!this.watchRequest) { return }
+
+    if (this.processor) {
+      clearInterval(this.processor)
+    }
+    logger.debug("Stopping watcher for api: " + this.apiUrl)
+    this.watchRequest.abort()
+  }
+
+  private watchHandler(phase: string, obj: RuntimeRawExtension) {
+    this.eventBuffer.push({
+      type: phase,
+      object: obj
+    })
+  }
+
+  private doneHandler(error: Error) {
+    if (error) {
+      logger.error("watch error: " + error.toString())
+      this.sendEvent({
+        type: "STREAM_END",
+        url: this.apiUrl,
+        status: 410,
+      })
+      return
+    }
+    this.start()
+  }
+
+  private sendEvent(evt: any) {
+    // convert to "text/event-stream" format
+    this.response.write(`data: ${JSON.stringify(evt)}\n\n`);
+  }
+}
+
+class WatchRoute extends LensApi {
+
+  public async routeWatch(request: LensApiRequest) {
+    const { params, response, cluster} = request
+    const apis: string[] = request.query.getAll("api")
+    const watchers: ApiWatcher[] = []
+
+    if (!apis.length) {
+      this.respondJson(response, {
+        message: "Empty request. Query params 'api' are not provided.",
+        example: "?api=/api/v1/pods&api=/api/v1/nodes",
+      }, 400)
+      return
+    }
+
+    response.setHeader("Content-Type", "text/event-stream")
+    response.setHeader("Cache-Control", "no-cache")
+    response.setHeader("Connection", "keep-alive")
+
+    apis.forEach(apiUrl => {
+      const watcher = new ApiWatcher(apiUrl, cluster.contextHandler.kc, response)
+      watcher.start()
+      watchers.push(watcher)
+    })
+
+    request.raw.req.on("close", () => {
+      logger.debug("Watch request closed")
+      watchers.map(watcher => watcher.stop())
+    })
+
+    request.raw.req.on("end", () => {
+      logger.debug("Watch request ended")
+      watchers.map(watcher => watcher.stop())
+    })
+
+  }
+}
+
+export const watchRoute = new WatchRoute()