private bool InstallFromCache(PackageWorkingInstallFromCache installFromCache)
{
var mode = installFromCache.Mode;
var install = installFromCache.Install;
var packageDirectory = new DirectoryInfo(installFromCache.PackagePath);
var path = packageDirectory.FullName.RemoveStart(nodeModulesPath + @"\");
try
{
var elapsed = TimeSpan.MinValue;
SkipPath(packageDirectory.Name);
AddInstallStatus(installFromCache, StatusMode.Normal, $"Installing '{ install }' from cache");
using (this.StartStopwatch((s) => elapsed = s))
{
installFromCache.InstallPackage();
AddPathStatus(path, CacheStatusType.PathProcessed);
}
AddInstallStatus(installFromCache, StatusMode.Success, "Install of '{0}' from cache took {1} seconds", path, elapsed.ToDecimalSeconds());
AddPackageCacheStatus(path, install, CacheStatusType.PathCopiedFromCache);
}
catch (Exception ex)
{
AddInstallStatus(installFromCache, StatusMode.Error, "Error installing '{0}', ", ex.Message);
AddPackageCacheStatus(path, install, ex);
DebugUtils.Break();
return(false);
}
return(true);
}
public AddInstallStatusEventArgs(PackageWorkingInstallFromCache installFromCache, StatusMode mode, string status, params object[] args)
{
this.InstallFromCache = installFromCache;
this.StatusMode = mode;
this.Status = status;
this.Args = args;
}
private void AddInstallStatus(PackageWorkingInstallFromCache installFromCache, StatusMode mode, string status, params object[] args)
{
using (lockObject.Lock())
{
if (args.Length > 0)
{
status = string.Format(status, args);
}
installFromCache.InstallStatusList.Add(installFromCache.CreateStatus(status, mode));
}
}
private void Add(string install, PackageWorkingInstallFromCache workingInstallFromCache)
{
this.DependenciesFromCacheToProcess.AddToDictionaryIfNotExist(install, workingInstallFromCache);
if (this.IsRoot)
{
this.AllDependenciesToProcess.AddToDictionaryIfNotExist(install, workingInstallFromCache);
}
else
{
OnAddToAllDependencies.Raise(this, new KeyValuePair <string, PackageWorkingInstallFromCache>(install, workingInstallFromCache));
}
}
private void InstallFromCache(string name, NpmVersion installVersion, DirectoryInfo cacheDirectory, DirectoryInfo packageDirectory, bool executeActions = true, bool executeDirectly = false)
{
var install = name + "@" + installVersion.Version;
if (!this.ContainsKey(install))
{
var workingInstallFromCache = new PackageWorkingInstallFromCache(this.Mode, install, cacheDirectory.FullName, packageDirectory.FullName, this.PackageModules, this);
HandleEvents(workingInstallFromCache);
this.Add(install, workingInstallFromCache);
workingInstallFromCache.InstallPackage(executeActions, executeDirectly);
}
}
private void HandleEvents(PackageWorkingInstallFromCache workingInstallFromCache)
{
workingInstallFromCache.OnUpdateCacheStatus += (sender, e) =>
{
internalOnUpdateCacheStatus(sender, e);
};
workingInstallFromCache.OnQueueInstallAction += (sender, e) =>
{
if (this.IsRoot)
{
this.InstallActionsQueue.Enqueue(e.Value);
}
else
{
OnQueueInstallAction.Raise(sender, e.Value);
}
};
workingInstallFromCache.OnAddToAllDependencies += (sender, e) =>
{
var pair = e.Value;
if (this.IsRoot)
{
this.AllDependenciesToProcess.Add(pair.Key, pair.Value);
}
else
{
OnAddToAllDependencies.Raise(sender, pair);
}
};
workingInstallFromCache.OnAddInstallStatus += (sender, e) =>
{
if (this.IsRoot)
{
this.AddInstallStatus(sender, e.InstallFromCache, e.StatusMode, e.Status, e.Args);
}
else
{
this.AddInstallStatus(e.InstallFromCache, e.StatusMode, e.Status, e.Args);
}
};
}
public bool QueueInstallFromCache(string mode, string install, string cachePath, string packagePath)
{
using (lockObject.Lock())
{
if (NO_INSTALL_FROM_CACHE)
{
return(false);
}
else
{
if (!installsFromCacheToProcess.ContainsKey(install))
{
var workingInstallFromCache = new PackageWorkingInstallFromCache(mode, install, cachePath, packagePath, packageModules);
if (installsFromCacheStatus == null)
{
installsFromCacheStatus = new PackageInstallsFromCacheStatus("Queueing installs from cache");
}
if (!workingInstallFromCache.IsMissingPeer)
{
workingInstallFromCache.OnUpdateCacheStatus += WorkingInstallFromCache_OnUpdateCacheStatus;
workingInstallFromCache.OnAddInstallStatus += WorkingInstallFromCache_OnAddInstallStatus;
this.NothingToPoll = false;
this.WriteLineNoLock("Adding '{0}' to install from cache", install);
installsFromCacheToProcess.AddToDictionaryIfNotExist(install, workingInstallFromCache);
}
}
}
return(true);
}
}
public PackageWorkingInstallFromCache(string mode, string install, string cachePath, string packagePath, NpmNodeModules packageModules, PackageWorkingInstallFromCache parent = null)
{
var packageDirectory = new DirectoryInfo(packagePath);
var cacheDirectory = new DirectoryInfo(cachePath);
this.Mode = mode;
this.Install = install;
this.CachePath = cachePath;
this.PackagePath = packagePath;
this.InstallStatusList = new List <PackageInstallFromCacheStatus>();
this.InstallActionsQueue = new Queue <InstallAction>();
this.PackageModules = packageModules;
this.Parent = parent;
nodeModulesPath = packageDirectory.GetParentPathToFolder("node_modules", true);
cachePathRoot = cacheDirectory.GetParentPathToFolder("cache", true);
this.DependenciesFromCacheToProcess = new Dictionary <string, PackageWorkingInstallFromCache>();
this.AllDependenciesToProcess = new Dictionary <string, PackageWorkingInstallFromCache>();
}
private void AddInstallStatus(PackageWorkingInstallFromCache installFromCache, StatusMode mode, string status, params object[] args)
{
var installStatusEventArgs = new AddInstallStatusEventArgs(installFromCache, mode, status, args);
OnAddInstallStatus(this, installStatusEventArgs);
}
