/// <summary> /// Releases resources used by the <see cref="T:Microsoft.Perks.Async.Collections.BlockingCollection{T}" /> instance. /// </summary> /// <param name="isDisposing">Whether being disposed explicitly (true) or due to a finalizer (false).</param> protected override void Dispose(bool isDisposing) { if (!_isDisposed) { CompleteAdding(); _blockingEnumerable = null; base.Dispose(isDisposing); _isDisposed = true; } }
protected IEnumerable <PackageProvider> FilterProvidersUsingDynamicParameters(MutableEnumerable <PackageProvider> providers, bool didUserSpecifyProviders, bool didUserSpecifySources) { var excluded = new Dictionary <string, IEnumerable <string> >(); var setparameters = DynamicParameterDictionary.Values.OfType <CustomRuntimeDefinedParameter>().Where(each => each.IsSet).ReEnumerable(); var matchedProviders = (setparameters.Any() ? providers.Where(p => setparameters.All(each => each.Options.Any(opt => opt.ProviderName == p.ProviderName))) : providers).ReEnumerable(); foreach (var provider in matchedProviders) { // if a 'required' parameter is not filled in, the provider should not be returned. // we'll collect these for warnings at the end of the filter. var missingRequiredParameters = DynamicParameterDictionary.Values.OfType <CustomRuntimeDefinedParameter>().Where(each => !each.IsSet && each.IsRequiredForProvider(provider.ProviderName)).ReEnumerable(); if (!missingRequiredParameters.Any()) { yield return(provider); } else { // remember these so we can warn later. excluded.Add(provider.ProviderName, missingRequiredParameters.Select(each => each.Name).ReEnumerable()); } } /* TODO: provide errors in the case where everything got filtered out. Or maybe warnings? * * var mismatchedProviders = (setparameters.Any() ? providers.Where(each => !matchedProviders.Contains(each)).Where(p => setparameters.Any(each => each.Options.Any(opt => opt.ProviderName == p.ProviderName))) : Enumerable.Empty<PackageProvider>()).ReEnumerable(); * * if (!found) { * // we didn't find anything that matched * // they specified dynamic parameters that implicitly select providers * // that don't fit with the providers and sources that they initially asked for. * * if (didUserSpecifyProviders || didUserSpecifySources) { * * if (IsInvocation) { * QueueHeldMessage(() => Error(Errors.ExcludedProvidersDueToMissingRequiredParameter, excluded.Keys, userSpecifiedSources.JoinWithComma())); * } * * yield break; * * } * * if (didUserSpecifySources) { * // user gave sources which implied some providers but the dynamic parameters implied different providers * if (IsInvocation) { * // error * } * // return empty set * return result; * } * * // well, this is silly. * // if the user didn't specify a source or a provider * // but the FilterProvidersUsingDynamicParameters came back empty * // that means that they user specified parameters from two conflicting providers * // and they forced each other out! * * if (IsInvocation) { * // error * * } * * } */ // these warnings only show for providers that would have otherwise be selected. // if not for the missing requrired parameter. foreach (var mp in excluded.OrderBy(each => each.Key)) { Verbose(Constants.Messages.SkippedProviderMissingRequiredOption, mp.Key, mp.Value); } }
/// <summary> /// Provides a blocking AND consuming <see cref="T:System.Collections.Generics.IEnumerable{T}" /> for items in the /// collection. /// Iterating thru the collection will remove the items from the collection. /// </summary> /// <remarks> /// This will remove items as they are returned, and iterating on the collection will block until the collection is /// marked as complete, /// or the cancellation token is cancelled. /// (Think of this as a "Give me what you have" operation.) /// </remarks> /// <param name="cancellationToken"> /// A cancellation token that can be used to stop consuming items and yielding them. /// Upon cancellation, items remaining in the collection will not be removed. /// </param> /// <returns> /// An <see cref="T:System.Collections.Generics.IEnumerable{T}" /> that removes and returns items from the /// collection. /// </returns> public IEnumerable <T> GetBlockingEnumerable(CancellationToken cancellationToken) => _blockingEnumerable ?? (_blockingEnumerable = SafeGetBlockingEnumerable(cancellationToken).ReEnumerable());
private IEnumerable<PackageProvider> FilterProvidersUsingDynamicParameters(MutableEnumerable<PackageProvider> providers, IEnumerable<PackageSource> userSpecifiedRegisteredSources, bool didUserSpecifyProviders, bool didUserSpecifySources) { var excluded = new Dictionary<string, IEnumerable<string>>(StringComparer.OrdinalIgnoreCase); var setparameters = DynamicParameterDictionary.Values.OfType<CustomRuntimeDefinedParameter>().Where(each => each.IsSet).ReEnumerable(); var matchedProviders = (setparameters.Any() ? providers.Where(p => setparameters.All(each => each.Options.Any(opt => opt.ProviderName == p.ProviderName))) : providers).ReEnumerable(); foreach (var provider in matchedProviders) { // if a 'required' parameter is not filled in, the provider should not be returned. // we'll collect these for warnings at the end of the filter. var missingRequiredParameters = DynamicParameterDictionary.Values.OfType<CustomRuntimeDefinedParameter>().Where(each => !each.IsSet && each.IsRequiredForProvider(provider.ProviderName)).ReEnumerable(); if (!missingRequiredParameters.Any()) { yield return provider; } else { Collection<string> missingOptions = new Collection<string>(); foreach (var missingRequiredParameter in missingRequiredParameters) { foreach (var option in missingRequiredParameter.Options) { // remember these so we can warn later. missingOptions.Add(option.Name); } } excluded.Add(provider.ProviderName, missingOptions); } } /* TODO: provide errors in the case where everything got filtered out. Or maybe warnings? * var mismatchedProviders = (setparameters.Any() ? providers.Where(each => !matchedProviders.Contains(each)).Where(p => setparameters.Any(each => each.Options.Any(opt => opt.ProviderName == p.ProviderName))) : Enumerable.Empty<PackageProvider>()).ReEnumerable(); if (!found) { // we didn't find anything that matched // they specified dynamic parameters that implicitly select providers // that don't fit with the providers and sources that they initially asked for. if (didUserSpecifyProviders || didUserSpecifySources) { if (IsInvocation) { QueueHeldMessage(() => Error(Errors.ExcludedProvidersDueToMissingRequiredParameter, excluded.Keys, userSpecifiedSources.JoinWithComma())); } yield break; } if (didUserSpecifySources) { // user gave sources which implied some providers but the dynamic parameters implied different providers if (IsInvocation) { // error } // return empty set return result; } // well, this is silly. // if the user didn't specify a source or a provider // but the FilterProvidersUsingDynamicParameters came back empty // that means that they user specified parameters from two conflicting providers // and they forced each other out! if (IsInvocation) { // error } } */ if (ProviderName != null && ProviderName.Any()) { foreach (var providerName in ProviderName) { if (excluded.ContainsKey(providerName)) { Error(Constants.Errors.SpecifiedProviderMissingRequiredOption, providerName, excluded[providerName].JoinWithComma()); } } } // these warnings only show for providers that would have otherwise be selected. // if not for the missing required parameter. foreach (var mp in excluded.OrderBy(each => each.Key)) { string optionsValue = mp.Value.JoinWithComma(); if (userSpecifiedRegisteredSources.Any()) { var mp1 = mp; //Check if the provider with missing dynamic parameters has been registered with the source provided by a user var sources = userSpecifiedRegisteredSources.Where(source => source.ProviderName != null && source.ProviderName.EqualsIgnoreCase(mp1.Key)); if (didUserSpecifySources && sources.Any()) { //Error out if the provider associated with the -source matches Error(Constants.Errors.SpecifiedProviderMissingRequiredOption, mp.Key, optionsValue); } } Verbose(Constants.Messages.SkippedProviderMissingRequiredOption, mp.Key, optionsValue); } }