Merge branch 'master' into extensions-api

src/main/cluster.ts

@@ -56,10 +56,10 @@ export class Cluster implements ClusterModel {
   @observable kubeConfigPath: string;
   @observable apiUrl: string; // cluster server url
   @observable kubeProxyUrl: string; // lens-proxy to kube-api url
-  @observable online: boolean;
-  @observable accessible: boolean;
-  @observable ready: boolean;
-  @observable disconnected: boolean;
+  @observable online = false;
+  @observable accessible = false;
+  @observable ready = false;
+  @observable disconnected = true;
   @observable failureReason: string;
   @observable nodes = 0;
   @observable version: string;
@@ -124,13 +124,14 @@ export class Cluster implements ClusterModel {
     this.eventDisposers.length = 0;
   }
 
-  async activate(init = false) {
+  @action
+  async activate() {
     logger.info(`[CLUSTER]: activate`, this.getMeta());
     await this.whenInitialized;
     if (!this.eventDisposers.length) {
       this.bindEvents();
     }
-    if (this.disconnected || (!init && !this.accessible)) {
+    if (this.disconnected || !this.accessible) {
       await this.reconnect();
     }
     await this.refreshConnectionStatus()
@@ -143,6 +144,7 @@ export class Cluster implements ClusterModel {
     return this.pushState();
   }
 
+  @action
   async reconnect() {
     logger.info(`[CLUSTER]: reconnect`, this.getMeta());
     this.contextHandler.stopServer();

src/main/kubectl.ts

@@ -36,7 +36,7 @@ const packageMirrors: Map<string, string> = new Map([
 let bundledPath: string
 const initScriptVersionString = "# lens-initscript v3\n"
 
-if (isDevelopment || isTestEnv) {
+if (isDevelopment || isTestEnv) {
   const platformName = isWindows ? "windows" : process.platform
   bundledPath = path.join(process.cwd(), "binaries", "client", platformName, process.arch, "kubectl")
 } else {
@@ -110,7 +110,11 @@ export class Kubectl {
   }
 
   protected getDownloadDir() {
-    return userStore.preferences?.downloadBinariesPath || Kubectl.kubectlDir
+    if (userStore.preferences?.downloadBinariesPath) {
+      return path.join(userStore.preferences.downloadBinariesPath, "kubectl")
+    }
+
+    return Kubectl.kubectlDir
   }
 
   public async getPath(bundled = false): Promise<string> {
@@ -214,7 +218,7 @@ export class Kubectl {
         });
         isValid = !await this.checkBinary(this.path, false)
       }
-      if(!isValid) {
+      if (!isValid) {
         logger.debug(`Releasing lock for ${this.kubectlVersion}`)
         release()
         return false
@@ -279,6 +283,12 @@ export class Kubectl {
     bashScript += "fi\n"
     bashScript += `export PATH="${helmPath}:${kubectlPath}:$PATH"\n`
     bashScript += "export KUBECONFIG=\"$tempkubeconfig\"\n"
+
+    bashScript += "NO_PROXY=\",${NO_PROXY:-localhost},\"\n"
+    bashScript += "NO_PROXY=\"${NO_PROXY//,localhost,/,}\"\n"
+    bashScript += "NO_PROXY=\"${NO_PROXY//,127.0.0.1,/,}\"\n"
+    bashScript += "NO_PROXY=\"localhost,127.0.0.1${NO_PROXY%,}\"\n"
+    bashScript += "export NO_PROXY\n"
     bashScript += "unset tempkubeconfig\n"
     await fsPromises.writeFile(bashScriptPath, bashScript.toString(), { mode: 0o644 })
 
@@ -304,6 +314,11 @@ export class Kubectl {
     zshScript += "d=${d/#:/}\n"
     zshScript += "export PATH=\"$helmpath:$kubectlpath:${d/%:/}\"\n"
     zshScript += "export KUBECONFIG=\"$tempkubeconfig\"\n"
+    zshScript += "NO_PROXY=\",${NO_PROXY:-localhost},\"\n"
+    zshScript += "NO_PROXY=\"${NO_PROXY//,localhost,/,}\"\n"
+    zshScript += "NO_PROXY=\"${NO_PROXY//,127.0.0.1,/,}\"\n"
+    zshScript += "NO_PROXY=\"localhost,127.0.0.1${NO_PROXY%,}\"\n"
+    zshScript += "export NO_PROXY\n"
     zshScript += "unset tempkubeconfig\n"
     zshScript += "unset OLD_ZDOTDIR\n"
     await fsPromises.writeFile(zshScriptPath, zshScript.toString(), { mode: 0o644 })

src/main/lens-proxy.ts

@@ -44,9 +44,7 @@ export class LensProxy {
     const spdyProxy = spdy.createServer({
       spdy: {
         plain: true,
-        connection: {
-          autoSpdy31: true
-        }
+        protocols: ["http/1.1", "spdy/3.1"]
       }
     }, (req: http.IncomingMessage, res: http.ServerResponse) => {
       this.handleRequest(proxy, req, res)
@@ -55,11 +53,7 @@ export class LensProxy {
       if (req.url.startsWith(`${apiPrefix}?`)) {
         this.handleWsUpgrade(req, socket, head)
       } else {
-        if (req.headers.upgrade?.startsWith("SPDY")) {
-          this.handleSpdyProxy(proxy, req, socket, head)
-        } else {
-          socket.end()
-        }
+        this.handleProxyUpgrade(proxy, req, socket, head)
       }
     })
     spdyProxy.on("error", (err) => {
@@ -68,17 +62,45 @@ export class LensProxy {
     return spdyProxy
   }
 
-  protected async handleSpdyProxy(proxy: httpProxy, req: http.IncomingMessage, socket: net.Socket, head: Buffer) {
+  protected async handleProxyUpgrade(proxy: httpProxy, req: http.IncomingMessage, socket: net.Socket, head: Buffer) {
     const cluster = this.clusterManager.getClusterForRequest(req)
     if (cluster) {
       const proxyUrl = await cluster.contextHandler.resolveAuthProxyUrl() + req.url.replace(apiKubePrefix, "")
       const apiUrl = url.parse(cluster.apiUrl)
-      const res = new http.ServerResponse(req)
-      res.assignSocket(socket)
-      res.setHeader("Location", proxyUrl)
-      res.setHeader("Host", apiUrl.hostname)
-      res.statusCode = 302
-      res.end()
+      const pUrl = url.parse(proxyUrl)
+      const connectOpts = { port: parseInt(pUrl.port), host: pUrl.hostname }
+      const proxySocket = new net.Socket()
+      proxySocket.connect(connectOpts, () => {
+        proxySocket.write(`${req.method} ${pUrl.path} HTTP/1.1\r\n`)
+        proxySocket.write(`Host: ${apiUrl.host}\r\n`)
+        for (let i = 0; i < req.rawHeaders.length; i += 2) {
+          const key = req.rawHeaders[i]
+          if (key !== "Host" && key !== "Authorization") {
+            proxySocket.write(`${req.rawHeaders[i]}: ${req.rawHeaders[i+1]}\r\n`)
+          }
+        }
+        proxySocket.write("\r\n")
+        proxySocket.write(head)
+      })
+      proxySocket.on('data', function (chunk) {
+        socket.write(chunk)
+      })
+      proxySocket.on('end', function () {
+        socket.end()
+      })
+      proxySocket.on('error', function (err) {
+        socket.write("HTTP/" + req.httpVersion + " 500 Connection error\r\n\r\n");
+        socket.end()
+      })
+      socket.on('data', function (chunk) {
+        proxySocket.write(chunk)
+      })
+      socket.on('end', function () {
+        proxySocket.end()
+      })
+      socket.on('error', function () {
+        proxySocket.end()
+      })
     }
   }
 
@@ -134,7 +156,6 @@ export class LensProxy {
   protected async handleRequest(proxy: httpProxy, req: http.IncomingMessage, res: http.ServerResponse) {
     const cluster = this.clusterManager.getClusterForRequest(req)
     if (cluster) {
-      await cluster.contextHandler.ensureServer();
       const proxyTarget = await this.getProxyTarget(req, cluster.contextHandler)
       if (proxyTarget) {
         // allow to fetch apis in "clusterId.localhost:port" from "localhost:port"

src/main/prometheus/operator.ts

@@ -37,19 +37,19 @@ export class PrometheusOperator implements PrometheusProvider {
         memoryUsage: `
           sum(
             node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)
-          ) by (node)
+          )
         `.replace(/_bytes/g, `_bytes * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"}`),
-        memoryRequests: `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="memory"}) by (component)`,
-        memoryLimits: `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="memory"}) by (component)`,
-        memoryCapacity: `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="memory"}) by (component)`,
-        cpuUsage: `sum(rate(node_cpu_seconds_total{mode=~"user|system"}[${this.rateAccuracy}])* on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"}) by (node)`,
-        cpuRequests:`sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="cpu"}) by (component)`,
-        cpuLimits: `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="cpu"}) by (component)`,
-        cpuCapacity: `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="cpu"}) by (component)`,
+        memoryRequests: `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="memory"})`,
+        memoryLimits: `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="memory"})`,
+        memoryCapacity: `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="memory"})`,
+        cpuUsage: `sum(rate(node_cpu_seconds_total{mode=~"user|system"}[${this.rateAccuracy}])* on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"})`,
+        cpuRequests:`sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="cpu"})`,
+        cpuLimits: `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="cpu"})`,
+        cpuCapacity: `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="cpu"})`,
         podUsage: `sum(kubelet_running_pod_count{node=~"${opts.nodes}"})`,
-        podCapacity: `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="pods"}) by (component)`,
-        fsSize: `sum(node_filesystem_size_bytes{mountpoint="/"} * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"}) by (node)`,
-        fsUsage: `sum(node_filesystem_size_bytes{mountpoint="/"} * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"} - node_filesystem_avail_bytes{mountpoint="/"} * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"}) by (node)`
+        podCapacity: `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="pods"})`,
+        fsSize: `sum(node_filesystem_size_bytes{mountpoint="/"} * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"})`,
+        fsUsage: `sum(node_filesystem_size_bytes{mountpoint="/"} * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"} - node_filesystem_avail_bytes{mountpoint="/"} * on (pod,namespace) group_left(node) kube_pod_info{node=~"${opts.nodes}"})`
       }
     case 'nodes':
       return {
@@ -62,10 +62,10 @@ export class PrometheusOperator implements PrometheusProvider {
       }
     case 'pods':
       return {
-        cpuUsage: `sum(rate(container_cpu_usage_seconds_total{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}[${this.rateAccuracy}])) by (${opts.selector})`,
+        cpuUsage: `sum(rate(container_cpu_usage_seconds_total{container!="POD",container!="",image!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}[${this.rateAccuracy}])) by (${opts.selector})`,
         cpuRequests: `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}",resource="cpu",namespace="${opts.namespace}"}) by (${opts.selector})`,
         cpuLimits: `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}",resource="cpu",namespace="${opts.namespace}"}) by (${opts.selector})`,
-        memoryUsage: `sum(container_memory_working_set_bytes{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`,
+        memoryUsage: `sum(container_memory_working_set_bytes{container!="POD",container!="",image!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`,
         memoryRequests: `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}",resource="memory",namespace="${opts.namespace}"}) by (${opts.selector})`,
         memoryLimits: `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}",resource="memory",namespace="${opts.namespace}"}) by (${opts.selector})`,
         fsUsage: `sum(container_fs_usage_bytes{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`,

src/main/prometheus/stacklight.ts

@@ -0,0 +1,83 @@
+import { PrometheusProvider, PrometheusQueryOpts, PrometheusQuery, PrometheusService } from "./provider-registry";
+import { CoreV1Api } from "@kubernetes/client-node";
+import logger from "../logger"
+
+export class PrometheusStacklight implements PrometheusProvider {
+  id = "stacklight"
+  name = "Stacklight"
+  rateAccuracy = "1m"
+
+  public async getPrometheusService(client: CoreV1Api): Promise<PrometheusService> {
+    try {
+      const resp = await client.readNamespacedService("prometheus-server", "stacklight")
+      const service = resp.body
+      return {
+        id: this.id,
+        namespace: service.metadata.namespace,
+        service: service.metadata.name,
+        port: service.spec.ports[0].port
+      }
+    } catch(error) {
+      logger.warn(`PrometheusLens: failed to list services: ${error.response.body.message}`)
+    }
+  }
+
+  public getQueries(opts: PrometheusQueryOpts): PrometheusQuery {
+    switch(opts.category) {
+    case 'cluster':
+      return {
+        memoryUsage: `
+          sum(
+            node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)
+          ) by (kubernetes_name)
+        `.replace(/_bytes/g, `_bytes{node=~"${opts.nodes}"}`),
+        memoryRequests: `sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="memory"}) by (component)`,
+        memoryLimits: `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="memory"}) by (component)`,
+        memoryCapacity: `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="memory"}) by (component)`,
+        cpuUsage: `sum(rate(node_cpu_seconds_total{node=~"${opts.nodes}", mode=~"user|system"}[${this.rateAccuracy}]))`,
+        cpuRequests:`sum(kube_pod_container_resource_requests{node=~"${opts.nodes}", resource="cpu"}) by (component)`,
+        cpuLimits: `sum(kube_pod_container_resource_limits{node=~"${opts.nodes}", resource="cpu"}) by (component)`,
+        cpuCapacity: `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="cpu"}) by (component)`,
+        podUsage: `sum(kubelet_running_pod_count{instance=~"${opts.nodes}"})`,
+        podCapacity: `sum(kube_node_status_capacity{node=~"${opts.nodes}", resource="pods"}) by (component)`,
+        fsSize: `sum(node_filesystem_size_bytes{node=~"${opts.nodes}", mountpoint="/"}) by (node)`,
+        fsUsage: `sum(node_filesystem_size_bytes{node=~"${opts.nodes}", mountpoint="/"} - node_filesystem_avail_bytes{node=~"${opts.nodes}", mountpoint="/"}) by (node)`
+      }
+    case 'nodes':
+      return {
+        memoryUsage: `sum (node_memory_MemTotal_bytes - (node_memory_MemFree_bytes + node_memory_Buffers_bytes + node_memory_Cached_bytes)) by (node)`,
+        memoryCapacity: `sum(kube_node_status_capacity{resource="memory"}) by (node)`,
+        cpuUsage: `sum(rate(node_cpu_seconds_total{mode=~"user|system"}[${this.rateAccuracy}])) by(node)`,
+        cpuCapacity: `sum(kube_node_status_allocatable{resource="cpu"}) by (node)`,
+        fsSize: `sum(node_filesystem_size_bytes{mountpoint="/"}) by (node)`,
+        fsUsage: `sum(node_filesystem_size_bytes{mountpoint="/"} - node_filesystem_avail_bytes{mountpoint="/"}) by (node)`
+      }
+    case 'pods':
+      return {
+        cpuUsage: `sum(rate(container_cpu_usage_seconds_total{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}[${this.rateAccuracy}])) by (${opts.selector})`,
+        cpuRequests: `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}",resource="cpu",namespace="${opts.namespace}"}) by (${opts.selector})`,
+        cpuLimits: `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}",resource="cpu",namespace="${opts.namespace}"}) by (${opts.selector})`,
+        memoryUsage: `sum(container_memory_working_set_bytes{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`,
+        memoryRequests: `sum(kube_pod_container_resource_requests{pod=~"${opts.pods}",resource="memory",namespace="${opts.namespace}"}) by (${opts.selector})`,
+        memoryLimits: `sum(kube_pod_container_resource_limits{pod=~"${opts.pods}",resource="memory",namespace="${opts.namespace}"}) by (${opts.selector})`,
+        fsUsage: `sum(container_fs_usage_bytes{container!="POD",container!="",pod=~"${opts.pods}",namespace="${opts.namespace}"}) by (${opts.selector})`,
+        networkReceive: `sum(rate(container_network_receive_bytes_total{pod=~"${opts.pods}",namespace="${opts.namespace}"}[${this.rateAccuracy}])) by (${opts.selector})`,
+        networkTransmit: `sum(rate(container_network_transmit_bytes_total{pod=~"${opts.pods}",namespace="${opts.namespace}"}[${this.rateAccuracy}])) by (${opts.selector})`
+      }
+    case 'pvc':
+      return {
+        diskUsage: `sum(kubelet_volume_stats_used_bytes{persistentvolumeclaim="${opts.pvc}"}) by (persistentvolumeclaim, namespace)`,
+        diskCapacity: `sum(kubelet_volume_stats_capacity_bytes{persistentvolumeclaim="${opts.pvc}"}) by (persistentvolumeclaim, namespace)`
+      }
+    case 'ingress':
+      const bytesSent = (ingress: string, statuses: string) =>
+        `sum(rate(nginx_ingress_controller_bytes_sent_sum{ingress="${ingress}", status=~"${statuses}"}[${this.rateAccuracy}])) by (ingress)`
+      return {
+        bytesSentSuccess: bytesSent(opts.igress, "^2\\\\d*"),
+        bytesSentFailure: bytesSent(opts.ingres, "^5\\\\d*"),
+        requestDurationSeconds: `sum(rate(nginx_ingress_controller_request_duration_seconds_sum{ingress="${opts.ingress}"}[${this.rateAccuracy}])) by (ingress)`,
+        responseDurationSeconds: `sum(rate(nginx_ingress_controller_response_duration_seconds_sum{ingress="${opts.ingress}"}[${this.rateAccuracy}])) by (ingress)`
+      }
+    }
+  }
+}

src/main/shell-session.ts

@@ -125,6 +125,8 @@ export class ShellSession extends EventEmitter {
     if (this.preferences.httpsProxy) {
       env["HTTPS_PROXY"] = this.preferences.httpsProxy
     }
+    const no_proxy = ["localhost", "127.0.0.1", env["NO_PROXY"]]
+    env["NO_PROXY"] = no_proxy.filter(address => !!address).join()
     if (env.DEBUG) { // do not pass debug option to bash
       delete env["DEBUG"]
     }