@toa.io/operations 0.2.0-dev.3 → 0.2.1-dev.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/operations",
-  "version": "0.2.0-dev.3+8334154",
+  "version": "0.2.1-dev.4",
   "description": "Toa Deployment",
   "homepage": "https://toa.io",
   "author": {
@@ -26,8 +26,10 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/gears": "0.2.0-dev.3+8334154",
+    "@toa.io/filesystem": "*",
+    "@toa.io/generic": "*",
+    "@toa.io/yaml": "*",
     "execa": "5.1.1"
   },
-  "gitHead": "8334154c1b8a8268ad90adfb15b43a876459014f"
+  "gitHead": "2be07592325b2e4dc823e81d882a4e50bf50de24"
 }

package/src/deployment/.deployment/.describe/components.js

@@ -0,0 +1,19 @@
+'use strict'
+
+/**
+ * @param {toa.deployment.Composition[]} compositions
+ * @returns {string[]}
+ */
+const components = (compositions) => {
+  /** @type {Set<string>} */
+  const components = new Set()
+
+  for (const composition of compositions) {
+    for (const component of composition.components) {
+      components.add(component)
+    }
+  }
+
+  return Array.from(components)
+}
+exports.components = components

package/src/deployment/.deployment/.describe/dependencies.js

@@ -0,0 +1,18 @@
+'use strict'
+
+/**
+ * @param {toa.deployment.dependency.Reference[]} references
+ * @returns {*}
+ */
+const dependencies = (references) => {
+  return references?.reduce((map, reference) => {
+    const { name, alias, values } = reference
+
+    map[alias || name] = values
+
+    return map
+  }, {})
+}
+
+
+exports.dependencies = dependencies

package/src/deployment/.deployment/.describe/index.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { dependencies } = require('./dependencies')
+const { components } = require('./components')
+const { variables } = require('./variables')
+
+exports.dependencies = dependencies
+exports.components = components
+exports.variables = variables

package/src/deployment/.deployment/.describe/variables.js

@@ -0,0 +1,27 @@
+'use strict'
+
+/**
+ * @param {toa.norm.Context} context
+ * @param {toa.deployment.dependency.Variables} variables
+ * @returns {toa.deployment.dependency.Variables}
+ */
+const variables = (context, variables) => {
+  if (variables.global === undefined) variables.global = []
+
+  if (context.environment !== undefined) {
+    const variable = format('TOA_ENV', context.environment)
+
+    variables.global.push(variable)
+  }
+
+  return variables
+}
+
+/**
+ * @param {string} name
+ * @param {string} value
+ * @returns {toa.deployment.dependency.Variable}
+ */
+const format = (name, value) => ({ name, value })
+
+exports.variables = variables

package/src/deployment/.deployment/declare.js

@@ -0,0 +1,29 @@
+'use strict'
+
+/**
+ * @param {toa.norm.Context} context
+ * @param {toa.deployment.Dependency} dependency
+ * @returns {toa.deployment.Declaration}
+ */
+const declare = (context, dependency) => {
+  const { references } = dependency
+  const { name, description, version } = context
+
+  const dependencies = references.map(({ values, ...rest }) => rest)
+
+  return {
+    ...DECLARATION,
+    name,
+    description,
+    version,
+    appVersion: version,
+    dependencies
+  }
+}
+
+const DECLARATION = {
+  apiVersion: 'v2',
+  type: 'application'
+}
+
+exports.declare = declare

package/src/deployment/.deployment/describe.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const get = require('./.describe')
+
+/**
+ * @param {toa.norm.Context} context
+ * @param {toa.deployment.Composition[]} compositions
+ * @param {toa.deployment.Dependency} dependency
+ * @returns {toa.deployment.Contents}
+ */
+const describe = (context, compositions, dependency) => {
+  const { references, services, proxies } = dependency
+
+  const components = get.components(compositions)
+  const dependencies = get.dependencies(references)
+  const variables = get.variables(context, dependency.variables)
+
+  return {
+    compositions,
+    components,
+    services,
+    proxies,
+    variables,
+    ...dependencies
+  }
+}
+
+exports.describe = describe

package/src/deployment/.deployment/index.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { declare } = require('./declare')
+const { describe } = require('./describe')
+const { merge } = require('./merge')
+
+exports.declare = declare
+exports.describe = describe
+exports.merge = merge

package/src/deployment/.deployment/merge.js

@@ -0,0 +1,42 @@
+'use strict'
+
+/**
+ * @param {toa.deployment.Dependency[]} dependencies
+ * @returns {toa.deployment.Dependency}
+ */
+const merge = (dependencies) => {
+  /** @type {toa.deployment.dependency.Reference[]} */
+  const references = []
+
+  /** @type {toa.deployment.Service[]} */
+  const services = []
+
+  /** @type {toa.deployment.dependency.Proxy[]} */
+  const proxies = []
+
+  /** @type {toa.deployment.dependency.Variables} */
+  const variables = {}
+
+  for (const dependency of dependencies) {
+    if (dependency.references !== undefined) references.push(...dependency.references)
+    if (dependency.services !== undefined) services.push(...dependency.services)
+    if (dependency.proxies !== undefined) proxies.push(...dependency.proxies)
+    if (dependency.variables !== undefined) append(variables, dependency.variables)
+  }
+
+  return { references, services, proxies, variables }
+}
+
+/**
+ * @param {toa.deployment.dependency.Variables} merged
+ * @param {toa.deployment.dependency.Variables} variables
+ */
+const append = (merged, variables) => {
+  for (const [component, vars] of Object.entries(variables)) {
+    if (merged[component] === undefined) merged[component] = []
+
+    merged[component].push(...vars)
+  }
+}
+
+exports.merge = merge

package/src/deployment/{assets/chart → chart}/Chart.yaml

@@ -1,4 +1,4 @@
-# This file just helps with IDE autocompletion and helm debugging. Actually dynamically replaced by ../chart.js.
+# This file helps with IDE autocompletion
 apiVersion: v2
 name: toa-application
 description: Toa Application Chart

package/src/deployment/chart/templates/compositions.yaml

@@ -0,0 +1,38 @@
+{{- range .Values.compositions }}
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: composition-{{ required "deployment name is required" .name }}
+spec:
+  replicas: {{ .replicas | default 2 }}
+  selector:
+    matchLabels:
+      toa.io/composition: {{ .name }}
+  template:
+    metadata:
+      labels:
+        toa.io/composition: {{ .name }}
+        {{- range .components }}
+        {{ . }}: "1"
+        {{- end }}
+    spec:
+      containers:
+        - name: {{ .name }}
+          image: {{ .image }}
+          {{- if $.Values.variables }}
+          env:
+            {{- range $component := .components }}
+              {{- range $key, $vars := $.Values.variables }}
+                {{- if eq $component $key }}
+                  {{- range $vars }}
+                  {{- include "env.var" . | indent 12 }}
+                  {{- end }}
+                {{- end }}
+              {{- end }}
+            {{- end }}
+            {{- range $.Values.variables.global }}
+            {{- include "env.var" . | indent 12 }}
+            {{- end }}
+          {{- end }}
+---
+{{- end }}

package/src/deployment/chart/templates/proxies.yaml

@@ -0,0 +1,10 @@
+{{- range .Values.proxies }}
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ .name }}
+spec:
+  type: ExternalName
+  externalName: {{ .target }}
+---
+{{- end }}

package/src/deployment/chart/templates/services.yaml

@@ -0,0 +1,63 @@
+{{- range .Values.services }}
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: service-{{ required "deployment name is required" .name }}
+spec:
+  replicas: {{ .replicas | default 2 }}
+  selector:
+    matchLabels:
+      toa.io/service: {{ .name }}
+  template:
+    metadata:
+      labels:
+        toa.io/service: {{ .name }}
+    spec:
+      containers:
+        - name: {{ .name }}
+          image: {{ .image }}
+          {{- if $.Values.variables }}
+          env:
+            {{- range $.Values.variables.global }}
+            {{- include "env.var" . | indent 12 }}
+            {{- end }}
+          {{- end }}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: service-{{ .name }}
+spec:
+  type: ClusterIP
+  selector:
+    toa.io/service: {{ .name }}
+  ports:
+    - name: port-{{ .port }}
+      protocol: TCP
+      port: {{ .port }}
+      targetPort: {{ .port }}
+---
+{{- if .ingress }}
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: {{ .name }}
+  {{- if .ingress.annotations }}
+  annotations:
+{{ toYaml .ingress.annotations | indent 4 }}
+  {{- end }}
+spec:
+  ingressClassName: {{ required "ingress.class is required" .ingress.class }}
+  rules:
+    - host: {{ required "ingress.host is required" .ingress.host }}
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service:
+                name: service-{{ .name }}
+                port:
+                  number: 8000
+{{- end }}
+{{- end }}

package/src/deployment/chart/templates/variables.yaml

@@ -0,0 +1,12 @@
+{{- define "env.var" }}
+- name: {{ .name }}
+  {{- if .value }}
+  value: {{ .value | quote }}
+  {{- end }}
+  {{- if .secret }}
+  valueFrom:
+    secretKeyRef:
+      name: {{ .secret.name }}
+      key: {{ .secret.key }}
+  {{- end }}
+{{- end }}

package/src/deployment/chart/values.yaml

@@ -0,0 +1,47 @@
+# This file helps with IDE autocompletion
+compositions:
+  - name: todos
+    image: localhost:5000/composition-todos:0.0.0
+    replicas: 2
+    components:
+      - todos-tasks
+      - todos-stats
+  - name: users
+    image: localhost:5000/composition-users:0.0.0
+    replicas: 3
+    components:
+      - users-users
+# TODO: create component services only if sync binding is being used
+components:
+  - todos-tasks
+  - todos-stats
+  - users-users
+variables:
+  global:
+    - name: TOA_BINDINGS_AMQP_SYSTEM_USERNAME
+      value: foo
+      secret:
+        name: secret-name
+        key: secret-key
+  todos-tasks:
+    - name: TOA_CONFIGURATION_TODOS_TASKS
+      value: foo
+      secret:
+        name: secret-name
+        key: secret-key
+services:
+  - name: resources-gateway
+    image: localhost:5000/resources-gateway:0.0.0
+    port: 8000
+    replicas: 2
+    ingress:
+      host: dummies.toa.io
+      class: alb
+      annotations:
+        alb.ingress.kubernetes.io/scheme: internet-facing
+        alb.ingress.kubernetes.io/target-type: ip
+        alb.ingress.kubernetes.io/listen-ports: '[{"HTTPS": 443}]'
+proxies:
+  - name: storage-proxy
+    target: host.docker.internal
+environment: development

package/src/deployment/composition.js

@@ -1,17 +1,30 @@
 'use strict'
 
+// noinspection JSClosureCompilerSyntax
+/**
+ * @implements {toa.deployment.Composition}
+ */
 class Composition {
   name
-  components
-  replicas
   image
+  /** @type {string[]} */
+  components
 
+  /**
+   * @param composition {toa.norm.context.Composition}
+   * @param image {toa.deployment.images.Image}
+   */
   constructor (composition, image) {
     this.name = composition.name
-    this.components = composition.components
-    this.replicas = composition.replicas
-    this.image = image
+    this.image = image.reference
+    this.components = composition.components.map(component)
   }
 }
 
+/**
+ * @param {toa.norm.Component} component
+ * @returns {string}
+ */
+const component = (component) => component.locator.label
+
 exports.Composition = Composition

package/src/deployment/deployment.js

@@ -1,76 +1,82 @@
 'use strict'
 
-const { writeFile: write, rm: remove } = require('node:fs/promises')
-const execa = require('execa')
 const { join } = require('node:path')
-const { yaml } = require('@toa.io/gears')
+const { writeFile: write } = require('node:fs/promises')
+const { directory: { copy } } = require('@toa.io/filesystem')
+const { dump } = require('@toa.io/yaml')
 
-const { directory } = require('./directory')
-const { copy } = require('./copy')
+const { merge, declare, describe } = require('./.deployment')
 
+/**
+ * @implements {toa.deployment.Deployment}
+ */
 class Deployment {
-  #chart
-  #images
-
-  constructor (chart, images) {
-    this.#chart = chart
-    this.#images = images
-  }
-
-  async export (path) {
-    if (path === undefined) path = await directory.temp('deployment')
-    else await directory(path)
-
-    await this.#dump(path)
-
-    return path
-  }
-
-  async install (options = {}) {
-    await this.#push()
-    return await this.#upgrade(options)
+  /** @type {toa.deployment.Declaration} */
+  #declaration
+  /** @type {toa.deployment.Contents} */
+  #contents
+  /** @type {toa.operations.Process} */
+  #process
+  /** @type {string} */
+  #target
+
+  /**
+   * @param context {toa.norm.Context}
+   * @param compositions {toa.deployment.Composition[]}
+   * @param dependencies {toa.deployment.Dependency[]}
+   * @param process {toa.operations.Process}
+   */
+  constructor (context, compositions, dependencies, process) {
+    const dependency = merge(dependencies)
+
+    if (context.environment === 'local') throw new Error('Deployment environment name \'local\' is not allowed.')
+
+    this.#declaration = declare(context, dependency)
+    this.#contents = describe(context, compositions, dependency)
+    this.#process = process
   }
 
-  async #dump (path) {
-    const chart = yaml.dump(this.#chart.declaration)
-    const values = yaml.dump(this.#chart.values)
-
-    await copy(join(__dirname, 'assets/chart/templates'), join(path, 'templates'))
+  async export (target) {
+    const chart = dump(this.#declaration)
+    const values = dump(this.#contents)
 
     await Promise.all([
-      write(join(path, 'Chart.yaml'), chart),
-      write(join(path, 'values.yaml'), values)
+      write(join(target, 'Chart.yaml'), chart),
+      write(join(target, 'values.yaml'), values),
+      copy(TEMPLATES, join(target, 'templates'))
     ])
-  }
 
-  async #push () {
-    for (const image of this.#images) {
-      await image.build()
-      await image.push()
-    }
+    this.#target = target
   }
 
-  async #upgrade (options) {
-    const path = await this.export()
+  async install (options) {
+    if (options.target) this.#target = options.target
+    if (this.#target === undefined) throw new Error('Deployment hasn\'t been exported')
+
     const args = []
 
+    if (options.namespace !== undefined) args.push('-n', options.namespace)
     if (options.wait === true) args.push('--wait')
-    if (options.dry === true) args.push('--dry-run')
 
-    const update = execa('helm', ['dependency', 'update', path])
+    await this.#process.execute('helm', ['dependency', 'update', this.#target])
+    await this.#process.execute('helm', ['upgrade', this.#declaration.name, '-i', ...args, this.#target])
+  }
 
-    update.stdout.pipe(process.stdout)
-    await update
+  async template (options) {
+    if (this.#target === undefined) throw new Error('Deployment hasn\'t been exported')
 
-    const upgrade = execa('helm', ['upgrade', this.#chart.name, '-i', ...args, path])
+    await this.#process.execute('helm', ['dependency', 'update', this.#target], { silently: true })
 
-    upgrade.stdout.pipe(process.stdout)
-    const output = await upgrade
+    const args = []
 
-    await remove(path, { recursive: true })
+    if (options.namespace !== undefined) args.push('-n', options.namespace)
 
-    return output
+    return await this.#process.execute('helm',
+      ['template', this.#declaration.name, ...args, this.#target],
+      { silently: true })
   }
 }
 
+const TEMPLATES = join(__dirname, 'chart/templates')
+
 exports.Deployment = Deployment

package/src/deployment/factory.js

@@ -1,37 +1,100 @@
 'use strict'
 
-const { Composition } = require('./composition')
-const { Compositions } = require('./compositions')
-const { Image } = require('./image')
+const { Process } = require('../process')
+const { Operator } = require('./operator')
+const { Factory: Images, Registry } = require('./images')
 const { Deployment } = require('./deployment')
-const { Chart } = require('./chart')
+const { Composition } = require('./composition')
+const { Service } = require('./service')
 
+/**
+ * @implements {toa.deployment.Factory}
+ */
 class Factory {
+  /** @type {toa.norm.Context} */
   #context
+  /** @type {toa.deployment.images.Registry} */
+  #registry
+  /** @type {toa.operations.Process} */
+  #process
 
+  /**
+   * @param context {toa.norm.Context}
+   */
   constructor (context) {
     this.#context = context
-  }
+    this.#process = new Process()
 
-  deployment () {
-    const compositions = this.#compositions()
-    const images = Array.from(compositions).map((composition) => composition.image)
-    const chart = new Chart(this.#context, compositions)
-
-    return new Deployment(chart, images)
+    const images = new Images(context.name, context.runtime)
+    this.#registry = new Registry(context.registry, images, this.#process)
   }
 
-  #compositions () {
-    return new Compositions(this.#context, (composition) => this.#composition(composition))
+  operator () {
+    const compositions = this.#context.compositions.map((composition) => this.#composition(composition))
+    const dependencies = this.#dependencies()
+    const deployment = new Deployment(this.#context, compositions, dependencies, this.#process)
+
+    return new Operator(deployment, this.#registry)
   }
 
+  /**
+   * @param composition {toa.norm.context.Composition}
+   * @returns {Composition}
+   */
   #composition (composition) {
-    const image = this.#image(composition)
+    const image = this.#registry.composition(composition)
 
     return new Composition(composition, image)
   }
 
-  #image = (composition) => new Image(composition, this.#context)
+  /**
+   * @returns {toa.deployment.Dependency[]}
+   */
+  #dependencies () {
+    /** @type {toa.deployment.Dependency[]} */
+    const dependencies = []
+
+    for (const [reference, instances] of Object.entries(this.#context.dependencies)) {
+      const dependency = this.#dependency(reference, instances)
+
+      if (dependency !== undefined) dependencies.push(dependency)
+    }
+
+    return dependencies
+  }
+
+  /**
+   * @param {string} path
+   * @param {toa.norm.context.dependencies.Instance[]} instances
+   * @returns {toa.deployment.Dependency | undefined}
+   */
+  #dependency (path, instances) {
+    const module = require(path)
+    const pkg = require(path + '/package.json')
+
+    if (module.deployment === undefined) return
+
+    const annotations = this.#context.annotations?.[pkg.name]
+
+    /** @type {toa.deployment.dependency.Declaration} */
+    const dependency = module.deployment(instances, annotations)
+
+    /** @type {toa.deployment.Service[]} */
+    const services = dependency.services?.map((service) => this.#service(path, service))
+
+    return { ...dependency, services }
+  }
+
+  /**
+   * @param path {string}
+   * @param service {toa.deployment.dependency.Service}
+   * @returns {Service}
+   */
+  #service (path, service) {
+    const image = this.#registry.service(path, service)
+
+    return new Service(service, image)
+  }
 }
 
 exports.Factory = Factory