private static ISecretInjector GetSecretInjector(IDictionary<string, string> arguments)
        {
            ISecretReader secretReader;

            var vaultName = arguments.GetOrDefault<string>(Arguments.VaultName);
            if (string.IsNullOrEmpty(vaultName))
            {
                secretReader = new EmptySecretReader();
            }
            else
            {
                var clientId = arguments.GetOrThrow<string>(Arguments.ClientId);
                var certificateThumbprint = arguments.GetOrThrow<string>(Arguments.CertificateThumbprint);
                var storeName = arguments.GetOrDefault(Arguments.StoreName, StoreName.My);
                var storeLocation = arguments.GetOrDefault(Arguments.StoreLocation, StoreLocation.LocalMachine);
                var shouldValidateCert = arguments.GetOrDefault(Arguments.ValidateCertificate, false);

                var keyVaultConfig = new KeyVaultConfiguration(vaultName, clientId, certificateThumbprint, storeName, storeLocation, shouldValidateCert);

                secretReader = new CachingSecretReader(new KeyVaultReader(keyVaultConfig),
                    arguments.GetOrDefault(Arguments.RefreshIntervalSec, CachingSecretReader.DefaultRefreshIntervalSec));
            }

            return new SecretInjector(secretReader);
        }
        protected override void Init(IDictionary <string, string> arguments, CancellationToken cancellationToken)
        {
            var gallery            = arguments.GetOrThrow <string>(Arguments.Gallery);
            var index              = arguments.GetOrThrow <string>(Arguments.Index);
            var packageBaseAddress = arguments.GetOrThrow <string>(Arguments.ContentBaseAddress);
            var source             = arguments.GetOrThrow <string>(Arguments.Source);
            var requireSignature   = arguments.GetOrDefault(Arguments.RequireSignature, false);
            var verbose            = arguments.GetOrDefault(Arguments.Verbose, false);

            CommandHelpers.AssertAzureStorage(arguments);

            var monitoringStorageFactory = CommandHelpers.CreateStorageFactory(arguments, verbose);
            var auditingStorageFactory   = CommandHelpers.CreateSuffixedStorageFactory("Auditing", arguments, verbose);

            var endpointInputs        = CommandHelpers.GetEndpointFactoryInputs(arguments);
            var messageHandlerFactory = CommandHelpers.GetHttpMessageHandlerFactory(TelemetryService, verbose);

            Logger.LogInformation(
                "CONFIG gallery: {Gallery} index: {Index} storage: {Storage} auditingStorage: {AuditingStorage} endpoints: {Endpoints}",
                gallery, index, monitoringStorageFactory, auditingStorageFactory, string.Join(", ", endpointInputs.Select(e => e.Name)));

            _packageValidator = new PackageValidatorFactory(LoggerFactory)
                                .Create(gallery, index, packageBaseAddress, auditingStorageFactory, endpointInputs, messageHandlerFactory, requireSignature, verbose);

            _queue = CommandHelpers.CreateStorageQueue <PackageValidatorContext>(arguments, PackageValidatorContext.Version);

            _statusService = CommandHelpers.GetPackageMonitoringStatusService(arguments, monitoringStorageFactory, LoggerFactory);

            _notificationService = new LoggerMonitoringNotificationService(LoggerFactory.CreateLogger <LoggerMonitoringNotificationService>());

            _regResource = Repository.Factory.GetCoreV3(index).GetResource <RegistrationResourceV3>(cancellationToken);

            _client = new CollectorHttpClient(messageHandlerFactory());
        }
        public override async Task Run(IDictionary<string, string> arguments, CancellationToken cancellationToken)
        {
            var intervalSec = arguments.GetOrDefault(Arguments.Interval, Arguments.DefaultInterval);
            Logger.LogInformation("Looping job at interval {Interval} seconds.", intervalSec);

            // It can be expensive to initialize, so don't initialize on every run.
            // Remember the last time we initialized, and only reinitialize if a specified interval has passed since then.
            DateTime? timeLastInitialized = null;
            do
            {
                var timeMustReinitialize = DateTime.UtcNow.Subtract(new TimeSpan(0, 0, 0,
                    arguments.GetOrDefault(Arguments.ReinitializeIntervalSec, Arguments.DefaultReinitializeIntervalSec)));

                if (!timeLastInitialized.HasValue || timeLastInitialized.Value <= timeMustReinitialize)
                {
                    Logger.LogInformation("Initializing job.");
                    Init(arguments, cancellationToken);
                    timeLastInitialized = timeMustReinitialize;
                }

                Logger.LogInformation("Running job.");
                await RunInternal(cancellationToken);
                Logger.LogInformation("Job finished!");
                Logger.LogInformation("Waiting {Interval} seconds before starting job again.", intervalSec);
                await Task.Delay(intervalSec * 1000, cancellationToken);
            } while (true);
        }
        /// <summary>
        /// Set the headers using the configuration data.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="extensionForContent"></param>
        /// <param name="config"></param>
        /// <param name="configSectionName"></param>
        /// <param name="hashcode"></param>
        public static void SetHeaders(HttpContext context, string extensionForContent, IDictionary config, string configSectionName, int hashcode)
        {
            bool isCachable = config == null ? true : config.GetOrDefault <bool>(configSectionName, "CacheEnabledOnClientSide", true);

            context.Response.ContentType = extensionForContent;
            context.Response.Cache.VaryByHeaders["Accept-Encoding"] = true;

            if (isCachable)
            {
                int maxDaysCached = config == null ? 10 : config.GetOrDefault <int>(configSectionName, "CacheDurationInDays", 10);
                context.Response.Cache.SetCacheability(HttpCacheability.Public);
                context.Response.Cache.SetExpires(DateTime.Now.ToUniversalTime().AddDays(maxDaysCached));
                context.Response.Cache.SetMaxAge(new TimeSpan(maxDaysCached, 0, 0, 0));

                string eTag         = "\"" + hashcode.ToString() + "\"";
                string existingEtag = context.Request.Headers["If-None-Match"];
                context.Response.Cache.SetETag(eTag);

                if (String.Compare(existingEtag, eTag) == 0)
                {
                    context.Response.Clear();
                    context.Response.StatusCode      = (int)System.Net.HttpStatusCode.NotModified;
                    context.Response.SuppressContent = true;
                }
            }
        }
        protected override void Init(IDictionary<string, string> arguments, CancellationToken cancellationToken)
        {
            _directory = CommandHelpers.GetLuceneDirectory(arguments);
            _source = arguments.GetOrThrow<string>(Arguments.Source);
            _verbose = arguments.GetOrDefault(Arguments.Verbose, false);

            _registration = arguments.GetOrDefault<string>(Arguments.Registration);
            if (_registration == null)
            {
                Logger.LogInformation("Lucene index will be created up to the end of the catalog (alternatively if you provide a registration it will not pass that)");
            }

            _catalogBaseAddress = arguments.GetOrDefault<string>(Arguments.CatalogBaseAddress);
            if (_catalogBaseAddress == null)
            {
                Logger.LogInformation("No catalogBaseAddress was specified so the Lucene index will NOT contain the storage paths");
            }

            _storageBaseAddress = arguments.GetOrDefault<string>(Arguments.StorageBaseAddress);

            Logger.LogInformation("CONFIG source: \"{ConfigSource}\" registration: \"{Registration}\"" +
                                   " catalogBaseAddress: \"{CatalogBaseAddress}\" storageBaseAddress: \"{StorageBaseAddress}\"",
                                   _source,
                                   _registration ?? "(null)",
                                   _catalogBaseAddress ?? "(null)",
                                   _storageBaseAddress ?? "(null)");

            _handlerFunc = CommandHelpers.GetHttpMessageHandlerFactory(_verbose, _catalogBaseAddress, _storageBaseAddress);
        }
Exemple #6
0
        public static void Main(string[] args)
        {
            _arguments = ArgumentsFactory.ArgumentsAsDictionary(args);

            const string defaultFunction = "logic";
            var          function        = _arguments.GetOrDefault("func", defaultFunction);

            var defaultInput = function + "-input.txt";
            var input        = _arguments.GetOrDefault("file", defaultInput);

            input = "TestInputs/logic02simple.txt";

            if (input == null)
            {
                ExitWithMsg("No input file specified");
            }
            else if (!File.Exists(input))
            {
                ExitWithMsg("Input file does not exist: " + input);
            }

            if (function == "path")
            {
                PathPlanning(input);
            }
            else if (function == "logic")
            {
                Inference(input);
            }
            else
            {
                ExitWithMsg("Invalid function specified, valid values are: 'path' and 'logic'");
            }
        }
        public void InsertNewEdition(string sourceName, string name, bool hasFoil, string code, int?idBlock, int?blockPosition, int?cardNumber, DateTime?releaseDate, byte[] icon)
        {
            using (new WriterLock(_lock))
            {
                IEdition edition = GetEdition(sourceName);
                if (edition == null)
                {
                    Edition realEdition = new Edition
                    {
                        Name          = name,
                        GathererName  = sourceName,
                        Completed     = false,
                        HasFoil       = hasFoil,
                        Code          = code,
                        IdBlock       = idBlock,
                        BlockPosition = idBlock.HasValue ? blockPosition : null,
                        CardNumber    = cardNumber,
                        ReleaseDate   = releaseDate
                    };
                    if (realEdition.IdBlock.HasValue)
                    {
                        realEdition.Block = _blocks.GetOrDefault(realEdition.IdBlock.Value);
                    }

                    AddToDbAndUpdateReferential(realEdition, InsertInReferential);
                }
                InsertNewTreePicture(name, icon);
            }
        }
Exemple #8
0
        private void CheckInfos(IDictionary <string, string> infos)
        {
            if (!infos.ContainsKey(NameKey))
            {
                throw new ParserException("No name found");
            }

            if (!infos.ContainsKey(TypeKey))
            {
                throw new ParserException("No type found");
            }

            if (!infos.ContainsKey(RarityKey))
            {
                throw new ParserException("No rarity found");
            }

            string type        = infos.GetOrDefault(TypeKey);
            string castingcost = infos.GetOrDefault(ManaCostKey);

            //Add check on casting cost because of second face of Garruk, the Veil-Cursed which has no loyalty counter
            if ((MagicRules.IsCreature(type) || MagicRules.IsPlaneswalker(type) || MagicRules.IsVehicle(type)) && !infos.ContainsKey(PTKey) && !string.IsNullOrWhiteSpace(castingcost))
            {
                throw new ParserException("No PT/Loyalty found");
            }
        }
Exemple #9
0
            public object TestActionE(IDictionary <string, object> param)
            {
                var name = param.GetOrDefault <string>("name");
                var age  = param.GetOrDefault <int>("age");

                return(new { name, age });
            }
        private static ISecretInjector GetSecretInjector(IDictionary <string, string> arguments)
        {
            ISecretReader secretReader;

            var vaultName = arguments.GetOrDefault <string>(Arguments.VaultName);

            if (string.IsNullOrEmpty(vaultName))
            {
                secretReader = new EmptySecretReader();
            }
            else
            {
                var clientId = arguments.GetOrThrow <string>(Arguments.ClientId);
                var certificateThumbprint = arguments.GetOrThrow <string>(Arguments.CertificateThumbprint);
                var storeName             = arguments.GetOrDefault(Arguments.StoreName, StoreName.My);
                var storeLocation         = arguments.GetOrDefault(Arguments.StoreLocation, StoreLocation.LocalMachine);
                var shouldValidateCert    = arguments.GetOrDefault(Arguments.ValidateCertificate, true);

                var keyVaultCertificate = CertificateUtility.FindCertificateByThumbprint(storeName, storeLocation, certificateThumbprint, shouldValidateCert);
                var keyVaultConfig      = new KeyVaultConfiguration(vaultName, clientId, keyVaultCertificate);

                secretReader = new CachingSecretReader(new KeyVaultReader(keyVaultConfig),
                                                       arguments.GetOrDefault(Arguments.RefreshIntervalSec, CachingSecretReader.DefaultRefreshIntervalSec));
            }

            return(new SecretInjector(secretReader));
        }
        internal DateTime?LastShown(string decisionPoint)
        {
            Validate(decisionPoint);

            return(values.GetOrDefault(
                       decisionPoint + LAST_SHOWN,
                       (DateTime?)null));
        }
 protected override void Init(IDictionary<string, string> arguments, CancellationToken cancellationToken)
 {
     _gallery = arguments.GetOrThrow<string>(Arguments.Gallery);
     _verbose = arguments.GetOrDefault(Arguments.Verbose, false);
     _id = arguments.GetOrThrow<string>(Arguments.Id);
     _version = arguments.GetOrDefault<string>(Arguments.Version);
     _storageFactory = CommandHelpers.CreateStorageFactory(arguments, _verbose);
 }
Exemple #13
0
            public static ModuleInfo CreateFrom(IDictionary <string, object> dictionary)
            {
                var component = (RobotComponentType)dictionary.GetOrDefault <int>(k.component);
                var slot      = dictionary.GetOrDefault <int>(k.slot);
                var module    = EntityDefault.Get(dictionary.GetOrDefault <int>(k.module));
                var ammo      = EntityDefault.Get(dictionary.GetOrDefault <int>(k.ammo));

                return(new ModuleInfo(component, slot, module, ammo));
            }
Exemple #14
0
 public void PopulateFrom(IDictionary <string, object> prop)
 {
     Name    = prop.GetOrDefault <string>("name");
     Country = prop.GetOrDefault <string>("country");
     Place   = prop.GetOrDefault <string>("place");
     ClubId  = prop.GetOrDefault <long>("club_id");
     Access  = prop.GetOrDefault <string>("access");
     Members = ParseMembers(prop["members"]);
 }
Exemple #15
0
        private async Task UpdateBookAsync(BookDto book, IDictionary <string, object> input)
        {
            EditingBookDto.Name        = input.GetOrDefault("Name") == null ? book.Name : input.GetOrDefault("Name").ToString();
            EditingBookDto.Price       = input.GetOrDefault("Price") == null ? book.Price : (float)input.GetOrDefault("Price");
            EditingBookDto.PublishDate = input.GetOrDefault("PublishDate") == null ? book.PublishDate : (DateTime)input.GetOrDefault("PublishDate");
            await BookAppService.UpdateAsync(book.Id, EditingBookDto);

            await GetBooksAsync();
        }
        /// <summary>
        /// 创建表单字段属性
        /// </summary>
        public FormFieldAttribute Create(IDictionary <string, object> fieldData)
        {
            var name  = fieldData.GetOrDefault <string>("Name");
            var group = fieldData.GetOrDefault <string>("Group");

            return(new HiddenFieldAttribute(name)
            {
                Group = group
            });
        }
Exemple #17
0
        private async Task CreateBookAsync(IDictionary <string, object> input)
        {
            NewBookDto.Name        = input.GetOrDefault("Name").ToString();
            NewBookDto.Price       = (float)input.GetOrDefault("Price");
            NewBookDto.PublishDate = (DateTime)input.GetOrDefault("PublishDate");
            Console.WriteLine(input.GetOrDefault("Type") == null ? "null" : input.GetOrDefault("Type"));
            await BookAppService.CreateAsync(NewBookDto);

            await GetBooksAsync();
        }
Exemple #18
0
        /// <summary>
        /// 获取用户标识
        /// </summary>
        /// <param name="payload">负载列表</param>
        private string GetUserId(IDictionary <string, string> payload)
        {
            var userId = payload.GetOrDefault(IdentityModel.JwtClaimTypes.Subject, string.Empty);

            if (userId.IsEmpty())
            {
                userId = payload.GetOrDefault(System.Security.Claims.ClaimTypes.NameIdentifier, string.Empty);
            }
            return(userId);
        }
        /// <summary>
        /// 生成长度验证属性
        /// </summary>
        public Attribute Create(IDictionary <string, object> validatorData)
        {
            var maximumLength = validatorData.GetOrDefault <int>("MaximumLength");
            var minimumLength = validatorData.GetOrDefault <int>("MinimumLength");

            return(new StringLengthAttribute(maximumLength)
            {
                MinimumLength = minimumLength
            });
        }
 private static Uri ExtractUrl(IDictionary<string, string> args)
 {
     Uri url = new UriBuilder()
     {
         Scheme = args.GetOrDefault("protocol", "https"),
         Host = args.GetOrDefault("host", "no-host.git"),
         Path = args.GetOrDefault("path", "/")
     }.Uri;
     return url;
 }
 public static ServerInfo Deserialize(IDictionary <string, object> dictionary)
 {
     return(new ServerInfo
     {
         Name = dictionary.GetOrDefault <string>(k.name),
         Description = dictionary.GetOrDefault <string>(k.description),
         Contact = dictionary.GetOrDefault <string>(k.contact),
         IsOpen = dictionary.GetOrDefault <int>(k.isOpen) == 1,
         IsBroadcast = dictionary.GetOrDefault <int>(k.isBroadcast) == 1,
     });
 }
Exemple #22
0
        /// <summary>
        /// 创建表单字段属性
        /// </summary>
        public FormFieldAttribute Create(IDictionary <string, object> fieldData)
        {
            var name        = fieldData.GetOrDefault <string>("Name");
            var placeHolder = fieldData.GetOrDefault <string>("PlaceHolder");
            var group       = fieldData.GetOrDefault <string>("Group");

            return(new TextBoxFieldAttribute(name, placeHolder)
            {
                Group = group
            });
        }
        public static Punctuation CharToPunctuation(char c)
        {
            var punctuation = PunctuationsByChar.GetOrDefault(c);

            if (punctuation == default)
            {
                throw new ArgumentOutOfRangeException(nameof(c), $"'{c}' is not a known punctuation character.");
            }

            return(punctuation);
        }
        /// <summary>
        /// 创建表单字段属性
        /// </summary>
        public FormFieldAttribute Create(IDictionary <string, object> fieldData)
        {
            var name  = fieldData.GetOrDefault <string>("Name");
            var path  = fieldData.GetOrDefault <string>("Path");
            var group = fieldData.GetOrDefault <string>("Group");

            return(new TemplateHtmlFieldAttribute(name, path)
            {
                Group = group
            });
        }
        protected override void Init(IDictionary <string, string> arguments, CancellationToken cancellationToken)
        {
            _gallery = arguments.GetOrThrow <string>(Arguments.Gallery);
            _verbose = arguments.GetOrDefault(Arguments.Verbose, false);
            _id      = arguments.GetOrThrow <string>(Arguments.Id);
            _version = arguments.GetOrDefault <string>(Arguments.Version);

            var storageFactory = CommandHelpers.CreateStorageFactory(arguments, _verbose);

            _storage = storageFactory.Create();
        }
Exemple #26
0
        protected override void Init(IDictionary <string, string> arguments, CancellationToken cancellationToken)
        {
            PrintLightning();

            // Hard code against Azure storage.
            arguments[Arguments.StorageType] = Arguments.AzureStorageType;

            // Configure the package path provider.
            var useFlatContainerAsPackageContent = arguments.GetOrDefault <bool>(Arguments.ContentIsFlatContainer, false);

            if (!useFlatContainerAsPackageContent)
            {
                RegistrationMakerCatalogItem.PackagePathProvider = new PackagesFolderPackagePathProvider();
            }
            else
            {
                var flatContainerName = arguments.GetOrThrow <string>(Arguments.FlatContainerName);
                RegistrationMakerCatalogItem.PackagePathProvider = new FlatContainerPackagePathProvider(flatContainerName);
            }

            _command            = arguments.GetOrThrow <string>(Arguments.Command);
            _verbose            = arguments.GetOrDefault(Arguments.Verbose, false);
            _log                = _verbose ? Console.Out : new StringWriter();
            _contentBaseAddress = arguments.GetOrThrow <string>(Arguments.ContentBaseAddress);
            _galleryBaseAddress = arguments.GetOrThrow <string>(Arguments.GalleryBaseAddress);
            _storageFactories   = CommandHelpers.CreateRegistrationStorageFactories(arguments, _verbose);
            _shouldIncludeSemVer2ForLegacyStorageFactory = RegistrationCollector.GetShouldIncludeRegistrationPackageForLegacyStorageFactory(_storageFactories.SemVer2StorageFactory);
            _postProcessGraphForLegacyStorageFactory     = RegistrationCollector.GetPostProcessGraphForLegacyStorageFactory(_storageFactories.SemVer2StorageFactory);
            _forceIconsFromFlatContainer = arguments.GetOrDefault <bool>(Arguments.AllIconsInFlatContainer);
            _driver = arguments.GetOrDefault(Arguments.Driver, GraphDriver).ToLowerInvariant();
            // We save the arguments because the "prepare" command generates "strike" commands. Some of the arguments
            // used by "prepare" should be used when executing "strike".
            _arguments = arguments;

            if (_driver != GraphDriver && _driver != JsonDriver)
            {
                throw new NotSupportedException($"The lightning driver '{_driver}' is not supported.");
            }

            switch (_command.ToLowerInvariant())
            {
            case "charge":
            case "prepare":
                InitPrepare(arguments);
                break;

            case "strike":
                InitStrike(arguments);
                break;

            default:
                throw new NotSupportedException($"The lightning command '{_command}' is not supported.");
            }
        }
        /// <summary>
        /// 创建表单字段属性
        /// </summary>
        public FormFieldAttribute Create(IDictionary <string, object> fieldData)
        {
            var name       = fieldData.GetOrDefault <string>("Name");
            var type       = fieldData.GetOrDefault <string>("Type");
            var group      = fieldData.GetOrDefault <string>("Group");
            var sourceType = Type.GetType(type, true);

            return(new DropdownListFieldAttribute(name, sourceType)
            {
                Group = group
            });
        }
Exemple #28
0
 public static MssgsMessage Parse(IDictionary <string, string> data, bool newMessage)
 {
     return(new MssgsMessage(
                data["message"],
                data["conversation"],
                Convert.ToInt32(data["date"]),
                data["username"],
                data.GetOrDefault("op").ToBoolean(),
                data.GetOrDefault("internal").ToBoolean(),
                newMessage
                ));
 }
        /// <summary>
        /// 创建表单字段属性
        /// </summary>
        public FormFieldAttribute Create(IDictionary <string, object> fieldData)
        {
            var name              = fieldData.GetOrDefault <string>("Name");
            var extensions        = fieldData.GetOrDefault <string>("Extensions");
            var maxContentsLength = fieldData.GetOrDefault <int>("MaxContentsLength");
            var group             = fieldData.GetOrDefault <string>("Group");

            return(new FileUploaderFieldAttribute(name, extensions, maxContentsLength)
            {
                Group = group
            });
        }
        /// <summary>
        /// 创建表单字段属性
        /// </summary>
        public FormFieldAttribute Create(IDictionary <string, object> fieldData)
        {
            var name            = fieldData.GetOrDefault <string>("Name");
            var config          = fieldData.GetOrDefault <string>("Config");
            var imageBrowserUrl = fieldData.GetOrDefault <string>("ImageBrowserUrl");
            var group           = fieldData.GetOrDefault <string>("Group");

            return(new RichTextEditorAttribute(name, config)
            {
                ImageBrowserUrl = imageBrowserUrl, Group = group
            });
        }
        internal void Associate(CefBrowser browser, CefFrame frame, CefV8Context context)
        {
            var webView = new CefV8_WebView(context, context.GetTaskRunner());
            var taskCompletionSource = _TaskCompletionSources.GetOrDefault(frame.Identifier);

            if (taskCompletionSource != null)
            {
                _TaskCompletionSources.Remove(frame.Identifier);
                taskCompletionSource.TrySetResult(webView);
            }
            _Associated.Add(frame.Identifier, webView);
        }
Exemple #32
0
        public static Binding CreateFromDictionary(IDictionary<string, string> dict)
        {
            var binding = new Binding();

            // Parse the enums first
            BindingMode mode;
            if (Enum.TryParse(dict.GetOrDefault("Mode"), out mode)) binding.Mode = mode;

            RelativeSourceMode sourceMode;
            if (Enum.TryParse(dict.GetOrDefault("RelativeSource"), out sourceMode))
            {
                binding.RelativeSource = new RelativeSource
                {
                    Mode = sourceMode
                };
            }

            UpdateSourceTrigger trigger;
            if (Enum.TryParse(dict.GetOrDefault("UpdateSourceTrigger"), out trigger))
            {
                binding.UpdateSourceTrigger = trigger;
            }

            // Then the other stuff
            // var converter = SOMETHING;
            var converterLanguage = dict.GetOrDefault("ConverterLanguage");
            var converterParameter = dict.GetOrDefault("ConverterParameter");
            var elementName = dict.GetOrDefault("ElementName");
            var fallbackValue = dict.GetOrDefault("FallbackValue");
            var path = dict.GetOrDefault("Path");
            var source = dict.GetOrDefault("Source");
            var targetNullValue = dict.GetOrDefault("TargetNullValue");

            // And now for the null checks...
            if (converterLanguage != null)
                binding.ConverterLanguage = converterLanguage;
            if (converterParameter != null)
                binding.ConverterParameter = converterParameter;
            if (elementName != null)
                binding.ElementName = elementName;
            if (fallbackValue != null)
                binding.FallbackValue = fallbackValue;
            if (path != null)
                binding.Path = new PropertyPath(path);
            if (source != null)
                binding.Source = source;
            if (targetNullValue != null)
                binding.TargetNullValue = targetNullValue;

            // Done!
            return binding;
        }
Exemple #33
0
        protected override void Init(IDictionary <string, string> arguments, CancellationToken cancellationToken)
        {
            var source  = arguments.GetOrThrow <string>(Arguments.Source);
            var verbose = arguments.GetOrDefault(Arguments.Verbose, false);

            var contentBaseAddress     = arguments.GetOrDefault <string>(Arguments.ContentBaseAddress);
            var galleryBaseAddress     = arguments.GetOrDefault <string>(Arguments.GalleryBaseAddress);
            var isContentFlatContainer = arguments.GetOrDefault <bool>(Arguments.ContentIsFlatContainer);

            // The term "legacy" here refers to the registration hives that do not contain any SemVer 2.0.0 packages.
            // In production, this is two registration hives:
            //   1) the first hive released, which is not gzipped and does not have SemVer 2.0.0 packages
            //   2) the secondary hive released, which is gzipped but does not have SemVer 2.0.0 packages
            var storageFactories = CommandHelpers.CreateRegistrationStorageFactories(arguments, verbose);

            Logger.LogInformation(
                "CONFIG source: \"{ConfigSource}\" storage: \"{Storage}\"",
                source,
                storageFactories.LegacyStorageFactory);

            if (isContentFlatContainer)
            {
                var flatContainerCursorUriString = arguments.GetOrThrow <string>(Arguments.CursorUri);
                var flatContainerName            = arguments.GetOrThrow <string>(Arguments.FlatContainerName);
                RegistrationMakerCatalogItem.PackagePathProvider = new FlatContainerPackagePathProvider(flatContainerName);
                // In case that the flat container is used as the packages' source the registration needs to wait for the flatcontainer cursor
                _back = new HttpReadCursor(new Uri(flatContainerCursorUriString));
            }
            else
            {
                RegistrationMakerCatalogItem.PackagePathProvider = new PackagesFolderPackagePathProvider();
                _back = MemoryCursor.CreateMax();
            }

            _collector = new RegistrationCollector(
                new Uri(source),
                storageFactories.LegacyStorageFactory,
                storageFactories.SemVer2StorageFactory,
                contentBaseAddress == null ? null : new Uri(contentBaseAddress),
                galleryBaseAddress == null ? null : new Uri(galleryBaseAddress),
                TelemetryService,
                Logger,
                CommandHelpers.GetHttpMessageHandlerFactory(TelemetryService, verbose));

            var cursorStorage = storageFactories.LegacyStorageFactory.Create();

            _front = new DurableCursor(cursorStorage.ResolveUri("cursor.json"), cursorStorage, MemoryCursor.MinValue);
            storageFactories.SemVer2StorageFactory?.Create();

            _destination = storageFactories.LegacyStorageFactory.DestinationAddress;
            TelemetryService.GlobalDimensions[TelemetryConstants.Destination] = _destination?.AbsoluteUri;
        }
        /// <summary>
        /// 创建表单字段属性
        /// </summary>
        public FormFieldAttribute Create(IDictionary <string, object> fieldData)
        {
            var name       = fieldData.GetOrDefault <string>("Name");
            var source     = fieldData.GetOrDefault <string>("Source");
            var group      = fieldData.GetOrDefault <string>("Group");
            var provider   = Application.Ioc.Resolve <IListItemTreeProvider>(IfUnresolved.ReturnDefault, source);
            var sourceType = provider?.GetType();

            return(new CheckBoxTreeFieldAttribute(name, sourceType)
            {
                Group = group
            });
        }
        protected override void Init(IDictionary <string, string> arguments, CancellationToken cancellationToken)
        {
            var verbose = arguments.GetOrDefault(Arguments.Verbose, false);

            _maxRequeueQueueSize = arguments.GetOrDefault(Arguments.MaxRequeueQueueSize, DefaultMaxQueueSize);

            CommandHelpers.AssertAzureStorage(arguments);

            var monitoringStorageFactory = CommandHelpers.CreateStorageFactory(arguments, verbose);

            _statusService = CommandHelpers.GetPackageMonitoringStatusService(arguments, monitoringStorageFactory, LoggerFactory);

            _queue = CommandHelpers.CreateStorageQueue <PackageValidatorContext>(arguments, PackageValidatorContext.Version);
        }
        protected override void Init(IDictionary <string, string> arguments, CancellationToken cancellationToken)
        {
            var verbose = arguments.GetOrDefault(Arguments.Verbose, false);

            _maxRequeueQueueSize = arguments.GetOrDefault(Arguments.MaxRequeueQueueSize, DefaultMaxQueueSize);

            CommandHelpers.AssertAzureStorage(arguments);

            var monitoringStorageFactory = CommandHelpers.CreateStorageFactory(arguments, verbose);

            _statusService = CommandHelpers.GetPackageMonitoringStatusService(arguments, monitoringStorageFactory, LoggerFactory);
            _packageValidatorContextQueue = CommandHelpers.CreateStorageQueue <PackageValidatorContext>(arguments, PackageValidatorContext.Version);

            Logger.LogInformation(
                "CONFIG storage: {Storage}",
                monitoringStorageFactory);

            _monitoringCursor = ValidationFactory.GetFront(monitoringStorageFactory);
            _galleryCursor    = CreateCursor(monitoringStorageFactory, GalleryCursorFileName);
            _deletedCursor    = CreateCursor(monitoringStorageFactory, DeletedCursorFileName);

            var connectionString    = arguments.GetOrThrow <string>(Arguments.ConnectionString);
            var galleryDbConnection = new AzureSqlConnectionFactory(
                connectionString,
                SecretInjector,
                LoggerFactory.CreateLogger <AzureSqlConnectionFactory>());

            var packageContentUriBuilder = new PackageContentUriBuilder(
                arguments.GetOrThrow <string>(Arguments.PackageContentUrlFormat));

            var timeoutInSeconds = arguments.GetOrDefault(Arguments.SqlCommandTimeoutInSeconds, 300);

            _galleryDatabaseQueryService = new GalleryDatabaseQueryService(
                galleryDbConnection,
                packageContentUriBuilder,
                TelemetryService,
                timeoutInSeconds);

            var auditingStorageFactory = CommandHelpers.CreateSuffixedStorageFactory(
                "Auditing",
                arguments,
                verbose,
                new SemaphoreSlimThrottle(new SemaphoreSlim(ServicePointManager.DefaultConnectionLimit)));

            _auditingStorage = auditingStorageFactory.Create();

            var messageHandlerFactory = CommandHelpers.GetHttpMessageHandlerFactory(TelemetryService, verbose);

            _client = new CollectorHttpClient(messageHandlerFactory());
        }
        protected override void Init(IDictionary<string, string> arguments, CancellationToken cancellationToken)
        {
            var source = arguments.GetOrThrow<string>(Arguments.Source);
            var unlistShouldDelete = arguments.GetOrDefault(Arguments.UnlistShouldDelete, false);
            var verbose = arguments.GetOrDefault(Arguments.Verbose, false);

            var contentBaseAddress = arguments.GetOrDefault<string>(Arguments.ContentBaseAddress);

            StorageFactory storageFactoryToUse;

            var storageFactory = CommandHelpers.CreateStorageFactory(arguments, verbose);
            var compressedStorageFactory = CommandHelpers.CreateCompressedStorageFactory(arguments, verbose);

            Logger.LogInformation("CONFIG source: \"{ConfigSource}\" storage: \"{Storage}\"", source, storageFactory);

            RegistrationMakerCatalogItem.PackagePathProvider = new PackagesFolderPackagePathProvider();

            if (compressedStorageFactory != null)
            {
                var secondaryStorageBaseUrlRewriter = new SecondaryStorageBaseUrlRewriter(new List<KeyValuePair<string, string>>
                {
                    // always rewrite storage root url in seconary
                    new KeyValuePair<string, string>(storageFactory.BaseAddress.ToString(), compressedStorageFactory.BaseAddress.ToString())
                });

                var aggregateStorageFactory = new AggregateStorageFactory(
                    storageFactory,
                    new[] { compressedStorageFactory },
                    secondaryStorageBaseUrlRewriter.Rewrite);

                storageFactoryToUse = aggregateStorageFactory;
            }
            else
            {
                storageFactoryToUse = storageFactory;
            }

            _collector = new RegistrationCollector(new Uri(source), storageFactoryToUse, CommandHelpers.GetHttpMessageHandlerFactory(verbose))
            {
                ContentBaseAddress = contentBaseAddress == null
                    ? null
                    : new Uri(contentBaseAddress)
            };

            var storage = storageFactoryToUse.Create();
            _front = new DurableCursor(storage.ResolveUri("cursor.json"), storage, MemoryCursor.MinValue);
            _back = MemoryCursor.CreateMax();
        }
        private static Uri ExtractUrl(IDictionary<string, string> args)
        {
            // Manually build a string (tried a UriBuilder, but Git gives us credentials and port numbers so it's difficult)
            string scheme = args.GetOrDefault("protocol", "https");
            string host = args.GetOrDefault("host", "no-host.git");
            string path = args.GetOrDefault("path", "/");

            string candidateUrl = String.Format("{0}://{1}{2}", scheme, host, path);
            Uri url;
            if (!Uri.TryCreate(candidateUrl, UriKind.Absolute, out url))
            {
                Console.Error.WriteLine("Failed to parse url: {0}", candidateUrl);
                return null;
            }
            return url;
        }
        protected override void Init(IDictionary<string, string> arguments, CancellationToken cancellationToken)
        {
            Gallery = arguments.GetOrThrow<string>(Arguments.Gallery);
            Verbose = arguments.GetOrDefault(Arguments.Verbose, false);
            StartDate = arguments.GetOrDefault(Arguments.StartDate, DateTimeMinValueUtc);

            var catalogStorageFactory = CommandHelpers.CreateStorageFactory(arguments, Verbose);
            var auditingStorageFactory = CommandHelpers.CreateSuffixedStorageFactory("Auditing", arguments, Verbose);

            Logger.LogInformation("CONFIG source: \"{ConfigSource}\" storage: \"{Storage}\"", Gallery, catalogStorageFactory);

            CatalogStorage = catalogStorageFactory.Create();
            AuditingStorage = auditingStorageFactory.Create();

            Top = 20;
            Timeout = TimeSpan.FromSeconds(300);
        }
Exemple #40
0
        /// <summary>
        /// Creates a <see cref="ExtensionMetadata"/> instance from the given metadata dictionary.
        /// </summary>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public static IEnumerable<IExtensionMetadata> Extract(IDictionary<string, object> metadata)
        {
            var objectTypes = (ExtensionObjectType[])metadata.GetOrDefault("ObjectType");
            var localNames = (string[])metadata.GetOrDefault("LocalName");
            var namespaceNames = (string[])metadata.GetOrDefault("NamespaceName");
            var predicateTypes = (Type[])metadata.GetOrDefault("PredicateType");

            // find shortest array
            int length = objectTypes.Length;
            length = Math.Min(length, localNames.Length);
            length = Math.Min(length, namespaceNames.Length);
            length = Math.Min(length, predicateTypes.Length);

            // extract metadata
            for (int i = 0; i < length; i++)
                yield return new ExtensionMetadata(objectTypes[i], localNames[i], namespaceNames[i], predicateTypes[i]);
        }
        protected override void Init(IDictionary<string, string> arguments, CancellationToken cancellationToken)
        {
            var source = arguments.GetOrThrow<string>(Arguments.Source);
            var verbose = arguments.GetOrDefault(Arguments.Verbose, false);
            var contentBaseAddress = arguments.GetOrDefault<string>(Arguments.ContentBaseAddress);
            var storageFactory = CommandHelpers.CreateStorageFactory(arguments, verbose);

            Logger.LogInformation("CONFIG source: \"{ConfigSource}\" storage: \"{Storage}\"", source, storageFactory);

            _collector = new DnxCatalogCollector(new Uri(source), storageFactory, CommandHelpers.GetHttpMessageHandlerFactory(verbose))
            {
                ContentBaseAddress = contentBaseAddress == null ? null : new Uri(contentBaseAddress)
            };

            var storage = storageFactory.Create();
            _front = new DurableCursor(storage.ResolveUri("cursor.json"), storage, MemoryCursor.MinValue);
            _back = MemoryCursor.CreateMax();
        }
        static IEnumerable<Tuple<string, string>> StoreCommand(IDictionary<string, string> args)
        {
            // Build the URL
            Uri url = ExtractUrl(args);
            string userName = args.GetOrDefault("username", String.Empty);
            string password = args.GetOrDefault("password", String.Empty);

            bool abort = false;
            if(abort |= String.IsNullOrEmpty(userName)) {
                Console.Error.WriteLine("username parameter must be provided");
            }
            if(abort |= String.IsNullOrEmpty(password)) {
                Console.Error.WriteLine("password parameter must be provided");
            }
            if (!abort)
            {
                string target = GetTargetName(url);
                IntPtr passwordPtr = Marshal.StringToBSTR(password);
                NativeMethods.CREDENTIAL cred = new NativeMethods.CREDENTIAL()
                {
                    type = 0x01, // Generic
                    targetName = target,
                    credentialBlob = Marshal.StringToCoTaskMemUni(password),
                    persist = 0x03, // Enterprise (roaming)
                    attributeCount = 0,
                    userName = userName
                };
                cred.credentialBlobSize = Encoding.Unicode.GetByteCount(password);
                if (!NativeMethods.CredWrite(ref cred, 0))
                {
                    Console.Error.WriteLine(
                        "Failed to write credential: " +
                        GetLastErrorMessage());
                }
            }
            return Enumerable.Empty<Tuple<string, string>>();
        }
		private int ProcessBatch(AbstractViewGenerator viewGenerator, List<object> currentDocumentResults, string currentKey, HashSet<ReduceKeyAndBucket> changes,
			IStorageActionsAccessor actions,
			IDictionary<string, int> statsPerKey)
		{
			if (currentKey == null || currentDocumentResults.Count == 0)
				return 0;
			var old = CurrentIndexingScope.Current;
			try
			{
				CurrentIndexingScope.Current = null;

				if (logIndexing.IsDebugEnabled)
				{
					var sb = new StringBuilder()
						.AppendFormat("Index {0} for document {1} resulted in:", PublicName, currentKey)
						.AppendLine();
					foreach (var currentDocumentResult in currentDocumentResults)
					{
						sb.AppendLine(JsonConvert.SerializeObject(currentDocumentResult));
					}
					logIndexing.Debug(sb.ToString());
				}

				int count = 0;
				var results = RobustEnumerationReduceDuringMapPhase(currentDocumentResults.GetEnumerator(), viewGenerator.ReduceDefinition);
				foreach (var doc in results)
				{
					count++;

					var reduceValue = viewGenerator.GroupByExtraction(doc);
					if (reduceValue == null)
					{
						logIndexing.Debug("Field {0} is used as the reduce key and cannot be null, skipping document {1}",
										  viewGenerator.GroupByExtraction, currentKey);
						continue;
					}
					string reduceKey = ReduceKeyToString(reduceValue);

					var data = GetMappedData(doc);

					logIndexing.Debug("Index {0} for document {1} resulted in ({2}): {3}", PublicName, currentKey, reduceKey, data);
					actions.MapReduce.PutMappedResult(indexId, currentKey, reduceKey, data);
					statsPerKey[reduceKey] = statsPerKey.GetOrDefault(reduceKey) + 1;
					actions.General.MaybePulseTransaction();
					changes.Add(new ReduceKeyAndBucket(IndexingUtil.MapBucket(currentKey), reduceKey));
				}
				return count;
			}
			finally
			{
				CurrentIndexingScope.Current = old;
			}
		}
Exemple #44
0
		private int ProcessBatch(AbstractViewGenerator viewGenerator, List<object> currentDocumentResults, string currentKey, HashSet<ReduceKeyAndBucket> changes,
			IStorageActionsAccessor actions,
			IDictionary<string, int> statsPerKey)
		{
			if (currentKey == null || currentDocumentResults.Count == 0)
				return 0;

			int count = 0;
			var results = RobustEnumerationReduceDuringMapPhase(currentDocumentResults.GetEnumerator(), viewGenerator.ReduceDefinition);
			foreach (var doc in results)
			{
				count++;

				var reduceValue = viewGenerator.GroupByExtraction(doc);
				if (reduceValue == null)
				{
					logIndexing.Debug("Field {0} is used as the reduce key and cannot be null, skipping document {1}",
									  viewGenerator.GroupByExtraction, currentKey);
					continue;
				}
				string reduceKey = ReduceKeyToString(reduceValue);

				var data = GetMappedData(doc);

				actions.MapReduce.PutMappedResult(name, currentKey, reduceKey, data);
				statsPerKey[reduceKey] = statsPerKey.GetOrDefault(reduceKey) + 1;
				actions.General.MaybePulseTransaction();
				changes.Add(new ReduceKeyAndBucket(IndexingUtil.MapBucket(currentKey), reduceKey));
			}
			return count;
		}
Exemple #45
0
			private void UpdateFacetResults(IDictionary<string, Dictionary<string, int>> facetsByName)
			{
				foreach (var facet in Facets.Values)
				{
					var values = new List<FacetValue>();
					List<string> allTerms;

					int maxResults = Math.Min(facet.MaxResults ?? Database.Configuration.MaxPageSize, Database.Configuration.MaxPageSize);
					var groups = facetsByName.GetOrDefault(facet.Name);

					if (groups == null)
						continue;

					switch (facet.TermSortMode)
					{
						case FacetTermSortMode.ValueAsc:
							allTerms = new List<string>(groups.OrderBy(x => x.Key).ThenBy(x => x.Value).Select(x => x.Key));
							break;
						case FacetTermSortMode.ValueDesc:
							allTerms = new List<string>(groups.OrderByDescending(x => x.Key).ThenBy(x => x.Value).Select(x => x.Key));
							break;
						case FacetTermSortMode.HitsAsc:
							allTerms = new List<string>(groups.OrderBy(x => x.Value).ThenBy(x => x.Key).Select(x => x.Key));
							break;
						case FacetTermSortMode.HitsDesc:
							allTerms = new List<string>(groups.OrderByDescending(x => x.Value).ThenBy(x=>x.Key).Select(x => x.Key));
							break;
						default:
							throw new ArgumentException(string.Format("Could not understand '{0}'", facet.TermSortMode));
					}

					foreach (var term in allTerms.TakeWhile(term => values.Count < maxResults))
					{
						values.Add(new FacetValue
						{
							Hits = groups.GetOrDefault(term),
							Range = term
						});
					}

					Results.Results[facet.Name] = new FacetResult
				{
					Values = values,
					RemainingTermsCount = allTerms.Count - values.Count,
					RemainingHits = groups.Values.Sum() - values.Sum(x => x.Hits),
				};

					if (facet.InclueRemainingTerms)
						Results.Results[facet.Name].RemainingTerms = allTerms.Skip(maxResults).ToList();
				}
			}
        private static StorageFactory CreateStorageFactoryImpl(IDictionary<string, string> arguments, IDictionary<string, string> argumentNameMap, bool verbose)
        {
            Uri storageBaseAddress = null;
            var storageBaseAddressStr = arguments.GetOrDefault<string>(argumentNameMap[Arguments.StorageBaseAddress]);
            if (!string.IsNullOrEmpty(storageBaseAddressStr))
            {
                storageBaseAddressStr = storageBaseAddressStr.TrimEnd('/') + "/";

                storageBaseAddress = new Uri(storageBaseAddressStr);
            }

            var storageType = arguments.GetOrThrow<string>(Arguments.StorageType);

            if (storageType.Equals(Arguments.FileStorageType, StringComparison.InvariantCultureIgnoreCase))
            {
                var storagePath = arguments.GetOrThrow<string>(argumentNameMap[Arguments.StoragePath]);

                if (storageBaseAddress != null)
                {
                    return new FileStorageFactory(storageBaseAddress, storagePath) {Verbose = verbose};
                }

                TraceRequiredArgument(argumentNameMap[Arguments.StorageBaseAddress]);
                return null;
            }

            if (Arguments.AzureStorageType.Equals(storageType, StringComparison.InvariantCultureIgnoreCase))
            {
                var storageAccountName = arguments.GetOrThrow<string>(argumentNameMap[Arguments.StorageAccountName]);
                var storageKeyValue = arguments.GetOrThrow<string>(argumentNameMap[Arguments.StorageKeyValue]);
                var storageContainer = arguments.GetOrThrow<string>(argumentNameMap[Arguments.StorageContainer]);
                var storagePath = arguments.GetOrDefault<string>(argumentNameMap[Arguments.StoragePath]);

                var credentials = new StorageCredentials(storageAccountName, storageKeyValue);
                var account = new CloudStorageAccount(credentials, true);
                return new AzureStorageFactory(account, storageContainer, storagePath, storageBaseAddress) { Verbose = verbose };
            }
            
            throw new ArgumentException($"Unrecognized storageType \"{storageType}\"");
        }
        protected override void Init(IDictionary<string, string> arguments, CancellationToken cancellationToken)
        {
            PrintLightning();

            _command = arguments.GetOrThrow<string>(Arguments.Command);
            _verbose = arguments.GetOrDefault(Arguments.Verbose, false);

            _log = _verbose ? Console.Out : new StringWriter();

            switch (_command.ToLowerInvariant())
            {
                case "charge":
                case "prepare":
                    InitPrepare(arguments);
                    break;
                case "strike":
                    InitStrike(arguments);
                    break;
                default:
                    throw new ArgumentNullException();
            }

            _contentBaseAddress = arguments.GetOrThrow<string>(Arguments.ContentBaseAddress);
            _storageAccount = arguments.GetOrThrow<string>(Arguments.StorageAccount);
            _storageContainer = arguments.GetOrThrow<string>(Arguments.StorageContainer);
            _storageBaseAddress = arguments.GetOrThrow<string>(Arguments.StorageBaseAddress);
            _compress = arguments.GetOrDefault(Arguments.Compress, false);
        }
Exemple #48
0
		/// <summary>
		/// 解析提交上来的值
		/// 同时检查csrf校验和值是否符合验证器的规则
		/// </summary>
		/// <param name="builder">表单构建器</param>
		/// <param name="submitValues">提交上来的值</param>
		/// <returns></returns>
		public static IDictionary<string, object> ParseValues(
			this FormBuilder builder, IDictionary<string, string> submitValues) {
			// 检查csrf校验值
			if (builder.Attribute.EnableCsrfToken) {
				var exceptedToken = HttpContextUtils.GetCookie(FormBuilder.CsrfTokenKey);
				var actualToken = submitValues.GetOrDefault(FormBuilder.CsrfTokenFieldName);
				if (string.IsNullOrEmpty(exceptedToken) || exceptedToken != actualToken) {
					throw new HttpException(403, new T("Check Csrf Token Failed."));
				}
			}
			// 枚举字段,逐个进行检查和设置
			var result = new Dictionary<string, object>();
			foreach (var field in builder.Fields) {
				// 解析值
				string value = submitValues.GetOrDefault(field.Attribute.Name);
				object parsed = null;
				if (value != null) {
					var fieldHandler = Application.Ioc.Resolve<IFormFieldHandler>(serviceKey: field.Attribute.GetType());
					parsed = fieldHandler.Parse(field, value);
				}
				// 校验值
				foreach (var attribute in field.ValidationAttributes) {
					var validator = Application.Ioc.Resolve<IFormFieldValidator>(serviceKey: attribute.GetType());
					validator.Validate(field, attribute, parsed);
				}
				// 设置到结果中
				result[field.Attribute.Name] = parsed;
			}
			return result;
		}
        static IEnumerable<Tuple<string, string>> GetCommand(IDictionary<string, string> args)
        {
            // Build the URL
            Uri url = ExtractUrl(args);
            if (url == null)
            {
                yield break;
            }

            string userName = args.GetOrDefault("username", null);
            string password = null;

            IntPtr credPtr = IntPtr.Zero;
            try
            {
                // Check for a credential
                string target = GetTargetName(url);
                if (!NativeMethods.CredRead(target, NativeMethods.CRED_TYPE.GENERIC, 0, out credPtr))
                {
                    // Don't have a credential for this user. Are we on XP? If so, sorry no dice.
                    if (OnXP())
                    {
                        // Users will get a Git prompt for user name and password. We'll still store them.
                        yield break;
                    }
                    credPtr = IntPtr.Zero;

                    // If we have a username, pack an input authentication buffer
                    Tuple<int, IntPtr> inputBuffer = null;;
                    IntPtr outputBuffer = IntPtr.Zero;
                    int outputBufferSize = 0;
                    try
                    {
                        inputBuffer = PackUserNameBuffer(userName);
                        if (inputBuffer == null) { yield break; }

                        // Setup UI
                        NativeMethods.CREDUI_INFO ui = new NativeMethods.CREDUI_INFO()
                        {
                            pszCaptionText = "Git Credentials",
                            pszMessageText = "Enter your credentials for: " + GetHost(url)
                        };
                        ui.cbSize = Marshal.SizeOf(ui);

                        // Prompt!
                        int authPackage = 0;
                        bool save = false;
                        var ret = NativeMethods.CredUIPromptForWindowsCredentials(
                            uiInfo: ref ui,
                            authError: 0,
                            authPackage: ref authPackage,
                            InAuthBuffer: inputBuffer.Item2,
                            InAuthBufferSize: inputBuffer.Item1,
                            refOutAuthBuffer: out outputBuffer,
                            refOutAuthBufferSize: out outputBufferSize,
                            fSave: ref save,
                            flags: NativeMethods.PromptForWindowsCredentialsFlags.CREDUIWIN_GENERIC);
                        if (ret != NativeMethods.CredUIReturnCodes.NO_ERROR)
                        {
                            Console.Error.WriteLine("Error prompting for credentials: " + ret.ToString());
                            yield break;
                        }
                    }
                    finally
                    {
                        if (inputBuffer != null && inputBuffer.Item2 != IntPtr.Zero)
                        {
                            Marshal.FreeHGlobal(inputBuffer.Item2);
                        }
                    }

                    try
                    {
                        // Unpack
                        if (!UnPackAuthBuffer(outputBuffer, outputBufferSize, out userName, out password))
                        {
                            yield break;
                        }
                    }
                    finally
                    {
                        if (outputBuffer != IntPtr.Zero)
                        {
                            Marshal.FreeHGlobal(outputBuffer);
                        }
                    }
                }
                else
                {
                    // Decode the credential
                    NativeMethods.CREDENTIAL cred = (NativeMethods.CREDENTIAL)Marshal.PtrToStructure(credPtr, typeof(NativeMethods.CREDENTIAL));
                    userName = cred.userName;
                    password = Marshal.PtrToStringBSTR(cred.credentialBlob);
                }

                yield return Tuple.Create("username", userName);
                yield return Tuple.Create("password", password);
            }
            finally
            {
                if (credPtr != IntPtr.Zero)
                {
                    NativeMethods.CredFree(credPtr);
                }
            }
        }
        public static StorageFactory CreateCompressedStorageFactory(IDictionary<string, string> arguments, bool verbose)
        {
            if (!arguments.GetOrDefault(Arguments.UseCompressedStorage, false))
            {
                return null;
            }

            IDictionary<string, string> names = new Dictionary<string, string>
            {
                { Arguments.StorageBaseAddress, Arguments.CompressedStorageBaseAddress },
                { Arguments.StorageAccountName, Arguments.CompressedStorageAccountName },
                { Arguments.StorageKeyValue, Arguments.CompressedStorageKeyValue },
                { Arguments.StorageContainer, Arguments.CompressedStorageContainer },
                { Arguments.StoragePath, Arguments.CompressedStoragePath }
            };

            return CreateStorageFactoryImpl(arguments, names, verbose);
        }