t2 run/push: insert os or firmware version request into pipeline

Signed-off-by: Rick Waldron <[email protected]>

Author: rwaldron

lib/tessel/deploy.js

@@ -118,7 +118,7 @@ Tessel.prototype.memoryInfo = function() {
  * @return {Promise}
  */
 Tessel.prototype.deploy = function(opts) {
-
+  /* istanbul ignore else */
   if (typeof opts.tessel === 'undefined') {
     opts.tessel = this;
   }
@@ -136,6 +136,7 @@ Tessel.prototype.deploy = function(opts) {
     return this.simpleExec(commands.app.stop())
       .catch(error => {
         // This _must_ be inline
+        /* istanbul ignore else */
         if (error.length > 0) {
           throw new Error(`Remote command: ${commands.app.stop().join(' ')} failed.`);
         }
@@ -217,6 +218,7 @@ Tessel.prototype.restart = function(opts) {
         }
       })
       .catch((error) => {
+        /* istanbul ignore else */
         if (error.message.includes('No such file or directory')) {
           error = `"${opts.entryPoint}" not found on ${this.name}`;
         }
@@ -256,11 +258,13 @@ exportables.findProject = function(opts) {
       // exist. The cost of the try/catch is negligible.
       isDirectory = fs.lstatSync(file).isDirectory();
     } catch (error) {
+      /* istanbul ignore else */
       if (opts.lang.meta.isFile) {
         reject(error.message);
       }
     }
 
+    /* istanbul ignore if */
     if (isDirectory && single) {
       return reject('You can only push a single file, not a directory');
     }
@@ -280,6 +284,7 @@ exportables.findProject = function(opts) {
         relpath = path.join(path.basename(pushdir), relpath);
         pushdir = path.dirname(pushdir);
 
+        /* istanbul ignore if */
         if (pushdir === undefined) {
           pushdir = '';
         }
@@ -351,6 +356,7 @@ exportables.sendBundle = function(tessel, opts) {
 
             // Calling receive to know when the process closes
             tessel.receive(remoteProcess, (err) => {
+              /* istanbul ignore if */
               if (err) {
                 return reject(err);
               } else {
@@ -389,6 +395,7 @@ exportables.run = function(tessel, options) {
         commands[lang.meta.extname].execute(Tessel.REMOTE_RUN_PATH, options.resolvedEntryPoint, options.subargs), {
           pty: true
         }, (error, remoteProcess) => {
+          /* istanbul ignore if */
           if (error) {
             return reject(error);
           }
@@ -413,6 +420,7 @@ exportables.run = function(tessel, options) {
 
 exportables.push = function(tessel, opts) {
   // Write the node start file
+  /* istanbul ignore if */
   if (opts.resolvedEntryPoint === undefined) {
     opts.resolvedEntryPoint = opts.entryPoint;
   }
@@ -431,16 +439,18 @@ exportables.push = function(tessel, opts) {
 exportables.createShellScript = function(tessel, opts) {
   return new Promise((resolve, reject) => {
     // Open a stdin pipe tp the file
-    tessel.connection.exec(commands.openStdinToFile(PUSH_START_SH_SCRIPT), (err, remoteProcess) => {
-      if (err) {
-        return reject(err);
+    tessel.connection.exec(commands.openStdinToFile(PUSH_START_SH_SCRIPT), (error, remoteProcess) => {
+      /* istanbul ignore if */
+      if (error) {
+        return reject(error);
       }
       // When the remote process finishes
       remoteProcess.once('close', () => {
         // Set the perimissions on the file to be executable
-        tessel.connection.exec(commands.chmod('+x', PUSH_START_SH_SCRIPT), (err, remoteProcess) => {
-          if (err) {
-            return reject(err);
+        tessel.connection.exec(commands.chmod('+x', PUSH_START_SH_SCRIPT), (error, remoteProcess) => {
+          /* istanbul ignore if */
+          if (error) {
+            return reject(error);
           }
           // When that process completes
           remoteProcess.once('close', () => {

lib/tessel/deployment/javascript.js

@@ -27,6 +27,7 @@ var log = require('../../log');
 var provision = require('../provision'); // jshint ignore:line
 var remote = require('../../remote');
 var Tessel = require('../tessel');
+var updates = require('../../update-fetch');
 
 var binaryModulesUsed = new Map();
 var isWindows = process.platform.startsWith('win');
@@ -210,6 +211,7 @@ exportables.resolveBinaryModules = function(opts) {
             // Unless there is a specific `binary.module_path`.
             // Checking this only matters when the glob patterns
             // didn't turn up a .node binary.
+            /* istanbul ignore if */
             if (packageJson.binary && packageJson.binary.module_path) {
               buildPath = path.normalize(packageJson.binary.module_path);
               if (buildPath[0] === '.') {
@@ -285,7 +287,8 @@ exportables.resolveBinaryModules = function(opts) {
               path: details.extractPath,
             });
 
-            gunzip.on('error', function(error) {
+            gunzip.on('error', (error) => {
+              /* istanbul ignore else */
               if (error.code === 'Z_DATA_ERROR') {
                 details.resolved = false;
 
@@ -406,11 +409,16 @@ exportables.injectBinaryModules = function(globRoot, tempBundlePath, options) {
 };
 
 exportables.preBundle = function(options) {
-  return options.tessel.fetchNodeProcessVersions()
-    .then(versions => {
-      options.tessel.versions = versions;
-      return exportables.resolveBinaryModules(options);
+  return Promise.all([
+    updates.requestBuildList(),
+    options.tessel.fetchCurrentBuildInfo(),
+    options.tessel.fetchNodeProcessVersions(),
+  ]).then(responses => {
+    options.tessel.versions = Object.assign(responses[2], {
+      build: updates.findBuild(responses[0], 'sha', responses[1]),
     });
+    return exportables.resolveBinaryModules(options);
+  });
 };
 
 exportables.tarBundle = function(options) {
@@ -797,6 +805,7 @@ exportables.compress = function(source, options) {
     ast.compute_char_frequency(mangle);
     ast.mangle_names(mangle);
 
+    /* istanbul ignore if */
     if (special.rescope_after_mangle) {
       ast.figure_out_scope(mangle);
     }
@@ -807,6 +816,7 @@ exportables.compress = function(source, options) {
 
     return stream.toString();
   } catch (error) {
+    /* istanbul ignore next */
     return source;
   }
 };

lib/tessel/update.js

@@ -21,10 +21,7 @@ var remoteVersioningFile = '/etc/tessel-version';
 Tessel.prototype.fetchCurrentBuildInfo = function() {
   // Read the version file
   return this.simpleExec(commands.readFile(remoteVersioningFile))
-    .then(function fileRead(fileContents) {
-      // Trim the file new line and return
-      return fileContents.trim();
-    });
+    .then(fileContents => fileContents.trim());
 };
 
 Tessel.prototype.update = function(opts, newImage) {

test/.jshintrc

@@ -98,6 +98,7 @@
     "tags": true,
     "tar": true,
     "Tessel": true,
+    "tesselBuilds": true,
     "TesselSeeker": true,
     "TesselSimulator": true,
     "toml": true,

test/common/bootstrap.js

@@ -208,3 +208,13 @@ global.processVersions = {
   modules: '46',
   openssl: '1.0.2d',
 };
+
+global.tesselBuilds = [{
+  released: '2016-09-21T19:40:32.992Z',
+  sha: '40b2b46a62a34b5a26170c75f7e717cea673d1eb',
+  version: '0.0.16'
+}, {
+  sha: '9a85c84f5a03c715908921baaaa9e7397985bc7f',
+  released: '2017-05-12T03:01:57.856Z',
+  version: '0.0.17'
+}];

test/unit/deploy.js

@@ -133,7 +133,9 @@ exports['Tessel.prototype.deploy'] = {
     this.tessel = TesselSimulator();
     this.end = sandbox.spy(this.tessel._rps.stdin, 'end');
 
+    this.fetchCurrentBuildInfo = sandbox.stub(this.tessel, 'fetchCurrentBuildInfo').returns(Promise.resolve('40b2b46a62a34b5a26170c75f7e717cea673d1eb'));
     this.fetchNodeProcessVersions = sandbox.stub(this.tessel, 'fetchNodeProcessVersions').returns(Promise.resolve(processVersions));
+    this.requestBuildList = sandbox.stub(updates, 'requestBuildList').returns(Promise.resolve(tesselBuilds));
 
     this.pWrite = sandbox.stub(Preferences, 'write').returns(Promise.resolve());
 

test/unit/deployment/javascript.js

@@ -38,7 +38,9 @@ exports['Deployment: JavaScript'] = {
     this.tessel = TesselSimulator();
     this.end = sandbox.spy(this.tessel._rps.stdin, 'end');
 
+    this.fetchCurrentBuildInfo = sandbox.stub(this.tessel, 'fetchCurrentBuildInfo').returns(Promise.resolve('40b2b46a62a34b5a26170c75f7e717cea673d1eb'));
     this.fetchNodeProcessVersions = sandbox.stub(this.tessel, 'fetchNodeProcessVersions').returns(Promise.resolve(processVersions));
+    this.requestBuildList = sandbox.stub(updates, 'requestBuildList').returns(Promise.resolve(tesselBuilds));
 
     this.pWrite = sandbox.stub(Preferences, 'write').returns(Promise.resolve());
 
@@ -1802,7 +1804,10 @@ exports['deploy.findProject'] = {
 exports['deploy.sendBundle, error handling'] = {
   setUp: function(done) {
     this.tessel = TesselSimulator();
+    this.fetchCurrentBuildInfo = sandbox.stub(this.tessel, 'fetchCurrentBuildInfo').returns(Promise.resolve('40b2b46a62a34b5a26170c75f7e717cea673d1eb'));
     this.fetchNodeProcessVersions = sandbox.stub(this.tessel, 'fetchNodeProcessVersions').returns(Promise.resolve(processVersions));
+    this.requestBuildList = sandbox.stub(updates, 'requestBuildList').returns(Promise.resolve(tesselBuilds));
+
 
     this.pathResolve = sandbox.stub(path, 'resolve');
     this.failure = 'FAIL';
@@ -1882,7 +1887,10 @@ exports['deployment.js.preBundle'] = {
       callback();
     });
 
+    this.fetchCurrentBuildInfo = sandbox.stub(this.tessel, 'fetchCurrentBuildInfo').returns(Promise.resolve('40b2b46a62a34b5a26170c75f7e717cea673d1eb'));
     this.fetchNodeProcessVersions = sandbox.stub(this.tessel, 'fetchNodeProcessVersions').returns(Promise.resolve(processVersions));
+    this.requestBuildList = sandbox.stub(updates, 'requestBuildList').returns(Promise.resolve(tesselBuilds));
+
 
     this.findProject = sandbox.stub(deploy, 'findProject').returns(Promise.resolve({
       pushdir: '',
@@ -1916,6 +1924,44 @@ exports['deployment.js.preBundle'] = {
     });
   },
 
+  preBundleCallsfetchCurrentBuildInfoAndForwardsResult(test) {
+    test.expect(4);
+
+    deploy.sendBundle(this.tessel, {
+      target: '/',
+      entryPoint: 'foo.js',
+      lang: deployment.js
+    }).then(() => {
+      test.equal(this.fetchCurrentBuildInfo.callCount, 1);
+      test.equal(this.resolveBinaryModules.callCount, 1);
+
+      var args = this.resolveBinaryModules.lastCall.args[0];
+
+      test.equal(args.tessel, this.tessel);
+      test.equal(args.tessel.versions, processVersions);
+      test.done();
+    });
+  },
+
+  preBundleCallsrequestBuildListAndForwardsResult(test) {
+    test.expect(4);
+
+    deploy.sendBundle(this.tessel, {
+      target: '/',
+      entryPoint: 'foo.js',
+      lang: deployment.js
+    }).then(() => {
+      test.equal(this.requestBuildList.callCount, 1);
+      test.equal(this.resolveBinaryModules.callCount, 1);
+
+      var args = this.resolveBinaryModules.lastCall.args[0];
+
+      test.equal(args.tessel, this.tessel);
+      test.equal(args.tessel.versions, processVersions);
+      test.done();
+    });
+  },
+
   preBundleCallsfetchNodeProcessVersionsAndForwardsResult(test) {
     test.expect(4);
 
@@ -2364,6 +2410,80 @@ exports['deployment.js.resolveBinaryModules'] = {
       test.done();
     });
   },
+
+  requestsRemoteGunzipErrors: function(test) {
+    test.expect(9);
+
+    this.removeSync = sandbox.stub(fs, 'removeSync');
+    this.exists = sandbox.stub(fs, 'existsSync', () => false);
+    this.mkdirp = sandbox.stub(fs, 'mkdirp', (dir, handler) => {
+      handler();
+    });
+
+    this.transform = new Transform();
+    this.transform.stubsUsed = [];
+    this.rstream = null;
+
+    this.pipe = sandbox.stub(stream.Stream.prototype, 'pipe', () => {
+      // After the second transform is piped, emit the end
+      // event on the request stream;
+      if (this.pipe.callCount === 2) {
+        process.nextTick(() => this.rstream.emit('end'));
+      }
+      return this.rstream;
+    });
+
+    this.createGunzip = sandbox.stub(zlib, 'createGunzip', () => {
+      this.transform.stubsUsed.push('createGunzip');
+      return this.transform;
+    });
+
+    this.Extract = sandbox.stub(tar, 'Extract', () => {
+      this.transform.stubsUsed.push('Extract');
+      return this.transform;
+    });
+
+    this.request = sandbox.stub(request, 'Request', (opts) => {
+      this.rstream = new Request(opts);
+      return this.rstream;
+    });
+
+    // Hook into the ifReachable call to trigger an error at the gunzip stream
+    this.ifReachable.restore();
+    this.ifReachable = sandbox.stub(remote, 'ifReachable', () => {
+      this.transform.emit('error', {
+        code: 'Z_DATA_ERROR',
+      });
+      return Promise.resolve();
+    });
+
+    deployment.js.resolveBinaryModules({
+      target: this.target,
+      tessel: {
+        versions: {
+          modules: 46
+        },
+      },
+    }).then(() => {
+      test.equal(this.globFiles.callCount, 1);
+      test.equal(this.exists.callCount, 1);
+      test.equal(this.mkdirp.callCount, 1);
+      test.equal(this.mkdirp.lastCall.args[0].endsWith(path.normalize('.tessel/binaries/release-1.1.1-Release-node-v46-linux-mipsel')), true);
+
+      // The result of gunzip emitting an error:
+      test.equal(this.removeSync.callCount, 1);
+      test.equal(this.removeSync.lastCall.args[0].endsWith(path.normalize('.tessel/binaries/release-1.1.1-Release-node-v46-linux-mipsel')), true);
+
+      test.equal(this.request.callCount, 1);
+      test.equal(this.createGunzip.callCount, 1);
+      test.deepEqual(this.transform.stubsUsed, ['createGunzip', 'Extract']);
+
+      test.done();
+    }).catch(error => {
+      test.ok(false, error.toString());
+      test.done();
+    });
+  },
 };
 
 exports['deployment.js.injectBinaryModules'] = {