private IEnumerable <SelectionCandidate> GetCandidates(FeedUri feedUri, Feed feed, Requirements requirements)
{
var feedPreferences = FeedPreferences.LoadForSafe(feedUri);
foreach (var element in feed.Elements)
{
var packageImplementation = element as PackageImplementation;
if (packageImplementation != null)
{ // Each <package-implementation> provides 0..n selection candidates
var externalImplementations = _packageManager.Query(packageImplementation, requirements.Distributions.ToArray());
foreach (var externalImplementation in externalImplementations)
{
_externalImplementations[externalImplementation.ID] = externalImplementation;
yield return(new SelectionCandidate(new FeedUri(FeedUri.FromDistributionPrefix + feedUri), feedPreferences, externalImplementation, requirements));
}
}
else if (requirements.Distributions.ContainsOrEmpty(Restriction.DistributionZeroInstall))
{
var implementation = element as Implementation;
if (implementation != null)
{ // Each <implementation> provides 1 selection candidate
yield return(new SelectionCandidate(feedUri, feedPreferences, implementation, requirements,
offlineUncached: (_config.NetworkUse == NetworkLevel.Offline) && !_isCached(implementation)));
}
}
}
}
/// <inheritdoc/>
public void ImportFeed(string path, FeedUri uri, FeedUri mirrorUrl = null)
{
#region Sanity checks
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
#endregion
if (uri.IsFile)
{
throw new UriFormatException(Resources.FeedUriLocal);
}
Log.Debug("Importing feed " + uri.ToStringRfc() + " from: " + path);
var data = File.ReadAllBytes(path);
var newSignature = _trustManager.CheckTrust(data, uri, mirrorUrl);
DetectAttacks(data, uri, newSignature);
// Add to cache and remember time
_feedCache.Add(uri, data);
var preferences = FeedPreferences.LoadForSafe(uri);
preferences.LastChecked = DateTime.UtcNow;
preferences.Normalize();
preferences.SaveFor(uri);
}
private void AddToCache(byte[] data, FeedUri feedUri)
{
_feedCache.Add(feedUri, data);
var preferences = FeedPreferences.LoadForSafe(feedUri);
preferences.LastChecked = DateTime.UtcNow;
preferences.Normalize();
preferences.SaveFor(feedUri);
}
/// <inheritdoc/>
public bool IsStale(FeedUri feedUri)
{
#region Sanity checks
if (feedUri == null)
{
throw new ArgumentNullException(nameof(feedUri));
}
#endregion
var preferences = FeedPreferences.LoadForSafe(feedUri);
TimeSpan lastChecked = DateTime.UtcNow - preferences.LastChecked;
TimeSpan lastCheckAttempt = DateTime.UtcNow - GetLastCheckAttempt(feedUri);
return(lastChecked > _config.Freshness && lastCheckAttempt > _failedCheckDelay);
}
private IEnumerable <SelectionCandidate> GenerateDummyCandidates(FeedUri feedUri)
{
if (feedUri.IsFromDistribution)
{
return(Enumerable.Empty <SelectionCandidate>());
}
try
{
var feed = _feedManager[feedUri];
var feedPreferences = FeedPreferences.LoadForSafe(feedUri);
return(feed.Implementations.Select(implementation => GenerateDummyCandidate(feedUri, feedPreferences, implementation)));
}
#region Error handling
catch (KeyNotFoundException)
{
return(Enumerable.Empty <SelectionCandidate>());
}
#endregion
}
private static void ApplyVersionRestrictions(Requirements requirements, Selections selections)
{
if (requirements.ExtraRestrictions.Count == 0)
{
return;
}
// TODO
Log.Warn($"You have applied a version restriction to this app. Zero Install will continue to apply this restriction to any future updates. You will need to run '0install select --customize {requirements.InterfaceUri}' to undo this.");
foreach (var restriction in requirements.ExtraRestrictions)
{
var selection = selections.GetImplementation(restriction.Key);
if (selection != null)
{
var pref = FeedPreferences.LoadForSafe(restriction.Key);
pref.Implementations.Clear();
pref[selection.ID].UserStability = Stability.Preferred;
pref.SaveFor(restriction.Key);
}
}
}