Merge pull request #3980 from NativeScript/kddimitrov/restart-on-hmr-fail

Kddimitrov/restart on hmr fail

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/appbuilder/device-log-provider.ts

@@ -16,7 +16,7 @@ export class DeviceLogProvider extends DeviceLogProviderBase {
 
 		if (data) {
 			this.emit('data', deviceIdentifier, data);
-			this.emit(DEVICE_LOG_EVENT_NAME, data, deviceIdentifier);
+			this.emit(DEVICE_LOG_EVENT_NAME, data, deviceIdentifier, platform);
 		}
 	}
 

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/common/mobile/device-log-provider.ts

@@ -12,7 +12,7 @@ export class DeviceLogProvider extends DeviceLogProviderBase {
 		const data = this.$logFilter.filterData(platform, lineText, loggingOptions);
 		if (data) {
 			this.$logger.write(data);
-			this.emit(DEVICE_LOG_EVENT_NAME, lineText, deviceIdentifier);
+			this.emit(DEVICE_LOG_EVENT_NAME, lineText, deviceIdentifier, platform);
 		}
 	}
 

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

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

lib/definitions/preview-app-livesync.d.ts

@@ -1,4 +1,5 @@
 import { FilePayload, Device, FilesPayload } from "nativescript-preview-sdk";
+import { EventEmitter } from "events";
 
 declare global {
 	interface IPreviewAppLiveSyncService {
@@ -9,7 +10,7 @@ declare global {
 
 	interface IPreviewAppLiveSyncData extends IProjectDir, IAppFilesUpdaterOptionsComposition, IEnvOptions { }
 
-	interface IPreviewSdkService {
+	interface IPreviewSdkService extends EventEmitter {
 		getQrCodeUrl(options: IHasUseHotModuleReloadOption): string;
 		connectedDevices: Device[];
 		initialize(getInitialFiles: (device: Device) => Promise<FilesPayload>): void;

lib/services/hmr-status-service.ts

@@ -0,0 +1,98 @@
+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 = "Successfully applied update with";
+	public static FAILED_MESSAGE = "Cannot apply update with";
+	private hashOperationStatuses: IDictionary<any> = {};
+	private intervals: IDictionary<any> = {};
+
+	constructor(private $logParserService: ILogParserService,
+		private $processService: IProcessService,
+		private $logger: ILogger) {
+			this.$processService.attachToProcessExitSignals(this, this.dispose);
+		}
+
+	public getHmrStatus(deviceId: string, operationHash: string): Promise<number> {
+		return new Promise((resolve, reject) => {
+			const key = `${deviceId}${operationHash}`;
+			let retryCount = 40;
+
+			this.intervals[key] = setInterval(() => {
+				const status = this.getStatusByKey(key);
+				if (status || retryCount === 0) {
+					clearInterval(this.intervals[key]);
+					this.intervals[key] = null;
+					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;
+	}
+
+	private dispose() {
+		_.forEach(this.intervals, (value, key) => {
+			clearInterval(value);
+			this.intervals[key] = null;
+		});
+	}
+}
+
+$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.getHmrStatus(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/livesync/playground/preview-app-livesync-service.ts

@@ -2,6 +2,7 @@ import * as path from "path";
 import { FilePayload, Device, FilesPayload } from "nativescript-preview-sdk";
 import { PreviewSdkEventNames } from "./preview-app-constants";
 import { APP_FOLDER_NAME, APP_RESOURCES_FOLDER_NAME, TNS_MODULES_FOLDER_NAME } from "../../../constants";
+import { HmrConstants } from "../../../common/constants";
 const isTextOrBinary = require('istextorbinary');
 
 export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
@@ -19,6 +20,7 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 		private $previewSdkService: IPreviewSdkService,
 		private $previewAppPluginsService: IPreviewAppPluginsService,
 		private $projectFilesManager: IProjectFilesManager,
+		private $hmrStatusService: IHmrStatusService,
 		private $projectFilesProvider: IProjectFilesProvider) { }
 
 	public async initialize(data: IPreviewAppLiveSyncData): Promise<void> {
@@ -43,19 +45,38 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 
 	private async initializePreviewForDevice(data: IPreviewAppLiveSyncData, device: Device): Promise<FilesPayload> {
 		const filesToSyncMap: IDictionary<string[]> = {};
+		const hmrData: { hash: string; fallbackFiles: IDictionary<string[]> } = {
+			hash: "",
+			fallbackFiles: {}
+		};
 		let promise = Promise.resolve<FilesPayload>(null);
 		const startSyncFilesTimeout = async (platform: string) => {
 			await promise
 				.then(async () => {
 					const projectData = this.$projectDataService.getProjectData(data.projectDir);
-					promise = this.applyChanges(this.$platformsData.getPlatformData(platform, projectData), projectData, filesToSyncMap[platform]);
+					const platformData = this.$platformsData.getPlatformData(platform, projectData);
+					const currentHmrData = _.cloneDeep(hmrData);
+					const filesToSync = _.cloneDeep(filesToSyncMap[platform]);
+					promise = this.applyChanges(platformData, projectData, filesToSync, { useHotModuleReload: data.appFilesUpdaterOptions.useHotModuleReload});
 					await promise;
+
+					if (data.appFilesUpdaterOptions.useHotModuleReload && currentHmrData.hash) {
+						const devices = _.filter(this.$previewSdkService.connectedDevices, { platform: platform.toLowerCase() });
+
+						await Promise.all(_.map(devices, async (previewDevice: Device) => {
+							const status = await this.$hmrStatusService.getHmrStatus(previewDevice.id, currentHmrData.hash);
+							if (status === HmrConstants.HMR_ERROR_STATUS) {
+								await this.applyChanges(platformData, projectData, currentHmrData.fallbackFiles[platform], { useHotModuleReload: false }, previewDevice.id);
+							}
+						}));
+					}
 				});
 			filesToSyncMap[platform] = [];
 		};
 		await this.$hooksService.executeBeforeHooks("preview-sync", {
 			hookArgs: {
 				projectData: this.$projectDataService.getProjectData(data.projectDir),
+				hmrData,
 				config: {
 					env: data.env,
 					platform: device.platform,
@@ -104,10 +125,11 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 
 			let result: FilesPayload = null;
 			if (files && files.length) {
-				result = await this.applyChanges(platformData, projectData, files);
+				result = await this.applyChanges(platformData, projectData, files, { useHotModuleReload: data.appFilesUpdaterOptions.useHotModuleReload});
 				this.$logger.info(`Successfully synced ${result.files.map(filePayload => filePayload.file.yellow)} for platform ${platform}.`);
 			} else {
-				result = await this.getFilesPayload(platformData, projectData);
+				const hmrMode = data.appFilesUpdaterOptions.useHotModuleReload ? 1 : 0;
+				result = await this.getFilesPayload(platformData, projectData, hmrMode);
 				this.$logger.info(`Successfully synced changes for platform ${platform}.`);
 			}
 
@@ -117,14 +139,15 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 		}
 	}
 
-	private async applyChanges(platformData: IPlatformData, projectData: IProjectData, files: string[]): Promise<FilesPayload> {
-		const payloads = this.getFilesPayload(platformData, projectData, _(files).uniq().value());
+	private async applyChanges(platformData: IPlatformData, projectData: IProjectData, files: string[], { useHotModuleReload }: {useHotModuleReload: Boolean}, deviceId?: string): Promise<FilesPayload> {
+		const hmrMode = useHotModuleReload ? 1 : 0;
+		const payloads = this.getFilesPayload(platformData, projectData, hmrMode, _(files).uniq().value(), deviceId);
 		await this.$previewSdkService.applyChanges(payloads);
 
 		return payloads;
 	}
 
-	private getFilesPayload(platformData: IPlatformData, projectData: IProjectData, files?: string[]): FilesPayload {
+	private getFilesPayload(platformData: IPlatformData, projectData: IProjectData, hmrMode: number, files?: string[], deviceId?: string): FilesPayload {
 		const platformsAppFolderPath = path.join(platformData.appDestinationDirectoryPath, APP_FOLDER_NAME);
 
 		if (files && files.length) {
@@ -163,7 +186,7 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 				return filePayload;
 			});
 
-		return { files: payloads, platform: platformData.normalizedPlatformName.toLowerCase() };
+		return { files: payloads, platform: platformData.normalizedPlatformName.toLowerCase(), hmrMode, deviceId};
 	}
 
 	private async preparePlatform(platform: string, appFilesUpdaterOptions: IAppFilesUpdaterOptions, env: Object, projectData: IProjectData): Promise<void> {

lib/services/livesync/playground/preview-sdk-service.ts

@@ -1,8 +1,10 @@
 import { MessagingService, Config, Device, DeviceConnectedMessage, SdkCallbacks, ConnectedDevices, FilesPayload } from "nativescript-preview-sdk";
 import { PubnubKeys } from "./preview-app-constants";
+import { DEVICE_LOG_EVENT_NAME } from "../../../common/constants";
+import { EventEmitter } from "events";
 const pako = require("pako");
 
-export class PreviewSdkService implements IPreviewSdkService {
+export class PreviewSdkService extends EventEmitter implements IPreviewSdkService {
 	private static MAX_FILES_UPLOAD_BYTE_LENGTH = 15 * 1024 * 1024; // In MBs
 	private messagingService: MessagingService = null;
 	private instanceId: string = null;
@@ -11,6 +13,7 @@ export class PreviewSdkService implements IPreviewSdkService {
 	constructor(private $logger: ILogger,
 		private $httpClient: Server.IHttpClient,
 		private $config: IConfiguration) {
+			super();
 	}
 
 	public getQrCodeUrl(options: IHasUseHotModuleReloadOption): string {
@@ -58,7 +61,9 @@ export class PreviewSdkService implements IPreviewSdkService {
 				this.$logger.trace("Received onLogSdkMessage message: ", log);
 			},
 			onConnectedDevicesChange: (connectedDevices: ConnectedDevices) => ({ }),
-			onLogMessage: (log: string, deviceName: string) => {
+			onLogMessage: (log: string, deviceName: string, deviceId: string) => {
+				const device = _.find(this.connectedDevices, { id: deviceId});
+				this.emit(DEVICE_LOG_EVENT_NAME, log, deviceId, device.platform);
 				this.$logger.info(`LOG from device ${deviceName}: ${log}`);
 			},
 			onRestartMessage: () => {
@@ -69,7 +74,7 @@ export class PreviewSdkService implements IPreviewSdkService {
 			},
 			onDeviceConnectedMessage: (deviceConnectedMessage: DeviceConnectedMessage) => ({ }),
 			onDeviceConnected: (device: Device) => {
-				if (!_.includes(this.connectedDevices, device)) {
+				if (!_.find(this.connectedDevices, {id: device.id})) {
 					this.connectedDevices.push(device);
 				}
 			},