Enforce semicolons in eslint

Signed-off-by: Panu Horsmalahti <phorsmalahti@mirantis.com>

src/main/routes/helm-route.ts

@@ -1,114 +1,114 @@
-import { LensApiRequest } from "../router"
-import { helmService } from "../helm/helm-service"
-import { LensApi } from "../lens-api"
-import logger from "../logger"
+import { LensApiRequest } from "../router";
+import { helmService } from "../helm/helm-service";
+import { LensApi } from "../lens-api";
+import logger from "../logger";
 
 class HelmApiRoute extends LensApi {
   public async listCharts(request: LensApiRequest) {
-    const { response } = request
-    const charts = await helmService.listCharts()
-    this.respondJson(response, charts)
+    const { response } = request;
+    const charts = await helmService.listCharts();
+    this.respondJson(response, charts);
   }
 
   public async getChart(request: LensApiRequest) {
-    const { params, query, response } = request
-    const chart = await helmService.getChart(params.repo, params.chart, query.get("version"))
-    this.respondJson(response, chart)
+    const { params, query, response } = request;
+    const chart = await helmService.getChart(params.repo, params.chart, query.get("version"));
+    this.respondJson(response, chart);
   }
 
   public async getChartValues(request: LensApiRequest) {
-    const { params, query, response } = request
-    const values = await helmService.getChartValues(params.repo, params.chart, query.get("version"))
-    this.respondJson(response, values)
+    const { params, query, response } = request;
+    const values = await helmService.getChartValues(params.repo, params.chart, query.get("version"));
+    this.respondJson(response, values);
   }
 
   public async installChart(request: LensApiRequest) {
-    const { payload, cluster, response } = request
+    const { payload, cluster, response } = request;
     try {
-      const result = await helmService.installChart(cluster, payload)
-      this.respondJson(response, result, 201)
+      const result = await helmService.installChart(cluster, payload);
+      this.respondJson(response, result, 201);
     } catch (error) {
-      logger.debug(error)
-      this.respondText(response, error, 422)
+      logger.debug(error);
+      this.respondText(response, error, 422);
     }
   }
 
   public async updateRelease(request: LensApiRequest) {
-    const { cluster, params, payload, response } = request
+    const { cluster, params, payload, response } = request;
     try {
-      const result = await helmService.updateRelease(cluster, params.release, params.namespace, payload )
-      this.respondJson(response, result)
+      const result = await helmService.updateRelease(cluster, params.release, params.namespace, payload );
+      this.respondJson(response, result);
     } catch (error) {
-      logger.debug(error)
-      this.respondText(response, error, 422)
+      logger.debug(error);
+      this.respondText(response, error, 422);
     }
   }
 
   public async rollbackRelease(request: LensApiRequest) {
-    const { cluster, params, payload, response } = request
+    const { cluster, params, payload, response } = request;
     try {
-      const result = await helmService.rollback(cluster, params.release, params.namespace, payload.revision)
-      this.respondJson(response, result)
+      const result = await helmService.rollback(cluster, params.release, params.namespace, payload.revision);
+      this.respondJson(response, result);
     } catch (error) {
-      logger.debug(error)
-      this.respondText(response, error)
+      logger.debug(error);
+      this.respondText(response, error);
     }
   }
 
   public async listReleases(request: LensApiRequest) {
-    const { cluster, params, response } = request
+    const { cluster, params, response } = request;
     try {
-      const result = await helmService.listReleases(cluster, params.namespace)
-      this.respondJson(response, result)
+      const result = await helmService.listReleases(cluster, params.namespace);
+      this.respondJson(response, result);
     } catch(error) {
-      logger.debug(error)
-      this.respondText(response, error)
+      logger.debug(error);
+      this.respondText(response, error);
     }
   }
 
   public async getRelease(request: LensApiRequest) {
-    const { cluster, params, response } = request
+    const { cluster, params, response } = request;
     try {
-      const result = await helmService.getRelease(cluster, params.release, params.namespace)
-      this.respondJson(response, result)
+      const result = await helmService.getRelease(cluster, params.release, params.namespace);
+      this.respondJson(response, result);
     } catch (error) {
-      logger.debug(error)
-      this.respondText(response, error, 422)
+      logger.debug(error);
+      this.respondText(response, error, 422);
     }
   }
 
   public async getReleaseValues(request: LensApiRequest) {
-    const { cluster, params, response } = request
+    const { cluster, params, response } = request;
     try {
-      const result = await helmService.getReleaseValues(cluster, params.release, params.namespace)
-      this.respondText(response, result)
+      const result = await helmService.getReleaseValues(cluster, params.release, params.namespace);
+      this.respondText(response, result);
     } catch (error) {
-      logger.debug(error)
-      this.respondText(response, error, 422)
+      logger.debug(error);
+      this.respondText(response, error, 422);
     }
   }
 
   public async getReleaseHistory(request: LensApiRequest) {
-    const { cluster, params, response } = request
+    const { cluster, params, response } = request;
     try {
-      const result = await helmService.getReleaseHistory(cluster, params.release, params.namespace)
-      this.respondJson(response, result)
+      const result = await helmService.getReleaseHistory(cluster, params.release, params.namespace);
+      this.respondJson(response, result);
     } catch (error) {
-      logger.debug(error)
-      this.respondText(response, error, 422)
+      logger.debug(error);
+      this.respondText(response, error, 422);
     }
   }
 
   public async deleteRelease(request: LensApiRequest) {
-    const { cluster, params, response } = request
+    const { cluster, params, response } = request;
     try {
-      const result = await helmService.deleteRelease(cluster, params.release, params.namespace)
-      this.respondJson(response, result)
+      const result = await helmService.deleteRelease(cluster, params.release, params.namespace);
+      this.respondJson(response, result);
     } catch (error) {
-      logger.debug(error)
-      this.respondText(response, error, 422)
+      logger.debug(error);
+      this.respondText(response, error, 422);
     }
   }
 }
 
-export const helmRoute = new HelmApiRoute()
+export const helmRoute = new HelmApiRoute();

src/main/routes/index.ts

@@ -1,6 +1,6 @@
-export * from "./kubeconfig-route"
-export * from "./metrics-route"
-export * from "./port-forward-route"
-export * from "./watch-route"
-export * from "./helm-route"
-export * from "./resource-applier-route"
+export * from "./kubeconfig-route";
+export * from "./metrics-route";
+export * from "./port-forward-route";
+export * from "./watch-route";
+export * from "./helm-route";
+export * from "./resource-applier-route";

src/main/routes/kubeconfig-route.ts

@@ -1,10 +1,10 @@
-import { LensApiRequest } from "../router"
-import { LensApi } from "../lens-api"
-import { Cluster } from "../cluster"
-import { CoreV1Api, V1Secret } from "@kubernetes/client-node"
+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 = Buffer.from(secret.data["token"], "base64")
+  const tokenData = Buffer.from(secret.data["token"], "base64");
   return {
     'apiVersion': 'v1',
     'kind': 'Config',
@@ -36,23 +36,23 @@ function generateKubeConfig(username: string, secret: V1Secret, cluster: Cluster
       }
     ],
     'current-context': cluster.contextName
-  }
+  };
 }
 
 class KubeconfigRoute extends LensApi {
 
   public async routeServiceAccountRoute(request: LensApiRequest) {
-    const { params, response, cluster} = request
+    const { params, response, cluster} = request;
 
     const client = cluster.getProxyKubeconfig().makeApiClient(CoreV1Api);
-    const secretList = await client.listNamespacedSecret(params.namespace)
+    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)
+    this.respondJson(response, data);
   }
 }
 
-export const kubeconfigRoute = new KubeconfigRoute()
+export const kubeconfigRoute = new KubeconfigRoute();

src/main/routes/metrics-route.ts

@@ -1,32 +1,32 @@
-import { LensApiRequest } from "../router"
-import { LensApi } from "../lens-api"
-import { Cluster } from "../cluster"
-import _ from "lodash"
+import { LensApiRequest } from "../router";
+import { LensApi } from "../lens-api";
+import { Cluster } from "../cluster";
+import _ from "lodash";
 
 export type IMetricsQuery = string | string[] | {
   [metricName: string]: string;
 }
 
 // This is used for backoff retry tracking.
-const MAX_ATTEMPTS = 5
-const ATTEMPTS = [...(_.fill(Array(MAX_ATTEMPTS - 1), false)), true]
+const MAX_ATTEMPTS = 5;
+const ATTEMPTS = [...(_.fill(Array(MAX_ATTEMPTS - 1), false)), true];
 
 // prometheus metrics loader
 async function loadMetrics(promQueries: string[], cluster: Cluster, prometheusPath: string, queryParams: Record<string, string>): Promise<any[]> {
-  const queries = promQueries.map(p => p.trim())
-  const loaders = new Map<string, Promise<any>>()
+  const queries = promQueries.map(p => p.trim());
+  const loaders = new Map<string, Promise<any>>();
 
   async function loadMetric(query: string): Promise<any> {
     async function loadMetricHelper(): Promise<any> {
       for (const [attempt, lastAttempt] of ATTEMPTS.entries()) { // retry
         try {
-          return await cluster.getMetrics(prometheusPath, { query, ...queryParams })
+          return await cluster.getMetrics(prometheusPath, { query, ...queryParams });
         } catch (error) {
           if (lastAttempt || error?.statusCode === 404) {
             return {
               status: error.toString(),
               data: { result: [] },
-            }
+            };
           }
 
           await new Promise(resolve => setTimeout(resolve, (attempt + 1) * 1000)); // add delay before repeating request
@@ -34,41 +34,41 @@ async function loadMetrics(promQueries: string[], cluster: Cluster, prometheusPa
       }
     }
 
-    return loaders.get(query) ?? loaders.set(query, loadMetricHelper()).get(query)
+    return loaders.get(query) ?? loaders.set(query, loadMetricHelper()).get(query);
   }
 
-  return Promise.all(queries.map(loadMetric))
+  return Promise.all(queries.map(loadMetric));
 }
 
 class MetricsRoute extends LensApi {
   async routeMetrics({ response, cluster, payload, query }: LensApiRequest) {
-    const queryParams: IMetricsQuery = Object.fromEntries(query.entries())
+    const queryParams: IMetricsQuery = Object.fromEntries(query.entries());
 
     try {
       const [prometheusPath, prometheusProvider] = await Promise.all([
         cluster.contextHandler.getPrometheusPath(),
         cluster.contextHandler.getPrometheusProvider()
-      ])
+      ]);
 
       // return data in same structure as query
       if (typeof payload === "string") {
-        const [data] = await loadMetrics([payload], cluster, prometheusPath, queryParams)
-        this.respondJson(response, data)
+        const [data] = await loadMetrics([payload], cluster, prometheusPath, queryParams);
+        this.respondJson(response, data);
       } else if (Array.isArray(payload)) {
-        const data = await loadMetrics(payload, cluster, prometheusPath, queryParams)
-        this.respondJson(response, data)
+        const data = await loadMetrics(payload, cluster, prometheusPath, queryParams);
+        this.respondJson(response, data);
       } else {
         const queries = Object.entries(payload).map(([queryName, queryOpts]) => (
           (prometheusProvider.getQueries(queryOpts) as Record<string, string>)[queryName]
-        ))
-        const result = await loadMetrics(queries, cluster, prometheusPath, queryParams)
-        const data = Object.fromEntries(Object.keys(payload).map((metricName, i) => [metricName, result[i]]))
-        this.respondJson(response, data)
+        ));
+        const result = await loadMetrics(queries, cluster, prometheusPath, queryParams);
+        const data = Object.fromEntries(Object.keys(payload).map((metricName, i) => [metricName, result[i]]));
+        this.respondJson(response, data);
       }
     } catch {
-      this.respondJson(response, {})
+      this.respondJson(response, {});
     }
   }
 }
 
-export const metricsRoute = new MetricsRoute()
+export const metricsRoute = new MetricsRoute();

src/main/routes/port-forward-route.ts

@@ -1,11 +1,11 @@
-import { LensApiRequest } from "../router"
-import { LensApi } from "../lens-api"
-import { spawn, ChildProcessWithoutNullStreams } from "child_process"
-import { Kubectl } from "../kubectl"
-import { getFreePort } from "../port"
-import { shell } from "electron"
-import * as tcpPortUsed from "tcp-port-used"
-import logger from "../logger"
+import { LensApiRequest } from "../router";
+import { LensApi } from "../lens-api";
+import { spawn, ChildProcessWithoutNullStreams } from "child_process";
+import { Kubectl } from "../kubectl";
+import { getFreePort } from "../port";
+import { shell } from "electron";
+import * as tcpPortUsed from "tcp-port-used";
+import logger from "../logger";
 
 class PortForward {
   public static portForwards: PortForward[] = []
@@ -18,8 +18,8 @@ class PortForward {
         pf.name == forward.name &&
         pf.namespace == forward.namespace &&
         pf.port == forward.port
-      )
-    })
+      );
+    });
   }
 
   public clusterId: string
@@ -32,56 +32,56 @@ class PortForward {
   public localPort: number
 
   constructor(obj: any) {
-    Object.assign(this, obj)
+    Object.assign(this, obj);
   }
 
   public async start() {
-    this.localPort = await getFreePort()
-    const kubectlBin = await Kubectl.bundled().getPath()
+    this.localPort = await getFreePort();
+    const kubectlBin = await Kubectl.bundled().getPath();
     const args = [
       "--kubeconfig", this.kubeConfig,
       "port-forward",
       "-n", this.namespace,
       `${this.kind}/${this.name}`,
       `${this.localPort}:${this.port}`
-    ]
+    ];
 
     this.process = spawn(kubectlBin, args, {
       env: process.env
-    })
-    PortForward.portForwards.push(this)
+    });
+    PortForward.portForwards.push(this);
     this.process.on("exit", () => {
-      const index = PortForward.portForwards.indexOf(this)
+      const index = PortForward.portForwards.indexOf(this);
       if (index > -1) {
-        PortForward.portForwards.splice(index, 1)
+        PortForward.portForwards.splice(index, 1);
       }
-    })
+    });
     try {
-      await tcpPortUsed.waitUntilUsed(this.localPort, 500, 15000)
-      return true
+      await tcpPortUsed.waitUntilUsed(this.localPort, 500, 15000);
+      return true;
     } catch (error) {
-      this.process.kill()
-      return false
+      this.process.kill();
+      return false;
     }
   }
 
   public open() {
-    shell.openExternal(`http://localhost:${this.localPort}`)
+    shell.openExternal(`http://localhost:${this.localPort}`);
   }
 }
 
 class PortForwardRoute extends LensApi {
 
   public async routePortForward(request: LensApiRequest) {
-    const { params, response, cluster} = request
-    const { namespace, port, resourceType, resourceName } = params
+    const { params, response, cluster} = request;
+    const { namespace, port, resourceType, resourceName } = params;
 
     let portForward = PortForward.getPortforward({
       clusterId: cluster.id, kind: resourceType, name: resourceName,
       namespace: namespace, port: port
-    })
+    });
     if (!portForward) {
-      logger.info(`Creating a new port-forward ${namespace}/${resourceType}/${resourceName}:${port}`)
+      logger.info(`Creating a new port-forward ${namespace}/${resourceType}/${resourceName}:${port}`);
       portForward = new PortForward({
         clusterId: cluster.id,
         kind: resourceType,
@@ -89,20 +89,20 @@ class PortForwardRoute extends LensApi {
         name: resourceName,
         port: port,
         kubeConfig: cluster.getProxyKubeconfigPath()
-      })
-      const started = await portForward.start()
+      });
+      const started = await portForward.start();
       if (!started) {
         this.respondJson(response, {
           message: "Failed to open port-forward"
-        }, 400)
-        return
+        }, 400);
+        return;
       }
     }
 
-    portForward.open()
+    portForward.open();
 
-    this.respondJson(response, {})
+    this.respondJson(response, {});
   }
 }
 
-export const portForwardRoute = new PortForwardRoute()
+export const portForwardRoute = new PortForwardRoute();

src/main/routes/resource-applier-route.ts

@@ -1,17 +1,17 @@
-import { LensApiRequest } from "../router"
-import { LensApi } from "../lens-api"
-import { ResourceApplier } from "../resource-applier"
+import { LensApiRequest } from "../router";
+import { LensApi } from "../lens-api";
+import { ResourceApplier } from "../resource-applier";
 
 class ResourceApplierApiRoute extends LensApi {
   public async applyResource(request: LensApiRequest) {
-    const { response, cluster, payload } = request
+    const { response, cluster, payload } = request;
     try {
       const resource = await new ResourceApplier(cluster).apply(payload);
-      this.respondJson(response, [resource], 200)
+      this.respondJson(response, [resource], 200);
     } catch (error) {
-      this.respondText(response, error, 422)
+      this.respondText(response, error, 422);
     }
   }
 }
 
-export const resourceApplierRoute = new ResourceApplierApiRoute()
+export const resourceApplierRoute = new ResourceApplierApiRoute();

src/main/routes/watch-route.ts

@@ -1,9 +1,9 @@
-import { LensApiRequest } from "../router"
-import { LensApi } from "../lens-api"
-import { Watch, KubeConfig } from "@kubernetes/client-node"
-import { ServerResponse } from "http"
-import { Request } from "request"
-import logger from "../logger"
+import { LensApiRequest } from "../router";
+import { LensApi } from "../lens-api";
+import { Watch, KubeConfig } from "@kubernetes/client-node";
+import { ServerResponse } from "http";
+import { Request } from "request";
+import logger from "../logger";
 
 class ApiWatcher {
   private apiUrl: string
@@ -14,40 +14,40 @@ class ApiWatcher {
   private eventBuffer: any[] = []
 
   constructor(apiUrl: string, kubeConfig: KubeConfig, response: ServerResponse) {
-    this.apiUrl = apiUrl
-    this.watch = new Watch(kubeConfig)
-    this.response = response
+    this.apiUrl = apiUrl;
+    this.watch = new Watch(kubeConfig);
+    this.response = response;
   }
 
   public async start() {
     if (this.processor) {
-      clearInterval(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 = await this.watch.watch(this.apiUrl, {}, this.watchHandler.bind(this), this.doneHandler.bind(this))
+      const events = this.eventBuffer.splice(0);
+      events.map(event => this.sendEvent(event));
+      this.response.flushHeaders();
+    }, 50);
+    this.watchRequest = await this.watch.watch(this.apiUrl, {}, this.watchHandler.bind(this), this.doneHandler.bind(this));
   }
 
   public stop() {
-    if (!this.watchRequest) { return }
+    if (!this.watchRequest) { return; }
 
     if (this.processor) {
-      clearInterval(this.processor)
+      clearInterval(this.processor);
     }
-    logger.debug("Stopping watcher for api: " + this.apiUrl)
+    logger.debug("Stopping watcher for api: " + this.apiUrl);
     try {
-      this.watchRequest.abort()
+      this.watchRequest.abort();
       this.sendEvent({
         type: "STREAM_END",
         url: this.apiUrl,
         status: 410,
-      })
-      logger.debug("watch aborted")
+      });
+      logger.debug("watch aborted");
     } catch (error) {
-      logger.error("Watch abort errored:" + error)
+      logger.error("Watch abort errored:" + error);
     }
   }
 
@@ -55,12 +55,12 @@ class ApiWatcher {
     this.eventBuffer.push({
       type: phase,
       object: obj
-    })
+    });
   }
 
   private doneHandler(error: Error) {
-    if (error) logger.warn("watch ended: " + error.toString())
-    this.watchRequest.abort()
+    if (error) logger.warn("watch ended: " + error.toString());
+    this.watchRequest.abort();
   }
 
   private sendEvent(evt: any) {
@@ -72,40 +72,40 @@ class ApiWatcher {
 class WatchRoute extends LensApi {
 
   public async routeWatch(request: LensApiRequest) {
-    const { params, response, cluster} = request
-    const apis: string[] = request.query.getAll("api")
-    const watchers: ApiWatcher[] = []
+    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
+      }, 400);
+      return;
     }
 
-    response.setHeader("Content-Type", "text/event-stream")
-    response.setHeader("Cache-Control", "no-cache")
-    response.setHeader("Connection", "keep-alive")
-    logger.debug("watch using kubeconfig:" + JSON.stringify(cluster.getProxyKubeconfig(), null, 2))
+    response.setHeader("Content-Type", "text/event-stream");
+    response.setHeader("Cache-Control", "no-cache");
+    response.setHeader("Connection", "keep-alive");
+    logger.debug("watch using kubeconfig:" + JSON.stringify(cluster.getProxyKubeconfig(), null, 2));
 
     apis.forEach(apiUrl => {
-      const watcher = new ApiWatcher(apiUrl, cluster.getProxyKubeconfig(), response)
-      watcher.start()
-      watchers.push(watcher)
-    })
+      const watcher = new ApiWatcher(apiUrl, cluster.getProxyKubeconfig(), response);
+      watcher.start();
+      watchers.push(watcher);
+    });
 
     request.raw.req.on("close", () => {
-      logger.debug("Watch request closed")
-      watchers.map(watcher => watcher.stop())
-    })
+      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())
-    })
+      logger.debug("Watch request ended");
+      watchers.map(watcher => watcher.stop());
+    });
 
   }
 }
 
-export const watchRoute = new WatchRoute()
+export const watchRoute = new WatchRoute();