Add eslint rule padding-line-between-statements (#1593)

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

src/main/routes/helm-route.ts

@@ -7,13 +7,16 @@ class HelmApiRoute extends LensApi {
   public async listCharts(request: LensApiRequest) {
     const { response } = request;
     const charts = await helmService.listCharts();
+
     this.respondJson(response, charts);
   }
 
   public async getChart(request: LensApiRequest) {
     const { params, query, response } = request;
+
     try {
       const chart = await helmService.getChart(params.repo, params.chart, query.get("version"));
+
       this.respondJson(response, chart);
     } catch (error) {
       this.respondText(response, error, 422);
@@ -22,8 +25,10 @@ class HelmApiRoute extends LensApi {
 
   public async getChartValues(request: LensApiRequest) {
     const { params, query, response } = request;
+
     try {
       const values = await helmService.getChartValues(params.repo, params.chart, query.get("version"));
+
       this.respondJson(response, values);
     } catch (error) {
       this.respondText(response, error, 422);
@@ -32,8 +37,10 @@ class HelmApiRoute extends LensApi {
 
   public async installChart(request: LensApiRequest) {
     const { payload, cluster, response } = request;
+
     try {
       const result = await helmService.installChart(cluster, payload);
+
       this.respondJson(response, result, 201);
     } catch (error) {
       logger.debug(error);
@@ -43,8 +50,10 @@ class HelmApiRoute extends LensApi {
 
   public async updateRelease(request: LensApiRequest) {
     const { cluster, params, payload, response } = request;
+
     try {
       const result = await helmService.updateRelease(cluster, params.release, params.namespace, payload );
+
       this.respondJson(response, result);
     } catch (error) {
       logger.debug(error);
@@ -54,8 +63,10 @@ class HelmApiRoute extends LensApi {
 
   public async rollbackRelease(request: LensApiRequest) {
     const { cluster, params, payload, response } = request;
+
     try {
       const result = await helmService.rollback(cluster, params.release, params.namespace, payload.revision);
+
       this.respondJson(response, result);
     } catch (error) {
       logger.debug(error);
@@ -65,8 +76,10 @@ class HelmApiRoute extends LensApi {
 
   public async listReleases(request: LensApiRequest) {
     const { cluster, params, response } = request;
+
     try {
       const result = await helmService.listReleases(cluster, params.namespace);
+
       this.respondJson(response, result);
     } catch(error) {
       logger.debug(error);
@@ -76,8 +89,10 @@ class HelmApiRoute extends LensApi {
 
   public async getRelease(request: LensApiRequest) {
     const { cluster, params, response } = request;
+
     try {
       const result = await helmService.getRelease(cluster, params.release, params.namespace);
+
       this.respondJson(response, result);
     } catch (error) {
       logger.debug(error);
@@ -87,8 +102,10 @@ class HelmApiRoute extends LensApi {
 
   public async getReleaseValues(request: LensApiRequest) {
     const { cluster, params, response } = request;
+
     try {
       const result = await helmService.getReleaseValues(cluster, params.release, params.namespace);
+
       this.respondText(response, result);
     } catch (error) {
       logger.debug(error);
@@ -98,8 +115,10 @@ class HelmApiRoute extends LensApi {
 
   public async getReleaseHistory(request: LensApiRequest) {
     const { cluster, params, response } = request;
+
     try {
       const result = await helmService.getReleaseHistory(cluster, params.release, params.namespace);
+
       this.respondJson(response, result);
     } catch (error) {
       logger.debug(error);
@@ -109,8 +128,10 @@ class HelmApiRoute extends LensApi {
 
   public async deleteRelease(request: LensApiRequest) {
     const { cluster, params, response } = request;
+
     try {
       const result = await helmService.deleteRelease(cluster, params.release, params.namespace);
+
       this.respondJson(response, result);
     } catch (error) {
       logger.debug(error);

src/main/routes/kubeconfig-route.ts

@@ -5,6 +5,7 @@ import { CoreV1Api, V1Secret } from "@kubernetes/client-node";
 
 function generateKubeConfig(username: string, secret: V1Secret, cluster: Cluster) {
   const tokenData = Buffer.from(secret.data["token"], "base64");
+
   return {
     "apiVersion": "v1",
     "kind": "Config",
@@ -43,14 +44,15 @@ class KubeconfigRoute extends LensApi {
 
   public async routeServiceAccountRoute(request: LensApiRequest) {
     const { params, response, cluster} = request;
-
     const client = cluster.getProxyKubeconfig().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);
   }
 }

src/main/routes/metrics-route.ts

@@ -44,24 +44,31 @@ class MetricsRoute extends LensApi {
   async routeMetrics({ response, cluster, payload, query }: LensApiRequest) {
     const queryParams: IMetricsQuery = Object.fromEntries(query.entries());
     const prometheusMetadata: ClusterPrometheusMetadata = {};
+
     try {
       const [prometheusPath, prometheusProvider] = await Promise.all([
         cluster.contextHandler.getPrometheusPath(),
         cluster.contextHandler.getPrometheusProvider()
       ]);
+
       prometheusMetadata.provider = prometheusProvider?.id;
       prometheusMetadata.autoDetected = !cluster.preferences.prometheusProvider?.type;
+
       if (!prometheusPath) {
         prometheusMetadata.success = false;
         this.respondJson(response, {});
+
         return;
       }
+
       // return data in same structure as query
       if (typeof payload === "string") {
         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);
       } else {
         const queries = Object.entries(payload).map(([queryName, queryOpts]) => (
@@ -69,6 +76,7 @@ class MetricsRoute extends LensApi {
         ));
         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);
       }
       prometheusMetadata.success = true;

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

@@ -52,15 +52,19 @@ class PortForward {
     PortForward.portForwards.push(this);
     this.process.on("exit", () => {
       const index = PortForward.portForwards.indexOf(this);
+
       if (index > -1) {
         PortForward.portForwards.splice(index, 1);
       }
     });
+
     try {
       await tcpPortUsed.waitUntilUsed(this.localPort, 500, 15000);
+
       return true;
     } catch (error) {
       this.process.kill();
+
       return false;
     }
   }
@@ -75,11 +79,11 @@ class PortForwardRoute extends LensApi {
   public async routePortForward(request: LensApiRequest) {
     const { params, response, cluster} = request;
     const { namespace, port, resourceType, resourceName } = params;
-
     let portForward = PortForward.getPortforward({
       clusterId: cluster.id, kind: resourceType, name: resourceName,
       namespace, port
     });
+
     if (!portForward) {
       logger.info(`Creating a new port-forward ${namespace}/${resourceType}/${resourceName}:${port}`);
       portForward = new PortForward({
@@ -91,10 +95,12 @@ class PortForwardRoute extends LensApi {
         kubeConfig: cluster.getProxyKubeconfigPath()
       });
       const started = await portForward.start();
+
       if (!started) {
         this.respondJson(response, {
           message: "Failed to open port-forward"
         }, 400);
+
         return;
       }
     }

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

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

src/main/routes/watch-route.ts

@@ -25,6 +25,7 @@ class ApiWatcher {
     }
     this.processor = setInterval(() => {
       const events = this.eventBuffer.splice(0);
+
       events.map(event => this.sendEvent(event));
       this.response.flushHeaders();
     }, 50);
@@ -38,6 +39,7 @@ class ApiWatcher {
       clearInterval(this.processor);
     }
     logger.debug(`Stopping watcher for api: ${this.apiUrl}`);
+
     try {
       this.watchRequest.abort();
       this.sendEvent({
@@ -81,6 +83,7 @@ class WatchRoute extends LensApi {
         message: "Empty request. Query params 'api' are not provided.",
         example: "?api=/api/v1/pods&api=/api/v1/nodes",
       }, 400);
+
       return;
     }
 
@@ -91,6 +94,7 @@ class WatchRoute extends LensApi {
 
     apis.forEach(apiUrl => {
       const watcher = new ApiWatcher(apiUrl, cluster.getProxyKubeconfig(), response);
+
       watcher.start();
       watchers.push(watcher);
     });