* Implement lockfile to allow parallel execution

* Symlink option

Author: Fatme

lib/bootstrap.ts

@@ -33,5 +33,6 @@ $injector.requireCommand("emulate", "./commands/emulate");
 $injector.requireCommand("list-devices", "./commands/list-devices");
 
 $injector.require("npm", "./node-package-manager");
+$injector.require("lockfile", "./lockfile");
 $injector.require("config", "./config");
 $injector.require("optionsService", "./services/options-service");

lib/declarations.ts

@@ -1,5 +1,5 @@
 interface INodePackageManager {
-	getCacheRootPath(): IFuture<string>;
+	getCacheRootPath(): string;
 	addToCache(packageName: string, version: string): IFuture<void>;
 	cacheUnpack(packageName: string, version: string, unpackTarget?: string): IFuture<void>;
 	load(config?: any): IFuture<void>;
@@ -21,3 +21,7 @@ interface IApplicationPackage {
 	time: Date;
 }
 
+interface ILockFile {
+	lock(): IFuture<void>;
+	unlock(): IFuture<void>;
+}

lib/definitions/lockfile.d.ts

@@ -0,0 +1,15 @@
+declare module "lockfile" {
+	export function lock(lockFilename: string, lockParams: ILockParams, callback: (err: Error) => void): void;
+	export function lockSync(lockFilename: string, lockParams: any): void;
+	export function unlock(lockFilename: string, callback: (err: Error) => void): void;
+	export function unlockSync(lockFilename: string): void;
+
+	interface ILockSyncParams {
+		retries: number;
+		stale: number;
+	}
+
+	interface ILockParams extends ILockSyncParams {
+		retryWait: number;
+	}
+}

lib/lockfile.ts

@@ -0,0 +1,42 @@
+///<reference path=".d.ts"/>
+"use strict";
+
+import Future = require("fibers/future");
+import lockfile = require("lockfile");
+import path = require("path");
+import options = require("./options");
+
+export class LockFile implements ILockFile {
+	private static LOCK_FILENAME = path.join(options["profile-dir"], ".lock");
+	private static LOCK_EXPIRY_PERIOD_SEC = 180;
+	private static LOCK_PARAMS = {
+		retryWait: 100,
+		retries: LockFile.LOCK_EXPIRY_PERIOD_SEC*10,
+		stale: LockFile.LOCK_EXPIRY_PERIOD_SEC*1000
+	};
+
+	public lock(): IFuture<void> {
+		var future = new Future<void>();
+		lockfile.lock(LockFile.LOCK_FILENAME, LockFile.LOCK_PARAMS, (err: Error) => {
+			if(err) {
+				future.throw(err);
+			} else {
+				future.return();
+			}
+		});
+		return future;
+	}
+
+	public unlock(): IFuture<void> {
+		var future = new Future<void>();
+		lockfile.unlock(LockFile.LOCK_FILENAME, (err: Error) => {
+			if(err) {
+				future.throw(err);
+			} else {
+				future.return();
+			}
+		});
+		return future;
+	}
+}
+$injector.register("lockfile", LockFile);

lib/nativescript-cli.ts

@@ -1,6 +1,5 @@
 ///<reference path=".d.ts"/>
 "use strict";
-
 import path = require("path");
 
 require("./bootstrap");

lib/node-package-manager.ts

@@ -14,28 +14,21 @@ export class NodePackageManager implements INodePackageManager {
 	private static NPM_REGISTRY_URL = "http://registry.npmjs.org/";
 
 	private versionsCache: IDictionary<string[]>;
-	private isLoaded: boolean;
 
 	constructor(private $logger: ILogger,
 		private $errors: IErrors,
 		private $httpClient: Server.IHttpClient,
-		private $staticConfig: IStaticConfig,
 		private $fs: IFileSystem) {
 		this.versionsCache = {};
+		this.load().wait();
 	}
 
-	public getCacheRootPath(): IFuture<string> {
-		return (() => {
-			this.load().wait();
-			return npm.cache;
-		}).future<string>()();
+	public getCacheRootPath(): string {
+		return npm.cache;
 	}
 
 	public addToCache(packageName: string, version: string): IFuture<void> {
-		return (() => {
-			this.load().wait();
-			this.addToCacheCore(packageName, version).wait();
-		}).future<void>()();
+		return this.addToCacheCore(packageName, version);
 	}
 
 	public load(config?: any): IFuture<void> {
@@ -53,28 +46,16 @@ export class NodePackageManager implements INodePackageManager {
 	public install(packageName: string, opts?: INpmInstallOptions): IFuture<string> {
 		return (() => {
 			try {
-				this.load().wait(); // It's obligatory to execute load before whatever npm function
-
 				var packageToInstall = packageName;
 				var pathToSave = (opts && opts.pathToSave) || npm.cache;
 				var version = (opts && opts.version) || null;
-				var isSemanticVersioningDisabled = options.frameworkPath ? true : false; // We need to disable sem versioning for local packages
-
-				if(version) {
-					this.validateVersion(packageName, version).wait();
-					packageToInstall = packageName + "@" + version;
-				}
 
-				this.installCore(packageToInstall, pathToSave, isSemanticVersioningDisabled).wait();
+				return this.installCore(packageToInstall, pathToSave, version).wait();
 			} catch(error) {
 				this.$logger.debug(error);
-				this.$errors.fail(NodePackageManager.NPM_LOAD_FAILED);
+				this.$errors.fail("%s. Error: %s", NodePackageManager.NPM_LOAD_FAILED, error);
 			}
 
-			var pathToNodeModules = path.join(pathToSave, "node_modules");
-			var folders = this.$fs.readDirectory(pathToNodeModules).wait();
-			return path.join(pathToNodeModules, folders[0]);
-
 		}).future<string>()();
 	}
 
@@ -86,21 +67,40 @@ export class NodePackageManager implements INodePackageManager {
 		}).future<string>()();
 	}
 
-	private installCore(packageName: string, pathToSave: string, isSemanticVersioningDisabled: boolean): IFuture<void> {
-		var currentVersion = this.$staticConfig.version;
-		if(!semver.valid(currentVersion)) {
-			this.$errors.fail("Invalid version.");
-		}
-
-		if(!isSemanticVersioningDisabled) {
-			var incrementedVersion = semver.inc(currentVersion, constants.ReleaseType.MINOR);
-			if(packageName.indexOf("@") < 0) {
-				packageName = packageName + "@<" + incrementedVersion;
+	private installCore(packageName: string, pathToSave: string, version: string): IFuture<string> {
+		return (() => {
+			if (options.frameworkPath) {
+				if (this.$fs.getFsStats(options.frameworkPath).wait().isFile()) {
+					this.npmInstall(packageName, pathToSave, version).wait();
+					var pathToNodeModules = path.join(pathToSave, "node_modules");
+					var folders = this.$fs.readDirectory(pathToNodeModules).wait();
+					return path.join(pathToNodeModules, folders[0]);
+				}
+				return options.frameworkPath;
+			} else {
+				var version = version || this.getLatestVersion(packageName).wait();
+				var packagePath = path.join(npm.cache, packageName, version, "package");
+				if (this.isPackageCached(packagePath).wait()) {
+					if(!this.isPackageUnpacked(packagePath).wait()) {
+						this.cacheUnpack(packageName, version).wait();
+					}
+					return packagePath;
+				} else {
+					this.npmInstall(packageName, pathToSave, version).wait();
+					return path.join(pathToSave, "node_modules", packageName);
+				}
 			}
-		}
+		}).future<string>()();
+	}
 
+	private npmInstall(packageName: string, pathToSave: string, version: string): IFuture<void> {
 		this.$logger.out("Installing ", packageName);
 
+		var incrementedVersion = semver.inc(version, constants.ReleaseType.MINOR);
+		if (!options.frameworkPath && packageName.indexOf("@") < 0) {
+			packageName = packageName + "@<" + incrementedVersion;
+		}
+
 		var future = new Future<void>();
 		npm.commands["install"](pathToSave, packageName, (err: Error, data: any) => {
 			if(err) {
@@ -113,6 +113,17 @@ export class NodePackageManager implements INodePackageManager {
 		return future;
 	}
 
+	private isPackageCached(packagePath: string): IFuture<boolean> {
+		return this.$fs.exists(packagePath);
+	}
+
+	private isPackageUnpacked(packagePath: string): IFuture<boolean> {
+		return (() => {
+			return this.$fs.getFsStats(packagePath).wait().isDirectory() &&
+				helpers.enumerateFilesInDirectorySync(packagePath).length > 1;
+		}).future<boolean>()();
+	}
+
 	private addToCacheCore(packageName: string, version: string): IFuture<void> {
 		var future = new Future<void>();
 		npm.commands["cache"].add(packageName, version, undefined, (err: Error, data: any) => {

lib/options.ts

@@ -13,6 +13,7 @@ var knownOpts:any = {
 		"release": Boolean,
 		"device": Boolean,
 		"emulator": Boolean,
+		"symlink": Boolean,
 		"keyStorePath": String,
 		"keyStorePassword": String,
 		"keyStoreAlias": String,

lib/services/android-project-service.ts

@@ -49,11 +49,8 @@ class AndroidProjectService implements IPlatformProjectService {
 		return (() => {
 			this.validateAndroidTarget(frameworkDir); // We need framework to be installed to validate android target so we can't call this method in validate()
 
-			var paths = "assets libs res".split(' ').map(p => path.join(frameworkDir, p));
-			shell.cp("-R", paths, projectRoot);
-
-			paths = ".project AndroidManifest.xml project.properties".split(' ').map(p => path.join(frameworkDir, p));
-			shell.cp("-f", paths, projectRoot);
+			this.copyFiles(projectRoot, frameworkDir, "assets libs res").wait();
+			this.copyFiles(projectRoot, frameworkDir, ".project AndroidManifest.xml project.properties").wait();
 
 			// Create src folder
 			var packageName = this.$projectData.projectId;
@@ -124,6 +121,17 @@ class AndroidProjectService implements IPlatformProjectService {
 		return [".jar", ".dat"];
 	}
 
+	private copyFiles(projectRoot: string, frameworkDir: string, files: string): IFuture<void> {
+		return (() => {
+			var paths = files.split(' ').map(p => path.join(frameworkDir, p));
+			if(options.symlink) {
+				_.each(paths, p => this.$fs.symlink(p, projectRoot).wait());
+			} else {
+				shell.cp("-R", paths, projectRoot);
+			}
+		}).future<void>()();
+	}
+
 	private spawn(command: string, args: string[]): IFuture<void> {
 		if (hostInfo.isWindows()) {
 			args.unshift('/s', '/c', command);

lib/services/ios-project-service.ts

@@ -62,7 +62,11 @@ class IOSProjectService implements  IPlatformProjectService {
 
 	public createProject(projectRoot: string, frameworkDir: string): IFuture<void> {
 		return (() => {
-			shell.cp("-R", path.join(frameworkDir, "*"), projectRoot);
+			if(options.symlink) {
+				this.$fs.symlink(frameworkDir, projectRoot);
+			} else {
+				shell.cp("-R", path.join(frameworkDir, "*"), projectRoot);
+			}
 		}).future<void>()();
 	}
 

lib/services/platform-service.ts

@@ -17,16 +17,23 @@ export class PlatformService implements IPlatformService {
 		private $platformsData: IPlatformsData,
 		private $projectData: IProjectData,
 		private $projectDataService: IProjectDataService,
-		private $prompter: IPrompter) { }
+		private $prompter: IPrompter,
+		private $lockfile: ILockFile) { }
 
 	public addPlatforms(platforms: string[]): IFuture<void> {
 		return (() => {
 			var platformsDir = this.$projectData.platformsDir;
 			this.$fs.ensureDirectoryExists(platformsDir).wait();
 
-			_.each(platforms, platform => {
-				this.addPlatform(platform.toLowerCase()).wait();
-			});
+			this.$lockfile.lock().wait();
+
+			try {
+				_.each(platforms, platform => {
+					this.addPlatform(platform.toLowerCase()).wait();
+				});
+			} finally {
+				this.$lockfile.unlock().wait();
+			}
 
 		}).future<void>()();
 	}
@@ -445,7 +452,7 @@ export class PlatformService implements IPlatformService {
 
 	private getNpmCacheDirectoryCore(packageName: string, version: string): IFuture<string> {
 		return (() => {
-			var npmCacheRoot = this.$npm.getCacheRootPath().wait();
+			var npmCacheRoot = this.$npm.getCacheRootPath();
 			return path.join(npmCacheRoot, packageName, version, "package");
 		}).future<string>()();
 	}