static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(DependencyResolutionResult resolveResult, ExecutionEnvironment exec, bool includeContentOnly)
{
var packages = resolveResult.Dependencies
.Where(x=> includeContentOnly || !IsInContentBranch(x))
.Select(x => x.Package);
return GetAssemblyReferencesFromPackages(packages, exec);
}
ICommandResult DependencyResolutionFailed(DependencyResolutionResult result)
{
return new Result("Dependency resolution failed.")
{
Success = false
};
}
public static IEnumerable<ICommandOutput> CopyPackagesToRepositories(this IPackageManager manager,
DependencyResolutionResult dependencies,
IEnumerable<IPackageRepository> repositoriesToWriteTo)
{
if (manager == null) throw new ArgumentNullException("manager");
if (dependencies == null) throw new ArgumentNullException("dependencies");
if (repositoriesToWriteTo == null) throw new ArgumentNullException("repositoriesToWriteTo");
if (!dependencies.IsSuccess)
{
yield return DependencyResolutionFailed(dependencies);
yield break;
}
foreach (var dependency in dependencies.Dependencies)
{
// fast forward to the source repository
var repositoriesForDependency = repositoriesToWriteTo
.SkipWhile(x => x != dependency.Package.Source)
.Skip(1)
.ToList();
if (repositoriesForDependency.Count == 0)
repositoriesForDependency = repositoriesToWriteTo.ToList();
foreach (var repository in repositoriesForDependency.Where(x => x != null && x.CanPublish))
{
yield return new Result("Copying '{0}' to '{1}'", dependency.Package.FullName, repository.Name);
manager.UpdateDependency(dependency, repository);
}
}
}
public static void RefreshAnchors(this IPackageRepository repo, DependencyResolutionResult resolvedPackages)
{
var projectRepo = repo as ISupportAnchoring;
if (projectRepo != null)
{
var packagesToAnchor = resolvedPackages.Dependencies
.Where(x => x.Dependency.Anchored || (x.Package != null && x.Package.Anchored))
.Select(x=>x.Package)
.NotNull()
.Where(x=>x.Source == projectRepo).ToList();
projectRepo.VerifyAnchors(packagesToAnchor);
}
}
public DependencyResolutionFailedResult(string message, DependencyResolutionResult result)
{
_message = message;
_result = result;
}
public DependencyResolutionFailedResult(DependencyResolutionResult result)
: this("The following dependencies were not found:", result)
{
Result = result;
}
IEnumerable<ICommandOutput> UpdateSystemPackages()
{
if (!System) yield break;
yield return new Result("Searching for updated packages...");
foreach (var packageToSearch in CreateDescriptorForEachSystemPackage())
{
var sourceRepos = Environment.RemoteRepositories.Concat(Environment.CurrentDirectoryRepository).ToList();
var resolveResult = PackageResolver.TryResolveDependencies(packageToSearch, sourceRepos);
var successful = resolveResult.ResolvedPackages.Where(x => x.Package != null).ToList();
resolveResult = new DependencyResolutionResult { IsSuccess = successful.Count > 0, ResolvedPackages = successful };
if (!resolveResult.IsSuccess)
continue;
foreach (var m in PackageResolver.CopyPackagesToRepositories(resolveResult, Environment.SystemRepository))
if (m is DependencyResolutionFailedResult)
yield return PackageNotFoundInRemote((DependencyResolutionFailedResult)m);
else
yield return m;
foreach (var m in VerifyPackageCache(packageToSearch)) yield return m;
}
}
IEnumerable<ICommandOutput> FailedUpdate(DependencyResolutionResult resolvedPackages, IEnumerable<IPackageRepository> sourceRepos)
{
foreach(var notFoundPackage in resolvedPackages.ResolvedPackages.Where(x=>x.Package == null))
yield return new DependenciesNotFoundInRepositories(notFoundPackage.Dependencies, sourceRepos);
var conflictingDependencies = resolvedPackages.ResolvedPackages
.Where(x => x.Package != null)
.GroupBy(x => x.Package.Name, StringComparer.OrdinalIgnoreCase)
.Where(x => x.Count() > 1);
if (conflictingDependencies.Count() > 0)
yield return new DependenciesConflictMessage(conflictingDependencies.ToList());
}
IEnumerable<PackageOperationResult> ReturnError(DependencyResolutionResult resolvedPackages)
{
return resolvedPackages.DiscardedPackages.Select(PackageConflict)
.Concat(resolvedPackages.MissingPackages.Select(PackageMissing));
}
IEnumerable<PackageOperationResult> CopyPackagesToRepositories(IEnumerable<IPackageRepository> sourceRepositories,
DependencyResolutionResult resolvedPackages,
IEnumerable<IPackageRepository> destinationRepositories)
{
var publishingRepos = destinationRepositories.NotNull().OfType<ISupportPublishing>().ToList();
foreach (var foundPackage in resolvedPackages.SuccessfulPackages)
{
foreach (var destinationRepository in publishingRepos)
{
var existingUpToDateVersion = GetExistingPackage(destinationRepository, foundPackage, x => x >= foundPackage.Identifier.Version);
if (existingUpToDateVersion == null)
{
var sourcePackage = GetBestSourcePackage(sourceRepositories, foundPackage.Packages);
_deployer.DeployDependency(sourcePackage, destinationRepository);
var existingVersion = GetExistingPackage(destinationRepository, foundPackage, x => x < foundPackage.Identifier.Version);
yield return existingVersion == null
? new PackageAddedResult(sourcePackage, destinationRepository)
: new PackageUpdatedResult(existingVersion, sourcePackage, destinationRepository);
}
else
{
yield return new PackageUpToDateResult(existingUpToDateVersion, destinationRepository);
}
}
}
foreach (var repo in publishingRepos)
repo.PublishCompleted();
}
static IEnumerable<PackageAnchoredResult> AnchorPackages(DependencyResolutionResult resolvedPackages, IEnumerable<IPackageRepository> destinationRepositories)
{
return from repo in destinationRepositories.OfType<ISupportAnchoring>()
from successfulPackage in resolvedPackages.SuccessfulPackages
where successfulPackage.IsAnchored
let packageInstances = from packageInstance in successfulPackage.Packages
where packageInstance != null &&
packageInstance.Source == repo
select packageInstance
from anchorResult in repo.AnchorPackages(packageInstances)
select anchorResult;
}
//public IEnumerable<SystemPackage> SystemDependencies { get { return Environment.SystemRepository.PackagesByName.Select(x => new SystemPackage(x.Key, x)); } }
public WrapSlice(string noun, IEnumerable<VerbSlice> commandDescriptors) : base(noun, commandDescriptors)
{
if (Environment != null && Environment.ProjectRepository != null)
{
ProjectDependencies = PackageResolver.TryResolveDependencies(Environment.Descriptor, new[] { Environment.ProjectRepository });
}
}
static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(DependencyResolutionResult resolveResult, ExecutionEnvironment exec, bool includeContentOnly)
{
var packages = resolveResult.SuccessfulPackages.Where(resolvedPackage => includeContentOnly || !resolvedPackage.IsInContentBranch).SelectMany(x=>x.Packages);
return GetAssemblyReferencesFromPackages(packages, exec);
}
public static IEnumerable<ICommandOutput> CopyPackagesToRepositories(this IPackageManager manager, DependencyResolutionResult dependencies, params IPackageRepository[] repositories)
{
return CopyPackagesToRepositories(manager, dependencies, (IEnumerable<IPackageRepository>)repositories);
}