Lens restructure (#540)

Signed-off-by: Roman <ixrock@gmail.com>

src/renderer/_vue/App.vue

@@ -1,7 +1,7 @@
 <template>
   <div id="app">
-    <div class="draggable-top" />
     <div id="lens-container" />
+    <div class="draggable-top" />
     <div class="main-view" :class="{ 'menu-visible': isMenuVisible }">
       <main-menu v-if="isMenuVisible" />
       <router-view />
@@ -11,27 +11,28 @@
 </template>
 
 <script>
-import MainMenu from "@/components/MainMenu/MainMenu";
-import BottomBar from "@/components/BottomBar/BottomBar";
+import MainMenu from "@/_vue/components/MainMenu/MainMenu";
+import BottomBar from "@/_vue/components/BottomBar/BottomBar";
+
 export default {
   name: 'Lens',
   components: {
     BottomBar,
     MainMenu
   },
-  computed:{
-    isMenuVisible: function(){ return this.$store.getters.isMenuVisible }
+  computed: {
+    isMenuVisible: function () { return this.$store.getters.isMenuVisible }
   }
 }
 </script>
-<style>
-#lens-container {
-  position: absolute;
-  top: 0;
-  left: 70px;
-  right: 0;
-  height: 100%;
-  z-index: 100;
-  display: none;
-}
-</style>
+
+<style scoped>
+  .draggable-top {
+    -webkit-app-region: drag;
+    left: 0;
+    top: 0;
+    position: absolute;
+    height: 20px;
+    width: 100%;
+  }
+</style>

src/renderer/_vue/assets/css/app.scss

@@ -1,11 +1,12 @@
+@import "custom";
+@import "~typeface-roboto/index.css";
+@import "~material-design-icons/iconfont/material-icons.css";
+@import "~bootstrap/scss/bootstrap";
+@import "~bootstrap-vue/src/index";
+@import "~prismjs/themes/prism-tomorrow.css";
+@import "~vue-prism-editor/dist/VuePrismEditor.css";
 
-@import 'custom.scss';
-@import '~bootstrap/scss/bootstrap';
-@import '~bootstrap-vue/src/index.scss';
-
-@import 'fonts.scss';
-
-html, body{
+html, body {
   margin: 0;
   padding: 0;
   width: 100%;
@@ -24,7 +25,7 @@ pre {
   color: $lens-text-color-light;
 }
 
-#app{
+#app {
   width: 100%;
   height: 100%;
   & > .main-view{
@@ -56,15 +57,6 @@ pre {
   }
 }
 
-.draggable-top{
-  -webkit-app-region: drag;
-  left: 0;
-  top: 0;
-  position: absolute;
-  height: 20px;
-  width: 100%;
-}
-
 ::-webkit-scrollbar {
   width: 12px;
 
@@ -202,3 +194,13 @@ h1, h2, h3, h4, h5, h6{
     font-size: 16px;
   }
 }
+
+#lens-container {
+  position: absolute;
+  top: 0;
+  left: 70px;
+  right: 0;
+  height: 100%;
+  z-index: 100;
+  display: none;
+}

src/renderer/_vue/components/AddClusterPage.vue

@@ -111,8 +111,8 @@
 <script>
 import * as PrismEditor from 'vue-prism-editor'
 import * as k8s from "@kubernetes/client-node"
-import { dumpConfigYaml } from "../../main/k8s"
-import ClustersMixin from "@/mixins/ClustersMixin";
+import { dumpConfigYaml } from "../../../main/k8s"
+import ClustersMixin from "@/_vue/mixins/ClustersMixin";
 
 class ClusterAccessError extends Error {}
 

src/renderer/_vue/components/AddWorkspacePage.vue

@@ -49,7 +49,7 @@
 
 <script>
 import { v4 as uuid } from "uuid";
-import ClosePageButton from "@/components/common/ClosePageButton";
+import ClosePageButton from "@/_vue/components/common/ClosePageButton";
 
 export default {
   name: 'AddWorkspacePage',

src/renderer/_vue/components/ClusterPage.vue

@@ -26,7 +26,7 @@
 </template>
 
 <script>
-import CubeSpinner from "@/components/CubeSpinner";
+import CubeSpinner from "@/_vue/components/CubeSpinner";
 import { remote, shell } from 'electron';
 export default {
   name: "ClusterPage",

src/renderer/_vue/components/ClusterSettings/Preferences/index.vue

@@ -70,7 +70,7 @@
 
 <script>
 import { lstatSync } from "fs"
-import { prometheusProviders } from '../../../../common/prometheus-providers';
+import { prometheusProviders } from '../../../../../common/prometheus-providers';
 
 export default {
   name: 'ClusterSettingsPreferences',

src/renderer/_vue/components/ClusterSettings/index.vue

@@ -39,13 +39,13 @@
 </template>
 
 <script>
-import CubeSpinner from "@/components/CubeSpinner";
-import ClusterSettingsGeneral from "./General";
-import ClusterSettingsOverview from "./Overview";
-import ClusterSettingsPreferences from "./Preferences";
-import ClusterSettingsFeatures from "./Features";
+import CubeSpinner from "@/_vue/components/CubeSpinner";
+import ClusterSettingsGeneral from "./General/index";
+import ClusterSettingsOverview from "./Overview/index";
+import ClusterSettingsPreferences from "./Preferences/index";
+import ClusterSettingsFeatures from "./Features/index";
 import hashicon from "../hashicon/hashicon";
-import ClosePageButton from "@/components/common/ClosePageButton";
+import ClosePageButton from "@/_vue/components/common/ClosePageButton";
 
 export default {
   name: 'ClusterSettingsPage',

src/renderer/_vue/components/EditWorkspacePage.vue

@@ -54,7 +54,7 @@
 </template>
 
 <script>
-import ClosePageButton from "@/components/common/ClosePageButton";
+import ClosePageButton from "@/_vue/components/common/ClosePageButton";
 
 export default {
   name: 'EditWorkspacePage',

src/renderer/_vue/components/MainMenu/AddClusterMenuItem.vue

@@ -17,7 +17,7 @@
 </template>
 
 <script>
-import ClustersMixin from "@/mixins/ClustersMixin";
+import ClustersMixin from "@/_vue/mixins/ClustersMixin";
 import { newContexts } from '@kubernetes/client-node/dist/config_types';
 export default {
   name: "AddClusterMenuItem",

src/renderer/_vue/components/MainMenu/MainMenu.vue

@@ -19,14 +19,14 @@
 </template>
 
 <script>
-import ClusterMenuItem from "@/components/MainMenu/ClusterMenuItem";
-import AddClusterMenuItem from "@/components/MainMenu/AddClusterMenuItem";
+import ClusterMenuItem from "@/_vue/components/MainMenu/ClusterMenuItem";
+import AddClusterMenuItem from "@/_vue/components/MainMenu/AddClusterMenuItem";
 import draggable from 'vuedraggable'
-import { clusterStore } from "@/../common/cluster-store";
-import * as os from "os";
+import { clusterStore } from "../../../../common/cluster-store"
+import { isMac } from "../../../../common/vars"
 
-const { remote } = require('electron')
-const { Menu, MenuItem } = remote
+const {remote} = require('electron')
+const {Menu, MenuItem} = remote
 
 export default {
   name: "MainMenu",
@@ -35,30 +35,27 @@ export default {
     AddClusterMenuItem,
     draggable
   },
-  data(){
+  data() {
     return {
       computedPaddingTop: "15px"
     }
   },
-  computed : {
-    menuAvailable: function(){
-      return this.$store.getters.isLoggedIn && this.$store.getters.isEulaAccepted
-    },
+  computed: {
     clusters: {
-      get: function() {
+      get: function () {
         return this.$store.getters.clusters;
       },
-      set: function(clusters) {
+      set: function (clusters) {
         this.$store.commit("updateClusters", clusters);
         clusterStore.storeClusters(clusters);
       }
     }
   },
   methods: {
-    isActive: function( id ){
+    isActive: function (id) {
       return id === this.$route.params.id;
     },
-    addCluster: async function(){
+    addCluster: async function () {
       this.$router.push({
         name: "add-cluster-page",
         params: {
@@ -67,8 +64,8 @@ export default {
       }).catch(err => {})
     }
   },
-  mounted: function() {
-    if (os.platform() == "darwin") {
+  mounted: function () {
+    if (isMac) {
       this.computedPaddingTop = "25px";
     }
   }
@@ -76,32 +73,36 @@ export default {
 </script>
 
 <style scoped lang="scss">
-.main-menu {
-  position: absolute;
-  left: 0;
-  top: 0;
-  bottom: 20px;
-  width: 70px;
-  padding-top: 15px;
-  background: #252729;
-  overflow: hidden;
-  z-index: 1000;
-}
-.menu-item {
-  position: relative;
-  cursor: pointer;
-  display: block;
-  padding: 6px 15px 6px 15px;
-  color: #87909c;
-  opacity: 0.3;
-  &.active {
-    opacity: 1;
+  .main-menu {
+    position: absolute;
+    left: 0;
+    top: 0;
+    bottom: 20px;
+    width: 70px;
+    padding-top: 15px;
+    background: #252729;
+    overflow: hidden;
+    z-index: 1000;
   }
-  &.online {
-    opacity: 1;
+
+  .menu-item {
+    position: relative;
+    cursor: pointer;
+    display: block;
+    padding: 6px 15px 6px 15px;
+    color: #87909c;
+    opacity: 0.3;
+
+    &.active {
+      opacity: 1;
+    }
+
+    &.online {
+      opacity: 1;
+    }
+
+    &:hover {
+      opacity: 1;
+    }
   }
-  &:hover {
-    opacity: 1;
-  }
-}
 </style>

src/renderer/_vue/components/PreferencesPage.vue

@@ -135,9 +135,9 @@
 </template>
 
 <script>
-import * as request from 'request-promise-native'
-import { globalRequestOpts } from "../../common/request"
-import ClosePageButton from "@/components/common/ClosePageButton";
+import request from 'request-promise-native'
+import { globalRequestOpts } from "../../../common/request"
+import ClosePageButton from "@/_vue/components/common/ClosePageButton";
 
 export default {
   name: 'PreferencesPage',

src/renderer/_vue/components/WhatsNewPage.vue

@@ -28,16 +28,17 @@
 
 <script>
 import marked from 'marked'
-import fs from 'fs'
-import * as path from "path"
+import {readFileSync} from 'fs'
+import { getStaticPath } from "../../../common/register-static"
 
 export default {
   name: 'WhatsNewPage',
   data() {
+    let releaseNotes = getStaticPath("RELEASE_NOTES.md");
+    let content = marked(readFileSync(releaseNotes, 'utf8'));
     return {
       error: "",
-      // eslint-disable-next-line
-      content: marked(fs.readFileSync(path.join(__static, "RELEASE_NOTES.md"), 'utf8')),
+      content: content,
     }
   },
   components: {},

src/renderer/_vue/components/WorkspacesPage.vue

@@ -38,7 +38,7 @@
 </template>
 
 <script>
-import ClosePageButton from "@/components/common/ClosePageButton";
+import ClosePageButton from "@/_vue/components/common/ClosePageButton";
 export default {
   name: 'WorkspacesPage',
   components: {

src/renderer/_vue/index.js

@@ -0,0 +1,47 @@
+import "../../common/system-ca"
+import "./assets/css/app.scss"
+import "prismjs";
+import "prismjs/components/prism-yaml"
+import { remote } from "electron"
+import Vue from 'vue'
+import VueElectron from 'vue-electron'
+import BootstrapVue from 'bootstrap-vue'
+import { PromiseIpc } from 'electron-promise-ipc'
+import { Tracker } from "../../common/tracker"
+import App from './App'
+import router from './router'
+import store from './store'
+
+const tracker = new Tracker(remote.app);
+const promiseIpc = new PromiseIpc({maxTimeoutMs: 6000});
+
+promiseIpc.on('navigate', async (view) => {
+  router.push(view).catch(err => {})
+});
+
+Vue.config.productionTip = false
+Vue.use(VueElectron)
+Vue.use(BootstrapVue)
+
+Vue.mixin({
+  created: function () {
+    this.$promiseIpc = promiseIpc;
+    this.$tracker = tracker;
+  }
+})
+
+// any initialization we want to do for app state
+setTimeout(() => {
+  store.dispatch('init', ).catch((error) => {
+    console.error(error)
+  }).finally(() => {
+    /* eslint-disable no-new */
+    console.log("start vue")
+    new Vue({
+      components: { App },
+      store,
+      router,
+      template: '<App/>'
+    }).$mount('#app')
+  })
+}, 0)

src/renderer/_vue/router/index.js

@@ -1,70 +1,68 @@
 import Vue from 'vue'
 import Router from 'vue-router'
-import store from "../store/index.js";
+import store from "../store";
+import { whatsNew } from './routeguard'
 
-// Route Guard
-import * as guard from './routeguard'
-
-Vue.use(Router)
+Vue.use(Router);
 
 const router = new Router({
   routes: [
     {
       path: '/',
       name: 'landing-page',
-      component: require('@/components/LandingPage').default,
+      component: require('@/_vue/components/LandingPage').default,
       meta: {
         routeguard: [
           // guards in priority order; the first one to catch will trigger something
-          guard.whatsNew,
+          whatsNew,
         ],
       }
     },
     {
       path: '/preferences',
       name: 'preferences-page',
-      component: require('@/components/PreferencesPage').default,
+      component: require('@/_vue/components/PreferencesPage').default,
     },
     {
       path: '/workspaces',
       name: 'workspaces-page',
-      component: require('@/components/WorkspacesPage').default,
+      component: require('@/_vue/components/WorkspacesPage').default,
       props: true,
     },
     {
       path: '/add-workspace',
       name: 'add-workspace-page',
-      component: require('@/components/AddWorkspacePage').default,
+      component: require('@/_vue/components/AddWorkspacePage').default,
       props: true,
     },
     {
       path: '/edit-workspace',
       name: 'edit-workspace-page',
-      component: require('@/components/EditWorkspacePage').default,
+      component: require('@/_vue/components/EditWorkspacePage').default,
       props: true,
     },
     {
       path: '/clusters/:id',
       name: 'cluster-page',
-      component: require('@/components/ClusterPage').default,
+      component: require('@/_vue/components/ClusterPage').default,
       props: true,
     },
     {
       path: '/clusters/:id/settings',
       name: 'cluster-settings-page',
-      component: require('@/components/ClusterSettings').default,
+      component: require('@/_vue/components/ClusterSettings').default,
       props: true,
     },
     {
       path: "/add-cluster",
       name: "add-cluster-page",
-      component: require('@/components/AddClusterPage').default,
+      component: require('@/_vue/components/AddClusterPage').default,
       props: true,
     },
     {
       path: "/whats-new",
       name: "whats-new-page",
-      component: require('@/components/WhatsNewPage').default,
+      component: require('@/_vue/components/WhatsNewPage').default,
       props: true,
     },
     {

src/renderer/_vue/store/index.js

@@ -1,19 +1,19 @@
 import Vue from 'vue'
 import Vuex from 'vuex'
-import { userStore } from "../../common/user-store"
+import semver from "semver"
+import { userStore } from "../../../common/user-store"
+import { getAppVersion } from "../../../common/utils/app-version"
 import KubeContexts from './modules/kube-contexts'
 import Clusters from './modules/clusters'
 import HelmRepos from './modules/helm-repos'
 import Workspaces from './modules/workspaces'
-import * as semver from "semver"
-import * as appUtil from "../../common/app-utils"
 
 // promise ipc
 import { PromiseIpc } from 'electron-promise-ipc'
 const promiseIpc = new PromiseIpc( { maxTimeoutMs: 120000 } );
 
 // tracker
-import { Tracker } from "../../common/tracker"
+import { Tracker } from "../../../common/tracker"
 import { remote } from "electron"
 const tracker = new Tracker(remote.app);
 
@@ -77,7 +77,7 @@ export default new Vuex.Store({
     },
     async updateLastSeenAppVersion({commit, state}) {
       tracker.event("app", "whats-new-seen")
-      commit("updateLastSeenAppVersion", appUtil.getAppVersion())
+      commit("updateLastSeenAppVersion", getAppVersion())
     }
   },
   getters : {
@@ -87,7 +87,7 @@ export default new Vuex.Store({
       return state.hud.isMenuVisible && !getters.showWhatsNew;
     },
     showWhatsNew: function(state) {
-      return semver.gt(appUtil.getAppVersion(), state.lastSeenAppVersion);
+      return semver.gt(getAppVersion(), state.lastSeenAppVersion);
     },
     preferences: state => state.preferences,
   }

src/renderer/_vue/store/modules/clusters.ts

@@ -1,11 +1,11 @@
 import Vue from "vue"
-import { ClusterInfo } from "../../../main/cluster"
+import { ClusterInfo } from "../../../../main/cluster"
 import { MutationTree, ActionTree, GetterTree } from "vuex"
 import { PromiseIpc } from 'electron-promise-ipc'
-import { Tracker } from "../../../common/tracker"
+import { Tracker } from "../../../../common/tracker"
 import { remote } from "electron"
-import { clusterStore } from "../../../common/cluster-store"
-import { Workspace } from "../../../common/workspace-store"
+import { clusterStore } from "../../../../common/cluster-store"
+import { Workspace } from "../../../../common/workspace-store"
 
 const promiseIpc = new PromiseIpc( { maxTimeoutMs: 120000 } );
 const tracker = new Tracker(remote.app);
@@ -88,7 +88,7 @@ const actions: ActionTree<ClusterState, any>  = {
     await promiseIpc.send("removeCluster", cluster.id).catch((error: Error) => {
       return false;
     })
-    tracker.event("cluster", "remove´");
+    tracker.event("cluster", "remove");
     await dispatch("refreshClusters", getters.currentWorkspace)
     return true;
   },

src/renderer/_vue/store/modules/helm-repos.ts

@@ -1,6 +1,6 @@
 import Vue from "vue"
 import { MutationTree, ActionTree, GetterTree } from "vuex"
-import { HelmRepo, repoManager } from "../../../main/helm-repo-manager"
+import { HelmRepo, repoManager } from "../../../../main/helm-repo-manager"
 
 export interface HelmRepoState {
   repos: HelmRepo[];

src/renderer/_vue/store/modules/kube-contexts.js

@@ -1,5 +1,5 @@
 import * as k8s from "@kubernetes/client-node"
-import { splitConfig, dumpConfigYaml } from "../../../main/k8s"
+import { splitConfig, dumpConfigYaml } from "../../../../main/k8s"
 
 const state = {
   availableKubeContexts: []

src/renderer/_vue/store/modules/workspaces.ts

@@ -1,5 +1,5 @@
 import { MutationTree, ActionTree, GetterTree } from "vuex"
-import { workspaceStore, Workspace, WorkspaceData } from "../../../common/workspace-store"
+import { workspaceStore, Workspace, WorkspaceData } from "../../../../common/workspace-store"
 
 export interface WorkspaceState {
   workspaces: Array<Workspace>;

src/renderer/api/api-manager.ts

@@ -0,0 +1,74 @@
+import type { KubeObjectStore } from "../kube-object.store";
+import type { KubeObjectDetailsProps, KubeObjectListLayoutProps, KubeObjectMenuProps } from "../components/kube-object";
+import type React from "react";
+
+import { observable } from "mobx";
+import { autobind } from "../utils/autobind";
+import { KubeApi } from "./kube-api";
+
+export interface ApiComponents {
+  List?: React.ComponentType<KubeObjectListLayoutProps>;
+  Menu?: React.ComponentType<KubeObjectMenuProps>;
+  Details?: React.ComponentType<KubeObjectDetailsProps>;
+}
+
+@autobind()
+export class ApiManager {
+  private apis = observable.map<string, KubeApi>();
+  private stores = observable.map<KubeApi, KubeObjectStore>();
+  private views = observable.map<KubeApi, ApiComponents>();
+
+  getApi(pathOrCallback: string | ((api: KubeApi) => boolean)) {
+    if (typeof pathOrCallback === "string") {
+      return this.apis.get(pathOrCallback) || this.apis.get(KubeApi.parseApi(pathOrCallback).apiBase);
+    }
+
+    return Array.from(this.apis.values()).find(pathOrCallback);
+  }
+
+  registerApi(apiBase: string, api: KubeApi) {
+    if (!this.apis.has(apiBase)) {
+      this.apis.set(apiBase, api);
+    }
+  }
+
+  protected resolveApi(api: string | KubeApi): KubeApi {
+    if (typeof api === "string") return this.getApi(api)
+    return api;
+  }
+
+  unregisterApi(api: string | KubeApi) {
+    if (typeof api === "string") this.apis.delete(api);
+    else {
+      const apis = Array.from(this.apis.entries());
+      const entry = apis.find(entry => entry[1] === api);
+      if (entry) this.unregisterApi(entry[0]);
+    }
+  }
+
+  registerStore(api: KubeApi, store: KubeObjectStore) {
+    this.stores.set(api, store);
+  }
+
+  getStore(api: string | KubeApi): KubeObjectStore {
+    return this.stores.get(this.resolveApi(api));
+  }
+
+  registerViews(api: KubeApi | KubeApi[], views: ApiComponents) {
+    if (Array.isArray(api)) {
+      api.forEach(api => this.registerViews(api, views));
+      return;
+    }
+    const currentViews = this.views.get(api) || {};
+    this.views.set(api, {
+      ...currentViews,
+      ...views,
+    });
+  }
+
+  getViews(api: string | KubeApi): ApiComponents {
+    return this.views.get(this.resolveApi(api)) || {}
+  }
+}
+
+export const apiManager = new ApiManager();

src/renderer/api/endpoints/cert-manager.api.ts

@@ -0,0 +1,261 @@
+// Kubernetes certificate management controller apis
+// Reference: https://docs.cert-manager.io/en/latest/reference/index.html
+// API docs: https://docs.cert-manager.io/en/latest/reference/api-docs/index.html
+
+import { KubeObject } from "../kube-object";
+import { ISecretRef, secretsApi } from "./secret.api";
+import { getDetailsUrl } from "../../navigation";
+import { KubeApi } from "../kube-api";
+
+export class Certificate extends KubeObject {
+  static kind = "Certificate"
+
+  spec: {
+    secretName: string;
+    commonName?: string;
+    dnsNames?: string[];
+    organization?: string[];
+    ipAddresses?: string[];
+    duration?: string;
+    renewBefore?: string;
+    isCA?: boolean;
+    keySize?: number;
+    keyAlgorithm?: "rsa" | "ecdsa";
+    issuerRef: {
+      kind?: string;
+      name: string;
+    };
+    acme?: {
+      config: {
+        domains: string[];
+        http01: {
+          ingress?: string;
+          ingressClass?: string;
+        };
+        dns01?: {
+          provider: string;
+        };
+      }[];
+    };
+  }
+  status: {
+    conditions?: {
+      lastTransitionTime: string; // 2019-06-04T07:35:58Z,
+      message: string; // Certificate is up to date and has not expired,
+      reason: string; // Ready,
+      status: string; // True,
+      type: string; // Ready
+    }[];
+    notAfter: string; // 2019-11-01T05:36:27Z
+    lastFailureTime?: string;
+  }
+
+  getType(): string {
+    const { isCA, acme } = this.spec;
+    if (isCA) return "CA"
+    if (acme) return "ACME"
+  }
+
+  getCommonName() {
+    return this.spec.commonName || ""
+  }
+
+  getIssuerName() {
+    return this.spec.issuerRef.name;
+  }
+
+  getSecretName() {
+    return this.spec.secretName;
+  }
+
+  getIssuerDetailsUrl() {
+    return getDetailsUrl(issuersApi.getUrl({
+      namespace: this.getNs(),
+      name: this.getIssuerName(),
+    }))
+  }
+
+  getSecretDetailsUrl() {
+    return getDetailsUrl(secretsApi.getUrl({
+      namespace: this.getNs(),
+      name: this.getSecretName(),
+    }))
+  }
+
+  getConditions() {
+    const { conditions = [] } = this.status;
+    return conditions.map(condition => {
+      const { message, reason, lastTransitionTime, status } = condition;
+      return {
+        ...condition,
+        isReady: status === "True",
+        tooltip: `${message || reason} (${lastTransitionTime})`
+      }
+    });
+  }
+}
+
+export class Issuer extends KubeObject {
+  static kind = "Issuer"
+
+  spec: {
+    acme?: {
+      email: string;
+      server: string;
+      skipTLSVerify?: boolean;
+      privateKeySecretRef: ISecretRef;
+      solvers?: {
+        dns01?: {
+          cnameStrategy: string;
+          acmedns?: {
+            host: string;
+            accountSecretRef: ISecretRef;
+          };
+          akamai?: {
+            accessTokenSecretRef: ISecretRef;
+            clientSecretSecretRef: ISecretRef;
+            clientTokenSecretRef: ISecretRef;
+            serviceConsumerDomain: string;
+          };
+          azuredns?: {
+            clientID: string;
+            clientSecretSecretRef: ISecretRef;
+            hostedZoneName: string;
+            resourceGroupName: string;
+            subscriptionID: string;
+            tenantID: string;
+          };
+          clouddns?: {
+            project: string;
+            serviceAccountSecretRef: ISecretRef;
+          };
+          cloudflare?: {
+            email: string;
+            apiKeySecretRef: ISecretRef;
+          };
+          digitalocean?: {
+            tokenSecretRef: ISecretRef;
+          };
+          rfc2136?: {
+            nameserver: string;
+            tsigAlgorithm: string;
+            tsigKeyName: string;
+            tsigSecretSecretRef: ISecretRef;
+          };
+          route53?: {
+            accessKeyID: string;
+            hostedZoneID: string;
+            region: string;
+            secretAccessKeySecretRef: ISecretRef;
+          };
+          webhook?: {
+            config: object; // arbitrary json
+            groupName: string;
+            solverName: string;
+          };
+        };
+        http01?: {
+          ingress: {
+            class: string;
+            name: string;
+            serviceType: string;
+          };
+        };
+        selector?: {
+          dnsNames: string[];
+          matchLabels: {
+            [label: string]: string;
+          };
+        };
+      }[];
+    };
+    ca?: {
+      secretName: string;
+    };
+    vault?: {
+      path: string;
+      server: string;
+      caBundle: string; // <base64 encoded caBundle PEM file>
+      auth: {
+        appRole: {
+          path: string;
+          roleId: string;
+          secretRef: ISecretRef;
+        };
+      };
+    };
+    selfSigned?: {};
+    venafi?: {
+      zone: string;
+      cloud?: {
+        apiTokenSecretRef: ISecretRef;
+      };
+      tpp?: {
+        url: string;
+        caBundle: string; // <base64 encoded caBundle PEM file>
+        credentialsRef: {
+          name: string;
+        };
+      };
+    };
+  }
+
+  status: {
+    acme?: {
+      uri: string;
+    };
+    conditions?: {
+      lastTransitionTime: string; // 2019-06-05T07:10:42Z,
+      message: string; // The ACME account was registered with the ACME server,
+      reason: string; // ACMEAccountRegistered,
+      status: string; // True,
+      type: string; // Ready
+    }[];
+  }
+
+  getType() {
+    const { acme, ca, selfSigned, vault, venafi } = this.spec;
+    if (acme) return "ACME"
+    if (ca) return "CA"
+    if (selfSigned) return "SelfSigned"
+    if (vault) return "Vault"
+    if (venafi) return "Venafi"
+  }
+
+  getConditions() {
+    const { conditions = [] } = this.status;
+    return conditions.map(condition => {
+      const { message, reason, lastTransitionTime, status } = condition;
+      return {
+        ...condition,
+        isReady: status === "True",
+        tooltip: `${message || reason} (${lastTransitionTime})`,
+      }
+    });
+  }
+}
+
+export class ClusterIssuer extends Issuer {
+  static kind = "ClusterIssuer"
+}
+
+export const certificatesApi = new KubeApi({
+  kind: Certificate.kind,
+  apiBase: "/apis/cert-manager.io/v1alpha2/certificates",
+  isNamespaced: true,
+  objectConstructor: Certificate,
+});
+
+export const issuersApi = new KubeApi({
+  kind: Issuer.kind,
+  apiBase: "/apis/cert-manager.io/v1alpha2/issuers",
+  isNamespaced: true,
+  objectConstructor: Issuer,
+});
+
+export const clusterIssuersApi = new KubeApi({
+  kind: ClusterIssuer.kind,
+  apiBase: "/apis/cert-manager.io/v1alpha2/clusterissuers",
+  isNamespaced: false,
+  objectConstructor: ClusterIssuer,
+});

src/renderer/api/endpoints/cluster-role-binding.api.ts

@@ -0,0 +1,13 @@
+import { RoleBinding } from "./role-binding.api";
+import { KubeApi } from "../kube-api";
+
+export class ClusterRoleBinding extends RoleBinding {
+  static kind = "ClusterRoleBinding"
+}
+
+export const clusterRoleBindingApi = new KubeApi({
+  kind: ClusterRoleBinding.kind,
+  apiBase: "/apis/rbac.authorization.k8s.io/v1/clusterrolebindings",
+  isNamespaced: false,
+  objectConstructor: ClusterRoleBinding,
+});

src/renderer/api/endpoints/cluster-role.api.ts

@@ -0,0 +1,15 @@
+import { autobind } from "../../utils";
+import { Role } from "./role.api";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class ClusterRole extends Role {
+  static kind = "ClusterRole"
+}
+
+export const clusterRoleApi = new KubeApi({
+  kind: ClusterRole.kind,
+  apiBase: "/apis/rbac.authorization.k8s.io/v1/clusterroles",
+  isNamespaced: false,
+  objectConstructor: ClusterRole,
+});

src/renderer/api/endpoints/cluster.api.ts

@@ -0,0 +1,98 @@
+import { IMetrics, IMetricsReqParams, metricsApi } from "./metrics.api";
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+export class ClusterApi extends KubeApi<Cluster> {
+  async getMetrics(nodeNames: string[], params?: IMetricsReqParams): Promise<IClusterMetrics> {
+    const nodes = nodeNames.join("|");
+    const opts = { category: "cluster", nodes: nodes }
+
+    return metricsApi.getMetrics({
+      memoryUsage: opts,
+      memoryRequests: opts,
+      memoryLimits: opts,
+      memoryCapacity: opts,
+      cpuUsage: opts,
+      cpuRequests: opts,
+      cpuLimits: opts,
+      cpuCapacity: opts,
+      podUsage: opts,
+      podCapacity: opts,
+      fsSize: opts,
+      fsUsage: opts
+    }, params);
+  }
+}
+
+export enum ClusterStatus {
+  ACTIVE = "Active",
+  CREATING = "Creating",
+  REMOVING = "Removing",
+  ERROR = "Error"
+}
+
+export interface IClusterMetrics<T = IMetrics> {
+  [metric: string]: T;
+  memoryUsage: T;
+  memoryRequests: T;
+  memoryLimits: T;
+  memoryCapacity: T;
+  cpuUsage: T;
+  cpuRequests: T;
+  cpuLimits: T;
+  cpuCapacity: T;
+  podUsage: T;
+  podCapacity: T;
+  fsSize: T;
+  fsUsage: T;
+}
+
+export class Cluster extends KubeObject {
+  static kind = "Cluster";
+
+  spec: {
+    clusterNetwork?: {
+      serviceDomain?: string;
+      pods?: {
+        cidrBlocks?: string[];
+      };
+      services?: {
+        cidrBlocks?: string[];
+      };
+    };
+    providerSpec: {
+      value: {
+        profile: string;
+      };
+    };
+  }
+  status?: {
+    apiEndpoints: {
+      host: string;
+      port: string;
+    }[];
+    providerStatus: {
+      adminUser?: string;
+      adminPassword?: string;
+      kubeconfig?: string;
+      processState?: string;
+      lensAddress?: string;
+    };
+    errorMessage?: string;
+    errorReason?: string;
+  }
+
+  getStatus() {
+    if (this.metadata.deletionTimestamp) return ClusterStatus.REMOVING;
+    if (!this.status || !this.status) return ClusterStatus.CREATING;
+    if (this.status.errorMessage) return ClusterStatus.ERROR;
+    return ClusterStatus.ACTIVE;
+  }
+}
+
+export const clusterApi = new ClusterApi({
+  kind: Cluster.kind,
+  apiBase: "/apis/cluster.k8s.io/v1alpha1/clusters",
+  isNamespaced: true,
+  objectConstructor: Cluster,
+});

src/renderer/api/endpoints/component-status.api.ts

@@ -0,0 +1,25 @@
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+export interface IComponentStatusCondition {
+  type: string;
+  status: string;
+  message: string;
+}
+
+export class ComponentStatus extends KubeObject {
+  static kind = "ComponentStatus"
+
+  conditions: IComponentStatusCondition[]
+
+  getTruthyConditions() {
+    return this.conditions.filter(c => c.status === "True");
+  }
+}
+
+export const componentStatusApi = new KubeApi({
+  kind: ComponentStatus.kind,
+  apiBase: "/api/v1/componentstatuses",
+  isNamespaced: false,
+  objectConstructor: ComponentStatus,
+});

src/renderer/api/endpoints/config.api.ts

@@ -0,0 +1,9 @@
+// App configuration api
+import type { IConfigRoutePayload } from "../../../main/routes/config";
+import { apiBase } from "../index";
+
+export const configApi = {
+  getConfig() {
+    return apiBase.get<IConfigRoutePayload>("/config")
+  },
+};

src/renderer/api/endpoints/configmap.api.ts

@@ -0,0 +1,29 @@
+import { KubeObject } from "../kube-object";
+import { KubeJsonApiData } from "../kube-json-api";
+import { autobind } from "../../utils";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class ConfigMap extends KubeObject {
+  static kind = "ConfigMap";
+
+  constructor(data: KubeJsonApiData) {
+    super(data);
+    this.data = this.data || {};
+  }
+
+  data: {
+    [param: string]: string;
+  }
+
+  getKeys(): string[] {
+    return Object.keys(this.data);
+  }
+}
+
+export const configMapApi = new KubeApi({
+  kind: ConfigMap.kind,
+  apiBase: "/api/v1/configmaps",
+  isNamespaced: true,
+  objectConstructor: ConfigMap,
+});

src/renderer/api/endpoints/crd.api.ts

@@ -0,0 +1,138 @@
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+import { crdResourcesURL } from "../../components/+custom-resources/crd.route";
+
+export class CustomResourceDefinition extends KubeObject {
+  static kind = "CustomResourceDefinition";
+
+  spec: {
+    group: string;
+    version: string;
+    names: {
+      plural: string;
+      singular: string;
+      kind: string;
+      listKind: string;
+    };
+    scope: "Namespaced" | "Cluster" | string;
+    validation?: any;
+    versions: {
+      name: string;
+      served: boolean;
+      storage: boolean;
+    }[];
+    conversion: {
+      strategy?: string;
+      webhook?: any;
+    };
+    additionalPrinterColumns?: {
+      name: string;
+      type: "integer" | "number" | "string" | "boolean" | "date";
+      priority: number;
+      description: string;
+      JSONPath: string;
+    }[];
+  }
+  status: {
+    conditions: {
+      lastTransitionTime: string;
+      message: string;
+      reason: string;
+      status: string;
+      type: string;
+    }[];
+    acceptedNames: {
+      plural: string;
+      singular: string;
+      kind: string;
+      shortNames: string[];
+      listKind: string;
+    };
+    storedVersions: string[];
+  }
+
+  getResourceUrl() {
+    return crdResourcesURL({
+      params: {
+        group: this.getGroup(),
+        name: this.getPluralName(),
+      }
+    })
+  }
+
+  getResourceApiBase() {
+    const { version, group } = this.spec;
+    return `/apis/${group}/${version}/${this.getPluralName()}`
+  }
+
+  getPluralName() {
+    return this.getNames().plural
+  }
+
+  getResourceKind() {
+    return this.spec.names.kind
+  }
+
+  getResourceTitle() {
+    const name = this.getPluralName();
+    return name[0].toUpperCase() + name.substr(1)
+  }
+
+  getGroup() {
+    return this.spec.group;
+  }
+
+  getScope() {
+    return this.spec.scope;
+  }
+
+  getVersion() {
+    return this.spec.version;
+  }
+
+  isNamespaced() {
+    return this.getScope() === "Namespaced";
+  }
+
+  getStoredVersions() {
+    return this.status.storedVersions.join(", ");
+  }
+
+  getNames() {
+    return this.spec.names;
+  }
+
+  getConversion() {
+    return JSON.stringify(this.spec.conversion);
+  }
+
+  getPrinterColumns(ignorePriority = true) {
+    const columns = this.spec.additionalPrinterColumns || [];
+    return columns
+      .filter(column => column.name != "Age")
+      .filter(column => ignorePriority ? true : !column.priority);
+  }
+
+  getValidation() {
+    return JSON.stringify(this.spec.validation, null, 2);
+  }
+
+  getConditions() {
+    if (!this.status.conditions) return [];
+    return this.status.conditions.map(condition => {
+      const { message, reason, lastTransitionTime, status } = condition;
+      return {
+        ...condition,
+        isReady: status === "True",
+        tooltip: `${message || reason} (${lastTransitionTime})`
+      }
+    });
+  }
+}
+
+export const crdApi = new KubeApi<CustomResourceDefinition>({
+  kind: CustomResourceDefinition.kind,
+  apiBase: "/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions",
+  isNamespaced: false,
+  objectConstructor: CustomResourceDefinition,
+});

src/renderer/api/endpoints/cron-job.api.ts

@@ -0,0 +1,88 @@
+import moment from "moment";
+import { KubeObject } from "../kube-object";
+import { IPodContainer } from "./pods.api";
+import { formatDuration } from "../../utils/formatDuration";
+import { autobind } from "../../utils";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class CronJob extends KubeObject {
+  static kind = "CronJob"
+
+  kind: string
+  apiVersion: string
+  metadata: {
+    name: string;
+    namespace: string;
+    selfLink: string;
+    uid: string;
+    resourceVersion: string;
+    creationTimestamp: string;
+    labels: {
+      [key: string]: string;
+    };
+    annotations: {
+      [key: string]: string;
+    };
+  }
+  spec: {
+    schedule: string;
+    concurrencyPolicy: string;
+    suspend: boolean;
+    jobTemplate: {
+      metadata: {
+        creationTimestamp?: string;
+      };
+      spec: {
+        template: {
+          metadata: {
+            creationTimestamp?: string;
+          };
+          spec: {
+            containers: IPodContainer[];
+            restartPolicy: string;
+            terminationGracePeriodSeconds: number;
+            dnsPolicy: string;
+            hostPID: boolean;
+            schedulerName: string;
+          };
+        };
+      };
+    };
+    successfulJobsHistoryLimit: number;
+    failedJobsHistoryLimit: number;
+  }
+  status: {
+    lastScheduleTime: string;
+  }
+
+  getSuspendFlag() {
+    return this.spec.suspend.toString()
+  }
+
+  getLastScheduleTime() {
+    const diff = moment().diff(this.status.lastScheduleTime)
+    return formatDuration(diff, true)
+  }
+
+  getSchedule() {
+    return this.spec.schedule
+  }
+
+  isNeverRun() {
+    const schedule = this.getSchedule();
+    const daysInMonth = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    const stamps = schedule.split(" ");
+    const day = Number(stamps[stamps.length - 3]);  // 1-31
+    const month = Number(stamps[stamps.length - 2]);  // 1-12
+    if (schedule.startsWith("@")) return false;
+    return day > daysInMonth[month - 1];
+  }
+}
+
+export const cronJobApi = new KubeApi({
+  kind: CronJob.kind,
+  apiBase: "/apis/batch/v1beta1/cronjobs",
+  isNamespaced: true,
+  objectConstructor: CronJob,
+});

src/renderer/api/endpoints/daemon-set.api.ts

@@ -0,0 +1,76 @@
+import get from "lodash/get";
+import { IPodContainer } from "./pods.api";
+import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
+import { autobind } from "../../utils";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class DaemonSet extends WorkloadKubeObject {
+  static kind = "DaemonSet"
+
+  spec: {
+    selector: {
+      matchLabels: {
+        [name: string]: string;
+      };
+    };
+    template: {
+      metadata: {
+        creationTimestamp?: string;
+        labels: {
+          name: string;
+        };
+      };
+      spec: {
+        containers: IPodContainer[];
+        initContainers?: IPodContainer[];
+        restartPolicy: string;
+        terminationGracePeriodSeconds: number;
+        dnsPolicy: string;
+        hostPID: boolean;
+        affinity?: IAffinity;
+        nodeSelector?: {
+          [selector: string]: string;
+        };
+        securityContext: {};
+        schedulerName: string;
+        tolerations: {
+          key: string;
+          operator: string;
+          effect: string;
+          tolerationSeconds: number;
+        }[];
+      };
+    };
+    updateStrategy: {
+      type: string;
+      rollingUpdate: {
+        maxUnavailable: number;
+      };
+    };
+    revisionHistoryLimit: number;
+  }
+  status: {
+    currentNumberScheduled: number;
+    numberMisscheduled: number;
+    desiredNumberScheduled: number;
+    numberReady: number;
+    observedGeneration: number;
+    updatedNumberScheduled: number;
+    numberAvailable: number;
+    numberUnavailable: number;
+  }
+
+  getImages() {
+    const containers: IPodContainer[] = get(this, "spec.template.spec.containers", [])
+    const initContainers: IPodContainer[] = get(this, "spec.template.spec.initContainers", [])
+    return [...containers, ...initContainers].map(container => container.image)
+  }
+}
+
+export const daemonSetApi = new KubeApi({
+  kind: DaemonSet.kind,
+  apiBase: "/apis/apps/v1/daemonsets",
+  isNamespaced: true,
+  objectConstructor: DaemonSet,
+});

src/renderer/api/endpoints/deployment.api.ts

@@ -0,0 +1,171 @@
+import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
+import { autobind } from "../../utils";
+import { KubeApi } from "../kube-api";
+
+export class DeploymentApi extends KubeApi<Deployment> {
+  protected getScaleApiUrl(params: { namespace: string; name: string }) {
+    return this.getUrl(params) + "/scale"
+  }
+
+  getReplicas(params: { namespace: string; name: string }): Promise<number> {
+    return this.request
+      .get(this.getScaleApiUrl(params))
+      .then(({ status }: any) => status.replicas)
+  }
+
+  scale(params: { namespace: string; name: string }, replicas: number) {
+    return this.request.put(this.getScaleApiUrl(params), {
+      data: {
+        metadata: params,
+        spec: {
+          replicas: replicas
+        }
+      }
+    })
+  }
+}
+
+@autobind()
+export class Deployment extends WorkloadKubeObject {
+  static kind = "Deployment"
+
+  spec: {
+    replicas: number;
+    selector: { matchLabels: { [app: string]: string } };
+    template: {
+      metadata: {
+        creationTimestamp?: string;
+        labels: { [app: string]: string };
+      };
+      spec: {
+        containers: {
+          name: string;
+          image: string;
+          args?: string[];
+          ports?: {
+            name: string;
+            containerPort: number;
+            protocol: string;
+          }[];
+          env?: {
+            name: string;
+            value: string;
+          }[];
+          resources: {
+            limits?: {
+              cpu: string;
+              memory: string;
+            };
+            requests: {
+              cpu: string;
+              memory: string;
+            };
+          };
+          volumeMounts?: {
+            name: string;
+            mountPath: string;
+          }[];
+          livenessProbe?: {
+            httpGet: {
+              path: string;
+              port: number;
+              scheme: string;
+            };
+            initialDelaySeconds: number;
+            timeoutSeconds: number;
+            periodSeconds: number;
+            successThreshold: number;
+            failureThreshold: number;
+          };
+          readinessProbe?: {
+            httpGet: {
+              path: string;
+              port: number;
+              scheme: string;
+            };
+            initialDelaySeconds: number;
+            timeoutSeconds: number;
+            periodSeconds: number;
+            successThreshold: number;
+            failureThreshold: number;
+          };
+          terminationMessagePath: string;
+          terminationMessagePolicy: string;
+          imagePullPolicy: string;
+        }[];
+        restartPolicy: string;
+        terminationGracePeriodSeconds: number;
+        dnsPolicy: string;
+        affinity?: IAffinity;
+        nodeSelector?: {
+          [selector: string]: string;
+        };
+        serviceAccountName: string;
+        serviceAccount: string;
+        securityContext: {};
+        schedulerName: string;
+        tolerations?: {
+          key: string;
+          operator: string;
+          effect: string;
+          tolerationSeconds: number;
+        }[];
+        volumes?: {
+          name: string;
+          configMap: {
+            name: string;
+            defaultMode: number;
+            optional: boolean;
+          };
+        }[];
+      };
+    };
+    strategy: {
+      type: string;
+      rollingUpdate: {
+        maxUnavailable: number;
+        maxSurge: number;
+      };
+    };
+  }
+  status: {
+    observedGeneration: number;
+    replicas: number;
+    updatedReplicas: number;
+    readyReplicas: number;
+    availableReplicas?: number;
+    unavailableReplicas?: number;
+    conditions: {
+      type: string;
+      status: string;
+      lastUpdateTime: string;
+      lastTransitionTime: string;
+      reason: string;
+      message: string;
+    }[];
+  }
+
+  getConditions(activeOnly = false) {
+    const { conditions } = this.status
+    if (!conditions) return []
+    if (activeOnly) {
+      return conditions.filter(c => c.status === "True")
+    }
+    return conditions
+  }
+
+  getConditionsText(activeOnly = true) {
+    return this.getConditions(activeOnly).map(({ type }) => type).join(" ")
+  }
+
+  getReplicas() {
+    return this.spec.replicas || 0;
+  }
+}
+
+export const deploymentApi = new DeploymentApi({
+  kind: Deployment.kind,
+  apiBase: "/apis/apps/v1/deployments",
+  isNamespaced: true,
+  objectConstructor: Deployment,
+});

src/renderer/api/endpoints/endpoint.api.ts

@@ -0,0 +1,125 @@
+import { autobind } from "../../utils";
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+export interface IEndpointPort {
+  name?: string;
+  protocol: string;
+  port: number;
+}
+
+export interface IEndpointAddress {
+  hostname: string;
+  ip: string;
+  nodeName: string;
+}
+
+export interface IEndpointSubset {
+  addresses: IEndpointAddress[];
+  notReadyAddresses: IEndpointAddress[];
+  ports: IEndpointPort[];
+}
+
+interface ITargetRef {
+  kind: string;
+  namespace: string;
+  name: string;
+  uid: string;
+  resourceVersion: string;
+  apiVersion: string;
+}
+
+export class EndpointAddress implements IEndpointAddress {
+  hostname: string;
+  ip: string;
+  nodeName: string;
+  targetRef?: {
+    kind: string;
+    namespace: string;
+    name: string;
+    uid: string;
+    resourceVersion: string;
+  };
+
+  constructor(data: IEndpointAddress) {
+    Object.assign(this, data)
+  }
+
+  getId() {
+    return this.ip
+  }
+
+  getName() {
+    return this.hostname
+  }
+
+  getTargetRef(): ITargetRef {
+    if (this.targetRef) {
+      return Object.assign(this.targetRef, {apiVersion: "v1"})
+    } else {
+      return null
+    }
+  }
+}
+
+export class EndpointSubset implements IEndpointSubset {
+  addresses: IEndpointAddress[];
+  notReadyAddresses: IEndpointAddress[];
+  ports: IEndpointPort[];
+
+  constructor(data: IEndpointSubset) {
+    Object.assign(this, data)
+  }
+
+  getAddresses(): EndpointAddress[] {
+    const addresses = this.addresses || [];
+    return addresses.map(a => new EndpointAddress(a));
+  }
+
+  getNotReadyAddresses(): EndpointAddress[] {
+    const notReadyAddresses = this.notReadyAddresses || [];
+    return notReadyAddresses.map(a => new EndpointAddress(a));
+  }
+
+  toString(): string {
+    if(!this.addresses) {
+      return ""
+    }
+    return this.addresses.map(address => {
+      if (!this.ports) {
+        return address.ip
+      }
+      return this.ports.map(port => {
+        return `${address.ip}:${port.port}`
+      }).join(", ")
+    }).join(", ")
+  }
+}
+
+@autobind()
+export class Endpoint extends KubeObject {
+  static kind = "Endpoint"
+
+  subsets: IEndpointSubset[]
+
+  getEndpointSubsets(): EndpointSubset[] {
+    const subsets = this.subsets || [];
+    return subsets.map(s => new EndpointSubset(s));
+  }
+
+  toString(): string {
+    if(this.subsets) {
+      return this.getEndpointSubsets().map(es => es.toString()).join(", ")
+    } else {
+      return "<none>"
+    }
+  }
+
+}
+
+export const endpointApi = new KubeApi({
+  kind: Endpoint.kind,
+  apiBase: "/api/v1/endpoints",
+  isNamespaced: true,
+  objectConstructor: Endpoint,
+});

src/renderer/api/endpoints/events.api.ts

@@ -0,0 +1,59 @@
+import moment from "moment";
+import { KubeObject } from "../kube-object";
+import { formatDuration } from "../../utils/formatDuration";
+import { autobind } from "../../utils";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class KubeEvent extends KubeObject {
+  static kind = "Event"
+
+  involvedObject: {
+    kind: string;
+    namespace: string;
+    name: string;
+    uid: string;
+    apiVersion: string;
+    resourceVersion: string;
+    fieldPath: string;
+  }
+  reason: string
+  message: string
+  source: {
+    component: string;
+    host: string;
+  }
+  firstTimestamp: string
+  lastTimestamp: string
+  count: number
+  type: string
+  eventTime: null
+  reportingComponent: string
+  reportingInstance: string
+
+  isWarning() {
+    return this.type === "Warning";
+  }
+
+  getSource() {
+    const { component, host } = this.source
+    return `${component} ${host || ""}`
+  }
+
+  getFirstSeenTime() {
+    const diff = moment().diff(this.firstTimestamp)
+    return formatDuration(diff, true)
+  }
+
+  getLastSeenTime() {
+    const diff = moment().diff(this.lastTimestamp)
+    return formatDuration(diff, true)
+  }
+}
+
+export const eventApi = new KubeApi({
+  kind: KubeEvent.kind,
+  apiBase: "/api/v1/events",
+  isNamespaced: true,
+  objectConstructor: KubeEvent,
+})

src/renderer/api/endpoints/helm-charts.api.ts

@@ -0,0 +1,129 @@
+import { compile } from "path-to-regexp";
+import { apiHelm } from "../index";
+import { stringify } from "querystring";
+import { autobind } from "../../utils";
+
+interface IHelmChartList {
+  [repo: string]: {
+    [name: string]: HelmChart;
+  };
+}
+
+export interface IHelmChartDetails {
+  readme: string;
+  versions: HelmChart[];
+}
+
+const endpoint = compile(`/v2/charts/:repo?/:name?`) as (params?: {
+  repo?: string;
+  name?: string;
+}) => string;
+
+export const helmChartsApi = {
+  list() {
+    return apiHelm
+      .get<IHelmChartList>(endpoint())
+      .then(data => {
+        return Object
+          .values(data)
+          .reduce((allCharts, repoCharts) => allCharts.concat(Object.values(repoCharts)), [])
+          .map(HelmChart.create);
+      });
+  },
+
+  get(repo: string, name: string, readmeVersion?: string) {
+    const path = endpoint({ repo, name });
+    return apiHelm
+      .get<IHelmChartDetails>(path + "?" + stringify({ version: readmeVersion }))
+      .then(data => {
+        const versions = data.versions.map(HelmChart.create);
+        const readme = data.readme;
+        return {
+          readme,
+          versions,
+        }
+      });
+  },
+
+  getValues(repo: string, name: string, version: string) {
+    return apiHelm
+      .get<string>(`/v2/charts/${repo}/${name}/values?` + stringify({ version }));
+  }
+};
+
+@autobind()
+export class HelmChart {
+  constructor(data: any) {
+    Object.assign(this, data);
+  }
+
+  static create(data: any) {
+    return new HelmChart(data);
+  }
+
+  apiVersion: string
+  name: string
+  version: string
+  repo: string
+  kubeVersion?: string
+  created: string
+  description?: string
+  digest: string
+  keywords?: string[]
+  home?: string
+  sources?: string[]
+  maintainers?: {
+    name: string;
+    email: string;
+    url: string;
+  }[]
+  engine?: string
+  icon?: string
+  appVersion?: string
+  deprecated?: boolean
+  tillerVersion?: string
+
+  getId() {
+    return this.digest;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getFullName(splitter = "/") {
+    return [this.getRepository(), this.getName()].join(splitter);
+  }
+
+  getDescription() {
+    return this.description;
+  }
+
+  getIcon() {
+    return this.icon;
+  }
+
+  getHome() {
+    return this.home;
+  }
+
+  getMaintainers() {
+    return this.maintainers || [];
+  }
+
+  getVersion() {
+    return this.version;
+  }
+
+  getRepository() {
+    return this.repo;
+  }
+
+  getAppVersion() {
+    return this.appVersion || "";
+  }
+
+  getKeywords() {
+    return this.keywords || [];
+  }
+}

src/renderer/api/endpoints/helm-releases.api.ts

@@ -0,0 +1,205 @@
+import jsYaml from "js-yaml";
+import { compile } from "path-to-regexp";
+import { autobind, formatDuration } from "../../utils";
+import capitalize from "lodash/capitalize";
+import { apiHelm } from "../index";
+import { helmChartStore } from "../../components/+apps-helm-charts/helm-chart.store";
+import { ItemObject } from "../../item.store";
+import { KubeObject } from "../kube-object";
+
+interface IReleasePayload {
+  name: string;
+  namespace: string;
+  version: string;
+  config: string;  // release values
+  manifest: string;
+  info: {
+    deleted: string;
+    description: string;
+    first_deployed: string;
+    last_deployed: string;
+    notes: string;
+    status: string;
+  };
+}
+
+interface IReleaseRawDetails extends IReleasePayload {
+  resources: string;
+}
+
+export interface IReleaseDetails extends IReleasePayload {
+  resources: KubeObject[];
+}
+
+export interface IReleaseCreatePayload {
+  name?: string;
+  repo: string;
+  chart: string;
+  namespace: string;
+  version: string;
+  values: string;
+}
+
+export interface IReleaseUpdatePayload {
+  repo: string;
+  chart: string;
+  version: string;
+  values: string;
+}
+
+export interface IReleaseUpdateDetails {
+  log: string;
+  release: IReleaseDetails;
+}
+
+export interface IReleaseRevision {
+  revision: number;
+  updated: string;
+  status: string;
+  chart: string;
+  description: string;
+}
+
+const endpoint = compile(`/v2/releases/:namespace?/:name?`) as (
+  params?: {
+    namespace?: string;
+    name?: string;
+  }
+) => string;
+
+export const helmReleasesApi = {
+  list(namespace?: string) {
+    return apiHelm
+      .get<HelmRelease[]>(endpoint({ namespace }))
+      .then(releases => releases.map(HelmRelease.create));
+  },
+
+  get(name: string, namespace: string) {
+    const path = endpoint({ name, namespace });
+    return apiHelm.get<IReleaseRawDetails>(path).then(details => {
+      const items: KubeObject[] = JSON.parse(details.resources).items;
+      const resources = items.map(item => KubeObject.create(item));
+      return {
+        ...details,
+        resources
+      }
+    });
+  },
+
+  create(payload: IReleaseCreatePayload): Promise<IReleaseUpdateDetails> {
+    const { repo, ...data } = payload;
+    data.chart = `${repo}/${data.chart}`;
+    data.values = jsYaml.safeLoad(data.values);
+    return apiHelm.post(endpoint(), { data });
+  },
+
+  update(name: string, namespace: string, payload: IReleaseUpdatePayload): Promise<IReleaseUpdateDetails> {
+    const { repo, ...data } = payload;
+    data.chart = `${repo}/${data.chart}`;
+    data.values = jsYaml.safeLoad(data.values);
+    return apiHelm.put(endpoint({ name, namespace }), { data });
+  },
+
+  async delete(name: string, namespace: string) {
+    const path = endpoint({ name, namespace });
+    return apiHelm.del(path);
+  },
+
+  getValues(name: string, namespace: string) {
+    const path = endpoint({ name, namespace }) + "/values";
+    return apiHelm.get<string>(path);
+  },
+
+  getHistory(name: string, namespace: string): Promise<IReleaseRevision[]> {
+    const path = endpoint({ name, namespace }) + "/history";
+    return apiHelm.get(path);
+  },
+
+  rollback(name: string, namespace: string, revision: number) {
+    const path = endpoint({ name, namespace }) + "/rollback";
+    return apiHelm.put(path, {
+      data: {
+        revision: revision
+      }
+    });
+  }
+};
+
+@autobind()
+export class HelmRelease implements ItemObject {
+  constructor(data: any) {
+    Object.assign(this, data);
+  }
+
+  static create(data: any) {
+    return new HelmRelease(data);
+  }
+
+  appVersion: string
+  name: string
+  namespace: string
+  chart: string
+  status: string
+  updated: string
+  revision: number
+
+  getId() {
+    return this.namespace + this.name;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getNs() {
+    return this.namespace;
+  }
+
+  getChart(withVersion = false) {
+    let chart = this.chart
+    if(!withVersion && this.getVersion() != "" ) {
+      const search = new RegExp(`-${this.getVersion()}`)
+      chart = chart.replace(search, "");
+    }
+    return chart
+  }
+
+  getRevision() {
+    return this.revision;
+  }
+
+  getStatus() {
+    return capitalize(this.status);
+  }
+
+  getVersion() {
+    const versions = this.chart.match(/(v?\d+)[^-].*$/)
+    if (versions) {
+      return versions[0]
+    }
+    else {
+      return ""
+    }
+  }
+
+  getUpdated(humanize = true, compact = true) {
+    const now = new Date().getTime();
+    const updated = this.updated.replace(/\s\w*$/, "");  // 2019-11-26 10:58:09 +0300 MSK -> 2019-11-26 10:58:09 +0300 to pass into Date()
+    const updatedDate = new Date(updated).getTime();
+    const diff = now - updatedDate;
+    if (humanize) {
+      return formatDuration(diff, compact);
+    }
+    return diff;
+  }
+
+  // Helm does not store from what repository the release is installed,
+  // so we have to try to guess it by searching charts
+  async getRepo() {
+    const chartName = this.getChart();
+    const version = this.getVersion();
+    const versions = await helmChartStore.getVersions(chartName);
+    const chartVersion = versions.find(chartVersion => chartVersion.version === version);
+    return chartVersion ? chartVersion.repo : "";
+  }
+}

src/renderer/api/endpoints/hpa.api.ts

@@ -0,0 +1,140 @@
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+export enum HpaMetricType {
+  Resource = "Resource",
+  Pods = "Pods",
+  Object = "Object",
+  External = "External",
+}
+
+export type IHpaMetricData<T = any> = T & {
+  target?: {
+    kind: string;
+    name: string;
+    apiVersion: string;
+  };
+  name?: string;
+  metricName?: string;
+  currentAverageUtilization?: number;
+  currentAverageValue?: string;
+  targetAverageUtilization?: number;
+  targetAverageValue?: string;
+}
+
+export interface IHpaMetric {
+  [kind: string]: IHpaMetricData;
+
+  type: HpaMetricType;
+  resource?: IHpaMetricData<{ name: string }>;
+  pods?: IHpaMetricData;
+  external?: IHpaMetricData;
+  object?: IHpaMetricData<{
+    describedObject: {
+      apiVersion: string;
+      kind: string;
+      name: string;
+    };
+  }>;
+}
+
+export class HorizontalPodAutoscaler extends KubeObject {
+  static kind = "HorizontalPodAutoscaler";
+
+  spec: {
+    scaleTargetRef: {
+      kind: string;
+      name: string;
+      apiVersion: string;
+    };
+    minReplicas: number;
+    maxReplicas: number;
+    metrics: IHpaMetric[];
+  }
+  status: {
+    currentReplicas: number;
+    desiredReplicas: number;
+    currentMetrics: IHpaMetric[];
+    conditions: {
+      lastTransitionTime: string;
+      message: string;
+      reason: string;
+      status: string;
+      type: string;
+    }[];
+  }
+
+  getMaxPods() {
+    return this.spec.maxReplicas || 0;
+  }
+
+  getMinPods() {
+    return this.spec.minReplicas || 0;
+  }
+
+  getReplicas() {
+    return this.status.currentReplicas;
+  }
+
+  getConditions() {
+    if (!this.status.conditions) return [];
+    return this.status.conditions.map(condition => {
+      const { message, reason, lastTransitionTime, status } = condition;
+      return {
+        ...condition,
+        isReady: status === "True",
+        tooltip: `${message || reason} (${lastTransitionTime})`
+      }
+    });
+  }
+
+  getMetrics() {
+    return this.spec.metrics || [];
+  }
+
+  getCurrentMetrics() {
+    return this.status.currentMetrics || [];
+  }
+
+  protected getMetricName(metric: IHpaMetric): string {
+    const { type, resource, pods, object, external } = metric;
+    switch (type) {
+    case HpaMetricType.Resource:
+      return resource.name
+    case HpaMetricType.Pods:
+      return pods.metricName;
+    case HpaMetricType.Object:
+      return object.metricName;
+    case HpaMetricType.External:
+      return external.metricName;
+    }
+  }
+
+  // todo: refactor
+  getMetricValues(metric: IHpaMetric): string {
+    const metricType = metric.type.toLowerCase();
+    const currentMetric = this.getCurrentMetrics().find(current =>
+      metric.type == current.type && this.getMetricName(metric) == this.getMetricName(current)
+    );
+    const current = currentMetric ? currentMetric[metricType] : null;
+    const target = metric[metricType];
+    let currentValue = "unknown";
+    let targetValue = "unknown";
+    if (current) {
+      currentValue = current.currentAverageUtilization || current.currentAverageValue || current.currentValue;
+      if (current.currentAverageUtilization) currentValue += "%";
+    }
+    if (target) {
+      targetValue = target.targetAverageUtilization || target.targetAverageValue || target.targetValue;
+      if (target.targetAverageUtilization) targetValue += "%"
+    }
+    return `${currentValue} / ${targetValue}`;
+  }
+}
+
+export const hpaApi = new KubeApi({
+  kind: HorizontalPodAutoscaler.kind,
+  apiBase: "/apis/autoscaling/v2beta1/horizontalpodautoscalers",
+  isNamespaced: true,
+  objectConstructor: HorizontalPodAutoscaler,
+});

src/renderer/api/endpoints/index.ts

@@ -0,0 +1,33 @@
+// Local express.js endpoints
+export * from "./config.api"
+export * from "./cluster.api"
+export * from "./kubeconfig.api"
+
+// Kubernetes endpoints
+// Docs: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/
+export * from "./namespaces.api"
+export * from "./cluster-role.api"
+export * from "./cluster-role-binding.api"
+export * from "./role.api"
+export * from "./role-binding.api"
+export * from "./secret.api"
+export * from "./service-accounts.api"
+export * from "./nodes.api"
+export * from "./pods.api"
+export * from "./deployment.api"
+export * from "./daemon-set.api"
+export * from "./stateful-set.api"
+export * from "./replica-set.api"
+export * from "./job.api"
+export * from "./cron-job.api"
+export * from "./configmap.api"
+export * from "./ingress.api"
+export * from "./network-policy.api"
+export * from "./persistent-volume-claims.api"
+export * from "./persistent-volume.api"
+export * from "./service.api"
+export * from "./endpoint.api"
+export * from "./storage-class.api"
+export * from "./pod-metrics.api"
+export * from "./podsecuritypolicy.api"
+export * from "./selfsubjectrulesreviews.api"

src/renderer/api/endpoints/ingress.api.ts

@@ -0,0 +1,113 @@
+import { KubeObject } from "../kube-object";
+import { autobind } from "../../utils";
+import { IMetrics, metricsApi } from "./metrics.api";
+import { KubeApi } from "../kube-api";
+
+export class IngressApi extends KubeApi<Ingress> {
+  getMetrics(ingress: string, namespace: string): Promise<IIngressMetrics> {
+    const opts = { category: "ingress", ingress }
+    return metricsApi.getMetrics({
+      bytesSentSuccess: opts,
+      bytesSentFailure: opts,
+      requestDurationSeconds: opts,
+      responseDurationSeconds: opts
+    }, {
+      namespace,
+    });
+  }
+}
+
+export interface IIngressMetrics<T = IMetrics> {
+  [metric: string]: T;
+  bytesSentSuccess: T;
+  bytesSentFailure: T;
+  requestDurationSeconds: T;
+  responseDurationSeconds: T;
+}
+
+@autobind()
+export class Ingress extends KubeObject {
+  static kind = "Ingress"
+
+  spec: {
+    tls: {
+      secretName: string;
+    }[];
+    rules?: {
+      host?: string;
+      http: {
+        paths: {
+          path?: string;
+          backend: {
+            serviceName: string;
+            servicePort: number;
+          };
+        }[];
+      };
+    }[];
+    backend?: {
+      serviceName: string;
+      servicePort: number;
+    };
+  }
+  status: {
+    loadBalancer: {
+      ingress: any[];
+    };
+  }
+
+  getRoutes() {
+    const { spec: { tls, rules } } = this
+    if (!rules) return []
+
+    let protocol = "http"
+    const routes: string[] = []
+    if (tls && tls.length > 0) {
+      protocol += "s"
+    }
+    rules.map(rule => {
+      const host = rule.host ? rule.host : "*"
+      if (rule.http && rule.http.paths) {
+        rule.http.paths.forEach(path => {
+          routes.push(protocol + "://" + host + (path.path || "/") + " ⇢ " + path.backend.serviceName + ":" + path.backend.servicePort)
+        })
+      }
+    })
+
+    return routes;
+  }
+
+  getHosts() {
+    const { spec: { rules } } = this
+    if (!rules) return []
+    return rules.filter(rule => rule.host).map(rule => rule.host)
+  }
+
+  getPorts() {
+    const ports: number[] = []
+    const { spec: { tls, rules, backend } } = this
+    const httpPort = 80
+    const tlsPort = 443
+    if (rules && rules.length > 0) {
+      if (rules.some(rule => rule.hasOwnProperty("http"))) {
+        ports.push(httpPort)
+      }
+    }
+    else {
+      if (backend && backend.servicePort) {
+        ports.push(backend.servicePort)
+      }
+    }
+    if (tls && tls.length > 0) {
+      ports.push(tlsPort)
+    }
+    return ports.join(", ")
+  }
+}
+
+export const ingressApi = new IngressApi({
+  kind: Ingress.kind,
+  apiBase: "/apis/extensions/v1beta1/ingresses",
+  isNamespaced: true,
+  objectConstructor: Ingress,
+});

src/renderer/api/endpoints/job.api.ts

@@ -0,0 +1,106 @@
+import get from "lodash/get";
+import { autobind } from "../../utils";
+import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
+import { IPodContainer } from "./pods.api";
+import { KubeApi } from "../kube-api";
+import { JsonApiParams } from "../json-api";
+
+@autobind()
+export class Job extends WorkloadKubeObject {
+  static kind = "Job"
+
+  spec: {
+    parallelism?: number;
+    completions?: number;
+    backoffLimit?: number;
+    selector: {
+      matchLabels: {
+        [name: string]: string;
+      };
+    };
+    template: {
+      metadata: {
+        creationTimestamp?: string;
+        labels: {
+          name: string;
+        };
+      };
+      spec: {
+        containers: IPodContainer[];
+        restartPolicy: string;
+        terminationGracePeriodSeconds: number;
+        dnsPolicy: string;
+        hostPID: boolean;
+        affinity?: IAffinity;
+        nodeSelector?: {
+          [selector: string]: string;
+        };
+        tolerations: {
+          key: string;
+          operator: string;
+          effect: string;
+          tolerationSeconds: number;
+        }[];
+        schedulerName: string;
+      };
+    };
+    containers?: IPodContainer[];
+    restartPolicy?: string;
+    terminationGracePeriodSeconds?: number;
+    dnsPolicy?: string;
+    serviceAccountName?: string;
+    serviceAccount?: string;
+    schedulerName?: string;
+  }
+  status: {
+    conditions: {
+      type: string;
+      status: string;
+      lastProbeTime: string;
+      lastTransitionTime: string;
+      message?: string;
+    }[];
+    startTime: string;
+    completionTime: string;
+    succeeded: number;
+  }
+
+  getDesiredCompletions() {
+    return this.spec.completions || 0;
+  }
+
+  getCompletions() {
+    return this.status.succeeded || 0;
+  }
+
+  getParallelism() {
+    return this.spec.parallelism;
+  }
+
+  getCondition() {
+    // Type of Job condition could be only Complete or Failed
+    // https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.14/#jobcondition-v1-batch
+    const { conditions } = this.status;
+    if (!conditions) return;
+    return conditions.find(({ status }) => status === "True");
+  }
+
+  getImages() {
+    const containers: IPodContainer[] = get(this, "spec.template.spec.containers", [])
+    return [...containers].map(container => container.image)
+  }
+
+  delete() {
+    const params: JsonApiParams = {
+      query: { propagationPolicy: "Background" }
+    }
+    return super.delete(params)
+  }
+}
+
+export const jobApi = new KubeApi({
+  kind: Job.kind,
+  apiBase: "/apis/batch/v1/jobs",
+  isNamespaced: true,
+  objectConstructor: Job,
+});

src/renderer/api/endpoints/kubeconfig.api.ts

@@ -0,0 +1,12 @@
+// Kubeconfig api
+import { apiBase } from "../index";
+
+export const kubeConfigApi = {
+  getUserConfig() {
+    return apiBase.get("/kubeconfig/user");
+  },
+
+  getServiceAccountConfig(account: string, namespace: string) {
+    return apiBase.get(`/kubeconfig/service-account/${namespace}/${account}`);
+  },
+};

src/renderer/api/endpoints/metrics.api.ts

@@ -0,0 +1,130 @@
+// Metrics api
+
+import moment from "moment";
+import { apiBase } from "../index";
+import type { IMetricsQuery } from "../../../main/routes/metrics";
+
+export interface IMetrics {
+  status: string;
+  data: {
+    resultType: string;
+    result: IMetricsResult[];
+  };
+}
+
+export interface IMetricsResult {
+  metric: {
+    [name: string]: string;
+    instance: string;
+    node?: string;
+    pod?: string;
+    kubernetes?: string;
+    kubernetes_node?: string;
+    kubernetes_namespace?: string;
+  };
+  values: [number, string][];
+}
+
+export interface IMetricsReqParams {
+  start?: number | string;        // timestamp in seconds or valid date-string
+  end?: number | string;
+  step?: number;                  // step in seconds (default: 60s = each point 1m)
+  range?: number;                 // time-range in seconds for data aggregation (default: 3600s = last 1h)
+  namespace?: string;             // rbac-proxy validation param
+}
+
+export const metricsApi = {
+  async getMetrics<T = IMetricsQuery>(query: T, reqParams: IMetricsReqParams = {}): Promise<T extends object ? { [K in keyof T]: IMetrics } : IMetrics> {
+    const { range = 3600, step = 60, namespace } = reqParams;
+    let { start, end } = reqParams;
+
+    if (!start && !end) {
+      const timeNow = Date.now() / 1000;
+      const now = moment.unix(timeNow).startOf('minute').unix();  // round date to minutes
+      start = now - range;
+      end = now;
+    }
+
+    return apiBase.post("/metrics", {
+      data: query,
+      query: {
+        start, end, step,
+        "kubernetes_namespace": namespace,
+      }
+    });
+  },
+};
+
+export function normalizeMetrics(metrics: IMetrics, frames = 60): IMetrics {
+  if (!metrics?.data?.result) {
+    return {
+      data: {
+        resultType: "",
+        result: [{
+          metric: {},
+          values: []
+        } as IMetricsResult],
+      },
+      status: "",
+    }
+  }
+
+  const { result } = metrics.data;
+
+  if (result.length) {
+    if (frames > 0) {
+      // fill the gaps
+      result.forEach(res => {
+        if (!res.values || !res.values.length) return;
+        while (res.values.length < frames) {
+          const timestamp = moment.unix(res.values[0][0]).subtract(1, "minute").unix();
+          res.values.unshift([timestamp, "0"])
+        }
+      });
+    }
+  }
+  else {
+    // always return at least empty values array
+    result.push({
+      metric: {},
+      values: []
+    } as IMetricsResult);
+  }
+
+  return metrics;
+}
+
+export function isMetricsEmpty(metrics: { [key: string]: IMetrics }) {
+  return Object.values(metrics).every(metric => !metric?.data?.result?.length);
+}
+
+export function getItemMetrics(metrics: { [key: string]: IMetrics }, itemName: string): { [key: string]: IMetrics } {
+  if (!metrics) return;
+  const itemMetrics = { ...metrics };
+  for (const metric in metrics) {
+    if (!metrics[metric]?.data?.result) {
+      continue
+    }
+    const results = metrics[metric].data.result;
+    const result = results.find(res => Object.values(res.metric)[0] == itemName);
+    itemMetrics[metric].data.result = result ? [result] : [];
+  }
+  return itemMetrics;
+}
+
+export function getMetricLastPoints(metrics: { [key: string]: IMetrics }) {
+  const result: Partial<{ [metric: string]: number }> = {};
+
+  Object.keys(metrics).forEach(metricName => {
+    try {
+      const metric = metrics[metricName];
+      if (metric.data.result.length) {
+        result[metricName] = +metric.data.result[0].values.slice(-1)[0][1];
+      }
+    } catch (e) {
+    }
+    return result;
+  }, {});
+
+  return result;
+}

src/renderer/api/endpoints/namespaces.api.ts

@@ -0,0 +1,28 @@
+import { KubeApi } from "../kube-api";
+import { KubeObject } from "../kube-object";
+import { autobind } from "../../utils";
+
+export enum NamespaceStatus {
+  ACTIVE = "Active",
+  TERMINATING = "Terminating",
+}
+
+@autobind()
+export class Namespace extends KubeObject {
+  static kind = "Namespace";
+
+  status?: {
+    phase: string;
+  }
+
+  getStatus() {
+    return this.status ? this.status.phase : "-";
+  }
+}
+
+export const namespacesApi = new KubeApi({
+  kind: Namespace.kind,
+  apiBase: "/api/v1/namespaces",
+  isNamespaced: false,
+  objectConstructor: Namespace,
+});

src/renderer/api/endpoints/network-policy.api.ts

@@ -0,0 +1,72 @@
+import { KubeObject } from "../kube-object";
+import { autobind } from "../../utils";
+import { KubeApi } from "../kube-api";
+
+export interface IPolicyIpBlock {
+  cidr: string;
+  except?: string[];
+}
+
+export interface IPolicySelector {
+  matchLabels: {
+    [label: string]: string;
+  };
+}
+
+export interface IPolicyIngress {
+  from: {
+    ipBlock?: IPolicyIpBlock;
+    namespaceSelector?: IPolicySelector;
+    podSelector?: IPolicySelector;
+  }[];
+  ports: {
+    protocol: string;
+    port: number;
+  }[];
+}
+
+export interface IPolicyEgress {
+  to: {
+    ipBlock: IPolicyIpBlock;
+  }[];
+  ports: {
+    protocol: string;
+    port: number;
+  }[];
+}
+
+@autobind()
+export class NetworkPolicy extends KubeObject {
+  static kind = "NetworkPolicy"
+
+  spec: {
+    podSelector: {
+      matchLabels: {
+        [label: string]: string;
+        role: string;
+      };
+    };
+    policyTypes: string[];
+    ingress: IPolicyIngress[];
+    egress: IPolicyEgress[];
+  }
+
+  getMatchLabels(): string[] {
+    if (!this.spec.podSelector || !this.spec.podSelector.matchLabels) return [];
+    return Object
+      .entries(this.spec.podSelector.matchLabels)
+      .map(data => data.join(":"))
+  }
+
+  getTypes(): string[] {
+    if (!this.spec.policyTypes) return [];
+    return this.spec.policyTypes;
+  }
+}
+
+export const networkPolicyApi = new KubeApi({
+  kind: NetworkPolicy.kind,
+  apiBase: "/apis/networking.k8s.io/v1/networkpolicies",
+  isNamespaced: true,
+  objectConstructor: NetworkPolicy,
+});

src/renderer/api/endpoints/nodes.api.ts

@@ -0,0 +1,163 @@
+import { KubeObject } from "../kube-object";
+import { autobind, cpuUnitsToNumber, unitsToBytes } from "../../utils";
+import { IMetrics, metricsApi } from "./metrics.api";
+import { KubeApi } from "../kube-api";
+
+export class NodesApi extends KubeApi<Node> {
+  getMetrics(): Promise<INodeMetrics> {
+    const opts = { category: "nodes"}
+
+    return metricsApi.getMetrics({
+      memoryUsage: opts,
+      memoryCapacity: opts,
+      cpuUsage: opts,
+      cpuCapacity: opts,
+      fsSize: opts,
+      fsUsage: opts
+    });
+  }
+}
+
+export interface INodeMetrics<T = IMetrics> {
+  [metric: string]: T;
+  memoryUsage: T;
+  memoryCapacity: T;
+  cpuUsage: T;
+  cpuCapacity: T;
+  fsUsage: T;
+  fsSize: T;
+}
+
+@autobind()
+export class Node extends KubeObject {
+  static kind = "Node"
+
+  spec: {
+    podCIDR: string;
+    externalID: string;
+    taints?: {
+      key: string;
+      value: string;
+      effect: string;
+    }[];
+    unschedulable?: boolean;
+  }
+  status: {
+    capacity: {
+      cpu: string;
+      memory: string;
+      pods: string;
+    };
+    allocatable: {
+      cpu: string;
+      memory: string;
+      pods: string;
+    };
+    conditions: {
+      type: string;
+      status?: string;
+      lastHeartbeatTime?: string;
+      lastTransitionTime?: string;
+      reason?: string;
+      message?: string;
+    }[];
+    addresses: {
+      type: string;
+      address: string;
+    }[];
+    nodeInfo: {
+      machineID: string;
+      systemUUID: string;
+      bootID: string;
+      kernelVersion: string;
+      osImage: string;
+      containerRuntimeVersion: string;
+      kubeletVersion: string;
+      kubeProxyVersion: string;
+      operatingSystem: string;
+      architecture: string;
+    };
+    images: {
+      names: string[];
+      sizeBytes: number;
+    }[];
+  }
+
+  getNodeConditionText() {
+    const { conditions } = this.status
+    if (!conditions) return ""
+    return conditions.reduce((types, current) => {
+      if (current.status !== "True") return ""
+      return types += ` ${current.type}`
+    }, "")
+  }
+
+  getTaints() {
+    return this.spec.taints || [];
+  }
+
+  getRoleLabels() {
+    const roleLabels = Object.keys(this.metadata.labels).filter(key =>
+      key.includes("node-role.kubernetes.io")
+    ).map(key => key.match(/([^/]+$)/)[0]) // all after last slash
+
+    if (this.metadata.labels["kubernetes.io/role"] != undefined) {
+      roleLabels.push(this.metadata.labels["kubernetes.io/role"])
+    }
+
+    return roleLabels.join(", ")
+  }
+
+  getCpuCapacity() {
+    if (!this.status.capacity || !this.status.capacity.cpu) return 0
+    return cpuUnitsToNumber(this.status.capacity.cpu)
+  }
+
+  getMemoryCapacity() {
+    if (!this.status.capacity || !this.status.capacity.memory) return 0
+    return unitsToBytes(this.status.capacity.memory)
+  }
+
+  getConditions() {
+    const conditions = this.status.conditions || [];
+    if (this.isUnschedulable()) {
+      return [{ type: "SchedulingDisabled", status: "True" }, ...conditions];
+    }
+    return conditions;
+  }
+
+  getActiveConditions() {
+    return this.getConditions().filter(c => c.status === "True");
+  }
+
+  getWarningConditions() {
+    const goodConditions = ["Ready", "HostUpgrades", "SchedulingDisabled"];
+    return this.getActiveConditions().filter(condition => {
+      return !goodConditions.includes(condition.type);
+    });
+  }
+
+  getKubeletVersion() {
+    return this.status.nodeInfo.kubeletVersion;
+  }
+
+  getOperatingSystem(): string {
+    const label = this.getLabels().find(label => label.startsWith("kubernetes.io/os="))
+    if (label) {
+      return label.split("=", 2)[1]
+    }
+
+    return "linux"
+  }
+
+  isUnschedulable() {
+    return this.spec.unschedulable
+  }
+}
+
+export const nodesApi = new NodesApi({
+  kind: Node.kind,
+  apiBase: "/api/v1/nodes",
+  isNamespaced: false,
+  objectConstructor: Node,
+});

src/renderer/api/endpoints/persistent-volume-claims.api.ts

@@ -0,0 +1,88 @@
+import { KubeObject } from "../kube-object";
+import { autobind } from "../../utils";
+import { IMetrics, metricsApi } from "./metrics.api";
+import { Pod } from "./pods.api";
+import { KubeApi } from "../kube-api";
+
+export class PersistentVolumeClaimsApi extends KubeApi<PersistentVolumeClaim> {
+  getMetrics(pvcName: string, namespace: string): Promise<IPvcMetrics> {
+    return metricsApi.getMetrics({
+      diskUsage: { category: 'pvc', pvc: pvcName },
+      diskCapacity: { category: 'pvc', pvc: pvcName }
+    }, {
+      namespace
+    });
+  }
+}
+
+export interface IPvcMetrics<T = IMetrics> {
+  [key: string]: T;
+  diskUsage: T;
+  diskCapacity: T;
+}
+
+@autobind()
+export class PersistentVolumeClaim extends KubeObject {
+  static kind = "PersistentVolumeClaim"
+
+  spec: {
+    accessModes: string[];
+    storageClassName: string;
+    selector: {
+      matchLabels: {
+        release: string;
+      };
+      matchExpressions: {
+        key: string; // environment,
+        operator: string; // In,
+        values: string[]; // [dev]
+      }[];
+    };
+    resources: {
+      requests: {
+        storage: string; // 8Gi
+      };
+    };
+  }
+  status: {
+    phase: string; // Pending
+  }
+
+  getPods(allPods: Pod[]): Pod[] {
+    const pods = allPods.filter(pod => pod.getNs() === this.getNs())
+    return pods.filter(pod => {
+      return pod.getVolumes().filter(volume =>
+        volume.persistentVolumeClaim &&
+        volume.persistentVolumeClaim.claimName === this.getName()
+      ).length > 0
+    })
+  }
+
+  getStorage(): string {
+    if (!this.spec.resources || !this.spec.resources.requests) return "-";
+    return this.spec.resources.requests.storage;
+  }
+
+  getMatchLabels(): string[] {
+    if (!this.spec.selector || !this.spec.selector.matchLabels) return [];
+    return Object.entries(this.spec.selector.matchLabels)
+      .map(([name, val]) => `${name}:${val}`);
+  }
+
+  getMatchExpressions() {
+    if (!this.spec.selector || !this.spec.selector.matchExpressions) return [];
+    return this.spec.selector.matchExpressions;
+  }
+
+  getStatus(): string {
+    if (this.status) return this.status.phase;
+    return "-"
+  }
+}
+
+export const pvcApi = new PersistentVolumeClaimsApi({
+  kind: PersistentVolumeClaim.kind,
+  apiBase: "/api/v1/persistentvolumeclaims",
+  isNamespaced: true,
+  objectConstructor: PersistentVolumeClaim,
+});

src/renderer/api/endpoints/persistent-volume.api.ts

@@ -0,0 +1,71 @@
+import { KubeObject } from "../kube-object";
+import { unitsToBytes } from "../../utils/convertMemory";
+import { autobind } from "../../utils";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class PersistentVolume extends KubeObject {
+  static kind = "PersistentVolume"
+
+  spec: {
+    capacity: {
+      storage: string; // 8Gi
+    };
+    flexVolume: {
+      driver: string; // ceph.rook.io/rook-ceph-system,
+      options: {
+        clusterNamespace: string; // rook-ceph,
+        image: string; // pvc-c5d7c485-9f1b-11e8-b0ea-9600000e54fb,
+        pool: string; // replicapool,
+        storageClass: string; // rook-ceph-block
+      };
+    };
+    mountOptions?: string[];
+    accessModes: string[]; // [ReadWriteOnce]
+    claimRef: {
+      kind: string; // PersistentVolumeClaim,
+      namespace: string; // storage,
+      name: string; // nfs-provisioner,
+      uid: string; // c5d7c485-9f1b-11e8-b0ea-9600000e54fb,
+      apiVersion: string; // v1,
+      resourceVersion: string; // 292180
+    };
+    persistentVolumeReclaimPolicy: string; // Delete,
+    storageClassName: string; // rook-ceph-block
+    nfs?: {
+      path: string;
+      server: string;
+    };
+  }
+
+  status: {
+    phase: string;
+    reason?: string;
+  }
+
+  getCapacity(inBytes = false) {
+    const capacity = this.spec.capacity;
+    if (capacity) {
+      if (inBytes) return unitsToBytes(capacity.storage)
+      return capacity.storage;
+    }
+    return 0;
+  }
+
+  getStatus() {
+    if (!this.status) return;
+    return this.status.phase || "-";
+  }
+
+  getClaimRefName() {
+    const { claimRef } = this.spec;
+    return claimRef ? claimRef.name : "";
+  }
+}
+
+export const persistentVolumeApi = new KubeApi({
+  kind: PersistentVolume.kind,
+  apiBase: "/api/v1/persistentvolumes",
+  isNamespaced: false,
+  objectConstructor: PersistentVolume,
+});

src/renderer/api/endpoints/pod-metrics.api.ts

@@ -0,0 +1,21 @@
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+export class PodMetrics extends KubeObject {
+  timestamp: string
+  window: string
+  containers: {
+    name: string;
+    usage: {
+      cpu: string;
+      memory: string;
+    };
+  }[]
+}
+
+export const podMetricsApi = new KubeApi({
+  kind: PodMetrics.kind,
+  apiBase: "/apis/metrics.k8s.io/v1beta1/pods",
+  isNamespaced: true,
+  objectConstructor: PodMetrics,
+});

src/renderer/api/endpoints/pods.api.ts

@@ -0,0 +1,423 @@
+import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
+import { autobind } from "../../utils";
+import { IMetrics, metricsApi } from "./metrics.api";
+import { KubeApi } from "../kube-api";
+
+export class PodsApi extends KubeApi<Pod> {
+  async getLogs(params: { namespace: string; name: string }, query?: IPodLogsQuery): Promise<string> {
+    const path = this.getUrl(params) + "/log";
+    return this.request.get(path, { query });
+  }
+
+  getMetrics(pods: Pod[], namespace: string, selector = "pod, namespace"): Promise<IPodMetrics> {
+    const podSelector = pods.map(pod => pod.getName()).join("|");
+    const opts = { category: "pods", pods: podSelector, namespace, selector }
+
+    return metricsApi.getMetrics({
+      cpuUsage: opts,
+      cpuRequests: opts,
+      cpuLimits: opts,
+      memoryUsage: opts,
+      memoryRequests: opts,
+      memoryLimits: opts,
+      fsUsage: opts,
+      networkReceive: opts,
+      networkTransmit: opts,
+    }, {
+      namespace,
+    });
+  }
+}
+
+export interface IPodMetrics<T = IMetrics> {
+  [metric: string]: T;
+  cpuUsage: T;
+  cpuRequests: T;
+  cpuLimits: T;
+  memoryUsage: T;
+  memoryRequests: T;
+  memoryLimits: T;
+  fsUsage: T;
+  networkReceive: T;
+  networkTransmit: T;
+}
+
+export interface IPodLogsQuery {
+  container?: string;
+  tailLines?: number;
+  timestamps?: boolean;
+  sinceTime?: string; // Date.toISOString()-format
+}
+
+export enum PodStatus {
+  TERMINATED = "Terminated",
+  FAILED = "Failed",
+  PENDING = "Pending",
+  RUNNING = "Running",
+  SUCCEEDED = "Succeeded",
+  EVICTED = "Evicted"
+}
+
+export interface IPodContainer {
+  name: string;
+  image: string;
+  command?: string[];
+  args?: string[];
+  ports: {
+    name?: string;
+    containerPort: number;
+    protocol: string;
+  }[];
+  resources?: {
+    limits: {
+      cpu: string;
+      memory: string;
+    };
+    requests: {
+      cpu: string;
+      memory: string;
+    };
+  };
+  env?: {
+    name: string;
+    value?: string;
+    valueFrom?: {
+      fieldRef?: {
+        apiVersion: string;
+        fieldPath: string;
+      };
+      secretKeyRef?: {
+        key: string;
+        name: string;
+      };
+      configMapKeyRef?: {
+        key: string;
+        name: string;
+      };
+    };
+  }[];
+  envFrom?: {
+    configMapRef?: {
+      name: string;
+    };
+  }[];
+  volumeMounts?: {
+    name: string;
+    readOnly: boolean;
+    mountPath: string;
+  }[];
+  livenessProbe?: IContainerProbe;
+  readinessProbe?: IContainerProbe;
+  imagePullPolicy: string;
+}
+
+interface IContainerProbe {
+  httpGet?: {
+    path?: string;
+    port: number;
+    scheme: string;
+    host?: string;
+  };
+  exec?: {
+    command: string[];
+  };
+  tcpSocket?: {
+    port: number;
+  };
+  initialDelaySeconds?: number;
+  timeoutSeconds?: number;
+  periodSeconds?: number;
+  successThreshold?: number;
+  failureThreshold?: number;
+}
+
+export interface IPodContainerStatus {
+  name: string;
+  state: {
+    [index: string]: object;
+    running?: {
+      startedAt: string;
+    };
+    waiting?: {
+      reason: string;
+      message: string;
+    };
+    terminated?: {
+      startedAt: string;
+      finishedAt: string;
+      exitCode: number;
+      reason: string;
+    };
+  };
+  lastState: {};
+  ready: boolean;
+  restartCount: number;
+  image: string;
+  imageID: string;
+  containerID: string;
+}
+
+@autobind()
+export class Pod extends WorkloadKubeObject {
+  static kind = "Pod"
+
+  spec: {
+    volumes?: {
+      name: string;
+      persistentVolumeClaim: {
+        claimName: string;
+      };
+      emptyDir: {
+        medium?: string;
+        sizeLimit?: string;
+      };
+      configMap: {
+        name: string;
+      };
+      secret: {
+        secretName: string;
+        defaultMode: number;
+      };
+    }[];
+    initContainers: IPodContainer[];
+    containers: IPodContainer[];
+    restartPolicy: string;
+    terminationGracePeriodSeconds: number;
+    dnsPolicy: string;
+    serviceAccountName: string;
+    serviceAccount: string;
+    priority: number;
+    priorityClassName: string;
+    nodeName: string;
+    nodeSelector?: {
+      [selector: string]: string;
+    };
+    securityContext: {};
+    schedulerName: string;
+    tolerations: {
+      key: string;
+      operator: string;
+      effect: string;
+      tolerationSeconds: number;
+    }[];
+    affinity: IAffinity;
+  }
+  status: {
+    phase: string;
+    conditions: {
+      type: string;
+      status: string;
+      lastProbeTime: number;
+      lastTransitionTime: string;
+    }[];
+    hostIP: string;
+    podIP: string;
+    startTime: string;
+    initContainerStatuses?: IPodContainerStatus[];
+    containerStatuses?: IPodContainerStatus[];
+    qosClass: string;
+    reason?: string;
+  }
+
+  getInitContainers() {
+    return this.spec.initContainers || [];
+  }
+
+  getContainers() {
+    return this.spec.containers || [];
+  }
+
+  getAllContainers() {
+    return this.getContainers().concat(this.getInitContainers());
+  }
+
+  getRunningContainers() {
+    const statuses = this.getContainerStatuses()
+    return this.getAllContainers().filter(container => {
+      return statuses.find(status => status.name === container.name && !!status.state["running"])
+    }
+    )
+  }
+
+  getContainerStatuses(includeInitContainers = true) {
+    const statuses: IPodContainerStatus[] = [];
+    const { containerStatuses, initContainerStatuses } = this.status;
+    if (containerStatuses) {
+      statuses.push(...containerStatuses);
+    }
+    if (includeInitContainers && initContainerStatuses) {
+      statuses.push(...initContainerStatuses);
+    }
+    return statuses;
+  }
+
+  getRestartsCount(): number {
+    const { containerStatuses } = this.status;
+    if (!containerStatuses) return 0;
+    return containerStatuses.reduce((count, item) => count + item.restartCount, 0);
+  }
+
+  getQosClass() {
+    return this.status.qosClass || "";
+  }
+
+  getReason() {
+    return this.status.reason || "";
+  }
+
+  getPriorityClassName() {
+    return this.spec.priorityClassName || "";
+  }
+
+  // Returns one of 5 statuses: Running, Succeeded, Pending, Failed, Evicted
+  getStatus() {
+    const phase = this.getStatusPhase();
+    const reason = this.getReason();
+    const goodConditions = ["Initialized", "Ready"].every(condition =>
+      !!this.getConditions().find(item => item.type === condition && item.status === "True")
+    );
+    if (reason === PodStatus.EVICTED) {
+      return PodStatus.EVICTED;
+    }
+    if (phase === PodStatus.FAILED) {
+      return PodStatus.FAILED;
+    }
+    if (phase === PodStatus.SUCCEEDED) {
+      return PodStatus.SUCCEEDED;
+    }
+    if (phase === PodStatus.RUNNING && goodConditions) {
+      return PodStatus.RUNNING;
+    }
+    return PodStatus.PENDING;
+  }
+
+  // Returns pod phase or container error if occured
+  getStatusMessage() {
+    if (this.getReason() === PodStatus.EVICTED) return "Evicted";
+    if (this.getStatus() === PodStatus.RUNNING && this.metadata.deletionTimestamp) return "Terminating";
+
+    let message = "";
+    const statuses = this.getContainerStatuses(false); // not including initContainers
+    if (statuses.length) {
+      statuses.forEach(status => {
+        const { state } = status;
+        if (state.waiting) {
+          const { reason } = state.waiting;
+          message = reason ? reason : "Waiting";
+        }
+        if (state.terminated) {
+          const { reason } = state.terminated;
+          message = reason ? reason : "Terminated";
+        }
+      })
+    }
+    if (message) return message;
+    return this.getStatusPhase();
+  }
+
+  getStatusPhase() {
+    return this.status.phase;
+  }
+
+  getConditions() {
+    return this.status.conditions || [];
+  }
+
+  getVolumes() {
+    return this.spec.volumes || [];
+  }
+
+  getSecrets(): string[] {
+    return this.getVolumes()
+      .filter(vol => vol.secret)
+      .map(vol => vol.secret.secretName);
+  }
+
+  getNodeSelectors(): string[] {
+    const { nodeSelector } = this.spec
+    if (!nodeSelector) return []
+    return Object.entries(nodeSelector).map(values => values.join(": "))
+  }
+
+  getTolerations() {
+    return this.spec.tolerations || []
+  }
+
+  getAffinity(): IAffinity {
+    return this.spec.affinity
+  }
+
+  hasIssues() {
+    const notReady = !!this.getConditions().find(condition => {
+      return condition.type == "Ready" && condition.status !== "True"
+    });
+    const crashLoop = !!this.getContainerStatuses().find(condition => {
+      const waiting = condition.state.waiting
+      return (waiting && waiting.reason == "CrashLoopBackOff")
+    })
+    return (
+      notReady ||
+      crashLoop ||
+      this.getStatusPhase() !== "Running"
+    )
+  }
+
+  getLivenessProbe(container: IPodContainer) {
+    return this.getProbe(container.livenessProbe);
+  }
+
+  getReadinessProbe(container: IPodContainer) {
+    return this.getProbe(container.readinessProbe);
+  }
+
+  getProbe(probeData: IContainerProbe) {
+    if (!probeData) return [];
+    const {
+      httpGet, exec, tcpSocket, initialDelaySeconds, timeoutSeconds,
+      periodSeconds, successThreshold, failureThreshold
+    } = probeData;
+    const probe = [];
+    // HTTP Request
+    if (httpGet) {
+      const { path, port, host, scheme } = httpGet;
+      probe.push(
+        "http-get",
+        `${scheme.toLowerCase()}://${host || ""}:${port || ""}${path || ""}`,
+      );
+    }
+    // Command
+    if (exec && exec.command) {
+      probe.push(`exec [${exec.command.join(" ")}]`);
+    }
+    // TCP Probe
+    if (tcpSocket && tcpSocket.port) {
+      probe.push(`tcp-socket :${tcpSocket.port}`);
+    }
+    probe.push(
+      `delay=${initialDelaySeconds || "0"}s`,
+      `timeout=${timeoutSeconds || "0"}s`,
+      `period=${periodSeconds || "0"}s`,
+      `#success=${successThreshold || "0"}`,
+      `#failure=${failureThreshold || "0"}`,
+    );
+    return probe;
+  }
+
+  getNodeName() {
+    return this.spec?.nodeName
+  }
+
+  getSelectedNodeOs() {
+    if (!this.spec.nodeSelector) return
+    if (!this.spec.nodeSelector["kubernetes.io/os"] && !this.spec.nodeSelector["beta.kubernetes.io/os"]) return
+
+    return this.spec.nodeSelector["kubernetes.io/os"] || this.spec.nodeSelector["beta.kubernetes.io/os"]
+  }
+}
+
+export const podsApi = new PodsApi({
+  kind: Pod.kind,
+  apiBase: "/api/v1/pods",
+  isNamespaced: true,
+  objectConstructor: Pod,
+});

src/renderer/api/endpoints/podsecuritypolicy.api.ts

@@ -0,0 +1,94 @@
+import { autobind } from "../../utils";
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class PodSecurityPolicy extends KubeObject {
+  static kind = "PodSecurityPolicy"
+
+  spec: {
+    allowPrivilegeEscalation?: boolean;
+    allowedCSIDrivers?: {
+      name: string;
+    }[];
+    allowedCapabilities: string[];
+    allowedFlexVolumes?: {
+      driver: string;
+    }[];
+    allowedHostPaths?: {
+      pathPrefix: string;
+      readOnly: boolean;
+    }[];
+    allowedProcMountTypes?: string[];
+    allowedUnsafeSysctls?: string[];
+    defaultAddCapabilities?: string[];
+    defaultAllowPrivilegeEscalation?: boolean;
+    forbiddenSysctls?: string[];
+    fsGroup?: {
+      rule: string;
+      ranges: { max: number; min: number }[];
+    };
+    hostIPC?: boolean;
+    hostNetwork?: boolean;
+    hostPID?: boolean;
+    hostPorts?: {
+      max: number;
+      min: number;
+    }[];
+    privileged?: boolean;
+    readOnlyRootFilesystem?: boolean;
+    requiredDropCapabilities?: string[];
+    runAsGroup?: {
+      ranges: { max: number; min: number }[];
+      rule: string;
+    };
+    runAsUser?: {
+      rule: string;
+      ranges: { max: number; min: number }[];
+    };
+    runtimeClass?: {
+      allowedRuntimeClassNames: string[];
+      defaultRuntimeClassName: string;
+    };
+    seLinux?: {
+      rule: string;
+      seLinuxOptions: {
+        level: string;
+        role: string;
+        type: string;
+        user: string;
+      };
+    };
+    supplementalGroups?: {
+      rule: string;
+      ranges: { max: number; min: number }[];
+    };
+    volumes?: string[];
+  }
+
+  isPrivileged() {
+    return !!this.spec.privileged;
+  }
+
+  getVolumes() {
+    return this.spec.volumes || [];
+  }
+
+  getRules() {
+    const { fsGroup, runAsGroup, runAsUser, supplementalGroups, seLinux } = this.spec;
+    return {
+      fsGroup: fsGroup ? fsGroup.rule : "",
+      runAsGroup: runAsGroup ? runAsGroup.rule : "",
+      runAsUser: runAsUser ? runAsUser.rule : "",
+      supplementalGroups: supplementalGroups ? supplementalGroups.rule : "",
+      seLinux: seLinux ? seLinux.rule : "",
+    };
+  }
+}
+
+export const pspApi = new KubeApi({
+  kind: PodSecurityPolicy.kind,
+  apiBase: "/apis/policy/v1beta1/podsecuritypolicies",
+  isNamespaced: false,
+  objectConstructor: PodSecurityPolicy,
+});

src/renderer/api/endpoints/replica-set.api.ts

@@ -0,0 +1,58 @@
+import get from "lodash/get";
+import { autobind } from "../../utils";
+import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
+import { IPodContainer } from "./pods.api";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class ReplicaSet extends WorkloadKubeObject {
+  static kind = "ReplicaSet"
+
+  spec: {
+    replicas?: number;
+    selector?: {
+      matchLabels: {
+        [key: string]: string;
+      };
+    };
+    containers?: IPodContainer[];
+    template?: {
+      spec?: {
+        affinity?: IAffinity;
+        nodeSelector?: {
+          [selector: string]: string;
+        };
+        tolerations: {
+          key: string;
+          operator: string;
+          effect: string;
+          tolerationSeconds: number;
+        }[];
+        containers: IPodContainer[];
+      };
+    };
+    restartPolicy?: string;
+    terminationGracePeriodSeconds?: number;
+    dnsPolicy?: string;
+    schedulerName?: string;
+  }
+  status: {
+    replicas: number;
+    fullyLabeledReplicas: number;
+    readyReplicas: number;
+    availableReplicas: number;
+    observedGeneration: number;
+  }
+
+  getImages() {
+    const containers: IPodContainer[] = get(this, "spec.template.spec.containers", [])
+    return [...containers].map(container => container.image)
+  }
+}
+
+export const replicaSetApi = new KubeApi({
+  kind: ReplicaSet.kind,
+  apiBase: "/apis/apps/v1/replicasets",
+  isNamespaced: true,
+  objectConstructor: ReplicaSet,
+});

src/renderer/api/endpoints/resource-applier.api.ts

@@ -0,0 +1,26 @@
+import jsYaml from "js-yaml"
+import { KubeObject } from "../kube-object";
+import { KubeJsonApiData } from "../kube-json-api";
+import { apiResourceApplier } from "../index";
+import { apiManager } from "../api-manager";
+
+export const resourceApplierApi = {
+  annotations: [
+    "kubectl.kubernetes.io/last-applied-configuration"
+  ],
+
+  async update<D extends KubeObject>(resource: object | string): Promise<D> {
+    if (typeof resource === "string") {
+      resource = jsYaml.safeLoad(resource);
+    }
+    return apiResourceApplier
+      .post<KubeJsonApiData[]>("/stack", { data: resource })
+      .then(data => {
+        const items = data.map(obj => {
+          const api = apiManager.getApi(obj.metadata.selfLink);
+          return new api.objectConstructor(obj);
+        });
+        return items.length === 1 ? items[0] : items;
+      });
+  }
+};

src/renderer/api/endpoints/resource-quota.api.ts

@@ -0,0 +1,68 @@
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+import { KubeJsonApiData } from "../kube-json-api";
+
+export interface IResourceQuotaValues {
+  [quota: string]: string;
+
+  // Compute Resource Quota
+  "limits.cpu"?: string;
+  "limits.memory"?: string;
+  "requests.cpu"?: string;
+  "requests.memory"?: string;
+
+  // Storage Resource Quota
+  "requests.storage"?: string;
+  "persistentvolumeclaims"?: string;
+
+  // Object Count Quota
+  "count/pods"?: string;
+  "count/persistentvolumeclaims"?: string;
+  "count/services"?: string;
+  "count/secrets"?: string;
+  "count/configmaps"?: string;
+  "count/replicationcontrollers"?: string;
+  "count/deployments.apps"?: string;
+  "count/replicasets.apps"?: string;
+  "count/statefulsets.apps"?: string;
+  "count/jobs.batch"?: string;
+  "count/cronjobs.batch"?: string;
+  "count/deployments.extensions"?: string;
+}
+
+export class ResourceQuota extends KubeObject {
+  static kind = "ResourceQuota"
+
+  constructor(data: KubeJsonApiData) {
+    super(data);
+    this.spec = this.spec || {} as any
+  }
+
+  spec: {
+    hard: IResourceQuotaValues;
+    scopeSelector?: {
+      matchExpressions: {
+        operator: string;
+        scopeName: string;
+        values: string[];
+      }[];
+    };
+  }
+
+  status: {
+    hard: IResourceQuotaValues;
+    used: IResourceQuotaValues;
+  }
+
+  getScopeSelector() {
+    const { matchExpressions = [] } = this.spec.scopeSelector || {};
+    return matchExpressions;
+  }
+}
+
+export const resourceQuotaApi = new KubeApi({
+  kind: ResourceQuota.kind,
+  apiBase: "/api/v1/resourcequotas",
+  isNamespaced: true,
+  objectConstructor: ResourceQuota,
+});

src/renderer/api/endpoints/role-binding.api.ts

@@ -0,0 +1,37 @@
+import { autobind } from "../../utils";
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+export interface IRoleBindingSubject {
+  kind: string;
+  name: string;
+  namespace?: string;
+  apiGroup?: string;
+}
+
+@autobind()
+export class RoleBinding extends KubeObject {
+  static kind = "RoleBinding"
+
+  subjects?: IRoleBindingSubject[]
+  roleRef: {
+    kind: string;
+    name: string;
+    apiGroup?: string;
+  }
+
+  getSubjects() {
+    return this.subjects || [];
+  }
+
+  getSubjectNames(): string {
+    return this.getSubjects().map(subject => subject.name).join(", ")
+  }
+}
+
+export const roleBindingApi = new KubeApi({
+  kind: RoleBinding.kind,
+  apiBase: "/apis/rbac.authorization.k8s.io/v1/rolebindings",
+  isNamespaced: true,
+  objectConstructor: RoleBinding,
+});

src/renderer/api/endpoints/role.api.ts

@@ -0,0 +1,24 @@
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+export class Role extends KubeObject {
+  static kind = "Role"
+
+  rules: {
+    verbs: string[];
+    apiGroups: string[];
+    resources: string[];
+    resourceNames?: string[];
+  }[]
+
+  getRules() {
+    return this.rules || [];
+  }
+}
+
+export const roleApi = new KubeApi({
+  kind: Role.kind,
+  apiBase: "/apis/rbac.authorization.k8s.io/v1/roles",
+  isNamespaced: true,
+  objectConstructor: Role,
+});

src/renderer/api/endpoints/secret.api.ts

@@ -0,0 +1,51 @@
+import { KubeObject } from "../kube-object";
+import { KubeJsonApiData } from "../kube-json-api";
+import { autobind } from "../../utils";
+import { KubeApi } from "../kube-api";
+
+export enum SecretType {
+  Opaque = "Opaque",
+  ServiceAccountToken = "kubernetes.io/service-account-token",
+  Dockercfg = "kubernetes.io/dockercfg",
+  DockerConfigJson = "kubernetes.io/dockerconfigjson",
+  BasicAuth = "kubernetes.io/basic-auth",
+  SSHAuth = "kubernetes.io/ssh-auth",
+  TLS = "kubernetes.io/tls",
+  BootstrapToken = "bootstrap.kubernetes.io/token",
+}
+
+export interface ISecretRef {
+  key?: string;
+  name: string;
+}
+
+@autobind()
+export class Secret extends KubeObject {
+  static kind = "Secret"
+
+  type: SecretType;
+  data: {
+    [prop: string]: string;
+    token?: string;
+  }
+
+  constructor(data: KubeJsonApiData) {
+    super(data);
+    this.data = this.data || {};
+  }
+
+  getKeys(): string[] {
+    return Object.keys(this.data);
+  }
+
+  getToken() {
+    return this.data.token;
+  }
+}
+
+export const secretsApi = new KubeApi({
+  kind: Secret.kind,
+  apiBase: "/api/v1/secrets",
+  isNamespaced: true,
+  objectConstructor: Secret,
+});

src/renderer/api/endpoints/selfsubjectrulesreviews.api.ts

@@ -0,0 +1,68 @@
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+export class SelfSubjectRulesReviewApi extends KubeApi<SelfSubjectRulesReview> {
+  create({ namespace = "default" }): Promise<SelfSubjectRulesReview> {
+    return super.create({}, {
+      spec: {
+        namespace
+      },
+    }
+    );
+  }
+}
+
+export interface ISelfSubjectReviewRule {
+  verbs: string[];
+  apiGroups?: string[];
+  resources?: string[];
+  resourceNames?: string[];
+  nonResourceURLs?: string[];
+}
+
+export class SelfSubjectRulesReview extends KubeObject {
+  static kind = "SelfSubjectRulesReview"
+
+  spec: {
+    // fixme: add more types from api docs
+    namespace?: string;
+  }
+
+  status: {
+    resourceRules: ISelfSubjectReviewRule[];
+    nonResourceRules: ISelfSubjectReviewRule[];
+    incomplete: boolean;
+  }
+
+  getResourceRules() {
+    const rules = this.status && this.status.resourceRules || [];
+    return rules.map(rule => this.normalize(rule));
+  }
+
+  getNonResourceRules() {
+    const rules = this.status && this.status.nonResourceRules || [];
+    return rules.map(rule => this.normalize(rule));
+  }
+
+  protected normalize(rule: ISelfSubjectReviewRule): ISelfSubjectReviewRule {
+    const { apiGroups = [], resourceNames = [], verbs = [], nonResourceURLs = [], resources = [] } = rule;
+    return {
+      apiGroups,
+      nonResourceURLs,
+      resourceNames,
+      verbs,
+      resources: resources.map((resource, index) => {
+        const apiGroup = apiGroups.length >= index + 1 ? apiGroups[index] : apiGroups.slice(-1)[0];
+        const separator = apiGroup == "" ? "" : ".";
+        return resource + separator + apiGroup;
+      })
+    }
+  }
+}
+
+export const selfSubjectRulesReviewApi = new SelfSubjectRulesReviewApi({
+  kind: SelfSubjectRulesReview.kind,
+  apiBase: "/apis/authorization.k8s.io/v1/selfsubjectrulesreviews",
+  isNamespaced: false,
+  objectConstructor: SelfSubjectRulesReview,
+});

src/renderer/api/endpoints/service-accounts.api.ts

@@ -0,0 +1,30 @@
+import { autobind } from "../../utils";
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class ServiceAccount extends KubeObject {
+  static kind = "ServiceAccount";
+
+  secrets?: {
+    name: string;
+  }[]
+  imagePullSecrets?: {
+    name: string;
+  }[]
+
+  getSecrets() {
+    return this.secrets || [];
+  }
+
+  getImagePullSecrets() {
+    return this.imagePullSecrets || [];
+  }
+}
+
+export const serviceAccountsApi = new KubeApi<ServiceAccount>({
+  kind: ServiceAccount.kind,
+  apiBase: "/api/v1/serviceaccounts",
+  isNamespaced: true,
+  objectConstructor: ServiceAccount,
+});

src/renderer/api/endpoints/service.api.ts

@@ -0,0 +1,100 @@
+import { autobind } from "../../utils";
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+export interface IServicePort {
+  name?: string;
+  protocol: string;
+  port: number;
+  targetPort: number;
+}
+
+export class ServicePort implements IServicePort {
+  name?: string;
+  protocol: string;
+  port: number;
+  targetPort: number;
+  nodePort?: number;
+
+  constructor(data: IServicePort) {
+    Object.assign(this, data)
+  }
+
+  toString() {
+    if (this.nodePort) {
+      return `${this.port}:${this.nodePort}/${this.protocol}`;
+    } else {
+      return `${this.port}${this.port === this.targetPort ? "" : ":" + this.targetPort}/${this.protocol}`;
+    }
+  }
+}
+
+@autobind()
+export class Service extends KubeObject {
+  static kind = "Service"
+
+  spec: {
+    type: string;
+    clusterIP: string;
+    externalTrafficPolicy?: string;
+    loadBalancerIP?: string;
+    sessionAffinity: string;
+    selector: { [key: string]: string };
+    ports: ServicePort[];
+    externalIPs?: string[]; // https://kubernetes.io/docs/concepts/services-networking/service/#external-ips
+  }
+
+  status: {
+    loadBalancer?: {
+      ingress?: {
+        ip?: string;
+        hostname?: string;
+      }[];
+    };
+  }
+
+  getClusterIp() {
+    return this.spec.clusterIP;
+  }
+
+  getExternalIps() {
+    const lb = this.getLoadBalancer();
+    if (lb && lb.ingress) {
+      return lb.ingress.map(val => val.ip || val.hostname)
+    }
+    return this.spec.externalIPs || [];
+  }
+
+  getType() {
+    return this.spec.type || "-";
+  }
+
+  getSelector(): string[] {
+    if (!this.spec.selector) return [];
+    return Object.entries(this.spec.selector).map(val => val.join("="));
+  }
+
+  getPorts(): ServicePort[] {
+    const ports = this.spec.ports || [];
+    return ports.map(p => new ServicePort(p));
+  }
+
+  getLoadBalancer() {
+    return this.status.loadBalancer;
+  }
+
+  isActive() {
+    return this.getType() !== "LoadBalancer" || this.getExternalIps().length > 0;
+  }
+
+  getStatus() {
+    return this.isActive() ? "Active" : "Pending";
+  }
+}
+
+export const serviceApi = new KubeApi({
+  kind: Service.kind,
+  apiBase: "/api/v1/services",
+  isNamespaced: true,
+  objectConstructor: Service,
+});

src/renderer/api/endpoints/stateful-set.api.ts

@@ -0,0 +1,84 @@
+import get from "lodash/get";
+import { IPodContainer } from "./pods.api";
+import { IAffinity, WorkloadKubeObject } from "../workload-kube-object";
+import { autobind } from "../../utils";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class StatefulSet extends WorkloadKubeObject {
+  static kind = "StatefulSet"
+
+  spec: {
+    serviceName: string;
+    replicas: number;
+    selector: {
+      matchLabels: {
+        [key: string]: string;
+      };
+    };
+    template: {
+      metadata: {
+        labels: {
+          app: string;
+        };
+      };
+      spec: {
+        containers: {
+          name: string;
+          image: string;
+          ports: {
+            containerPort: number;
+            name: string;
+          }[];
+          volumeMounts: {
+            name: string;
+            mountPath: string;
+          }[];
+        }[];
+        affinity?: IAffinity;
+        nodeSelector?: {
+          [selector: string]: string;
+        };
+        tolerations: {
+          key: string;
+          operator: string;
+          effect: string;
+          tolerationSeconds: number;
+        }[];
+      };
+    };
+    volumeClaimTemplates: {
+      metadata: {
+        name: string;
+      };
+      spec: {
+        accessModes: string[];
+        resources: {
+          requests: {
+            storage: string;
+          };
+        };
+      };
+    }[];
+  }
+  status: {
+    observedGeneration: number;
+    replicas: number;
+    currentReplicas: number;
+    currentRevision: string;
+    updateRevision: string;
+    collisionCount: number;
+  }
+
+  getImages() {
+    const containers: IPodContainer[] = get(this, "spec.template.spec.containers", [])
+    return [...containers].map(container => container.image)
+  }
+}
+
+export const statefulSetApi = new KubeApi({
+  kind: StatefulSet.kind,
+  apiBase: "/apis/apps/v1/statefulsets",
+  isNamespaced: true,
+  objectConstructor: StatefulSet,
+});

src/renderer/api/endpoints/storage-class.api.ts

@@ -0,0 +1,39 @@
+import { autobind } from "../../utils";
+import { KubeObject } from "../kube-object";
+import { KubeApi } from "../kube-api";
+
+@autobind()
+export class StorageClass extends KubeObject {
+  static kind = "StorageClass"
+
+  provisioner: string; // e.g. "storage.k8s.io/v1"
+  mountOptions?: string[];
+  volumeBindingMode: string;
+  reclaimPolicy: string;
+  parameters: {
+    [param: string]: string; // every provisioner has own set of these parameters
+  }
+
+  isDefault() {
+    const annotations = this.metadata.annotations || {};
+    return (
+      annotations["storageclass.kubernetes.io/is-default-class"] === "true" ||
+      annotations["storageclass.beta.kubernetes.io/is-default-class"] === "true"
+    )
+  }
+
+  getVolumeBindingMode() {
+    return this.volumeBindingMode || "-"
+  }
+
+  getReclaimPolicy() {
+    return this.reclaimPolicy || "-"
+  }
+}
+
+export const storageClassApi = new KubeApi({
+  kind: StorageClass.kind,
+  apiBase: "/apis/storage.k8s.io/v1/storageclasses",
+  isNamespaced: false,
+  objectConstructor: StorageClass,
+});

src/renderer/api/index.ts

@@ -0,0 +1,38 @@
+import { JsonApi, JsonApiErrorParsed } from "./json-api";
+import { KubeJsonApi } from "./kube-json-api";
+import { Notifications } from "../components/notifications";
+import { apiPrefix, isDevelopment } from "../../common/vars";
+
+//-- JSON HTTP APIS
+
+export const apiBase = new JsonApi({
+  debug: isDevelopment,
+  apiPrefix: apiPrefix.BASE,
+});
+export const apiKube = new KubeJsonApi({
+  debug: isDevelopment,
+  apiPrefix: apiPrefix.KUBE_BASE,
+});
+export const apiHelm = new KubeJsonApi({
+  debug: isDevelopment,
+  apiPrefix: apiPrefix.KUBE_HELM,
+});
+export const apiResourceApplier = new KubeJsonApi({
+  debug: isDevelopment,
+  apiPrefix: apiPrefix.KUBE_RESOURCE_APPLIER,
+});
+
+// Common handler for HTTP api errors
+function onApiError(error: JsonApiErrorParsed, res: Response) {
+  switch (res.status) {
+  case 403:
+    error.isUsedForNotification = true;
+    Notifications.error(error);
+    break;
+  }
+}
+
+apiBase.onError.addListener(onApiError);
+apiKube.onError.addListener(onApiError);
+apiHelm.onError.addListener(onApiError);
+apiResourceApplier.onError.addListener(onApiError);

src/renderer/api/json-api.ts

@@ -0,0 +1,155 @@
+// Base http-service / json-api class
+
+import { stringify } from "querystring";
+import { EventEmitter } from "../utils/eventEmitter";
+import { cancelableFetch } from "../utils/cancelableFetch";
+
+export interface JsonApiData {
+}
+
+export interface JsonApiError {
+  code?: number;
+  message?: string;
+  errors?: { id: string; title: string; status?: number }[];
+}
+
+export interface JsonApiParams<D = any> {
+  query?: { [param: string]: string | number | any };
+  data?: D; // request body
+}
+
+export interface JsonApiLog {
+  method: string;
+  reqUrl: string;
+  reqInit: RequestInit;
+  data?: any;
+  error?: any;
+}
+
+export interface JsonApiConfig {
+  apiPrefix: string;
+  debug?: boolean;
+}
+
+export class JsonApi<D = JsonApiData, P extends JsonApiParams = JsonApiParams> {
+  static reqInitDefault: RequestInit = {
+    headers: {
+      'content-type': 'application/json'
+    }
+  };
+
+  static configDefault: Partial<JsonApiConfig> = {
+    debug: false
+  };
+
+  constructor(protected config: JsonApiConfig, protected reqInit?: RequestInit) {
+    this.config = Object.assign({}, JsonApi.configDefault, config);
+    this.reqInit = Object.assign({}, JsonApi.reqInitDefault, reqInit);
+    this.parseResponse = this.parseResponse.bind(this);
+  }
+
+  public onData = new EventEmitter<[D, Response]>();
+  public onError = new EventEmitter<[JsonApiErrorParsed, Response]>();
+
+  get<T = D>(path: string, params?: P, reqInit: RequestInit = {}) {
+    return this.request<T>(path, params, { ...reqInit, method: "get" });
+  }
+
+  post<T = D>(path: string, params?: P, reqInit: RequestInit = {}) {
+    return this.request<T>(path, params, { ...reqInit, method: "post" });
+  }
+
+  put<T = D>(path: string, params?: P, reqInit: RequestInit = {}) {
+    return this.request<T>(path, params, { ...reqInit, method: "put" });
+  }
+
+  patch<T = D>(path: string, params?: P, reqInit: RequestInit = {}) {
+    return this.request<T>(path, params, { ...reqInit, method: "patch" });
+  }
+
+  del<T = D>(path: string, params?: P, reqInit: RequestInit = {}) {
+    return this.request<T>(path, params, { ...reqInit, method: "delete" });
+  }
+
+  protected request<D>(path: string, params?: P, init: RequestInit = {}) {
+    let reqUrl = this.config.apiPrefix + path;
+    const reqInit: RequestInit = { ...this.reqInit, ...init };
+    const { data, query } = params || {} as P;
+    if (data && !reqInit.body) {
+      reqInit.body = JSON.stringify(data);
+    }
+    if (query) {
+      const queryString = stringify(query);
+      reqUrl += (reqUrl.includes("?") ? "&" : "?") + queryString;
+    }
+    const infoLog: JsonApiLog = {
+      method: reqInit.method.toUpperCase(),
+      reqUrl: reqUrl,
+      reqInit: reqInit,
+    };
+    return cancelableFetch(reqUrl, reqInit).then(res => {
+      return this.parseResponse<D>(res, infoLog);
+    });
+  }
+
+  protected parseResponse<D>(res: Response, log: JsonApiLog): Promise<D> {
+    const { status } = res;
+    return res.text().then(text => {
+      let data;
+      try {
+        data = text ? JSON.parse(text) : ""; // DELETE-requests might not have response-body
+      } catch (e) {
+        data = text;
+      }
+      if (status >= 200 && status < 300) {
+        this.onData.emit(data, res);
+        this.writeLog({ ...log, data });
+        return data;
+      } else if (log.method === "GET" && res.status === 403) {
+        this.writeLog({ ...log, data });
+      } else {
+        const error = new JsonApiErrorParsed(data, this.parseError(data, res));
+        this.onError.emit(error, res);
+        this.writeLog({ ...log, error })
+        throw error;
+      }
+    })
+  }
+
+  protected parseError(error: JsonApiError | string, res: Response): string[] {
+    if (typeof error === "string") {
+      return [error]
+    }
+    else if (Array.isArray(error.errors)) {
+      return error.errors.map(error => error.title)
+    }
+    else if (error.message) {
+      return [error.message]
+    }
+    return [res.statusText || "Error!"]
+  }
+
+  protected writeLog(log: JsonApiLog) {
+    if (!this.config.debug) return;
+    const { method, reqUrl, ...params } = log;
+    let textStyle = 'font-weight: bold;';
+    if (params.data) textStyle += 'background: green; color: white;';
+    if (params.error) textStyle += 'background: red; color: white;';
+    console.log(`%c${method} ${reqUrl}`, textStyle, params);
+  }
+}
+
+export class JsonApiErrorParsed {
+  isUsedForNotification = false;
+
+  constructor(private error: JsonApiError | DOMException, private messages: string[]) {
+  }
+
+  get isAborted() {
+    return this.error.code === DOMException.ABORT_ERR;
+  }
+
+  toString() {
+    return this.messages.join("\n");
+  }
+}

src/renderer/api/kube-api-parse.ts

@@ -0,0 +1,103 @@
+// Parse kube-api path and get api-version, group, etc.
+import { splitArray } from "../../common/utils";
+
+export interface IKubeApiLinkRef {
+  apiPrefix?: string;
+  apiVersion: string;
+  resource: string;
+  name: string;
+  namespace?: string;
+}
+
+export interface IKubeApiLinkBase extends IKubeApiLinkRef {
+  apiBase: string;
+  apiGroup: string;
+  apiVersionWithGroup: string;
+}
+
+export function parseApi(path: string): IKubeApiLinkBase {
+  path = new URL(path, location.origin).pathname;
+  const [, prefix, ...parts] = path.split("/");
+  const apiPrefix = `/${prefix}`;
+
+  const [left, right, namespaced] = splitArray(parts, "namespaces");
+  let apiGroup, apiVersion, namespace, resource, name;
+
+  if (namespaced) {
+    switch (right.length) {
+    case 1:
+      name = right[0];
+      // fallthrough
+    case 0:
+      resource = "namespaces"; // special case this due to `split` removing namespaces
+      break;
+    default:
+      [namespace, resource, name] = right;
+      break;
+    }
+
+    apiVersion = left.pop();
+    apiGroup = left.join("/");
+  } else {
+    switch (left.length) {
+    case 2:
+      resource = left.pop();
+      // fallthrough
+    case 1:
+      apiVersion = left.pop();
+      apiGroup = "";
+      break;
+    default:
+      /**
+       * Given that
+       *  - `apiVersion` is `GROUP/VERSION` and
+       *  - `VERSION` is `DNS_LABEL` which is /^[a-z0-9]((-[a-z0-9])|[a-z0-9])*$/i
+       *     where length <= 63
+       *  - `GROUP` is /^D(\.D)*$/ where D is `DNS_LABEL` and length <= 253
+       *
+       * There is no well defined selection from an array of items that were
+       * seperated by '/'
+       *
+       * Solution is to create a huristic. Namely:
+       * 1. if '.' in left[0] then apiGroup <- left[0]
+       * 2. if left[1] matches /^v[0-9]/ then apiGroup, apiVersion <- left[0], left[1]
+       * 3. otherwise assume apiVersion <- left[0]
+       * 4. always resource, name <- left[(0 or 1)+1..]
+       */
+      if (left[0].includes('.') || left[1].match(/^v[0-9]/)) {
+        [apiGroup, apiVersion] = left;
+        resource = left.slice(2).join("/")
+      } else {
+        apiGroup = "";
+        apiVersion = left[0];
+        [resource, name] = left.slice(1)
+      }
+      break;
+    }
+  }
+
+  const apiVersionWithGroup = [apiGroup, apiVersion].filter(v => v).join("/");
+  const apiBase = [apiPrefix, apiGroup, apiVersion, resource].filter(v => v).join("/");
+
+  if (!apiBase) {
+    throw new Error(`invalid apiPath: ${path}`)
+  }
+
+  return {
+    apiBase,
+    apiPrefix, apiGroup,
+    apiVersion, apiVersionWithGroup,
+    namespace, resource, name,
+  };
+}
+
+export function createApiLink(ref: IKubeApiLinkRef): string {
+  const { apiPrefix = "/apis", resource, apiVersion, name } = ref;
+  let { namespace } = ref;
+  if (namespace) {
+    namespace = `namespaces/${namespace}`
+  }
+  return [apiPrefix, apiVersion, namespace, resource, name]
+    .filter(v => v)
+    .join("/")
+}

src/renderer/api/kube-api-parse_test.ts

@@ -0,0 +1,122 @@
+import { IKubeApiLinkBase, parseApi } from "./kube-api-parse";
+
+interface KubeApi_Parse_Test {
+  url: string;
+  expected: Required<IKubeApiLinkBase>;
+}
+
+const tests: KubeApi_Parse_Test[] = [
+  {
+    url: "/api/v1/namespaces/kube-system/pods/coredns-6955765f44-v8p27",
+    expected: {
+      apiBase: "/api/v1/pods",
+      apiPrefix: "/api",
+      apiGroup: "",
+      apiVersion: "v1",
+      apiVersionWithGroup: "v1",
+      namespace: "kube-system",
+      resource: "pods",
+      name: "coredns-6955765f44-v8p27"
+    },
+  },
+  {
+    url: "/apis/stable.example.com/foo1/crontabs",
+    expected: {
+      apiBase: "/apis/stable.example.com/foo1/crontabs",
+      apiPrefix: "/apis",
+      apiGroup: "stable.example.com",
+      apiVersion: "foo1",
+      apiVersionWithGroup: "stable.example.com/foo1",
+      resource: "crontabs",
+      name: undefined,
+      namespace: undefined,
+    },
+  },
+  {
+    url: "/apis/cluster.k8s.io/v1alpha1/clusters",
+    expected: {
+      apiBase: "/apis/cluster.k8s.io/v1alpha1/clusters",
+      apiPrefix: "/apis",
+      apiGroup: "cluster.k8s.io",
+      apiVersion: "v1alpha1",
+      apiVersionWithGroup: "cluster.k8s.io/v1alpha1",
+      resource: "clusters",
+      name: undefined,
+      namespace: undefined,
+    },
+  },
+  {
+    url: "/api/v1/namespaces",
+    expected: {
+      apiBase: "/api/v1/namespaces",
+      apiPrefix: "/api",
+      apiGroup: "",
+      apiVersion: "v1",
+      apiVersionWithGroup: "v1",
+      resource: "namespaces",
+      name: undefined,
+      namespace: undefined,
+    },
+  },
+  {
+    url: "/api/v1/secrets",
+    expected: {
+      apiBase: "/api/v1/secrets",
+      apiPrefix: "/api",
+      apiGroup: "",
+      apiVersion: "v1",
+      apiVersionWithGroup: "v1",
+      resource: "secrets",
+      name: undefined,
+      namespace: undefined,
+    },
+  },
+  {
+    url: "/api/v1/nodes/minikube",
+    expected: {
+      apiBase: "/api/v1/nodes",
+      apiPrefix: "/api",
+      apiGroup: "",
+      apiVersion: "v1",
+      apiVersionWithGroup: "v1",
+      resource: "nodes",
+      name: "minikube",
+      namespace: undefined,
+    },
+  },
+  {
+    url: "/api/foo-bar/nodes/minikube",
+    expected: {
+      apiBase: "/api/foo-bar/nodes",
+      apiPrefix: "/api",
+      apiGroup: "",
+      apiVersion: "foo-bar",
+      apiVersionWithGroup: "foo-bar",
+      resource: "nodes",
+      name: "minikube",
+      namespace: undefined,
+    },
+  },
+  {
+    url: "/api/v1/namespaces/kube-public",
+    expected: {
+      apiBase: "/api/v1/namespaces",
+      apiPrefix: "/api",
+      apiGroup: "",
+      apiVersion: "v1",
+      apiVersionWithGroup: "v1",
+      resource: "namespaces",
+      name: "kube-public",
+      namespace: undefined,
+    },
+  },
+];
+
+describe.only("parseApi unit tests", () => {
+  for (const i in tests) {
+    const { url: tUrl, expected:tExpect} = tests[i];
+    test(`test #${parseInt(i)+1}`, () => {
+      expect(parseApi(tUrl)).toStrictEqual(tExpect);
+    });
+  }
+});

src/renderer/api/kube-api.ts

@@ -0,0 +1,209 @@
+// Base class for building all kubernetes apis
+
+import merge from "lodash/merge"
+import { stringify } from "querystring";
+import { IKubeObjectConstructor, KubeObject } from "./kube-object";
+import { IKubeObjectRef, KubeJsonApi, KubeJsonApiData, KubeJsonApiDataList } from "./kube-json-api";
+import { apiKube } from "./index";
+import { kubeWatchApi } from "./kube-watch-api";
+import { apiManager } from "./api-manager";
+import { createApiLink, parseApi } from "./kube-api-parse";
+
+export interface IKubeApiOptions<T extends KubeObject> {
+  kind: string; // resource type within api-group, e.g. "Namespace"
+  apiBase: string; // base api-path for listing all resources, e.g. "/api/v1/pods"
+  isNamespaced: boolean;
+  objectConstructor?: IKubeObjectConstructor<T>;
+  request?: KubeJsonApi;
+}
+
+export interface IKubeApiQueryParams {
+  watch?: boolean | number;
+  resourceVersion?: string;
+  timeoutSeconds?: number;
+  limit?: number; // doesn't work with ?watch
+  continue?: string; // might be used with ?limit from second request
+}
+
+export class KubeApi<T extends KubeObject = any> {
+  static parseApi = parseApi;
+  static createLink = createApiLink;
+
+  static watchAll(...apis: KubeApi[]) {
+    const disposers = apis.map(api => api.watch());
+    return () => disposers.forEach(unwatch => unwatch());
+  }
+
+  readonly kind: string
+  readonly apiBase: string
+  readonly apiPrefix: string
+  readonly apiGroup: string
+  readonly apiVersion: string
+  readonly apiVersionWithGroup: string
+  readonly apiResource: string
+  readonly isNamespaced: boolean
+
+  public objectConstructor: IKubeObjectConstructor<T>;
+  protected request: KubeJsonApi;
+  protected resourceVersions = new Map<string, string>();
+
+  constructor(protected options: IKubeApiOptions<T>) {
+    const {
+      kind,
+      isNamespaced = false,
+      objectConstructor = KubeObject as IKubeObjectConstructor,
+      request = apiKube
+    } = options || {};
+    const { apiBase, apiPrefix, apiGroup, apiVersion, apiVersionWithGroup, resource } = KubeApi.parseApi(options.apiBase);
+
+    this.kind = kind;
+    this.isNamespaced = isNamespaced;
+    this.apiBase = apiBase;
+    this.apiPrefix = apiPrefix;
+    this.apiGroup = apiGroup;
+    this.apiVersion = apiVersion;
+    this.apiVersionWithGroup = apiVersionWithGroup;
+    this.apiResource = resource;
+    this.request = request;
+    this.objectConstructor = objectConstructor;
+
+    this.parseResponse = this.parseResponse.bind(this);
+    apiManager.registerApi(apiBase, this);
+  }
+
+  setResourceVersion(namespace = "", newVersion: string) {
+    this.resourceVersions.set(namespace, newVersion);
+  }
+
+  getResourceVersion(namespace = "") {
+    return this.resourceVersions.get(namespace);
+  }
+
+  async refreshResourceVersion(params?: { namespace: string }) {
+    return this.list(params, { limit: 1 });
+  }
+
+  getUrl({ name = "", namespace = "" } = {}, query?: Partial<IKubeApiQueryParams>) {
+    const { apiPrefix, apiVersionWithGroup, apiResource } = this;
+    const resourcePath = KubeApi.createLink({
+      apiPrefix: apiPrefix,
+      apiVersion: apiVersionWithGroup,
+      resource: apiResource,
+      namespace: this.isNamespaced ? namespace : undefined,
+      name: name,
+    });
+    return resourcePath + (query ? `?` + stringify(query) : "");
+  }
+
+  protected parseResponse(data: KubeJsonApiData | KubeJsonApiData[] | KubeJsonApiDataList, namespace?: string): any {
+    const KubeObjectConstructor = this.objectConstructor;
+    if (KubeObject.isJsonApiData(data)) {
+      return new KubeObjectConstructor(data);
+    }
+
+    // process items list response
+    if (KubeObject.isJsonApiDataList(data)) {
+      const { apiVersion, items, metadata } = data;
+      this.setResourceVersion(namespace, metadata.resourceVersion);
+      this.setResourceVersion("", metadata.resourceVersion);
+      return items.map(item => new KubeObjectConstructor({
+        kind: this.kind,
+        apiVersion: apiVersion,
+        ...item,
+      }))
+    }
+
+    // custom apis might return array for list response, e.g. users, groups, etc.
+    if (Array.isArray(data)) {
+      return data.map(data => new KubeObjectConstructor(data));
+    }
+
+    return data;
+  }
+
+  async list({ namespace = "" } = {}, query?: IKubeApiQueryParams): Promise<T[]> {
+    return this.request
+      .get(this.getUrl({ namespace }), { query })
+      .then(data => this.parseResponse(data, namespace));
+  }
+
+  async get({ name = "", namespace = "default" } = {}, query?: IKubeApiQueryParams): Promise<T> {
+    return this.request
+      .get(this.getUrl({ namespace, name }), { query })
+      .then(this.parseResponse);
+  }
+
+  async create({ name = "", namespace = "default" } = {}, data?: Partial<T>): Promise<T> {
+    const apiUrl = this.getUrl({ namespace });
+
+    return this.request
+      .post(apiUrl, {
+        data: merge({
+          kind: this.kind,
+          apiVersion: this.apiVersionWithGroup,
+          metadata: {
+            name,
+            namespace
+          }
+        }, data)
+      })
+      .then(this.parseResponse);
+  }
+
+  async update({ name = "", namespace = "default" } = {}, data?: Partial<T>): Promise<T> {
+    const apiUrl = this.getUrl({ namespace, name });
+    return this.request
+      .put(apiUrl, { data })
+      .then(this.parseResponse)
+  }
+
+  async delete({ name = "", namespace = "default" }) {
+    const apiUrl = this.getUrl({ namespace, name });
+    return this.request.del(apiUrl)
+  }
+
+  getWatchUrl(namespace = "", query: IKubeApiQueryParams = {}) {
+    return this.getUrl({ namespace }, {
+      watch: 1,
+      resourceVersion: this.getResourceVersion(namespace),
+      ...query,
+    })
+  }
+
+  watch(): () => void {
+    return kubeWatchApi.subscribe(this);
+  }
+}
+
+export function lookupApiLink(ref: IKubeObjectRef, parentObject: KubeObject): string {
+  const {
+    kind, apiVersion, name,
+    namespace = parentObject.getNs()
+  } = ref;
+
+  // search in registered apis by 'kind' & 'apiVersion'
+  const api = apiManager.getApi(api => api.kind === kind && api.apiVersionWithGroup == apiVersion)
+  if (api) {
+    return api.getUrl({ namespace, name })
+  }
+
+  // lookup api by generated resource link
+  const apiPrefixes = ["/apis", "/api"];
+  const resource = kind.toLowerCase() + kind.endsWith("s") ? "es" : "s";
+  for (const apiPrefix of apiPrefixes) {
+    const apiLink = KubeApi.createLink({ apiPrefix, apiVersion, name, namespace, resource });
+    if (apiManager.getApi(apiLink)) {
+      return apiLink;
+    }
+  }
+
+  // resolve by kind only (hpa's might use refs to older versions of resources for example)
+  const apiByKind = apiManager.getApi(api => api.kind === kind);
+  if (apiByKind) {
+    return apiByKind.getUrl({ name, namespace })
+  }
+
+  // otherwise generate link with default prefix
+  // resource still might exists in k8s, but api is not registered in the app
+  return KubeApi.createLink({ apiVersion, name, namespace, resource })
+}

src/renderer/api/kube-json-api.ts

@@ -0,0 +1,68 @@
+import { JsonApi, JsonApiData, JsonApiError } from "./json-api";
+
+export interface KubeJsonApiDataList<T = KubeJsonApiData> {
+  kind: string;
+  apiVersion: string;
+  items: T[];
+  metadata: {
+    resourceVersion: string;
+    selfLink: string;
+  };
+}
+
+export interface KubeJsonApiData extends JsonApiData {
+  kind: string;
+  apiVersion: string;
+  metadata: {
+    uid: string;
+    name: string;
+    namespace?: string;
+    creationTimestamp?: string;
+    resourceVersion: string;
+    continue?: string;
+    finalizers?: string[];
+    selfLink: string;
+    labels?: {
+      [label: string]: string;
+    };
+    annotations?: {
+      [annotation: string]: string;
+    };
+  };
+}
+
+export interface IKubeObjectRef {
+  kind: string;
+  apiVersion: string;
+  name: string;
+  namespace?: string;
+}
+
+export interface KubeJsonApiError extends JsonApiError {
+  code: number;
+  status: string;
+  message?: string;
+  reason: string;
+  details: {
+    name: string;
+    kind: string;
+  };
+}
+
+export interface IKubeJsonApiQuery {
+  watch?: any;
+  resourceVersion?: string;
+  timeoutSeconds?: number;
+  limit?: number; // doesn't work with ?watch
+  continue?: string; // might be used with ?limit from second request
+}
+
+export class KubeJsonApi extends JsonApi<KubeJsonApiData> {
+  protected parseError(error: KubeJsonApiError | any, res: Response): string[] {
+    const { status, reason, message } = error;
+    if (status && reason) {
+      return [message || `${status}: ${reason}`];
+    }
+    return super.parseError(error, res);
+  }
+}

src/renderer/api/kube-object.ts

@@ -0,0 +1,160 @@
+// Base class for all kubernetes objects
+
+import moment from "moment";
+import { KubeJsonApiData, KubeJsonApiDataList } from "./kube-json-api";
+import { autobind, formatDuration } from "../utils";
+import { ItemObject } from "../item.store";
+import { apiKube } from "./index";
+import { JsonApiParams } from "./json-api";
+import { resourceApplierApi } from "./endpoints/resource-applier.api";
+
+export type IKubeObjectConstructor<T extends KubeObject = any> = (new (data: KubeJsonApiData | any) => T) & {
+  kind?: string;
+};
+
+export interface IKubeObjectMetadata {
+  uid: string;
+  name: string;
+  namespace?: string;
+  creationTimestamp: string;
+  resourceVersion: string;
+  selfLink: string;
+  deletionTimestamp?: string;
+  finalizers?: string[];
+  continue?: string; // provided when used "?limit=" query param to fetch objects list
+  labels?: {
+    [label: string]: string;
+  };
+  annotations?: {
+    [annotation: string]: string;
+  };
+  ownerReferences?: {
+    apiVersion: string;
+    kind: string;
+    name: string;
+    uid: string;
+    controller: boolean;
+    blockOwnerDeletion: boolean;
+  }[];
+}
+
+export type IKubeMetaField = keyof IKubeObjectMetadata;
+
+@autobind()
+export class KubeObject implements ItemObject {
+  static readonly kind: string;
+
+  static create(data: any) {
+    return new KubeObject(data);
+  }
+
+  static isNonSystem(item: KubeJsonApiData | KubeObject) {
+    return !item.metadata.name.startsWith("system:");
+  }
+
+  static isJsonApiData(object: any): object is KubeJsonApiData {
+    return !object.items && object.metadata;
+  }
+
+  static isJsonApiDataList(object: any): object is KubeJsonApiDataList {
+    return object.items && object.metadata;
+  }
+
+  static stringifyLabels(labels: { [name: string]: string }): string[] {
+    if (!labels) return [];
+    return Object.entries(labels).map(([name, value]) => `${name}=${value}`)
+  }
+
+  constructor(data: KubeJsonApiData) {
+    Object.assign(this, data);
+  }
+
+  apiVersion: string
+  kind: string
+  metadata: IKubeObjectMetadata;
+  status?: any; // todo: type-safety support
+
+  get selfLink() {
+    return this.metadata.selfLink
+  }
+
+  getId() {
+    return this.metadata.uid;
+  }
+
+  getResourceVersion() {
+    return this.metadata.resourceVersion;
+  }
+
+  getName() {
+    return this.metadata.name;
+  }
+
+  getNs() {
+    // avoid "null" serialization via JSON.stringify when post data
+    return this.metadata.namespace || undefined;
+  }
+
+  // todo: refactor with named arguments
+  getAge(humanize = true, compact = true, fromNow = false) {
+    if (fromNow) {
+      return moment(this.metadata.creationTimestamp).fromNow();
+    }
+    const diff = new Date().getTime() - new Date(this.metadata.creationTimestamp).getTime();
+    if (humanize) {
+      return formatDuration(diff, compact);
+    }
+    return diff;
+  }
+
+  getFinalizers(): string[] {
+    return this.metadata.finalizers || [];
+  }
+
+  getLabels(): string[] {
+    return KubeObject.stringifyLabels(this.metadata.labels);
+  }
+
+  getAnnotations(): string[] {
+    const labels = KubeObject.stringifyLabels(this.metadata.annotations);
+    return labels.filter(label => {
+      const skip = resourceApplierApi.annotations.some(key => label.startsWith(key));
+      return !skip;
+    })
+  }
+
+  getOwnerRefs() {
+    const refs = this.metadata.ownerReferences || [];
+    return refs.map(ownerRef => ({
+      ...ownerRef,
+      namespace: this.getNs(),
+    }))
+  }
+
+  getSearchFields() {
+    const { getName, getId, getNs, getAnnotations, getLabels } = this
+    return [
+      getName(),
+      getNs(),
+      getId(),
+      ...getLabels(),
+      ...getAnnotations(),
+    ]
+  }
+
+  toPlainObject(): object {
+    return JSON.parse(JSON.stringify(this));
+  }
+
+  // use unified resource-applier api for updating all k8s objects
+  async update<T extends KubeObject>(data: Partial<T>) {
+    return resourceApplierApi.update<T>({
+      ...this.toPlainObject(),
+      ...data,
+    });
+  }
+
+  delete(params?: JsonApiParams) {
+    return apiKube.del(this.selfLink, params);
+  }
+}

src/renderer/api/kube-watch-api.ts

@@ -0,0 +1,164 @@
+// Kubernetes watch-api consumer
+
+import { computed, observable, reaction } from "mobx";
+import { stringify } from "querystring"
+import { autobind, EventEmitter } from "../utils";
+import { KubeJsonApiData } from "./kube-json-api";
+import type { KubeObjectStore } from "../kube-object.store";
+import { KubeApi } from "./kube-api";
+import { configStore } from "../config.store";
+import { apiManager } from "./api-manager";
+import { apiPrefix, isDevelopment } from "../../common/vars";
+
+export interface IKubeWatchEvent<T = any> {
+  type: "ADDED" | "MODIFIED" | "DELETED";
+  object?: T;
+}
+
+export interface IKubeWatchRouteEvent {
+  type: "STREAM_END";
+  url: string;
+  status: number;
+}
+
+export interface IKubeWatchRouteQuery {
+  api: string | string[];
+}
+
+@autobind()
+export class KubeWatchApi {
+  protected evtSource: EventSource;
+  protected onData = new EventEmitter<[IKubeWatchEvent]>();
+  protected apiUrl = apiPrefix.BASE + "/watch";
+  protected subscribers = observable.map<KubeApi, number>();
+  protected reconnectTimeoutMs = 5000;
+  protected maxReconnectsOnError = 10;
+  protected reconnectAttempts = this.maxReconnectsOnError;
+
+  constructor() {
+    reaction(() => this.activeApis, () => this.connect(), {
+      fireImmediately: true,
+      delay: 500,
+    });
+  }
+
+  @computed get activeApis() {
+    return Array.from(this.subscribers.keys());
+  }
+
+  getSubscribersCount(api: KubeApi) {
+    return this.subscribers.get(api) || 0;
+  }
+
+  subscribe(...apis: KubeApi[]) {
+    apis.forEach(api => {
+      this.subscribers.set(api, this.getSubscribersCount(api) + 1);
+    });
+    return () => apis.forEach(api => {
+      const count = this.getSubscribersCount(api) - 1;
+      if (count <= 0) this.subscribers.delete(api);
+      else this.subscribers.set(api, count);
+    });
+  }
+
+  protected getQuery(): Partial<IKubeWatchRouteQuery> {
+    const { isClusterAdmin, allowedNamespaces } = configStore;
+    return {
+      api: this.activeApis.map(api => {
+        if (isClusterAdmin) return api.getWatchUrl();
+        return allowedNamespaces.map(namespace => api.getWatchUrl(namespace))
+      }).flat()
+    }
+  }
+
+  // todo: maybe switch to websocket to avoid often reconnects
+  @autobind()
+  protected connect() {
+    if (this.evtSource) this.disconnect(); // close previous connection
+    if (!this.activeApis.length) {
+      return;
+    }
+    const query = this.getQuery();
+    const apiUrl = this.apiUrl + "?" + stringify(query);
+    this.evtSource = new EventSource(apiUrl);
+    this.evtSource.onmessage = this.onMessage;
+    this.evtSource.onerror = this.onError;
+    this.writeLog("CONNECTING", query.api);
+  }
+
+  reconnect() {
+    if (!this.evtSource || this.evtSource.readyState !== EventSource.OPEN) {
+      this.reconnectAttempts = this.maxReconnectsOnError;
+      this.connect();
+    }
+  }
+
+  protected disconnect() {
+    if (!this.evtSource) return;
+    this.evtSource.close();
+    this.evtSource.onmessage = null;
+    this.evtSource = null;
+  }
+
+  protected onMessage(evt: MessageEvent) {
+    if (!evt.data) return;
+    const data = JSON.parse(evt.data);
+    if ((data as IKubeWatchEvent).object) {
+      this.onData.emit(data);
+    } else {
+      this.onRouteEvent(data);
+    }
+  }
+
+  protected async onRouteEvent({ type, url }: IKubeWatchRouteEvent) {
+    if (type === "STREAM_END") {
+      this.disconnect();
+      const { apiBase, namespace } = KubeApi.parseApi(url);
+      const api = apiManager.getApi(apiBase);
+      if (api) {
+        try {
+          await api.refreshResourceVersion({ namespace });
+          this.reconnect();
+        } catch (error) {
+          console.debug("failed to refresh resource version", error)
+        }
+      }
+    }
+  }
+
+  protected onError(evt: MessageEvent) {
+    const { reconnectAttempts: attemptsRemain, reconnectTimeoutMs } = this;
+    if (evt.eventPhase === EventSource.CLOSED) {
+      if (attemptsRemain > 0) {
+        this.reconnectAttempts--;
+        setTimeout(() => this.connect(), reconnectTimeoutMs);
+      }
+    }
+  }
+
+  protected writeLog(...data: any[]) {
+    if (isDevelopment) {
+      console.log('%cKUBE-WATCH-API:', `font-weight: bold`, ...data);
+    }
+  }
+
+  addListener(store: KubeObjectStore, callback: (evt: IKubeWatchEvent) => void) {
+    const listener = (evt: IKubeWatchEvent<KubeJsonApiData>) => {
+      const { selfLink, namespace, resourceVersion } = evt.object.metadata;
+      const api = apiManager.getApi(selfLink);
+      api.setResourceVersion(namespace, resourceVersion);
+      api.setResourceVersion("", resourceVersion);
+      if (store == apiManager.getStore(api)) {
+        callback(evt);
+      }
+    };
+    this.onData.addListener(listener);
+    return () => this.onData.removeListener(listener);
+  }
+
+  reset() {
+    this.subscribers.clear();
+  }
+}
+
+export const kubeWatchApi = new KubeWatchApi();

src/renderer/api/rbac.ts

@@ -0,0 +1,14 @@
+import { configStore } from "../config.store";
+
+export function isAllowedResource(resources: string | string[]) {
+  if (!Array.isArray(resources)) {
+    resources = [resources];
+  }
+  const { allowedResources } = configStore;
+  for (const resource of resources) {
+    if (!allowedResources.includes(resource)) {
+      return false;
+    }
+  }
+  return true;
+}

src/renderer/api/terminal-api.ts

@@ -0,0 +1,165 @@
+import { stringify } from "querystring";
+import { autobind, base64, EventEmitter, interval } from "../utils";
+import { WebSocketApi } from "./websocket-api";
+import { configStore } from "../config.store";
+import isEqual from "lodash/isEqual"
+import { apiPrefix, isDevelopment } from "../../common/vars";
+
+export enum TerminalChannels {
+  STDIN = 0,
+  STDOUT = 1,
+  STDERR = 2,
+  TERMINAL_SIZE = 4,
+  TOKEN = 9,
+}
+
+enum TerminalColor {
+  RED = "\u001b[31m",
+  GREEN = "\u001b[32m",
+  YELLOW = "\u001b[33m",
+  BLUE = "\u001b[34m",
+  MAGENTA = "\u001b[35m",
+  CYAN = "\u001b[36m",
+  GRAY = "\u001b[90m",
+  LIGHT_GRAY = "\u001b[37m",
+  NO_COLOR = "\u001b[0m",
+}
+
+export interface ITerminalApiOptions {
+  id: string;
+  node?: string;
+  colorTheme?: "light" | "dark";
+}
+
+export class TerminalApi extends WebSocketApi {
+  protected size: { Width: number; Height: number };
+  protected currentToken: string;
+  protected tokenInterval = interval(60, this.sendNewToken); // refresh every minute
+
+  public onReady = new EventEmitter<[]>();
+  public isReady = false;
+
+  constructor(protected options: ITerminalApiOptions) {
+    super({
+      logging: isDevelopment,
+      flushOnOpen: false,
+      pingIntervalSeconds: 30,
+    });
+  }
+
+  async getUrl(token: string) {
+    const { hostname, protocol } = location;
+    let { port } = location;
+    const prefix = apiPrefix.TERMINAL;
+    const { id, node } = this.options;
+    const wss = `ws${protocol === "https:" ? "s" : ""}://`;
+    const queryParams = { token, id };
+    if (port) {
+      port = `:${port}`
+    }
+    if (node) {
+      Object.assign(queryParams, {
+        node: node,
+        type: "node"
+      });
+    }
+    return `${wss}${hostname}${port}${prefix}/api?${stringify(queryParams)}`;
+  }
+
+  async connect() {
+    const token = await configStore.getToken();
+    const apiUrl = await this.getUrl(token);
+    const { colorTheme } = this.options;
+    this.emitStatus("Connecting ...", {
+      color: colorTheme == "light" ? TerminalColor.GRAY : TerminalColor.LIGHT_GRAY
+    });
+    this.onData.addListener(this._onReady, { prepend: true });
+    this.currentToken = token;
+    this.tokenInterval.start();
+    return super.connect(apiUrl);
+  }
+
+  @autobind()
+  async sendNewToken() {
+    const token = await configStore.getToken();
+    if (!this.isReady || token == this.currentToken) return;
+    this.sendCommand(token, TerminalChannels.TOKEN);
+    this.currentToken = token;
+  }
+
+  destroy() {
+    if (!this.socket) return;
+    const exitCode = String.fromCharCode(4); // ctrl+d
+    this.sendCommand(exitCode);
+    this.tokenInterval.stop();
+    setTimeout(() => super.destroy(), 2000);
+  }
+
+  removeAllListeners() {
+    super.removeAllListeners();
+    this.onReady.removeAllListeners();
+  }
+
+  @autobind()
+  protected _onReady(data: string) {
+    if (!data) return;
+    this.isReady = true;
+    this.onReady.emit();
+    this.onData.removeListener(this._onReady);
+    this.flush();
+    this.onData.emit(data); // re-emit data
+    return false; // prevent calling rest of listeners
+  }
+
+  reconnect() {
+    const { reconnectDelaySeconds } = this.params;
+    super.reconnect();
+  }
+
+  sendCommand(key: string, channel = TerminalChannels.STDIN) {
+    return this.send(channel + base64.encode(key));
+  }
+
+  sendTerminalSize(cols: number, rows: number) {
+    const newSize = { Width: cols, Height: rows };
+    if (!isEqual(this.size, newSize)) {
+      this.sendCommand(JSON.stringify(newSize), TerminalChannels.TERMINAL_SIZE);
+      this.size = newSize;
+    }
+  }
+
+  protected parseMessage(data: string) {
+    data = data.substr(1); // skip channel
+    return base64.decode(data);
+  }
+
+  protected _onOpen(evt: Event) {
+    // Client should send terminal size in special channel 4,
+    // But this size will be changed by terminal.fit()
+    this.sendTerminalSize(120, 80);
+    super._onOpen(evt);
+  }
+
+  protected _onClose(evt: CloseEvent) {
+    super._onClose(evt);
+    this.isReady = false;
+  }
+
+  protected emitStatus(data: string, options: { color?: TerminalColor; showTime?: boolean } = {}) {
+    const { color, showTime } = options;
+    if (color) {
+      data = `${color}${data}${TerminalColor.NO_COLOR}`;
+    }
+    let time;
+    if (showTime) {
+      time = (new Date()).toLocaleString() + " ";
+    }
+    this.onData.emit(`${showTime ? time : ""}${data}\r\n`);
+  }
+
+  protected emitError(error: string) {
+    this.emitStatus(error, {
+      color: TerminalColor.RED
+    });
+  }
+}

src/renderer/api/websocket-api.ts

@@ -0,0 +1,169 @@
+import { observable } from "mobx";
+import { EventEmitter } from "../utils/eventEmitter";
+
+interface IParams {
+  url?: string;          // connection url, starts with ws:// or wss://
+  autoConnect?: boolean; // auto-connect in constructor
+  flushOnOpen?: boolean; // flush pending commands on open socket
+  reconnectDelaySeconds?: number; // reconnect timeout in case of error (0 - don't reconnect)
+  pingIntervalSeconds?: number; // send ping message for keeping connection alive in some env, e.g. AWS (0 - don't ping)
+  logging?: boolean;    // show logs in console
+}
+
+interface IMessage {
+  id: string;
+  data: string;
+}
+
+export enum WebSocketApiState {
+  PENDING = -1,
+  OPEN,
+  CONNECTING,
+  RECONNECTING,
+  CLOSED,
+}
+
+export class WebSocketApi {
+  protected socket: WebSocket;
+  protected pendingCommands: IMessage[] = [];
+  protected reconnectTimer: any;
+  protected pingTimer: any;
+  protected pingMessage = "PING";
+
+  @observable readyState = WebSocketApiState.PENDING;
+
+  public onOpen = new EventEmitter<[]>();
+  public onData = new EventEmitter<[string]>();
+  public onClose = new EventEmitter<[]>();
+
+  static defaultParams: Partial<IParams> = {
+    autoConnect: true,
+    logging: false,
+    reconnectDelaySeconds: 10,
+    pingIntervalSeconds: 0,
+    flushOnOpen: true,
+  };
+
+  constructor(protected params: IParams) {
+    this.params = Object.assign({}, WebSocketApi.defaultParams, params);
+    const { autoConnect, pingIntervalSeconds } = this.params;
+    if (autoConnect) {
+      setTimeout(() => this.connect());
+    }
+    if (pingIntervalSeconds) {
+      this.pingTimer = setInterval(() => this.ping(), pingIntervalSeconds * 1000);
+    }
+  }
+
+  get isConnected() {
+    const state = this.socket ? this.socket.readyState : -1;
+    return state === WebSocket.OPEN && this.isOnline;
+  }
+
+  get isOnline() {
+    return navigator.onLine;
+  }
+
+  setParams(params: Partial<IParams>) {
+    Object.assign(this.params, params);
+  }
+
+  connect(url = this.params.url) {
+    if (this.socket) {
+      this.socket.close(); // close previous connection first
+    }
+    this.socket = new WebSocket(url);
+    this.socket.onopen = this._onOpen.bind(this);
+    this.socket.onmessage = this._onMessage.bind(this);
+    this.socket.onerror = this._onError.bind(this);
+    this.socket.onclose = this._onClose.bind(this);
+    this.readyState = WebSocketApiState.CONNECTING;
+  }
+
+  ping() {
+    if (!this.isConnected) return;
+    this.send(this.pingMessage);
+  }
+
+  reconnect() {
+    const { reconnectDelaySeconds } = this.params;
+    if (!reconnectDelaySeconds) return;
+    this.writeLog('reconnect after', reconnectDelaySeconds + "ms");
+    this.reconnectTimer = setTimeout(() => this.connect(), reconnectDelaySeconds * 1000);
+    this.readyState = WebSocketApiState.RECONNECTING;
+  }
+
+  destroy() {
+    if (!this.socket) return;
+    this.socket.close();
+    this.socket = null;
+    this.pendingCommands = [];
+    this.removeAllListeners();
+    clearTimeout(this.reconnectTimer);
+    clearInterval(this.pingTimer);
+    this.readyState = WebSocketApiState.PENDING;
+  }
+
+  removeAllListeners() {
+    this.onOpen.removeAllListeners();
+    this.onData.removeAllListeners();
+    this.onClose.removeAllListeners();
+  }
+
+  send(command: string) {
+    const msg: IMessage = {
+      id: (Math.random() * Date.now()).toString(16).replace(".", ""),
+      data: command,
+    };
+    if (this.isConnected) {
+      this.socket.send(msg.data);
+    }
+    else {
+      this.pendingCommands.push(msg);
+    }
+  }
+
+  protected flush() {
+    this.pendingCommands.forEach(msg => this.send(msg.data));
+    this.pendingCommands.length = 0;
+  }
+
+  protected parseMessage(data: string) {
+    return data;
+  }
+
+  protected _onOpen(evt: Event) {
+    this.onOpen.emit();
+    if (this.params.flushOnOpen) this.flush();
+    this.readyState = WebSocketApiState.OPEN;
+    this.writeLog('%cOPEN', 'color:green;font-weight:bold;', evt);
+  }
+
+  protected _onMessage(evt: MessageEvent) {
+    const data = this.parseMessage(evt.data);
+    this.onData.emit(data);
+    this.writeLog('%cMESSAGE', 'color:black;font-weight:bold;', data);
+  }
+
+  protected _onError(evt: Event) {
+    this.writeLog('%cERROR', 'color:red;font-weight:bold;', evt)
+  }
+
+  protected _onClose(evt: CloseEvent) {
+    const error = evt.code !== 1000 || !evt.wasClean;
+    if (error) {
+      this.reconnect();
+    }
+    else {
+      this.readyState = WebSocketApiState.CLOSED;
+      this.onClose.emit();
+    }
+    this.writeLog('%cCLOSE', `color:${error ? "red" : "black"};font-weight:bold;`, evt);
+  }
+
+  protected writeLog(...data: any[]) {
+    if (this.params.logging) {
+      console.log(...data);
+    }
+  }
+}

src/renderer/api/workload-kube-object.ts

@@ -0,0 +1,82 @@
+import get from "lodash/get";
+import { IKubeObjectMetadata, KubeObject } from "./kube-object";
+
+interface IToleration {
+  key?: string;
+  operator?: string;
+  effect?: string;
+  tolerationSeconds?: number;
+}
+
+interface IMatchExpression {
+  key: string;
+  operator: string;
+  values: string[];
+}
+
+interface INodeAffinity {
+  nodeSelectorTerms?: {
+    matchExpressions: IMatchExpression[];
+  }[];
+  weight: number;
+  preference: {
+    matchExpressions: IMatchExpression[];
+  };
+}
+
+interface IPodAffinity {
+  labelSelector: {
+    matchExpressions: IMatchExpression[];
+  };
+  topologyKey: string;
+}
+
+export interface IAffinity {
+  nodeAffinity?: {
+    requiredDuringSchedulingIgnoredDuringExecution?: INodeAffinity[];
+    preferredDuringSchedulingIgnoredDuringExecution?: INodeAffinity[];
+  };
+  podAffinity?: {
+    requiredDuringSchedulingIgnoredDuringExecution?: IPodAffinity[];
+    preferredDuringSchedulingIgnoredDuringExecution?: IPodAffinity[];
+  };
+  podAntiAffinity?: {
+    requiredDuringSchedulingIgnoredDuringExecution?: IPodAffinity[];
+    preferredDuringSchedulingIgnoredDuringExecution?: IPodAffinity[];
+  };
+}
+
+export class WorkloadKubeObject extends KubeObject {
+
+  // fixme: add type
+  spec: any;
+
+  getSelectors(): string[] {
+    const selector = this.spec.selector;
+    return KubeObject.stringifyLabels(selector ? selector.matchLabels : null);
+  }
+
+  getNodeSelectors(): string[] {
+    const nodeSelector = get(this, "spec.template.spec.nodeSelector");
+    return KubeObject.stringifyLabels(nodeSelector);
+  }
+
+  getTemplateLabels(): string[] {
+    const labels = get(this, "spec.template.metadata.labels");
+    return KubeObject.stringifyLabels(labels);
+  }
+
+  getTolerations(): IToleration[] {
+    return get(this, "spec.template.spec.tolerations", [])
+  }
+
+  getAffinity(): IAffinity {
+    return get(this, "spec.template.spec.affinity")
+  }
+
+  getAffinityNumber() {
+    const affinity = this.getAffinity()
+    if (!affinity) return 0
+    return Object.keys(affinity).length
+  }
+}

src/renderer/assets/css/fonts.scss

@@ -1,2 +0,0 @@
-@import "~typeface-roboto/index.css";
-@import "~material-design-icons/iconfont/material-icons.css";

src/renderer/browser-check.tsx

@@ -0,0 +1,20 @@
+import React from "react";
+import { Notifications } from "./components/notifications";
+import { Trans } from "@lingui/macro";
+
+export function browserCheck() {
+  const ua = window.navigator.userAgent
+  const msie = ua.indexOf('MSIE ')  // IE < 11
+  const trident = ua.indexOf('Trident/')  // IE 11
+  const edge = ua.indexOf('Edge')  // Edge
+  if (msie > 0 || trident > 0 || edge > 0) {
+    Notifications.info(
+      <p>
+        <Trans>
+          <b>Your browser does not support all Lens features. </b>{" "}
+          Please consider using another browser.
+        </Trans>
+      </p>
+    )
+  }
+}

src/renderer/components/+404/index.ts

@@ -0,0 +1 @@
+export * from "./not-found"

src/renderer/components/+404/not-found.tsx

@@ -0,0 +1,15 @@
+import React from "react";
+import { Trans } from "@lingui/macro";
+import { MainLayout } from "../layout/main-layout";
+
+export class NotFound extends React.Component {
+  render() {
+    return (
+      <MainLayout className="NotFound" contentClass="flex" footer={null}>
+        <p className="box center">
+          <Trans>Page not found</Trans>
+        </p>
+      </MainLayout>
+    )
+  }
+}

src/renderer/components/+apps-helm-charts/helm-chart-details.scss

@@ -0,0 +1,53 @@
+.HelmChartDetails {
+  .intro-logo {
+    margin-right: $margin * 2;
+    background: $helmLogoBackground;
+    border-radius: $radius;
+    max-width: 150px;
+    max-height: 100px;
+    padding: $padding;
+    box-sizing: content-box;
+  }
+
+  .intro-contents {
+    .description {
+      font-weight: bold;
+      color: $textColorAccent;
+      padding-bottom: $padding;
+
+      .Button {
+        padding-left: $padding * 3;
+        padding-right: $padding * 3;
+        margin-left: $margin * 2;
+        align-self: flex-start;
+      }
+    }
+
+    .version {
+      .Select {
+        width: 80px;
+        min-width: 80px;
+        white-space: nowrap;
+      }
+
+      .Icon {
+        margin-right: $margin;
+      }
+    }
+
+    .maintainers {
+      a {
+        display: inline-block;
+        margin-right: $margin;
+      }
+    }
+
+    .DrawerItem {
+      align-items: center;
+    }
+  }
+
+  .chart-description {
+    margin-top: $margin * 2;
+  }
+}

src/renderer/components/+apps-helm-charts/helm-chart-details.tsx

@@ -0,0 +1,138 @@
+import "./helm-chart-details.scss";
+
+import React, { Component } from "react";
+import { HelmChart, helmChartsApi } from "../../api/endpoints/helm-charts.api";
+import { t, Trans } from "@lingui/macro";
+import { autorun, observable } from "mobx";
+import { disposeOnUnmount, observer } from "mobx-react";
+import { Drawer, DrawerItem } from "../drawer";
+import { autobind, stopPropagation } from "../../utils";
+import { MarkdownViewer } from "../markdown-viewer";
+import { Spinner } from "../spinner";
+import { CancelablePromise } from "../../utils/cancelableFetch";
+import { Button } from "../button";
+import { Select, SelectOption } from "../select";
+import { createInstallChartTab } from "../dock/install-chart.store";
+import { Badge } from "../badge";
+import { _i18n } from "../../i18n";
+
+interface Props {
+  chart: HelmChart;
+  hideDetails(): void;
+}
+
+@observer
+export class HelmChartDetails extends Component<Props> {
+  @observable chartVersions: HelmChart[];
+  @observable selectedChart: HelmChart;
+  @observable description: string = null;
+
+  private chartPromise: CancelablePromise<{ readme: string; versions: HelmChart[] }>;
+
+  @disposeOnUnmount
+  chartSelector = autorun(async () => {
+    if (!this.props.chart) return;
+    this.chartVersions = null;
+    this.selectedChart = null;
+    this.description = null;
+    this.loadChartData();
+    this.chartPromise.then(data => {
+      this.description = data.readme;
+      this.chartVersions = data.versions;
+      this.selectedChart = data.versions[0];
+    });
+  });
+
+  loadChartData(version?: string) {
+    const { chart: { name, repo } } = this.props;
+    if (this.chartPromise) this.chartPromise.cancel();
+    this.chartPromise = helmChartsApi.get(repo, name, version);
+  }
+
+  @autobind()
+  onVersionChange(opt: SelectOption) {
+    const version = opt.value;
+    this.selectedChart = this.chartVersions.find(chart => chart.version === version);
+    this.description = null;
+    this.loadChartData(version);
+    this.chartPromise.then(data => {
+      this.description = data.readme
+    });
+  }
+
+  @autobind()
+  install() {
+    createInstallChartTab(this.selectedChart);
+    this.props.hideDetails()
+  }
+
+  renderIntroduction() {
+    const { selectedChart, chartVersions, onVersionChange } = this;
+    const placeholder = require("./helm-placeholder.svg");
+    return (
+      <div className="introduction flex align-flex-start">
+        <img
+          className="intro-logo"
+          src={selectedChart.getIcon() || placeholder}
+          onError={(event) => event.currentTarget.src = placeholder}
+        />
+        <div className="intro-contents box grow">
+          <div className="description flex align-center justify-space-between">
+            {selectedChart.getDescription()}
+            <Button primary label={_i18n._(t`Install`)} onClick={this.install}/>
+          </div>
+          <DrawerItem name={_i18n._(t`Version`)} className="version" onClick={stopPropagation}>
+            <Select
+              themeName="outlined"
+              menuPortalTarget={null}
+              options={chartVersions.map(chart => chart.version)}
+              value={selectedChart.getVersion()}
+              onChange={onVersionChange}
+            />
+          </DrawerItem>
+          <DrawerItem name={_i18n._(t`Home`)}>
+            <a href={selectedChart.getHome()} target="_blank">{selectedChart.getHome()}</a>
+          </DrawerItem>
+          <DrawerItem name={_i18n._(t`Maintainers`)} className="maintainers">
+            {selectedChart.getMaintainers().map(({ name, email, url }) =>
+              <a key={name} href={url ? url : `mailto:${email}`} target="_blank">{name}</a>
+            )}
+          </DrawerItem>
+          {selectedChart.getKeywords().length > 0 && (
+            <DrawerItem name={_i18n._(t`Keywords`)} labelsOnly>
+              {selectedChart.getKeywords().map(key => <Badge key={key} label={key}/>)}
+            </DrawerItem>
+          )}
+        </div>
+      </div>
+    );
+  }
+
+  renderContent() {
+    if (this.selectedChart === null || this.description === null) return <Spinner center/>;
+    return (
+      <div className="box grow">
+        {this.renderIntroduction()}
+        <div className="chart-description">
+          <MarkdownViewer markdown={this.description}/>
+        </div>
+      </div>
+    );
+  }
+
+  render() {
+    const { chart, hideDetails } = this.props;
+    const title = chart ? <Trans>Chart: {chart.getFullName()}</Trans> : "";
+    return (
+      <Drawer
+        className="HelmChartDetails"
+        usePortal={true}
+        open={!!chart}
+        title={title}
+        onClose={hideDetails}
+      >
+        {this.renderContent()}
+      </Drawer>
+    );
+  }
+}