presidium 0.17.0 → 0.18.0

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/package.json

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