public List <DirectoryInfo> GetVersionDirectories(string package)
{
List <DirectoryInfo> result;
if (!_library.TryGetValue(package, out result))
{
result = new List <DirectoryInfo>();
_library.Add(package, result);
foreach (var feed in SearchPaths)
{
DirectoryInfo dir;
if (!GetPackageDirectories(feed).TryGetValue(package, out dir))
{
continue;
}
var versions = dir.GetDirectories();
Array.Sort(versions, (left, right) => VersionRange.Compare(right.Name, left.Name));
foreach (var version in versions)
{
if (PackageFile.Exists(version.FullName))
{
result.Add(version);
}
}
}
}
return(result);
}
public void Repair(List <string> optionalPackages = null, bool force = false)
{
// Implicit --force when packages are specified explicitly
force = force || optionalPackages?.Count > 0;
foreach (var dir in EnumerateDirectories(optionalPackages))
{
var path = dir.FullName;
try
{
// Skip locally built packages (taken care of by LibraryBuilder)
if (PackageFile.Exists(path) &&
!File.Exists(Path.Combine(path, ".unobuild")) &&
Repair(PackageFile.Load(path), force))
{
Log.Message("Updated " + path.Relative().Quote());
}
}
catch (Exception e)
{
Log.Trace(e);
Log.Error("Failed to load package " + path.Relative().Quote() + ": " + e.Message);
}
}
}
PackageFile GetFile(PackageReference reference)
{
var name = reference.PackageName;
var versionRange = VersionRange.Parse(reference.PackageVersion);
if (_sourcePaths.Count > 0)
{
var dirs = _sourcePaths.GetOrderedVersionDirectories(name);
foreach (var dir in dirs)
{
if (versionRange.IsCompatible(dir.Name))
{
return(PackageFile.Load(dir.FullName));
}
}
// Fallback to "best" version for now
if (dirs.Length > 0)
{
return(PackageFile.Load(dirs[0].FullName));
}
}
string version;
if (_locks.TryGetValue(name, out version))
{
foreach (var dir in _searchPaths.EnumeratePackageDirectories(name))
{
var versionDir = Path.Combine(dir.FullName, version);
if (PackageFile.Exists(versionDir))
{
return(PackageFile.Load(versionDir));
}
}
}
else
{
var dirs = _searchPaths.GetOrderedVersionDirectories(name).ToArray();
foreach (var dir in dirs)
{
if (versionRange.IsCompatible(dir.Name))
{
return(PackageFile.Load(dir.FullName));
}
}
// Fallback to "best" version for now
if (dirs.Length > 0)
{
return(PackageFile.Load(dirs[0].FullName));
}
}
return(null);
}
public IEnumerable <DirectoryInfo> EnumerateVersionDirectories(string name = "*", string version = null)
{
version = version ?? "*";
foreach (var package in EnumeratePackageDirectories(name))
{
foreach (var dir in package.EnumerateDirectories(version))
{
if (PackageFile.Exists(dir.FullName))
{
yield return(dir);
}
}
}
}
public bool Repair(PackageFile file, bool force = false)
{
var upk = file.CreateSourcePackage();
var reader = new SourceReader(Log, upk, this);
if (force || !reader.CacheExists ||
reader.HasAnythingChangedSince(reader.CacheTime, false))
{
Log.Verbose("Generating cache for " + file.Name);
using (new FileLock(Log, file.CacheDirectory))
reader.ExportCache(file.CacheDirectory);
return(true);
}
return(false);
}
public PackageFile Install(IPackage upk)
{
var dst = Path.Combine(InstallDirectory, upk.Name, upk.Version);
Log.WriteLine("Installing " + upk.Name + " " + upk.Version, ConsoleColor.Blue);
using (new FileLock(dst))
{
if (Force || !PackageFile.Exists(dst))
{
upk.Install(dst);
}
var file = PackageFile.Load(dst);
CheckInstalled(file);
return(file);
}
}
public bool Repair(PackageFile file, bool force = false)
{
var upk = file.CreateSourcePackage();
var reader = new SourceReader(Log, upk, this);
// Install NPM packages if package.json exists
if (NPM.NeedsInstall(upk))
{
new NPM(Log).Install(upk);
}
if (force || !reader.CacheExists ||
reader.HasAnythingChangedSince(reader.CacheTime, false))
{
Log.Verbose("Generating cache for " + file.Name);
using (new FileLock(file.CacheDirectory))
reader.ExportCache(file.CacheDirectory);
return(true);
}
return(false);
}
public PackageFile Install(string name, string version = null)
{
if (!Force)
{
var upk = GetInstalled(name, version);
if (upk != null)
{
try
{
var file = PackageFile.Load(upk.Source);
CheckInstalled(file);
return(file);
}
catch (Exception e)
{
Log.Trace(e);
}
}
}
var cached = Path.Combine(CacheDir, name + "." + version + ".nupkg");
if (File.Exists(cached))
{
try
{
return(Install(new UpkFile(cached, name, version)));
}
catch (Exception e)
{
Log.Trace(e);
}
}
return(Install(FindPackage(name, version)));
}
PackageFile GetFile(PackageReference reference)
{
var name = reference.PackageName;
var versionRange = VersionRange.Parse(reference.PackageVersion);
if (_sourcePaths.Count > 0)
{
var dirs = _sourcePaths.GetOrderedVersionDirectories(name);
foreach (var dir in dirs)
{
if (versionRange.IsCompatible(dir.Name))
{
return(PackageFile.Load(dir.FullName));
}
}
// Fallback to "best" version for now
if (dirs.Length > 0)
{
return(PackageFile.Load(dirs[0].FullName));
}
}
string version;
if (_locks.TryGetValue(name, out version))
{
foreach (var dir in _searchPaths.EnumeratePackageDirectories(name))
{
var versionDir = Path.Combine(dir.FullName, version);
if (PackageFile.Exists(versionDir))
{
return(PackageFile.Load(versionDir));
}
}
if (_pm != null)
{
try
{
return(_pm.Install(name, version));
}
catch (Exception e)
{
Log.Trace(e);
Log.Error("Failed to install package " + name.Quote() + ": " + e.Message);
}
}
}
else
{
var dirs = _searchPaths.GetOrderedVersionDirectories(name).ToArray();
foreach (var dir in dirs)
{
if (versionRange.IsCompatible(dir.Name))
{
return(PackageFile.Load(dir.FullName));
}
}
// Fallback to "best" version for now
if (dirs.Length > 0)
{
return(PackageFile.Load(dirs[0].FullName));
}
}
return(null);
}
void CheckInstalled(PackageFile file)
{
// Update cache if necessary
new PackageDoctor(Log).Repair(file);
InstallCount++;
}
