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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/operations",
-  "version": "0.2.0-dev.2",
+  "version": "0.2.1-dev.3",
   "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.2",
+    "@toa.io/filesystem": "*",
+    "@toa.io/generic": "*",
+    "@toa.io/yaml": "*",
     "execa": "5.1.1"
   },
-  "gitHead": "83480176c88640dd2bed2a775ce2d13b95341f19"
+  "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/chart/Chart.yaml

@@ -0,0 +1,7 @@
+# This file helps with IDE autocompletion
+apiVersion: v2
+name: toa-application
+description: Toa Application Chart
+type: application
+version: 0.0.0
+appVersion: "0.0.0"

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

@@ -0,0 +1,16 @@
+{{- range .Values.components }}
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ . }}
+spec:
+  type: ClusterIP
+  selector:
+    {{ . }}: "1"
+  ports:
+    - name: http-binding
+      protocol: TCP
+      port: 3000
+      targetPort: 3000
+---
+{{- end }}

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

@@ -0,0 +1,30 @@
+'use strict'
+
+// noinspection JSClosureCompilerSyntax
+/**
+ * @implements {toa.deployment.Composition}
+ */
+class Composition {
+  name
+  image
+  /** @type {string[]} */
+  components
+
+  /**
+   * @param composition {toa.norm.context.Composition}
+   * @param image {toa.deployment.images.Image}
+   */
+  constructor (composition, image) {
+    this.name = composition.name
+    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

@@ -0,0 +1,82 @@
+'use strict'
+
+const { join } = require('node:path')
+const { writeFile: write } = require('node:fs/promises')
+const { directory: { copy } } = require('@toa.io/filesystem')
+const { dump } = require('@toa.io/yaml')
+
+const { merge, declare, describe } = require('./.deployment')
+
+/**
+ * @implements {toa.deployment.Deployment}
+ */
+class Deployment {
+  /** @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 export (target) {
+    const chart = dump(this.#declaration)
+    const values = dump(this.#contents)
+
+    await Promise.all([
+      write(join(target, 'Chart.yaml'), chart),
+      write(join(target, 'values.yaml'), values),
+      copy(TEMPLATES, join(target, 'templates'))
+    ])
+
+    this.#target = target
+  }
+
+  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')
+
+    await this.#process.execute('helm', ['dependency', 'update', this.#target])
+    await this.#process.execute('helm', ['upgrade', this.#declaration.name, '-i', ...args, this.#target])
+  }
+
+  async template (options) {
+    if (this.#target === undefined) throw new Error('Deployment hasn\'t been exported')
+
+    await this.#process.execute('helm', ['dependency', 'update', this.#target], { silently: true })
+
+    const args = []
+
+    if (options.namespace !== undefined) args.push('-n', options.namespace)
+
+    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

@@ -0,0 +1,100 @@
+'use strict'
+
+const { Process } = require('../process')
+const { Operator } = require('./operator')
+const { Factory: Images, Registry } = require('./images')
+const { Deployment } = require('./deployment')
+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()
+
+    const images = new Images(context.name, context.runtime)
+    this.#registry = new Registry(context.registry, images, this.#process)
+  }
+
+  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.#registry.composition(composition)
+
+    return new Composition(composition, image)
+  }
+
+  /**
+   * @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

package/src/deployment/images/composition.Dockerfile

@@ -0,0 +1,14 @@
+FROM node:18.2.0-alpine3.15
+
+ENV NODE_ENV=production
+RUN npm set registry {{registry}}
+RUN npm set proxy {{proxy}}
+RUN npm i -g @toa.io/runtime@{{version}}
+
+WORKDIR /composition
+ADD . .
+
+# run 'npm i' in each component
+RUN find . -maxdepth 1 -type d \( ! -name . \) -exec /bin/sh -c "cd '{}' && if [ -f package.json ]; then npm i; fi" \;
+
+CMD toa compose *

package/src/deployment/images/composition.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const { join } = require('node:path')
+const { hash } = require('@toa.io/generic')
+const { directory: { copy } } = require('@toa.io/filesystem')
+
+const { Image } = require('./image')
+
+class Composition extends Image {
+  dockerfile = join(__dirname, 'composition.Dockerfile')
+
+  /** @type {string} */
+  #name
+  /** @type {Array<toa.norm.Component>} */
+  #components
+
+  /**
+   * @param scope {string}
+   * @param runtime {toa.norm.context.Runtime}
+   * @param composition {toa.norm.context.Composition}
+   */
+  constructor (scope, runtime, composition) {
+    super(scope, runtime)
+
+    this.#name = composition.name
+    this.#components = composition.components
+  }
+
+  get name () {
+    return this.#name
+  }
+
+  get version () {
+    const tags = this.#components.map((component) => component.locator.id + ':' + component.version)
+
+    return hash(tags.join(';'))
+  }
+
+  async prepare (root) {
+    const context = await super.prepare(root)
+
+    for (const component of this.#components) {
+      await copy(component.path, join(context, component.locator.label))
+    }
+
+    return context
+  }
+}
+
+exports.Composition = Composition