sailkick-boat 0.22.0 → 0.22.2

package/lib/cloud/index.js

@@ -80,29 +80,52 @@ function createCloud (app, options = {}) {
     return null
   }
 
+  // Node wraps every transport failure as the useless message "fetch failed" and hides
+  // the real reason in e.cause — ENOTFOUND, ECONNRESET, ETIMEDOUT and a TLS failure are
+  // very different problems and want different fixes, so say which.
+  const why = (e) => {
+    const c = e && e.cause
+    const code = c && (c.code || c.message)
+    return code ? `${e.message}: ${code}` : (e ? e.message : 'unknown')
+  }
+
+  // Retry TRANSPORT failures only — never an HTTP status, so a 401 stays a 401. This
+  // boat's link drops for a second or two at a time (live sync recovers after a single
+  // attempt), and a button that dead-ends on the first blip is needlessly fragile.
+  async function attempt (fn, tries = 3) {
+    let last
+    for (let i = 0; i < tries; i++) {
+      try { return { ok: true, value: await fn() } } catch (e) {
+        last = e
+        if (i < tries - 1) await new Promise((resolve) => setTimeout(resolve, 400 * Math.pow(3, i)))
+      }
+    }
+    return { ok: false, error: last }
+  }
+
   async function login (slug, password) {
     if (!upstream) return { ok: false, code: 'no-upstream', message: 'no cloud host configured' }
-    let r
-    try {
-      r = await fetch(`${upstream}/api/auth/login`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ slug, password }),
-        signal: AbortSignal.timeout(timeoutMs)
-      })
-    } catch (e) {
-      return { ok: false, code: 'offline', message: `cannot reach ${upstream} (${e.message})` }
+    const got = await attempt(() => fetch(`${upstream}/api/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ slug, password }),
+      signal: AbortSignal.timeout(timeoutMs)
+    }))
+    if (!got.ok) {
+      warn(`login could not reach ${upstream} after 3 attempts — ${why(got.error)}`)
+      return { ok: false, code: 'offline', message: `cannot reach ${upstream} — ${why(got.error)}. The boat's link may have dropped; try again.` }
     }
+    const r = got.value
     if (r.status === 401) return { ok: false, code: 'bad-credentials', message: 'wrong boat name or password' }
     if (!r.ok) return { ok: false, code: 'login-failed', message: `the cloud replied HTTP ${r.status}` }
-    const got = readCookie(r.headers)
-    if (!got) return { ok: false, code: 'no-session', message: 'the cloud accepted the login but sent no session' }
+    const cookie = readCookie(r.headers)
+    if (!cookie) return { ok: false, code: 'no-session', message: 'the cloud accepted the login but sent no session' }
 
     let name = slug
     try { const j = await r.json(); name = (j && j.boat && (j.boat.slug || j.boat.name)) || slug } catch {}
-    session = { cookie: got.cookie, slug: name, expiresAt: got.expiresAt }
+    session = { cookie: cookie.cookie, slug: name, expiresAt: cookie.expiresAt }
     await persist()
-    log(`logged in to ${upstream} as ${name}${got.expiresAt ? `; session valid until ${new Date(got.expiresAt).toISOString().slice(0, 10)}` : ''}`)
+    log(`logged in to ${upstream} as ${name}${cookie.expiresAt ? `; session valid until ${new Date(cookie.expiresAt).toISOString().slice(0, 10)}` : ''}`)
     return { ok: true, ...status() }
   }
 
@@ -128,21 +151,20 @@ function createCloud (app, options = {}) {
   // handler and a boat is offline most of the time.
   async function request (apiPath, { method = 'GET', body = null } = {}) {
     if (!session) return { ok: false, status: 401, code: 'logged-out', message: 'not logged in to the cloud' }
-    let r
-    try {
-      r = await fetch(upstream + apiPath, {
-        method,
-        headers: {
-          Cookie: session.cookie,
-          Accept: 'application/json',
-          ...(body ? { 'Content-Type': 'application/json' } : {})
-        },
-        body: body || undefined,
-        signal: AbortSignal.timeout(timeoutMs)
-      })
-    } catch (e) {
-      return { ok: false, status: 0, code: 'offline', message: `cannot reach the cloud (${e.message})` }
+    const got = await attempt(() => fetch(upstream + apiPath, {
+      method,
+      headers: {
+        Cookie: session.cookie,
+        Accept: 'application/json',
+        ...(body ? { 'Content-Type': 'application/json' } : {})
+      },
+      body: body || undefined,
+      signal: AbortSignal.timeout(timeoutMs)
+    }))
+    if (!got.ok) {
+      return { ok: false, status: 0, code: 'offline', message: `cannot reach the cloud — ${why(got.error)}. The boat's link may have dropped; try again.` }
     }
+    const r = got.value
     // A 401 means the session died (expired, or revoked by a logout elsewhere). Clear it
     // so the page shows a login form instead of silently failing every button.
     if (r.status === 401) {
@@ -164,7 +186,23 @@ function createCloud (app, options = {}) {
     res.end(JSON.stringify(obj))
   }
 
+  // Signal K mounts plugin routers AFTER its own bodyParser.json(), so on that path the
+  // body is already parsed and the request stream is spent — listening for 'data'/'end'
+  // waits for events that will never fire, and the request hangs for ever with no error.
+  // (That is exactly what happened: the Sync page sat on "Signing in…".) On the mirror
+  // there is no body parser and the stream is live, so both paths must be handled.
   function readJson (req) {
+    if (req.body !== undefined && req.body !== null) {
+      if (typeof req.body === 'string') {
+        if (!req.body.trim()) return Promise.resolve(null)
+        try { return Promise.resolve(JSON.parse(req.body)) } catch { return Promise.resolve(undefined) }
+      }
+      if (typeof req.body === 'object') {
+        // bodyParser.json() gives {} for an absent body; treat that as "nothing sent".
+        return Promise.resolve(Object.keys(req.body).length || Array.isArray(req.body) ? req.body : null)
+      }
+    }
+    if (req.readableEnded || req.complete) return Promise.resolve(null) // stream already drained
     return new Promise((resolve) => {
       let size = 0
       const chunks = []

package/lib/profile/index.js

@@ -84,16 +84,32 @@ function createProfile (app, options = {}) {
   const badBody = (res, what) => send(res, 400, { ok: false, code: 'bad-body', message: `${what} must be a JSON object` })
   const failed = (res, e) => { lastError = e.message; warn(e.message); send(res, 500, { ok: false, code: 'profile-error', message: e.message }) }
 
+  // Signal K mounts plugin routers AFTER its own bodyParser.json(), so on that path the
+  // body is already parsed and the request stream is spent — listening for 'data'/'end'
+  // waits for events that will never fire, and the request hangs for ever with no error.
+  // (That is exactly what happened: the Sync page sat on "Signing in…".) On the mirror
+  // there is no body parser and the stream is live, so both paths must be handled.
   function readJson (req) {
-    return new Promise((resolve, reject) => {
+    if (req.body !== undefined && req.body !== null) {
+      if (typeof req.body === 'string') {
+        if (!req.body.trim()) return Promise.resolve(null)
+        try { return Promise.resolve(JSON.parse(req.body)) } catch { return Promise.resolve(undefined) }
+      }
+      if (typeof req.body === 'object') {
+        // bodyParser.json() gives {} for an absent body; treat that as "nothing sent".
+        return Promise.resolve(Object.keys(req.body).length || Array.isArray(req.body) ? req.body : null)
+      }
+    }
+    if (req.readableEnded || req.complete) return Promise.resolve(null) // stream already drained
+    return new Promise((resolve) => {
       let size = 0
       const chunks = []
       req.on('data', (c) => {
         size += c.length
-        if (size > MAX_BODY_BYTES) { reject(new Error('body too large')); req.destroy(); return }
+        if (size > MAX_BODY_BYTES) { req.destroy(); resolve(undefined); return }
         chunks.push(c)
       })
-      req.on('error', reject)
+      req.on('error', () => resolve(undefined))
       req.on('end', () => {
         const raw = Buffer.concat(chunks).toString('utf8')
         if (!raw.trim()) return resolve(null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sailkick-boat",
-  "version": "0.22.0",
+  "version": "0.22.2",
   "description": "Run the sailkick app on board with no internet: charts, weather, climatology, trends and AIS all served from the boat itself. With a sailkick account it also syncs your metrics to the cloud in real time. Alpha, invite-only \u2014 info@sailkick.io",
   "main": "index.js",
   "scripts": {