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

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

src/main/helm/helm-chart-manager.ts

@@ -20,32 +20,39 @@ export class HelmChartManager {
 
   public async chart(name: string) {
     const charts = await this.charts();
+
     return charts[name];
   }
 
   public async charts(): Promise<any> {
     try {
       const cachedYaml = await this.cachedYaml();
+
       return cachedYaml["entries"];
     } catch(error) {
       logger.error(error);
+
       return [];
     }
   }
 
   public async getReadme(name: string, version = "") {
     const helm = await helmCli.binaryPath();
+
     if(version && version != "") {
       const { stdout } = await promiseExec(`"${helm}" show readme ${this.repo.name}/${name} --version ${version}`).catch((error) => { throw(error.stderr);});
+
       return stdout;
     } else {
       const { stdout } = await promiseExec(`"${helm}" show readme ${this.repo.name}/${name}`).catch((error) => { throw(error.stderr);});
+
       return stdout;
     }
   }
 
   public async getValues(name: string, version = "") {
     const helm = await helmCli.binaryPath();
+
     if(version && version != "") {
       const { stdout } = await promiseExec(`"${helm}" show values ${this.repo.name}/${name} --version ${version}`).catch((error) => { throw(error.stderr);});
 
@@ -61,6 +68,7 @@ export class HelmChartManager {
     if (!(this.repo.name in this.cache)) {
       const cacheFile = await fs.promises.readFile(this.repo.cacheFilePath, "utf-8");
       const data = yaml.safeLoad(cacheFile);
+
       for(const key in data["entries"]) {
         data["entries"][key].forEach((version: any) => {
           version["repo"] = this.repo.name;
@@ -69,6 +77,7 @@ export class HelmChartManager {
       }
       this.cache[this.repo.name] = Buffer.from(JSON.stringify(data));
     }
+
     return JSON.parse(this.cache[this.repo.name].toString());
   }
 }

src/main/helm/helm-cli.ts

@@ -12,6 +12,7 @@ export class HelmCli extends LensBinary {
       originalBinaryName: "helm",
       newBinaryName: "helm3"
     };
+
     super(opts);
   }
 

src/main/helm/helm-release-manager.ts

@@ -12,14 +12,15 @@ export class HelmReleaseManager {
     const helm = await helmCli.binaryPath();
     const namespaceFlag = namespace ? `-n ${namespace}` : "--all-namespaces";
     const { stdout } = await promiseExec(`"${helm}" ls --output json ${namespaceFlag} --kubeconfig ${pathToKubeconfig}`).catch((error) => { throw(error.stderr);});
-
     const output = JSON.parse(stdout);
+
     if (output.length == 0) {
       return output;
     }
     output.forEach((release: any, index: number) => {
       output[index] = toCamelCase(release);
     });
+
     return output;
   }
 
@@ -27,15 +28,19 @@ export class HelmReleaseManager {
   public async installChart(chart: string, values: any, name: string, namespace: string, version: string, pathToKubeconfig: string){
     const helm = await helmCli.binaryPath();
     const fileName = tempy.file({name: "values.yaml"});
+
     await fs.promises.writeFile(fileName, yaml.safeDump(values));
+
     try {
       let generateName = "";
+
       if (!name) {
         generateName = "--generate-name";
         name = "";
       }
       const { stdout } = await promiseExec(`"${helm}" install ${name} ${chart} --version ${version} -f ${fileName} --namespace ${namespace} --kubeconfig ${pathToKubeconfig} ${generateName}`).catch((error) => { throw(error.stderr);});
       const releaseName = stdout.split("\n")[0].split(" ")[1].trim();
+
       return {
         log: stdout,
         release: {
@@ -51,10 +56,12 @@ export class HelmReleaseManager {
   public async upgradeRelease(name: string, chart: string, values: any, namespace: string, version: string, cluster: Cluster){
     const helm = await helmCli.binaryPath();
     const fileName = tempy.file({name: "values.yaml"});
+
     await fs.promises.writeFile(fileName, yaml.safeDump(values));
 
     try {
       const { stdout } = await promiseExec(`"${helm}" upgrade ${name} ${chart} --version ${version} -f ${fileName} --namespace ${namespace} --kubeconfig ${cluster.getProxyKubeconfigPath()}`).catch((error) => { throw(error.stderr);});
+
       return {
         log: stdout,
         release: this.getRelease(name, namespace, cluster)
@@ -68,7 +75,9 @@ export class HelmReleaseManager {
     const helm = await helmCli.binaryPath();
     const { stdout } = await promiseExec(`"${helm}" status ${name} --output json --namespace ${namespace} --kubeconfig ${cluster.getProxyKubeconfigPath()}`).catch((error) => { throw(error.stderr);});
     const release = JSON.parse(stdout);
+
     release.resources = await this.getResources(name, namespace, cluster);
+
     return release;
   }
 
@@ -82,18 +91,21 @@ export class HelmReleaseManager {
   public async getValues(name: string, namespace: string, pathToKubeconfig: string) {
     const helm = await helmCli.binaryPath();
     const { stdout,  } = await promiseExec(`"${helm}" get values ${name} --all --output yaml --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`).catch((error) => { throw(error.stderr);});
+
     return stdout;
   }
 
   public async getHistory(name: string, namespace: string, pathToKubeconfig: string) {
     const helm = await helmCli.binaryPath();
     const { stdout } = await promiseExec(`"${helm}" history ${name} --output json --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`).catch((error) => { throw(error.stderr);});
+
     return JSON.parse(stdout);
   }
 
   public async rollback(name: string, namespace: string, revision: number, pathToKubeconfig: string) {
     const helm = await helmCli.binaryPath();
     const { stdout } = await promiseExec(`"${helm}" rollback ${name} ${revision} --namespace ${namespace} --kubeconfig ${pathToKubeconfig}`).catch((error) => { throw(error.stderr);});
+
     return stdout;
   }
 
@@ -104,6 +116,7 @@ export class HelmReleaseManager {
     const { stdout } = await promiseExec(`"${helm}" get manifest ${name} --namespace ${namespace} --kubeconfig ${pathToKubeconfig} | "${kubectl}" get -n ${namespace} --kubeconfig ${pathToKubeconfig} -f - -o=json`).catch(() => {
       return { stdout: JSON.stringify({items: []})};
     });
+
     return stdout;
   }
 }

src/main/helm/helm-repo-manager.ts

@@ -42,12 +42,14 @@ export class HelmRepoManager extends Singleton {
       resolveWithFullResponse: true,
       timeout: 10000,
     });
+
     return orderBy<HelmRepo>(res.body, repo => repo.name);
   }
 
   async init() {
     helmCli.setLogger(logger);
     await helmCli.ensureBinary();
+
     if (!this.initialized) {
       this.helmEnv = await this.parseHelmEnv();
       await this.update();
@@ -62,12 +64,15 @@ export class HelmRepoManager extends Singleton {
     });
     const lines = stdout.split(/\r?\n/); // split by new line feed
     const env: HelmEnv = {};
+
     lines.forEach((line: string) => {
       const [key, value] = line.split("=");
+
       if (key && value) {
         env[key] = value.replace(/"/g, ""); // strip quotas
       }
     });
+
     return env;
   }
 
@@ -75,6 +80,7 @@ export class HelmRepoManager extends Singleton {
     if (!this.initialized) {
       await this.init();
     }
+
     try {
       const repoConfigFile = this.helmEnv.HELM_REPOSITORY_CONFIG;
       const { repositories }: HelmRepoConfig = await readFile(repoConfigFile, "utf8")
@@ -82,22 +88,27 @@ export class HelmRepoManager extends Singleton {
         .catch(() => ({
           repositories: []
         }));
+
       if (!repositories.length) {
         await this.addRepo({ name: "bitnami", url: "https://charts.bitnami.com/bitnami" });
+
         return await this.repositories();
       }
+
       return repositories.map(repo => ({
         ...repo,
         cacheFilePath: `${this.helmEnv.HELM_REPOSITORY_CACHE}/${repo.name}-index.yaml`
       }));
     } catch (error) {
       logger.error(`[HELM]: repositories listing error "${error}"`);
+
       return [];
     }
   }
 
   public async repository(name: string) {
     const repositories = await this.repositories();
+
     return repositories.find(repo => repo.name == name);
   }
 
@@ -106,6 +117,7 @@ export class HelmRepoManager extends Singleton {
     const { stdout } = await promiseExec(`"${helm}" repo update`).catch((error) => {
       return { stdout: error.stdout };
     });
+
     return stdout;
   }
 
@@ -115,6 +127,7 @@ export class HelmRepoManager extends Singleton {
     const { stdout } = await promiseExec(`"${helm}" repo add ${name} ${url}`).catch((error) => {
       throw(error.stderr);
     });
+
     return stdout;
   }
 
@@ -124,6 +137,7 @@ export class HelmRepoManager extends Singleton {
     const { stdout } = await promiseExec(`"${helm}" repo remove ${name}`).catch((error) => {
       throw(error.stderr);
     });
+
     return stdout;
   }
 }

src/main/helm/helm-service.ts

@@ -11,18 +11,23 @@ class HelmService {
 
   public async listCharts() {
     const charts: any = {};
+
     await repoManager.init();
     const repositories = await repoManager.repositories();
+
     for (const repo of repositories) {
       charts[repo.name] = {};
       const manager = new HelmChartManager(repo);
       let entries = await manager.charts();
+
       entries = this.excludeDeprecated(entries);
+
       for (const key in entries) {
         entries[key] = entries[key][0];
       }
       charts[repo.name] = entries;
     }
+
     return charts;
   }
 
@@ -34,50 +39,60 @@ class HelmService {
     const repo = await repoManager.repository(repoName);
     const chartManager = new HelmChartManager(repo);
     const chart = await chartManager.chart(chartName);
+
     result.readme = await chartManager.getReadme(chartName, version);
     result.versions = chart;
+
     return result;
   }
 
   public async getChartValues(repoName: string, chartName: string, version = "") {
     const repo = await repoManager.repository(repoName);
     const chartManager = new HelmChartManager(repo);
+
     return chartManager.getValues(chartName, version);
   }
 
   public async listReleases(cluster: Cluster, namespace: string = null) {
     await repoManager.init();
+
     return await releaseManager.listReleases(cluster.getProxyKubeconfigPath(), namespace);
   }
 
   public async getRelease(cluster: Cluster, releaseName: string, namespace: string) {
     logger.debug("Fetch release");
+
     return await releaseManager.getRelease(releaseName, namespace, cluster);
   }
 
   public async getReleaseValues(cluster: Cluster, releaseName: string, namespace: string) {
     logger.debug("Fetch release values");
+
     return await releaseManager.getValues(releaseName, namespace, cluster.getProxyKubeconfigPath());
   }
 
   public async getReleaseHistory(cluster: Cluster, releaseName: string, namespace: string) {
     logger.debug("Fetch release history");
+
     return await releaseManager.getHistory(releaseName, namespace, cluster.getProxyKubeconfigPath());
   }
 
   public async deleteRelease(cluster: Cluster, releaseName: string, namespace: string) {
     logger.debug("Delete release");
+
     return await releaseManager.deleteRelease(releaseName, namespace, cluster.getProxyKubeconfigPath());
   }
 
   public async updateRelease(cluster: Cluster, releaseName: string, namespace: string, data: { chart: string; values: {}; version: string }) {
     logger.debug("Upgrade release");
+
     return await releaseManager.upgradeRelease(releaseName, data.chart, data.values, namespace, data.version, cluster);
   }
 
   public async rollback(cluster: Cluster, releaseName: string, namespace: string, revision: number) {
     logger.debug("Rollback release");
     const output = await releaseManager.rollback(releaseName, namespace, revision, cluster.getProxyKubeconfigPath());
+
     return { message: output };
   }
 
@@ -87,9 +102,11 @@ class HelmService {
         if (Array.isArray(entry)) {
           return entry[0]["deprecated"] != true;
         }
+
         return entry["deprecated"] != true;
       });
     }
+
     return entries;
   }