Fix android livesync with sockets

Fatme · Fatme · commit 69c8b57101d1 · 2018-08-02T18:06:38.000+03:00
diff --git a/lib/definitions/livesync-global.d.ts b/lib/definitions/livesync-global.d.ts
@@ -1,7 +1,7 @@
-import * as stream from "stream";
+import { Socket } from "net";
 
 declare global {
-	interface IDuplexSocket extends stream.Duplex {
+	interface INetSocket extends Socket {
 		uid?: string;
 	}
 }
diff --git a/lib/definitions/livesync.d.ts b/lib/definitions/livesync.d.ts
@@ -332,6 +332,8 @@ interface ILiveSyncResultInfo {
 	useLiveEdit?: boolean;
 }
 
+interface IAndroidLiveSyncResultInfo extends ILiveSyncResultInfo, IAndroidLivesyncSyncOperationResult { }
+
 interface IFullSyncInfo extends IProjectDataComposition {
 	device: Mobile.IDevice;
 	watch: boolean;
@@ -377,22 +379,22 @@ interface INativeScriptDeviceLiveSyncService extends IDeviceLiveSyncServiceBase
 	 * @return {Promise<Mobile.ILocalToDevicePathData[]>} Returns the ILocalToDevicePathData of all transfered files
 	 */
 	transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string, isFullSync: boolean): Promise<Mobile.ILocalToDevicePathData[]>;
-
-	/**
-	 * Guarantees all remove/update operations have finished
-	 * @param  {ILiveSyncResultInfo} liveSyncInfo Describes the LiveSync operation - for which project directory is the operation and other settings.
-	 * @return {Promise<void>}
-	 */
-	finalizeSync(liveSyncInfo: ILiveSyncResultInfo): Promise<void>;
 }
 
-interface IAndroidNativeScriptDeviceLiveSyncService {
+interface IAndroidNativeScriptDeviceLiveSyncService extends INativeScriptDeviceLiveSyncService {
 	/**
 	 * Retrieves the android device's hash service.
 	 * @param  {string} appIdentifier Application identifier.
 	 * @return {Promise<Mobile.IAndroidDeviceHashService>} The hash service
 	 */
 	getDeviceHashService(appIdentifier: string): Mobile.IAndroidDeviceHashService;
+
+	/**
+	 * Guarantees all remove/update operations have finished
+	 * @param  {ILiveSyncResultInfo} liveSyncInfo Describes the LiveSync operation - for which project directory is the operation and other settings.
+	 * @return {Promise<IAndroidLiveSyncResultInfo>}
+	 */
+	finalizeSync(liveSyncInfo: ILiveSyncResultInfo): Promise<IAndroidLiveSyncResultInfo>;
 }
 
 interface IAndroidLivesyncTool {
diff --git a/lib/services/livesync/android-device-livesync-sockets-service.ts b/lib/services/livesync/android-device-livesync-sockets-service.ts
@@ -39,18 +39,23 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 		return `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}-livesync-in-progress`;
 	}
 
-	public async finalizeSync(liveSyncInfo: ILiveSyncResultInfo) {
-		await this.doSync(liveSyncInfo);
+	public async finalizeSync(liveSyncInfo: ILiveSyncResultInfo): Promise<any> {
+		try {
+			const result = await this.doSync(liveSyncInfo);
+			return result;
+		} finally {
+			this.livesyncTool.end();
+		}
 	}
 
-	private async doSync(liveSyncInfo: ILiveSyncResultInfo, { doRefresh = false }: { doRefresh?: boolean } = {}): Promise<IAndroidLivesyncSyncOperationResult> {
+	private async doSync(liveSyncInfo: ILiveSyncResultInfo): Promise<IAndroidLivesyncSyncOperationResult> {
 		const operationId = this.livesyncTool.generateOperationIdentifier();
 
 		let result = { operationId, didRefresh: true };
 
 		if (liveSyncInfo.modifiedFilesData.length) {
 
-			const doSyncPromise = this.livesyncTool.sendDoSyncOperation(doRefresh, null, operationId);
+			const doSyncPromise = this.livesyncTool.sendDoSyncOperation(true, null, operationId);
 
 			const syncInterval: NodeJS.Timer = setInterval(() => {
 				if (this.livesyncTool.isOperationInProgress(operationId)) {
@@ -64,24 +69,21 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 			};
 
 			this.$processService.attachToProcessExitSignals(this, actionOnEnd);
-			doSyncPromise.then(actionOnEnd, actionOnEnd);
+			// We need to clear resources when the action fails
+			// But we also need the real result of the action.
+			await doSyncPromise.then(actionOnEnd.bind(this), actionOnEnd.bind(this));
 
 			result = await doSyncPromise;
+		} else {
+			await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
 		}
 
-		await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
-
 		return result;
 	}
 
-	public async refreshApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo) {
+	public async refreshApplication(projectData: IProjectData, liveSyncInfo: IAndroidLiveSyncResultInfo) {
 		const canExecuteFastSync = !liveSyncInfo.isFullSync && this.canExecuteFastSyncForPaths(liveSyncInfo.modifiedFilesData, projectData, this.device.deviceInfo.platform);
-
-		const syncOperationResult = await this.doSync(liveSyncInfo, { doRefresh: canExecuteFastSync });
-
-		this.livesyncTool.end();
-
-		if (!canExecuteFastSync || !syncOperationResult.didRefresh) {
+		if (!canExecuteFastSync || !liveSyncInfo.didRefresh) {
 			await this.device.applicationManager.restartApplication({ appId: liveSyncInfo.deviceAppData.appIdentifier, projectName: projectData.projectName });
 		}
 	}
diff --git a/lib/services/livesync/android-livesync-service.ts b/lib/services/livesync/android-livesync-service.ts
@@ -23,6 +23,25 @@ export class AndroidLiveSyncService extends PlatformLiveSyncServiceBase implemen
 		return this.$injector.resolve<INativeScriptDeviceLiveSyncService>(AndroidDeviceLiveSyncService, { device, data });
 	}
 
+	public async liveSyncWatchAction(device: Mobile.IDevice, liveSyncInfo: ILiveSyncWatchInfo): Promise<IAndroidLiveSyncResultInfo> {
+		const liveSyncResult = await super.liveSyncWatchAction(device, liveSyncInfo);
+		const result = await this.finalizeSync(device, liveSyncInfo.projectData, liveSyncResult);
+		return result;
+	}
+
+	public async fullSync(syncInfo: IFullSyncInfo): Promise<IAndroidLiveSyncResultInfo> {
+		const liveSyncResult = await super.fullSync(syncInfo);
+		const result = await this.finalizeSync(syncInfo.device, syncInfo.projectData, liveSyncResult);
+		return result;
+	}
+
 	public async prepareForLiveSync(device: Mobile.IDevice, data: IProjectDir): Promise<void> { /* */ }
+
+	private async finalizeSync(device: Mobile.IDevice, projectData: IProjectData, liveSyncResult: ILiveSyncResultInfo): Promise<IAndroidLiveSyncResultInfo> {
+		const liveSyncService = <IAndroidNativeScriptDeviceLiveSyncService>this.getDeviceLiveSyncService(device,projectData);
+		const finalizeResult = await liveSyncService.finalizeSync(liveSyncResult);
+		const result = _.extend(liveSyncResult, finalizeResult);
+		return result;
+	}
 }
 $injector.register("androidLiveSyncService", AndroidLiveSyncService);
diff --git a/lib/services/livesync/android-livesync-tool.ts b/lib/services/livesync/android-livesync-tool.ts
@@ -22,13 +22,13 @@ const DEFAULT_LOCAL_HOST_ADDRESS = "127.0.0.1";
 export class AndroidLivesyncTool implements IAndroidLivesyncTool {
 	private operationPromises: IDictionary<any>;
 	private socketError: string | Error;
-	private socketConnection: IDuplexSocket;
+	private socketConnection: INetSocket;
 	private configuration: IAndroidLivesyncToolConfiguration;
 	private pendingConnectionData: {
 		connectionTimer?: NodeJS.Timer,
 		socketTimer?: NodeJS.Timer,
 		rejectHandler?: Function,
-		socket?: IDuplexSocket
+		socket?: INetSocket
 	} = null;
 
 	constructor(private $androidProcessService: Mobile.IAndroidProcessService,
@@ -173,6 +173,7 @@ export class AndroidLivesyncTool implements IAndroidLivesyncTool {
 			this.cleanState(socketUid);
 			//call end of the connection (close and error callbacks won't be called - listeners removed)
 			socket.end();
+			socket.destroy();
 			//reject all pending sync requests and clear timeouts
 			this.rejectPendingSyncOperations(socketUid, error);
 		}
@@ -254,7 +255,7 @@ export class AndroidLivesyncTool implements IAndroidLivesyncTool {
 		});
 	}
 
-	private createSocket(port: number): IDuplexSocket {
+	private createSocket(port: number): INetSocket {
 		const socket = new net.Socket();
 		socket.connect(port, this.configuration.localHostAddress);
 		return socket;
@@ -280,7 +281,7 @@ export class AndroidLivesyncTool implements IAndroidLivesyncTool {
 		}
 	}
 
-	private handleConnection({ socket, data }: { socket: IDuplexSocket, data: NodeBuffer | string }) {
+	private handleConnection({ socket, data }: { socket: INetSocket, data: NodeBuffer | string }) {
 		this.socketConnection = socket;
 		this.socketConnection.uid = this.generateOperationIdentifier();
 
@@ -304,15 +305,15 @@ export class AndroidLivesyncTool implements IAndroidLivesyncTool {
 		});
 	}
 
-	private connectEventuallyUntilTimeout(factory: () => IDuplexSocket, timeout: number): Promise<{socket: IDuplexSocket, data: NodeBuffer | string}> {
+	private connectEventuallyUntilTimeout(factory: () => INetSocket, timeout: number): Promise<{socket: INetSocket, data: NodeBuffer | string}> {
 		return new Promise((resolve, reject) => {
 			let lastKnownError: Error | string,
 				isConnected = false;
 
 			const connectionTimer = setTimeout(() => {
 				if (!isConnected) {
 					isConnected = true;
-					reject(lastKnownError || { message: "Socket connection timeouted." });
+					reject(lastKnownError || new Error("Socket connection timeouted."));
 					this.pendingConnectionData = null;
 				}
 			}, timeout);
diff --git a/lib/services/livesync/device-livesync-service-base.ts b/lib/services/livesync/device-livesync-service-base.ts
@@ -39,7 +39,7 @@ export abstract class DeviceLiveSyncServiceBase {
 		return transferredFiles;
 	}
 
-	public async finalizeSync(liveSyncInfo: ILiveSyncResultInfo): Promise<void> {
+	public async finalizeSync(liveSyncInfo: ILiveSyncResultInfo): Promise<any> {
 		//implement in case a sync point for all remove/create operation is needed
 	}
 }
diff --git a/lib/services/livesync/livesync-service.ts b/lib/services/livesync/livesync-service.ts
@@ -164,9 +164,6 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 		};
 
 		try {
-			const platformLiveSyncService = this.getLiveSyncService(liveSyncResultInfo.deviceAppData.platform);
-			const deviceLivesyncService = platformLiveSyncService.getDeviceLiveSyncService(deviceAppData.device, projectData);
-			await deviceLivesyncService.finalizeSync(liveSyncResultInfo);
 			await deviceAppData.device.applicationManager.stopApplication({ appId: applicationId, projectName: projectData.projectName });
 			// Now that we've stopped the application we know it isn't started, so set debugOptions.start to false
 			// so that it doesn't default to true in attachDebugger method
@@ -493,7 +490,7 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 					applicationIdentifier: projectData.projectId
 				});
 			} catch (err) {
-				this.$logger.warn(`Unable to apply changes on device: ${device.deviceInfo.identifier}. Error is: ${err.message}.`);
+				this.$logger.warn(`Unable to apply changes on device: ${device.deviceInfo.identifier}. Error is: ${err.message}.`, err.stack);
 
 				this.emit(LiveSyncEvents.liveSyncError, {
 					error: err,

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`		`-import * as stream from "stream";`
	`1`	`+import { Socket } from "net";`
`2`	`2`
`3`	`3`	`declare global {`
`4`		`- interface IDuplexSocket extends stream.Duplex {`
	`4`	`+ interface INetSocket extends Socket {`
`5`	`5`	`uid?: string;`
`6`	`6`	`}`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ export abstract class DeviceLiveSyncServiceBase {`
`39`	`39`	`return transferredFiles;`
`40`	`40`	`}`
`41`	`41`
`42`		`- public async finalizeSync(liveSyncInfo: ILiveSyncResultInfo): Promise<void> {`
	`42`	`+ public async finalizeSync(liveSyncInfo: ILiveSyncResultInfo): Promise<any> {`
`43`	`43`	`//implement in case a sync point for all remove/create operation is needed`
`44`	`44`	`}`
`45`	`45`	`}`