opensource/certimate
3
0
Fork 0
mirror of https://github.com/certimate-go/certimate.git synced 2026-09-24 23:10:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: clean code

Browse Source
This commit is contained in:
Fu Diwei
2025-09-01 22:13:54 +08:00
parent 90907427ba
commit d9a46b32fb
156 changed files with 927 additions and 927 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/applicant/providers.go
+5 -5
View File
@@ -35,10 +35,10 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
}
return provider(&applicators.ProviderFactoryOptions{
AccessConfig: options.ProviderAccessConfig,
ProviderConfig: options.ProviderServiceConfig,
DnsPropagationWait: options.DnsPropagationWait,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
ProviderAccessConfig: options.ProviderAccessConfig,
ProviderExtendedConfig: options.ProviderServiceConfig,
DnsPropagationWait: options.DnsPropagationWait,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
}
internal/certapply/applicators/registry.go
+5 -5
View File
@@ -10,11 +10,11 @@ import (
type ProviderFactoryFunc func(options *ProviderFactoryOptions) (core.ACMEChallenger, error)
type ProviderFactoryOptions struct {
AccessConfig map[string]any
ProviderConfig map[string]any
DnsPropagationWait int32
DnsPropagationTimeout int32
DnsTTL int32
ProviderAccessConfig map[string]any
ProviderExtendedConfig map[string]any
DnsPropagationWait int32
DnsPropagationTimeout int32
DnsTTL int32
}
type Registry[T comparable] interface {
internal/certapply/applicators/sp_acmehttpreq.go
+6 -6
View File
@@ -12,16 +12,16 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeACMEHttpReq, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForACMEHttpReq{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForACMEHttpReq{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := acmehttpreq.NewChallengeProvider(&acmehttpreq.ChallengeProviderConfig{
Endpoint: access.Endpoint,
Mode: access.Mode,
Username: access.Username,
Password: access.Password,
Endpoint: credentials.Endpoint,
Mode: credentials.Mode,
Username: credentials.Username,
Password: credentials.Password,
DnsPropagationTimeout: options.DnsPropagationTimeout,
})
return provider, err
internal/certapply/applicators/sp_aliyun_dns.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeAliyunDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyun.NewChallengeProvider(&aliyun.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_aliyun_esa.go
+5 -5
View File
@@ -12,15 +12,15 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeAliyunESA, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunesa.NewChallengeProvider(&aliyunesa.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: xmaps.GetString(options.ProviderConfig, "region"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_aws_route53.go
+6 -6
View File
@@ -12,16 +12,16 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeAWSRoute53, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForAWS{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAWS{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := awsroute53.NewChallengeProvider(&awsroute53.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: xmaps.GetString(options.ProviderConfig, "region"),
HostedZoneId: xmaps.GetString(options.ProviderConfig, "hostedZoneId"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
HostedZoneId: xmaps.GetString(options.ProviderExtendedConfig, "hostedZoneId"),
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_azure_dns.go
+6 -6
View File
@@ -12,16 +12,16 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeAzureDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForAzure{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAzure{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := azuredns.NewChallengeProvider(&azuredns.ChallengeProviderConfig{
TenantId: access.TenantId,
ClientId: access.ClientId,
ClientSecret: access.ClientSecret,
CloudName: access.CloudName,
TenantId: credentials.TenantId,
ClientId: credentials.ClientId,
ClientSecret: credentials.ClientSecret,
CloudName: credentials.CloudName,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_baiducloud_dns.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeBaiduCloudDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForBaiduCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBaiduCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := baiducloud.NewChallengeProvider(&baiducloud.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_bunny.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeBunny, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForBunny{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBunny{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := bunny.NewChallengeProvider(&bunny.ChallengeProviderConfig{
ApiKey: access.ApiKey,
ApiKey: credentials.ApiKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_cloudflare.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeCloudflare, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForCloudflare{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCloudflare{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := cloudflare.NewChallengeProvider(&cloudflare.ChallengeProviderConfig{
DnsApiToken: access.DnsApiToken,
ZoneApiToken: access.ZoneApiToken,
DnsApiToken: credentials.DnsApiToken,
ZoneApiToken: credentials.ZoneApiToken,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_cloudns.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeClouDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForClouDNS{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForClouDNS{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := cloudns.NewChallengeProvider(&cloudns.ChallengeProviderConfig{
AuthId: access.AuthId,
AuthPassword: access.AuthPassword,
AuthId: credentials.AuthId,
AuthPassword: credentials.AuthPassword,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_cmcccloud_dns.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeCMCCCloudDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForCMCCCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCMCCCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := cmcccloud.NewChallengeProvider(&cmcccloud.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_constellix.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeConstellix, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForConstellix{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForConstellix{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := constellix.NewChallengeProvider(&constellix.ChallengeProviderConfig{
ApiKey: access.ApiKey,
SecretKey: access.SecretKey,
ApiKey: credentials.ApiKey,
SecretKey: credentials.SecretKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_ctcccloud_smartdns.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeCTCCCloudSmartDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := ctcccloud.NewChallengeProvider(&ctcccloud.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_desec.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeDeSEC, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForDeSEC{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForDeSEC{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := desec.NewChallengeProvider(&desec.ChallengeProviderConfig{
Token: access.Token,
Token: credentials.Token,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_digitalocean.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeDigitalOcean, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForDigitalOcean{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForDigitalOcean{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := digitalocean.NewChallengeProvider(&digitalocean.ChallengeProviderConfig{
AccessToken: access.AccessToken,
AccessToken: credentials.AccessToken,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_dnsla.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeDNSLA, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForDNSLA{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForDNSLA{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := dnsla.NewChallengeProvider(&dnsla.ChallengeProviderConfig{
ApiId: access.ApiId,
ApiSecret: access.ApiSecret,
ApiId: credentials.ApiId,
ApiSecret: credentials.ApiSecret,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_duckdns.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeDuckDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForDuckDNS{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForDuckDNS{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := duckdns.NewChallengeProvider(&duckdns.ChallengeProviderConfig{
Token: access.Token,
Token: credentials.Token,
DnsPropagationTimeout: options.DnsPropagationTimeout,
})
return provider, err
internal/certapply/applicators/sp_dynv6.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeDynv6, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForDynv6{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForDynv6{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := dynv6.NewChallengeProvider(&dynv6.ChallengeProviderConfig{
HttpToken: access.HttpToken,
HttpToken: credentials.HttpToken,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_gcore.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeGcore, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForGcore{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForGcore{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := gcore.NewChallengeProvider(&gcore.ChallengeProviderConfig{
ApiToken: access.ApiToken,
ApiToken: credentials.ApiToken,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_gname.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeGname, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForGname{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForGname{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := gname.NewChallengeProvider(&gname.ChallengeProviderConfig{
AppId: access.AppId,
AppKey: access.AppKey,
AppId: credentials.AppId,
AppKey: credentials.AppKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_godaddy.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeGoDaddy, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForGoDaddy{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForGoDaddy{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := godaddy.NewChallengeProvider(&godaddy.ChallengeProviderConfig{
ApiKey: access.ApiKey,
ApiSecret: access.ApiSecret,
ApiKey: credentials.ApiKey,
ApiSecret: credentials.ApiSecret,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_hetzner.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeHetzner, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForHetzner{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForHetzner{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := hetzner.NewChallengeProvider(&hetzner.ChallengeProviderConfig{
ApiToken: access.ApiToken,
ApiToken: credentials.ApiToken,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_huaweicloud_dns.go
+5 -5
View File
@@ -12,15 +12,15 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeHuaweiCloudDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForHuaweiCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForHuaweiCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := huaweicloud.NewChallengeProvider(&huaweicloud.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: xmaps.GetString(options.ProviderConfig, "region"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_jdcloud_dns.go
+5 -5
View File
@@ -12,15 +12,15 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeJDCloudDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForJDCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForJDCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := jdcloud.NewChallengeProvider(&jdcloud.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
RegionId: xmaps.GetString(options.ProviderConfig, "regionId"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
RegionId: xmaps.GetString(options.ProviderExtendedConfig, "regionId"),
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_local.go
+1 -1
View File
@@ -11,7 +11,7 @@ import (
func init() {
if err := ACMEHttp01Registries.Register(domain.ACMEHttp01ProviderTypeLocal, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
provider, err := local.NewChallengeProvider(&local.ChallengeProviderConfig{
WebRootPath: xmaps.GetString(options.ProviderConfig, "webRootPath"),
WebRootPath: xmaps.GetString(options.ProviderExtendedConfig, "webRootPath"),
})
return provider, err
}); err != nil {
internal/certapply/applicators/sp_namecheap.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeNamecheap, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForNamecheap{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForNamecheap{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := namecheap.NewChallengeProvider(&namecheap.ChallengeProviderConfig{
Username: access.Username,
ApiKey: access.ApiKey,
Username: credentials.Username,
ApiKey: credentials.ApiKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_namedotcom.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeNameDotCom, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForNameDotCom{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForNameDotCom{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := namedotcom.NewChallengeProvider(&namedotcom.ChallengeProviderConfig{
Username: access.Username,
ApiToken: access.ApiToken,
Username: credentials.Username,
ApiToken: credentials.ApiToken,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_namesilo.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeNameSilo, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForNameSilo{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForNameSilo{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := namesilo.NewChallengeProvider(&namesilo.ChallengeProviderConfig{
ApiKey: access.ApiKey,
ApiKey: credentials.ApiKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_netcup.go
+5 -5
View File
@@ -12,15 +12,15 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeNetcup, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForNetcup{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForNetcup{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := netcup.NewChallengeProvider(&netcup.ChallengeProviderConfig{
CustomerNumber: access.CustomerNumber,
ApiKey: access.ApiKey,
ApiPassword: access.ApiPassword,
CustomerNumber: credentials.CustomerNumber,
ApiKey: credentials.ApiKey,
ApiPassword: credentials.ApiPassword,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_netlify.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeNetlify, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForNetlify{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForNetlify{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := netlify.NewChallengeProvider(&netlify.ChallengeProviderConfig{
ApiToken: access.ApiToken,
ApiToken: credentials.ApiToken,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_ns1.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeNS1, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForNS1{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForNS1{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := ns1.NewChallengeProvider(&ns1.ChallengeProviderConfig{
ApiKey: access.ApiKey,
ApiKey: credentials.ApiKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_porkbun.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypePorkbun, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForPorkbun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForPorkbun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := porkbun.NewChallengeProvider(&porkbun.ChallengeProviderConfig{
ApiKey: access.ApiKey,
SecretApiKey: access.SecretApiKey,
ApiKey: credentials.ApiKey,
SecretApiKey: credentials.SecretApiKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_powerdns.go
+5 -5
View File
@@ -12,15 +12,15 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypePowerDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForPowerDNS{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForPowerDNS{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := powerdns.NewChallengeProvider(&powerdns.ChallengeProviderConfig{
ServerUrl: access.ServerUrl,
ApiKey: access.ApiKey,
AllowInsecureConnections: access.AllowInsecureConnections,
ServerUrl: credentials.ServerUrl,
ApiKey: credentials.ApiKey,
AllowInsecureConnections: credentials.AllowInsecureConnections,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_rainyun.go
+3 -3
View File
@@ -12,13 +12,13 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeRainYun, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForRainYun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForRainYun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := rainyun.NewChallengeProvider(&rainyun.ChallengeProviderConfig{
ApiKey: access.ApiKey,
ApiKey: credentials.ApiKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_spaceship.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeSpaceship, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForSpaceship{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForSpaceship{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := spaceship.NewChallengeProvider(&spaceship.ChallengeProviderConfig{
ApiKey: access.ApiKey,
ApiSecret: access.ApiSecret,
ApiKey: credentials.ApiKey,
ApiSecret: credentials.ApiSecret,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_tencentcloud_dns.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeTencentCloudDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForTencentCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForTencentCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := tencentcloud.NewChallengeProvider(&tencentcloud.ChallengeProviderConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
SecretId: credentials.SecretId,
SecretKey: credentials.SecretKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_tencentcloud_eo.go
+5 -5
View File
@@ -12,15 +12,15 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeTencentCloudEO, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForTencentCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForTencentCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := teo.NewChallengeProvider(&teo.ChallengeProviderConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
ZoneId: xmaps.GetString(options.ProviderConfig, "zoneId"),
SecretId: credentials.SecretId,
SecretKey: credentials.SecretKey,
ZoneId: xmaps.GetString(options.ProviderExtendedConfig, "zoneId"),
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_ucloud_udnr.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeUCloudUDNR, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForUCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForUCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := udnr.NewChallengeProvider(&udnr.ChallengeProviderConfig{
PrivateKey: access.PrivateKey,
PublicKey: access.PublicKey,
PrivateKey: credentials.PrivateKey,
PublicKey: credentials.PublicKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_vercel.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeVercel, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForVercel{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForVercel{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := vercel.NewChallengeProvider(&vercel.ChallengeProviderConfig{
ApiAccessToken: access.ApiAccessToken,
TeamId: access.TeamId,
ApiAccessToken: credentials.ApiAccessToken,
TeamId: credentials.TeamId,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_volcengine_dns.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeVolcEngineDNS, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForVolcEngine{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForVolcEngine{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := volcengine.NewChallengeProvider(&volcengine.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certapply/applicators/sp_westcn.go
+4 -4
View File
@@ -12,14 +12,14 @@ import (
func init() {
if err := ACMEDns01Registries.Register(domain.ACMEDns01ProviderTypeWestcn, func(options *ProviderFactoryOptions) (challenge.Provider, error) {
access := domain.AccessConfigForWestcn{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForWestcn{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := westcn.NewChallengeProvider(&westcn.ChallengeProviderConfig{
Username: access.Username,
ApiPassword: access.ApiPassword,
Username: credentials.Username,
ApiPassword: credentials.ApiPassword,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
})
internal/certdeploy/deployers/registry.go
+2 -2
View File
@@ -10,8 +10,8 @@ import (
type ProviderFactoryFunc func(options *ProviderFactoryOptions) (core.SSLDeployer, error)
type ProviderFactoryOptions struct {
AccessConfig map[string]any
ProviderConfig map[string]any
ProviderAccessConfig map[string]any
ProviderExtendedConfig map[string]any
}
type Registry[T comparable] interface {
internal/certdeploy/deployers/sp_1panel_console.go
+7 -7
View File
@@ -11,17 +11,17 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderType1PanelConsole, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigFor1Panel{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigFor1Panel{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := opconsole.NewSSLDeployerProvider(&opconsole.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiVersion: access.ApiVersion,
ApiKey: access.ApiKey,
AllowInsecureConnections: access.AllowInsecureConnections,
AutoRestart: xmaps.GetBool(options.ProviderConfig, "autoRestart"),
ServerUrl: credentials.ServerUrl,
ApiVersion: credentials.ApiVersion,
ApiKey: credentials.ApiKey,
AllowInsecureConnections: credentials.AllowInsecureConnections,
AutoRestart: xmaps.GetBool(options.ProviderExtendedConfig, "autoRestart"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_1panel_site.go
+10 -10
View File
@@ -11,20 +11,20 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderType1PanelSite, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigFor1Panel{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigFor1Panel{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := opsite.NewSSLDeployerProvider(&opsite.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiVersion: access.ApiVersion,
ApiKey: access.ApiKey,
AllowInsecureConnections: access.AllowInsecureConnections,
NodeName: xmaps.GetString(options.ProviderConfig, "nodeName"),
ResourceType: opsite.ResourceType(xmaps.GetOrDefaultString(options.ProviderConfig, "resourceType", string(opsite.RESOURCE_TYPE_WEBSITE))),
WebsiteId: xmaps.GetInt64(options.ProviderConfig, "websiteId"),
CertificateId: xmaps.GetInt64(options.ProviderConfig, "certificateId"),
ServerUrl: credentials.ServerUrl,
ApiVersion: credentials.ApiVersion,
ApiKey: credentials.ApiKey,
AllowInsecureConnections: credentials.AllowInsecureConnections,
NodeName: xmaps.GetString(options.ProviderExtendedConfig, "nodeName"),
ResourceType: opsite.ResourceType(xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "resourceType", string(opsite.RESOURCE_TYPE_WEBSITE))),
WebsiteId: xmaps.GetInt64(options.ProviderExtendedConfig, "websiteId"),
CertificateId: xmaps.GetInt64(options.ProviderExtendedConfig, "certificateId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_alb.go
+10 -10
View File
@@ -11,20 +11,20 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunALB, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunalb.NewSSLDeployerProvider(&aliyunalb.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ResourceType: aliyunalb.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderConfig, "loadbalancerId"),
ListenerId: xmaps.GetString(options.ProviderConfig, "listenerId"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ResourceType: aliyunalb.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderExtendedConfig, "loadbalancerId"),
ListenerId: xmaps.GetString(options.ProviderExtendedConfig, "listenerId"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_apigw.go
+10 -10
View File
@@ -11,20 +11,20 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunAPIGW, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunapigw.NewSSLDeployerProvider(&aliyunapigw.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ServiceType: aliyunapigw.ServiceType(xmaps.GetString(options.ProviderConfig, "serviceType")),
GatewayId: xmaps.GetString(options.ProviderConfig, "gatewayId"),
GroupId: xmaps.GetString(options.ProviderConfig, "groupId"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ServiceType: aliyunapigw.ServiceType(xmaps.GetString(options.ProviderExtendedConfig, "serviceType")),
GatewayId: xmaps.GetString(options.ProviderExtendedConfig, "gatewayId"),
GroupId: xmaps.GetString(options.ProviderExtendedConfig, "groupId"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_cas.go
+6 -6
View File
@@ -11,16 +11,16 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunCAS, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyuncas.NewSSLDeployerProvider(&aliyuncas.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_casdeploy.go
+8 -8
View File
@@ -14,18 +14,18 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunCASDeploy, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyuncasdeploy.NewSSLDeployerProvider(&aliyuncasdeploy.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ResourceIds: lo.Filter(strings.Split(xmaps.GetString(options.ProviderConfig, "resourceIds"), ";"), func(s string, _ int) bool { return s != "" }),
ContactIds: lo.Filter(strings.Split(xmaps.GetString(options.ProviderConfig, "contactIds"), ";"), func(s string, _ int) bool { return s != "" }),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ResourceIds: lo.Filter(strings.Split(xmaps.GetString(options.ProviderExtendedConfig, "resourceIds"), ";"), func(s string, _ int) bool { return s != "" }),
ContactIds: lo.Filter(strings.Split(xmaps.GetString(options.ProviderExtendedConfig, "contactIds"), ";"), func(s string, _ int) bool { return s != "" }),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_cdn.go
+6 -6
View File
@@ -11,16 +11,16 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyuncdn.NewSSLDeployerProvider(&aliyuncdn.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_clb.go
+10 -10
View File
@@ -11,20 +11,20 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunCLB, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunclb.NewSSLDeployerProvider(&aliyunclb.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ResourceType: aliyunclb.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderConfig, "loadbalancerId"),
ListenerPort: xmaps.GetOrDefaultInt32(options.ProviderConfig, "listenerPort", 443),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ResourceType: aliyunclb.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderExtendedConfig, "loadbalancerId"),
ListenerPort: xmaps.GetOrDefaultInt32(options.ProviderExtendedConfig, "listenerPort", 443),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_ddos.go
+7 -7
View File
@@ -11,17 +11,17 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunDDoS, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunddos.NewSSLDeployerProvider(&aliyunddos.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_esa.go
+6 -6
View File
@@ -11,16 +11,16 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunESA, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunesa.NewSSLDeployerProvider(&aliyunesa.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: xmaps.GetString(options.ProviderConfig, "region"),
SiteId: xmaps.GetInt64(options.ProviderConfig, "siteId"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
SiteId: xmaps.GetInt64(options.ProviderExtendedConfig, "siteId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_fc.go
+8 -8
View File
@@ -11,18 +11,18 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunFC, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunfc.NewSSLDeployerProvider(&aliyunfc.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ServiceVersion: xmaps.GetOrDefaultString(options.ProviderConfig, "serviceVersion", "3.0"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ServiceVersion: xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "serviceVersion", "3.0"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_ga.go
+9 -9
View File
@@ -11,19 +11,19 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunGA, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunga.NewSSLDeployerProvider(&aliyunga.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
ResourceType: aliyunga.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
AcceleratorId: xmaps.GetString(options.ProviderConfig, "acceleratorId"),
ListenerId: xmaps.GetString(options.ProviderConfig, "listenerId"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
ResourceType: aliyunga.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
AcceleratorId: xmaps.GetString(options.ProviderExtendedConfig, "acceleratorId"),
ListenerId: xmaps.GetString(options.ProviderExtendedConfig, "listenerId"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_live.go
+6 -6
View File
@@ -11,16 +11,16 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunLive, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunlive.NewSSLDeployerProvider(&aliyunlive.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: xmaps.GetString(options.ProviderConfig, "region"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_nlb.go
+9 -9
View File
@@ -11,19 +11,19 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunNLB, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunnlb.NewSSLDeployerProvider(&aliyunnlb.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ResourceType: aliyunnlb.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderConfig, "loadbalancerId"),
ListenerId: xmaps.GetString(options.ProviderConfig, "listenerId"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ResourceType: aliyunnlb.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderExtendedConfig, "loadbalancerId"),
ListenerId: xmaps.GetString(options.ProviderExtendedConfig, "listenerId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_oss.go
+8 -8
View File
@@ -11,18 +11,18 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunOSS, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunoss.NewSSLDeployerProvider(&aliyunoss.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
Bucket: xmaps.GetString(options.ProviderConfig, "bucket"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
Bucket: xmaps.GetString(options.ProviderExtendedConfig, "bucket"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_vod.go
+7 -7
View File
@@ -11,17 +11,17 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunVOD, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunvod.NewSSLDeployerProvider(&aliyunvod.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyun_waf.go
+9 -9
View File
@@ -11,19 +11,19 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunWAF, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyunwaf.NewSSLDeployerProvider(&aliyunwaf.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ServiceVersion: xmaps.GetOrDefaultString(options.ProviderConfig, "serviceVersion", "3.0"),
InstanceId: xmaps.GetString(options.ProviderConfig, "instanceId"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ServiceVersion: xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "serviceVersion", "3.0"),
InstanceId: xmaps.GetString(options.ProviderExtendedConfig, "instanceId"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aliyund_cdn.go
+6 -6
View File
@@ -11,16 +11,16 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAliyunDCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAliyun{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := aliyundcdn.NewSSLDeployerProvider(&aliyundcdn.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
ResourceGroupId: access.ResourceGroupId,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
ResourceGroupId: credentials.ResourceGroupId,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_apisix.go
+7 -7
View File
@@ -11,17 +11,17 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAPISIX, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAPISIX{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAPISIX{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := apisix.NewSSLDeployerProvider(&apisix.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiKey: access.ApiKey,
AllowInsecureConnections: access.AllowInsecureConnections,
ResourceType: apisix.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
CertificateId: xmaps.GetString(options.ProviderConfig, "certificateId"),
ServerUrl: credentials.ServerUrl,
ApiKey: credentials.ApiKey,
AllowInsecureConnections: credentials.AllowInsecureConnections,
ResourceType: apisix.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
CertificateId: xmaps.GetString(options.ProviderExtendedConfig, "certificateId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aws_acm.go
+6 -6
View File
@@ -11,16 +11,16 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAWSACM, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAWS{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAWS{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := awsacm.NewSSLDeployerProvider(&awsacm.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: xmaps.GetString(options.ProviderConfig, "region"),
CertificateArn: xmaps.GetString(options.ProviderConfig, "certificateArn"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
CertificateArn: xmaps.GetString(options.ProviderExtendedConfig, "certificateArn"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aws_cloudfront.go
+7 -7
View File
@@ -11,17 +11,17 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAWSCloudFront, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAWS{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAWS{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := awscloudfront.NewSSLDeployerProvider(&awscloudfront.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: xmaps.GetString(options.ProviderConfig, "region"),
DistributionId: xmaps.GetString(options.ProviderConfig, "distributionId"),
CertificateSource: xmaps.GetOrDefaultString(options.ProviderConfig, "certificateSource", "ACM"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
DistributionId: xmaps.GetString(options.ProviderExtendedConfig, "distributionId"),
CertificateSource: xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "certificateSource", "ACM"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_aws_iam.go
+6 -6
View File
@@ -11,16 +11,16 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAWSIAM, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAWS{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAWS{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := awsiam.NewSSLDeployerProvider(&awsiam.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: xmaps.GetString(options.ProviderConfig, "region"),
CertificatePath: xmaps.GetOrDefaultString(options.ProviderConfig, "certificatePath", "/"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
CertificatePath: xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "certificatePath", "/"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_azure_keyvault.go
+8 -8
View File
@@ -11,18 +11,18 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeAzureKeyVault, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForAzure{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForAzure{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := azurekeyvault.NewSSLDeployerProvider(&azurekeyvault.SSLDeployerProviderConfig{
TenantId: access.TenantId,
ClientId: access.ClientId,
ClientSecret: access.ClientSecret,
CloudName: access.CloudName,
KeyVaultName: xmaps.GetString(options.ProviderConfig, "keyvaultName"),
CertificateName: xmaps.GetString(options.ProviderConfig, "certificateName"),
TenantId: credentials.TenantId,
ClientId: credentials.ClientId,
ClientSecret: credentials.ClientSecret,
CloudName: credentials.CloudName,
KeyVaultName: xmaps.GetString(options.ProviderExtendedConfig, "keyvaultName"),
CertificateName: xmaps.GetString(options.ProviderExtendedConfig, "certificateName"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_baiducloud_appblb.go
+9 -9
View File
@@ -11,19 +11,19 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBaiduCloudAppBLB, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBaiduCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBaiduCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := baiducloudappblb.NewSSLDeployerProvider(&baiducloudappblb.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ResourceType: baiducloudappblb.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderConfig, "loadbalancerId"),
ListenerPort: xmaps.GetInt32(options.ProviderConfig, "listenerPort"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ResourceType: baiducloudappblb.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderExtendedConfig, "loadbalancerId"),
ListenerPort: xmaps.GetInt32(options.ProviderExtendedConfig, "listenerPort"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_baiducloud_blb.go
+9 -9
View File
@@ -11,19 +11,19 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBaiduCloudBLB, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBaiduCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBaiduCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := baiducloudblb.NewSSLDeployerProvider(&baiducloudblb.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ResourceType: baiducloudblb.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderConfig, "loadbalancerId"),
ListenerPort: xmaps.GetInt32(options.ProviderConfig, "listenerPort"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ResourceType: baiducloudblb.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderExtendedConfig, "loadbalancerId"),
ListenerPort: xmaps.GetInt32(options.ProviderExtendedConfig, "listenerPort"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_baiducloud_cdn.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBaiduCloudCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBaiduCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBaiduCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := baiducloudcdn.NewSSLDeployerProvider(&baiducloudcdn.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_baiducloud_cert.go
+4 -4
View File
@@ -11,14 +11,14 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBaiduCloudCert, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBaiduCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBaiduCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := baiducloudcert.NewSSLDeployerProvider(&baiducloudcert.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_baishan_cdn.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBaishanCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBaishan{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBaishan{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := baishancdn.NewSSLDeployerProvider(&baishancdn.SSLDeployerProviderConfig{
ApiToken: access.ApiToken,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
CertificateId: xmaps.GetString(options.ProviderConfig, "certificateId"),
ApiToken: credentials.ApiToken,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
CertificateId: xmaps.GetString(options.ProviderExtendedConfig, "certificateId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_baotapanel_console.go
+6 -6
View File
@@ -11,16 +11,16 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBaotaPanelConsole, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBaotaPanel{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBaotaPanel{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := baotapanelconsole.NewSSLDeployerProvider(&baotapanelconsole.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiKey: access.ApiKey,
AllowInsecureConnections: access.AllowInsecureConnections,
AutoRestart: xmaps.GetBool(options.ProviderConfig, "autoRestart"),
ServerUrl: credentials.ServerUrl,
ApiKey: credentials.ApiKey,
AllowInsecureConnections: credentials.AllowInsecureConnections,
AutoRestart: xmaps.GetBool(options.ProviderExtendedConfig, "autoRestart"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_baotapanel_site.go
+8 -8
View File
@@ -14,18 +14,18 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBaotaPanelSite, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBaotaPanel{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBaotaPanel{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := baotapanelsite.NewSSLDeployerProvider(&baotapanelsite.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiKey: access.ApiKey,
AllowInsecureConnections: access.AllowInsecureConnections,
SiteType: xmaps.GetOrDefaultString(options.ProviderConfig, "siteType", "other"),
SiteName: xmaps.GetString(options.ProviderConfig, "siteName"),
SiteNames: lo.Filter(strings.Split(xmaps.GetString(options.ProviderConfig, "siteNames"), ";"), func(s string, _ int) bool { return s != "" }),
ServerUrl: credentials.ServerUrl,
ApiKey: credentials.ApiKey,
AllowInsecureConnections: credentials.AllowInsecureConnections,
SiteType: xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "siteType", "other"),
SiteName: xmaps.GetString(options.ProviderExtendedConfig, "siteName"),
SiteNames: lo.Filter(strings.Split(xmaps.GetString(options.ProviderExtendedConfig, "siteNames"), ";"), func(s string, _ int) bool { return s != "" }),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_baotawaf_console.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBaotaWAFConsole, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBaotaWAF{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBaotaWAF{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := baotawafconsole.NewSSLDeployerProvider(&baotawafconsole.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiKey: access.ApiKey,
AllowInsecureConnections: access.AllowInsecureConnections,
ServerUrl: credentials.ServerUrl,
ApiKey: credentials.ApiKey,
AllowInsecureConnections: credentials.AllowInsecureConnections,
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_baotawaf_site.go
+7 -7
View File
@@ -11,17 +11,17 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBaotaWAFSite, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBaotaWAF{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBaotaWAF{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := baotawafsite.NewSSLDeployerProvider(&baotawafsite.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiKey: access.ApiKey,
AllowInsecureConnections: access.AllowInsecureConnections,
SiteName: xmaps.GetString(options.ProviderConfig, "siteName"),
SitePort: xmaps.GetOrDefaultInt32(options.ProviderConfig, "sitePort", 443),
ServerUrl: credentials.ServerUrl,
ApiKey: credentials.ApiKey,
AllowInsecureConnections: credentials.AllowInsecureConnections,
SiteName: xmaps.GetString(options.ProviderExtendedConfig, "siteName"),
SitePort: xmaps.GetOrDefaultInt32(options.ProviderExtendedConfig, "sitePort", 443),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_bunny_cdn.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBunnyCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBunny{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBunny{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := bunnycdn.NewSSLDeployerProvider(&bunnycdn.SSLDeployerProviderConfig{
ApiKey: access.ApiKey,
PullZoneId: xmaps.GetString(options.ProviderConfig, "pullZoneId"),
Hostname: xmaps.GetString(options.ProviderConfig, "hostname"),
ApiKey: credentials.ApiKey,
PullZoneId: xmaps.GetString(options.ProviderExtendedConfig, "pullZoneId"),
Hostname: xmaps.GetString(options.ProviderExtendedConfig, "hostname"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_byteplus_cdn.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeBytePlusCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForBytePlus{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForBytePlus{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := bytepluscdn.NewSSLDeployerProvider(&bytepluscdn.SSLDeployerProviderConfig{
AccessKey: access.AccessKey,
SecretKey: access.SecretKey,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKey: credentials.AccessKey,
SecretKey: credentials.SecretKey,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_cachefly.go
+3 -3
View File
@@ -11,13 +11,13 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeCacheFly, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForCacheFly{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCacheFly{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := cachefly.NewSSLDeployerProvider(&cachefly.SSLDeployerProviderConfig{
ApiToken: access.ApiToken,
ApiToken: credentials.ApiToken,
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_cdnfly.go
+9 -9
View File
@@ -11,19 +11,19 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeCdnfly, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForCdnfly{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCdnfly{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
deployer, err := cdnfly.NewSSLDeployerProvider(&cdnfly.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiKey: access.ApiKey,
ApiSecret: access.ApiSecret,
AllowInsecureConnections: access.AllowInsecureConnections,
ResourceType: cdnfly.ResourceType(xmaps.GetOrDefaultString(options.ProviderConfig, "resourceType", string(cdnfly.RESOURCE_TYPE_SITE))),
SiteId: xmaps.GetString(options.ProviderConfig, "siteId"),
CertificateId: xmaps.GetString(options.ProviderConfig, "certificateId"),
ServerUrl: credentials.ServerUrl,
ApiKey: credentials.ApiKey,
ApiSecret: credentials.ApiSecret,
AllowInsecureConnections: credentials.AllowInsecureConnections,
ResourceType: cdnfly.ResourceType(xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "resourceType", string(cdnfly.RESOURCE_TYPE_SITE))),
SiteId: xmaps.GetString(options.ProviderExtendedConfig, "siteId"),
CertificateId: xmaps.GetString(options.ProviderExtendedConfig, "certificateId"),
})
return deployer, err
}); err != nil {
internal/certdeploy/deployers/sp_ctcccloud_ao.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeCTCCCloudAO, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := ctcccloudao.NewSSLDeployerProvider(&ctcccloudao.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_ctcccloud_cdn.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeCTCCCloudCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := ctcccloudcdn.NewSSLDeployerProvider(&ctcccloudcdn.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_ctcccloud_cms.go
+4 -4
View File
@@ -11,14 +11,14 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeCTCCCloudCMS, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := ctcccloudcms.NewSSLDeployerProvider(&ctcccloudcms.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_ctcccloud_elb.go
+8 -8
View File
@@ -11,18 +11,18 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeCTCCCloudELB, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := ctcccloudelb.NewSSLDeployerProvider(&ctcccloudelb.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
RegionId: xmaps.GetString(options.ProviderConfig, "regionId"),
ResourceType: ctcccloudelb.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderConfig, "loadbalancerId"),
ListenerId: xmaps.GetString(options.ProviderConfig, "listenerId"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
RegionId: xmaps.GetString(options.ProviderExtendedConfig, "regionId"),
ResourceType: ctcccloudelb.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderExtendedConfig, "loadbalancerId"),
ListenerId: xmaps.GetString(options.ProviderExtendedConfig, "listenerId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_ctcccloud_icdn.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeCTCCCloudICDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := ctcccloudicdn.NewSSLDeployerProvider(&ctcccloudicdn.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_ctcccloud_lvdn.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeCTCCCloudLVDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForCTCCCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := ctcccloudlvdn.NewSSLDeployerProvider(&ctcccloudlvdn.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_dogecloud_cdn.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeDogeCloudCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForDogeCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForDogeCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := pDogeCDN.NewSSLDeployerProvider(&pDogeCDN.SSLDeployerProviderConfig{
AccessKey: access.AccessKey,
SecretKey: access.SecretKey,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKey: credentials.AccessKey,
SecretKey: credentials.SecretKey,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_edgio_applications.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeEdgioApplications, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForEdgio{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForEdgio{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := edgioapps.NewSSLDeployerProvider(&edgioapps.SSLDeployerProviderConfig{
ClientId: access.ClientId,
ClientSecret: access.ClientSecret,
EnvironmentId: xmaps.GetString(options.ProviderConfig, "environmentId"),
ClientId: credentials.ClientId,
ClientSecret: credentials.ClientSecret,
EnvironmentId: xmaps.GetString(options.ProviderExtendedConfig, "environmentId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_flexcdn.go
+9 -9
View File
@@ -11,19 +11,19 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeFlexCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForFlexCDN{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForFlexCDN{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := flexcdn.NewSSLDeployerProvider(&flexcdn.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiRole: access.ApiRole,
AccessKeyId: access.AccessKeyId,
AccessKey: access.AccessKey,
AllowInsecureConnections: access.AllowInsecureConnections,
ResourceType: flexcdn.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
CertificateId: xmaps.GetInt64(options.ProviderConfig, "certificateId"),
ServerUrl: credentials.ServerUrl,
ApiRole: credentials.ApiRole,
AccessKeyId: credentials.AccessKeyId,
AccessKey: credentials.AccessKey,
AllowInsecureConnections: credentials.AllowInsecureConnections,
ResourceType: flexcdn.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
CertificateId: xmaps.GetInt64(options.ProviderExtendedConfig, "certificateId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_gcore_cdn.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeGcoreCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForGcore{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForGcore{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := gcorecdn.NewSSLDeployerProvider(&gcorecdn.SSLDeployerProviderConfig{
ApiToken: access.ApiToken,
ResourceId: xmaps.GetInt64(options.ProviderConfig, "resourceId"),
CertificateId: xmaps.GetInt64(options.ProviderConfig, "certificateId"),
ApiToken: credentials.ApiToken,
ResourceId: xmaps.GetInt64(options.ProviderExtendedConfig, "resourceId"),
CertificateId: xmaps.GetInt64(options.ProviderExtendedConfig, "certificateId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_goedge.go
+9 -9
View File
@@ -11,19 +11,19 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeGoEdge, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForGoEdge{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForGoEdge{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := goedge.NewSSLDeployerProvider(&goedge.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiRole: access.ApiRole,
AccessKeyId: access.AccessKeyId,
AccessKey: access.AccessKey,
AllowInsecureConnections: access.AllowInsecureConnections,
ResourceType: goedge.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
CertificateId: xmaps.GetInt64(options.ProviderConfig, "certificateId"),
ServerUrl: credentials.ServerUrl,
ApiRole: credentials.ApiRole,
AccessKeyId: credentials.AccessKeyId,
AccessKey: credentials.AccessKey,
AllowInsecureConnections: credentials.AllowInsecureConnections,
ResourceType: goedge.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
CertificateId: xmaps.GetInt64(options.ProviderExtendedConfig, "certificateId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_huaweicloud_cdn.go
+7 -7
View File
@@ -11,17 +11,17 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeHuaweiCloudCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForHuaweiCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForHuaweiCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := huaweicloudcdn.NewSSLDeployerProvider(&huaweicloudcdn.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
EnterpriseProjectId: access.EnterpriseProjectId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
EnterpriseProjectId: credentials.EnterpriseProjectId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_huaweicloud_elb.go
+10 -10
View File
@@ -11,20 +11,20 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeHuaweiCloudELB, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForHuaweiCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForHuaweiCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := huaweicloudelb.NewSSLDeployerProvider(&huaweicloudelb.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
EnterpriseProjectId: access.EnterpriseProjectId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ResourceType: huaweicloudelb.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
CertificateId: xmaps.GetString(options.ProviderConfig, "certificateId"),
LoadbalancerId: xmaps.GetString(options.ProviderConfig, "loadbalancerId"),
ListenerId: xmaps.GetString(options.ProviderConfig, "listenerId"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
EnterpriseProjectId: credentials.EnterpriseProjectId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ResourceType: huaweicloudelb.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
CertificateId: xmaps.GetString(options.ProviderExtendedConfig, "certificateId"),
LoadbalancerId: xmaps.GetString(options.ProviderExtendedConfig, "loadbalancerId"),
ListenerId: xmaps.GetString(options.ProviderExtendedConfig, "listenerId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_huaweicloud_scm.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeHuaweiCloudSCM, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForHuaweiCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForHuaweiCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := huaweicloudscm.NewSSLDeployerProvider(&huaweicloudscm.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
EnterpriseProjectId: access.EnterpriseProjectId,
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
EnterpriseProjectId: credentials.EnterpriseProjectId,
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_huaweicloud_waf.go
+9 -9
View File
@@ -11,19 +11,19 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeHuaweiCloudWAF, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForHuaweiCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForHuaweiCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := huaweicloudwaf.NewSSLDeployerProvider(&huaweicloudwaf.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
EnterpriseProjectId: access.EnterpriseProjectId,
Region: xmaps.GetString(options.ProviderConfig, "region"),
ResourceType: huaweicloudwaf.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
CertificateId: xmaps.GetString(options.ProviderConfig, "certificateId"),
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
SecretAccessKey: credentials.SecretAccessKey,
EnterpriseProjectId: credentials.EnterpriseProjectId,
Region: xmaps.GetString(options.ProviderExtendedConfig, "region"),
ResourceType: huaweicloudwaf.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
CertificateId: xmaps.GetString(options.ProviderExtendedConfig, "certificateId"),
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_jdcloud_alb.go
+8 -8
View File
@@ -11,18 +11,18 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeJDCloudALB, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForJDCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForJDCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := jdcloudalb.NewSSLDeployerProvider(&jdcloudalb.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
RegionId: xmaps.GetString(options.ProviderConfig, "regionId"),
ResourceType: jdcloudalb.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderConfig, "loadbalancerId"),
ListenerId: xmaps.GetString(options.ProviderConfig, "listenerId"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
RegionId: xmaps.GetString(options.ProviderExtendedConfig, "regionId"),
ResourceType: jdcloudalb.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
LoadbalancerId: xmaps.GetString(options.ProviderExtendedConfig, "loadbalancerId"),
ListenerId: xmaps.GetString(options.ProviderExtendedConfig, "listenerId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_jdcloud_cdn.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeJDCloudCDN, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForJDCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForJDCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := jdcloudcdn.NewSSLDeployerProvider(&jdcloudcdn.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_jdcloud_live.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeJDCloudLive, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForJDCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForJDCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := jdcloudlive.NewSSLDeployerProvider(&jdcloudlive.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_jdcloud_vod.go
+5 -5
View File
@@ -11,15 +11,15 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeJDCloudVOD, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForJDCloud{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForJDCloud{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := jdcloudvod.NewSSLDeployerProvider(&jdcloudvod.SSLDeployerProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Domain: xmaps.GetString(options.ProviderConfig, "domain"),
AccessKeyId: credentials.AccessKeyId,
AccessKeySecret: credentials.AccessKeySecret,
Domain: xmaps.GetString(options.ProviderExtendedConfig, "domain"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_kong.go
+8 -8
View File
@@ -11,18 +11,18 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeKong, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForKong{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForKong{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := kong.NewSSLDeployerProvider(&kong.SSLDeployerProviderConfig{
ServerUrl: access.ServerUrl,
ApiToken: access.ApiToken,
AllowInsecureConnections: access.AllowInsecureConnections,
ResourceType: kong.ResourceType(xmaps.GetString(options.ProviderConfig, "resourceType")),
Workspace: xmaps.GetString(options.ProviderConfig, "workspace"),
CertificateId: xmaps.GetString(options.ProviderConfig, "certificateId"),
ServerUrl: credentials.ServerUrl,
ApiToken: credentials.ApiToken,
AllowInsecureConnections: credentials.AllowInsecureConnections,
ResourceType: kong.ResourceType(xmaps.GetString(options.ProviderExtendedConfig, "resourceType")),
Workspace: xmaps.GetString(options.ProviderExtendedConfig, "workspace"),
CertificateId: xmaps.GetString(options.ProviderExtendedConfig, "certificateId"),
})
return provider, err
}); err != nil {
internal/certdeploy/deployers/sp_kubernetes_secret.go
+8 -8
View File
@@ -11,18 +11,18 @@ import (
func init() {
if err := Registries.Register(domain.DeploymentProviderTypeKubernetesSecret, func(options *ProviderFactoryOptions) (core.SSLDeployer, error) {
access := domain.AccessConfigForKubernetes{}
if err := xmaps.Populate(options.AccessConfig, &access); err != nil {
credentials := domain.AccessConfigForKubernetes{}
if err := xmaps.Populate(options.ProviderAccessConfig, &credentials); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
provider, err := k8ssecret.NewSSLDeployerProvider(&k8ssecret.SSLDeployerProviderConfig{
KubeConfig: access.KubeConfig,
Namespace: xmaps.GetOrDefaultString(options.ProviderConfig, "namespace", "default"),
SecretName: xmaps.GetString(options.ProviderConfig, "secretName"),
SecretType: xmaps.GetOrDefaultString(options.ProviderConfig, "secretType", "kubernetes.io/tls"),
SecretDataKeyForCrt: xmaps.GetOrDefaultString(options.ProviderConfig, "secretDataKeyForCrt", "tls.crt"),
SecretDataKeyForKey: xmaps.GetOrDefaultString(options.ProviderConfig, "secretDataKeyForKey", "tls.key"),
KubeConfig: credentials.KubeConfig,
Namespace: xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "namespace", "default"),
SecretName: xmaps.GetString(options.ProviderExtendedConfig, "secretName"),
SecretType: xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "secretType", "kubernetes.io/tls"),
SecretDataKeyForCrt: xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "secretDataKeyForCrt", "tls.crt"),
SecretDataKeyForKey: xmaps.GetOrDefaultString(options.ProviderExtendedConfig, "secretDataKeyForKey", "tls.key"),
})
return provider, err
}); err != nil {

Some files were not shown because too many files have changed in this diff Show More