private void GetPackageRepository(INuGetSource source, Action <IPackageRepository> processor)
{
using (CredentialsUpdater.UpdateCredentialsProvider(source))
{
processor(RepositoryFactoryTC.CreateRepository(source.Source));
}
}
public void Multiple_Credentials_Multiple()
{
var sources = new INuGetSource[]
{
new NuGetSource
{
Source = "http://foo",
Username = "******",
Password = "******"
},
new NuGetSource
{
Source = "https://another-feed",
Username = "******",
Password = "******"
},
};
var p = new TeamCityMultipleCredentialProvider(sources);
AssertAuth(p, username: "******", password: "******", url: "http://foo");
AssertAuth(p, username: "******", password: "******", url: "http://foo/");
AssertAuth(p, username: "******", password: "******", url: "https://another-feed");
AssertAuth(p, username: null, url: "https://the-other");
}
private void ProcessPackageSource(INuGetSource source, List <INuGetPackage> request)
{
//todo: optimize query to return only required set of versions.
foreach (var req in new[]
{
new { Data = request.Where(x => x.VersionSpec == null && x.IncludePrerelease).ToArray(), FetchOption = PackageFetchOption.IncludeLatestAndPrerelease },
new { Data = request.Where(x => x.VersionSpec == null && !x.IncludePrerelease).ToArray(), FetchOption = PackageFetchOption.IncludeLatest },
new { Data = request.Where(x => x.VersionSpec != null).ToArray(), FetchOption = PackageFetchOption.IncludeAll }
})
{
try
{
ProcessPackages(source, req.FetchOption, req.Data);
}
catch (Exception e)
{
foreach (var pkg in req.Data)
{
pkg.AddError(e.Message);
}
System.Console.Out.WriteLine("Failed to check package sources information for URI {0}. {1}", source, e.Message);
System.Console.Out.WriteLine(e);
}
}
}
public IDisposable UpdateCredentialsProvider([NotNull] INuGetSource source)
{
if (!source.HasCredentials)
{
return(Noop);
}
return(UpdateCredentialsProvider(new TeamCitySingleCredentialProvider(source)));
}
private void ProcessPackageSource(INuGetSource source, List <INuGetPackage> request)
{
//todo: optimize query to return only required set of versions.
foreach (var req in new[]
{
new { Data = request.Where(x => x.VersionSpec == null && x.IncludePrerelease).ToArray(), FetchOption = PackageFetchOption.IncludeLatestAndPrerelease },
new { Data = request.Where(x => x.VersionSpec == null && !x.IncludePrerelease).ToArray(), FetchOption = PackageFetchOption.IncludeLatest },
new { Data = request.Where(x => x.VersionSpec != null).ToArray(), FetchOption = PackageFetchOption.IncludeAll }
})
{
try
{
ProcessPackages(source, req.FetchOption, req.Data);
}
catch (Exception e)
{
string message;
var aggregateException = e as AggregateException;
if (aggregateException != null)
{
var ae = aggregateException;
ae.Flatten();
var stringBuilder = new StringBuilder();
foreach (var exception in ae.InnerExceptions)
{
stringBuilder.AppendLine(exception.Message);
}
message = stringBuilder.ToString();
}
else
{
message = e.Message;
}
foreach (var pkg in req.Data)
{
pkg.AddError(message);
}
System.Console.Error.WriteLine("Failed to check package sources information for {0}: {1}", source, message);
System.Console.Out.WriteLine(e);
}
}
}
private static void ValidateSourceUrl(INuGetSource feed)
{
string source = feed.Source;
Uri uri;
try
{
uri = new Uri(source);
}
catch (Exception e)
{
throw new InvalidFeedUrlException(source, e.Message);
}
if (uri.IsFile && !Directory.Exists(uri.LocalPath))
{
throw new InvalidFeedUrlException(source, "Local path does not exist: " + uri.LocalPath);
}
}
/// <exception cref="InvalidFeedUrlException">may be thrown on error</exception>
protected void GetAllPackages(INuGetSource feed,
PackageFetchOption fetchOption,
IEnumerable <string> ids,
Action <IPackage> processor)
{
System.Console.Out.WriteLine("Checking packages on source: {0}", feed);
ValidateSourceUrl(feed);
var repo = RepositoryFactoryTC.CreateRepository(feed.Source);
var param = Expression.Parameter(typeof(IPackage));
Expression filter = QueryBuilder.GenerateQuery(fetchOption, ids, param);
var filtered = repo.GetPackages().Where(Expression.Lambda <Func <IPackage, bool> >(filter, param));
foreach (var package in filtered)
{
processor(package);
}
}
private void ProcessPackages(INuGetSource source, PackageFetchOption fetchOptions, IEnumerable <INuGetPackage> package)
{
var packageToData = package
.GroupBy(x => x.Id, Id, PACKAGE_ID_COMPARER)
.ToDictionary(x => x.Key, Id, PACKAGE_ID_COMPARER);
if (packageToData.Count == 0)
{
return;
}
var count = 0;
GetAllPackages(source,
fetchOptions,
packageToData.Keys,
p =>
{
count++;
IGrouping <string, INuGetPackage> res;
if (!packageToData.TryGetValue(p.Id, out res))
{
return;
}
foreach (var r in res)
{
if (!r.VersionChecker(p))
{
continue;
}
r.AddEntry(new NuGetPackageEntry {
Version = p.VersionString()
});
}
});
System.Console.Out.WriteLine("Scanned {0} packages for feed {1}", count, source);
}
private INuGetSource SetObservedFeed(IEnumerable <INuGetSource> feeds, INuGetSource defaultFeed)
{
var lastSelectedSourceName = (_configurationService as IConfigurationService)?.GetLastRepository("Browse") ?? string.Empty;
return(feeds.FirstOrDefault(x => string.Equals(x.Name, lastSelectedSourceName)) ?? defaultFeed);
}
private void GetPackageRepository(INuGetSource source, Action <IPackageRepository> processor)
{
processor(RepositoryFactoryTC.CreateRepository(source.Source));
}
public TeamCitySingleCredentialProvider(INuGetSource source, ICredentialProvider next = null)
{
mySource = source;
myNext = next;
}
