Feature/sc 123873/check hash

src/cmd/binary.js

@@ -41,8 +41,9 @@ class BinaryCommand {
 	async inspectBinary(file) {
 		await this._checkFile(file);
 		const extractedFiles = await this._extractFiles(file);
-		const parsedBinaryInfo = await this._parseApplicationBinary(extractedFiles.application);
-		await this._verifyBundle(parsedBinaryInfo, extractedFiles.assets);
+		const parsedAppInfo = await this._parseApplicationBinary(extractedFiles.application);
+		const assets = extractedFiles.assets;
+		await this._verifyBundle(parsedAppInfo, assets);
 	}
 
 	async _checkFile(file) {
@@ -85,21 +86,23 @@ class BinaryCommand {
 		return fileInfo;
 	}
 
-	async _verifyBundle(binaryFileInfo, assets) {
-		if (binaryFileInfo.assets && assets.length){
+	async _verifyBundle(appInfo, assets) {
+		const appAssets = appInfo.assets;
+		if (appAssets && assets.length > 0) {
 			console.log('It depends on assets:');
-			for (const assetInfo of binaryFileInfo.assets) {
-				const asset = assets.find((asset) => asset.name === assetInfo.name);
+			for (const appAsset of appAssets) {
+				const asset = assets.find((bundleAsset) => bundleAsset.name === appAsset.name);
 				if (asset) {
-					const valid = isAssetValid(asset.data, assetInfo);
+					const valid = isAssetValid(asset.data, appAsset);
+					// isAssetValid();
 
 					if (valid) {
-						console.log(' ' + chalk.bold(assetInfo.name) + ' (hash ' + assetInfo.hash + ')');
+						console.log(' ' + chalk.bold(appAsset.name) + ' (hash ' + appAsset.hash + ')');
 					} else {
-						console.log(chalk.red(' ' + assetInfo.name + ' failed' + ' (hash should be ' + assetInfo.hash + ')'));
+						console.log(chalk.red(' ' + appAsset.name + ' failed' + ' (hash should be ' + appAsset.hash + ')'));
 					}
 				} else {
-					console.log(chalk.red(' ' + assetInfo.name + ' failed' + ' (hash should be ' + assetInfo.hash + ' but is not in the bundle)'));
+					console.log(chalk.red(' ' + appAsset.name + ' failed' + ' (hash should be ' + appAsset.hash + ' but is not in the bundle)'));
 				}
 			}
 		}

src/cmd/flash.js

@@ -1,7 +1,7 @@
 const fs = require('fs-extra');
 const os = require('os');
 const ParticleApi = require('./api');
-const { ModuleInfo } = require('binary-version-reader');
+const { ModuleInfo, unwrapAssetModule } = require('binary-version-reader');
 const { errors: { usageError } } = require('../app/command-processor');
 const usbUtils = require('./usb-util');
 const CLICommandBase = require('./base');
@@ -16,6 +16,7 @@ const { knownAppNames, knownAppsForPlatform } = require('../lib/known-apps');
 const { sourcePatterns, binaryPatterns, binaryExtensions } = require('../lib/file-types');
 const deviceOsUtils = require('../lib/device-os-version-util');
 const semver = require('semver');
+const crypto = require('crypto');
 const {
 	createFlashSteps,
 	filterModulesToFlash,
@@ -125,40 +126,82 @@ module.exports = class FlashCommand extends CLICommandBase {
 		const { api, auth } = this._particleApi();
 		const device = await usbUtils.getOneUsbDevice({ idOrName: deviceIdOrName, api, auth, ui: this.ui });
 
-		const platformName = platformForId(device.platformId).name;
+		const platformId = device.platformId;
+		const platformName = platformForId(platformId).name;
+		const currentDeviceOsVersion = device.firmwareVersion;
 
 		this.ui.write(`Flashing ${platformName} ${deviceIdOrName || device.id}`);
+
 		validateDFUSupport({ device, ui: this.ui });
 
 		let { skipDeviceOSFlash, files: filesToFlash } = await this._prepareFilesToFlash({
 			knownApp,
 			parsedFiles,
-			platformId: device.platformId,
+			platformId,
 			platformName,
 			target
 		});
 
 		filesToFlash = await this._processBundle({ filesToFlash });
 
 		const fileModules = await parseModulesToFlash({ files: filesToFlash });
-		await this._validateModulesForPlatform({ modules: fileModules, platformId: device.platformId, platformName });
+
+		const eligibleModules = await this._filterAssetsOnDevice(device, fileModules);
+
+		await this._validateModulesForPlatform({ modules: eligibleModules, platformId, platformName });
 
 		const deviceOsBinaries = await this._getDeviceOsBinaries({
-			currentDeviceOsVersion: device.firmwareVersion,
+			currentDeviceOsVersion,
 			skipDeviceOSFlash,
 			target,
-			modules: fileModules,
-			platformId: device.platformId,
+			modules: eligibleModules,
+			platformId,
 			applicationOnly
 		});
 		const deviceOsModules = await parseModulesToFlash({ files: deviceOsBinaries });
-		let modulesToFlash = [...fileModules, ...deviceOsModules];
-		modulesToFlash = filterModulesToFlash({ modules: modulesToFlash, platformId: device.platformId });
+		let modulesToFlash = [...eligibleModules, ...deviceOsModules];
+		modulesToFlash = filterModulesToFlash({ modules: modulesToFlash, platformId });
+
+		const flashSteps = await createFlashSteps({
+			modules: modulesToFlash,
+			isInDfuMode: device.isInDfuMode,
+			platformId
+		});
 
-		const flashSteps = await createFlashSteps({ modules: modulesToFlash, isInDfuMode: device.isInDfuMode , platformId: device.platformId });
 		await flashFiles({ device, flashSteps, ui: this.ui });
 	}
 
+	async _filterAssetsOnDevice(device, modules) {
+		if (device.isInDfuMode) {
+			device = await usbUtils.reopenInNormalMode(device, { reset: true });
+		}
+		const { available } = await device.getAssetInfo();
+
+		const filteredModules = await Promise.all(
+			modules.map(async (module) => {
+				if (module.prefixInfo.moduleFunction !== ModuleInfo.FunctionType.ASSET) {
+					return module; // Keep non-asset modules
+				}
+
+				const hashAssetToBeFlashed = await this._get256Hash(module);
+				if (available.some((asset) => {
+					return hashAssetToBeFlashed === asset.hash;
+				})) {
+					this.ui.write(`Skipping asset ${path.basename(module.filename)} because it is already on the device`);
+					return null;
+				}
+				return module;
+			})
+		);
+		return filteredModules.filter(Boolean); // Remove null values
+	}
+
+	async _get256Hash(module) {
+		if (module && module.fileBuffer) {
+			const assetModule = await unwrapAssetModule(module.fileBuffer);
+			return crypto.createHash('sha256').update(assetModule).digest('hex');
+		}
+	}
 
 	async _analyzeFiles(files) {
 		const apps = knownAppNames();

src/cmd/flash.test.js

@@ -1,5 +1,5 @@
 const { expect, sinon } = require('../../test/setup');
-const fs = require('fs-extra'); // Use fs-extra instead of fs
+const fs = require('fs-extra');
 const nock = require('nock');
 const temp = require('temp').track();
 const path = require('path');
@@ -8,6 +8,7 @@ const BundleCommand = require('./bundle');
 const { PATH_TMP_DIR } = require('../../test/lib/env');
 const deviceOsUtils = require('../lib/device-os-version-util');
 const { firmwareTestHelper, createAssetModule, ModuleInfo, HalModuleParser } = require('binary-version-reader');
+const usbUtils = require('./usb-util');
 
 describe('FlashCommand', () => {
 	let flash;
@@ -418,4 +419,89 @@ describe('FlashCommand', () => {
 			expect(binaries).to.eql([]);
 		});
 	});
+
+	describe('_filterAssetsOnDevice and returns eligible modules to be flashed',() => {
+		let fwModules;
+		let assetModules;
+		beforeEach(async () => {
+			fwModules = await createModules();
+			assetModules = await createAssetModules();
+		});
+
+		it('returns all firmware modules', async () => {
+			const device = {
+				isInDfuMode: false,
+				getAssetInfo: sinon.stub().resolves({ available: [] }),
+			};
+
+			const eligibleModules = await flash._filterAssetsOnDevice(device, fwModules);
+
+			expect(eligibleModules).to.eql(fwModules);
+		});
+
+		it('returns all firmware and asset modules', async () => {
+			const device = {
+				isInDfuMode: false,
+				getAssetInfo: sinon.stub().resolves({ available: [] }),
+			};
+			const modules = [...fwModules, ...assetModules];
+
+			const eligibleModules = await flash._filterAssetsOnDevice(device, modules);
+
+			expect(eligibleModules).to.eql(modules);
+		});
+
+		it('returns all firmware modules and the assets which are not on the device', async () => {
+			const hash = [
+				'9e3dd2ea9ff3da70862a52621f7c1dc81c2b184cb886a324a3f430ec11efd3f2',
+				'8e3dd2ea9ff3da70862a52621f7c1dc81c2b184cb886a324a3f430ec11efd3f2'
+			];
+			const device = {
+				isInDfuMode: false,
+				getAssetInfo: sinon.stub().resolves({
+					available: [
+						{ name: 'asset1.bin', hash: hash[0], size: 16, storageSize: 8 }
+					]
+				})
+			};
+			const modules = [...fwModules, ...assetModules];
+			const expectedModules = [...fwModules, assetModules[1]];
+			sinon.stub(flash, '_get256Hash').callsFake(() => {
+				const callCnt = flash._get256Hash.callCount;
+				return Promise.resolve(hash[callCnt - 1]);
+			});
+
+			const eligibleModules = await flash._filterAssetsOnDevice(device, modules);
+
+			expect(eligibleModules).to.eql(expectedModules);
+		});
+
+		it('checks if device is in Dfu mode', async () => {
+			const device = {
+				isInDfuMode: true,
+				getAssetInfo: sinon.stub().resolves({ available: [] })
+			};
+			const reopen = sinon.stub(usbUtils, 'reopenInNormalMode').resolves(device);
+
+			await flash._filterAssetsOnDevice(device, fwModules);
+
+			expect(reopen).to.have.been.calledOnce;
+		});
+	});
+
+	describe('_get256Hash', () => {
+		it ('returns the hash of the file', async () => {
+			const assetModules = await createAssetModules();
+
+			const hash = await flash._get256Hash(assetModules[0]);
+
+			expect(hash).to.equal('8e3dd2ea9ff3da70862a52621f7c1dc81c2b184cb886a324a3f430ec11efd3f2');
+		});
+
+		it ('returns if module is not available', async () => {
+			const hash = await flash._get256Hash();
+
+			expect(hash).to.equal(undefined);
+		});
+	});
 });