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

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

@@ -1,8 +1,10 @@
-'use strict'
+import * as desc from './.describe/index.js'
+import { addVariables } from './.describe/variables.js'
+import { addMounts } from './.describe/mounts.js'
+import { resources } from './.describe/resources.js'
+import { events } from './.describe/events.js'
 
-const get = require('./.describe')
-
-const describe = (context, compositions, dependency) => {
+export const describe = (context, compositions, dependency, image) => {
   const { services } = dependency
 
   dependency.variables.global ??= []
@@ -17,18 +19,140 @@ const describe = (context, compositions, dependency) => {
     }
   )
 
-  const components = get.components(compositions)
+  const atomicity = context.atomicity
+
+  if (atomicity?.redis !== undefined) {
+    const addresses = Array.isArray(atomicity.redis) ? atomicity.redis : [atomicity.redis]
+
+    // a lock is taken on `floor(n / 2) + 1` of them, so an even number tolerates no more
+    // losses than the odd number below it, and two tolerate fewer than one does
+    if (addresses.length % 2 === 0)
+      throw new Error(`'atomicity.redis' takes an odd number of addresses, ` +
+        `${addresses.length} given`)
+
+    dependency.variables.global.push({
+      name: 'TOA_ATOMICITY_REDIS',
+      value: addresses.join(' ')
+    })
+  }
+
+  if (atomicity?.interval !== undefined)
+    dependency.variables.global.push({
+      name: 'TOA_ATOMICITY_INTERVAL',
+      value: String(atomicity.interval)
+    })
+
+  const outbox = context.outbox
+
+  if (outbox?.interval !== undefined)
+    dependency.variables.global.push({
+      name: 'TOA_OUTBOX_INTERVAL',
+      value: String(outbox.interval)
+    })
+
+  if (outbox?.batch !== undefined)
+    dependency.variables.global.push({
+      name: 'TOA_OUTBOX_BATCH',
+      value: String(outbox.batch)
+    })
+
+  if (outbox?.retention !== undefined)
+    dependency.variables.global.push({
+      name: 'TOA_OUTBOX_RETENTION',
+      value: String(outbox.retention)
+    })
+
+  events(context, dependency)
+
   const credentials = context.registry?.credentials
 
-  get.compositions(compositions, dependency.variables, context.environment)
-  get.services(services, dependency.variables)
+  if (image !== undefined) {
+    const mono = unit(context, dependency)
+
+    mono.image = image.reference
+
+    const values = {
+      compositions: [],
+      components: mono.components,
+      services: [],
+      credentials,
+      mono
+    }
+
+    resources(context, values)
 
-  return {
+    return values
+  }
+
+  const components = desc.components(compositions)
+
+  desc.compositions(compositions, dependency)
+  desc.services(services, dependency.variables, dependency.probe, context.ingress)
+
+  const values = {
     compositions,
     components,
     services,
     credentials
   }
+
+  resources(context, values)
+
+  return values
 }
 
-exports.describe = describe
+function unit (context, dependency) {
+  const components = (context.components ?? []).map((component) => component.locator.label)
+
+  const variables = dependency.variables ?? {}
+  const mounts = dependency.mounts ?? {}
+
+  const mono = {
+    replicas: context.mono?.replicas,
+    resources: context.mono?.resources,
+    components,
+    variables: []
+  }
+
+  if (context.ingress !== undefined)
+    mono.ingress = Object.assign({}, context.ingress)
+
+  addVariables(mono, variables, Object.keys(variables))
+  addMounts(mono, dependency.mounts, Object.keys(mounts))
+
+  for (const service of dependency.services ?? []) {
+    if (service.variables !== undefined)
+      for (const variable of service.variables)
+        if (!mono.variables.some((item) => item.name === variable.name))
+          mono.variables.push(variable)
+
+    // every declared port is bound by the single mono process, none is primary
+    if (service.port !== undefined)
+      (mono.backends ??= []).push({ port: service.port, path: service.ingress?.path ?? '/' })
+
+    // one Service fronts every backend, so its annotations are the union
+    if (service.annotations !== undefined)
+      mono.annotations = Object.assign(mono.annotations ?? {}, service.annotations)
+
+    if (service.ingress !== undefined) {
+      const { path, hosts, ...ingress } = service.ingress
+
+      mono.ingress = Object.assign(mono.ingress ?? {}, ingress)
+
+      // one Ingress serves every path, so its hosts are the union, not the last word
+      if (hosts !== undefined)
+        mono.ingress.hosts = [...new Set([...(mono.ingress.hosts ?? []), ...hosts])]
+    }
+
+    if (service.probe !== undefined && service.probe !== false)
+      mono.probe = service.probe
+  }
+
+  if (mono.probe === undefined && dependency.probe !== undefined && dependency.probe !== false)
+    mono.probe = dependency.probe
+
+  // the more specific prefix must come first, whatever the controller's tie-break
+  mono.backends?.sort((a, b) => b.path.length - a.path.length)
+
+  return mono
+}

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

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

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

@@ -1,6 +1,4 @@
-'use strict'
-
-const merge = (dependencies) => {
+export const merge = (dependencies) => {
   /** @type {toa.deployment.dependency.Reference[]} */
   const references = []
 
@@ -13,14 +11,58 @@ const merge = (dependencies) => {
   /** @type {toa.deployment.dependency.Variables} */
   const variables = {}
 
+  /** event labels consumed by something other than a component's own receivers */
+  const events = []
+
+  const mounts = {}
+
+  /** @type {toa.deployment.dependency.Probe | false | undefined} */
+  let probe
+
   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)
+    if (dependency.events !== undefined) events.push(...dependency.events)
+    if (dependency.mounts !== undefined) append(mounts, dependency.mounts)
+    if (dependency.probe !== undefined) probe = dependency.probe
   }
 
-  return { references, services, proxies, variables }
+  reserve(services, probe)
+
+  return { references, services, proxies, variables, mounts, events, probe }
+}
+
+/**
+ * In Kubernetes these are separate pods, but `toa mono` and a local run put every
+ * service in one process — so a port may be claimed once and only once.
+ */
+const reserve = (services, probe) => {
+  const claimed = new Map()
+
+  if (probe !== undefined && probe !== false)
+    claimed.set(probe.port, 'the readiness probe')
+
+  for (const service of services)
+    for (const [port, claimant] of ports(service)) {
+      const conflicting = claimed.get(port)
+
+      if (conflicting !== undefined)
+        throw new Error(`Port ${port} is claimed by both ${conflicting} and ${claimant}`)
+
+      claimed.set(port, claimant)
+    }
+}
+
+function * ports (service) {
+  const name = `'${service.group}-${service.name}'`
+
+  if (service.port !== undefined)
+    yield [service.port, name]
+
+  if (service.probe !== undefined && service.probe !== false && service.probe.port !== service.port)
+    yield [service.probe.port, `the readiness probe of ${name}`]
 }
 
 const append = (merged, variables) => {
@@ -30,5 +72,3 @@ const append = (merged, variables) => {
     merged[component].push(...vars)
   }
 }
-
-exports.merge = merge

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

@@ -0,0 +1,72 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { merge } from './merge.js'
+
+const service = (name, extra = {}) => ({ group: 'group', name, version: '0', ...extra })
+
+it('should merge services of all dependencies', () => {
+  const merged = merge([
+    { services: [service('one', { port: 8000 })] },
+    { services: [service('two', { port: 8001 })] }
+  ])
+
+  assert.strictEqual(merged.services.length, 2)
+})
+
+/*
+ * In Kubernetes these are separate pods, but `toa mono` and a local run put every
+ * service in one process.
+ */
+describe('port reservation', () => {
+  it('should reject two services claiming one port', () => {
+    const dependencies = [
+      { services: [service('one', { port: 8000 })] },
+      { services: [service('two', { port: 8000 })] }
+    ]
+
+    assert.throws(() => merge(dependencies), (error) => /Port 8000 is claimed by both 'group-one' and 'group-two'/.test(error.message))
+  })
+
+  it('should reject a service claiming the port of the readiness probe', () => {
+    const dependencies = [
+      { probe: { path: '/.ready', port: 8001 } },
+      { services: [service('one', { port: 8001 })] }
+    ]
+
+    assert.throws(() => merge(dependencies), (error) => /Port 8001 is claimed by both the readiness probe and 'group-one'/.test(error.message))
+  })
+
+  it('should reject a probe claiming the port of another service', () => {
+    const dependencies = [
+      { services: [service('one', { port: 8000 })] },
+      { services: [service('two', { port: 8002, probe: { path: '/.ready', port: 8000 } })] }
+    ]
+
+    assert.throws(() => merge(dependencies), (error) => /Port 8000 is claimed by both 'group-one' and the readiness probe of 'group-two'/.test(error.message))
+  })
+
+  it('should allow a service to probe its own port', () => {
+    const dependencies = [
+      { services: [service('one', { port: 8000, probe: { path: '/.ready', port: 8000 } })] }
+    ]
+
+    assert.doesNotThrow(() => merge(dependencies))
+  })
+
+  it('should ignore services without a port', () => {
+    const dependencies = [
+      { services: [service('one'), service('two')] }
+    ]
+
+    assert.doesNotThrow(() => merge(dependencies))
+  })
+
+  it('should ignore a disabled probe', () => {
+    const dependencies = [
+      { probe: false, services: [service('one', { port: 8000, probe: false })] }
+    ]
+
+    assert.doesNotThrow(() => merge(dependencies))
+  })
+})

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

@@ -5,6 +5,9 @@ metadata:
   name: composition-{{ required "composition 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
   selector:
     matchLabels:
       toa.io/composition: {{ .name }}
@@ -19,15 +22,82 @@ spec:
       containers:
         - name: {{ .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 }}
             {{- include "env.var" . | indent 12 }}
             {{- end }}
           {{- end }}
+          {{- if .probe }}
+          ports:
+            - containerPort: {{ .probe.port }}
+          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 }}
+          {{- if .mounts }}
+          volumeMounts:
+            {{- range .mounts }}
+            - name: {{ .name }}
+              mountPath: {{ .path }}
+            {{- end }}
+          {{- end }}
+          lifecycle:
+            preStop:
+              exec:
+                command: [sleep, "5"]
+      terminationGracePeriodSeconds: 45
       {{- if $.Values.credentials }}
       imagePullSecrets:
         - name: {{ $.Values.credentials }}
       {{- end }}
+      {{- if .mounts }}
+      volumes:
+        {{- range .mounts }}
+        - name: {{ .name }}
+          persistentVolumeClaim:
+            claimName: {{ .claim }}
+        {{- end }}
+      {{- end }}
+      topologySpreadConstraints:
+        - maxSkew: 1
+          topologyKey: kubernetes.io/hostname
+          whenUnsatisfiable: ScheduleAnyway
+          labelSelector:
+            matchLabels:
+              toa.io/composition: {{ .name }}
 ---
 {{- end }}

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

@@ -0,0 +1,181 @@
+{{- if .Values.mono }}
+{{- with .Values.mono }}
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: mono
+spec:
+  replicas: {{ .replicas | default 2 }}
+  progressDeadlineSeconds: 900
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxUnavailable: 0
+      maxSurge: 50%
+  selector:
+    matchLabels:
+      toa.io/composition: mono
+  template:
+    metadata:
+      labels:
+        toa.io/composition: mono
+        {{- range .components }}
+        {{ . }}: "1"
+        {{- end }}
+    spec:
+      containers:
+        - name: mono
+          image: {{ .image }}
+          {{- if or .backends .probe }}
+          ports:
+            {{- range .backends }}
+            - containerPort: {{ .port }}
+            {{- end }}
+            {{- if .probe }}
+            - containerPort: {{ .probe.port }}
+            {{- end }}
+          {{- end }}
+          {{- 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 }}
+            {{- include "env.var" . | indent 12 }}
+            {{- end }}
+          {{- end }}
+          {{- if .probe }}
+          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 }}
+          {{- if .mounts }}
+          volumeMounts:
+            {{- range .mounts }}
+            - name: {{ .name }}
+              mountPath: {{ .path }}
+            {{- end }}
+          {{- end }}
+          lifecycle:
+            preStop:
+              exec:
+                command: [sleep, "5"]
+      terminationGracePeriodSeconds: 45
+      {{- if $.Values.credentials }}
+      imagePullSecrets:
+        - name: {{ $.Values.credentials }}
+      {{- end }}
+      {{- if .mounts }}
+      volumes:
+        {{- range .mounts }}
+        - name: {{ .name }}
+          persistentVolumeClaim:
+            claimName: {{ .claim }}
+        {{- end }}
+      {{- end }}
+      topologySpreadConstraints:
+        - maxSkew: 1
+          topologyKey: kubernetes.io/hostname
+          whenUnsatisfiable: ScheduleAnyway
+          labelSelector:
+            matchLabels:
+              toa.io/composition: mono
+{{- if .backends }}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: mono
+  {{- if .annotations }}
+  annotations:
+{{ toYaml .annotations | indent 4 }}
+  {{- end }}
+spec:
+  type: ClusterIP
+  selector:
+    toa.io/composition: mono
+  ports:
+    {{- range .backends }}
+    - name: port-{{ .port }}
+      protocol: TCP
+      port: {{ .port }}
+      targetPort: {{ .port }}
+    {{- end }}
+{{- end }}
+{{- if .ingress }}
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: mono
+  {{- if .ingress.annotations }}
+  annotations:
+{{ toYaml .ingress.annotations | indent 4 }}
+  {{- end }}
+spec:
+  {{- if .ingress.class }}
+  ingressClassName: {{ .ingress.class }}
+  {{- end }}
+  {{- $backends := .backends }}
+  rules:
+    {{- range .ingress.hosts }}
+    - host: {{ . }}
+      http:
+        paths:
+          {{- range $backends }}
+          - path: {{ .path }}
+            pathType: Prefix
+            backend:
+              service:
+                name: mono
+                port:
+                  number: {{ .port }}
+          {{- end }}
+    {{- end }}
+    {{- if .ingress.default }}
+    - http:
+        paths:
+          {{- range $backends }}
+          - path: {{ .path }}
+            pathType: Prefix
+            backend:
+              service:
+                name: mono
+                port:
+                  number: {{ .port }}
+          {{- end }}
+    {{- end }}
+{{- end }}
+---
+{{- end }}
+{{- end }}