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

package/src/deployment/images/factory.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const { Composition } = require('./composition')
+const { Service } = require('./service')
+
+/**
+ * @implements {toa.deployment.images.Factory}
+ */
+class Factory {
+  /** @type {string} */
+  #scope
+  /** @type {toa.norm.context.Runtime} */
+  #runtime
+
+  /**
+   * @param scope {string}
+   * @param runtime {toa.norm.context.Runtime}
+   */
+  constructor (scope, runtime) {
+    this.#scope = scope
+    this.#runtime = runtime
+  }
+
+  /**
+   * @returns {Composition}
+   */
+  composition (composition) {
+    return new Composition(this.#scope, this.#runtime, composition)
+  }
+
+  /**
+   * @returns {Service}
+   */
+  service (path, service) {
+    return new Service(this.#scope, this.#runtime, path, service)
+  }
+}
+
+exports.Factory = Factory

package/src/deployment/images/image.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const { join, posix } = require('node:path')
+const { readFile: read, writeFile: write } = require('node:fs/promises')
+
+const { hash } = require('@toa.io/generic')
+const { directory } = require('@toa.io/filesystem')
+
+/**
+ * @implements {toa.deployment.images.Image}
+ * @abstract
+ */
+class Image {
+  context
+  reference
+
+  /**
+   * @protected
+   * @type {string}
+   */
+  dockerfile
+
+  /** @type {string} */
+  #scope
+  /** @type {toa.norm.context.Runtime} */
+  #runtime
+  /** @type {string} */
+  #type
+
+  /**
+   * @param scope {string}
+   * @param runtime {toa.norm.context.Runtime}
+   */
+  constructor (scope, runtime) {
+    this.#scope = scope
+    this.#runtime = runtime
+    this.#type = this.constructor.name.toLowerCase()
+  }
+
+  /**
+   * @abstract
+   * @protected
+   * @type {string}
+   */
+  get name () {}
+
+  /**
+   * @abstract
+   * @protected
+   * @type {string}
+   */
+  get version () {}
+
+  tag (base) {
+    const tag = hash(this.#runtime.version + ';' + this.version)
+
+    this.reference = posix.join(base, `${this.#scope}/${this.#type}-${this.name}:${tag}`)
+  }
+
+  async prepare (root) {
+    if (this.dockerfile === undefined) throw new Error('Dockerfile isn\'t specified')
+
+    const path = join(root, `${this.#type}-${this.name}.${this.version}`)
+
+    await directory.ensure(path)
+
+    const template = await read(this.dockerfile, 'utf-8')
+    const contents = template.replace(/{{(\.?\w+)}}/g, (_, key) => this.#value(key))
+    const ignore = 'Dockerfile'
+
+    await write(join(path, 'Dockerfile'), contents)
+    await write(join(path, '.dockerignore'), ignore)
+
+    this.context = path
+
+    return path
+  }
+
+  /**
+   * @param key {string}
+   * @returns {string}
+   */
+  #value (key) {
+    const [, property] = key.split('.')
+
+    if (property !== undefined) return this[property]
+    else return this.#runtime[key]
+  }
+}
+
+exports.Image = Image

package/src/deployment/images/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { Factory } = require('./factory')
+const { Registry } = require('./registry')
+
+exports.Factory = Factory
+exports.Registry = Registry

package/src/deployment/images/registry.js

@@ -0,0 +1,102 @@
+'use strict'
+
+const { directory: { remove } } = require('@toa.io/filesystem')
+
+/**
+ * @implements {toa.deployment.images.Registry}
+ */
+class Registry {
+  /** @type {toa.norm.context.Registry} */
+  #registry
+  /** @type {toa.deployment.images.Factory} */
+  #factory
+  /** @type {toa.operations.Process} */
+  #process
+  /** @type {Array<toa.deployment.images.Image>} */
+  #images = []
+
+  /**
+   * @param {toa.norm.context.Registry} registry
+   * @param {toa.deployment.images.Factory} factory
+   * @param {toa.operations.Process} process
+   */
+  constructor (registry, factory, process) {
+    this.#registry = registry
+    this.#factory = factory
+    this.#process = process
+  }
+
+  composition (composition) {
+    return this.#create('composition', composition)
+  }
+
+  service (path, service) {
+    return this.#create('service', path, service)
+  }
+
+  async prepare (target) {
+    await Promise.all(this.#images.map((image) => image.prepare(target)))
+  }
+
+  async push () {
+    for (const image of this.#images) {
+      await this.#push(image)
+      await remove(image.context)
+    }
+  }
+
+  /**
+   * @param {"composition" | "service"} type
+   * @param {...any} args
+   * @returns {toa.deployment.images.Image}
+   */
+  #create (type, ...args) {
+    const image = this.#factory[type](...args)
+
+    image.tag(this.#registry.base)
+    this.#images.push(image)
+
+    return image
+  }
+
+  /**
+   * @param {toa.deployment.images.Image} image
+   * @returns {Promise<void>}
+   */
+  async #push (image) {
+    const args = ['buildx', 'build', '--push', '--tag', image.reference, image.context]
+    const local = this.#registry.platforms === null
+
+    if (local) {
+      args.push('--builder', 'default')
+    } else {
+      const platform = this.#registry.platforms.join(',')
+
+      args.push('--platform', platform)
+      args.push('--builder', BUILDER)
+
+      await this.#builder()
+    }
+
+    await this.#process.execute('docker', args)
+  }
+
+  async #builder () {
+    const ls = 'buildx ls'.split(' ')
+    const output = await this.#process.execute('docker', ls, { silently: true })
+
+    const exists = output.split('\n').find((line) => line.startsWith('toa '))
+
+    if (exists === undefined) {
+      const create = `buildx create --name ${BUILDER} --use`.split(' ')
+      const bootstrap = 'buildx inspect --bootstrap'.split(' ')
+
+      await this.#process.execute('docker', create)
+      await this.#process.execute('docker', bootstrap)
+    }
+  }
+}
+
+const BUILDER = 'toa'
+
+exports.Registry = Registry

package/src/deployment/images/service.Dockerfile

@@ -0,0 +1,12 @@
+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 /service
+ADD . .
+RUN npm i
+
+CMD toa serve .

package/src/deployment/images/service.js

@@ -0,0 +1,70 @@
+'use strict'
+
+const { join, dirname } = require('node:path')
+
+const { Image } = require('./image')
+const { directory: { copy } } = require('@toa.io/filesystem')
+
+class Service extends Image {
+  dockerfile = join(__dirname, 'service.Dockerfile')
+
+  /**
+   * Used by Dockerfile
+   *
+   * @readonly
+   * @type {string}
+   * */
+  service
+
+  /** @type {string} */
+  #group
+  /** @type {string} */
+  #name
+  /** @type {string} */
+  #path
+  /** @type {string} */
+  #version
+
+  /**
+   * @param {string} scope
+   * @param {toa.norm.context.Runtime} runtime
+   * @param {string} reference
+   * @param {toa.deployment.dependency.Service} service
+   */
+  constructor (scope, runtime, reference, service) {
+    super(scope, runtime)
+
+    this.service = service.name
+
+    this.#group = service.group
+    this.#name = service.name
+    this.#path = find(reference)
+    this.#version = service.version
+  }
+
+  get name () {
+    return this.#group + '-' + this.#name
+  }
+
+  get version () {
+    return this.#version
+  }
+
+  async prepare (root) {
+    const context = await super.prepare(root)
+
+    await copy(this.#path, context)
+
+    return context
+  }
+}
+
+/**
+ * @param {string} reference
+ * @returns {string}
+ */
+const find = (reference) => {
+  return dirname(require.resolve(join(reference, 'package.json')))
+}
+
+exports.Service = Service

package/src/deployment/index.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const { Factory } = require('./factory')
+
+exports.Factory = Factory

package/src/deployment/operator.js

@@ -0,0 +1,85 @@
+'use strict'
+
+const { directory } = require('@toa.io/filesystem')
+
+/**
+ * @implements {toa.deployment.Operator}
+ */
+class Operator {
+  /** @type {toa.deployment.Deployment} */
+  #deployment
+  /** @type {toa.deployment.images.Registry} */
+  #registry
+
+  /**
+   * @param deployment {toa.deployment.Deployment}
+   * @param registry {toa.deployment.images.Registry}
+   */
+  constructor (deployment, registry) {
+    this.#deployment = deployment
+    this.#registry = registry
+  }
+
+  async export (path) {
+    const target = await Operator.#target('deployment', path)
+
+    await this.#deployment.export(target)
+
+    return target
+  }
+
+  async prepare (path) {
+    const target = await Operator.#target('images', path)
+
+    await this.#registry.prepare(target)
+
+    return target
+  }
+
+  async build () {
+    const target = await Operator.#target('images')
+
+    await this.#registry.prepare(target)
+    await this.#registry.push()
+
+    await directory.remove(target)
+  }
+
+  async install (options = {}) {
+    options = Object.assign({}, OPTIONS, options)
+
+    const [source] = await Promise.all([this.export(), this.build()])
+
+    await this.#deployment.install(options)
+
+    await directory.remove(source)
+  }
+
+  async template (options = {}) {
+    const source = await this.export()
+    const output = await this.#deployment.template(options)
+
+    await directory.remove(source)
+
+    return output
+  }
+
+  /**
+   * @param type {string}
+   * @param [path] {string}
+   * @returns {Promise<string>}
+   */
+  static async #target (type, path) {
+    if (path === undefined) path = await directory.temp('toa-' + type)
+    else path = await directory.ensure(path)
+
+    return path
+  }
+}
+
+/** @type {toa.deployment.installation.Options} */
+const OPTIONS = {
+  wait: false
+}
+
+exports.Operator = Operator

package/src/deployment/service.js

@@ -0,0 +1,25 @@
+'use strict'
+
+// noinspection JSClosureCompilerSyntax
+/**
+ * @implements {toa.deployment.Service}
+ */
+class Service {
+  name
+  image
+  port
+  ingress
+
+  /**
+   * @param service {toa.deployment.dependency.Service}
+   * @param image {toa.deployment.images.Image}
+   */
+  constructor (service, image) {
+    this.name = service.group + '-' + service.name
+    this.port = service.port
+    this.image = image.reference
+    this.ingress = service.ingress
+  }
+}
+
+exports.Service = Service

package/src/index.js

@@ -1,7 +1,3 @@
 'use strict'
 
-const { Images } = require('./images')
-const { Deployment } = require('./deployment')
-
-exports.Images = Images
-exports.Deployment = Deployment
+exports.deployment = require('./deployment')

package/src/process.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const execa = require('execa')
+
+/**
+ * @implements {toa.operations.Process}
+ */
+class Process {
+  async execute (cmd, args, options = {}) {
+    /** @type {execa.ExecaReturnValue<import('stream').Stream>} */
+    const command = execa(cmd, args)
+
+    if (options.silently !== true) {
+      command.stdout.pipe(process.stdout)
+      command.stderr.pipe(process.stderr)
+    }
+
+    /** @type {execa.ExecaReturnValue<string>} */
+    const result = await command
+
+    return result.stdout
+  }
+}
+
+exports.Process = Process

package/test/deployment/deployment.fixtures.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const context = /** @type {toa.norm.Context} */ { name: generate() }
+const compositions = []
+const dependencies = []
+const process = /** @type {toa.operations.Process} */ { execute: jest.fn() }
+const options = /** @type {toa.deployment.installation.Options} */ {
+  namespace: generate(),
+  target: generate()
+}
+
+exports.context = context
+exports.compositions = compositions
+exports.dependencies = dependencies
+exports.process = process
+exports.options = options

package/test/deployment/deployment.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+const fixtures = require('./deployment.fixtures')
+const { Deployment } = require('../../src/deployment/deployment')
+
+/** @type {toa.deployment.Deployment} */
+let deployment
+/** @type {toa.deployment.installation.Options} */
+let options
+
+beforeEach(() => {
+  deployment = new Deployment(fixtures.context, fixtures.compositions, fixtures.dependencies, fixtures.process)
+  options = clone(fixtures.options)
+})
+
+it('should pass -n argument if options.namespace is set', async () => {
+  await deployment.install(options)
+
+  const call = fixtures.process.execute.mock.calls.find((call) => call[0] === 'helm' && call[1][0] === 'upgrade')
+
+  expect(call).toBeDefined()
+
+  const args = call[1]
+  const index = args.findIndex((value) => value === '-n')
+  const namespace = args[index + 1]
+
+  expect(index).not.toStrictEqual(-1)
+  expect(namespace).toStrictEqual(fixtures.options.namespace)
+})
+
+it('should forbid local deployment environment', () => {
+  const context = clone(fixtures.context)
+
+  context.environment = 'local'
+
+  const create = () => new Deployment(context, fixtures.compositions, fixtures.dependencies, fixtures.process)
+
+  expect(create).toThrow(/name 'local' is not allowed/)
+})

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

@@ -0,0 +1,33 @@
+'use strict'
+
+const { Image } = require('../../../src/deployment/images/image')
+const { generate } = require('randomstring')
+const { hash } = require('@toa.io/generic')
+
+const version = generate()
+const name = generate()
+
+/**
+ * @implements {toa.deployment.images.Image}
+ */
+class Class extends Image {
+  get name () {
+    return name
+  }
+
+  get version () {
+    return version
+  }
+}
+
+/** @type {toa.norm.context.Runtime} */
+const runtime = {
+  version: generate()
+}
+
+exports.scope = generate()
+exports.name = name
+exports.version = hash(runtime.version + ';' + version)
+exports.Class = Class
+exports.runtime = runtime
+exports.process = process

package/test/deployment/images/image.test.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const fixtures = require('./image.fixtures')
+const { generate } = require('randomstring')
+
+/** @type {toa.deployment.images.Image} */
+let instance
+
+beforeEach(() => {
+  instance = new fixtures.Class(fixtures.scope, fixtures.runtime)
+})
+
+it('should assign url', () => {
+  const registry = generate()
+
+  instance.tag(registry)
+
+  expect(instance.reference).toEqual(`${registry}/${fixtures.scope}/class-${fixtures.name}:${fixtures.version}`)
+})
+
+describe('prepare', () => {
+  it('should throw error if no dockerfile specified', async () => {
+    await expect(instance.prepare(generate())).rejects.toThrow(/Dockerfile isn't specified/)
+  })
+})

package/types/deployment/composition.d.ts

@@ -0,0 +1,13 @@
+// noinspection ES6UnusedImports
+
+import type { Deployable } from './deployment'
+
+declare namespace toa.deployment {
+
+    interface Composition extends Deployable {
+        components: Array<string>
+    }
+
+}
+
+export type Composition = toa.deployment.Composition

package/types/deployment/dependency.d.ts

@@ -0,0 +1,77 @@
+// noinspection JSUnusedGlobalSymbols,ES6UnusedImports
+
+import { Service } from './service'
+import { dependencies } from '@toa.io/norm/types/context'
+
+declare namespace toa.deployment {
+
+  namespace dependency {
+
+    type Constructor = (instances: dependencies.Instance[], annotation: any) => Declaration
+
+    type Reference = {
+      name: string
+      version: string
+      repository?: string
+      alias?: string
+      values?: Object
+    }
+
+    type Service = {
+      group: string
+      name: string
+      version: string
+      port: number
+      ingress?: {
+        host: string
+        class: string
+        annotations?: object
+      }
+    }
+
+    type Proxy = {
+      name: string
+      target: string
+    }
+
+    type Variable = {
+      name: string
+      value?: string | number
+      secret?: {
+        name: string,
+        key: string
+      }
+    }
+
+    type Variables = {
+      [key: string]: Variable[]
+    }
+
+    type Declaration = {
+      references?: Reference[]
+      services?: Service[] // dependency.Service
+      proxies?: Proxy[]
+      variables?: Variables
+    }
+
+  }
+
+  type Dependency = {
+    references?: dependency.Reference[]
+    services?: Service[] // deployment.Service
+    proxies?: dependency.Proxy[]
+    variables?: dependency.Variables
+  }
+
+}
+
+export namespace dependency {
+  export type Declaration = toa.deployment.dependency.Declaration
+  export type Reference = toa.deployment.dependency.Reference
+  export type Service = toa.deployment.dependency.Service
+  export type Proxy = toa.deployment.dependency.Proxy
+  export type Variables = toa.deployment.dependency.Variables
+  export type Variable = toa.deployment.dependency.Variable
+}
+
+export type Dependency = toa.deployment.Dependency