@toa.io/operations 1.0.0-alpha.28 → 1.0.0-alpha.280

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

@@ -5,6 +5,16 @@ metadata:
   name: extension-{{ required "deployment name is required" .name }}
 spec:
   replicas: {{ .replicas | default 2 }}
+  # A backstop for stuck rollouts only. Must stay above the `helm upgrade --timeout`
+  # the deploy runs with, so a slow but progressing rollout is not marked failed.
+  progressDeadlineSeconds: 900
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      # a replacement must pass readiness before a running replica is taken out,
+      # otherwise a single pod serves all traffic while the others start up
+      maxUnavailable: 0
+      maxSurge: 50%
   selector:
     matchLabels:
       toa.io/service: extension-{{ .name }}
@@ -16,6 +26,25 @@ spec:
       containers:
         - name: extension-{{ .name }}
           image: {{ .image }}
+          {{- if .resources }}
+          resources:
+            {{- if or .resources.cpu .resources.memory }}
+            requests:
+              {{- if .resources.cpu }}
+              cpu: {{ index .resources.cpu 0 }}
+              {{- end }}
+              {{- if .resources.memory }}
+              memory: {{ index .resources.memory 0 }}
+              {{- end }}
+            limits:
+              {{- if .resources.cpu }}
+              cpu: {{ index .resources.cpu 1 }}
+              {{- end }}
+              {{- if .resources.memory }}
+              memory: {{ index .resources.memory 1 }}
+              {{- end }}
+            {{- end }}
+          {{- end }}
           {{- if .variables }}
           env:
             {{- range .variables }}
@@ -23,19 +52,46 @@ spec:
             {{- end }}
           {{- end }}
           {{- if .probe }}
-          readinessProbe:
+          startupProbe:
             httpGet:
               path: {{ .probe.path }}
               port: {{ .probe.port }}
             {{- if .probe.delay }}
             initialDelaySeconds: {{ .probe.delay }}
             {{- end }}
+            periodSeconds: 2
+            timeoutSeconds: 3
+            failureThreshold: 150
+          readinessProbe:
+            httpGet:
+              path: {{ .probe.path }}
+              port: {{ .probe.port }}
+            periodSeconds: 10
+            timeoutSeconds: 3
+            failureThreshold: 3
           {{- end }}
+          lifecycle:
+            preStop:
+              exec:
+                command: [sleep, "5"]
+      terminationGracePeriodSeconds: 45
+      topologySpreadConstraints:
+        - maxSkew: 1
+          topologyKey: kubernetes.io/hostname
+          whenUnsatisfiable: ScheduleAnyway
+          labelSelector:
+            matchLabels:
+              toa.io/service: extension-{{ .name }}
+{{- if .port }}
 ---
 apiVersion: v1
 kind: Service
 metadata:
   name: extension-{{ .name }}
+  {{- if .annotations }}
+  annotations:
+{{ toYaml .annotations | indent 4 }}
+  {{- end }}
 spec:
   type: ClusterIP
   selector:
@@ -45,9 +101,12 @@ spec:
       protocol: TCP
       port: {{ .port }}
       targetPort: {{ .port }}
----
+{{- end }}
 {{- if .ingress }}
 {{- $service := .name }}
+{{- $port := .port }}
+{{- $path := .ingress.path | default "/" }}
+---
 apiVersion: networking.k8s.io/v1
 kind: Ingress
 metadata:
@@ -65,13 +124,25 @@ spec:
     - host: {{ . }}
       http:
         paths:
-          - path: /
+          - path: {{ $path }}
+            pathType: Prefix
+            backend:
+              service:
+                name: extension-{{ $service }}
+                port:
+                  number: {{ $port }}
+    {{- end }}
+    {{- if .ingress.default }}
+    - http:
+        paths:
+          - path: {{ $path }}
             pathType: Prefix
             backend:
               service:
                 name: extension-{{ $service }}
                 port:
-                  number: 8000
+                  number: {{ $port }}
     {{- end }}
 {{- end }}
+---
 {{- end }}

package/src/deployment/chart/values.yaml

@@ -3,9 +3,16 @@ compositions:
   - name: todos
     image: localhost:5000/composition-todos:0.0.0
     replicas: 2
+    mounts:
+      - name: mount-name
+        path: /storage
+        claim: storage-pvc
     components:
       - todos-tasks
       - todos-stats
+    resources:
+      cpu: [100m, 1]
+      memory: [100Mi, 1Gi]
     variables:
       - name: TOA_CONFIGURATION_TODOS_TASKS
         value: foo
@@ -18,7 +25,6 @@ compositions:
     replicas: 3
     components:
       - users-users
-# TODO: create component services only if sync binding is being used
 components:
   - todos-tasks
   - todos-stats
@@ -28,7 +34,11 @@ services:
     image: localhost:5000/resources-gateway:0.0.0
     port: 8000
     replicas: 2
+    resources:
+      cpu: [100m, 1]
+      memory: [100Mi, 1Gi]
     ingress:
+      default: true
       hosts: [dummies.toa.io]
       class: alb
       annotations:

package/src/deployment/composition.js

@@ -1,6 +1,4 @@
-'use strict'
-
-class Composition {
+export class Composition {
   name
   image
   /** @type {string[]} */
@@ -10,9 +8,8 @@ class Composition {
     this.name = composition.name
     this.image = image.reference
     this.components = composition.components.map(component)
+    this.resources = composition.resources
   }
 }
 
 const component = (component) => component.locator.label
-
-exports.Composition = Composition

package/src/deployment/deployment.js

@@ -1,23 +1,21 @@
-'use strict'
+import { join } from 'node:path'
+import { writeFile as write } from 'node:fs/promises'
+import { yaml as jsyaml } from '@toa.io/generic'
+import fs from 'fs-extra'
 
-const { join } = require('node:path')
-const { writeFile: write } = require('node:fs/promises')
-const { dump } = require('@toa.io/yaml')
-const fs = require('fs-extra')
+import { merge, declare, describe } from './.deployment/index.js'
 
-const { merge, declare, describe } = require('./.deployment')
-
-class Deployment {
+export class Deployment {
   #chart
   #values
   #process
   #target
 
-  constructor (context, compositions, dependencies, process) {
+  constructor (context, compositions, dependencies, process, image) {
     const dependency = merge(dependencies)
 
     this.#chart = declare(context, dependency)
-    this.#values = describe(context, compositions, dependency)
+    this.#values = describe(context, compositions, dependency, image)
     this.#process = process
   }
 
@@ -42,6 +40,7 @@ class Deployment {
 
     if (options.namespace !== undefined) args.push('-n', options.namespace)
     if (options.wait === true) args.push('--wait')
+    if (options.timeout !== undefined) args.push('--timeout', options.timeout)
 
     await this.#process.execute('helm', ['dependency', 'update', this.#target])
     await this.#process.execute('helm', ['upgrade', this.#chart.name, '-i', ...args, this.#target])
@@ -68,6 +67,9 @@ class Deployment {
     addVariables(this.#values.compositions, variables, used)
     addVariables(this.#values.services, variables, used)
 
+    if (this.#values.mono !== undefined)
+      addVariables([this.#values.mono], variables, used)
+
     return variables
   }
 }
@@ -85,6 +87,11 @@ function addVariables (list, variables, used = new Set()) {
   }
 }
 
-const TEMPLATES = join(__dirname, 'chart/templates')
+const TEMPLATES = join(import.meta.dirname, 'chart/templates')
+
 
-exports.Deployment = Deployment
+
+function dump (object) {
+  // js-yaml writes plain objects only, and the values carry locators and images
+  return jsyaml.dump(JSON.parse(JSON.stringify(object)), { noRefs: true, lineWidth: -1 })
+}

package/src/deployment/factory.js

@@ -1,35 +1,56 @@
-'use strict'
-
-const { context: load } = require('@toa.io/norm')
-const { Process } = require('../process')
-const { Operator } = require('./operator')
-const { Factory: ImagesFactory } = require('./images')
-const { Deployment } = require('./deployment')
-const { Registry } = require('./registry')
-const { Composition } = require('./composition')
-const { Service } = require('./service')
-
-class Factory {
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { createRequire } from 'node:module'
+import { pathToFileURL } from 'node:url'
+import { context as load } from '@toa.io/norm'
+import { Process } from '../process.js'
+import { Operator } from './operator.js'
+import { Factory as ImagesFactory } from './images/index.js'
+import { Deployment } from './deployment.js'
+
+// a dependency is resolved the way a package is
+const require = createRequire(import.meta.url)
+import { Registry } from './registry.js'
+import { Composition } from './composition.js'
+import { Service } from './service.js'
+
+export class Factory {
   #context
+  #mono
   #compositions
   #dependencies
   #registry
   #process
-  #extensionComponents = []
+  #image
 
-  constructor (context) {
+  constructor (context, options = {}) {
     this.#context = context
+    this.#mono = options.mono === true
     this.#process = new Process()
 
     const imagesFactory = new ImagesFactory(context.name, context.runtime, context.registry)
 
-    this.#registry = new Registry(context.registry, imagesFactory, this.#process)
-    this.#compositions = context.compositions.map((composition) => this.#composition(composition))
+    this.#registry = new Registry(context.name, context.registry, imagesFactory, this.#process)
     this.#dependencies = this.#getDependencies()
+    this.#compositions = []
+
+    if (this.#mono)
+      this.#image = this.#registry.mono({
+        components: context.components
+      })
+    else
+      this.#compositions = context.compositions.map((composition) => this.#composition(composition))
   }
 
-  operator () {
-    const deployment = new Deployment(this.#context, this.#compositions, this.#dependencies, this.#process)
+  async operator () {
+    const deployment = new Deployment(
+      this.#context,
+      this.#compositions,
+      // the constructor cannot await, so what it started is settled here
+      await this.#dependencies,
+      this.#process,
+      this.#image
+    )
 
     return new Operator(deployment, this.#registry)
   }
@@ -44,14 +65,14 @@ class Factory {
     return new Composition(composition, image)
   }
 
-  #getDependencies () {
+  async #getDependencies () {
     /** @type {toa.deployment.Dependency[]} */
     const dependencies = []
 
     if (this.#context.dependencies === undefined) return dependencies
 
     for (const [reference, instances] of Object.entries(this.#context.dependencies)) {
-      const dependency = this.#getDependency(reference, instances)
+      const dependency = await this.#getDependency(reference, instances)
 
       if (dependency !== undefined) dependencies.push(dependency)
     }
@@ -59,9 +80,11 @@ class Factory {
     return dependencies
   }
 
-  #getDependency (path, instances) {
-    const module = require(path)
-    const pkg = require(path + '/package.json')
+  async #getDependency (reference, instances) {
+    // a dependency may be named the way a package is or written as a directory,
+    // and a module is loaded by file
+    const module = await import(pathToFileURL(require.resolve(reference)).href)
+    const pkg = JSON.parse(readFileSync(require.resolve(join(reference, 'package.json')), 'utf8'))
 
     if (module.deployment === undefined) return
 
@@ -71,7 +94,8 @@ class Factory {
     const dependency = module.deployment(instances, annotation)
 
     /** @type {toa.deployment.Service[]} */
-    const services = dependency.services?.map((service) => this.#service(path, service))
+    const services = dependency.services?.map((service) =>
+      this.#mono ? service : this.#service(reference, service))
 
     return { ...dependency, services }
   }
@@ -87,11 +111,9 @@ class Factory {
     return new Service(service, image)
   }
 
-  static async create (path, environment) {
+  static async create (path, environment, options = {}) {
     const context = await load(path, environment)
 
-    return new Factory(context)
+    return new Factory(context, options)
   }
 }
-
-exports.Factory = Factory

package/src/deployment/images/composition.Dockerfile

@@ -5,7 +5,6 @@ FROM {{build.image}}
 ENV NODE_ENV=production
 RUN if [ "{{runtime.registry}}" != "" ]; then npm set registry {{runtime.registry}}; fi
 RUN if [ "{{runtime.proxy}}" != "" ]; then npm set proxy {{runtime.proxy}}; fi
-RUN npm i -g @toa.io/runtime@{{runtime.version}} --omit=dev
 
 WORKDIR /composition
 COPY --chown=node:node . /composition
@@ -13,7 +12,8 @@ COPY --chown=node:node . /composition
 {{build.run}}
 
 # run 'npm i' in each component
-RUN for entry in *; do if [ -f "$entry/package.json" ]; then (cd $entry && npm i --omit=dev); fi; done
+RUN --mount=type=cache,target=/root/.npm \
+  for entry in *; do if grep -qs '"dependencies"' "$entry/package.json"; then (cd $entry && npm i --omit=dev); fi; done
 
 USER node
 CMD toa compose *

package/src/deployment/images/composition.js

@@ -1,13 +1,12 @@
-'use strict'
+import { join } from 'node:path'
+import fs from 'fs-extra'
+import { createHash } from 'node:crypto'
 
-const { join } = require('node:path')
-const fs = require('fs-extra')
-const { createHash } = require('node:crypto')
+import { Image } from './image.js'
+import { declare } from './format.js'
 
-const { Image } = require('./image')
-
-class Composition extends Image {
-  dockerfile = join(__dirname, 'composition.Dockerfile')
+export class Composition extends Image {
+  dockerfile = join(import.meta.dirname, 'composition.Dockerfile')
 
   #name
   #image
@@ -37,34 +36,39 @@ class Composition extends Image {
   }
 
   get base () {
-    if (this.#image !== undefined) {
-      return this.#image
-    }
+    if (this.#image !== undefined) return this.#image
 
-    let image = null
+    const images = new Set(this.#components.map((component) => component.build?.image))
 
-    for (const component of this.#components) {
-      const value = component.build?.image
+    if (images.size > 1)
+      throw new Error(`Composition '${this.#name}' requires different base images for its components. Specify base image for the composition in the context.`)
+
+    return images.values().next().value
+  }
 
-      if (image !== null && image !== value) {
-        throw new Error(`Composition '${this.#name}' requires different base images for its components. Specify base image for the composition in the context.`)
-      }
+  get run () {
+    const commands = []
 
-      image = value
+    for (const component of this.#components) {
+      const run = component.build?.run
+
+      if (run !== undefined)
+        commands.push(run)
     }
 
-    return image ?? undefined
+    return commands.join('\n')
   }
 
   async prepare (root) {
     const context = await super.prepare(root)
 
     for (const component of this.#components) {
-      await fs.copy(component.path, join(context, component.locator.label))
+      const target = join(context, component.locator.label)
+
+      await fs.copy(component.path, target)
+      await declare(component.path, target, component.locator.label)
     }
 
     return context
   }
 }
-
-exports.Composition = Composition

package/src/deployment/images/factory.js

@@ -1,12 +1,8 @@
-'use strict'
+import { Composition } from './composition.js'
+import { Service } from './service.js'
+import { Mono } from './mono.js'
 
-const { Composition } = require('./composition')
-const { Service } = require('./service')
-
-/**
- * @implements {toa.deployment.images.Factory}
- */
-class Factory {
+export class Factory {
   /** @type {string} */
   #scope
 
@@ -48,6 +44,15 @@ class Factory {
 
     return instance
   }
-}
 
-exports.Factory = Factory
+  /**
+   * @returns {Mono}
+   */
+  mono (composition) {
+    const instance = new Mono(this.#scope, this.#runtime, this.#registry, composition)
+
+    instance.tag()
+
+    return instance
+  }
+}

package/src/deployment/images/format.js

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { writeFile } from 'node:fs/promises'
+import { dirname, join, parse } from 'node:path'
+
+/**
+ * A component is copied into the image on its own, away from the package that
+ * declared what its files are. Node reads a `.js` as CommonJS unless a manifest
+ * beside it says otherwise, so the one the component was written under is
+ * restated where it lands.
+ *
+ * A component that ships its own manifest already says so, and is left alone.
+ *
+ * @param {string} source the component in the workspace
+ * @param {string} target where it was copied
+ * @param {string} name
+ */
+export async function declare (source, target, name) {
+  if (existsSync(join(target, MANIFEST))) return
+
+  await writeFile(join(target, MANIFEST),
+    JSON.stringify({ name, private: true, type: format(source) }, null, 2) + '\n')
+}
+
+/**
+ * The module format a directory's files are read as, which the nearest manifest
+ * above it decides.
+ *
+ * @param {string} directory
+ * @returns {'module' | 'commonjs'}
+ */
+export function format (directory) {
+  const { root } = parse(directory)
+
+  let current = directory
+
+  while (current !== root) {
+    const manifest = join(current, MANIFEST)
+
+    if (existsSync(manifest))
+      return JSON.parse(readFileSync(manifest, 'utf8')).type === 'module' ? 'module' : 'commonjs'
+
+    current = dirname(current)
+  }
+
+  return 'commonjs'
+}
+
+const MANIFEST = 'package.json'

package/src/deployment/images/format.test.js

@@ -0,0 +1,74 @@
+import { it, describe, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { declare, format } from './format.js'
+
+let root
+
+before(async () => {
+  root = await mkdtemp(join(tmpdir(), 'format-'))
+})
+
+after(async () => {
+  await rm(root, { recursive: true, force: true })
+})
+
+describe('format', () => {
+  it('should read the nearest manifest above', async () => {
+    const workspace = join(root, 'modules')
+    const component = join(workspace, 'components', 'one')
+
+    await mkdir(component, { recursive: true })
+    await writeFile(join(workspace, 'package.json'), JSON.stringify({ type: 'module' }))
+
+    assert.strictEqual(format(component), 'module')
+  })
+
+  it('should default to commonjs', async () => {
+    const workspace = join(root, 'scripts')
+    const component = join(workspace, 'components', 'one')
+
+    await mkdir(component, { recursive: true })
+    await writeFile(join(workspace, 'package.json'), JSON.stringify({ name: 'scripts' }))
+
+    assert.strictEqual(format(component), 'commonjs')
+  })
+})
+
+describe('declare', () => {
+  it('should state the format the component was written under', async () => {
+    const workspace = join(root, 'stated')
+    const source = join(workspace, 'components', 'one')
+    const target = join(root, 'image', 'one')
+
+    await mkdir(source, { recursive: true })
+    await mkdir(target, { recursive: true })
+    await writeFile(join(workspace, 'package.json'), JSON.stringify({ type: 'module' }))
+
+    await declare(source, target, 'default-one')
+
+    const manifest = JSON.parse(await readFile(join(target, 'package.json'), 'utf8'))
+
+    assert.strictEqual(manifest.type, 'module')
+    assert.strictEqual(manifest.name, 'default-one')
+    assert.strictEqual(manifest.private, true)
+  })
+
+  it('should leave a manifest the component ships alone', async () => {
+    const source = join(root, 'own', 'components', 'one')
+    const target = join(root, 'image', 'own')
+
+    await mkdir(source, { recursive: true })
+    await mkdir(target, { recursive: true })
+
+    const own = JSON.stringify({ name: 'own', dependencies: { matchacho: '0.6.0' } })
+
+    await writeFile(join(target, 'package.json'), own)
+    await declare(source, target, 'default-own')
+
+    assert.strictEqual(await readFile(join(target, 'package.json'), 'utf8'), own)
+  })
+})

package/src/deployment/images/image.fixtures.js

@@ -1,7 +1,5 @@
-'use strict'
-
-const { Image } = require('./image')
-const { generate } = require('randomstring')
+import { Image } from './image.js'
+import { generate } from 'randomstring'
 
 const version = '168b04ff'
 const name = generate()
@@ -29,10 +27,12 @@ const registry = {
   base: 'node:alpine'
 }
 
-exports.scope = generate()
-exports.name = name
-exports.version = 'ba2409fc'
-exports.Class = Class
-exports.runtime = runtime
-exports.registry = registry
-exports.process = process
+export const scope = generate()
+
+// distinct from the module's own `version` above
+const published = 'ba2409fc'
+
+// the fixture stands in for the global process
+const current = process
+
+export { name, Class, runtime, registry, current as process, published as version }