feat: add hmr status service

Author: KristianDD

lib/bootstrap.ts

@@ -178,6 +178,7 @@ $injector.requirePublic("assetsGenerationService", "./services/assets-generation
 $injector.require("filesHashService", "./services/files-hash-service");
 $injector.require("logParserService", "./services/log-parser-service");
 $injector.require("iOSDebuggerPortService", "./services/ios-debugger-port-service");
+$injector.require("hmrStatusService", "./services/hmr-status-service");
 
 $injector.require("pacoteService", "./services/pacote-service");
 $injector.require("qrCodeTerminalService", "./services/qr-code-terminal-service");

lib/common/constants.ts

@@ -48,6 +48,11 @@ export class LiveSyncConstants {
 	static IOS_PROJECT_PATH = "/Documents/AppBuilder/LiveSync";
 }
 
+export class HmrConstants {
+	public static HMR_ERROR_STATUS = 3;
+	public static HMR_SUCCESS_STATUS = 2;
+}
+
 export class DeviceDiscoveryEventNames {
 	static DEVICE_FOUND = "deviceFound";
 	static DEVICE_LOST = "deviceLost";

lib/definitions/hmr-status-service.d.ts

@@ -0,0 +1,4 @@
+interface IHmrStatusService {
+	awaitHmrStatus(deviceId: string, operationHash: string): Promise<number>;
+	attachToHrmStatusEvent(): void;
+}

lib/services/hmr-status-service.ts

@@ -0,0 +1,86 @@
+import { cache } from "../common/decorators";
+import { HmrConstants } from "../common/constants";
+
+export class HmrStatusService implements IHmrStatusService {
+	public static HMR_STATUS_LOG_REGEX = /([a-z A-Z]*) hmr hash ([a-z0-9]*)\./;
+	public static STARTED_MESSAGE = "Checking for updates to the bundle with";
+	public static SUCCESS_MESSAGE = "Successfuly applied update with";
+	public static FAILED_MESSAGE = "Cannot apply update with";
+	private hashOperationStatuses: IDictionary<any> = {};
+
+	constructor(private $logParserService: ILogParserService,
+		private $logger: ILogger) { }
+
+	public awaitHmrStatus(deviceId: string, operationHash: string): Promise<number> {
+		return new Promise((resolve, reject) => {
+			const key = `${deviceId}${operationHash}`;
+			let retryCount = 40;
+
+			const interval = setInterval(() => {
+				const status = this.getStatusByKey(key);
+				if (status || retryCount === 0) {
+					clearInterval(interval);
+					resolve(status);
+				} else {
+					retryCount--;
+				}
+			}, 250);
+		});
+	}
+
+	@cache()
+	public attachToHrmStatusEvent(): void {
+		this.$logParserService.addParseRule({
+			regex: HmrStatusService.HMR_STATUS_LOG_REGEX,
+			handler: this.handleHmrStatusFound.bind(this),
+			name: "hmrStatus"
+		});
+	}
+
+	private handleHmrStatusFound(matches: RegExpMatchArray, deviceId: string): void {
+		const message = matches[1].trim();
+		const hash = matches[2];
+		let status;
+
+		switch (message) {
+			case HmrStatusService.SUCCESS_MESSAGE: {
+				status = HmrConstants.HMR_SUCCESS_STATUS;
+				break;
+			}
+			case HmrStatusService.FAILED_MESSAGE: {
+				status = HmrConstants.HMR_ERROR_STATUS;
+				break;
+			}
+			default: {
+				status = null;
+				break;
+			}
+		}
+
+		this.$logger.trace("Found hmr status.", {status, hash});
+
+		if (status) {
+			this.setData(status, hash, deviceId);
+		}
+	}
+
+	private getStatusByKey(key: string): number {
+		if (this.hashOperationStatuses[key]) {
+			return this.hashOperationStatuses[key].status;
+		}
+
+		return null;
+	}
+
+	private setData(status: Number, operationHash: string, deviceId: string): void {
+		const key = `${deviceId}${operationHash}`;
+
+		if (!this.hashOperationStatuses[key]) {
+			this.hashOperationStatuses[key] = <any>{};
+		}
+
+		this.hashOperationStatuses[key].status = status;
+	}
+}
+
+$injector.register("hmrStatusService", HmrStatusService);

lib/services/livesync/livesync-service.ts

@@ -4,7 +4,7 @@ import { EOL } from "os";
 import { EventEmitter } from "events";
 import { hook } from "../../common/helpers";
 import { PACKAGE_JSON_FILE_NAME, LiveSyncTrackActionNames, USER_INTERACTION_NEEDED_EVENT_NAME, DEBUGGER_ATTACHED_EVENT_NAME, DEBUGGER_DETACHED_EVENT_NAME, TrackActionNames } from "../../constants";
-import { DeviceTypes, DeviceDiscoveryEventNames } from "../../common/constants";
+import { DeviceTypes, DeviceDiscoveryEventNames, HmrConstants } from "../../common/constants";
 import { cache } from "../../common/decorators";
 
 const deviceDescriptorPrimaryKey = "identifier";
@@ -38,6 +38,7 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 		private $analyticsService: IAnalyticsService,
 		private $usbLiveSyncService: DeprecatedUsbLiveSyncService,
 		private $previewAppLiveSyncService: IPreviewAppLiveSyncService,
+		private $hmrStatusService: IHmrStatusService,
 		private $injector: IInjector) {
 		super();
 	}
@@ -147,8 +148,6 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 			deviceIdentifier: liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier,
 			isFullSync: liveSyncResultInfo.isFullSync
 		});
-
-		this.$logger.info(`Successfully synced application ${liveSyncResultInfo.deviceAppData.appIdentifier} on device ${liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier}.`);
 	}
 
 	private async refreshApplicationWithDebug(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, debugOptions: IDebugOptions, outputPath?: string): Promise<IDebugInformation> {
@@ -518,6 +517,7 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 
 				await this.$platformService.trackActionForPlatform({ action: "LiveSync", platform: device.deviceInfo.platform, isForDevice: !device.isEmulator, deviceOsVersion: device.deviceInfo.version });
 				await this.refreshApplication(projectData, liveSyncResultInfo, deviceBuildInfoDescriptor.debugOptions, deviceBuildInfoDescriptor.outputPath);
+				this.$logger.info(`Successfully synced application ${liveSyncResultInfo.deviceAppData.appIdentifier} on device ${liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier}.`);
 
 				this.emitLivesyncEvent(LiveSyncEvents.liveSyncStarted, {
 					projectDir: projectData.projectDir,
@@ -564,6 +564,10 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 		const platforms = _(devices).map(device => device.deviceInfo.platform).uniq().value();
 		const patterns = await this.getWatcherPatterns(liveSyncData, projectData, platforms);
 
+		if (liveSyncData.useHotModuleReload) {
+			this.$hmrStatusService.attachToHrmStatusEvent();
+		}
+
 		if (liveSyncData.watchAllFiles) {
 			const productionDependencies = this.$nodeModulesDependenciesBuilder.getProductionDependencies(projectData.projectDir);
 			patterns.push(PACKAGE_JSON_FILE_NAME);
@@ -582,6 +586,10 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 			}
 
 			let filesToSync: string[] = [];
+			const hmrData: { hash: string; fallbackFiles: IDictionary<string[]> } = {
+				hash: "",
+				fallbackFiles: {}
+			};
 			const filesToSyncMap: IDictionary<string[]> = {};
 			let filesToRemove: string[] = [];
 			let timeoutTimer: NodeJS.Timer;
@@ -610,6 +618,7 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 							if (filesToSync.length || filesToRemove.length) {
 								try {
 									const currentFilesToSync = _.cloneDeep(filesToSync);
+									const currentHmrData = _.cloneDeep(hmrData);
 									filesToSync.splice(0, filesToSync.length);
 
 									const currentFilesToRemove = _.cloneDeep(filesToRemove);
@@ -655,8 +664,21 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 											force: liveSyncData.force
 										};
 
-										const liveSyncResultInfo = await service.liveSyncWatchAction(device, settings);
+										let liveSyncResultInfo = await service.liveSyncWatchAction(device, settings);
+
 										await this.refreshApplication(projectData, liveSyncResultInfo, deviceBuildInfoDescriptor.debugOptions, deviceBuildInfoDescriptor.outputPath);
+
+										if (liveSyncData.useHotModuleReload && currentHmrData.hash) {
+											const status = await this.$hmrStatusService.awaitHmrStatus(device.deviceInfo.identifier, currentHmrData.hash);
+											if (status === HmrConstants.HMR_ERROR_STATUS) {
+												settings.filesToSync = currentHmrData.fallbackFiles[device.deviceInfo.platform];
+												liveSyncResultInfo = await service.liveSyncWatchAction(device, settings);
+												liveSyncResultInfo.isFullSync = true;
+												await this.refreshApplication(projectData, liveSyncResultInfo, deviceBuildInfoDescriptor.debugOptions, deviceBuildInfoDescriptor.outputPath);
+											}
+										}
+
+										this.$logger.info(`Successfully synced application ${liveSyncResultInfo.deviceAppData.appIdentifier} on device ${liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier}.`);
 									},
 										(device: Mobile.IDevice) => {
 											const liveSyncProcessInfo = this.liveSyncProcessesInfo[projectData.projectDir];
@@ -704,6 +726,7 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 					},
 					filesToSync,
 					filesToSyncMap,
+					hmrData,
 					filesToRemove,
 					startSyncFilesTimeout: async (platform: string) => {
 						if (platform) {

lib/services/log-parser-service.ts

@@ -29,14 +29,17 @@ export class LogParserService extends EventEmitter implements ILogParserService
 		const device = this.$devicesService.getDeviceByIdentifier(deviceIdentifier);
 		const devicePlatform = device.deviceInfo.platform.toLowerCase();
 
-		_.forEach(this.parseRules, (parseRule) => {
-			if (!parseRule.platform || parseRule.platform.toLowerCase() === devicePlatform) {
-				const matches = parseRule.regex.exec(message);
-
-				if (matches) {
-					parseRule.handler(matches, deviceIdentifier);
+		const lines = message.split("\n");
+		_.forEach(lines, line => {
+			_.forEach(this.parseRules, (parseRule) => {
+				if (!parseRule.platform || parseRule.platform.toLowerCase() === devicePlatform) {
+					const matches = parseRule.regex.exec(line);
+
+					if (matches) {
+						parseRule.handler(matches, deviceIdentifier);
+					}
 				}
-			}
+			});
 		});
 	}
 }

test/services/livesync-service.ts

@@ -7,6 +7,7 @@ const createTestInjector = (): IInjector => {
 	const testInjector = new Yok();
 
 	testInjector.register("platformService", {});
+	testInjector.register("hmrStatusService", {});
 	testInjector.register("projectDataService", {
 		getProjectData: (projectDir: string): IProjectData => (<any>{})
 	});
@@ -59,6 +60,7 @@ class LiveSyncServiceInheritor extends LiveSyncService {
 		$usbLiveSyncService: DeprecatedUsbLiveSyncService,
 		$injector: IInjector,
 		$previewAppLiveSyncService: IPreviewAppLiveSyncService,
+		$hmrStatusService: IHmrStatusService,
 		$platformsData: IPlatformsData) {
 
 		super(
@@ -78,6 +80,7 @@ class LiveSyncServiceInheritor extends LiveSyncService {
 			$analyticsService,
 			$usbLiveSyncService,
 			$previewAppLiveSyncService,
+			$hmrStatusService,
 			$injector
 		);
 	}