public IResolutionResult Resolve(PackageManifestRoot rootManifest, IRepository[] activeRepositories, string releaseLabel)
{
var resolver = new DependencyResolverImplementation(_writer, rootManifest, activeRepositories, releaseLabel);
resolver.Resolve();
return(resolver);
}
public DependencyResolverImplementation(IWriter writer, PackageManifestRoot rootManifest, IRepository[] activeRepositories, string releaseLabel)
{
_cache = new DependencyResolverCache(GetAllAvailableVersions, rootManifest.Framework);
_writer = writer;
_activeRepositories = activeRepositories;
var version = new VersionRangeExtended(rootManifest.Version)
{
ReleaseLabel = releaseLabel
};
_rootDependencyNode = new DependencyNode(null, rootManifest.PackageId, rootManifest.Framework.GetShortFolderName(), version);
_rootDependencyNode.MarkAsRoot(rootManifest);
}
private void Install(IResolutionResult resolutionResult, PackageManifestRoot manifest, RepositoryScope scope)
{
if (scope != RepositoryScope.Cache)
{
var cacheRepo = new CacheRepository(_repositoryFactory.TryGetEnabledRepos(RepositoryScope.Cache));
cacheRepo.PackageDownloadToCacheRepositoryStarted += CacheRepositoryPackageDownloadToCacheRepositoryStarted;
cacheRepo.PackageDownloadToCacheRepositoryFinished += CacheRepositoryOnPackageDownloadToCacheRepositoryFinished;
cacheRepo.DownloadLocally(resolutionResult.ResolutionTable.GetSatisfyingInfos());
cacheRepo.PackageDownloadToCacheRepositoryStarted -= CacheRepositoryPackageDownloadToCacheRepositoryStarted;
cacheRepo.PackageDownloadToCacheRepositoryFinished -= CacheRepositoryOnPackageDownloadToCacheRepositoryFinished;
}
using (var installer = _packageInstallerFactory.GetInstaller(_manifestResolver.CurrentDirectory, resolutionResult.ResolutionTable, manifest))
{
installer.BeginInstallPackage += BeginInstallPackage;
installer.FinishInstallPackage += FinishInstallPackage;
if (Force)
{
_writer.Text($"Reinstalling {resolutionResult.ResolutionTable.GetPackages().Count()} packages... ");
installer.Reinstall(Configuration);
}
else
{
var diff = installer.GetDiffWithCurrent(resolutionResult.ResolutionTable.GetSatisfyingInfos()).ToArray();
int changed = PrintSuccess(diff);
if (changed > 0)
{
installer.Upgrade(Configuration, diff);
}
else
{
_writer.Success("No changes detected");
}
}
installer.BeginInstallPackage -= BeginInstallPackage;
installer.FinishInstallPackage -= FinishInstallPackage;
}
}
public void SerializePackageManifestRoot(PackageManifestRoot manifestRoot, Stream stream)
{
var xmlManifest = manifestRoot.ToXmlPackageManifestRoot();
_serializer.Write(xmlManifest, stream);
}
public bool Execute()
{
var assembly = Assembly.GetEntryAssembly();
var packageId = "EBerzosa.Pundit";
var assemblyVersion = assembly.GetName().Version;
var minVersion = new NuGet.Versioning.NuGetVersion(assemblyVersion.Major, 0, 0);
var maxVersion = new NuGet.Versioning.NuGetVersion(assemblyVersion.Major + 1, 0, 0);
var manifest = new PackageManifestRoot
{
PackageId = packageId,
Framework = NuGet.Frameworks.NuGetFramework.AgnosticFramework,
Version = new NuGet.Versioning.NuGetVersion(1, 0, 0, 0),
Dependencies =
{
new PackageDependency(packageId, new NuGet.Versioning.VersionRange(minVersion, true, maxVersion))
{
Scope = DependencyScope.Normal
}
}
};
manifest.Validate();
_writer.BeginWrite().Text("Getting repositories...");
var scope = CacheReposOnly ? RepositoryScope.Cache : RepositoryScope.Any;
var repos = _repositoryFactory.TryGetEnabledRepos(scope).ToArray();
if (repos.Length == 0)
{
_writer.Error(" no available repos").EndWrite();
return(false);
}
_writer.Text(" using repos:").EndWrite();
foreach (var repository in repos)
{
_writer.Info(repository.ToString());
}
_writer.BeginWrite().Text("Resolving...");
var resolutionResult = _dependencyResolver.Resolve(manifest, repos, null);
if (resolutionResult.ResolutionTable.HasConflicts)
{
_writer.Error(" failed").EndWrite()
.Empty()
.BeginWrite().Error("Could not resolve manifest due to conflicts...").EndWrite();
PrintConflicts(_dependencyResolver, resolutionResult);
return(false);
}
_writer.Success(" ok").EndWrite();
if (DryRun)
{
return(true);
}
var currentPath = Path.GetDirectoryName(assembly.Location);
if (!Install(resolutionResult, manifest, currentPath, out var oldVersion))
{
return(true);
}
var oldPath = Path.Combine(currentPath, "old", DateTime.Now.ToString("yyyy-MM-dd-hh-mm-ss") + "_" + oldVersion);
var updatePath = Path.Combine(currentPath, "lib");
if (Directory.Exists(oldPath))
{
foreach (var file in Directory.EnumerateFiles(oldPath))
{
File.Delete(file);
}
}
else
{
Directory.CreateDirectory(oldPath);
}
foreach (var originalFile in Directory.EnumerateFiles(currentPath))
{
if (Path.GetFileNameWithoutExtension(originalFile) == string.Empty)
{
continue;
}
File.Move(originalFile, Path.Combine(oldPath, Path.GetFileName(originalFile)));
}
foreach (var newFile in Directory.EnumerateFiles(updatePath))
{
File.Move(newFile, Path.Combine(currentPath, Path.GetFileName(newFile)));
}
Directory.Delete(updatePath, false);
return(true);
}
public static XmlPackageManifestRoot ToXmlPackageManifestRoot(this PackageManifestRoot packageManifestRoot)
{
return(packageManifestRoot.Adapt <XmlPackageManifestRoot>());
}
