presidium 0.16.28 → 0.18.0

package/DockerService.js

@@ -107,35 +107,39 @@ const DockerService = function (options) {
   if (this == null || this.constructor != DockerService) {
     return new DockerService(options)
   }
+  this.serviceOptions = pick(dockerServiceOptions)(options)
   this.name = options.name
   this.docker = new Docker()
   this.version = null
   this.spec = null
   this.replicas = options.replicas
-
-  this.ready = this.docker.inspectService(this.name).then(pipe([
-    switchCase([
-      eq(404, get('status')),
-      pipe([
-        () => this.docker.createService(
-          this.name,
-          pick(dockerServiceOptions)(options)),
-        tap(async response => {
-          if (!response.ok) {
-            throw new Error(await response.text())
-          }
-        }),
-      ]),
-      pipe([
-        tap(() => this.synchronize()),
-        () => this.update(pick(dockerServiceOptions)(options)),
-      ]),
-    ]),
-    tap(() => this.synchronize()),
-  ]))
   return this
 }
 
+/**
+ * @name DockerService.prototype.deploy
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * DockerService(...).deploy()
+ * ```
+ */
+DockerService.prototype.deploy = async function deploy() {
+  const { status } = await this.docker.inspectService(this.name)
+
+  if (status == 404) {
+    const { name, serviceOptions } = this
+    const response = await this.docker.createService(name, serviceOptions)
+    if (!response.ok) {
+      throw new Error(await response.text())
+    }
+  } else {
+    await this.synchronize()
+    await this.update(this.serviceOptions)
+  }
+  await this.synchronize()
+}
+
 // new DockerService().synchronize() -> Promise<>
 DockerService.prototype.synchronize = function dockerServiceSynchronize() {
   return this.docker.inspectService(this.name).then(pipe([

package/DockerService.test.js

@@ -21,6 +21,8 @@ const test = new Test('DockerService', DockerService)
   image: 'nginx:1.19',
   replicas: 1,
 }, async function (myService) {
+  await myService.deploy()
+
   {
     const info = await myService.inspect()
     this.serviceId = info.ID
@@ -106,7 +108,7 @@ const test = new Test('DockerService', DockerService)
   image: 'nginx:1.19',
   replicas: 2,
 }, async function (myService) {
-  await myService.ready
+  await myService.deploy()
   // TODO test for update on construction assert.deepEqual(myService.spec, this.myServiceSpec)
 })
 
@@ -116,8 +118,8 @@ const test = new Test('DockerService', DockerService)
   replicas: 2,
   restart: 'always', // coulda fooled me
 }, async function (errorService) {
-  assert.rejects(
-    always(errorService.ready),
+  await assert.rejects(
+    errorService.deploy(),
     new Error('{"message":"invalid RestartCondition: \\"always\\""}\n'))
 })
 

package/DockerSwarm.js

@@ -1,81 +1,63 @@
-const assert = require('assert')
-const rubico = require('rubico')
+require('rubico/global')
 const Docker = require('./Docker')
 
-const {
-  pipe, tap,
-  switchCase, tryCatch,
-  fork, assign, get, pick, omit,
-  map, filter, reduce, transform, flatMap,
-  and, or, not, any, all,
-  eq, gt, lt, gte, lte,
-  thunkify, always,
-  curry, __,
-} = rubico
-
 /**
  * @name DockerSwarm
  *
  * @synopsis
  * ```coffeescript [specscript]
- * new DockerSwarm(
- *   advertiseAddr string, // url advertised to other nodes, e.g. 'eth0:2377'
- *   options {
- *     joinToken: string, // worker or manager join token
- *     remoteAddrs: Array<string>, // urls of manager nodes already participating in the swarm
- *   },
- * ) -> DockerSwarm
+ * new DockerSwarm(advertiseAddr string) -> DockerSwarm
  * ```
+ *
+ * @description
+ * DockerSwarm interface
+ *
+ * ## Resources
+ * https://boxboat.com/2016/08/17/whats-docker-swarm-advertise-addr/
  */
-const DockerSwarm = function (advertiseAddr, options = {}) {
-  if (this == null || this.constructor != DockerSwarm) {
-    return new DockerSwarm(advertiseAddr, options)
-  }
+const DockerSwarm = function (advertiseAddr) {
+  this.advertiseAddr = advertiseAddr
   this.docker = new Docker()
-  this.ready = this.docker.inspectSwarm().then(switchCase([
-    or([
-      eq(404, get('status')),
-      eq(503, get('status')),
-    ]),
-    options.joinToken == null ? async () => {
-      await this.docker.initSwarm(advertiseAddr)
-      await this.synchronize()
-    } : async () => {
-      const response = await this.docker.joinSwarm(advertiseAddr, options.joinToken, {
-        remoteAddrs: options.remoteAddrs,
-      })
-      if (!response.ok) {
-        throw new Error(await response.text())
-      }
-    },
-    async response => {
-      const data = await response.json()
-      this.version = data.Version.Index
-      this.spec = data.Spec
-      this.swarmData = data
-    },
-  ]))
-  this.version = null
-  this.spec = null
-  this.swarmData = null
   return this
 }
 
-// new DockerSwarm().synchronize() -> Promise<>
-DockerSwarm.prototype.synchronize = function dockerServiceSynchronize() {
-  return this.docker.inspectSwarm().then(pipe([
-    tap(async response => {
-      if (!response.ok) {
-        throw new Error(await response.text())
-      }
-    }),
-    response => response.json(),
-    data => {
-      this.version = data.Version.Index
-      this.spec = data.Spec
-      this.swarmData = data
-    },
-  ]))
+/**
+ * @name DockerSwarm.prototype.init
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new DockerSwarm(...).init() -> Promise<>
+ * ```
+ */
+DockerSwarm.prototype.init = async function init() {
+  await this.docker.initSwarm(this.advertiseAddr).then(async response => {
+    if (!response.ok) {
+      throw new Error(await response.text())
+    }
+  })
+}
+
+/**
+ * @name DockerSwarm.prototype.join
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new DockerSwarm(...).join(options {
+ *   joinToken: string, // worker or manager join token
+ *   remoteAddrs: Array<string>, // urls of manager nodes already participating in the swarm
+ * }) -> Promise<>
+ * ```
+ */
+
+DockerSwarm.prototype.join = async function join(options) {
+  const { joinToken, remoteAddrs } = options
+  await this.docker.joinSwarm(this.advertiseAddr, joinToken, {
+    remoteAddrs,
+  }).then(async response => {
+    if (!response.ok) {
+      throw new Error(await response.text())
+    }
+  })
 }
 
 // DockerSwarm(address).inspect() -> Promise<Object>
@@ -113,19 +95,15 @@ DockerSwarm.prototype.leave = function dockerSwarmLeave(options) {
  * @description
  * https://docs.docker.com/engine/api/v1.40/#operation/SwarmUpdate
  * https://docs.docker.com/engine/reference/commandline/swarm_update/
- */
+ *
+ * @deprecated
 DockerSwarm.prototype.update = async function dockerSwarmUpdate(options) {
   await this.ready
   return this.docker.updateSwarm({
     version: this.version,
     spec: this.spec,
     ...options,
-  }).then(pipe.sync([
-    tap.sync(() => {
-      this.ready = this.synchronize()
-    }),
-    always(this.spec),
-  ]))
-}
+  })
+} */
 
 module.exports = DockerSwarm

package/DockerSwarm.test.js

@@ -4,59 +4,27 @@ const Docker = require('./Docker')
 const DockerSwarm = require('./DockerSwarm')
 const inspect = require('util').inspect
 
-module.exports = Test('DockerSwarm', DockerSwarm)
-  .before(async function () {
-    this.docker = new Docker()
-    await this.docker.leaveSwarm({ force: true })
-  })
-  .case('[::1]:2377', async function (localSwarm) {
-    assert(localSwarm.spec == null)
-    assert(localSwarm.version == null)
-    await localSwarm.ready
-    assert(localSwarm.spec != null)
-    assert(localSwarm.version != null)
+const test = Test('DockerSwarm', async function () {
+  this.docker = new Docker()
+  await this.docker.leaveSwarm({ force: true })
 
-    {
-      const prevTokens = (await localSwarm.inspect()).JoinTokens
-      const result = await localSwarm.update({
-        rotateWorkerToken: true,
-        rotateManagerToken: true,
-        rotateManagerUnlockKey: true,
-        autolock: true,
-      })
+  const advertiseAddr = '[::1]:2377'
+  const localSwarm = new DockerSwarm(advertiseAddr)
 
-      assert.strictEqual(localSwarm.spec.EncryptionConfig.AutoLockManagers, false)
-      await localSwarm.ready
-      assert.strictEqual(localSwarm.spec.EncryptionConfig.AutoLockManagers, true)
-      const newTokens = (await localSwarm.inspect()).JoinTokens
-      assert(prevTokens.Worker != newTokens.Worker)
-      assert(prevTokens.Manager != newTokens.Manager)
-    }
+  console.log('initializing swarm')
+  await localSwarm.init()
 
-    {
-      const result = await localSwarm.update({
-        snapshotInterval: 20000,
-        keepOldSnapshots: 3,
-        logEntriesForSlowFollowers: 1000,
-        electionTick: 20,
-        heartbeatTick: 2,
-      })
+  await localSwarm.inspect().then(console.log)
 
-      assert.strictEqual(localSwarm.spec.Raft.SnapshotInterval, 10000)
-      assert.strictEqual(localSwarm.spec.Raft.KeepOldSnapshots, 0)
-      assert.strictEqual(localSwarm.spec.Raft.LogEntriesForSlowFollowers, 500)
-      assert.strictEqual(localSwarm.spec.Raft.ElectionTick, 10)
-      assert.strictEqual(localSwarm.spec.Raft.HeartbeatTick, 1)
-      await localSwarm.ready
-      assert.strictEqual(localSwarm.spec.Raft.SnapshotInterval, 20000)
-      assert.strictEqual(localSwarm.spec.Raft.KeepOldSnapshots, 3)
-      assert.strictEqual(localSwarm.spec.Raft.LogEntriesForSlowFollowers, 1000)
-      assert.strictEqual(localSwarm.spec.Raft.ElectionTick, 20)
-      assert.strictEqual(localSwarm.spec.Raft.HeartbeatTick, 2)
-    }
+  {
+    console.log('leaving swarm')
+    const result = await localSwarm.leave({ force: true })
+    assert.deepEqual(result, { message: '' })
+  }
+}).case()
 
-    {
-      const result = await localSwarm.leave({ force: true })
-      assert.deepEqual(result, { message: '' })
-    }
-  })
+if (process.argv[1] == __filename) {
+  test()
+}
+
+module.exports = test

package/Password.test.js

@@ -5,6 +5,10 @@ const Password = require('./Password')
 const test = new Test('Password', async function () {
   const plaintext = 'MyPassword!123'
   const hashed = await Password.hash(plaintext)
+  await assert.rejects(
+    Password.verify('incorrect', hashed),
+    new Error('Invalid password'),
+  )
   await Password.verify(plaintext, hashed) // should not throw
 }).case()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "presidium",
-  "version": "0.16.28",
+  "version": "0.18.0",
   "description": "A library for creating web services",
   "author": "Richard Tong",
   "license": "MIT",