public AzureDnsOptions(IOptionsService options)
 {
     TenantId          = options.TryGetRequiredOption(nameof(options.Options.AzureTenantId), options.Options.AzureTenantId);
     ClientId          = options.TryGetRequiredOption(nameof(options.Options.AzureTenantId), options.Options.AzureClientId);
     Secret            = options.TryGetRequiredOption(nameof(options.Options.AzureTenantId), options.Options.AzureSecret);
     SubscriptionId    = options.TryGetRequiredOption(nameof(options.Options.AzureTenantId), options.Options.AzureSubscriptionId);
     ResourceGroupName = options.TryGetRequiredOption(nameof(options.Options.AzureTenantId), options.Options.AzureResourceGroupName);
 }
 public DnsScriptOptions(IOptionsService options, ILogService log)
 {
     CreateScript = options.TryGetRequiredOption(nameof(options.Options.DnsCreateScript), options.Options.DnsCreateScript);
     if (!CreateScript.ValidFile(log))
     {
         throw new ArgumentException(nameof(options.Options.DnsCreateScript));
     }
     DeleteScript = options.TryGetRequiredOption(nameof(options.Options.DnsDeleteScript), options.Options.DnsDeleteScript);
     if (!DeleteScript.ValidFile(log))
     {
         throw new ArgumentException(nameof(options.Options.DnsDeleteScript));
     }
 }
示例#3
0
        public override AzureOptions Default(Target target, IOptionsService options)
        {
            var az = options.GetArguments <AzureArguments>();

            return(new AzureOptions()
            {
                TenantId = options.TryGetRequiredOption(nameof(az.AzureTenantId), az.AzureTenantId),
                ClientId = options.TryGetRequiredOption(nameof(az.AzureTenantId), az.AzureClientId),
                Secret = options.TryGetRequiredOption(nameof(az.AzureTenantId), az.AzureSecret),
                SubscriptionId = options.TryGetRequiredOption(nameof(az.AzureTenantId), az.AzureSubscriptionId),
                ResourceGroupName = options.TryGetRequiredOption(nameof(az.AzureTenantId), az.AzureResourceGroupName)
            });
        }
示例#4
0
 /// <summary>
 /// Remove renewal from the list of scheduled items
 /// </summary>
 private void CancelRenewal(RunLevel runLevel)
 {
     if (runLevel.HasFlag(RunLevel.Unattended))
     {
         var friendlyName = _optionsService.TryGetRequiredOption(nameof(MainArguments.FriendlyName), _arguments.FriendlyName);
         foreach (var r in _renewalService.FindByFriendlyName(friendlyName))
         {
             _renewalService.Cancel(r);
         }
     }
     else
     {
         var renewal = _input.ChooseFromList("Which renewal would you like to cancel?",
                                             _renewalService.Renewals.OrderBy(x => x.Date),
                                             x => Choice.Create(x),
                                             true);
         if (renewal != null)
         {
             if (_input.PromptYesNo($"Are you sure you want to cancel the renewal for {renewal}"))
             {
                 _renewalService.Cancel(renewal);
             }
         }
     }
 }
示例#5
0
        public override IISBindingOptions Default(IOptionsService optionsService)
        {
            var ret       = new IISBindingOptions();
            var args      = optionsService.GetArguments <IISBindingArguments>();
            var hostName  = optionsService.TryGetRequiredOption(nameof(args.Host), args.Host).ToLower();
            var rawSiteId = args.SiteId;
            var filterSet = _helper.GetBindings(false, false);

            if (!string.IsNullOrEmpty(rawSiteId))
            {
                if (long.TryParse(rawSiteId, out long siteId))
                {
                    filterSet = filterSet.Where(x => x.SiteId == siteId).ToList();
                }
                else
                {
                    _log.Error("Invalid SiteId {siteId}", rawSiteId);
                    return(null);
                }
            }
            var chosenTarget = filterSet.Where(x => x.HostUnicode == hostName || x.HostPunycode == hostName).FirstOrDefault();

            if (chosenTarget != null)
            {
                ret.SiteId = chosenTarget.SiteId;
                ret.Host   = chosenTarget.HostUnicode;
                ret.FriendlyNameSuggestion = chosenTarget.HostUnicode;
                return(ret);
            }
            else
            {
                return(null);
            }
        }
示例#6
0
        public override IISSitesOptions Default(IOptionsService optionsService)
        {
            var ret        = new IISSitesOptions();
            var args       = optionsService.GetArguments <IISSiteArguments>();
            var sites      = _helper.GetSites(false, false);
            var rawSiteIds = optionsService.TryGetRequiredOption(nameof(args.SiteId), args.SiteId);

            sites = ProcessSiteIds(ret, sites, rawSiteIds);
            if (sites == null)
            {
                return(null);
            }
            ret.ExcludeBindings = args.ExcludeBindings.ParseCsv();
            if (ret.ExcludeBindings != null)
            {
                ret.ExcludeBindings = ret.ExcludeBindings.Select(x => x.ConvertPunycode()).ToList();
            }
            var commonName = args.CommonName;

            if (!string.IsNullOrWhiteSpace(commonName))
            {
                commonName = commonName.ToLower().Trim().ConvertPunycode();
                if (sites.Any(s => s.Hosts.Contains(commonName)) &&
                    (ret.ExcludeBindings == null || !ret.ExcludeBindings.Contains(commonName)))
                {
                    ret.CommonName = commonName;
                }
                else
                {
                    _log.Error("Common name {commonName} not found or excluded", commonName);
                    return(null);
                }
            }
            return(ret);
        }
示例#7
0
        Target ITargetPlugin.Default(IOptionsService optionsService)
        {
            var  rawSiteId = optionsService.TryGetRequiredOption(nameof(optionsService.Options.SiteId), optionsService.Options.SiteId);
            long siteId    = 0;

            if (long.TryParse(rawSiteId, out siteId))
            {
                var found = GetSites(false, false).FirstOrDefault(binding => binding.TargetSiteId == siteId);
                if (found != null)
                {
                    found.ExcludeBindings = optionsService.Options.ExcludeBindings;
                    found.CommonName      = optionsService.Options.CommonName;
                    if (!found.IsCommonNameValid(_log))
                    {
                        return(null);
                    }
                    return(found);
                }
                else
                {
                    _log.Error("Unable to find SiteId {siteId}", siteId);
                }
            }
            else
            {
                _log.Error("Invalid SiteId {siteId}", optionsService.Options.SiteId);
            }
            return(null);
        }
示例#8
0
        Target ITargetPlugin.Default(IOptionsService optionsService)
        {
            var rawSiteId   = optionsService.TryGetRequiredOption(nameof(optionsService.Options.SiteId), optionsService.Options.SiteId);
            var totalTarget = GetCombinedTarget(GetSites(false, false), rawSiteId);

            totalTarget.ExcludeBindings = optionsService.Options.ExcludeBindings;
            return(totalTarget);
        }
        public override DreamhostOptions Default(Target target, IOptionsService options)
        {
            var az = options.GetArguments <DreamhostArguments>();

            return(new DreamhostOptions()
            {
                ApiKey = options.TryGetRequiredOption(nameof(az.ApiKey), az.ApiKey),
            });
        }
 public override void Default(ScheduledRenewal renewal, IOptionsService optionsService)
 {
     renewal.Script = optionsService.TryGetRequiredOption(nameof(optionsService.Options.Script), optionsService.Options.Script);
     if (!renewal.Script.ValidFile(_log))
     {
         throw new ArgumentException(nameof(optionsService.Options.Script));
     }
     renewal.ScriptParameters = optionsService.Options.ScriptParameters;
 }
示例#11
0
        public override ScriptOptions Default(Target target, IOptionsService options)
        {
            var args = options.GetArguments <ScriptArguments>();
            var ret  = new ScriptOptions
            {
                CreateScript = options.TryGetRequiredOption(nameof(args.DnsCreateScript), args.DnsCreateScript),
                DeleteScript = options.TryGetRequiredOption(nameof(args.DnsDeleteScript), args.DnsDeleteScript)
            };

            if (!ret.CreateScript.ValidFile(_log))
            {
                throw new ArgumentException(nameof(args.DnsCreateScript));
            }
            if (!ret.DeleteScript.ValidFile(_log))
            {
                throw new ArgumentException(nameof(args.DnsDeleteScript));
            }
            return(ret);
        }
示例#12
0
        Target ITargetPlugin.Default(IOptionsService optionsService)
        {
            var input  = optionsService.TryGetRequiredOption(nameof(optionsService.Options.ManualHost), optionsService.Options.ManualHost);
            var target = Create(input);

            target.CommonName = optionsService.Options.CommonName;
            if (!target.IsCommonNameValid(_log))
            {
                return(null);
            }
            return(target);
        }
示例#13
0
        Target ITargetPlugin.Default(IOptionsService optionsService)
        {
            var rawSiteId   = optionsService.TryGetRequiredOption(nameof(optionsService.Options.SiteId), optionsService.Options.SiteId);
            var totalTarget = GetCombinedTarget(GetSites(false, false), rawSiteId);

            totalTarget.ExcludeBindings = optionsService.Options.ExcludeBindings;
            totalTarget.CommonName      = optionsService.Options.CommonName;
            if (!totalTarget.IsCommonNameValid(_log))
            {
                return(null);
            }
            return(totalTarget);
        }
示例#14
0
        public override ScriptOptions Default(Target target, IOptionsService optionsService)
        {
            var args = optionsService.GetArguments <ScriptArguments>();
            var ret  = new ScriptOptions
            {
                Script = optionsService.TryGetRequiredOption(nameof(args.Script), args.Script)
            };

            if (!ret.Script.ValidFile(_log))
            {
                throw new ArgumentException(nameof(args.Script));
            }
            ret.ScriptParameters = args.ScriptParameters;
            return(ret);
        }
 /// <summary>
 /// Check information need for validation (unattended)
 /// </summary>
 /// <param name="target"></param>
 public override void Default(Target target, IOptionsService optionsService)
 {
     if (target.IIS == null)
     {
         target.IIS = optionsService.Options.ManualTargetIsIIS;
     }
     if (string.IsNullOrEmpty(target.WebRootPath))
     {
         target.WebRootPath = optionsService.TryGetRequiredOption(nameof(optionsService.Options.WebRoot), optionsService.Options.WebRoot);
     }
     if (!ValidateWebroot(target))
     {
         throw new ArgumentException($"Invalid --webroot {target.WebRootPath}: {WebrootHint()[0]}");
     }
 }
示例#16
0
        Target ITargetPlugin.Default(IOptionsService optionsService)
        {
            var  hostName  = optionsService.TryGetRequiredOption(nameof(optionsService.Options.ManualHost), optionsService.Options.ManualHost);
            var  rawSiteId = optionsService.Options.SiteId;
            long siteId    = 0;
            var  filterSet = GetBindings(false, false);

            if (long.TryParse(rawSiteId, out siteId))
            {
                filterSet = filterSet.Where(x => x.TargetSiteId == siteId).ToList();
            }
            return(filterSet.
                   Where(x => x.Host == hostName).
                   FirstOrDefault());
        }
示例#17
0
        public override IISSiteOptions Default(IOptionsService optionsService)
        {
            var ret       = new IISSiteOptions();
            var args      = optionsService.GetArguments <IISSiteArguments>();
            var rawSiteId = optionsService.TryGetRequiredOption(nameof(args.SiteId), args.SiteId);

            if (long.TryParse(rawSiteId, out long siteId))
            {
                var site = _helper.GetSites(false, false).FirstOrDefault(binding => binding.Id == siteId);
                if (site != null)
                {
                    ret.SiteId          = site.Id;
                    ret.ExcludeBindings = args.ExcludeBindings.ParseCsv();
                    if (ret.ExcludeBindings != null)
                    {
                        ret.ExcludeBindings = ret.ExcludeBindings.Select(x => x.ConvertPunycode()).ToList();
                    }

                    ret.FriendlyNameSuggestion = $"Site-{ret.SiteId}";
                    var commonName = args.CommonName;
                    if (!string.IsNullOrWhiteSpace(commonName))
                    {
                        commonName = commonName.ToLower().Trim().ConvertPunycode();
                        if (site.Hosts.Contains(commonName) &&
                            (ret.ExcludeBindings == null || !ret.ExcludeBindings.Contains(commonName)))
                        {
                            ret.CommonName = commonName;
                        }
                        else
                        {
                            _log.Error("Common name {commonName} not found or excluded", commonName);
                            return(null);
                        }
                    }
                    return(ret);
                }
                else
                {
                    _log.Error("Unable to find SiteId {siteId}", siteId);
                }
            }
            else
            {
                _log.Error("Invalid SiteId {siteId}", args.SiteId);
            }
            return(null);
        }
示例#18
0
        public override ManualOptions Default(IOptionsService optionsService)
        {
            var args       = optionsService.GetArguments <ManualArguments>();
            var input      = optionsService.TryGetRequiredOption(nameof(args.Host), args.Host);
            var ret        = Create(input);
            var commonName = args.CommonName;

            if (!string.IsNullOrWhiteSpace(commonName))
            {
                commonName     = commonName.ToLower().Trim().ConvertPunycode();
                ret.CommonName = commonName;
                if (!ret.AlternativeNames.Contains(commonName))
                {
                    ret.AlternativeNames.Insert(0, commonName);
                }
            }
            return(ret);
        }
        public override CentralSslOptions Default(IOptionsService optionsService)
        {
            var args = optionsService.GetArguments <CentralSslArguments>();
            var path = optionsService.TryGetRequiredOption(nameof(args.CentralSslStore), args.CentralSslStore);

            if (path.ValidPath(_log))
            {
                return(new CentralSslOptions
                {
                    Path = path,
                    KeepExisting = args.KeepExisting,
                    PfxPassword = args.PfxPassword
                });
            }
            else
            {
                throw new Exception("Invalid path specified");
            }
        }
示例#20
0
        /// <summary>
        /// Get webroot automatically
        /// </summary>
        public HttpValidationOptions <TPlugin> BaseDefault(Target target, IOptionsService options)
        {
            string path       = null;
            var    allowEmpty = AllowEmtpy(target);
            var    args       = options.GetArguments <HttpValidationArguments>();

            if (string.IsNullOrEmpty(path) && !allowEmpty)
            {
                path = options.TryGetRequiredOption(nameof(args.WebRoot), args.WebRoot);
            }
            if (!string.IsNullOrEmpty(path) && !PathIsValid(path))
            {
                throw new ArgumentException($"Invalid webroot {path}: {WebrootHint(false)[0]}");
            }
            return(new TOptions
            {
                Path = path,
                CopyWebConfig = target.IIS || args.ManualTargetIsIIS
            });
        }
示例#21
0
        Target ITargetPlugin.Default(IOptionsService optionsService)
        {
            var input = optionsService.TryGetRequiredOption(nameof(optionsService.Options.ManualHost), optionsService.Options.ManualHost);

            return(Create(input));
        }
示例#22
0
 public NetworkCredentialOptions(IOptionsService options)
 {
     UserName = options.TryGetRequiredOption(nameof(options.Options.UserName), options.Options.UserName);
     Password = options.TryGetRequiredOption(nameof(options.Options.Password), options.Options.Password);
 }