protected override void ExecuteTask()
{
if (ProjectFile == null && ProjectDir == null)
throw new ValidationException("Either project or project-dir must be set on <nuget-get-dependencies />.");
string dir = SolutionDir.FullName;
_fileSystem = new PhysicalFileSystem(dir);
string projectDir = ProjectFile == null ? ProjectDir.FullName : ProjectFile.Directory.FullName;
RepositoryFactory = new PackageRepositoryFactory();
SourceProvider = new PackageSourceProvider(new Settings(_fileSystem));
var packagesConfigFiles = Directory.GetFiles(projectDir, Constants.PackageReferenceFile, SearchOption.AllDirectories);
var project = packagesConfigFiles.Select(GetProject)
.Where(p => p.Project != null)
.SingleOrDefault();
if (project == null)
{
throw new BuildException("No project found", Location);
}
string repositoryPath = GetRepositoryPathFromSolution(dir);
IPackageRepository sourceRepository = AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source);
var references = GetReferences(project.PackagesConfigPath, project.Project, repositoryPath, sourceRepository);
var deps = new NuGetDependencies
{
Dependencies = references.Select(GetDependency).ToArray()
};
Project.DataTypeReferences.Add(ReferenceId, deps);
Log(Level.Info, "Found {0} dependencies", deps.Dependencies.Length);
}
public NugetService(Solution solution)
{
//_defaultPackageSource = new PackageSource(NuGetConstants.DefaultFeedUrl);
var factory = new PackageRepositoryFactory();
_remoteRepository = factory.CreateRepository(GalleryUrl);
_localRepository = factory.CreateRepository(solution.PackagesFolder());
_sourceRepository = new AggregateRepository(new[] { _remoteRepository, _localRepository });
_fileSystem = new PhysicalFileSystem(solution.PackagesFolder());
_pathResolver = new DefaultPackagePathResolver(_fileSystem);
_console = new Console();
_packageManager = new PackageManager(_sourceRepository, _pathResolver, _fileSystem, _localRepository){
Logger = _console
};
_packages = new Cache<NugetDependency, IPackage>(dep =>
{
Install(dep);
return _sourceRepository.FindPackage(dep.Name, dep.Version);
});
}
/// <summary>
/// Deletes all files from a package
/// </summary>
/// <param name="installed">Insyalled package</param>
/// <param name="repositories">Repositories where to find the package</param>
private void DeleteFiles(PackageInfo installed, ICollection<string> repositories)
{
Logger.Log("Deleting installed files... ");
var factory = new PackageRepositoryFactory();
IPackage package;
var globalRepo = new AggregateRepository(factory, repositories, true);
package = globalRepo.FindPackage(installed.Name, SemanticVersion.Parse(installed.Version), true, true);
if (package == null)
{
throw new InexistentPackageException(string.Format("Unable to find package {0} version {1}", installed.Name, installed.Version));
}
var fylesystem = new PhysicalFileSystem(installed.InstallationDirectory);
fylesystem.DeleteFiles(package.GetFiles(), installed.InstallationDirectory);
File.Delete(Path.Combine(installed.InstallationDirectory, installed.Name + "." + installed.Version + ".nupkg"));
foreach (var config in Directory.GetFiles(installed.InstallationDirectory, "*.config"))
{
File.Delete(config);
}
Logger.Log("Installed files deleted");
}
public NugetStore(string rootDirectory, string configFile = DefaultConfig, string overrideFile = OverrideConfig)
{
if (rootDirectory == null) throw new ArgumentNullException(nameof(rootDirectory));
if (configFile == null) throw new ArgumentNullException(nameof(configFile));
if (overrideFile == null) throw new ArgumentNullException(nameof(overrideFile));
// First try the override file with custom settings
var configFileName = overrideFile;
var configFilePath = Path.Combine(rootDirectory, configFileName);
if (!File.Exists(configFilePath))
{
// Override file does not exist, fallback to default config file
configFileName = configFile;
configFilePath = Path.Combine(rootDirectory, configFileName);
if (!File.Exists(configFilePath))
{
throw new ArgumentException($"Invalid installation. Configuration file [{configFile}] not found", nameof(configFile));
}
}
rootFileSystem = new PhysicalFileSystem(rootDirectory);
Settings = NuGet.Settings.LoadDefaultSettings(rootFileSystem, configFileName, null);
string installPath = Settings.GetRepositoryPath();
packagesFileSystem = new PhysicalFileSystem(installPath);
packageSourceProvider = new PackageSourceProvider(Settings);
repositoryFactory = new PackageRepositoryFactory();
SourceRepository = packageSourceProvider.CreateAggregateRepository(repositoryFactory, true);
pathResolver = new DefaultPackagePathResolver(packagesFileSystem);
Manager = new PackageManager(SourceRepository, pathResolver, packagesFileSystem);
var mainPackageList = Settings.GetConfigValue(MainPackagesKey);
if (string.IsNullOrWhiteSpace(mainPackageList))
{
throw new InvalidOperationException($"Invalid configuration. Expecting [{MainPackagesKey}] in config");
}
MainPackageIds = mainPackageList.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
VSIXPluginId = Settings.GetConfigValue(VsixPluginKey);
if (string.IsNullOrWhiteSpace(VSIXPluginId))
{
throw new InvalidOperationException($"Invalid configuration. Expecting [{VsixPluginKey}] in config");
}
RepositoryPath = Settings.GetConfigValue(RepositoryPathKey);
if (string.IsNullOrWhiteSpace(RepositoryPath))
{
RepositoryPath = DefaultGamePackagesDirectory;
}
// Setup NugetCachePath in the cache folder
Environment.SetEnvironmentVariable("NuGetCachePath", Path.Combine(rootDirectory, "Cache", RepositoryPath));
}
protected override void ExecuteTask()
{
string dir = SolutionDir.FullName;
_fileSystem = new PhysicalFileSystem(dir);
RepositoryFactory = new PackageRepositoryFactory();
SourceProvider = new PackageSourceProvider(new Settings(_fileSystem));
UpdateAllPackages(dir);
}
/// <summary>
/// Searches all available versions of a package in a list of repostiories
/// </summary>
/// <param name="repositories">Repositories to search</param>
/// <param name="packageName">Pacakge identifier</param>
/// <returns>List of available versions</returns>
public static ICollection<string> Search(ICollection<string> repositories, string packageName)
{
var factory = new PackageRepositoryFactory();
var globalRepo = new AggregateRepository(factory, repositories.Distinct(), true);
var packages = globalRepo.FindPackagesById(packageName);
return packages.Select(x => x.Version)
.OrderByDescending(x => x)
.Select(x => x.ToString())
.ToList()
.Distinct().ToList() ;
}
public int Count(string url, NetworkCredential credential)
{
var uri = new Uri(url);
TestCredentialProvider.Instance.Credentials.Add(uri, credential);
try
{
var repository = new PackageRepositoryFactory().CreateRepository(url);
return repository.GetPackages().Count();
}
finally
{
TestCredentialProvider.Instance.Credentials.Remove(uri);
}
}
public static Stream DownloadDacpac(string packageName, string version, string repository)
{
var factory = new PackageRepositoryFactory();
IPackage package;
var globalRepo = new AggregateRepository(factory,new string[] { repository }, true);
package = globalRepo.FindPackage(packageName, SemanticVersion.Parse(version), true, true);
var files = package.GetFiles();
return files.Single(x => x.Path.EndsWith(".dacpac")).GetStream();
}
public AddInRepository(params AddInSource[] sources)
{
List<PackageSource> packageSources = new List<PackageSource>();
foreach (AddInSource source in sources)
{
PackageSource packageSource = new PackageSource(source.Source,
source.Name,
isEnabled: true,
isOfficial: source.IsOfficial);
packageSources.Add(packageSource);
}
PackageSourceProvider packageSourceProvider = new PackageSourceProvider(new NullSettings(), packageSources);
IPackageRepositoryFactory packageRepositoryFactory = new PackageRepositoryFactory();
// TODO probably turn this off and report proper errors
this._repository = packageSourceProvider.GetAggregate(packageRepositoryFactory,
ignoreFailingRepositories: true);
}
protected override void ExecuteTask()
{
string dir = SolutionDir.FullName;
string repositoryPath = GetRepositoryPathFromSolution(dir);
_fileSystem = new PhysicalFileSystem(dir);
RepositoryFactory = new PackageRepositoryFactory();
SourceProvider = new PackageSourceProvider(new Settings(_fileSystem));
var repo = RepositoryFactory.CreateRepository(repositoryPath);
Log(Level.Debug, "Repo: {0}, Count: {1}", repo.Source, repo.GetPackages().Count());
var fw = VersionUtility.ParseFrameworkName(Framework);
List<string> files = new List<string>(), references = new List<string>();
foreach (var deps in Dependencies)
{
foreach (var dep in deps.Dependencies)
{
var package = repo.FindPackage(dep.Id, dep.VersionSpec, !String.IsNullOrWhiteSpace(dep.VersionSpec.MinVersion.SpecialVersion), false);
if (package == null)
package = repo.FindPackage(dep.Id, dep.VersionSpec, true, false);
if (package == null)
package = repo.FindPackage(dep.Id, dep.VersionSpec, true, true);
if (package == null)
throw new BuildException(String.Format("Can't find package {0} with min version {1}", dep.Id, dep.MinVersion), Location);
string pkgPath = Path.Combine(repositoryPath, package.Id + "." + package.Version);
var package_files = package.GetLibFiles().ToList();
IEnumerable<IPackageFile> compatible_files;
Log(Level.Debug, "Found package {0} with {1} file(s) - {2}", package.Id, package_files.Count, package.GetType());
if (!VersionUtility.TryGetCompatibleItems(fw, package_files, out compatible_files))
throw new BuildException("Couldn't get compatible files.");
foreach (var f in compatible_files)
{
var extension = Path.GetExtension(f.Path);
var path = Path.Combine(pkgPath, f.Path);
Log(Level.Debug, " - Found compatible file {1} ({0}) - {2}", f.Path, f.EffectivePath, path);
if (extension == ".dll" || extension == ".exe")
references.Add(path);
files.Add(path);
}
}
}
if (FilesId != null)
{
PatternSet ps = new PatternSet();
ps.Include.AddRange(files.Select(MakePattern).ToArray());
Project.DataTypeReferences.Add(FilesId, ps);
}
if (ReferencesId != null)
{
PatternSet ps = new PatternSet();
ps.Include.AddRange(references.Select(MakePattern).ToArray());
Project.DataTypeReferences.Add(ReferencesId, ps);
}
Log(Level.Info, "Found {0} file(s) and {1} reference(s)", files.Count, references.Count);
}
private async Task Initialize()
{
var listEndpoints = await GetListEndpointsAsync(_sourceProvider).ConfigureAwait(false);
var repositoryFactory = new PackageRepositoryFactory();
var repositories = listEndpoints
.Select(s => repositoryFactory.CreateRepository(s))
.ToList();
_repository = new AggregateRepository(repositories);
}
/// <summary>
/// Downloads the specified package and installs it in the configured folder
/// </summary>
/// <param name="info">Pacakge informations</param>
private void DownloadPackage(PackageInfo info, ICollection<string> repositories)
{
Logger.Log(String.Format("Downloading package for {0} version {1} ... ", info.Name, info.Version));
var factory = new PackageRepositoryFactory();
IPackage package;
var globalRepo = new AggregateRepository(factory, repositories, true);
package = globalRepo.FindPackage(info.Name, SemanticVersion.Parse(info.Version), true, true);
if (package == null)
{
throw new InexistentPackageException(string.Format("Unable to find package {0} version {1}", info.Name, info.Version));
}
var manager = new PackageManager(
globalRepo,
new CustomPathResolver() { BasePath = info.InstallationDirectory },
new OverWritingPhysicalFilesystem(info.InstallationDirectory));
manager.InstallPackage(package, false, true);
Logger.Log(String.Format("Package for {0} version {1} downloaded ... ", info.Name, info.Version));
}
public static IPackageRepository CreateRepository()
{
IPackageRepositoryFactory factory = new PackageRepositoryFactory();
IPackageRepository repository = factory.CreateRepository(new PackageSource("https://packages.nuget.org/v1/FeedService.svc/", "NuGet.org"));
return repository;
}
/// <summary>
/// Checks for package updates
/// </summary>
/// <returns>
/// The list of operations (if any) that should be applied to the
/// current package or its dependents to bring it up to date
/// </returns>
private IList<PackageOperation> ListOperations()
{
var sourceRepo = new PackageRepositoryFactory().CreateRepository(this.Source);
var localRepo = new PackageRepositoryFactory().CreateRepository(this.RepositoryRoot);
var targetFramework = VersionUtility.ParseFrameworkName(this.TargetFramework);
// locate the current version of the package in the source repository
var pkg = PackageHelper.ResolvePackage(
sourceRepo,
localRepo,
this.PackageID,
null,
false
);
// walk the package, and emit any update operations
var walker = new UpdateWalker(
localRepo,
sourceRepo,
new DependentsWalker(localRepo, targetFramework),
NullConstraintProvider.Instance,
targetFramework,
new Logger(),
true,
false
);
return walker.ResolveOperations(pkg).ToList();
}
