refactor: normalize providers constructors

internal/applicant/providers.go

@@ -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,

internal/deployer/deployer.go

@@ -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,

internal/deployer/providers.go

@@ -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) {
+func createDeployer(options *deployerOptions) (deployer.Deployer, error) {
-	logger := logger.NewDefaultLogger()
-
 	/*
 	  注意：如果追加新的常量值，请保持以 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))
 }

internal/notify/providers.go

@@ -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"),
 		})
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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")
 	}

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

@@ -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 {
+type DeployerProvider struct {
-	config      *AliyunALBDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AliyunALBDeployerConfig, logger logger.Logger) (*AliyunALBDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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{

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *AliyunCASDeployDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AliyunCASDeployDeployerConfig, logger logger.Logger) (*AliyunCASDeployDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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")
 	}

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

@@ -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 {
+type DeployerProvider struct {
-	config    *AliyunCDNDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *aliyunCdn.Client
 }
 
-var _ deployer.Deployer = (*AliyunCDNDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *AliyunCDNDeployerConfig) (*AliyunCDNDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AliyunCDNDeployerConfig, logger logger.Logger) (*AliyunCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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, "*")
 

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *AliyunCLBDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AliyunCLBDeployerConfig, logger logger.Logger) (*AliyunCLBDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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{

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config    *AliyunDCDNDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *aliyunDcdn.Client
 }
 
-var _ deployer.Deployer = (*AliyunDCDNDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *AliyunDCDNDeployerConfig) (*AliyunDCDNDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AliyunDCDNDeployerConfig, logger logger.Logger) (*AliyunDCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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, "*")
 

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *AliyunESADeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AliyunESADeployerConfig, logger logger.Logger) (*AliyunESADeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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")
 	}

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config    *AliyunLiveDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *aliyunLive.Client
 }
 
-var _ deployer.Deployer = (*AliyunLiveDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *AliyunLiveDeployerConfig) (*AliyunLiveDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AliyunLiveDeployerConfig, logger logger.Logger) (*AliyunLiveDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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, "*")
 

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *AliyunNLBDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AliyunNLBDeployerConfig, logger logger.Logger) (*AliyunNLBDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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{

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config    *AliyunOSSDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *oss.Client
 }
 
-var _ deployer.Deployer = (*AliyunOSSDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *AliyunOSSDeployerConfig) (*AliyunOSSDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AliyunOSSDeployerConfig, logger logger.Logger) (*AliyunOSSDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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")
 	}

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *AliyunWAFDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AliyunWAFDeployerConfig, logger logger.Logger) (*AliyunWAFDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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")
 	}

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *AWSCloudFrontDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *AWSCloudFrontDeployerConfig, logger logger.Logger) (*AWSCloudFrontDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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")
 	}

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

@@ -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)

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

@@ -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 {
+type DeployerProvider struct {
-	config    *BaiduCloudCDNDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *bceCdn.Client
 }
 
-var _ deployer.Deployer = (*BaiduCloudCDNDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *BaiduCloudCDNDeployerConfig) (*BaiduCloudCDNDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *BaiduCloudCDNDeployerConfig, logger logger.Logger) (*BaiduCloudCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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(

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config    *BaishanCDNDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *bssdk.Client
 }
 
-var _ deployer.Deployer = (*BaishanCDNDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *BaishanCDNDeployerConfig) (*BaishanCDNDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *BaishanCDNDeployerConfig, logger logger.Logger) (*BaishanCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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")
 	}

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

@@ -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,
 		})

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

@@ -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 {
+type DeployerProvider struct {
-	config    *BaotaPanelConsoleDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *btsdk.Client
 }
 
-var _ deployer.Deployer = (*BaotaPanelConsoleDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *BaotaPanelConsoleDeployerConfig) (*BaotaPanelConsoleDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *BaotaPanelConsoleDeployerConfig, logger logger.Logger) (*BaotaPanelConsoleDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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,

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

@@ -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,
 		})

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

@@ -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 {
+type DeployerProvider struct {
-	config    *BaotaPanelSiteDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *btsdk.Client
 }
 
-var _ deployer.Deployer = (*BaotaPanelSiteDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *BaotaPanelSiteDeployerConfig) (*BaotaPanelSiteDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *BaotaPanelSiteDeployerConfig, logger logger.Logger) (*BaotaPanelSiteDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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":
 		{

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *BytePlusCDNDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *BytePlusCDNDeployerConfig, logger logger.Logger) (*BytePlusCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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 {

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

@@ -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,

internal/pkg/core/deployer/providers/cachefly/cachefly.go

@@ -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 {
+type DeployerProvider struct {
-	config    *CacheFlyDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *cfsdk.Client
 }
 
-var _ deployer.Deployer = (*CacheFlyDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *CacheFlyDeployerConfig) (*CacheFlyDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *CacheFlyDeployerConfig, logger logger.Logger) (*CacheFlyDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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,

internal/pkg/core/deployer/providers/cachefly/cachefly_test.go

@@ -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 {

internal/pkg/core/deployer/providers/cdnfly/cdnfly.go

@@ -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 {
+type DeployerProvider struct {
-	config    *CdnflyDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *cfsdk.Client
 }
 
-var _ deployer.Deployer = (*CdnflyDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *CdnflyDeployerConfig) (*CdnflyDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *CdnflyDeployerConfig, logger logger.Logger) (*CdnflyDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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")
 	}

internal/pkg/core/deployer/providers/cdnfly/cdnfly_test.go

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *DogeCloudCDNDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *DogeCloudCDNDeployerConfig, logger logger.Logger) (*DogeCloudCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
+		logger:      logger.NewNilLogger(),
-		config:      config,
 		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 {

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config    *EdgioApplicationsDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *edgsdk.EdgioClient
 }
 
-var _ deployer.Deployer = (*EdgioApplicationsDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *EdgioApplicationsDeployerConfig) (*EdgioApplicationsDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *EdgioApplicationsDeployerConfig, logger logger.Logger) (*EdgioApplicationsDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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 {

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *GcoreCDNDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *GcoreCDNDeployerConfig, logger logger.Logger) (*GcoreCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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")
 	}

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

@@ -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,
 		})

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

@@ -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 {
+type DeployerProvider struct {
-	config      *HuaweiCloudCDNDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *HuaweiCloudCDNDeployerConfig, logger logger.Logger) (*HuaweiCloudCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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 {

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *HuaweiCloudELBDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *HuaweiCloudELBDeployerConfig, logger logger.Logger) (*HuaweiCloudELBDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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{

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *HuaweiCloudWAFDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *HuaweiCloudWAFDeployerConfig, logger logger.Logger) (*HuaweiCloudWAFDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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")
 	}

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config *K8sSecretDeployerConfig
+	config *DeployerConfig
 	logger logger.Logger
 }
 
-var _ deployer.Deployer = (*K8sSecretDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *K8sSecretDeployerConfig) (*K8sSecretDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *K8sSecretDeployerConfig, logger logger.Logger) (*K8sSecretDeployer, error) {
 	if config == nil {
 		panic("config is nil")
 	}
 
-	if logger == nil {
+	return &DeployerProvider{
-		panic("logger is nil")
+		logger: logger.NewNilLogger(),
-	}
-
-	return &K8sSecretDeployer{
-		logger: logger,
 		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")
 	}

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

@@ -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,

internal/pkg/core/deployer/providers/local/local.go

@@ -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 {
+type DeployerProvider struct {
-	config *LocalDeployerConfig
+	config *DeployerConfig
 	logger logger.Logger
 }
 
-var _ deployer.Deployer = (*LocalDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *LocalDeployerConfig) (*LocalDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *LocalDeployerConfig, logger logger.Logger) (*LocalDeployer, error) {
 	if config == nil {
 		panic("config is nil")
 	}
 
-	if logger == nil {
+	return &DeployerProvider{
-		panic("logger is nil")
-	}
-
-	return &LocalDeployer{
-		logger: logger,
 		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)

internal/pkg/core/deployer/providers/local/local_test.go

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *QiniuCDNDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *QiniuCDNDeployerConfig, logger logger.Logger) (*QiniuCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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 {

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *QiniuPiliDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *QiniuPiliDeployerConfig, logger logger.Logger) (*QiniuPiliDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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 {

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

@@ -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,

internal/pkg/core/deployer/providers/safeline/safeline.go

@@ -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 {
+type DeployerProvider struct {
-	config    *SafeLineDeployerConfig
+	config    *DeployerConfig
 	logger    logger.Logger
 	sdkClient *safelinesdk.Client
 }
 
-var _ deployer.Deployer = (*SafeLineDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *SafeLineDeployerConfig) (*SafeLineDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *SafeLineDeployerConfig, logger logger.Logger) (*SafeLineDeployer, 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{
+	return &DeployerProvider{
-		logger:    logger,
 		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")
 	}

internal/pkg/core/deployer/providers/safeline/safeline_test.go

@@ -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"),

internal/pkg/core/deployer/providers/ssh/ssh.go

@@ -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 {
+type DeployerProvider struct {
-	config *SshDeployerConfig
+	config *DeployerConfig
 	logger logger.Logger
 }
 
-var _ deployer.Deployer = (*SshDeployer)(nil)
+var _ deployer.Deployer = (*DeployerProvider)(nil)
 
-func New(config *SshDeployerConfig) (*SshDeployer, error) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *SshDeployerConfig, logger logger.Logger) (*SshDeployer, error) {
 	if config == nil {
 		panic("config is nil")
 	}
 
-	if logger == nil {
+	return &DeployerProvider{
-		panic("logger is nil")
-	}
-
-	return &SshDeployer{
-		logger: logger,
 		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,

internal/pkg/core/deployer/providers/ssh/ssh_test.go

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *TencentCloudCDNDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *TencentCloudCDNDeployerConfig, logger logger.Logger) (*TencentCloudCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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()

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *TencentCloudCLBDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *TencentCloudCLBDeployerConfig, logger logger.Logger) (*TencentCloudCLBDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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()

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *TencentCloudCOSDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *TencentCloudCOSDeployerConfig, logger logger.Logger) (*TencentCloudCOSDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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")
 	}

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *TencentCloudCSSDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *TencentCloudCSSDeployerConfig, logger logger.Logger) (*TencentCloudCSSDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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 {

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *TencentCloudECDNDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *TencentCloudECDNDeployerConfig, logger logger.Logger) (*TencentCloudECDNDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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()

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *TencentCloudEODeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *TencentCloudEODeployerConfig, logger logger.Logger) (*TencentCloudEODeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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")
 	}

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *TencentCloudSSLDeployDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *TencentCloudSSLDeployDeployerConfig, logger logger.Logger) (*TencentCloudSSLDeployDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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")
 	}

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

@@ -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 {
+type DeployerProvider struct {
-	config      *TencentCloudWAFDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *TencentCloudWAFDeployerConfig, logger logger.Logger) (*TencentCloudWAFDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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")
 	}

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *UCloudUCDNDeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *UCloudUCDNDeployerConfig, logger logger.Logger) (*UCloudUCDNDeployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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 {

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

@@ -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,

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

@@ -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 {
+type DeployerProvider struct {
-	config      *UCloudUS3DeployerConfig
+	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) {
+func NewDeployer(config *DeployerConfig) (*DeployerProvider, error) {
-	return NewWithLogger(config, logger.NewNilLogger())
-}
-
-func NewWithLogger(config *UCloudUS3DeployerConfig, logger logger.Logger) (*UCloudUS3Deployer, 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{
+	return &DeployerProvider{
-		logger:      logger,
 		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 {