feat: OLM operator installer

README.md

@@ -244,7 +244,7 @@ USAGE
   $ chectl server:start
 
 OPTIONS
-  -a, --installer=helm|operator|minishift-addon
+  -a, --installer=helm|operator|olm|minishift-addon
       Installer type
 
   -b, --domain=domain
@@ -263,7 +263,7 @@ OPTIONS
       show CLI help
 
   -i, --cheimage=cheimage
-      [default: quay.io/eclipse/che-server:nightly] Eclipse Che server container image
+      [default: quay.io/eclipse/che-server:7.9.0] Eclipse Che server container image
 
   -m, --multiuser
       Starts Eclipse Che in multi-user mode
@@ -293,6 +293,14 @@ OPTIONS
   -t, --templates=templates
       [default: templates] Path to the templates folder
 
+  --auto-update
+      Auto update approval strategy for installation Eclipse Che.  
+                           With this strategy will be provided auto-update Eclipse Che without any human interaction. 
+                           By default strategy this flag is false. It requires approval from user.
+                           To approve installation newer version Eclipse Che user should execute 'chectl server:update' 
+      command. 
+                           This parameter is used only when the installer is 'olm'.
+
   --che-operator-cr-patch-yaml=che-operator-cr-patch-yaml
       Path to a yaml file that overrides the default values in CheCluster CR used by the operator. This parameter is used 
       only when the installer is the operator.
@@ -345,6 +353,15 @@ OPTIONS
   --skip-version-check
       Skip minimal versions check.
 
+  --starting-csv=starting-csv
+      Starting cluster service version(CSV) for installation Eclipse Che.
+                           Flags uses to set up start installation version Che.
+                           For example: 'starting-csv' provided with value 'eclipse-che.v7.10.0' for stable channel.
+                           Then OLM will install Eclipse Che with version 7.10.0.
+                           Notice: this flag will be ignored with 'auto-update' flag. OLM with auto-update mode installs 
+      the latest known version.
+                           This parameter is used only when the installer is 'olm'.
+
   --workspace-pvc-storage-class-name=workspace-pvc-storage-class-name
       persistent volume(s) storage class name to use to store Eclipse Che workspaces data
 ```
@@ -385,7 +402,7 @@ USAGE
   $ chectl server:update
 
 OPTIONS
-  -a, --installer=helm|operator|minishift-addon                                Installer type
+  -a, --installer=helm|operator|minishift-addon|olm                            Installer type
   -h, --help                                                                   show CLI help
 
   -n, --chenamespace=chenamespace                                              [default: che] Kubernetes namespace where

src/api/kube.ts

@@ -20,10 +20,11 @@ import { merge } from 'lodash'
 import * as net from 'net'
 import { Writable } from 'stream'
 
-import { DEFAULT_CHE_IMAGE } from '../constants'
+import { DEFAULT_CHE_IMAGE, defaultApplicationRegistry } from '../constants'
 import { getClusterClientCommand } from '../util'
 
 import { V1alpha2Certificate } from './typings/cert-manager'
+import { CatalogSource, ClusterServiceVersionList, InstallPlan, OperatorGroup, OperatorSource, PackageManifest, Subscription } from './typings/olm'
 
 const AWAIT_TIMEOUT_S = 30
 
@@ -1211,6 +1212,299 @@ export class KubeHelper {
     }
   }
 
+  async isPreInstalledOLM(): Promise<boolean> {
+    const apiApi = this.kc.makeApiClient(ApisApi)
+    try {
+      const { body } = await apiApi.getAPIVersions()
+      const OLMAPIGroup = body.groups.find(apiGroup => apiGroup.name === 'operators.coreos.com')
+      return !!OLMAPIGroup
+    } catch {
+      return false
+    }
+  }
+
+  async operatorSourceExists(name: string, namespace: string): Promise<boolean> {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.getNamespacedCustomObject('operators.coreos.com', 'v1', namespace, 'operatorsources', name)
+      return this.compare(body, name)
+    } catch {
+      return false
+    }
+  }
+
+  async createOperatorSource(name: string, registryNamespace: string, namespace: string) {
+    const operatorSource: OperatorSource = {
+      apiVersion: 'operators.coreos.com/v1',
+      kind: 'OperatorSource',
+      metadata: {
+        name,
+        namespace,
+      },
+      spec: {
+        endpoint: defaultApplicationRegistry,
+        registryNamespace,
+        type: 'appregistry'
+      }
+    }
+
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.createNamespacedCustomObject('operators.coreos.com', 'v1', namespace, 'operatorsources', operatorSource)
+      return body
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async deleteOperatorSource(name: string, namespace: string) {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const options = new V1DeleteOptions()
+      await customObjectsApi.deleteNamespacedCustomObject('operators.coreos.com', 'v1', namespace, 'operatorsources', name, options)
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async catalogSourceExists(name: string, namespace: string): Promise<boolean> {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.getNamespacedCustomObject('operators.coreos.com', 'v1alpha1', namespace, 'catalogsources', name)
+      return this.compare(body, name)
+    } catch {
+      return false
+    }
+  }
+
+  async getCatalogSource(name: string, namespace: string): Promise<CatalogSource> {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.getNamespacedCustomObject('operators.coreos.com', 'v1alpha1', namespace, 'catalogsources', name)
+      return body
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async createCatalogSource(catalogSource: CatalogSource) {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const namespace = catalogSource.metadata.namespace
+      const { body } = await customObjectsApi.createNamespacedCustomObject('operators.coreos.com', 'v1alpha1', namespace, 'catalogsources', catalogSource)
+      return body
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async waitCatalogSource(namespace: string, catalogSourceName: string, timeout = 60): Promise<CatalogSource> {
+    return new Promise<CatalogSource>(async (resolve, reject) => {
+      const watcher = new Watch(this.kc)
+      let request: any
+      request = watcher.watch(`/apis/operators.coreos.com/v1alpha1/namespaces/${namespace}/catalogsources`,
+        { fieldSelector: `metadata.name=${catalogSourceName}` },
+        (_phase: string, obj: any) => {
+          resolve(obj as CatalogSource)
+        },
+        error => {
+          if (error) {
+            reject(error)
+          }
+        })
+
+      setTimeout(() => {
+        request.abort()
+        reject(`Timeout reached while waiting for "${catalogSourceName}" catalog source is created.`)
+      }, timeout * 1000)
+    })
+  }
+
+  async operatorGroupExists(name: string, namespace: string): Promise<boolean> {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.getNamespacedCustomObject('operators.coreos.com', 'v1', namespace, 'operatorgroups', name)
+      return this.compare(body, name)
+    } catch {
+      return false
+    }
+  }
+
+  async createOperatorGroup(operatorGroupName: string, namespace: string) {
+    const operatorGroup: OperatorGroup = {
+      apiVersion: 'operators.coreos.com/v1',
+      kind: 'OperatorGroup',
+      metadata: {
+        name: operatorGroupName,
+        namespace,
+      },
+      spec: {
+        targetNamespaces: [namespace]
+      }
+    }
+
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.createNamespacedCustomObject('operators.coreos.com', 'v1', namespace, 'operatorgroups', operatorGroup)
+      return body
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async deleteOperatorGroup(operatorGroupName: string, namespace: string) {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const options = new V1DeleteOptions()
+      await customObjectsApi.deleteNamespacedCustomObject('operators.coreos.com', 'v1', namespace, 'operatorgroups', operatorGroupName, options)
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async createOperatorSubscription(subscription: Subscription) {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.createNamespacedCustomObject('operators.coreos.com', 'v1alpha1', subscription.metadata.namespace, 'subscriptions', subscription)
+      return body
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async getOperatorSubscription(name: string, namespace: string): Promise<Subscription> {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.getNamespacedCustomObject('operators.coreos.com', 'v1alpha1', namespace, 'subscriptions', name)
+      return body as Subscription
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async operatorSubscriptionExists(name: string, namespace: string): Promise<boolean> {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.getNamespacedCustomObject('operators.coreos.com', 'v1alpha1', namespace, 'subscriptions', name)
+      return this.compare(body, name)
+    } catch {
+      return false
+    }
+  }
+
+  async deleteOperatorSubscription(operatorSubscriptionName: string, namespace: string) {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const options = new V1DeleteOptions()
+      await customObjectsApi.deleteNamespacedCustomObject('operators.coreos.com', 'v1alpha1', namespace, 'subscriptions', operatorSubscriptionName, options)
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async waitOperatorSubscriptionReadyForApproval(namespace: string, subscriptionName: string, timeout = AWAIT_TIMEOUT_S): Promise<InstallPlan> {
+    return new Promise<InstallPlan>(async (resolve, reject) => {
+      const watcher = new Watch(this.kc)
+      let request: any
+      request = watcher.watch(`/apis/operators.coreos.com/v1alpha1/namespaces/${namespace}/subscriptions`,
+        { fieldSelector: `metadata.name=${subscriptionName}` },
+        (_phase: string, obj: any) => {
+          const subscription = obj as Subscription
+          if (subscription.status && subscription.status.conditions) {
+            for (const condition of subscription.status.conditions) {
+              if (condition.type === 'InstallPlanPending' && condition.status === 'True') {
+                resolve(subscription.status.installplan)
+              }
+            }
+          }
+        },
+        error => {
+          if (error) {
+            reject(error)
+          }
+        })
+
+      setTimeout(() => {
+        request.abort()
+        reject(`Timeout reached while waiting for "${subscriptionName}" subscription is ready.`)
+      }, timeout * 1000)
+    })
+  }
+
+  async approveOperatorInstallationPlan(name = '', namespace = '') {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const patch: InstallPlan = {
+        spec: {
+          approved: true
+        }
+      }
+      await customObjectsApi.patchNamespacedCustomObject('operators.coreos.com', 'v1alpha1', namespace, 'installplans', name, patch, { headers: { 'Content-Type': 'application/merge-patch+json' } })
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async waitWhileOperatorInstalled(installPlanName: string, namespace: string, timeout = 30) {
+    return new Promise<InstallPlan>(async (resolve, reject) => {
+      const watcher = new Watch(this.kc)
+      let request: any
+      request = watcher.watch(`/apis/operators.coreos.com/v1alpha1/namespaces/${namespace}/installplans`,
+        { fieldSelector: `metadata.name=${installPlanName}` },
+        (_phase: string, obj: any) => {
+          const installPlan = obj as InstallPlan
+          if (installPlan.status && installPlan.status.conditions) {
+            for (const condition of installPlan.status.conditions) {
+              if (condition.type === 'Installed' && condition.status === 'True') {
+                resolve()
+              }
+            }
+          }
+        },
+        error => {
+          if (error) {
+            reject(error)
+          }
+        })
+
+      setTimeout(() => {
+        request.abort()
+        reject(`Timeout reached while waiting for "${installPlanName}" has go status 'Installed'.`)
+      }, timeout * 1000)
+    })
+  }
+
+  async getClusterServiceVersions(namespace: string): Promise<ClusterServiceVersionList> {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.listNamespacedCustomObject('operators.coreos.com', 'v1alpha1', namespace, 'clusterserviceversions')
+      return body as ClusterServiceVersionList
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async deleteClusterServiceVersion(namespace: string, csvName: string) {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const options = new V1DeleteOptions()
+      const { body } = await customObjectsApi.deleteNamespacedCustomObject('operators.coreos.com', 'v1alpha1', namespace, 'clusterserviceversions', csvName, options)
+      return body as ClusterServiceVersionList
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
+  async getPackageManifect(name: string): Promise<PackageManifest> {
+    const customObjectsApi = this.kc.makeApiClient(CustomObjectsApi)
+    try {
+      const { body } = await customObjectsApi.getNamespacedCustomObject('packages.operators.coreos.com', 'v1', 'default', 'packagemanifests', name)
+      return body as PackageManifest
+    } catch (e) {
+      throw this.wrapK8sClientError(e)
+    }
+  }
+
   async deleteNamespace(namespace: string): Promise<void> {
     const k8sCoreApi = this.kc.makeApiClient(CoreV1Api)
     try {