wood/certimate
1
0
Fork 0
mirror of https://github.com/woodchen-ink/certimate.git synced 2025-07-18 17:31:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: normalize providers constructors

Browse Source
This commit is contained in:
Fu Diwei 2025-02-18 19:18:28 +08:00
parent 1bac6174ad
commit ff53866e9e
132 changed files with 1014 additions and 1160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
internal/applicant/providers.go
View File

@ -41,7 +41,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pACMEHttpReq.NewChallengeProvider(&pACMEHttpReq.ACMEHttpReqApplicantConfig{
applicant, err := pACMEHttpReq.NewChallengeProvider(&pACMEHttpReq.ChallengeProviderConfig{
Endpoint: access.Endpoint,
Mode: access.Mode,
Username: access.Username,
@ -58,7 +58,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pAliyun.NewChallengeProvider(&pAliyun.AliyunApplicantConfig{
applicant, err := pAliyun.NewChallengeProvider(&pAliyun.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
DnsPropagationTimeout: options.DnsPropagationTimeout,
@ -74,7 +74,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pAWSRoute53.NewChallengeProvider(&pAWSRoute53.AWSRoute53ApplicantConfig{
applicant, err := pAWSRoute53.NewChallengeProvider(&pAWSRoute53.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: maps.GetValueAsString(options.ProviderApplyConfig, "region"),
@ -92,7 +92,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pAzureDNS.NewChallengeProvider(&pAzureDNS.AzureDNSApplicantConfig{
applicant, err := pAzureDNS.NewChallengeProvider(&pAzureDNS.ChallengeProviderConfig{
TenantId: access.TenantId,
ClientId: access.ClientId,
ClientSecret: access.ClientSecret,
@ -110,7 +110,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pBaiduCloud.NewChallengeProvider(&pBaiduCloud.BaiduCloudApplicantConfig{
applicant, err := pBaiduCloud.NewChallengeProvider(&pBaiduCloud.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
@ -126,7 +126,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pCloudflare.NewChallengeProvider(&pCloudflare.CloudflareApplicantConfig{
applicant, err := pCloudflare.NewChallengeProvider(&pCloudflare.ChallengeProviderConfig{
DnsApiToken: access.DnsApiToken,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
@ -141,7 +141,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pClouDNS.NewChallengeProvider(&pClouDNS.ClouDNSApplicantConfig{
applicant, err := pClouDNS.NewChallengeProvider(&pClouDNS.ChallengeProviderConfig{
AuthId: access.AuthId,
AuthPassword: access.AuthPassword,
DnsPropagationTimeout: options.DnsPropagationTimeout,
@ -157,7 +157,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pGcore.NewChallengeProvider(&pGcore.GcoreApplicantConfig{
applicant, err := pGcore.NewChallengeProvider(&pGcore.ChallengeProviderConfig{
ApiToken: access.ApiToken,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
@ -172,7 +172,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pGname.NewChallengeProvider(&pGname.GnameApplicantConfig{
applicant, err := pGname.NewChallengeProvider(&pGname.ChallengeProviderConfig{
AppId: access.AppId,
AppKey: access.AppKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
@ -188,7 +188,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pGoDaddy.NewChallengeProvider(&pGoDaddy.GoDaddyApplicantConfig{
applicant, err := pGoDaddy.NewChallengeProvider(&pGoDaddy.ChallengeProviderConfig{
ApiKey: access.ApiKey,
ApiSecret: access.ApiSecret,
DnsPropagationTimeout: options.DnsPropagationTimeout,
@ -204,7 +204,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pHuaweiCloud.NewChallengeProvider(&pHuaweiCloud.HuaweiCloudApplicantConfig{
applicant, err := pHuaweiCloud.NewChallengeProvider(&pHuaweiCloud.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: maps.GetValueAsString(options.ProviderApplyConfig, "region"),
@ -221,7 +221,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pNameDotCom.NewChallengeProvider(&pNameDotCom.NameDotComApplicantConfig{
applicant, err := pNameDotCom.NewChallengeProvider(&pNameDotCom.ChallengeProviderConfig{
Username: access.Username,
ApiToken: access.ApiToken,
DnsPropagationTimeout: options.DnsPropagationTimeout,
@ -237,7 +237,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pNameSilo.NewChallengeProvider(&pNameSilo.NameSiloApplicantConfig{
applicant, err := pNameSilo.NewChallengeProvider(&pNameSilo.ChallengeProviderConfig{
ApiKey: access.ApiKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
@ -252,7 +252,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pNS1.NewChallengeProvider(&pNS1.NS1ApplicantConfig{
applicant, err := pNS1.NewChallengeProvider(&pNS1.ChallengeProviderConfig{
ApiKey: access.ApiKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
@ -267,7 +267,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pPowerDNS.NewChallengeProvider(&pPowerDNS.PowerDNSApplicantConfig{
applicant, err := pPowerDNS.NewChallengeProvider(&pPowerDNS.ChallengeProviderConfig{
ApiUrl: access.ApiUrl,
ApiKey: access.ApiKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
@ -283,7 +283,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pRainYun.NewChallengeProvider(&pRainYun.RainYunApplicantConfig{
applicant, err := pRainYun.NewChallengeProvider(&pRainYun.ChallengeProviderConfig{
ApiKey: access.ApiKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL,
@ -298,7 +298,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pTencentCloud.NewChallengeProvider(&pTencentCloud.TencentCloudApplicantConfig{
applicant, err := pTencentCloud.NewChallengeProvider(&pTencentCloud.ChallengeProviderConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
@ -314,7 +314,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pVolcEngine.NewChallengeProvider(&pVolcEngine.VolcEngineApplicantConfig{
applicant, err := pVolcEngine.NewChallengeProvider(&pVolcEngine.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
DnsPropagationTimeout: options.DnsPropagationTimeout,
@ -330,7 +330,7 @@ func createApplicant(options *applicantOptions) (challenge.Provider, error) {
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
applicant, err := pWestcn.NewChallengeProvider(&pWestcn.WestcnApplicantConfig{
applicant, err := pWestcn.NewChallengeProvider(&pWestcn.ChallengeProviderConfig{
Username: access.Username,
ApiPassword: access.ApiPassword,
DnsPropagationTimeout: options.DnsPropagationTimeout,

4
internal/deployer/deployer.go
View File

@ -42,7 +42,7 @@ func NewWithDeployNode(node *domain.WorkflowNode, certdata struct {
return nil, fmt.Errorf("failed to unmarshal access config: %w", err)
}
deployer, logger, err := createDeployer(&deployerOptions{
deployer, err := createDeployer(&deployerOptions{
Provider: domain.DeployProviderType(nodeConfig.Provider),
ProviderAccessConfig: accessConfig,
ProviderDeployConfig: nodeConfig.ProviderConfig,
@ -52,7 +52,7 @@ func NewWithDeployNode(node *domain.WorkflowNode, certdata struct {
}
return &proxyDeployer{
logger: logger,
logger: logger.NewNilLogger(),
deployer: deployer,
deployCertificate: certdata.Certificate,
deployPrivateKey: certdata.PrivateKey,

329
internal/deployer/providers.go
View File

@ -53,14 +53,11 @@ import (
pVolcEngineLive "github.com/usual2970/certimate/internal/pkg/core/deployer/providers/volcengine-live"
pVolcEngineTOS "github.com/usual2970/certimate/internal/pkg/core/deployer/providers/volcengine-tos"
pWebhook "github.com/usual2970/certimate/internal/pkg/core/deployer/providers/webhook"
"github.com/usual2970/certimate/internal/pkg/core/logger"
"github.com/usual2970/certimate/internal/pkg/utils/maps"
"github.com/usual2970/certimate/internal/pkg/utils/slices"
)
func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger, error) {
logger := logger.NewDefaultLogger()
func createDeployer(options *deployerOptions) (deployer.Deployer, error) {
/*
注意：如果追加新的常量值，请保持以 ASCII 排序。
NOTICE: If you add new constant, please keep ASCII order.
@ -70,12 +67,12 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForAliyun{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeAliyunALB:
deployer, err := pAliyunALB.NewWithLogger(&pAliyunALB.AliyunALBDeployerConfig{
deployer, err := pAliyunALB.NewDeployer(&pAliyunALB.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
@ -83,29 +80,29 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
LoadbalancerId: maps.GetValueAsString(options.ProviderDeployConfig, "loadbalancerId"),
ListenerId: maps.GetValueAsString(options.ProviderDeployConfig, "listenerId"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeAliyunCASDeploy:
deployer, err := pAliyunCASDeploy.NewWithLogger(&pAliyunCASDeploy.AliyunCASDeployDeployerConfig{
deployer, err := pAliyunCASDeploy.NewDeployer(&pAliyunCASDeploy.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
ResourceIds: slices.Filter(strings.Split(maps.GetValueAsString(options.ProviderDeployConfig, "resourceIds"), ";"), func(s string) bool { return s != "" }),
ContactIds: slices.Filter(strings.Split(maps.GetValueAsString(options.ProviderDeployConfig, "contactIds"), ";"), func(s string) bool { return s != "" }),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeAliyunCDN:
deployer, err := pAliyunCDN.NewWithLogger(&pAliyunCDN.AliyunCDNDeployerConfig{
deployer, err := pAliyunCDN.NewDeployer(&pAliyunCDN.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeAliyunCLB:
deployer, err := pAliyunCLB.NewWithLogger(&pAliyunCLB.AliyunCLBDeployerConfig{
deployer, err := pAliyunCLB.NewDeployer(&pAliyunCLB.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
@ -113,64 +110,64 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
LoadbalancerId: maps.GetValueAsString(options.ProviderDeployConfig, "loadbalancerId"),
ListenerPort: maps.GetValueOrDefaultAsInt32(options.ProviderDeployConfig, "listenerPort", 443),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeAliyunDCDN:
deployer, err := pAliyunDCDN.NewWithLogger(&pAliyunDCDN.AliyunDCDNDeployerConfig{
deployer, err := pAliyunDCDN.NewDeployer(&pAliyunDCDN.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeAliyunESA:
deployer, err := pAliyunESA.NewWithLogger(&pAliyunESA.AliyunESADeployerConfig{
deployer, err := pAliyunESA.NewDeployer(&pAliyunESA.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
SiteId: maps.GetValueAsInt64(options.ProviderDeployConfig, "siteId"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeAliyunLive:
deployer, err := pAliyunLive.NewWithLogger(&pAliyunLive.AliyunLiveDeployerConfig{
deployer, err := pAliyunLive.NewDeployer(&pAliyunLive.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeAliyunNLB:
deployer, err := pAliyunNLB.NewWithLogger(&pAliyunNLB.AliyunNLBDeployerConfig{
deployer, err := pAliyunNLB.NewDeployer(&pAliyunNLB.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
ResourceType: pAliyunNLB.ResourceType(maps.GetValueAsString(options.ProviderDeployConfig, "resourceType")),
LoadbalancerId: maps.GetValueAsString(options.ProviderDeployConfig, "loadbalancerId"),
ListenerId: maps.GetValueAsString(options.ProviderDeployConfig, "listenerId"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeAliyunOSS:
deployer, err := pAliyunOSS.NewWithLogger(&pAliyunOSS.AliyunOSSDeployerConfig{
deployer, err := pAliyunOSS.NewDeployer(&pAliyunOSS.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
Bucket: maps.GetValueAsString(options.ProviderDeployConfig, "bucket"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeAliyunWAF:
deployer, err := pAliyunWAF.NewWithLogger(&pAliyunWAF.AliyunWAFDeployerConfig{
deployer, err := pAliyunWAF.NewDeployer(&pAliyunWAF.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
InstanceId: maps.GetValueAsString(options.ProviderDeployConfig, "instanceId"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -181,18 +178,18 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForAWS{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeAWSCloudFront:
deployer, err := pAWSCloudFront.NewWithLogger(&pAWSCloudFront.AWSCloudFrontDeployerConfig{
deployer, err := pAWSCloudFront.NewDeployer(&pAWSCloudFront.DeployerConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
DistributionId: maps.GetValueAsString(options.ProviderDeployConfig, "distributionId"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -203,17 +200,17 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForBaiduCloud{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeBaiduCloudCDN:
deployer, err := pBaiduCloudCDN.NewWithLogger(&pBaiduCloudCDN.BaiduCloudCDNDeployerConfig{
deployer, err := pBaiduCloudCDN.NewDeployer(&pBaiduCloudCDN.DeployerConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -224,16 +221,16 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForBaishan{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeBaishanCDN:
deployer, err := pBaishanCDN.NewWithLogger(&pBaishanCDN.BaishanCDNDeployerConfig{
deployer, err := pBaishanCDN.NewDeployer(&pBaishanCDN.DeployerConfig{
ApiToken: access.ApiToken,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -244,27 +241,27 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForBaotaPanel{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeBaotaPanelConsole:
deployer, err := pBaotaPanelConsole.NewWithLogger(&pBaotaPanelConsole.BaotaPanelConsoleDeployerConfig{
deployer, err := pBaotaPanelConsole.NewDeployer(&pBaotaPanelConsole.DeployerConfig{
ApiUrl: access.ApiUrl,
ApiKey: access.ApiKey,
AutoRestart: maps.GetValueAsBool(options.ProviderDeployConfig, "autoRestart"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeBaotaPanelSite:
deployer, err := pBaotaPanelSite.NewWithLogger(&pBaotaPanelSite.BaotaPanelSiteDeployerConfig{
deployer, err := pBaotaPanelSite.NewDeployer(&pBaotaPanelSite.DeployerConfig{
ApiUrl: access.ApiUrl,
ApiKey: access.ApiKey,
SiteType: maps.GetValueOrDefaultAsString(options.ProviderDeployConfig, "siteType", "other"),
SiteName: maps.GetValueAsString(options.ProviderDeployConfig, "siteName"),
SiteNames: slices.Filter(strings.Split(maps.GetValueAsString(options.ProviderDeployConfig, "siteNames"), ";"), func(s string) bool { return s != "" }),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -275,17 +272,17 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForBytePlus{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeBytePlusCDN:
deployer, err := pBytePlusCDN.NewWithLogger(&pBytePlusCDN.BytePlusCDNDeployerConfig{
deployer, err := pBytePlusCDN.NewDeployer(&pBytePlusCDN.DeployerConfig{
AccessKey: access.AccessKey,
SecretKey: access.SecretKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -296,77 +293,77 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForCacheFly{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
deployer, err := pCacheFly.NewWithLogger(&pCacheFly.CacheFlyDeployerConfig{
deployer, err := pCacheFly.NewDeployer(&pCacheFly.DeployerConfig{
ApiToken: access.ApiToken,
}, logger)
return deployer, logger, err
})
return deployer, err
}
case domain.DeployProviderTypeCdnfly:
{
access := domain.AccessConfigForCdnfly{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
deployer, err := pCdnfly.NewWithLogger(&pCdnfly.CdnflyDeployerConfig{
deployer, err := pCdnfly.NewDeployer(&pCdnfly.DeployerConfig{
ApiUrl: access.ApiUrl,
ApiKey: access.ApiKey,
ApiSecret: access.ApiSecret,
ResourceType: pCdnfly.ResourceType(maps.GetValueAsString(options.ProviderDeployConfig, "resourceType")),
SiteId: maps.GetValueAsString(options.ProviderDeployConfig, "siteId"),
CertificateId: maps.GetValueAsString(options.ProviderDeployConfig, "certificateId"),
}, logger)
return deployer, logger, err
})
return deployer, err
}
case domain.DeployProviderTypeDogeCloudCDN:
{
access := domain.AccessConfigForDogeCloud{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
deployer, err := pDogeCDN.NewWithLogger(&pDogeCDN.DogeCloudCDNDeployerConfig{
deployer, err := pDogeCDN.NewDeployer(&pDogeCDN.DeployerConfig{
AccessKey: access.AccessKey,
SecretKey: access.SecretKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
}
case domain.DeployProviderTypeEdgioApplications:
{
access := domain.AccessConfigForEdgio{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
deployer, err := pEdgioApplications.NewWithLogger(&pEdgioApplications.EdgioApplicationsDeployerConfig{
deployer, err := pEdgioApplications.NewDeployer(&pEdgioApplications.DeployerConfig{
ClientId: access.ClientId,
ClientSecret: access.ClientSecret,
EnvironmentId: maps.GetValueAsString(options.ProviderDeployConfig, "environmentId"),
}, logger)
return deployer, logger, err
})
return deployer, err
}
case domain.DeployProviderTypeGcoreCDN:
{
access := domain.AccessConfigForGcore{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeGcoreCDN:
deployer, err := pGcoreCDN.NewWithLogger(&pGcoreCDN.GcoreCDNDeployerConfig{
deployer, err := pGcoreCDN.NewDeployer(&pGcoreCDN.DeployerConfig{
ApiToken: access.ApiToken,
ResourceId: maps.GetValueAsInt64(options.ProviderDeployConfig, "resourceId"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -377,21 +374,21 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForHuaweiCloud{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeHuaweiCloudCDN:
deployer, err := pHuaweiCloudCDN.NewWithLogger(&pHuaweiCloudCDN.HuaweiCloudCDNDeployerConfig{
deployer, err := pHuaweiCloudCDN.NewDeployer(&pHuaweiCloudCDN.DeployerConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeHuaweiCloudELB:
deployer, err := pHuaweiCloudELB.NewWithLogger(&pHuaweiCloudELB.HuaweiCloudELBDeployerConfig{
deployer, err := pHuaweiCloudELB.NewDeployer(&pHuaweiCloudELB.DeployerConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
@ -399,19 +396,19 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
CertificateId: maps.GetValueAsString(options.ProviderDeployConfig, "certificateId"),
LoadbalancerId: maps.GetValueAsString(options.ProviderDeployConfig, "loadbalancerId"),
ListenerId: maps.GetValueAsString(options.ProviderDeployConfig, "listenerId"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeHuaweiCloudWAF:
deployer, err := pHuaweiCloudWAF.NewWithLogger(&pHuaweiCloudWAF.HuaweiCloudWAFDeployerConfig{
deployer, err := pHuaweiCloudWAF.NewDeployer(&pHuaweiCloudWAF.DeployerConfig{
AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
ResourceType: pHuaweiCloudWAF.ResourceType(maps.GetValueAsString(options.ProviderDeployConfig, "resourceType")),
CertificateId: maps.GetValueAsString(options.ProviderDeployConfig, "certificateId"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -420,7 +417,7 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
case domain.DeployProviderTypeLocal:
{
deployer, err := pLocal.NewWithLogger(&pLocal.LocalDeployerConfig{
deployer, err := pLocal.NewDeployer(&pLocal.DeployerConfig{
ShellEnv: pLocal.ShellEnvType(maps.GetValueAsString(options.ProviderDeployConfig, "shellEnv")),
PreCommand: maps.GetValueAsString(options.ProviderDeployConfig, "preCommand"),
PostCommand: maps.GetValueAsString(options.ProviderDeployConfig, "postCommand"),
@ -431,52 +428,52 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
JksAlias: maps.GetValueAsString(options.ProviderDeployConfig, "jksAlias"),
JksKeypass: maps.GetValueAsString(options.ProviderDeployConfig, "jksKeypass"),
JksStorepass: maps.GetValueAsString(options.ProviderDeployConfig, "jksStorepass"),
}, logger)
return deployer, logger, err
})
return deployer, err
}
case domain.DeployProviderTypeKubernetesSecret:
{
access := domain.AccessConfigForKubernetes{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
deployer, err := pK8sSecret.NewWithLogger(&pK8sSecret.K8sSecretDeployerConfig{
deployer, err := pK8sSecret.NewDeployer(&pK8sSecret.DeployerConfig{
KubeConfig: access.KubeConfig,
Namespace: maps.GetValueOrDefaultAsString(options.ProviderDeployConfig, "namespace", "default"),
SecretName: maps.GetValueAsString(options.ProviderDeployConfig, "secretName"),
SecretType: maps.GetValueOrDefaultAsString(options.ProviderDeployConfig, "secretType", "kubernetes.io/tls"),
SecretDataKeyForCrt: maps.GetValueOrDefaultAsString(options.ProviderDeployConfig, "secretDataKeyForCrt", "tls.crt"),
SecretDataKeyForKey: maps.GetValueOrDefaultAsString(options.ProviderDeployConfig, "secretDataKeyForKey", "tls.key"),
}, logger)
return deployer, logger, err
})
return deployer, err
}
case domain.DeployProviderTypeQiniuCDN, domain.DeployProviderTypeQiniuPili:
{
access := domain.AccessConfigForQiniu{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeQiniuCDN:
deployer, err := pQiniuCDN.NewWithLogger(&pQiniuCDN.QiniuCDNDeployerConfig{
deployer, err := pQiniuCDN.NewDeployer(&pQiniuCDN.DeployerConfig{
AccessKey: access.AccessKey,
SecretKey: access.SecretKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeQiniuPili:
deployer, err := pQiniuPili.NewWithLogger(&pQiniuPili.QiniuPiliDeployerConfig{
deployer, err := pQiniuPili.NewDeployer(&pQiniuPili.DeployerConfig{
AccessKey: access.AccessKey,
SecretKey: access.SecretKey,
Hub: maps.GetValueAsString(options.ProviderDeployConfig, "hub"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -487,26 +484,26 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForSafeLine{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
deployer, err := pSafeLine.NewWithLogger(&pSafeLine.SafeLineDeployerConfig{
deployer, err := pSafeLine.NewDeployer(&pSafeLine.DeployerConfig{
ApiUrl: access.ApiUrl,
ApiToken: access.ApiToken,
ResourceType: pSafeLine.ResourceType(maps.GetValueAsString(options.ProviderDeployConfig, "resourceType")),
CertificateId: maps.GetValueAsInt32(options.ProviderDeployConfig, "certificateId"),
}, logger)
return deployer, logger, err
})
return deployer, err
}
case domain.DeployProviderTypeSSH:
{
access := domain.AccessConfigForSSH{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
deployer, err := pSSH.NewWithLogger(&pSSH.SshDeployerConfig{
deployer, err := pSSH.NewDeployer(&pSSH.DeployerConfig{
SshHost: access.Host,
SshPort: access.Port,
SshUsername: access.Username,
@ -523,28 +520,28 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
JksAlias: maps.GetValueAsString(options.ProviderDeployConfig, "jksAlias"),
JksKeypass: maps.GetValueAsString(options.ProviderDeployConfig, "jksKeypass"),
JksStorepass: maps.GetValueAsString(options.ProviderDeployConfig, "jksStorepass"),
}, logger)
return deployer, logger, err
})
return deployer, err
}
case domain.DeployProviderTypeTencentCloudCDN, domain.DeployProviderTypeTencentCloudCLB, domain.DeployProviderTypeTencentCloudCOS, domain.DeployProviderTypeTencentCloudCSS, domain.DeployProviderTypeTencentCloudECDN, domain.DeployProviderTypeTencentCloudEO, domain.DeployProviderTypeTencentCloudSSLDeploy, domain.DeployProviderTypeTencentCloudWAF:
{
access := domain.AccessConfigForTencentCloud{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeTencentCloudCDN:
deployer, err := pTencentCloudCDN.NewWithLogger(&pTencentCloudCDN.TencentCloudCDNDeployerConfig{
deployer, err := pTencentCloudCDN.NewDeployer(&pTencentCloudCDN.DeployerConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeTencentCloudCLB:
deployer, err := pTencentCloudCLB.NewWithLogger(&pTencentCloudCLB.TencentCloudCLBDeployerConfig{
deployer, err := pTencentCloudCLB.NewDeployer(&pTencentCloudCLB.DeployerConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
@ -552,63 +549,63 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
LoadbalancerId: maps.GetValueAsString(options.ProviderDeployConfig, "loadbalancerId"),
ListenerId: maps.GetValueAsString(options.ProviderDeployConfig, "listenerId"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeTencentCloudCOS:
deployer, err := pTencentCloudCOS.NewWithLogger(&pTencentCloudCOS.TencentCloudCOSDeployerConfig{
deployer, err := pTencentCloudCOS.NewDeployer(&pTencentCloudCOS.DeployerConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
Bucket: maps.GetValueAsString(options.ProviderDeployConfig, "bucket"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeTencentCloudCSS:
deployer, err := pTencentCloudCSS.NewWithLogger(&pTencentCloudCSS.TencentCloudCSSDeployerConfig{
deployer, err := pTencentCloudCSS.NewDeployer(&pTencentCloudCSS.DeployerConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeTencentCloudECDN:
deployer, err := pTencentCloudECDN.NewWithLogger(&pTencentCloudECDN.TencentCloudECDNDeployerConfig{
deployer, err := pTencentCloudECDN.NewDeployer(&pTencentCloudECDN.DeployerConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeTencentCloudEO:
deployer, err := pTencentCloudEO.NewWithLogger(&pTencentCloudEO.TencentCloudEODeployerConfig{
deployer, err := pTencentCloudEO.NewDeployer(&pTencentCloudEO.DeployerConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
ZoneId: maps.GetValueAsString(options.ProviderDeployConfig, "zoneId"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeTencentCloudSSLDeploy:
deployer, err := pTencentCloudSSLDeploy.NewWithLogger(&pTencentCloudSSLDeploy.TencentCloudSSLDeployDeployerConfig{
deployer, err := pTencentCloudSSLDeploy.NewDeployer(&pTencentCloudSSLDeploy.DeployerConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
ResourceType: maps.GetValueAsString(options.ProviderDeployConfig, "resourceType"),
ResourceIds: slices.Filter(strings.Split(maps.GetValueAsString(options.ProviderDeployConfig, "resourceIds"), ";"), func(s string) bool { return s != "" }),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeTencentCloudWAF:
deployer, err := pTencentCloudWAF.NewWithLogger(&pTencentCloudWAF.TencentCloudWAFDeployerConfig{
deployer, err := pTencentCloudWAF.NewDeployer(&pTencentCloudWAF.DeployerConfig{
SecretId: access.SecretId,
SecretKey: access.SecretKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
DomainId: maps.GetValueAsString(options.ProviderDeployConfig, "domainId"),
InstanceId: maps.GetValueAsString(options.ProviderDeployConfig, "instanceId"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -619,29 +616,29 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForUCloud{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeUCloudUCDN:
deployer, err := pUCloudUCDN.NewWithLogger(&pUCloudUCDN.UCloudUCDNDeployerConfig{
deployer, err := pUCloudUCDN.NewDeployer(&pUCloudUCDN.DeployerConfig{
PrivateKey: access.PrivateKey,
PublicKey: access.PublicKey,
ProjectId: access.ProjectId,
DomainId: maps.GetValueAsString(options.ProviderDeployConfig, "domainId"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeUCloudUS3:
deployer, err := pUCloudUS3.NewWithLogger(&pUCloudUS3.UCloudUS3DeployerConfig{
deployer, err := pUCloudUS3.NewDeployer(&pUCloudUS3.DeployerConfig{
PrivateKey: access.PrivateKey,
PublicKey: access.PublicKey,
ProjectId: access.ProjectId,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
Bucket: maps.GetValueAsString(options.ProviderDeployConfig, "bucket"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -652,63 +649,63 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForVolcEngine{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
switch options.Provider {
case domain.DeployProviderTypeVolcEngineCDN:
deployer, err := pVolcEngineCDN.NewWithLogger(&pVolcEngineCDN.VolcEngineCDNDeployerConfig{
deployer, err := pVolcEngineCDN.NewDeployer(&pVolcEngineCDN.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.SecretAccessKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeVolcEngineCLB:
deployer, err := pVolcEngineCLB.NewWithLogger(&pVolcEngineCLB.VolcEngineCLBDeployerConfig{
deployer, err := pVolcEngineCLB.NewDeployer(&pVolcEngineCLB.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.SecretAccessKey,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
ResourceType: pVolcEngineCLB.ResourceType(maps.GetValueAsString(options.ProviderDeployConfig, "resourceType")),
ListenerId: maps.GetValueAsString(options.ProviderDeployConfig, "listenerId"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeVolcEngineDCDN:
deployer, err := pVolcEngineDCDN.NewWithLogger(&pVolcEngineDCDN.VolcEngineDCDNDeployerConfig{
deployer, err := pVolcEngineDCDN.NewDeployer(&pVolcEngineDCDN.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.SecretAccessKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeVolcEngineImageX:
deployer, err := pVolcEngineImageX.NewWithLogger(&pVolcEngineImageX.VolcEngineImageXDeployerConfig{
deployer, err := pVolcEngineImageX.NewDeployer(&pVolcEngineImageX.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.SecretAccessKey,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
ServiceId: maps.GetValueAsString(options.ProviderDeployConfig, "serviceId"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeVolcEngineLive:
deployer, err := pVolcEngineLive.NewWithLogger(&pVolcEngineLive.VolcEngineLiveDeployerConfig{
deployer, err := pVolcEngineLive.NewDeployer(&pVolcEngineLive.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.SecretAccessKey,
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
case domain.DeployProviderTypeVolcEngineTOS:
deployer, err := pVolcEngineTOS.NewWithLogger(&pVolcEngineTOS.VolcEngineTOSDeployerConfig{
deployer, err := pVolcEngineTOS.NewDeployer(&pVolcEngineTOS.DeployerConfig{
AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.SecretAccessKey,
Region: maps.GetValueAsString(options.ProviderDeployConfig, "region"),
Bucket: maps.GetValueAsString(options.ProviderDeployConfig, "bucket"),
Domain: maps.GetValueAsString(options.ProviderDeployConfig, "domain"),
}, logger)
return deployer, logger, err
})
return deployer, err
default:
break
@ -719,16 +716,16 @@ func createDeployer(options *deployerOptions) (deployer.Deployer, logger.Logger,
{
access := domain.AccessConfigForWebhook{}
if err := maps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, nil, fmt.Errorf("failed to populate provider access config: %w", err)
return nil, fmt.Errorf("failed to populate provider access config: %w", err)
}
deployer, err := pWebhook.NewWithLogger(&pWebhook.WebhookDeployerConfig{
deployer, err := pWebhook.NewDeployer(&pWebhook.DeployerConfig{
WebhookUrl: access.Url,
WebhookData: maps.GetValueAsString(options.ProviderDeployConfig, "webhookData"),
}, logger)
return deployer, logger, err
})
return deployer, err
}
}
return nil, nil, fmt.Errorf("unsupported deployer provider: %s", string(options.Provider))
return nil, fmt.Errorf("unsupported deployer provider: %s", string(options.Provider))
}

16
internal/notify/providers.go
View File

@ -23,19 +23,19 @@ func createNotifier(channel domain.NotifyChannelType, channelConfig map[string]a
*/
switch channel {
case domain.NotifyChannelTypeBark:
return pBark.New(&pBark.BarkNotifierConfig{
return pBark.NewNotifier(&pBark.NotifierConfig{
DeviceKey: maps.GetValueAsString(channelConfig, "deviceKey"),
ServerUrl: maps.GetValueAsString(channelConfig, "serverUrl"),
})
case domain.NotifyChannelTypeDingTalk:
return pDingTalk.New(&pDingTalk.DingTalkNotifierConfig{
return pDingTalk.NewNotifier(&pDingTalk.NotifierConfig{
AccessToken: maps.GetValueAsString(channelConfig, "accessToken"),
Secret: maps.GetValueAsString(channelConfig, "secret"),
})
case domain.NotifyChannelTypeEmail:
return pEmail.New(&pEmail.EmailNotifierConfig{
return pEmail.NewNotifier(&pEmail.NotifierConfig{
SmtpHost: maps.GetValueAsString(channelConfig, "smtpHost"),
SmtpPort: maps.GetValueAsInt32(channelConfig, "smtpPort"),
SmtpTLS: maps.GetValueOrDefaultAsBool(channelConfig, "smtpTLS", true),
@ -46,28 +46,28 @@ func createNotifier(channel domain.NotifyChannelType, channelConfig map[string]a
})
case domain.NotifyChannelTypeLark:
return pLark.New(&pLark.LarkNotifierConfig{
return pLark.NewNotifier(&pLark.NotifierConfig{
WebhookUrl: maps.GetValueAsString(channelConfig, "webhookUrl"),
})
case domain.NotifyChannelTypeServerChan:
return pServerChan.New(&pServerChan.ServerChanNotifierConfig{
return pServerChan.NewNotifier(&pServerChan.NotifierConfig{
Url: maps.GetValueAsString(channelConfig, "url"),
})
case domain.NotifyChannelTypeTelegram:
return pTelegram.New(&pTelegram.TelegramNotifierConfig{
return pTelegram.NewNotifier(&pTelegram.NotifierConfig{
ApiToken: maps.GetValueAsString(channelConfig, "apiToken"),
ChatId: maps.GetValueAsInt64(channelConfig, "chatId"),
})
case domain.NotifyChannelTypeWebhook:
return pWebhook.New(&pWebhook.WebhookNotifierConfig{
return pWebhook.NewNotifier(&pWebhook.NotifierConfig{
Url: maps.GetValueAsString(channelConfig, "url"),
})
case domain.NotifyChannelTypeWeCom:
return pWeCom.New(&pWeCom.WeComNotifierConfig{
return pWeCom.NewNotifier(&pWeCom.NotifierConfig{
WebhookUrl: maps.GetValueAsString(channelConfig, "webhookUrl"),
})
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/acmehttpreq/acmehttpreq.go
View File

@ -8,7 +8,7 @@ import (
"github.com/go-acme/lego/v4/providers/dns/httpreq"
)
type ACMEHttpReqApplicantConfig struct {
type ChallengeProviderConfig struct {
Endpoint string `json:"endpoint"`
Mode string `json:"mode"`
Username string `json:"username"`
@ -16,7 +16,7 @@ type ACMEHttpReqApplicantConfig struct {
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
}
func NewChallengeProvider(config *ACMEHttpReqApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/aliyun/aliyun.go
View File

@ -7,14 +7,14 @@ import (
"github.com/go-acme/lego/v4/providers/dns/alidns"
)
type AliyunApplicantConfig struct {
type ChallengeProviderConfig struct {
AccessKeyId string `json:"accessKeyId"`
AccessKeySecret string `json:"accessKeySecret"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *AliyunApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/aws-route53/aws-route53.go
View File

@ -7,7 +7,7 @@ import (
"github.com/go-acme/lego/v4/providers/dns/route53"
)
type AWSRoute53ApplicantConfig struct {
type ChallengeProviderConfig struct {
AccessKeyId string `json:"accessKeyId"`
SecretAccessKey string `json:"secretAccessKey"`
Region string `json:"region"`
@ -16,7 +16,7 @@ type AWSRoute53ApplicantConfig struct {
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *AWSRoute53ApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/azure-dns/azure-dns.go
View File

@ -10,7 +10,7 @@ import (
"github.com/go-acme/lego/v4/providers/dns/azuredns"
)
type AzureDNSApplicantConfig struct {
type ChallengeProviderConfig struct {
TenantId string `json:"tenantId"`
ClientId string `json:"clientId"`
ClientSecret string `json:"clientSecret"`
@ -19,7 +19,7 @@ type AzureDNSApplicantConfig struct {
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *AzureDNSApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/baiducloud/baiducloud.go
View File

@ -8,14 +8,14 @@ import (
internal "github.com/usual2970/certimate/internal/pkg/core/applicant/acme-dns-01/lego-providers/baiducloud/internal"
)
type BaiduCloudApplicantConfig struct {
type ChallengeProviderConfig struct {
AccessKeyId string `json:"accessKeyId"`
SecretAccessKey string `json:"secretAccessKey"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *BaiduCloudApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/cloudflare/cloudflare.go
View File

@ -7,13 +7,13 @@ import (
"github.com/go-acme/lego/v4/providers/dns/cloudflare"
)
type CloudflareApplicantConfig struct {
type ChallengeProviderConfig struct {
DnsApiToken string `json:"dnsApiToken"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *CloudflareApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/cloudns/cloudns.go
View File

@ -7,14 +7,14 @@ import (
"github.com/go-acme/lego/v4/providers/dns/cloudns"
)
type ClouDNSApplicantConfig struct {
type ChallengeProviderConfig struct {
AuthId string `json:"authId"`
AuthPassword string `json:"authPassword"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *ClouDNSApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/gcore/gcore.go
View File

@ -7,13 +7,13 @@ import (
"github.com/go-acme/lego/v4/providers/dns/gcore"
)
type GcoreApplicantConfig struct {
type ChallengeProviderConfig struct {
ApiToken string `json:"apiToken"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *GcoreApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/gname/gname.go
View File

@ -8,14 +8,14 @@ import (
internal "github.com/usual2970/certimate/internal/pkg/core/applicant/acme-dns-01/lego-providers/gname/internal"
)
type GnameApplicantConfig struct {
type ChallengeProviderConfig struct {
AppId string `json:"appId"`
AppKey string `json:"appKey"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *GnameApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/godaddy/godaddy.go
View File

@ -7,14 +7,14 @@ import (
"github.com/go-acme/lego/v4/providers/dns/godaddy"
)
type GoDaddyApplicantConfig struct {
type ChallengeProviderConfig struct {
ApiKey string `json:"apiKey"`
ApiSecret string `json:"apiSecret"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *GoDaddyApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/huaweicloud/huaweicloud.go
View File

@ -7,7 +7,7 @@ import (
hwc "github.com/go-acme/lego/v4/providers/dns/huaweicloud"
)
type HuaweiCloudApplicantConfig struct {
type ChallengeProviderConfig struct {
AccessKeyId string `json:"accessKeyId"`
SecretAccessKey string `json:"secretAccessKey"`
Region string `json:"region"`
@ -15,7 +15,7 @@ type HuaweiCloudApplicantConfig struct {
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *HuaweiCloudApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/namedotcom/namedotcom.go
View File

@ -7,14 +7,14 @@ import (
"github.com/go-acme/lego/v4/providers/dns/namedotcom"
)
type NameDotComApplicantConfig struct {
type ChallengeProviderConfig struct {
Username string `json:"username"`
ApiToken string `json:"apiToken"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *NameDotComApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/namesilo/namesilo.go
View File

@ -7,13 +7,13 @@ import (
"github.com/go-acme/lego/v4/providers/dns/namesilo"
)
type NameSiloApplicantConfig struct {
type ChallengeProviderConfig struct {
ApiKey string `json:"apiKey"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *NameSiloApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/ns1/ns1.go
View File

@ -7,13 +7,13 @@ import (
"github.com/go-acme/lego/v4/providers/dns/ns1"
)
type NS1ApplicantConfig struct {
type ChallengeProviderConfig struct {
ApiKey string `json:"apiKey"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *NS1ApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/powerdns/powerdns.go
View File

@ -8,14 +8,14 @@ import (
"github.com/go-acme/lego/v4/providers/dns/pdns"
)
type PowerDNSApplicantConfig struct {
type ChallengeProviderConfig struct {
ApiUrl string `json:"apiUrl"`
ApiKey string `json:"apiKey"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *PowerDNSApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/rainyun/rainyun.go
View File

@ -7,13 +7,13 @@ import (
"github.com/go-acme/lego/v4/providers/dns/rainyun"
)
type RainYunApplicantConfig struct {
type ChallengeProviderConfig struct {
ApiKey string `json:"apiKey"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *RainYunApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/tencentcloud/tencentcloud.go
View File

@ -7,14 +7,14 @@ import (
"github.com/go-acme/lego/v4/providers/dns/tencentcloud"
)
type TencentCloudApplicantConfig struct {
type ChallengeProviderConfig struct {
SecretId string `json:"secretId"`
SecretKey string `json:"secretKey"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *TencentCloudApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/volcengine/volcengine.go
View File

@ -7,14 +7,14 @@ import (
"github.com/go-acme/lego/v4/providers/dns/volcengine"
)
type VolcEngineApplicantConfig struct {
type ChallengeProviderConfig struct {
AccessKeyId string `json:"accessKeyId"`
SecretAccessKey string `json:"secretAccessKey"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *VolcEngineApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

4
internal/pkg/core/applicant/acme-dns-01/lego-providers/westcn/westcn.go
View File

@ -7,14 +7,14 @@ import (
"github.com/go-acme/lego/v4/providers/dns/westcn"
)
type WestcnApplicantConfig struct {
type ChallengeProviderConfig struct {
Username string `json:"username"`
ApiPassword string `json:"apiPassword"`
DnsPropagationTimeout int32 `json:"dnsPropagationTimeout,omitempty"`
DnsTTL int32 `json:"dnsTTL,omitempty"`
}
func NewChallengeProvider(config *WestcnApplicantConfig) (challenge.Provider, error) {
func NewChallengeProvider(config *ChallengeProviderConfig) (challenge.Provider, error) {
if config == nil {
panic("config is nil")
}

35
internal/pkg/core/deployer/providers/aliyun-alb/aliyun_alb.go
View File

@ -21,7 +21,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas"
)
type AliyunALBDeployerConfig struct {
type DeployerConfig struct {
// 阿里云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 阿里云 AccessKeySecret。
@ -41,33 +41,25 @@ type AliyunALBDeployerConfig struct {
Domain string `json:"domain,omitempty"`
}
type AliyunALBDeployer struct {
config *AliyunALBDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClients *wSdkClients
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*AliyunALBDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
type wSdkClients struct {
alb *aliyunAlb.Client
cas *aliyunCas.Client
}
func New(config *AliyunALBDeployerConfig) (*AliyunALBDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AliyunALBDeployerConfig, logger logger.Logger) (*AliyunALBDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
clients, err := createSdkClients(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk clients")
@ -78,15 +70,20 @@ func NewWithLogger(config *AliyunALBDeployerConfig, logger logger.Logger) (*Aliy
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &AliyunALBDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClients: clients,
sslUploader: uploader,
}, nil
}
func (d *AliyunALBDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 CAS
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {
@ -114,7 +111,7 @@ func (d *AliyunALBDeployer) Deploy(ctx context.Context, certPem string, privkeyP
return &deployer.DeployResult{}, nil
}
func (d *AliyunALBDeployer) deployToLoadbalancer(ctx context.Context, cloudCertId string) error {
func (d *DeployerProvider) deployToLoadbalancer(ctx context.Context, cloudCertId string) error {
if d.config.LoadbalancerId == "" {
return errors.New("config `loadbalancerId` is required")
}
@ -213,7 +210,7 @@ func (d *AliyunALBDeployer) deployToLoadbalancer(ctx context.Context, cloudCertI
return nil
}
func (d *AliyunALBDeployer) deployToListener(ctx context.Context, cloudCertId string) error {
func (d *DeployerProvider) deployToListener(ctx context.Context, cloudCertId string) error {
if d.config.ListenerId == "" {
return errors.New("config `listenerId` is required")
}
@ -226,7 +223,7 @@ func (d *AliyunALBDeployer) deployToListener(ctx context.Context, cloudCertId st
return nil
}
func (d *AliyunALBDeployer) updateListenerCertificate(ctx context.Context, cloudListenerId string, cloudCertId string) error {
func (d *DeployerProvider) updateListenerCertificate(ctx context.Context, cloudListenerId string, cloudCertId string) error {
// 查询监听的属性
// REF: https://help.aliyun.com/zh/slb/application-load-balancer/developer-reference/api-alb-2020-06-16-getlistenerattribute
getListenerAttributeReq := &aliyunAlb.GetListenerAttributeRequest{

4
internal/pkg/core/deployer/providers/aliyun-alb/aliyun_alb_test.go
View File

@ -63,7 +63,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.AliyunALBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Region: fRegion,
@ -98,7 +98,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("LISTENERID: %v", fListenerId),
}, "\n"))
deployer, err := provider.New(&provider.AliyunALBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Region: fRegion,

29
internal/pkg/core/deployer/providers/aliyun-cas-deploy/aliyun_cas_deploy.go
View File

@ -18,7 +18,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas"
)
type AliyunCASDeployDeployerConfig struct {
type DeployerConfig struct {
// 阿里云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 阿里云 AccessKeySecret。
@ -32,28 +32,20 @@ type AliyunCASDeployDeployerConfig struct {
ContactIds []string `json:"contactIds"`
}
type AliyunCASDeployDeployer struct {
config *AliyunCASDeployDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *aliyunCas.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*AliyunCASDeployDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *AliyunCASDeployDeployerConfig) (*AliyunCASDeployDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AliyunCASDeployDeployerConfig, logger logger.Logger) (*AliyunCASDeployDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -64,15 +56,20 @@ func NewWithLogger(config *AliyunCASDeployDeployerConfig, logger logger.Logger)
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &AliyunCASDeployDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *AliyunCASDeployDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if len(d.config.ResourceIds) == 0 {
return nil, errors.New("config `resourceIds` is required")
}

29
internal/pkg/core/deployer/providers/aliyun-cdn/aliyun_cdn.go
View File

@ -15,7 +15,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/logger"
)
type AliyunCDNDeployerConfig struct {
type DeployerConfig struct {
// 阿里云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 阿里云 AccessKeySecret。
@ -24,40 +24,37 @@ type AliyunCDNDeployerConfig struct {
Domain string `json:"domain"`
}
type AliyunCDNDeployer struct {
config *AliyunCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *aliyunCdn.Client
}
var _ deployer.Deployer = (*AliyunCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *AliyunCDNDeployerConfig) (*AliyunCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AliyunCDNDeployerConfig, logger logger.Logger) (*AliyunCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.AccessKeySecret)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &AliyunCDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *AliyunCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// "*.example.com" → ".example.com"，适配阿里云 CDN 要求的泛域名格式
domain := strings.TrimPrefix(d.config.Domain, "*")

2
internal/pkg/core/deployer/providers/aliyun-cdn/aliyun_cdn_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.AliyunCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Domain: fDomain,

35
internal/pkg/core/deployer/providers/aliyun-clb/aliyun_clb.go
View File

@ -16,7 +16,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-slb"
)
type AliyunCLBDeployerConfig struct {
type DeployerConfig struct {
// 阿里云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 阿里云 AccessKeySecret。
@ -36,28 +36,20 @@ type AliyunCLBDeployerConfig struct {
Domain string `json:"domain,omitempty"`
}
type AliyunCLBDeployer struct {
config *AliyunCLBDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *aliyunSlb.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*AliyunCLBDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *AliyunCLBDeployerConfig) (*AliyunCLBDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AliyunCLBDeployerConfig, logger logger.Logger) (*AliyunCLBDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -72,15 +64,20 @@ func NewWithLogger(config *AliyunCLBDeployerConfig, logger logger.Logger) (*Aliy
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &AliyunCLBDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *AliyunCLBDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 SLB
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {
@ -108,7 +105,7 @@ func (d *AliyunCLBDeployer) Deploy(ctx context.Context, certPem string, privkeyP
return &deployer.DeployResult{}, nil
}
func (d *AliyunCLBDeployer) deployToLoadbalancer(ctx context.Context, cloudCertId string) error {
func (d *DeployerProvider) deployToLoadbalancer(ctx context.Context, cloudCertId string) error {
if d.config.LoadbalancerId == "" {
return errors.New("config `loadbalancerId` is required")
}
@ -179,7 +176,7 @@ func (d *AliyunCLBDeployer) deployToLoadbalancer(ctx context.Context, cloudCertI
return nil
}
func (d *AliyunCLBDeployer) deployToListener(ctx context.Context, cloudCertId string) error {
func (d *DeployerProvider) deployToListener(ctx context.Context, cloudCertId string) error {
if d.config.LoadbalancerId == "" {
return errors.New("config `loadbalancerId` is required")
}
@ -195,7 +192,7 @@ func (d *AliyunCLBDeployer) deployToListener(ctx context.Context, cloudCertId st
return nil
}
func (d *AliyunCLBDeployer) updateListenerCertificate(ctx context.Context, cloudLoadbalancerId string, cloudListenerPort int32, cloudCertId string) error {
func (d *DeployerProvider) updateListenerCertificate(ctx context.Context, cloudLoadbalancerId string, cloudListenerPort int32, cloudCertId string) error {
// 查询监听配置
// REF: https://help.aliyun.com/zh/slb/classic-load-balancer/developer-reference/api-slb-2014-05-15-describeloadbalancerhttpslistenerattribute
describeLoadBalancerHTTPSListenerAttributeReq := &aliyunSlb.DescribeLoadBalancerHTTPSListenerAttributeRequest{

4
internal/pkg/core/deployer/providers/aliyun-clb/aliyun_clb_test.go
View File

@ -63,7 +63,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.AliyunCLBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Region: fRegion,
@ -99,7 +99,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("LISTENERPORT: %v", fListenerPort),
}, "\n"))
deployer, err := provider.New(&provider.AliyunCLBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Region: fRegion,

29
internal/pkg/core/deployer/providers/aliyun-dcdn/aliyun_dcdn.go
View File

@ -15,7 +15,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/logger"
)
type AliyunDCDNDeployerConfig struct {
type DeployerConfig struct {
// 阿里云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 阿里云 AccessKeySecret。
@ -24,40 +24,37 @@ type AliyunDCDNDeployerConfig struct {
Domain string `json:"domain"`
}
type AliyunDCDNDeployer struct {
config *AliyunDCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *aliyunDcdn.Client
}
var _ deployer.Deployer = (*AliyunDCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *AliyunDCDNDeployerConfig) (*AliyunDCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AliyunDCDNDeployerConfig, logger logger.Logger) (*AliyunDCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.AccessKeySecret)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &AliyunDCDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *AliyunDCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// "*.example.com" → ".example.com"，适配阿里云 DCDN 要求的泛域名格式
domain := strings.TrimPrefix(d.config.Domain, "*")

2
internal/pkg/core/deployer/providers/aliyun-dcdn/aliyun_dcdn_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.AliyunDCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Domain: fDomain,

29
internal/pkg/core/deployer/providers/aliyun-esa/aliyun_esa.go
View File

@ -18,7 +18,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas"
)
type AliyunESADeployerConfig struct {
type DeployerConfig struct {
// 阿里云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 阿里云 AccessKeySecret。
@ -29,28 +29,20 @@ type AliyunESADeployerConfig struct {
SiteId int64 `json:"siteId"`
}
type AliyunESADeployer struct {
config *AliyunESADeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *aliyunEsa.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*AliyunESADeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *AliyunESADeployerConfig) (*AliyunESADeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AliyunESADeployerConfig, logger logger.Logger) (*AliyunESADeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -61,15 +53,20 @@ func NewWithLogger(config *AliyunESADeployerConfig, logger logger.Logger) (*Aliy
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &AliyunESADeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *AliyunESADeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.SiteId == 0 {
return nil, errors.New("config `siteId` is required")
}

2
internal/pkg/core/deployer/providers/aliyun-esa/aliyun_esa_test.go
View File

@ -56,7 +56,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("SITEID: %v", fSiteId),
}, "\n"))
deployer, err := provider.New(&provider.AliyunESADeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Region: fRegion,

29
internal/pkg/core/deployer/providers/aliyun-live/aliyun_live.go
View File

@ -15,7 +15,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/logger"
)
type AliyunLiveDeployerConfig struct {
type DeployerConfig struct {
// 阿里云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 阿里云 AccessKeySecret。
@ -26,40 +26,37 @@ type AliyunLiveDeployerConfig struct {
Domain string `json:"domain"`
}
type AliyunLiveDeployer struct {
config *AliyunLiveDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *aliyunLive.Client
}
var _ deployer.Deployer = (*AliyunLiveDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *AliyunLiveDeployerConfig) (*AliyunLiveDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AliyunLiveDeployerConfig, logger logger.Logger) (*AliyunLiveDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &AliyunLiveDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *AliyunLiveDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// "*.example.com" → ".example.com"，适配阿里云 Live 要求的泛域名格式
domain := strings.TrimPrefix(d.config.Domain, "*")

2
internal/pkg/core/deployer/providers/aliyun-live/aliyun_live_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.AliyunLiveDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Domain: fDomain,

35
internal/pkg/core/deployer/providers/aliyun-nlb/aliyun_nlb.go
View File

@ -17,7 +17,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas"
)
type AliyunNLBDeployerConfig struct {
type DeployerConfig struct {
// 阿里云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 阿里云 AccessKeySecret。
@ -34,28 +34,20 @@ type AliyunNLBDeployerConfig struct {
ListenerId string `json:"listenerId,omitempty"`
}
type AliyunNLBDeployer struct {
config *AliyunNLBDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *aliyunNlb.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*AliyunNLBDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *AliyunNLBDeployerConfig) (*AliyunNLBDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AliyunNLBDeployerConfig, logger logger.Logger) (*AliyunNLBDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -66,15 +58,20 @@ func NewWithLogger(config *AliyunNLBDeployerConfig, logger logger.Logger) (*Aliy
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &AliyunNLBDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *AliyunNLBDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 CAS
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {
@ -102,7 +99,7 @@ func (d *AliyunNLBDeployer) Deploy(ctx context.Context, certPem string, privkeyP
return &deployer.DeployResult{}, nil
}
func (d *AliyunNLBDeployer) deployToLoadbalancer(ctx context.Context, cloudCertId string) error {
func (d *DeployerProvider) deployToLoadbalancer(ctx context.Context, cloudCertId string) error {
if d.config.LoadbalancerId == "" {
return errors.New("config `loadbalancerId` is required")
}
@ -171,7 +168,7 @@ func (d *AliyunNLBDeployer) deployToLoadbalancer(ctx context.Context, cloudCertI
return nil
}
func (d *AliyunNLBDeployer) deployToListener(ctx context.Context, cloudCertId string) error {
func (d *DeployerProvider) deployToListener(ctx context.Context, cloudCertId string) error {
if d.config.ListenerId == "" {
return errors.New("config `listenerId` is required")
}
@ -184,7 +181,7 @@ func (d *AliyunNLBDeployer) deployToListener(ctx context.Context, cloudCertId st
return nil
}
func (d *AliyunNLBDeployer) updateListenerCertificate(ctx context.Context, cloudListenerId string, cloudCertId string) error {
func (d *DeployerProvider) updateListenerCertificate(ctx context.Context, cloudListenerId string, cloudCertId string) error {
// 查询监听的属性
// REF: https://help.aliyun.com/zh/slb/network-load-balancer/developer-reference/api-nlb-2022-04-30-getlistenerattribute
getListenerAttributeReq := &aliyunNlb.GetListenerAttributeRequest{

4
internal/pkg/core/deployer/providers/aliyun-nlb/aliyun_nlb_test.go
View File

@ -59,7 +59,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("LOADBALANCERID: %v", fLoadbalancerId),
}, "\n"))
deployer, err := provider.New(&provider.AliyunNLBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Region: fRegion,
@ -94,7 +94,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("LISTENERID: %v", fListenerId),
}, "\n"))
deployer, err := provider.New(&provider.AliyunNLBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Region: fRegion,

29
internal/pkg/core/deployer/providers/aliyun-oss/aliyun_oss.go
View File

@ -12,7 +12,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/logger"
)
type AliyunOSSDeployerConfig struct {
type DeployerConfig struct {
// 阿里云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 阿里云 AccessKeySecret。
@ -25,40 +25,37 @@ type AliyunOSSDeployerConfig struct {
Domain string `json:"domain"`
}
type AliyunOSSDeployer struct {
config *AliyunOSSDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *oss.Client
}
var _ deployer.Deployer = (*AliyunOSSDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *AliyunOSSDeployerConfig) (*AliyunOSSDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AliyunOSSDeployerConfig, logger logger.Logger) (*AliyunOSSDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &AliyunOSSDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *AliyunOSSDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.Bucket == "" {
return nil, errors.New("config `bucket` is required")
}

2
internal/pkg/core/deployer/providers/aliyun-oss/aliyun_oss_test.go
View File

@ -60,7 +60,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.AliyunOSSDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Region: fRegion,

29
internal/pkg/core/deployer/providers/aliyun-waf/aliyun_waf.go
View File

@ -17,7 +17,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas"
)
type AliyunWAFDeployerConfig struct {
type DeployerConfig struct {
// 阿里云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 阿里云 AccessKeySecret。
@ -28,28 +28,20 @@ type AliyunWAFDeployerConfig struct {
InstanceId string `json:"instanceId"`
}
type AliyunWAFDeployer struct {
config *AliyunWAFDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *aliyunWaf.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*AliyunWAFDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *AliyunWAFDeployerConfig) (*AliyunWAFDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AliyunWAFDeployerConfig, logger logger.Logger) (*AliyunWAFDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -60,15 +52,20 @@ func NewWithLogger(config *AliyunWAFDeployerConfig, logger logger.Logger) (*Aliy
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &AliyunWAFDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *AliyunWAFDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.InstanceId == "" {
return nil, errors.New("config `instanceId` is required")
}

2
internal/pkg/core/deployer/providers/aliyun-waf/aliyun_waf_test.go
View File

@ -56,7 +56,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("INSTANCEID: %v", fInstanceId),
}, "\n"))
deployer, err := provider.New(&provider.AliyunWAFDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
AccessKeySecret: fAccessKeySecret,
Region: fRegion,

29
internal/pkg/core/deployer/providers/aws-cloudfront/aws_cloudfront.go
View File

@ -17,7 +17,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aws-acm"
)
type AWSCloudFrontDeployerConfig struct {
type DeployerConfig struct {
// AWS AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// AWS SecretAccessKey。
@ -28,28 +28,20 @@ type AWSCloudFrontDeployerConfig struct {
DistributionId string `json:"distributionId"`
}
type AWSCloudFrontDeployer struct {
config *AWSCloudFrontDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *awsCf.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*AWSCloudFrontDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *AWSCloudFrontDeployerConfig) (*AWSCloudFrontDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *AWSCloudFrontDeployerConfig, logger logger.Logger) (*AWSCloudFrontDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -64,15 +56,20 @@ func NewWithLogger(config *AWSCloudFrontDeployerConfig, logger logger.Logger) (*
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &AWSCloudFrontDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *AWSCloudFrontDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.DistributionId == "" {
return nil, errors.New("config `distribuitionId` is required")
}

4
internal/pkg/core/deployer/providers/aws-cloudfront/aws_cloudfront_test.go
View File

@ -56,11 +56,11 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DISTRIBUTIONID: %v", fDistribuitionId),
}, "\n"))
deployer, err := provider.New(&provider.AWSCloudFrontDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
SecretAccessKey: fSecretAccessKey,
Region: fRegion,
DistribuitionId: fDistribuitionId,
DistributionId: fDistribuitionId,
})
if err != nil {
t.Errorf("err: %+v", err)

29
internal/pkg/core/deployer/providers/baiducloud-cdn/baiducloud_cdn.go
View File

@ -13,7 +13,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/logger"
)
type BaiduCloudCDNDeployerConfig struct {
type DeployerConfig struct {
// 百度智能云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 百度智能云 SecretAccessKey。
@ -22,40 +22,37 @@ type BaiduCloudCDNDeployerConfig struct {
Domain string `json:"domain"`
}
type BaiduCloudCDNDeployer struct {
config *BaiduCloudCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *bceCdn.Client
}
var _ deployer.Deployer = (*BaiduCloudCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *BaiduCloudCDNDeployerConfig) (*BaiduCloudCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *BaiduCloudCDNDeployerConfig, logger logger.Logger) (*BaiduCloudCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.SecretAccessKey)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &BaiduCloudCDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *BaiduCloudCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 修改域名证书
// REF: https://cloud.baidu.com/doc/CDN/s/qjzuz2hp8
putCertResp, err := d.sdkClient.PutCert(

2
internal/pkg/core/deployer/providers/baiducloud-cdn/baiducloud_cdn_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.BaiduCloudCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
SecretAccessKey: fSecretAccessKey,
Domain: fDomain,

29
internal/pkg/core/deployer/providers/baishan-cdn/baishan_cdn.go
View File

@ -13,47 +13,44 @@ import (
bssdk "github.com/usual2970/certimate/internal/pkg/vendors/baishan-sdk"
)
type BaishanCDNDeployerConfig struct {
type DeployerConfig struct {
// 白山云 API Token。
ApiToken string `json:"apiToken"`
// 加速域名（支持泛域名）。
Domain string `json:"domain"`
}
type BaishanCDNDeployer struct {
config *BaishanCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *bssdk.Client
}
var _ deployer.Deployer = (*BaishanCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *BaishanCDNDeployerConfig) (*BaishanCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *BaishanCDNDeployerConfig, logger logger.Logger) (*BaishanCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.ApiToken)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &BaishanCDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *BaishanCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.Domain == "" {
return nil, errors.New("config `domain` is required")
}

2
internal/pkg/core/deployer/providers/baishan-cdn/baishan_cdn_test.go
View File

@ -48,7 +48,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.BaishanCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
ApiToken: fApiToken,
Domain: fDomain,
})

29
internal/pkg/core/deployer/providers/baotapanel-console/baotapanel_console.go
View File

@ -12,7 +12,7 @@ import (
btsdk "github.com/usual2970/certimate/internal/pkg/vendors/btpanel-sdk"
)
type BaotaPanelConsoleDeployerConfig struct {
type DeployerConfig struct {
// 宝塔面板地址。
ApiUrl string `json:"apiUrl"`
// 宝塔面板接口密钥。
@ -21,40 +21,37 @@ type BaotaPanelConsoleDeployerConfig struct {
AutoRestart bool `json:"autoRestart"`
}
type BaotaPanelConsoleDeployer struct {
config *BaotaPanelConsoleDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *btsdk.Client
}
var _ deployer.Deployer = (*BaotaPanelConsoleDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *BaotaPanelConsoleDeployerConfig) (*BaotaPanelConsoleDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *BaotaPanelConsoleDeployerConfig, logger logger.Logger) (*BaotaPanelConsoleDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.ApiUrl, config.ApiKey)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &BaotaPanelConsoleDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *BaotaPanelConsoleDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 设置面板 SSL 证书
configSavePanelSSLReq := &btsdk.ConfigSavePanelSSLRequest{
PrivateKey: privkeyPem,

2
internal/pkg/core/deployer/providers/baotapanel-console/baotapanel_console_test.go
View File

@ -48,7 +48,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("APIKEY: %v", fApiKey),
}, "\n"))
deployer, err := provider.New(&provider.BaotaPanelConsoleDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
ApiUrl: fApiUrl,
ApiKey: fApiKey,
})

29
internal/pkg/core/deployer/providers/baotapanel-site/baotapanel_site.go
View File

@ -14,7 +14,7 @@ import (
btsdk "github.com/usual2970/certimate/internal/pkg/vendors/btpanel-sdk"
)
type BaotaPanelSiteDeployerConfig struct {
type DeployerConfig struct {
// 宝塔面板地址。
ApiUrl string `json:"apiUrl"`
// 宝塔面板接口密钥。
@ -27,40 +27,37 @@ type BaotaPanelSiteDeployerConfig struct {
SiteNames []string `json:"siteNames,omitempty"`
}
type BaotaPanelSiteDeployer struct {
config *BaotaPanelSiteDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *btsdk.Client
}
var _ deployer.Deployer = (*BaotaPanelSiteDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *BaotaPanelSiteDeployerConfig) (*BaotaPanelSiteDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *BaotaPanelSiteDeployerConfig, logger logger.Logger) (*BaotaPanelSiteDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.ApiUrl, config.ApiKey)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &BaotaPanelSiteDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *BaotaPanelSiteDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
switch d.config.SiteType {
case "php":
{

2
internal/pkg/core/deployer/providers/baotapanel-site/baotapanel_site_test.go
View File

@ -56,7 +56,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("SITENAME: %v", fSiteName),
}, "\n"))
deployer, err := provider.New(&provider.BaotaPanelSiteDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
ApiUrl: fApiUrl,
ApiKey: fApiKey,
SiteName: fSiteName,

29
internal/pkg/core/deployer/providers/byteplus-cdn/byteplus_cdn.go
View File

@ -15,7 +15,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/byteplus-cdn"
)
type BytePlusCDNDeployerConfig struct {
type DeployerConfig struct {
// BytePlus AccessKey。
AccessKey string `json:"accessKey"`
// BytePlus SecretKey。
@ -24,28 +24,20 @@ type BytePlusCDNDeployerConfig struct {
Domain string `json:"domain"`
}
type BytePlusCDNDeployer struct {
config *BytePlusCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *bpCdn.CDN
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*BytePlusCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *BytePlusCDNDeployerConfig) (*BytePlusCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *BytePlusCDNDeployerConfig, logger logger.Logger) (*BytePlusCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client := bpCdn.NewInstance()
client.Client.SetAccessKey(config.AccessKey)
client.Client.SetSecretKey(config.SecretKey)
@ -58,15 +50,20 @@ func NewWithLogger(config *BytePlusCDNDeployerConfig, logger logger.Logger) (*By
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &BytePlusCDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *BytePlusCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 CDN
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {

2
internal/pkg/core/deployer/providers/byteplus-cdn/byteplus_cdn_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.BytePlusCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKey: fAccessKey,
SecretKey: fSecretKey,
Domain: fDomain,

29
internal/pkg/core/deployer/providers/cachefly/cachefly.go
View File

@ -11,45 +11,42 @@ import (
cfsdk "github.com/usual2970/certimate/internal/pkg/vendors/cachefly-sdk"
)
type CacheFlyDeployerConfig struct {
type DeployerConfig struct {
// CacheFly API Token。
ApiToken string `json:"apiToken"`
}
type CacheFlyDeployer struct {
config *CacheFlyDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *cfsdk.Client
}
var _ deployer.Deployer = (*CacheFlyDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *CacheFlyDeployerConfig) (*CacheFlyDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *CacheFlyDeployerConfig, logger logger.Logger) (*CacheFlyDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.ApiToken)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &CacheFlyDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *CacheFlyDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书
createCertificateReq := &cfsdk.CreateCertificateRequest{
Certificate: certPem,

2
internal/pkg/core/deployer/providers/cachefly/cachefly_test.go
View File

@ -44,7 +44,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("APITOKEN: %v", fApiToken),
}, "\n"))
deployer, err := provider.New(&provider.CacheFlyDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
ApiToken: fApiToken,
})
if err != nil {

33
internal/pkg/core/deployer/providers/cdnfly/cdnfly.go
View File

@ -15,7 +15,7 @@ import (
cfsdk "github.com/usual2970/certimate/internal/pkg/vendors/cdnfly-sdk"
)
type CdnflyDeployerConfig struct {
type DeployerConfig struct {
// Cdnfly 地址。
ApiUrl string `json:"apiUrl"`
// Cdnfly 用户端 API Key。
@ -32,40 +32,37 @@ type CdnflyDeployerConfig struct {
CertificateId string `json:"certificateId,omitempty"`
}
type CdnflyDeployer struct {
config *CdnflyDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *cfsdk.Client
}
var _ deployer.Deployer = (*CdnflyDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *CdnflyDeployerConfig) (*CdnflyDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *CdnflyDeployerConfig, logger logger.Logger) (*CdnflyDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.ApiUrl, config.ApiKey, config.ApiSecret)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &CdnflyDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *CdnflyDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 根据部署资源类型决定部署方式
switch d.config.ResourceType {
case RESOURCE_TYPE_SITE:
@ -85,7 +82,7 @@ func (d *CdnflyDeployer) Deploy(ctx context.Context, certPem string, privkeyPem
return &deployer.DeployResult{}, nil
}
func (d *CdnflyDeployer) deployToSite(ctx context.Context, certPem string, privkeyPem string) error {
func (d *DeployerProvider) deployToSite(ctx context.Context, certPem string, privkeyPem string) error {
if d.config.SiteId == "" {
return errors.New("config `siteId` is required")
}
@ -138,7 +135,7 @@ func (d *CdnflyDeployer) deployToSite(ctx context.Context, certPem string, privk
return nil
}
func (d *CdnflyDeployer) deployToCertificate(ctx context.Context, certPem string, privkeyPem string) error {
func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPem string, privkeyPem string) error {
if d.config.CertificateId == "" {
return errors.New("config `certificateId` is required")
}

2
internal/pkg/core/deployer/providers/cdnfly/cdnfly_test.go
View File

@ -56,7 +56,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("CERTIFICATEID: %v", fCertificateId),
}, "\n"))
deployer, err := provider.New(&provider.CdnflyDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
ApiUrl: fApiUrl,
ApiKey: fApiKey,
ApiSecret: fApiSecret,

30
internal/pkg/core/deployer/providers/dogecloud-cdn/dogecloud_cdn.go
View File

@ -13,7 +13,7 @@ import (
dogesdk "github.com/usual2970/certimate/internal/pkg/vendors/dogecloud-sdk"
)
type DogeCloudCDNDeployerConfig struct {
type DeployerConfig struct {
// 多吉云 AccessKey。
AccessKey string `json:"accessKey"`
// 多吉云 SecretKey。
@ -22,28 +22,20 @@ type DogeCloudCDNDeployerConfig struct {
Domain string `json:"domain"`
}
type DogeCloudCDNDeployer struct {
config *DogeCloudCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *dogesdk.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*DogeCloudCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *DogeCloudCDNDeployerConfig) (*DogeCloudCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *DogeCloudCDNDeployerConfig, logger logger.Logger) (*DogeCloudCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client := dogesdk.NewClient(config.AccessKey, config.SecretKey)
uploader, err := uploadersp.New(&uploadersp.DogeCloudUploaderConfig{
@ -54,15 +46,19 @@ func NewWithLogger(config *DogeCloudCDNDeployerConfig, logger logger.Logger) (*D
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &DogeCloudCDNDeployer{
logger: logger,
config: config,
return &DeployerProvider{
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *DogeCloudCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 CDN
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {

2
internal/pkg/core/deployer/providers/dogecloud-cdn/dogecloud_cdn_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.DogeCloudCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKey: fAccessKey,
SecretKey: fSecretKey,
Domain: fDomain,

29
internal/pkg/core/deployer/providers/edgio-applications/edgio_applications.go
View File

@ -12,7 +12,7 @@ import (
edgsdkDtos "github.com/usual2970/certimate/internal/pkg/vendors/edgio-sdk/applications/v7/dtos"
)
type EdgioApplicationsDeployerConfig struct {
type DeployerConfig struct {
// Edgio ClientId。
ClientId string `json:"clientId"`
// Edgio ClientSecret。
@ -21,40 +21,37 @@ type EdgioApplicationsDeployerConfig struct {
EnvironmentId string `json:"environmentId"`
}
type EdgioApplicationsDeployer struct {
config *EdgioApplicationsDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *edgsdk.EdgioClient
}
var _ deployer.Deployer = (*EdgioApplicationsDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *EdgioApplicationsDeployerConfig) (*EdgioApplicationsDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *EdgioApplicationsDeployerConfig, logger logger.Logger) (*EdgioApplicationsDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.ClientId, config.ClientSecret)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
}
return &EdgioApplicationsDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *EdgioApplicationsDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 提取 Edgio 所需的服务端证书和中间证书内容
privateCertPem, intermediateCertPem, err := certs.ExtractCertificatesFromPEM(certPem)
if err != nil {

2
internal/pkg/core/deployer/providers/edgio-applications/edgio_applications_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("ENVIRONMENTID: %v", fEnvironmentId),
}, "\n"))
deployer, err := provider.New(&provider.EdgioApplicationsDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
ClientId: fClientId,
ClientSecret: fClientSecret,
EnvironmentId: fEnvironmentId,

29
internal/pkg/core/deployer/providers/gcore-cdn/gcore_cdn.go
View File

@ -16,35 +16,27 @@ import (
gcoresdk "github.com/usual2970/certimate/internal/pkg/vendors/gcore-sdk/common"
)
type GcoreCDNDeployerConfig struct {
type DeployerConfig struct {
// Gcore API Token。
ApiToken string `json:"apiToken"`
// CDN 资源 ID。
ResourceId int64 `json:"resourceId"`
}
type GcoreCDNDeployer struct {
config *GcoreCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *gresources.Service
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*GcoreCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *GcoreCDNDeployerConfig) (*GcoreCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *GcoreCDNDeployerConfig, logger logger.Logger) (*GcoreCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.ApiToken)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -57,15 +49,20 @@ func NewWithLogger(config *GcoreCDNDeployerConfig, logger logger.Logger) (*Gcore
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &GcoreCDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *GcoreCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.ResourceId == 0 {
return nil, errors.New("config `resourceId` is required")
}

2
internal/pkg/core/deployer/providers/gcore-cdn/gcore_cdn_test.go
View File

@ -48,7 +48,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("RESOURCEID: %v", fResourceId),
}, "\n"))
deployer, err := provider.New(&provider.GcoreCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
ApiToken: fApiToken,
ResourceId: fResourceId,
})

29
internal/pkg/core/deployer/providers/huaweicloud-cdn/huaweicloud_cdn.go
View File

@ -16,7 +16,7 @@ import (
hwsdk "github.com/usual2970/certimate/internal/pkg/vendors/huaweicloud-sdk"
)
type HuaweiCloudCDNDeployerConfig struct {
type DeployerConfig struct {
// 华为云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 华为云 SecretAccessKey。
@ -27,28 +27,20 @@ type HuaweiCloudCDNDeployerConfig struct {
Domain string `json:"domain"`
}
type HuaweiCloudCDNDeployer struct {
config *HuaweiCloudCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *hcCdn.CdnClient
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*HuaweiCloudCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *HuaweiCloudCDNDeployerConfig) (*HuaweiCloudCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *HuaweiCloudCDNDeployerConfig, logger logger.Logger) (*HuaweiCloudCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(
config.AccessKeyId,
config.SecretAccessKey,
@ -66,15 +58,20 @@ func NewWithLogger(config *HuaweiCloudCDNDeployerConfig, logger logger.Logger) (
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &HuaweiCloudCDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *HuaweiCloudCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 SCM
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {

2
internal/pkg/core/deployer/providers/huaweicloud-cdn/huaweicloud_cdn_test.go
View File

@ -56,7 +56,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.HuaweiCloudCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
SecretAccessKey: fSecretAccessKey,
Region: fRegion,

37
internal/pkg/core/deployer/providers/huaweicloud-elb/huaweicloud_elb.go
View File

@ -23,7 +23,7 @@ import (
hwsdk "github.com/usual2970/certimate/internal/pkg/vendors/huaweicloud-sdk"
)
type HuaweiCloudELBDeployerConfig struct {
type DeployerConfig struct {
// 华为云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 华为云 SecretAccessKey。
@ -43,28 +43,20 @@ type HuaweiCloudELBDeployerConfig struct {
ListenerId string `json:"listenerId,omitempty"`
}
type HuaweiCloudELBDeployer struct {
config *HuaweiCloudELBDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *hcElb.ElbClient
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*HuaweiCloudELBDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *HuaweiCloudELBDeployerConfig) (*HuaweiCloudELBDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *HuaweiCloudELBDeployerConfig, logger logger.Logger) (*HuaweiCloudELBDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -79,15 +71,20 @@ func NewWithLogger(config *HuaweiCloudELBDeployerConfig, logger logger.Logger) (
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &HuaweiCloudELBDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *HuaweiCloudELBDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 SCM
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {
@ -120,7 +117,7 @@ func (d *HuaweiCloudELBDeployer) Deploy(ctx context.Context, certPem string, pri
return &deployer.DeployResult{}, nil
}
func (d *HuaweiCloudELBDeployer) deployToCertificate(ctx context.Context, certPem string, privkeyPem string) error {
func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPem string, privkeyPem string) error {
if d.config.CertificateId == "" {
return errors.New("config `certificateId` is required")
}
@ -146,7 +143,7 @@ func (d *HuaweiCloudELBDeployer) deployToCertificate(ctx context.Context, certPe
return nil
}
func (d *HuaweiCloudELBDeployer) deployToLoadbalancer(ctx context.Context, certPem string, privkeyPem string) error {
func (d *DeployerProvider) deployToLoadbalancer(ctx context.Context, certPem string, privkeyPem string) error {
if d.config.LoadbalancerId == "" {
return errors.New("config `loadbalancerId` is required")
}
@ -223,7 +220,7 @@ func (d *HuaweiCloudELBDeployer) deployToLoadbalancer(ctx context.Context, certP
return nil
}
func (d *HuaweiCloudELBDeployer) deployToListener(ctx context.Context, certPem string, privkeyPem string) error {
func (d *DeployerProvider) deployToListener(ctx context.Context, certPem string, privkeyPem string) error {
if d.config.ListenerId == "" {
return errors.New("config `listenerId` is required")
}
@ -244,7 +241,7 @@ func (d *HuaweiCloudELBDeployer) deployToListener(ctx context.Context, certPem s
return nil
}
func (d *HuaweiCloudELBDeployer) modifyListenerCertificate(ctx context.Context, cloudListenerId string, cloudCertId string) error {
func (d *DeployerProvider) modifyListenerCertificate(ctx context.Context, cloudListenerId string, cloudCertId string) error {
// 查询监听器详情
// REF: https://support.huaweicloud.com/api-elb/ShowListener.html
showListenerReq := &hcElbModel.ShowListenerRequest{

6
internal/pkg/core/deployer/providers/huaweicloud-elb/huaweicloud_elb_test.go
View File

@ -62,7 +62,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("CERTIFICATEID: %v", fCertificateId),
}, "\n"))
deployer, err := provider.New(&provider.HuaweiCloudELBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
SecretAccessKey: fSecretAccessKey,
Region: fRegion,
@ -96,7 +96,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("LOADBALANCERID: %v", fLoadbalancerId),
}, "\n"))
deployer, err := provider.New(&provider.HuaweiCloudELBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
SecretAccessKey: fSecretAccessKey,
Region: fRegion,
@ -130,7 +130,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("LISTENERID: %v", fListenerId),
}, "\n"))
deployer, err := provider.New(&provider.HuaweiCloudELBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
SecretAccessKey: fSecretAccessKey,
Region: fRegion,

35
internal/pkg/core/deployer/providers/huaweicloud-waf/huaweicloud_waf.go
View File

@ -23,7 +23,7 @@ import (
hwsdk "github.com/usual2970/certimate/internal/pkg/vendors/huaweicloud-sdk"
)
type HuaweiCloudWAFDeployerConfig struct {
type DeployerConfig struct {
// 华为云 AccessKeyId。
AccessKeyId string `json:"accessKeyId"`
// 华为云 SecretAccessKey。
@ -40,28 +40,20 @@ type HuaweiCloudWAFDeployerConfig struct {
Domain string `json:"domain,omitempty"`
}
type HuaweiCloudWAFDeployer struct {
config *HuaweiCloudWAFDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *hcWaf.WafClient
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*HuaweiCloudWAFDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *HuaweiCloudWAFDeployerConfig) (*HuaweiCloudWAFDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *HuaweiCloudWAFDeployerConfig, logger logger.Logger) (*HuaweiCloudWAFDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -76,15 +68,20 @@ func NewWithLogger(config *HuaweiCloudWAFDeployerConfig, logger logger.Logger) (
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &HuaweiCloudWAFDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *HuaweiCloudWAFDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 WAF
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {
@ -117,7 +114,7 @@ func (d *HuaweiCloudWAFDeployer) Deploy(ctx context.Context, certPem string, pri
return &deployer.DeployResult{}, nil
}
func (d *HuaweiCloudWAFDeployer) deployToCertificate(ctx context.Context, certPem string, privkeyPem string) error {
func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPem string, privkeyPem string) error {
if d.config.CertificateId == "" {
return errors.New("config `certificateId` is required")
}
@ -154,7 +151,7 @@ func (d *HuaweiCloudWAFDeployer) deployToCertificate(ctx context.Context, certPe
return nil
}
func (d *HuaweiCloudWAFDeployer) deployToCloudServer(ctx context.Context, certPem string, privkeyPem string) error {
func (d *DeployerProvider) deployToCloudServer(ctx context.Context, certPem string, privkeyPem string) error {
if d.config.Domain == "" {
return errors.New("config `domain` is required")
}
@ -221,7 +218,7 @@ func (d *HuaweiCloudWAFDeployer) deployToCloudServer(ctx context.Context, certPe
return nil
}
func (d *HuaweiCloudWAFDeployer) deployToPremiumHost(ctx context.Context, certPem string, privkeyPem string) error {
func (d *DeployerProvider) deployToPremiumHost(ctx context.Context, certPem string, privkeyPem string) error {
if d.config.Domain == "" {
return errors.New("config `domain` is required")
}

2
internal/pkg/core/deployer/providers/huaweicloud-waf/huaweicloud_waf_test.go
View File

@ -59,7 +59,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("RESOURCETYPE: %v", fResourceType),
}, "\n"))
deployer, err := provider.New(&provider.HuaweiCloudWAFDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKeyId: fAccessKeyId,
SecretAccessKey: fSecretAccessKey,
Region: fRegion,

29
internal/pkg/core/deployer/providers/k8s-secret/k8s_secret.go
View File

@ -17,7 +17,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/utils/certs"
)
type K8sSecretDeployerConfig struct {
type DeployerConfig struct {
// kubeconfig 文件内容。
KubeConfig string `json:"kubeConfig,omitempty"`
// Kubernetes 命名空间。
@ -32,33 +32,30 @@ type K8sSecretDeployerConfig struct {
SecretDataKeyForKey string `json:"secretDataKeyForKey,omitempty"`
}
type K8sSecretDeployer struct {
config *K8sSecretDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
}
var _ deployer.Deployer = (*K8sSecretDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *K8sSecretDeployerConfig) (*K8sSecretDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *K8sSecretDeployerConfig, logger logger.Logger) (*K8sSecretDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
return &K8sSecretDeployer{
logger: logger,
return &DeployerProvider{
logger: logger.NewNilLogger(),
config: config,
}, nil
}
func (d *K8sSecretDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.Namespace == "" {
return nil, errors.New("config `namespace` is required")
}

2
internal/pkg/core/deployer/providers/k8s-secret/k8s_secret_test.go
View File

@ -56,7 +56,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("SECRETDATAKEYFORKEY: %v", fSecretDataKeyForKey),
}, "\n"))
deployer, err := provider.New(&provider.K8sSecretDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
Namespace: fNamespace,
SecretName: fSecretName,
SecretDataKeyForCrt: fSecretDataKeyForCrt,

29
internal/pkg/core/deployer/providers/local/local.go
View File

@ -15,7 +15,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/utils/files"
)
type LocalDeployerConfig struct {
type DeployerConfig struct {
// Shell 执行环境。
// 零值时默认根据操作系统决定。
ShellEnv ShellEnvType `json:"shellEnv,omitempty"`
@ -43,33 +43,30 @@ type LocalDeployerConfig struct {
JksStorepass string `json:"jksStorepass,omitempty"`
}
type LocalDeployer struct {
config *LocalDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
}
var _ deployer.Deployer = (*LocalDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *LocalDeployerConfig) (*LocalDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *LocalDeployerConfig, logger logger.Logger) (*LocalDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
return &LocalDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
}, nil
}
func (d *LocalDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 执行前置命令
if d.config.PreCommand != "" {
stdout, stderr, err := execCommand(d.config.ShellEnv, d.config.PreCommand)

6
internal/pkg/core/deployer/providers/local/local_test.go
View File

@ -72,7 +72,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("POSTCOMMAND: %v", fPostCommand),
}, "\n"))
deployer, err := provider.New(&provider.LocalDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
OutputFormat: provider.OUTPUT_FORMAT_PEM,
OutputCertPath: fOutputCertPath + ".pem",
OutputKeyPath: fOutputKeyPath + ".pem",
@ -123,7 +123,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("PFXPASSWORD: %v", fPfxPassword),
}, "\n"))
deployer, err := provider.New(&provider.LocalDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
OutputFormat: provider.OUTPUT_FORMAT_PFX,
OutputCertPath: fOutputCertPath + ".pfx",
PfxPassword: fPfxPassword,
@ -164,7 +164,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("JKSSTOREPASS: %v", fJksStorepass),
}, "\n"))
deployer, err := provider.New(&provider.LocalDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
OutputFormat: provider.OUTPUT_FORMAT_JKS,
OutputCertPath: fOutputCertPath + ".jks",
JksAlias: fJksAlias,

29
internal/pkg/core/deployer/providers/qiniu-cdn/qiniu_cdn.go
View File

@ -14,7 +14,7 @@ import (
qiniusdk "github.com/usual2970/certimate/internal/pkg/vendors/qiniu-sdk"
)
type QiniuCDNDeployerConfig struct {
type DeployerConfig struct {
// 七牛云 AccessKey。
AccessKey string `json:"accessKey"`
// 七牛云 SecretKey。
@ -23,28 +23,20 @@ type QiniuCDNDeployerConfig struct {
Domain string `json:"domain"`
}
type QiniuCDNDeployer struct {
config *QiniuCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *qiniusdk.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*QiniuCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *QiniuCDNDeployerConfig) (*QiniuCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *QiniuCDNDeployerConfig, logger logger.Logger) (*QiniuCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client := qiniusdk.NewClient(auth.New(config.AccessKey, config.SecretKey))
uploader, err := uploadersp.New(&uploadersp.QiniuSSLCertUploaderConfig{
@ -55,15 +47,20 @@ func NewWithLogger(config *QiniuCDNDeployerConfig, logger logger.Logger) (*Qiniu
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &QiniuCDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *QiniuCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 CDN
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {

2
internal/pkg/core/deployer/providers/qiniu-cdn/qiniu_cdn_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.QiniuCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKey: fAccessKey,
SecretKey: fSecretKey,
Domain: fDomain,

29
internal/pkg/core/deployer/providers/qiniu-pili/qiniu_pili.go
View File

@ -12,7 +12,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/qiniu-sslcert"
)
type QiniuPiliDeployerConfig struct {
type DeployerConfig struct {
// 七牛云 AccessKey。
AccessKey string `json:"accessKey"`
// 七牛云 SecretKey。
@ -23,28 +23,20 @@ type QiniuPiliDeployerConfig struct {
Domain string `json:"domain"`
}
type QiniuPiliDeployer struct {
config *QiniuPiliDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *pili.Manager
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*QiniuPiliDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *QiniuPiliDeployerConfig) (*QiniuPiliDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *QiniuPiliDeployerConfig, logger logger.Logger) (*QiniuPiliDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
manager := pili.NewManager(pili.ManagerConfig{AccessKey: config.AccessKey, SecretKey: config.SecretKey})
uploader, err := uploadersp.New(&uploadersp.QiniuSSLCertUploaderConfig{
@ -55,15 +47,20 @@ func NewWithLogger(config *QiniuPiliDeployerConfig, logger logger.Logger) (*Qini
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &QiniuPiliDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: manager,
sslUploader: uploader,
}, nil
}
func (d *QiniuPiliDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 CDN
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {

2
internal/pkg/core/deployer/providers/qiniu-pili/qiniu_pili_test.go
View File

@ -56,7 +56,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.QiniuPiliDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
AccessKey: fAccessKey,
SecretKey: fSecretKey,
Domain: fDomain,

31
internal/pkg/core/deployer/providers/safeline/safeline.go
View File

@ -13,7 +13,7 @@ import (
safelinesdk "github.com/usual2970/certimate/internal/pkg/vendors/safeline-sdk"
)
type SafeLineDeployerConfig struct {
type DeployerConfig struct {
// 雷池 URL。
ApiUrl string `json:"apiUrl"`
// 雷池 API Token。
@ -25,40 +25,37 @@ type SafeLineDeployerConfig struct {
CertificateId int32 `json:"certificateId,omitempty"`
}
type SafeLineDeployer struct {
config *SafeLineDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *safelinesdk.Client
}
var _ deployer.Deployer = (*SafeLineDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *SafeLineDeployerConfig) (*SafeLineDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *SafeLineDeployerConfig, logger logger.Logger) (*SafeLineDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.ApiUrl, config.ApiToken)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk clients")
}
return &SafeLineDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
}, nil
}
func (d *SafeLineDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 根据部署资源类型决定部署方式
switch d.config.ResourceType {
case RESOURCE_TYPE_CERTIFICATE:
@ -73,7 +70,7 @@ func (d *SafeLineDeployer) Deploy(ctx context.Context, certPem string, privkeyPe
return &deployer.DeployResult{}, nil
}
func (d *SafeLineDeployer) deployToCertificate(ctx context.Context, certPem string, privkeyPem string) error {
func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPem string, privkeyPem string) error {
if d.config.CertificateId == 0 {
return errors.New("config `certificateId` is required")
}

2
internal/pkg/core/deployer/providers/safeline/safeline_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("CERTIFICATEID: %v", fCertificateId),
}, "\n"))
deployer, err := provider.New(&provider.SafeLineDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
ApiUrl: fApiUrl,
ApiToken: fApiToken,
ResourceType: provider.ResourceType("certificate"),

29
internal/pkg/core/deployer/providers/ssh/ssh.go
View File

@ -17,7 +17,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/utils/certs"
)
type SshDeployerConfig struct {
type DeployerConfig struct {
// SSH 主机。
// 零值时默认为 "localhost"。
SshHost string `json:"sshHost,omitempty"`
@ -58,33 +58,30 @@ type SshDeployerConfig struct {
JksStorepass string `json:"jksStorepass,omitempty"`
}
type SshDeployer struct {
config *SshDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
}
var _ deployer.Deployer = (*SshDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *SshDeployerConfig) (*SshDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *SshDeployerConfig, logger logger.Logger) (*SshDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
return &SshDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
}, nil
}
func (d *SshDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 连接
client, err := createSshClient(
d.config.SshHost,

2
internal/pkg/core/deployer/providers/ssh/ssh_test.go
View File

@ -64,7 +64,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("OUTPUTKEYPATH: %v", fOutputKeyPath),
}, "\n"))
deployer, err := provider.New(&provider.SshDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SshHost: fSshHost,
SshPort: int32(fSshPort),
SshUsername: fSshUsername,

33
internal/pkg/core/deployer/providers/tencentcloud-cdn/tencentcloud_cdn.go
View File

@ -17,7 +17,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/tencentcloud-ssl"
)
type TencentCloudCDNDeployerConfig struct {
type DeployerConfig struct {
// 腾讯云 SecretId。
SecretId string `json:"secretId"`
// 腾讯云 SecretKey。
@ -26,33 +26,25 @@ type TencentCloudCDNDeployerConfig struct {
Domain string `json:"domain"`
}
type TencentCloudCDNDeployer struct {
config *TencentCloudCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClients *wSdkClients
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*TencentCloudCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
type wSdkClients struct {
ssl *tcSsl.Client
cdn *tcCdn.Client
}
func New(config *TencentCloudCDNDeployerConfig) (*TencentCloudCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *TencentCloudCDNDeployerConfig, logger logger.Logger) (*TencentCloudCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
clients, err := createSdkClients(config.SecretId, config.SecretKey)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk clients")
@ -66,15 +58,20 @@ func NewWithLogger(config *TencentCloudCDNDeployerConfig, logger logger.Logger)
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &TencentCloudCDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClients: clients,
sslUploader: uploader,
}, nil
}
func (d *TencentCloudCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 SSL
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {
@ -134,7 +131,7 @@ func (d *TencentCloudCDNDeployer) Deploy(ctx context.Context, certPem string, pr
return &deployer.DeployResult{}, nil
}
func (d *TencentCloudCDNDeployer) getDomainsByCertificateId(cloudCertId string) ([]string, error) {
func (d *DeployerProvider) getDomainsByCertificateId(cloudCertId string) ([]string, error) {
// 获取证书中的可用域名
// REF: https://cloud.tencent.com/document/product/228/42491
describeCertDomainsReq := tcCdn.NewDescribeCertDomainsRequest()
@ -155,7 +152,7 @@ func (d *TencentCloudCDNDeployer) getDomainsByCertificateId(cloudCertId string)
return domains, nil
}
func (d *TencentCloudCDNDeployer) getDeployedDomainsByCertificateId(cloudCertId string) ([]string, error) {
func (d *DeployerProvider) getDeployedDomainsByCertificateId(cloudCertId string) ([]string, error) {
// 根据证书查询关联 CDN 域名
// REF: https://cloud.tencent.com/document/product/400/62674
describeDeployedResourcesReq := tcSsl.NewDescribeDeployedResourcesRequest()

2
internal/pkg/core/deployer/providers/tencentcloud-cdn/tencentcloud_cdn_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.TencentCloudCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SecretId: fSecretId,
SecretKey: fSecretKey,
Domain: fDomain,

39
internal/pkg/core/deployer/providers/tencentcloud-clb/tencentcloud_clb.go
View File

@ -17,7 +17,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/tencentcloud-ssl"
)
type TencentCloudCLBDeployerConfig struct {
type DeployerConfig struct {
// 腾讯云 SecretId。
SecretId string `json:"secretId"`
// 腾讯云 SecretKey。
@ -37,33 +37,25 @@ type TencentCloudCLBDeployerConfig struct {
Domain string `json:"domain,omitempty"`
}
type TencentCloudCLBDeployer struct {
config *TencentCloudCLBDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClients *wSdkClients
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*TencentCloudCLBDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
type wSdkClients struct {
ssl *tcSsl.Client
clb *tcClb.Client
}
func New(config *TencentCloudCLBDeployerConfig) (*TencentCloudCLBDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *TencentCloudCLBDeployerConfig, logger logger.Logger) (*TencentCloudCLBDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
clients, err := createSdkClients(config.SecretId, config.SecretKey, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk clients")
@ -77,15 +69,20 @@ func NewWithLogger(config *TencentCloudCLBDeployerConfig, logger logger.Logger)
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &TencentCloudCLBDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClients: clients,
sslUploader: uploader,
}, nil
}
func (d *TencentCloudCLBDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 SSL
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {
@ -123,7 +120,7 @@ func (d *TencentCloudCLBDeployer) Deploy(ctx context.Context, certPem string, pr
return &deployer.DeployResult{}, nil
}
func (d *TencentCloudCLBDeployer) deployViaSslService(ctx context.Context, cloudCertId string) error {
func (d *DeployerProvider) deployViaSslService(ctx context.Context, cloudCertId string) error {
if d.config.LoadbalancerId == "" {
return errors.New("config `loadbalancerId` is required")
}
@ -154,7 +151,7 @@ func (d *TencentCloudCLBDeployer) deployViaSslService(ctx context.Context, cloud
return nil
}
func (d *TencentCloudCLBDeployer) deployToLoadbalancer(ctx context.Context, cloudCertId string) error {
func (d *DeployerProvider) deployToLoadbalancer(ctx context.Context, cloudCertId string) error {
if d.config.LoadbalancerId == "" {
return errors.New("config `loadbalancerId` is required")
}
@ -201,7 +198,7 @@ func (d *TencentCloudCLBDeployer) deployToLoadbalancer(ctx context.Context, clou
return nil
}
func (d *TencentCloudCLBDeployer) deployToListener(ctx context.Context, cloudCertId string) error {
func (d *DeployerProvider) deployToListener(ctx context.Context, cloudCertId string) error {
if d.config.LoadbalancerId == "" {
return errors.New("config `loadbalancerId` is required")
}
@ -217,7 +214,7 @@ func (d *TencentCloudCLBDeployer) deployToListener(ctx context.Context, cloudCer
return nil
}
func (d *TencentCloudCLBDeployer) deployToRuleDomain(ctx context.Context, cloudCertId string) error {
func (d *DeployerProvider) deployToRuleDomain(ctx context.Context, cloudCertId string) error {
if d.config.LoadbalancerId == "" {
return errors.New("config `loadbalancerId` is required")
}
@ -248,7 +245,7 @@ func (d *TencentCloudCLBDeployer) deployToRuleDomain(ctx context.Context, cloudC
return nil
}
func (d *TencentCloudCLBDeployer) modifyListenerCertificate(ctx context.Context, cloudLoadbalancerId, cloudListenerId, cloudCertId string) error {
func (d *DeployerProvider) modifyListenerCertificate(ctx context.Context, cloudLoadbalancerId, cloudListenerId, cloudCertId string) error {
// 查询监听器列表
// REF: https://cloud.tencent.com/document/api/214/30686
describeListenersReq := tcClb.NewDescribeListenersRequest()

8
internal/pkg/core/deployer/providers/tencentcloud-clb/tencentcloud_clb_test.go
View File

@ -64,7 +64,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.TencentCloudCLBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SecretId: fSecretId,
SecretKey: fSecretKey,
Region: fRegion,
@ -100,7 +100,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("LOADBALANCERID: %v", fLoadbalancerId),
}, "\n"))
deployer, err := provider.New(&provider.TencentCloudCLBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SecretId: fSecretId,
SecretKey: fSecretKey,
Region: fRegion,
@ -135,7 +135,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("LISTENERID: %v", fListenerId),
}, "\n"))
deployer, err := provider.New(&provider.TencentCloudCLBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SecretId: fSecretId,
SecretKey: fSecretKey,
Region: fRegion,
@ -172,7 +172,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.TencentCloudCLBDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SecretId: fSecretId,
SecretKey: fSecretKey,
Region: fRegion,

29
internal/pkg/core/deployer/providers/tencentcloud-cos/tencentcloud_cos.go
View File

@ -16,7 +16,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/tencentcloud-ssl"
)
type TencentCloudCOSDeployerConfig struct {
type DeployerConfig struct {
// 腾讯云 SecretId。
SecretId string `json:"secretId"`
// 腾讯云 SecretKey。
@ -29,28 +29,20 @@ type TencentCloudCOSDeployerConfig struct {
Domain string `json:"domain"`
}
type TencentCloudCOSDeployer struct {
config *TencentCloudCOSDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *tcSsl.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*TencentCloudCOSDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *TencentCloudCOSDeployerConfig) (*TencentCloudCOSDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *TencentCloudCOSDeployerConfig, logger logger.Logger) (*TencentCloudCOSDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.SecretId, config.SecretKey, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk clients")
@ -64,15 +56,20 @@ func NewWithLogger(config *TencentCloudCOSDeployerConfig, logger logger.Logger)
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &TencentCloudCOSDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *TencentCloudCOSDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.Bucket == "" {
return nil, errors.New("config `bucket` is required")
}

2
internal/pkg/core/deployer/providers/tencentcloud-cos/tencentcloud_cos_test.go
View File

@ -60,7 +60,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.TencentCloudCOSDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SecretId: fSecretId,
SecretKey: fSecretKey,
Region: fRegion,

29
internal/pkg/core/deployer/providers/tencentcloud-css/tencentcloud_css.go
View File

@ -14,7 +14,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/tencentcloud-ssl"
)
type TencentCloudCSSDeployerConfig struct {
type DeployerConfig struct {
// 腾讯云 SecretId。
SecretId string `json:"secretId"`
// 腾讯云 SecretKey。
@ -23,28 +23,20 @@ type TencentCloudCSSDeployerConfig struct {
Domain string `json:"domain"`
}
type TencentCloudCSSDeployer struct {
config *TencentCloudCSSDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *tcLive.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*TencentCloudCSSDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *TencentCloudCSSDeployerConfig) (*TencentCloudCSSDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *TencentCloudCSSDeployerConfig, logger logger.Logger) (*TencentCloudCSSDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.SecretId, config.SecretKey)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -58,15 +50,20 @@ func NewWithLogger(config *TencentCloudCSSDeployerConfig, logger logger.Logger)
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &TencentCloudCSSDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *TencentCloudCSSDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 SSL
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {

2
internal/pkg/core/deployer/providers/tencentcloud-css/tencentcloud_css_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.TencentCloudCSSDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SecretId: fSecretId,
SecretKey: fSecretKey,
Domain: fDomain,

31
internal/pkg/core/deployer/providers/tencentcloud-ecdn/tencentcloud_ecdn.go
View File

@ -16,7 +16,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/tencentcloud-ssl"
)
type TencentCloudECDNDeployerConfig struct {
type DeployerConfig struct {
// 腾讯云 SecretId。
SecretId string `json:"secretId"`
// 腾讯云 SecretKey。
@ -25,33 +25,25 @@ type TencentCloudECDNDeployerConfig struct {
Domain string `json:"domain"`
}
type TencentCloudECDNDeployer struct {
config *TencentCloudECDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClients *wSdkClients
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*TencentCloudECDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
type wSdkClients struct {
ssl *tcSsl.Client
cdn *tcCdn.Client
}
func New(config *TencentCloudECDNDeployerConfig) (*TencentCloudECDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *TencentCloudECDNDeployerConfig, logger logger.Logger) (*TencentCloudECDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
clients, err := createSdkClients(config.SecretId, config.SecretKey)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk clients")
@ -65,15 +57,20 @@ func NewWithLogger(config *TencentCloudECDNDeployerConfig, logger logger.Logger)
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &TencentCloudECDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClients: clients,
sslUploader: uploader,
}, nil
}
func (d *TencentCloudECDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 SSL
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {
@ -117,7 +114,7 @@ func (d *TencentCloudECDNDeployer) Deploy(ctx context.Context, certPem string, p
return &deployer.DeployResult{}, nil
}
func (d *TencentCloudECDNDeployer) getDomainsByCertificateId(cloudCertId string) ([]string, error) {
func (d *DeployerProvider) getDomainsByCertificateId(cloudCertId string) ([]string, error) {
// 获取证书中的可用域名
// REF: https://cloud.tencent.com/document/product/228/42491
describeCertDomainsReq := tcCdn.NewDescribeCertDomainsRequest()

2
internal/pkg/core/deployer/providers/tencentcloud-ecdn/tencentcloud_ecdn_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.TencentCloudECDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SecretId: fSecretId,
SecretKey: fSecretKey,
Domain: fDomain,

29
internal/pkg/core/deployer/providers/tencentcloud-eo/tencentcloud_eo.go
View File

@ -16,7 +16,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/tencentcloud-ssl"
)
type TencentCloudEODeployerConfig struct {
type DeployerConfig struct {
// 腾讯云 SecretId。
SecretId string `json:"secretId"`
// 腾讯云 SecretKey。
@ -27,33 +27,25 @@ type TencentCloudEODeployerConfig struct {
Domain string `json:"domain"`
}
type TencentCloudEODeployer struct {
config *TencentCloudEODeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClients *wSdkClients
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*TencentCloudEODeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
type wSdkClients struct {
ssl *tcSsl.Client
teo *tcTeo.Client
}
func New(config *TencentCloudEODeployerConfig) (*TencentCloudEODeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *TencentCloudEODeployerConfig, logger logger.Logger) (*TencentCloudEODeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
clients, err := createSdkClients(config.SecretId, config.SecretKey)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk clients")
@ -67,15 +59,20 @@ func NewWithLogger(config *TencentCloudEODeployerConfig, logger logger.Logger) (
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &TencentCloudEODeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClients: clients,
sslUploader: uploader,
}, nil
}
func (d *TencentCloudEODeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.ZoneId == "" {
return nil, errors.New("config `zoneId` is required")
}

2
internal/pkg/core/deployer/providers/tencentcloud-eo/tencentcloud_eo_test.go
View File

@ -56,7 +56,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomain),
}, "\n"))
deployer, err := provider.New(&provider.TencentCloudEODeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SecretId: fSecretId,
SecretKey: fSecretKey,
ZoneId: fZoneId,

29
internal/pkg/core/deployer/providers/tencentcloud-ssl-deploy/tencentcloud_ssl_deploy.go
View File

@ -17,7 +17,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/tencentcloud-ssl"
)
type TencentCloudSSLDeployDeployerConfig struct {
type DeployerConfig struct {
// 腾讯云 SecretId。
SecretId string `json:"secretId"`
// 腾讯云 SecretKey。
@ -30,28 +30,20 @@ type TencentCloudSSLDeployDeployerConfig struct {
ResourceIds []string `json:"resourceIds"`
}
type TencentCloudSSLDeployDeployer struct {
config *TencentCloudSSLDeployDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *tcSsl.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*TencentCloudSSLDeployDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *TencentCloudSSLDeployDeployerConfig) (*TencentCloudSSLDeployDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *TencentCloudSSLDeployDeployerConfig, logger logger.Logger) (*TencentCloudSSLDeployDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.SecretId, config.SecretKey, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -65,15 +57,20 @@ func NewWithLogger(config *TencentCloudSSLDeployDeployerConfig, logger logger.Lo
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &TencentCloudSSLDeployDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *TencentCloudSSLDeployDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.ResourceType == "" {
return nil, errors.New("config `resourceType` is required")
}

29
internal/pkg/core/deployer/providers/tencentcloud-waf/tencentcloud_waf.go
View File

@ -15,7 +15,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/tencentcloud-ssl"
)
type TencentCloudWAFDeployerConfig struct {
type DeployerConfig struct {
// 腾讯云 SecretId。
SecretId string `json:"secretId"`
// 腾讯云 SecretKey。
@ -30,28 +30,20 @@ type TencentCloudWAFDeployerConfig struct {
InstanceId string `json:"instanceId"`
}
type TencentCloudWAFDeployer struct {
config *TencentCloudWAFDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *tcWaf.Client
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*TencentCloudWAFDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *TencentCloudWAFDeployerConfig) (*TencentCloudWAFDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *TencentCloudWAFDeployerConfig, logger logger.Logger) (*TencentCloudWAFDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.SecretId, config.SecretKey, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk clients")
@ -65,15 +57,20 @@ func NewWithLogger(config *TencentCloudWAFDeployerConfig, logger logger.Logger)
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &TencentCloudWAFDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *TencentCloudWAFDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
if d.config.Domain == "" {
return nil, errors.New("config `domain` is required")
}

2
internal/pkg/core/deployer/providers/tencentcloud-waf/tencentcloud_waf_test.go
View File

@ -63,7 +63,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("INSTANCEID: %v", fInstanceId),
}, "\n"))
deployer, err := provider.New(&provider.TencentCloudWAFDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
SecretId: fSecretId,
SecretKey: fSecretKey,
Region: fRegion,

29
internal/pkg/core/deployer/providers/ucloud-ucdn/ucloud_ucdn.go
View File

@ -16,7 +16,7 @@ import (
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ucloud-ussl"
)
type UCloudUCDNDeployerConfig struct {
type DeployerConfig struct {
// 优刻得 API 私钥。
PrivateKey string `json:"privateKey"`
// 优刻得 API 公钥。
@ -27,28 +27,20 @@ type UCloudUCDNDeployerConfig struct {
DomainId string `json:"domainId"`
}
type UCloudUCDNDeployer struct {
config *UCloudUCDNDeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *uCdn.UCDNClient
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*UCloudUCDNDeployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *UCloudUCDNDeployerConfig) (*UCloudUCDNDeployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *UCloudUCDNDeployerConfig, logger logger.Logger) (*UCloudUCDNDeployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.PrivateKey, config.PublicKey)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -63,15 +55,20 @@ func NewWithLogger(config *UCloudUCDNDeployerConfig, logger logger.Logger) (*UCl
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &UCloudUCDNDeployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *UCloudUCDNDeployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 USSL
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {

2
internal/pkg/core/deployer/providers/ucloud-ucdn/ucloud_ucdn_test.go
View File

@ -52,7 +52,7 @@ func TestDeploy(t *testing.T) {
fmt.Sprintf("DOMAIN: %v", fDomainId),
}, "\n"))
deployer, err := provider.New(&provider.UCloudUCDNDeployerConfig{
deployer, err := provider.NewDeployer(&provider.DeployerConfig{
PrivateKey: fPrivateKey,
PublicKey: fPublicKey,
DomainId: fDomainId,

29
internal/pkg/core/deployer/providers/ucloud-us3/ucloud_us3.go
View File

@ -14,7 +14,7 @@ import (
usdkFile "github.com/usual2970/certimate/internal/pkg/vendors/ucloud-sdk/ufile"
)
type UCloudUS3DeployerConfig struct {
type DeployerConfig struct {
// 优刻得 API 私钥。
PrivateKey string `json:"privateKey"`
// 优刻得 API 公钥。
@ -29,28 +29,20 @@ type UCloudUS3DeployerConfig struct {
Domain string `json:"domain"`
}
type UCloudUS3Deployer struct {
config *UCloudUS3DeployerConfig
type DeployerProvider struct {
config *DeployerConfig
logger logger.Logger
sdkClient *usdkFile.UFileClient
sslUploader uploader.Uploader
}
var _ deployer.Deployer = (*UCloudUS3Deployer)(nil)
var _ deployer.Deployer = (*DeployerProvider)(nil)
func New(config *UCloudUS3DeployerConfig) (*UCloudUS3Deployer, error) {
return NewWithLogger(config, logger.NewNilLogger())
}
func NewWithLogger(config *UCloudUS3DeployerConfig, logger logger.Logger) (*UCloudUS3Deployer, error) {
func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
if config == nil {
panic("config is nil")
}
if logger == nil {
panic("logger is nil")
}
client, err := createSdkClient(config.PrivateKey, config.PublicKey, config.Region)
if err != nil {
return nil, xerrors.Wrap(err, "failed to create sdk client")
@ -65,15 +57,20 @@ func NewWithLogger(config *UCloudUS3DeployerConfig, logger logger.Logger) (*UClo
return nil, xerrors.Wrap(err, "failed to create ssl uploader")
}
return &UCloudUS3Deployer{
logger: logger,
return &DeployerProvider{
config: config,
logger: logger.NewNilLogger(),
sdkClient: client,
sslUploader: uploader,
}, nil
}
func (d *UCloudUS3Deployer) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
func (d *DeployerProvider) WithLogger(logger logger.Logger) *DeployerProvider {
d.logger = logger
return d
}
func (d *DeployerProvider) Deploy(ctx context.Context, certPem string, privkeyPem string) (*deployer.DeployResult, error) {
// 上传证书到 USSL
upres, err := d.sslUploader.Upload(ctx, certPem, privkeyPem)
if err != nil {

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