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

refactor: rename utils

Browse Source
This commit is contained in:
Fu Diwei 2025-06-15 21:51:07 +08:00
parent e7ce12772a
commit 8149034bdc
84 changed files with 796 additions and 796 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
internal/applicant/acme_user.go
View File

@ -14,8 +14,8 @@ import (
"golang.org/x/sync/singleflight" "golang.org/x/sync/singleflight"
"github.com/usual2970/certimate/internal/domain" "github.com/usual2970/certimate/internal/domain"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
maputil "github.com/usual2970/certimate/internal/pkg/utils/map" xmaps "github.com/usual2970/certimate/internal/pkg/utils/maps"
"github.com/usual2970/certimate/internal/repository" "github.com/usual2970/certimate/internal/repository"
) )
@ -51,7 +51,7 @@ func newAcmeUser(ca, caAccessId, email string) (*acmeUser, error) {
return nil, err return nil, err
} }
keyPEM, err := certutil.ConvertECPrivateKeyToPEM(key) keyPEM, err := xcert.ConvertECPrivateKeyToPEM(key)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -75,7 +75,7 @@ func (u acmeUser) GetRegistration() *registration.Resource {
} }
func (u *acmeUser) GetPrivateKey() crypto.PrivateKey { func (u *acmeUser) GetPrivateKey() crypto.PrivateKey {
rs, _ := certutil.ParseECPrivateKeyFromPEM(u.privkey) rs, _ := xcert.ParseECPrivateKeyFromPEM(u.privkey)
return rs return rs
} }
@ -120,7 +120,7 @@ func registerAcmeUser(client *lego.Client, user *acmeUser, userRegisterOptions m
case caGoogleTrustServices: case caGoogleTrustServices:
{ {
access := domain.AccessConfigForGoogleTrustServices{} access := domain.AccessConfigForGoogleTrustServices{}
if err := maputil.Populate(userRegisterOptions, &access); err != nil { if err := xmaps.Populate(userRegisterOptions, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -134,7 +134,7 @@ func registerAcmeUser(client *lego.Client, user *acmeUser, userRegisterOptions m
case caSSLCom: case caSSLCom:
{ {
access := domain.AccessConfigForSSLCom{} access := domain.AccessConfigForSSLCom{}
if err := maputil.Populate(userRegisterOptions, &access); err != nil { if err := xmaps.Populate(userRegisterOptions, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -148,7 +148,7 @@ func registerAcmeUser(client *lego.Client, user *acmeUser, userRegisterOptions m
case caZeroSSL: case caZeroSSL:
{ {
access := domain.AccessConfigForZeroSSL{} access := domain.AccessConfigForZeroSSL{}
if err := maputil.Populate(userRegisterOptions, &access); err != nil { if err := xmaps.Populate(userRegisterOptions, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -162,7 +162,7 @@ func registerAcmeUser(client *lego.Client, user *acmeUser, userRegisterOptions m
case caCustom: case caCustom:
{ {
access := domain.AccessConfigForACMECA{} access := domain.AccessConfigForACMECA{}
if err := maputil.Populate(userRegisterOptions, &access); err != nil { if err := xmaps.Populate(userRegisterOptions, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }

10
internal/applicant/applicant.go
View File

@ -20,8 +20,8 @@ import (
"golang.org/x/time/rate" "golang.org/x/time/rate"
"github.com/usual2970/certimate/internal/domain" "github.com/usual2970/certimate/internal/domain"
maputil "github.com/usual2970/certimate/internal/pkg/utils/map" xmaps "github.com/usual2970/certimate/internal/pkg/utils/maps"
sliceutil "github.com/usual2970/certimate/internal/pkg/utils/slice" xslices "github.com/usual2970/certimate/internal/pkg/utils/slices"
"github.com/usual2970/certimate/internal/repository" "github.com/usual2970/certimate/internal/repository"
) )
@ -55,7 +55,7 @@ func NewWithWorkflowNode(config ApplicantWithWorkflowNodeConfig) (Applicant, err
nodeCfg := config.Node.GetConfigForApply() nodeCfg := config.Node.GetConfigForApply()
options := &applicantProviderOptions{ options := &applicantProviderOptions{
Domains: sliceutil.Filter(strings.Split(nodeCfg.Domains, ";"), func(s string) bool { return s != "" }), Domains: xslices.Filter(strings.Split(nodeCfg.Domains, ";"), func(s string) bool { return s != "" }),
ContactEmail: nodeCfg.ContactEmail, ContactEmail: nodeCfg.ContactEmail,
Provider: domain.ACMEDns01ProviderType(nodeCfg.Provider), Provider: domain.ACMEDns01ProviderType(nodeCfg.Provider),
ProviderAccessConfig: make(map[string]any), ProviderAccessConfig: make(map[string]any),
@ -64,7 +64,7 @@ func NewWithWorkflowNode(config ApplicantWithWorkflowNodeConfig) (Applicant, err
CAProviderAccessConfig: make(map[string]any), CAProviderAccessConfig: make(map[string]any),
CAProviderServiceConfig: nodeCfg.CAProviderConfig, CAProviderServiceConfig: nodeCfg.CAProviderConfig,
KeyAlgorithm: nodeCfg.KeyAlgorithm, KeyAlgorithm: nodeCfg.KeyAlgorithm,
Nameservers: sliceutil.Filter(strings.Split(nodeCfg.Nameservers, ";"), func(s string) bool { return s != "" }), Nameservers: xslices.Filter(strings.Split(nodeCfg.Nameservers, ";"), func(s string) bool { return s != "" }),
DnsPropagationWait: nodeCfg.DnsPropagationWait, DnsPropagationWait: nodeCfg.DnsPropagationWait,
DnsPropagationTimeout: nodeCfg.DnsPropagationTimeout, DnsPropagationTimeout: nodeCfg.DnsPropagationTimeout,
DnsTTL: nodeCfg.DnsTTL, DnsTTL: nodeCfg.DnsTTL,
@ -189,7 +189,7 @@ func applyUseLego(legoProvider challenge.Provider, options *applicantProviderOpt
} }
case caCustom: case caCustom:
caDirURL := maputil.GetString(options.CAProviderAccessConfig, "endpoint") caDirURL := xmaps.GetString(options.CAProviderAccessConfig, "endpoint")
if caDirURL != "" { if caDirURL != "" {
config.CADirURL = caDirURL config.CADirURL = caDirURL
} else { } else {

86
internal/applicant/providers.go
View File

@ -44,7 +44,7 @@ import (
pVercel "github.com/usual2970/certimate/internal/pkg/core/applicant/acme-dns-01/lego-providers/vercel" pVercel "github.com/usual2970/certimate/internal/pkg/core/applicant/acme-dns-01/lego-providers/vercel"
pVolcEngine "github.com/usual2970/certimate/internal/pkg/core/applicant/acme-dns-01/lego-providers/volcengine" pVolcEngine "github.com/usual2970/certimate/internal/pkg/core/applicant/acme-dns-01/lego-providers/volcengine"
pWestcn "github.com/usual2970/certimate/internal/pkg/core/applicant/acme-dns-01/lego-providers/westcn" pWestcn "github.com/usual2970/certimate/internal/pkg/core/applicant/acme-dns-01/lego-providers/westcn"
maputil "github.com/usual2970/certimate/internal/pkg/utils/map" xmaps "github.com/usual2970/certimate/internal/pkg/utils/maps"
) )
type applicantProviderOptions struct { type applicantProviderOptions struct {
@ -76,7 +76,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeACMEHttpReq: case domain.ACMEDns01ProviderTypeACMEHttpReq:
{ {
access := domain.AccessConfigForACMEHttpReq{} access := domain.AccessConfigForACMEHttpReq{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -93,7 +93,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeAliyun, domain.ACMEDns01ProviderTypeAliyunDNS, domain.ACMEDns01ProviderTypeAliyunESA: case domain.ACMEDns01ProviderTypeAliyun, domain.ACMEDns01ProviderTypeAliyunDNS, domain.ACMEDns01ProviderTypeAliyunESA:
{ {
access := domain.AccessConfigForAliyun{} access := domain.AccessConfigForAliyun{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -111,7 +111,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
applicant, err := pAliyunESA.NewChallengeProvider(&pAliyunESA.ChallengeProviderConfig{ applicant, err := pAliyunESA.NewChallengeProvider(&pAliyunESA.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId, AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret, AccessKeySecret: access.AccessKeySecret,
Region: maputil.GetString(options.ProviderServiceConfig, "region"), Region: xmaps.GetString(options.ProviderServiceConfig, "region"),
DnsPropagationTimeout: options.DnsPropagationTimeout, DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL, DnsTTL: options.DnsTTL,
}) })
@ -125,15 +125,15 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeAWS, domain.ACMEDns01ProviderTypeAWSRoute53: case domain.ACMEDns01ProviderTypeAWS, domain.ACMEDns01ProviderTypeAWSRoute53:
{ {
access := domain.AccessConfigForAWS{} access := domain.AccessConfigForAWS{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
applicant, err := pAWSRoute53.NewChallengeProvider(&pAWSRoute53.ChallengeProviderConfig{ applicant, err := pAWSRoute53.NewChallengeProvider(&pAWSRoute53.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId, AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey, SecretAccessKey: access.SecretAccessKey,
Region: maputil.GetString(options.ProviderServiceConfig, "region"), Region: xmaps.GetString(options.ProviderServiceConfig, "region"),
HostedZoneId: maputil.GetString(options.ProviderServiceConfig, "hostedZoneId"), HostedZoneId: xmaps.GetString(options.ProviderServiceConfig, "hostedZoneId"),
DnsPropagationTimeout: options.DnsPropagationTimeout, DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL, DnsTTL: options.DnsTTL,
}) })
@ -143,7 +143,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeAzure, domain.ACMEDns01ProviderTypeAzureDNS: case domain.ACMEDns01ProviderTypeAzure, domain.ACMEDns01ProviderTypeAzureDNS:
{ {
access := domain.AccessConfigForAzure{} access := domain.AccessConfigForAzure{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -161,7 +161,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeBaiduCloud, domain.ACMEDns01ProviderTypeBaiduCloudDNS: case domain.ACMEDns01ProviderTypeBaiduCloud, domain.ACMEDns01ProviderTypeBaiduCloudDNS:
{ {
access := domain.AccessConfigForBaiduCloud{} access := domain.AccessConfigForBaiduCloud{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -177,7 +177,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeBunny: case domain.ACMEDns01ProviderTypeBunny:
{ {
access := domain.AccessConfigForBunny{} access := domain.AccessConfigForBunny{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -192,7 +192,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeCloudflare: case domain.ACMEDns01ProviderTypeCloudflare:
{ {
access := domain.AccessConfigForCloudflare{} access := domain.AccessConfigForCloudflare{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -208,7 +208,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeClouDNS: case domain.ACMEDns01ProviderTypeClouDNS:
{ {
access := domain.AccessConfigForClouDNS{} access := domain.AccessConfigForClouDNS{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -224,7 +224,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeCMCCCloud, domain.ACMEDns01ProviderTypeCMCCCloudDNS: case domain.ACMEDns01ProviderTypeCMCCCloud, domain.ACMEDns01ProviderTypeCMCCCloudDNS:
{ {
access := domain.AccessConfigForCMCCCloud{} access := domain.AccessConfigForCMCCCloud{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -240,7 +240,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeConstellix: case domain.ACMEDns01ProviderTypeConstellix:
{ {
access := domain.AccessConfigForConstellix{} access := domain.AccessConfigForConstellix{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -256,7 +256,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeCTCCCloud, domain.ACMEDns01ProviderTypeCTCCCloudSmartDNS: case domain.ACMEDns01ProviderTypeCTCCCloud, domain.ACMEDns01ProviderTypeCTCCCloudSmartDNS:
{ {
access := domain.AccessConfigForCTCCCloud{} access := domain.AccessConfigForCTCCCloud{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -272,7 +272,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeDeSEC: case domain.ACMEDns01ProviderTypeDeSEC:
{ {
access := domain.AccessConfigForDeSEC{} access := domain.AccessConfigForDeSEC{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -287,7 +287,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeDigitalOcean: case domain.ACMEDns01ProviderTypeDigitalOcean:
{ {
access := domain.AccessConfigForDigitalOcean{} access := domain.AccessConfigForDigitalOcean{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -302,7 +302,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeDNSLA: case domain.ACMEDns01ProviderTypeDNSLA:
{ {
access := domain.AccessConfigForDNSLA{} access := domain.AccessConfigForDNSLA{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -318,7 +318,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeDuckDNS: case domain.ACMEDns01ProviderTypeDuckDNS:
{ {
access := domain.AccessConfigForDuckDNS{} access := domain.AccessConfigForDuckDNS{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -332,7 +332,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeDynv6: case domain.ACMEDns01ProviderTypeDynv6:
{ {
access := domain.AccessConfigForDynv6{} access := domain.AccessConfigForDynv6{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -347,7 +347,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeGcore: case domain.ACMEDns01ProviderTypeGcore:
{ {
access := domain.AccessConfigForGcore{} access := domain.AccessConfigForGcore{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -362,7 +362,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeGname: case domain.ACMEDns01ProviderTypeGname:
{ {
access := domain.AccessConfigForGname{} access := domain.AccessConfigForGname{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -378,7 +378,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeGoDaddy: case domain.ACMEDns01ProviderTypeGoDaddy:
{ {
access := domain.AccessConfigForGoDaddy{} access := domain.AccessConfigForGoDaddy{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -394,7 +394,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeHetzner: case domain.ACMEDns01ProviderTypeHetzner:
{ {
access := domain.AccessConfigForHetzner{} access := domain.AccessConfigForHetzner{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -409,14 +409,14 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeHuaweiCloud, domain.ACMEDns01ProviderTypeHuaweiCloudDNS: case domain.ACMEDns01ProviderTypeHuaweiCloud, domain.ACMEDns01ProviderTypeHuaweiCloudDNS:
{ {
access := domain.AccessConfigForHuaweiCloud{} access := domain.AccessConfigForHuaweiCloud{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
applicant, err := pHuaweiCloud.NewChallengeProvider(&pHuaweiCloud.ChallengeProviderConfig{ applicant, err := pHuaweiCloud.NewChallengeProvider(&pHuaweiCloud.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId, AccessKeyId: access.AccessKeyId,
SecretAccessKey: access.SecretAccessKey, SecretAccessKey: access.SecretAccessKey,
Region: maputil.GetString(options.ProviderServiceConfig, "region"), Region: xmaps.GetString(options.ProviderServiceConfig, "region"),
DnsPropagationTimeout: options.DnsPropagationTimeout, DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL, DnsTTL: options.DnsTTL,
}) })
@ -426,14 +426,14 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeJDCloud, domain.ACMEDns01ProviderTypeJDCloudDNS: case domain.ACMEDns01ProviderTypeJDCloud, domain.ACMEDns01ProviderTypeJDCloudDNS:
{ {
access := domain.AccessConfigForJDCloud{} access := domain.AccessConfigForJDCloud{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
applicant, err := pJDCloud.NewChallengeProvider(&pJDCloud.ChallengeProviderConfig{ applicant, err := pJDCloud.NewChallengeProvider(&pJDCloud.ChallengeProviderConfig{
AccessKeyId: access.AccessKeyId, AccessKeyId: access.AccessKeyId,
AccessKeySecret: access.AccessKeySecret, AccessKeySecret: access.AccessKeySecret,
RegionId: maputil.GetString(options.ProviderServiceConfig, "regionId"), RegionId: xmaps.GetString(options.ProviderServiceConfig, "regionId"),
DnsPropagationTimeout: options.DnsPropagationTimeout, DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL, DnsTTL: options.DnsTTL,
}) })
@ -443,7 +443,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeNamecheap: case domain.ACMEDns01ProviderTypeNamecheap:
{ {
access := domain.AccessConfigForNamecheap{} access := domain.AccessConfigForNamecheap{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -459,7 +459,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeNameDotCom: case domain.ACMEDns01ProviderTypeNameDotCom:
{ {
access := domain.AccessConfigForNameDotCom{} access := domain.AccessConfigForNameDotCom{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -475,7 +475,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeNameSilo: case domain.ACMEDns01ProviderTypeNameSilo:
{ {
access := domain.AccessConfigForNameSilo{} access := domain.AccessConfigForNameSilo{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -490,7 +490,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeNetcup: case domain.ACMEDns01ProviderTypeNetcup:
{ {
access := domain.AccessConfigForNetcup{} access := domain.AccessConfigForNetcup{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -507,7 +507,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeNetlify: case domain.ACMEDns01ProviderTypeNetlify:
{ {
access := domain.AccessConfigForNetlify{} access := domain.AccessConfigForNetlify{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -522,7 +522,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeNS1: case domain.ACMEDns01ProviderTypeNS1:
{ {
access := domain.AccessConfigForNS1{} access := domain.AccessConfigForNS1{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -537,7 +537,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypePorkbun: case domain.ACMEDns01ProviderTypePorkbun:
{ {
access := domain.AccessConfigForPorkbun{} access := domain.AccessConfigForPorkbun{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -553,7 +553,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypePowerDNS: case domain.ACMEDns01ProviderTypePowerDNS:
{ {
access := domain.AccessConfigForPowerDNS{} access := domain.AccessConfigForPowerDNS{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -570,7 +570,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeRainYun: case domain.ACMEDns01ProviderTypeRainYun:
{ {
access := domain.AccessConfigForRainYun{} access := domain.AccessConfigForRainYun{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -585,7 +585,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeTencentCloud, domain.ACMEDns01ProviderTypeTencentCloudDNS, domain.ACMEDns01ProviderTypeTencentCloudEO: case domain.ACMEDns01ProviderTypeTencentCloud, domain.ACMEDns01ProviderTypeTencentCloudDNS, domain.ACMEDns01ProviderTypeTencentCloudEO:
{ {
access := domain.AccessConfigForTencentCloud{} access := domain.AccessConfigForTencentCloud{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -603,7 +603,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
applicant, err := pTencentCloudEO.NewChallengeProvider(&pTencentCloudEO.ChallengeProviderConfig{ applicant, err := pTencentCloudEO.NewChallengeProvider(&pTencentCloudEO.ChallengeProviderConfig{
SecretId: access.SecretId, SecretId: access.SecretId,
SecretKey: access.SecretKey, SecretKey: access.SecretKey,
ZoneId: maputil.GetString(options.ProviderServiceConfig, "zoneId"), ZoneId: xmaps.GetString(options.ProviderServiceConfig, "zoneId"),
DnsPropagationTimeout: options.DnsPropagationTimeout, DnsPropagationTimeout: options.DnsPropagationTimeout,
DnsTTL: options.DnsTTL, DnsTTL: options.DnsTTL,
}) })
@ -617,7 +617,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeUCloudUDNR: case domain.ACMEDns01ProviderTypeUCloudUDNR:
{ {
access := domain.AccessConfigForUCloud{} access := domain.AccessConfigForUCloud{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -633,7 +633,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeVercel: case domain.ACMEDns01ProviderTypeVercel:
{ {
access := domain.AccessConfigForVercel{} access := domain.AccessConfigForVercel{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -649,7 +649,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeVolcEngine, domain.ACMEDns01ProviderTypeVolcEngineDNS: case domain.ACMEDns01ProviderTypeVolcEngine, domain.ACMEDns01ProviderTypeVolcEngineDNS:
{ {
access := domain.AccessConfigForVolcEngine{} access := domain.AccessConfigForVolcEngine{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -665,7 +665,7 @@ func createApplicantProvider(options *applicantProviderOptions) (challenge.Provi
case domain.ACMEDns01ProviderTypeWestcn: case domain.ACMEDns01ProviderTypeWestcn:
{ {
access := domain.AccessConfigForWestcn{} access := domain.AccessConfigForWestcn{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }

8
internal/certificate/service.go
View File

@ -17,7 +17,7 @@ import (
"github.com/usual2970/certimate/internal/domain" "github.com/usual2970/certimate/internal/domain"
"github.com/usual2970/certimate/internal/domain/dtos" "github.com/usual2970/certimate/internal/domain/dtos"
"github.com/usual2970/certimate/internal/notify" "github.com/usual2970/certimate/internal/notify"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
"github.com/usual2970/certimate/internal/repository" "github.com/usual2970/certimate/internal/repository"
) )
@ -145,7 +145,7 @@ func (s *CertificateService) ArchiveFile(ctx context.Context, req *dtos.Certific
{ {
const pfxPassword = "certimate" const pfxPassword = "certimate"
certPFX, err := certutil.TransformCertificateFromPEMToPFX(certificate.Certificate, certificate.PrivateKey, pfxPassword) certPFX, err := xcert.TransformCertificateFromPEMToPFX(certificate.Certificate, certificate.PrivateKey, pfxPassword)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -183,7 +183,7 @@ func (s *CertificateService) ArchiveFile(ctx context.Context, req *dtos.Certific
{ {
const jksPassword = "certimate" const jksPassword = "certimate"
certJKS, err := certutil.TransformCertificateFromPEMToJKS(certificate.Certificate, certificate.PrivateKey, jksPassword, jksPassword, jksPassword) certJKS, err := xcert.TransformCertificateFromPEMToJKS(certificate.Certificate, certificate.PrivateKey, jksPassword, jksPassword, jksPassword)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -223,7 +223,7 @@ func (s *CertificateService) ArchiveFile(ctx context.Context, req *dtos.Certific
} }
func (s *CertificateService) ValidateCertificate(ctx context.Context, req *dtos.CertificateValidateCertificateReq) (*dtos.CertificateValidateCertificateResp, error) { func (s *CertificateService) ValidateCertificate(ctx context.Context, req *dtos.CertificateValidateCertificateReq) (*dtos.CertificateValidateCertificateResp, error) {
certX509, err := certutil.ParseCertificateFromPEM(req.Certificate) certX509, err := xcert.ParseCertificateFromPEM(req.Certificate)
if err != nil { if err != nil {
return nil, err return nil, err
} else if time.Now().After(certX509.NotAfter) { } else if time.Now().After(certX509.NotAfter) {

534
internal/deployer/providers.go
View File

File diff suppressed because it is too large Load Diff

6
internal/domain/certificate.go
View File

@ -8,7 +8,7 @@ import (
"strings" "strings"
"time" "time"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
const CollectionNameCertificate = "certificate" const CollectionNameCertificate = "certificate"
@ -106,10 +106,10 @@ func (c *Certificate) PopulateFromPEM(certPEM, privkeyPEM string) *Certificate {
c.Certificate = certPEM c.Certificate = certPEM
c.PrivateKey = privkeyPEM c.PrivateKey = privkeyPEM
_, issuerCertPEM, _ := certutil.ExtractCertificatesFromPEM(certPEM) _, issuerCertPEM, _ := xcert.ExtractCertificatesFromPEM(certPEM)
c.IssuerCertificate = issuerCertPEM c.IssuerCertificate = issuerCertPEM
certX509, _ := certutil.ParseCertificateFromPEM(certPEM) certX509, _ := xcert.ParseCertificateFromPEM(certPEM)
if certX509 != nil { if certX509 != nil {
c.PopulateFromX509(certX509) c.PopulateFromX509(certX509)
} }

72
internal/domain/workflow.go
View File

@ -5,7 +5,7 @@ import (
"time" "time"
"github.com/usual2970/certimate/internal/domain/expr" "github.com/usual2970/certimate/internal/domain/expr"
maputil "github.com/usual2970/certimate/internal/pkg/utils/map" xmaps "github.com/usual2970/certimate/internal/pkg/utils/maps"
) )
const CollectionNameWorkflow = "workflow" const CollectionNameWorkflow = "workflow"
@ -121,62 +121,62 @@ type WorkflowNodeConfigForCondition struct {
func (n *WorkflowNode) GetConfigForApply() WorkflowNodeConfigForApply { func (n *WorkflowNode) GetConfigForApply() WorkflowNodeConfigForApply {
return WorkflowNodeConfigForApply{ return WorkflowNodeConfigForApply{
Domains: maputil.GetString(n.Config, "domains"), Domains: xmaps.GetString(n.Config, "domains"),
ContactEmail: maputil.GetString(n.Config, "contactEmail"), ContactEmail: xmaps.GetString(n.Config, "contactEmail"),
Provider: maputil.GetString(n.Config, "provider"), Provider: xmaps.GetString(n.Config, "provider"),
ProviderAccessId: maputil.GetString(n.Config, "providerAccessId"), ProviderAccessId: xmaps.GetString(n.Config, "providerAccessId"),
ProviderConfig: maputil.GetKVMapAny(n.Config, "providerConfig"), ProviderConfig: xmaps.GetKVMapAny(n.Config, "providerConfig"),
CAProvider: maputil.GetString(n.Config, "caProvider"), CAProvider: xmaps.GetString(n.Config, "caProvider"),
CAProviderAccessId: maputil.GetString(n.Config, "caProviderAccessId"), CAProviderAccessId: xmaps.GetString(n.Config, "caProviderAccessId"),
CAProviderConfig: maputil.GetKVMapAny(n.Config, "caProviderConfig"), CAProviderConfig: xmaps.GetKVMapAny(n.Config, "caProviderConfig"),
KeyAlgorithm: maputil.GetOrDefaultString(n.Config, "keyAlgorithm", string(CertificateKeyAlgorithmTypeRSA2048)), KeyAlgorithm: xmaps.GetOrDefaultString(n.Config, "keyAlgorithm", string(CertificateKeyAlgorithmTypeRSA2048)),
Nameservers: maputil.GetString(n.Config, "nameservers"), Nameservers: xmaps.GetString(n.Config, "nameservers"),
DnsPropagationWait: maputil.GetInt32(n.Config, "dnsPropagationWait"), DnsPropagationWait: xmaps.GetInt32(n.Config, "dnsPropagationWait"),
DnsPropagationTimeout: maputil.GetInt32(n.Config, "dnsPropagationTimeout"), DnsPropagationTimeout: xmaps.GetInt32(n.Config, "dnsPropagationTimeout"),
DnsTTL: maputil.GetInt32(n.Config, "dnsTTL"), DnsTTL: xmaps.GetInt32(n.Config, "dnsTTL"),
DisableFollowCNAME: maputil.GetBool(n.Config, "disableFollowCNAME"), DisableFollowCNAME: xmaps.GetBool(n.Config, "disableFollowCNAME"),
DisableARI: maputil.GetBool(n.Config, "disableARI"), DisableARI: xmaps.GetBool(n.Config, "disableARI"),
SkipBeforeExpiryDays: maputil.GetOrDefaultInt32(n.Config, "skipBeforeExpiryDays", 30), SkipBeforeExpiryDays: xmaps.GetOrDefaultInt32(n.Config, "skipBeforeExpiryDays", 30),
} }
} }
func (n *WorkflowNode) GetConfigForUpload() WorkflowNodeConfigForUpload { func (n *WorkflowNode) GetConfigForUpload() WorkflowNodeConfigForUpload {
return WorkflowNodeConfigForUpload{ return WorkflowNodeConfigForUpload{
Certificate: maputil.GetString(n.Config, "certificate"), Certificate: xmaps.GetString(n.Config, "certificate"),
PrivateKey: maputil.GetString(n.Config, "privateKey"), PrivateKey: xmaps.GetString(n.Config, "privateKey"),
Domains: maputil.GetString(n.Config, "domains"), Domains: xmaps.GetString(n.Config, "domains"),
} }
} }
func (n *WorkflowNode) GetConfigForMonitor() WorkflowNodeConfigForMonitor { func (n *WorkflowNode) GetConfigForMonitor() WorkflowNodeConfigForMonitor {
host := maputil.GetString(n.Config, "host") host := xmaps.GetString(n.Config, "host")
return WorkflowNodeConfigForMonitor{ return WorkflowNodeConfigForMonitor{
Host: host, Host: host,
Port: maputil.GetOrDefaultInt32(n.Config, "port", 443), Port: xmaps.GetOrDefaultInt32(n.Config, "port", 443),
Domain: maputil.GetOrDefaultString(n.Config, "domain", host), Domain: xmaps.GetOrDefaultString(n.Config, "domain", host),
RequestPath: maputil.GetString(n.Config, "path"), RequestPath: xmaps.GetString(n.Config, "path"),
} }
} }
func (n *WorkflowNode) GetConfigForDeploy() WorkflowNodeConfigForDeploy { func (n *WorkflowNode) GetConfigForDeploy() WorkflowNodeConfigForDeploy {
return WorkflowNodeConfigForDeploy{ return WorkflowNodeConfigForDeploy{
Certificate: maputil.GetString(n.Config, "certificate"), Certificate: xmaps.GetString(n.Config, "certificate"),
Provider: maputil.GetString(n.Config, "provider"), Provider: xmaps.GetString(n.Config, "provider"),
ProviderAccessId: maputil.GetString(n.Config, "providerAccessId"), ProviderAccessId: xmaps.GetString(n.Config, "providerAccessId"),
ProviderConfig: maputil.GetKVMapAny(n.Config, "providerConfig"), ProviderConfig: xmaps.GetKVMapAny(n.Config, "providerConfig"),
SkipOnLastSucceeded: maputil.GetBool(n.Config, "skipOnLastSucceeded"), SkipOnLastSucceeded: xmaps.GetBool(n.Config, "skipOnLastSucceeded"),
} }
} }
func (n *WorkflowNode) GetConfigForNotify() WorkflowNodeConfigForNotify { func (n *WorkflowNode) GetConfigForNotify() WorkflowNodeConfigForNotify {
return WorkflowNodeConfigForNotify{ return WorkflowNodeConfigForNotify{
Channel: maputil.GetString(n.Config, "channel"), Channel: xmaps.GetString(n.Config, "channel"),
Provider: maputil.GetString(n.Config, "provider"), Provider: xmaps.GetString(n.Config, "provider"),
ProviderAccessId: maputil.GetString(n.Config, "providerAccessId"), ProviderAccessId: xmaps.GetString(n.Config, "providerAccessId"),
ProviderConfig: maputil.GetKVMapAny(n.Config, "providerConfig"), ProviderConfig: xmaps.GetKVMapAny(n.Config, "providerConfig"),
Subject: maputil.GetString(n.Config, "subject"), Subject: xmaps.GetString(n.Config, "subject"),
Message: maputil.GetString(n.Config, "message"), Message: xmaps.GetString(n.Config, "message"),
SkipOnAllPrevSkipped: maputil.GetBool(n.Config, "skipOnAllPrevSkipped"), SkipOnAllPrevSkipped: xmaps.GetBool(n.Config, "skipOnAllPrevSkipped"),
} }
} }

4
internal/notify/notify.go
View File

@ -9,7 +9,7 @@ import (
"github.com/usual2970/certimate/internal/domain" "github.com/usual2970/certimate/internal/domain"
"github.com/usual2970/certimate/internal/pkg/core/notifier" "github.com/usual2970/certimate/internal/pkg/core/notifier"
maputil "github.com/usual2970/certimate/internal/pkg/utils/map" xmaps "github.com/usual2970/certimate/internal/pkg/utils/maps"
"github.com/usual2970/certimate/internal/repository" "github.com/usual2970/certimate/internal/repository"
) )
@ -65,7 +65,7 @@ func getEnabledNotifiers() ([]notifier.Notifier, error) {
notifiers := make([]notifier.Notifier, 0) notifiers := make([]notifier.Notifier, 0)
for k, v := range rs { for k, v := range rs {
if !maputil.GetBool(v, "enabled") { if !xmaps.GetBool(v, "enabled") {
continue continue
} }

44
internal/notify/providers.go
View File

@ -15,8 +15,8 @@ import (
pTelegramBot "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/telegrambot" pTelegramBot "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/telegrambot"
pWebhook "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/webhook" pWebhook "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/webhook"
pWeComBot "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/wecombot" pWeComBot "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/wecombot"
httputil "github.com/usual2970/certimate/internal/pkg/utils/http" xhttp "github.com/usual2970/certimate/internal/pkg/utils/http"
maputil "github.com/usual2970/certimate/internal/pkg/utils/map" xmaps "github.com/usual2970/certimate/internal/pkg/utils/maps"
) )
type notifierProviderOptions struct { type notifierProviderOptions struct {
@ -34,7 +34,7 @@ func createNotifierProvider(options *notifierProviderOptions) (notifier.Notifier
case domain.NotificationProviderTypeDingTalkBot: case domain.NotificationProviderTypeDingTalkBot:
{ {
access := domain.AccessConfigForDingTalkBot{} access := domain.AccessConfigForDingTalkBot{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -47,20 +47,20 @@ func createNotifierProvider(options *notifierProviderOptions) (notifier.Notifier
case domain.NotificationProviderTypeDiscordBot: case domain.NotificationProviderTypeDiscordBot:
{ {
access := domain.AccessConfigForDiscordBot{} access := domain.AccessConfigForDiscordBot{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
return pDiscordBot.NewNotifier(&pDiscordBot.NotifierConfig{ return pDiscordBot.NewNotifier(&pDiscordBot.NotifierConfig{
BotToken: access.BotToken, BotToken: access.BotToken,
ChannelId: maputil.GetOrDefaultString(options.ProviderServiceConfig, "channelId", access.DefaultChannelId), ChannelId: xmaps.GetOrDefaultString(options.ProviderServiceConfig, "channelId", access.DefaultChannelId),
}) })
} }
case domain.NotificationProviderTypeEmail: case domain.NotificationProviderTypeEmail:
{ {
access := domain.AccessConfigForEmail{} access := domain.AccessConfigForEmail{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -70,16 +70,16 @@ func createNotifierProvider(options *notifierProviderOptions) (notifier.Notifier
SmtpTls: access.SmtpTls, SmtpTls: access.SmtpTls,
Username: access.Username, Username: access.Username,
Password: access.Password, Password: access.Password,
SenderAddress: maputil.GetOrDefaultString(options.ProviderServiceConfig, "senderAddress", access.DefaultSenderAddress), SenderAddress: xmaps.GetOrDefaultString(options.ProviderServiceConfig, "senderAddress", access.DefaultSenderAddress),
SenderName: maputil.GetOrDefaultString(options.ProviderServiceConfig, "senderName", access.DefaultSenderName), SenderName: xmaps.GetOrDefaultString(options.ProviderServiceConfig, "senderName", access.DefaultSenderName),
ReceiverAddress: maputil.GetOrDefaultString(options.ProviderServiceConfig, "receiverAddress", access.DefaultReceiverAddress), ReceiverAddress: xmaps.GetOrDefaultString(options.ProviderServiceConfig, "receiverAddress", access.DefaultReceiverAddress),
}) })
} }
case domain.NotificationProviderTypeLarkBot: case domain.NotificationProviderTypeLarkBot:
{ {
access := domain.AccessConfigForLarkBot{} access := domain.AccessConfigForLarkBot{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -91,7 +91,7 @@ func createNotifierProvider(options *notifierProviderOptions) (notifier.Notifier
case domain.NotificationProviderTypeMattermost: case domain.NotificationProviderTypeMattermost:
{ {
access := domain.AccessConfigForMattermost{} access := domain.AccessConfigForMattermost{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
@ -99,46 +99,46 @@ func createNotifierProvider(options *notifierProviderOptions) (notifier.Notifier
ServerUrl: access.ServerUrl, ServerUrl: access.ServerUrl,
Username: access.Username, Username: access.Username,
Password: access.Password, Password: access.Password,
ChannelId: maputil.GetOrDefaultString(options.ProviderServiceConfig, "channelId", access.DefaultChannelId), ChannelId: xmaps.GetOrDefaultString(options.ProviderServiceConfig, "channelId", access.DefaultChannelId),
}) })
} }
case domain.NotificationProviderTypeSlackBot: case domain.NotificationProviderTypeSlackBot:
{ {
access := domain.AccessConfigForSlackBot{} access := domain.AccessConfigForSlackBot{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
return pSlackBot.NewNotifier(&pSlackBot.NotifierConfig{ return pSlackBot.NewNotifier(&pSlackBot.NotifierConfig{
BotToken: access.BotToken, BotToken: access.BotToken,
ChannelId: maputil.GetOrDefaultString(options.ProviderServiceConfig, "channelId", access.DefaultChannelId), ChannelId: xmaps.GetOrDefaultString(options.ProviderServiceConfig, "channelId", access.DefaultChannelId),
}) })
} }
case domain.NotificationProviderTypeTelegramBot: case domain.NotificationProviderTypeTelegramBot:
{ {
access := domain.AccessConfigForTelegramBot{} access := domain.AccessConfigForTelegramBot{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
return pTelegramBot.NewNotifier(&pTelegramBot.NotifierConfig{ return pTelegramBot.NewNotifier(&pTelegramBot.NotifierConfig{
BotToken: access.BotToken, BotToken: access.BotToken,
ChatId: maputil.GetOrDefaultInt64(options.ProviderServiceConfig, "chatId", access.DefaultChatId), ChatId: xmaps.GetOrDefaultInt64(options.ProviderServiceConfig, "chatId", access.DefaultChatId),
}) })
} }
case domain.NotificationProviderTypeWebhook: case domain.NotificationProviderTypeWebhook:
{ {
access := domain.AccessConfigForWebhook{} access := domain.AccessConfigForWebhook{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }
mergedHeaders := make(map[string]string) mergedHeaders := make(map[string]string)
if defaultHeadersString := access.HeadersString; defaultHeadersString != "" { if defaultHeadersString := access.HeadersString; defaultHeadersString != "" {
h, err := httputil.ParseHeaders(defaultHeadersString) h, err := xhttp.ParseHeaders(defaultHeadersString)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to parse webhook headers: %w", err) return nil, fmt.Errorf("failed to parse webhook headers: %w", err)
} }
@ -146,8 +146,8 @@ func createNotifierProvider(options *notifierProviderOptions) (notifier.Notifier
mergedHeaders[http.CanonicalHeaderKey(key)] = h.Get(key) mergedHeaders[http.CanonicalHeaderKey(key)] = h.Get(key)
} }
} }
if extendedHeadersString := maputil.GetString(options.ProviderServiceConfig, "headers"); extendedHeadersString != "" { if extendedHeadersString := xmaps.GetString(options.ProviderServiceConfig, "headers"); extendedHeadersString != "" {
h, err := httputil.ParseHeaders(extendedHeadersString) h, err := xhttp.ParseHeaders(extendedHeadersString)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to parse webhook headers: %w", err) return nil, fmt.Errorf("failed to parse webhook headers: %w", err)
} }
@ -158,7 +158,7 @@ func createNotifierProvider(options *notifierProviderOptions) (notifier.Notifier
return pWebhook.NewNotifier(&pWebhook.NotifierConfig{ return pWebhook.NewNotifier(&pWebhook.NotifierConfig{
WebhookUrl: access.Url, WebhookUrl: access.Url,
WebhookData: maputil.GetOrDefaultString(options.ProviderServiceConfig, "webhookData", access.DefaultDataForNotification), WebhookData: xmaps.GetOrDefaultString(options.ProviderServiceConfig, "webhookData", access.DefaultDataForNotification),
Method: access.Method, Method: access.Method,
Headers: mergedHeaders, Headers: mergedHeaders,
AllowInsecureConnections: access.AllowInsecureConnections, AllowInsecureConnections: access.AllowInsecureConnections,
@ -168,7 +168,7 @@ func createNotifierProvider(options *notifierProviderOptions) (notifier.Notifier
case domain.NotificationProviderTypeWeComBot: case domain.NotificationProviderTypeWeComBot:
{ {
access := domain.AccessConfigForWeComBot{} access := domain.AccessConfigForWeComBot{}
if err := maputil.Populate(options.ProviderAccessConfig, &access); err != nil { if err := xmaps.Populate(options.ProviderAccessConfig, &access); err != nil {
return nil, fmt.Errorf("failed to populate provider access config: %w", err) return nil, fmt.Errorf("failed to populate provider access config: %w", err)
} }

58
internal/notify/providers_deprecated.go
View File

@ -17,7 +17,7 @@ import (
pTelegram "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/telegrambot" pTelegram "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/telegrambot"
pWebhook "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/webhook" pWebhook "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/webhook"
pWeCom "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/wecombot" pWeCom "github.com/usual2970/certimate/internal/pkg/core/notifier/providers/wecombot"
maputil "github.com/usual2970/certimate/internal/pkg/utils/map" xmaps "github.com/usual2970/certimate/internal/pkg/utils/maps"
) )
// Deprecated: v0.4.x 将废弃 // Deprecated: v0.4.x 将废弃
@ -29,78 +29,78 @@ func createNotifierProviderUseGlobalSettings(channel domain.NotifyChannelType, c
switch channel { switch channel {
case domain.NotifyChannelTypeBark: case domain.NotifyChannelTypeBark:
return pBark.NewNotifier(&pBark.NotifierConfig{ return pBark.NewNotifier(&pBark.NotifierConfig{
DeviceKey: maputil.GetString(channelConfig, "deviceKey"), DeviceKey: xmaps.GetString(channelConfig, "deviceKey"),
ServerUrl: maputil.GetString(channelConfig, "serverUrl"), ServerUrl: xmaps.GetString(channelConfig, "serverUrl"),
}) })
case domain.NotifyChannelTypeDingTalk: case domain.NotifyChannelTypeDingTalk:
return pDingTalk.NewNotifier(&pDingTalk.NotifierConfig{ return pDingTalk.NewNotifier(&pDingTalk.NotifierConfig{
WebhookUrl: "https://oapi.dingtalk.com/robot/send?access_token=" + maputil.GetString(channelConfig, "accessToken"), WebhookUrl: "https://oapi.dingtalk.com/robot/send?access_token=" + xmaps.GetString(channelConfig, "accessToken"),
Secret: maputil.GetString(channelConfig, "secret"), Secret: xmaps.GetString(channelConfig, "secret"),
}) })
case domain.NotifyChannelTypeEmail: case domain.NotifyChannelTypeEmail:
return pEmail.NewNotifier(&pEmail.NotifierConfig{ return pEmail.NewNotifier(&pEmail.NotifierConfig{
SmtpHost: maputil.GetString(channelConfig, "smtpHost"), SmtpHost: xmaps.GetString(channelConfig, "smtpHost"),
SmtpPort: maputil.GetInt32(channelConfig, "smtpPort"), SmtpPort: xmaps.GetInt32(channelConfig, "smtpPort"),
SmtpTls: maputil.GetOrDefaultBool(channelConfig, "smtpTLS", true), SmtpTls: xmaps.GetOrDefaultBool(channelConfig, "smtpTLS", true),
Username: maputil.GetOrDefaultString(channelConfig, "username", maputil.GetString(channelConfig, "senderAddress")), Username: xmaps.GetOrDefaultString(channelConfig, "username", xmaps.GetString(channelConfig, "senderAddress")),
Password: maputil.GetString(channelConfig, "password"), Password: xmaps.GetString(channelConfig, "password"),
SenderAddress: maputil.GetString(channelConfig, "senderAddress"), SenderAddress: xmaps.GetString(channelConfig, "senderAddress"),
ReceiverAddress: maputil.GetString(channelConfig, "receiverAddress"), ReceiverAddress: xmaps.GetString(channelConfig, "receiverAddress"),
}) })
case domain.NotifyChannelTypeGotify: case domain.NotifyChannelTypeGotify:
return pGotify.NewNotifier(&pGotify.NotifierConfig{ return pGotify.NewNotifier(&pGotify.NotifierConfig{
ServerUrl: maputil.GetString(channelConfig, "url"), ServerUrl: xmaps.GetString(channelConfig, "url"),
Token: maputil.GetString(channelConfig, "token"), Token: xmaps.GetString(channelConfig, "token"),
Priority: maputil.GetOrDefaultInt64(channelConfig, "priority", 1), Priority: xmaps.GetOrDefaultInt64(channelConfig, "priority", 1),
}) })
case domain.NotifyChannelTypeLark: case domain.NotifyChannelTypeLark:
return pLark.NewNotifier(&pLark.NotifierConfig{ return pLark.NewNotifier(&pLark.NotifierConfig{
WebhookUrl: maputil.GetString(channelConfig, "webhookUrl"), WebhookUrl: xmaps.GetString(channelConfig, "webhookUrl"),
}) })
case domain.NotifyChannelTypeMattermost: case domain.NotifyChannelTypeMattermost:
return pMattermost.NewNotifier(&pMattermost.NotifierConfig{ return pMattermost.NewNotifier(&pMattermost.NotifierConfig{
ServerUrl: maputil.GetString(channelConfig, "serverUrl"), ServerUrl: xmaps.GetString(channelConfig, "serverUrl"),
ChannelId: maputil.GetString(channelConfig, "channelId"), ChannelId: xmaps.GetString(channelConfig, "channelId"),
Username: maputil.GetString(channelConfig, "username"), Username: xmaps.GetString(channelConfig, "username"),
Password: maputil.GetString(channelConfig, "password"), Password: xmaps.GetString(channelConfig, "password"),
}) })
case domain.NotifyChannelTypePushover: case domain.NotifyChannelTypePushover:
return pPushover.NewNotifier(&pPushover.NotifierConfig{ return pPushover.NewNotifier(&pPushover.NotifierConfig{
Token: maputil.GetString(channelConfig, "token"), Token: xmaps.GetString(channelConfig, "token"),
User: maputil.GetString(channelConfig, "user"), User: xmaps.GetString(channelConfig, "user"),
}) })
case domain.NotifyChannelTypePushPlus: case domain.NotifyChannelTypePushPlus:
return pPushPlus.NewNotifier(&pPushPlus.NotifierConfig{ return pPushPlus.NewNotifier(&pPushPlus.NotifierConfig{
Token: maputil.GetString(channelConfig, "token"), Token: xmaps.GetString(channelConfig, "token"),
}) })
case domain.NotifyChannelTypeServerChan: case domain.NotifyChannelTypeServerChan:
return pServerChan.NewNotifier(&pServerChan.NotifierConfig{ return pServerChan.NewNotifier(&pServerChan.NotifierConfig{
ServerUrl: maputil.GetString(channelConfig, "url"), ServerUrl: xmaps.GetString(channelConfig, "url"),
}) })
case domain.NotifyChannelTypeTelegram: case domain.NotifyChannelTypeTelegram:
return pTelegram.NewNotifier(&pTelegram.NotifierConfig{ return pTelegram.NewNotifier(&pTelegram.NotifierConfig{
BotToken: maputil.GetString(channelConfig, "apiToken"), BotToken: xmaps.GetString(channelConfig, "apiToken"),
ChatId: maputil.GetInt64(channelConfig, "chatId"), ChatId: xmaps.GetInt64(channelConfig, "chatId"),
}) })
case domain.NotifyChannelTypeWebhook: case domain.NotifyChannelTypeWebhook:
return pWebhook.NewNotifier(&pWebhook.NotifierConfig{ return pWebhook.NewNotifier(&pWebhook.NotifierConfig{
WebhookUrl: maputil.GetString(channelConfig, "url"), WebhookUrl: xmaps.GetString(channelConfig, "url"),
AllowInsecureConnections: maputil.GetBool(channelConfig, "allowInsecureConnections"), AllowInsecureConnections: xmaps.GetBool(channelConfig, "allowInsecureConnections"),
}) })
case domain.NotifyChannelTypeWeCom: case domain.NotifyChannelTypeWeCom:
return pWeCom.NewNotifier(&pWeCom.NotifierConfig{ return pWeCom.NewNotifier(&pWeCom.NotifierConfig{
WebhookUrl: maputil.GetString(channelConfig, "webhookUrl"), WebhookUrl: xmaps.GetString(channelConfig, "webhookUrl"),
}) })
} }

40
internal/pkg/core/applicant/acme-dns-01/lego-providers/ctcccloud/internal/lego.go
View File

@ -10,7 +10,7 @@ import (
"github.com/go-acme/lego/v4/platform/config/env" "github.com/go-acme/lego/v4/platform/config/env"
ctyundns "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/dns" ctyundns "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/dns"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
const ( const (
@ -129,9 +129,9 @@ func (d *DNSProvider) findDNSRecordId(zoneName, subDomain string) (int32, error)
// 查询解析记录列表 // 查询解析记录列表
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=122&api=11264&data=181&isNormal=1&vid=259 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=122&api=11264&data=181&isNormal=1&vid=259
request := &ctyundns.QueryRecordListRequest{} request := &ctyundns.QueryRecordListRequest{}
request.Domain = typeutil.ToPtr(zoneName) request.Domain = xtypes.ToPtr(zoneName)
request.Host = typeutil.ToPtr(subDomain) request.Host = xtypes.ToPtr(subDomain)
request.Type = typeutil.ToPtr("TXT") request.Type = xtypes.ToPtr("TXT")
response, err := d.client.QueryRecordList(request) response, err := d.client.QueryRecordList(request)
if err != nil { if err != nil {
@ -155,13 +155,13 @@ func (d *DNSProvider) addOrUpdateDNSRecord(zoneName, subDomain, value string) er
// 新增解析记录 // 新增解析记录
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=122&api=11259&data=181&isNormal=1&vid=259 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=122&api=11259&data=181&isNormal=1&vid=259
request := &ctyundns.AddRecordRequest{ request := &ctyundns.AddRecordRequest{
Domain: typeutil.ToPtr(zoneName), Domain: xtypes.ToPtr(zoneName),
Host: typeutil.ToPtr(subDomain), Host: xtypes.ToPtr(subDomain),
Type: typeutil.ToPtr("TXT"), Type: xtypes.ToPtr("TXT"),
LineCode: typeutil.ToPtr("Default"), LineCode: xtypes.ToPtr("Default"),
Value: typeutil.ToPtr(value), Value: xtypes.ToPtr(value),
State: typeutil.ToPtr(int32(1)), State: xtypes.ToPtr(int32(1)),
TTL: typeutil.ToPtr(int32(d.config.TTL)), TTL: xtypes.ToPtr(int32(d.config.TTL)),
} }
_, err := d.client.AddRecord(request) _, err := d.client.AddRecord(request)
return err return err
@ -169,14 +169,14 @@ func (d *DNSProvider) addOrUpdateDNSRecord(zoneName, subDomain, value string) er
// 修改解析记录 // 修改解析记录
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=122&api=11261&data=181&isNormal=1&vid=259 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=122&api=11261&data=181&isNormal=1&vid=259
request := &ctyundns.UpdateRecordRequest{ request := &ctyundns.UpdateRecordRequest{
RecordId: typeutil.ToPtr(recordId), RecordId: xtypes.ToPtr(recordId),
Domain: typeutil.ToPtr(zoneName), Domain: xtypes.ToPtr(zoneName),
Host: typeutil.ToPtr(subDomain), Host: xtypes.ToPtr(subDomain),
Type: typeutil.ToPtr("TXT"), Type: xtypes.ToPtr("TXT"),
LineCode: typeutil.ToPtr("Default"), LineCode: xtypes.ToPtr("Default"),
Value: typeutil.ToPtr(value), Value: xtypes.ToPtr(value),
State: typeutil.ToPtr(int32(1)), State: xtypes.ToPtr(int32(1)),
TTL: typeutil.ToPtr(int32(d.config.TTL)), TTL: xtypes.ToPtr(int32(d.config.TTL)),
} }
_, err := d.client.UpdateRecord(request) _, err := d.client.UpdateRecord(request)
return err return err
@ -195,7 +195,7 @@ func (d *DNSProvider) removeDNSRecord(zoneName, subDomain string) error {
// 删除解析记录 // 删除解析记录
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=122&api=11262&data=181&isNormal=1&vid=259 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=122&api=11262&data=181&isNormal=1&vid=259
request := &ctyundns.DeleteRecordRequest{ request := &ctyundns.DeleteRecordRequest{
RecordId: typeutil.ToPtr(recordId), RecordId: xtypes.ToPtr(recordId),
} }
_, err = d.client.DeleteRecord(request) _, err = d.client.DeleteRecord(request)
return err return err

4
internal/pkg/core/deployer/providers/aliyun-apigw/aliyun_apigw.go
View File

@ -16,7 +16,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -152,7 +152,7 @@ func (d *DeployerProvider) deployToCloudNative(ctx context.Context, certPEM stri
} }
listDomainsReq := &aliapig.ListDomainsRequest{ listDomainsReq := &aliapig.ListDomainsRequest{
ResourceGroupId: typeutil.ToPtrOrZeroNil(d.config.ResourceGroupId), ResourceGroupId: xtypes.ToPtrOrZeroNil(d.config.ResourceGroupId),
GatewayId: tea.String(d.config.GatewayId), GatewayId: tea.String(d.config.GatewayId),
NameLike: tea.String(d.config.Domain), NameLike: tea.String(d.config.Domain),
PageNumber: tea.Int32(listDomainsPageNumber), PageNumber: tea.Int32(listDomainsPageNumber),

6
internal/pkg/core/deployer/providers/aliyun-ga/aliyun_ga.go
View File

@ -14,7 +14,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas"
sliceutil "github.com/usual2970/certimate/internal/pkg/utils/slice" xslices "github.com/usual2970/certimate/internal/pkg/utils/slices"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -252,14 +252,14 @@ func (d *DeployerProvider) updateListenerCertificate(ctx context.Context, cloudA
} }
} else { } else {
// 指定 SNI，需部署到扩展域名 // 指定 SNI，需部署到扩展域名
if sliceutil.Some(listenerAdditionalCertificates, func(item *aliga.ListListenerCertificatesResponseBodyCertificates) bool { if xslices.Some(listenerAdditionalCertificates, func(item *aliga.ListListenerCertificatesResponseBodyCertificates) bool {
return tea.StringValue(item.CertificateId) == cloudCertId return tea.StringValue(item.CertificateId) == cloudCertId
}) { }) {
d.logger.Info("no need to update ga listener additional certificate") d.logger.Info("no need to update ga listener additional certificate")
return nil return nil
} }
if sliceutil.Some(listenerAdditionalCertificates, func(item *aliga.ListListenerCertificatesResponseBodyCertificates) bool { if xslices.Some(listenerAdditionalCertificates, func(item *aliga.ListListenerCertificatesResponseBodyCertificates) bool {
return tea.StringValue(item.Domain) == d.config.Domain return tea.StringValue(item.Domain) == d.config.Domain
}) { }) {
// 为监听替换扩展证书 // 为监听替换扩展证书

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

@ -14,8 +14,8 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aliyun-cas"
sliceutil "github.com/usual2970/certimate/internal/pkg/utils/slice" xslices "github.com/usual2970/certimate/internal/pkg/utils/slices"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -110,7 +110,7 @@ func (d *DeployerProvider) deployToWAF3(ctx context.Context, certPEM string, pri
// 查询默认 SSL/TLS 设置 // 查询默认 SSL/TLS 设置
// REF: https://help.aliyun.com/zh/waf/web-application-firewall-3-0/developer-reference/api-waf-openapi-2021-10-01-describedefaulthttps // REF: https://help.aliyun.com/zh/waf/web-application-firewall-3-0/developer-reference/api-waf-openapi-2021-10-01-describedefaulthttps
describeDefaultHttpsReq := &aliwaf.DescribeDefaultHttpsRequest{ describeDefaultHttpsReq := &aliwaf.DescribeDefaultHttpsRequest{
ResourceManagerResourceGroupId: typeutil.ToPtrOrZeroNil(d.config.ResourceGroupId), ResourceManagerResourceGroupId: xtypes.ToPtrOrZeroNil(d.config.ResourceGroupId),
InstanceId: tea.String(d.config.InstanceId), InstanceId: tea.String(d.config.InstanceId),
RegionId: tea.String(d.config.Region), RegionId: tea.String(d.config.Region),
} }
@ -123,7 +123,7 @@ func (d *DeployerProvider) deployToWAF3(ctx context.Context, certPEM string, pri
// 修改默认 SSL/TLS 设置 // 修改默认 SSL/TLS 设置
// REF: https://help.aliyun.com/zh/waf/web-application-firewall-3-0/developer-reference/api-waf-openapi-2021-10-01-modifydefaulthttps // REF: https://help.aliyun.com/zh/waf/web-application-firewall-3-0/developer-reference/api-waf-openapi-2021-10-01-modifydefaulthttps
modifyDefaultHttpsReq := &aliwaf.ModifyDefaultHttpsRequest{ modifyDefaultHttpsReq := &aliwaf.ModifyDefaultHttpsRequest{
ResourceManagerResourceGroupId: typeutil.ToPtrOrZeroNil(d.config.ResourceGroupId), ResourceManagerResourceGroupId: xtypes.ToPtrOrZeroNil(d.config.ResourceGroupId),
InstanceId: tea.String(d.config.InstanceId), InstanceId: tea.String(d.config.InstanceId),
RegionId: tea.String(d.config.Region), RegionId: tea.String(d.config.Region),
CertId: tea.String(upres.CertId), CertId: tea.String(upres.CertId),
@ -252,7 +252,7 @@ func assign(source *aliwaf.ModifyDomainRequest, target *aliwaf.DescribeDomainDet
} }
if target.Listen.HttpPorts != nil { if target.Listen.HttpPorts != nil {
source.Listen.HttpPorts = sliceutil.Map(target.Listen.HttpPorts, func(v *int64) *int32 { source.Listen.HttpPorts = xslices.Map(target.Listen.HttpPorts, func(v *int64) *int32 {
if v == nil { if v == nil {
return nil return nil
} }
@ -261,7 +261,7 @@ func assign(source *aliwaf.ModifyDomainRequest, target *aliwaf.DescribeDomainDet
} }
if target.Listen.HttpsPorts != nil { if target.Listen.HttpsPorts != nil {
source.Listen.HttpsPorts = sliceutil.Map(target.Listen.HttpsPorts, func(v *int64) *int32 { source.Listen.HttpsPorts = xslices.Map(target.Listen.HttpsPorts, func(v *int64) *int32 {
if v == nil { if v == nil {
return nil return nil
} }
@ -296,7 +296,7 @@ func assign(source *aliwaf.ModifyDomainRequest, target *aliwaf.DescribeDomainDet
} }
if target.Redirect.Backends != nil { if target.Redirect.Backends != nil {
source.Redirect.Backends = sliceutil.Map(target.Redirect.Backends, func(v *aliwaf.DescribeDomainDetailResponseBodyRedirectBackends) *string { source.Redirect.Backends = xslices.Map(target.Redirect.Backends, func(v *aliwaf.DescribeDomainDetailResponseBodyRedirectBackends) *string {
if v == nil { if v == nil {
return nil return nil
} }
@ -305,7 +305,7 @@ func assign(source *aliwaf.ModifyDomainRequest, target *aliwaf.DescribeDomainDet
} }
if target.Redirect.BackupBackends != nil { if target.Redirect.BackupBackends != nil {
source.Redirect.BackupBackends = sliceutil.Map(target.Redirect.BackupBackends, func(v *aliwaf.DescribeDomainDetailResponseBodyRedirectBackupBackends) *string { source.Redirect.BackupBackends = xslices.Map(target.Redirect.BackupBackends, func(v *aliwaf.DescribeDomainDetailResponseBodyRedirectBackupBackends) *string {
if v == nil { if v == nil {
return nil return nil
} }
@ -342,7 +342,7 @@ func assign(source *aliwaf.ModifyDomainRequest, target *aliwaf.DescribeDomainDet
} }
if target.Redirect.RequestHeaders != nil { if target.Redirect.RequestHeaders != nil {
source.Redirect.RequestHeaders = sliceutil.Map(target.Redirect.RequestHeaders, func(v *aliwaf.DescribeDomainDetailResponseBodyRedirectRequestHeaders) *aliwaf.ModifyDomainRequestRedirectRequestHeaders { source.Redirect.RequestHeaders = xslices.Map(target.Redirect.RequestHeaders, func(v *aliwaf.DescribeDomainDetailResponseBodyRedirectRequestHeaders) *aliwaf.ModifyDomainRequestRedirectRequestHeaders {
if v == nil { if v == nil {
return nil return nil
} }

16
internal/pkg/core/deployer/providers/apisix/apisix.go
View File

@ -10,8 +10,8 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
apisixsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/apisix" apisixsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/apisix"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -83,7 +83,7 @@ func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPEM stri
} }
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return err return err
} }
@ -92,11 +92,11 @@ func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPEM stri
// REF: https://apisix.apache.org/zh/docs/apisix/admin-api/#ssl // REF: https://apisix.apache.org/zh/docs/apisix/admin-api/#ssl
updateSSLReq := &apisixsdk.UpdateSSLRequest{ updateSSLReq := &apisixsdk.UpdateSSLRequest{
ID: d.config.CertificateId, ID: d.config.CertificateId,
Cert: typeutil.ToPtr(certPEM), Cert: xtypes.ToPtr(certPEM),
Key: typeutil.ToPtr(privkeyPEM), Key: xtypes.ToPtr(privkeyPEM),
SNIs: typeutil.ToPtr(certX509.DNSNames), SNIs: xtypes.ToPtr(certX509.DNSNames),
Type: typeutil.ToPtr("server"), Type: xtypes.ToPtr("server"),
Status: typeutil.ToPtr(int32(1)), Status: xtypes.ToPtr(int32(1)),
} }
updateSSLResp, err := d.sdkClient.UpdateSSL(updateSSLReq) updateSSLResp, err := d.sdkClient.UpdateSSL(updateSSLReq)
d.logger.Debug("sdk request 'apisix.UpdateSSL'", slog.Any("request", updateSSLReq), slog.Any("response", updateSSLResp)) d.logger.Debug("sdk request 'apisix.UpdateSSL'", slog.Any("request", updateSSLReq), slog.Any("response", updateSSLResp))

4
internal/pkg/core/deployer/providers/aws-acm/aws_acm.go
View File

@ -13,7 +13,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aws-acm" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/aws-acm"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -85,7 +85,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
} }
} else { } else {
// 提取服务器证书 // 提取服务器证书
serverCertPEM, intermediaCertPEM, err := certutil.ExtractCertificatesFromPEM(certPEM) serverCertPEM, intermediaCertPEM, err := xcert.ExtractCertificatesFromPEM(certPEM)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to extract certs: %w", err) return nil, fmt.Errorf("failed to extract certs: %w", err)
} }

8
internal/pkg/core/deployer/providers/azure-keyvault/azure_keyvault.go
View File

@ -17,7 +17,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/azure-keyvault" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/azure-keyvault"
azcommon "github.com/usual2970/certimate/internal/pkg/sdk3rd/azure/common" azcommon "github.com/usual2970/certimate/internal/pkg/sdk3rd/azure/common"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -86,13 +86,13 @@ func (d *DeployerProvider) WithLogger(logger *slog.Logger) deployer.Deployer {
func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) { func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// 转换证书格式 // 转换证书格式
certPFX, err := certutil.TransformCertificateFromPEMToPFX(certPEM, privkeyPEM, "") certPFX, err := xcert.TransformCertificateFromPEMToPFX(certPEM, privkeyPEM, "")
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to transform certificate from PEM to PFX: %w", err) return nil, fmt.Errorf("failed to transform certificate from PEM to PFX: %w", err)
} }
@ -118,7 +118,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
} else { } else {
oldCertX509, err := x509.ParseCertificate(getCertificateResp.CER) oldCertX509, err := x509.ParseCertificate(getCertificateResp.CER)
if err == nil { if err == nil {
if certutil.EqualCertificate(certX509, oldCertX509) { if xcert.EqualCertificate(certX509, oldCertX509) {
return &deployer.DeployResult{}, nil return &deployer.DeployResult{}, nil
} }
} }

4
internal/pkg/core/deployer/providers/baiducloud-appblb/baiducloud_appblb.go
View File

@ -14,7 +14,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/baiducloud-cert" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/baiducloud-cert"
sliceutil "github.com/usual2970/certimate/internal/pkg/utils/slice" xslices "github.com/usual2970/certimate/internal/pkg/utils/slices"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -286,7 +286,7 @@ func (d *DeployerProvider) updateHttpsListenerCertificate(ctx context.Context, c
ListenerPort: uint16(cloudHttpsListenerPort), ListenerPort: uint16(cloudHttpsListenerPort),
Scheduler: describeAppHTTPSListenersResp.ListenerList[0].Scheduler, Scheduler: describeAppHTTPSListenersResp.ListenerList[0].Scheduler,
CertIds: describeAppHTTPSListenersResp.ListenerList[0].CertIds, CertIds: describeAppHTTPSListenersResp.ListenerList[0].CertIds,
AdditionalCertDomains: sliceutil.Map(describeAppHTTPSListenersResp.ListenerList[0].AdditionalCertDomains, func(domain bceappblb.AdditionalCertDomainsModel) bceappblb.AdditionalCertDomainsModel { AdditionalCertDomains: xslices.Map(describeAppHTTPSListenersResp.ListenerList[0].AdditionalCertDomains, func(domain bceappblb.AdditionalCertDomainsModel) bceappblb.AdditionalCertDomainsModel {
if domain.Host == d.config.Domain { if domain.Host == d.config.Domain {
return bceappblb.AdditionalCertDomainsModel{ return bceappblb.AdditionalCertDomainsModel{
Host: domain.Host, Host: domain.Host,

4
internal/pkg/core/deployer/providers/baiducloud-blb/baiducloud_blb.go
View File

@ -14,7 +14,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/baiducloud-cert" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/baiducloud-cert"
sliceutil "github.com/usual2970/certimate/internal/pkg/utils/slice" xslices "github.com/usual2970/certimate/internal/pkg/utils/slices"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -284,7 +284,7 @@ func (d *DeployerProvider) updateHttpsListenerCertificate(ctx context.Context, c
ClientToken: generateClientToken(), ClientToken: generateClientToken(),
ListenerPort: uint16(cloudHttpsListenerPort), ListenerPort: uint16(cloudHttpsListenerPort),
CertIds: describeHTTPSListenersResp.ListenerList[0].CertIds, CertIds: describeHTTPSListenersResp.ListenerList[0].CertIds,
AdditionalCertDomains: sliceutil.Map(describeHTTPSListenersResp.ListenerList[0].AdditionalCertDomains, func(domain bceblb.AdditionalCertDomainsModel) bceblb.AdditionalCertDomainsModel { AdditionalCertDomains: xslices.Map(describeHTTPSListenersResp.ListenerList[0].AdditionalCertDomains, func(domain bceblb.AdditionalCertDomainsModel) bceblb.AdditionalCertDomainsModel {
if domain.Host == d.config.Domain { if domain.Host == d.config.Domain {
return bceblb.AdditionalCertDomainsModel{ return bceblb.AdditionalCertDomainsModel{
Host: domain.Host, Host: domain.Host,

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

@ -10,7 +10,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
btsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/btpanel" btsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/btpanel"
sliceutil "github.com/usual2970/certimate/internal/pkg/utils/slice" xslices "github.com/usual2970/certimate/internal/pkg/utils/slices"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -103,7 +103,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 设置站点证书 // 设置站点证书
sslSetBatchCertToSiteReq := &btsdk.SSLSetBatchCertToSiteRequest{ sslSetBatchCertToSiteReq := &btsdk.SSLSetBatchCertToSiteRequest{
BatchInfo: sliceutil.Map(d.config.SiteNames, func(siteName string) *btsdk.SSLSetBatchCertToSiteRequestBatchInfo { BatchInfo: xslices.Map(d.config.SiteNames, func(siteName string) *btsdk.SSLSetBatchCertToSiteRequestBatchInfo {
return &btsdk.SSLSetBatchCertToSiteRequestBatchInfo{ return &btsdk.SSLSetBatchCertToSiteRequestBatchInfo{
SiteName: siteName, SiteName: siteName,
SSLHash: sslCertSaveCertResp.SSLHash, SSLHash: sslCertSaveCertResp.SSLHash,

18
internal/pkg/core/deployer/providers/baotawaf-site/baotawaf_site.go
View File

@ -10,7 +10,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
btsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/btwaf" btsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/btwaf"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -82,9 +82,9 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
} }
getSiteListReq := &btsdk.GetSiteListRequest{ getSiteListReq := &btsdk.GetSiteListRequest{
SiteName: typeutil.ToPtr(d.config.SiteName), SiteName: xtypes.ToPtr(d.config.SiteName),
Page: typeutil.ToPtr(getSitListPage), Page: xtypes.ToPtr(getSitListPage),
PageSize: typeutil.ToPtr(getSitListPageSize), PageSize: xtypes.ToPtr(getSitListPageSize),
} }
getSiteListResp, err := d.sdkClient.GetSiteList(getSiteListReq) getSiteListResp, err := d.sdkClient.GetSiteList(getSiteListReq)
d.logger.Debug("sdk request 'bt.GetSiteList'", slog.Any("request", getSiteListReq), slog.Any("response", getSiteListResp)) d.logger.Debug("sdk request 'bt.GetSiteList'", slog.Any("request", getSiteListReq), slog.Any("response", getSiteListResp))
@ -114,13 +114,13 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 修改站点配置 // 修改站点配置
modifySiteReq := &btsdk.ModifySiteRequest{ modifySiteReq := &btsdk.ModifySiteRequest{
SiteId: siteId, SiteId: siteId,
Type: typeutil.ToPtr("openCert"), Type: xtypes.ToPtr("openCert"),
Server: &btsdk.SiteServerInfo{ Server: &btsdk.SiteServerInfo{
ListenSSLPorts: typeutil.ToPtr([]int32{d.config.SitePort}), ListenSSLPorts: xtypes.ToPtr([]int32{d.config.SitePort}),
SSL: &btsdk.SiteServerSSLInfo{ SSL: &btsdk.SiteServerSSLInfo{
IsSSL: typeutil.ToPtr(int32(1)), IsSSL: xtypes.ToPtr(int32(1)),
FullChain: typeutil.ToPtr(certPEM), FullChain: xtypes.ToPtr(certPEM),
PrivateKey: typeutil.ToPtr(privkeyPEM), PrivateKey: xtypes.ToPtr(privkeyPEM),
}, },
}, },
} }

12
internal/pkg/core/deployer/providers/ctcccloud-ao/ctcccloud_ao.go
View File

@ -10,7 +10,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ctcccloud-ao" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ctcccloud-ao"
ctyunao "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/ao" ctyunao "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/ao"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -82,7 +82,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 域名基础及加速配置查询 // 域名基础及加速配置查询
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=113&api=13412&data=174&isNormal=1&vid=167 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=113&api=13412&data=174&isNormal=1&vid=167
getDomainConfigReq := &ctyunao.GetDomainConfigRequest{ getDomainConfigReq := &ctyunao.GetDomainConfigRequest{
Domain: typeutil.ToPtr(d.config.Domain), Domain: xtypes.ToPtr(d.config.Domain),
} }
getDomainConfigResp, err := d.sdkClient.GetDomainConfig(getDomainConfigReq) getDomainConfigResp, err := d.sdkClient.GetDomainConfig(getDomainConfigReq)
d.logger.Debug("sdk request 'cdn.GetDomainConfig'", slog.Any("request", getDomainConfigReq), slog.Any("response", getDomainConfigResp)) d.logger.Debug("sdk request 'cdn.GetDomainConfig'", slog.Any("request", getDomainConfigReq), slog.Any("response", getDomainConfigResp))
@ -93,11 +93,11 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 域名基础及加速配置修改 // 域名基础及加速配置修改
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=113&api=13413&data=174&isNormal=1&vid=167 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=113&api=13413&data=174&isNormal=1&vid=167
modifyDomainConfigReq := &ctyunao.ModifyDomainConfigRequest{ modifyDomainConfigReq := &ctyunao.ModifyDomainConfigRequest{
Domain: typeutil.ToPtr(d.config.Domain), Domain: xtypes.ToPtr(d.config.Domain),
ProductCode: typeutil.ToPtr(getDomainConfigResp.ReturnObj.ProductCode), ProductCode: xtypes.ToPtr(getDomainConfigResp.ReturnObj.ProductCode),
Origin: getDomainConfigResp.ReturnObj.Origin, Origin: getDomainConfigResp.ReturnObj.Origin,
HttpsStatus: typeutil.ToPtr("on"), HttpsStatus: xtypes.ToPtr("on"),
CertName: typeutil.ToPtr(upres.CertName), CertName: xtypes.ToPtr(upres.CertName),
} }
modifyDomainConfigResp, err := d.sdkClient.ModifyDomainConfig(modifyDomainConfigReq) modifyDomainConfigResp, err := d.sdkClient.ModifyDomainConfig(modifyDomainConfigReq)
d.logger.Debug("sdk request 'cdn.ModifyDomainConfig'", slog.Any("request", modifyDomainConfigReq), slog.Any("response", modifyDomainConfigResp)) d.logger.Debug("sdk request 'cdn.ModifyDomainConfig'", slog.Any("request", modifyDomainConfigReq), slog.Any("response", modifyDomainConfigResp))

10
internal/pkg/core/deployer/providers/ctcccloud-cdn/ctcccloud_cdn.go
View File

@ -10,7 +10,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ctcccloud-cdn" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ctcccloud-cdn"
ctyuncdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/cdn" ctyuncdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/cdn"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -82,7 +82,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 查询域名配置信息 // 查询域名配置信息
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=108&api=11304&data=161&isNormal=1&vid=154 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=108&api=11304&data=161&isNormal=1&vid=154
queryDomainDetailReq := &ctyuncdn.QueryDomainDetailRequest{ queryDomainDetailReq := &ctyuncdn.QueryDomainDetailRequest{
Domain: typeutil.ToPtr(d.config.Domain), Domain: xtypes.ToPtr(d.config.Domain),
} }
queryDomainDetailResp, err := d.sdkClient.QueryDomainDetail(queryDomainDetailReq) queryDomainDetailResp, err := d.sdkClient.QueryDomainDetail(queryDomainDetailReq)
d.logger.Debug("sdk request 'cdn.QueryDomainDetail'", slog.Any("request", queryDomainDetailReq), slog.Any("response", queryDomainDetailResp)) d.logger.Debug("sdk request 'cdn.QueryDomainDetail'", slog.Any("request", queryDomainDetailReq), slog.Any("response", queryDomainDetailResp))
@ -93,9 +93,9 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 修改域名配置 // 修改域名配置
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=108&api=11308&data=161&isNormal=1&vid=154 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=108&api=11308&data=161&isNormal=1&vid=154
updateDomainReq := &ctyuncdn.UpdateDomainRequest{ updateDomainReq := &ctyuncdn.UpdateDomainRequest{
Domain: typeutil.ToPtr(d.config.Domain), Domain: xtypes.ToPtr(d.config.Domain),
HttpsStatus: typeutil.ToPtr("on"), HttpsStatus: xtypes.ToPtr("on"),
CertName: typeutil.ToPtr(upres.CertName), CertName: xtypes.ToPtr(upres.CertName),
} }
updateDomainResp, err := d.sdkClient.UpdateDomain(updateDomainReq) updateDomainResp, err := d.sdkClient.UpdateDomain(updateDomainReq)
d.logger.Debug("sdk request 'cdn.UpdateDomain'", slog.Any("request", updateDomainReq), slog.Any("response", updateDomainResp)) d.logger.Debug("sdk request 'cdn.UpdateDomain'", slog.Any("request", updateDomainReq), slog.Any("response", updateDomainResp))

12
internal/pkg/core/deployer/providers/ctcccloud-elb/ctcccloud_elb.go
View File

@ -11,7 +11,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ctcccloud-elb" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ctcccloud-elb"
ctyunelb "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/elb" ctyunelb "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/elb"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -120,8 +120,8 @@ func (d *DeployerProvider) deployToLoadbalancer(ctx context.Context, cloudCertId
} }
listListenersReq := &ctyunelb.ListListenersRequest{ listListenersReq := &ctyunelb.ListListenersRequest{
RegionID: typeutil.ToPtr(d.config.RegionId), RegionID: xtypes.ToPtr(d.config.RegionId),
LoadBalancerID: typeutil.ToPtr(d.config.LoadbalancerId), LoadBalancerID: xtypes.ToPtr(d.config.LoadbalancerId),
} }
listListenersResp, err := d.sdkClient.ListListeners(listListenersReq) listListenersResp, err := d.sdkClient.ListListeners(listListenersReq)
d.logger.Debug("sdk request 'elb.ListListeners'", slog.Any("request", listListenersReq), slog.Any("response", listListenersResp)) d.logger.Debug("sdk request 'elb.ListListeners'", slog.Any("request", listListenersReq), slog.Any("response", listListenersResp))
@ -181,9 +181,9 @@ func (d *DeployerProvider) updateListenerCertificate(ctx context.Context, cloudL
// 更新监听器 // 更新监听器
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=24&api=5652&data=88&isNormal=1&vid=82 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=24&api=5652&data=88&isNormal=1&vid=82
setLoadBalancerHTTPSListenerAttributeReq := &ctyunelb.UpdateListenerRequest{ setLoadBalancerHTTPSListenerAttributeReq := &ctyunelb.UpdateListenerRequest{
RegionID: typeutil.ToPtr(d.config.RegionId), RegionID: xtypes.ToPtr(d.config.RegionId),
ListenerID: typeutil.ToPtr(cloudListenerId), ListenerID: xtypes.ToPtr(cloudListenerId),
CertificateID: typeutil.ToPtr(cloudCertId), CertificateID: xtypes.ToPtr(cloudCertId),
} }
setLoadBalancerHTTPSListenerAttributeResp, err := d.sdkClient.UpdateListener(setLoadBalancerHTTPSListenerAttributeReq) setLoadBalancerHTTPSListenerAttributeResp, err := d.sdkClient.UpdateListener(setLoadBalancerHTTPSListenerAttributeReq)
d.logger.Debug("sdk request 'elb.UpdateListener'", slog.Any("request", setLoadBalancerHTTPSListenerAttributeReq), slog.Any("response", setLoadBalancerHTTPSListenerAttributeResp)) d.logger.Debug("sdk request 'elb.UpdateListener'", slog.Any("request", setLoadBalancerHTTPSListenerAttributeReq), slog.Any("response", setLoadBalancerHTTPSListenerAttributeResp))

10
internal/pkg/core/deployer/providers/ctcccloud-icdn/ctcccloud_icdn.go
View File

@ -10,7 +10,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ctcccloud-icdn" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ctcccloud-icdn"
ctyunicdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/icdn" ctyunicdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/icdn"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -82,7 +82,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 查询域名配置信息 // 查询域名配置信息
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=112&api=10849&data=173&isNormal=1&vid=166 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=112&api=10849&data=173&isNormal=1&vid=166
queryDomainDetailReq := &ctyunicdn.QueryDomainDetailRequest{ queryDomainDetailReq := &ctyunicdn.QueryDomainDetailRequest{
Domain: typeutil.ToPtr(d.config.Domain), Domain: xtypes.ToPtr(d.config.Domain),
} }
queryDomainDetailResp, err := d.sdkClient.QueryDomainDetail(queryDomainDetailReq) queryDomainDetailResp, err := d.sdkClient.QueryDomainDetail(queryDomainDetailReq)
d.logger.Debug("sdk request 'icdn.QueryDomainDetail'", slog.Any("request", queryDomainDetailReq), slog.Any("response", queryDomainDetailResp)) d.logger.Debug("sdk request 'icdn.QueryDomainDetail'", slog.Any("request", queryDomainDetailReq), slog.Any("response", queryDomainDetailResp))
@ -93,9 +93,9 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 修改域名配置 // 修改域名配置
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=112&api=10853&data=173&isNormal=1&vid=166 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=112&api=10853&data=173&isNormal=1&vid=166
updateDomainReq := &ctyunicdn.UpdateDomainRequest{ updateDomainReq := &ctyunicdn.UpdateDomainRequest{
Domain: typeutil.ToPtr(d.config.Domain), Domain: xtypes.ToPtr(d.config.Domain),
HttpsStatus: typeutil.ToPtr("on"), HttpsStatus: xtypes.ToPtr("on"),
CertName: typeutil.ToPtr(upres.CertName), CertName: xtypes.ToPtr(upres.CertName),
} }
updateDomainResp, err := d.sdkClient.UpdateDomain(updateDomainReq) updateDomainResp, err := d.sdkClient.UpdateDomain(updateDomainReq)
d.logger.Debug("sdk request 'icdn.UpdateDomain'", slog.Any("request", updateDomainReq), slog.Any("response", updateDomainResp)) d.logger.Debug("sdk request 'icdn.UpdateDomain'", slog.Any("request", updateDomainReq), slog.Any("response", updateDomainResp))

14
internal/pkg/core/deployer/providers/ctcccloud-lvdn/ctcccloud_lvdn.go
View File

@ -10,7 +10,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ctcccloud-lvdn" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/ctcccloud-lvdn"
ctyunlvdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/lvdn" ctyunlvdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/lvdn"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -82,8 +82,8 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 查询域名配置信息 // 查询域名配置信息
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=125&api=11473&data=183&isNormal=1&vid=261 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=125&api=11473&data=183&isNormal=1&vid=261
queryDomainDetailReq := &ctyunlvdn.QueryDomainDetailRequest{ queryDomainDetailReq := &ctyunlvdn.QueryDomainDetailRequest{
Domain: typeutil.ToPtr(d.config.Domain), Domain: xtypes.ToPtr(d.config.Domain),
ProductCode: typeutil.ToPtr("005"), ProductCode: xtypes.ToPtr("005"),
} }
queryDomainDetailResp, err := d.sdkClient.QueryDomainDetail(queryDomainDetailReq) queryDomainDetailResp, err := d.sdkClient.QueryDomainDetail(queryDomainDetailReq)
d.logger.Debug("sdk request 'lvdn.QueryDomainDetail'", slog.Any("request", queryDomainDetailReq), slog.Any("response", queryDomainDetailResp)) d.logger.Debug("sdk request 'lvdn.QueryDomainDetail'", slog.Any("request", queryDomainDetailReq), slog.Any("response", queryDomainDetailResp))
@ -94,10 +94,10 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 修改域名配置 // 修改域名配置
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=108&api=11308&data=161&isNormal=1&vid=154 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=108&api=11308&data=161&isNormal=1&vid=154
updateDomainReq := &ctyunlvdn.UpdateDomainRequest{ updateDomainReq := &ctyunlvdn.UpdateDomainRequest{
Domain: typeutil.ToPtr(d.config.Domain), Domain: xtypes.ToPtr(d.config.Domain),
ProductCode: typeutil.ToPtr("005"), ProductCode: xtypes.ToPtr("005"),
HttpsSwitch: typeutil.ToPtr(int32(1)), HttpsSwitch: xtypes.ToPtr(int32(1)),
CertName: typeutil.ToPtr(upres.CertName), CertName: xtypes.ToPtr(upres.CertName),
} }
updateDomainResp, err := d.sdkClient.UpdateDomain(updateDomainReq) updateDomainResp, err := d.sdkClient.UpdateDomain(updateDomainReq)
d.logger.Debug("sdk request 'lvdn.UpdateDomain'", slog.Any("request", updateDomainReq), slog.Any("response", updateDomainResp)) d.logger.Debug("sdk request 'lvdn.UpdateDomain'", slog.Any("request", updateDomainReq), slog.Any("response", updateDomainResp))

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

@ -9,7 +9,7 @@ import (
edgiodtos "github.com/Edgio/edgio-api/applications/v7/dtos" edgiodtos "github.com/Edgio/edgio-api/applications/v7/dtos"
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -57,7 +57,7 @@ func (d *DeployerProvider) WithLogger(logger *slog.Logger) deployer.Deployer {
func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) { func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
// 提取服务器证书和中间证书 // 提取服务器证书和中间证书
serverCertPEM, intermediaCertPEM, err := certutil.ExtractCertificatesFromPEM(certPEM) serverCertPEM, intermediaCertPEM, err := xcert.ExtractCertificatesFromPEM(certPEM)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to extract certs: %w", err) return nil, fmt.Errorf("failed to extract certs: %w", err)
} }

4
internal/pkg/core/deployer/providers/flexcdn/flexcdn.go
View File

@ -12,7 +12,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
flexcdnsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/flexcdn" flexcdnsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/flexcdn"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -89,7 +89,7 @@ func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPEM stri
} }
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return err return err
} }

4
internal/pkg/core/deployer/providers/goedge/goedge.go
View File

@ -12,7 +12,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
goedgesdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/goedge" goedgesdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/goedge"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -89,7 +89,7 @@ func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPEM stri
} }
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return err return err
} }

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

@ -13,7 +13,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/huaweicloud-scm" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/huaweicloud-scm"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -91,7 +91,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 查询加速域名配置 // 查询加速域名配置
// REF: https://support.huaweicloud.com/api-cdn/ShowDomainFullConfig.html // REF: https://support.huaweicloud.com/api-cdn/ShowDomainFullConfig.html
showDomainFullConfigReq := &hccdnmodel.ShowDomainFullConfigRequest{ showDomainFullConfigReq := &hccdnmodel.ShowDomainFullConfigRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(d.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(d.config.EnterpriseProjectId),
DomainName: d.config.Domain, DomainName: d.config.Domain,
} }
showDomainFullConfigResp, err := d.sdkClient.ShowDomainFullConfig(showDomainFullConfigReq) showDomainFullConfigResp, err := d.sdkClient.ShowDomainFullConfig(showDomainFullConfigReq)
@ -106,12 +106,12 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
updateDomainMultiCertificatesReqBodyContent := &hccdnmodel.UpdateDomainMultiCertificatesRequestBodyContent{} updateDomainMultiCertificatesReqBodyContent := &hccdnmodel.UpdateDomainMultiCertificatesRequestBodyContent{}
updateDomainMultiCertificatesReqBodyContent.DomainName = d.config.Domain updateDomainMultiCertificatesReqBodyContent.DomainName = d.config.Domain
updateDomainMultiCertificatesReqBodyContent.HttpsSwitch = 1 updateDomainMultiCertificatesReqBodyContent.HttpsSwitch = 1
updateDomainMultiCertificatesReqBodyContent.CertificateType = typeutil.ToPtr(int32(2)) updateDomainMultiCertificatesReqBodyContent.CertificateType = xtypes.ToPtr(int32(2))
updateDomainMultiCertificatesReqBodyContent.ScmCertificateId = typeutil.ToPtr(upres.CertId) updateDomainMultiCertificatesReqBodyContent.ScmCertificateId = xtypes.ToPtr(upres.CertId)
updateDomainMultiCertificatesReqBodyContent.CertName = typeutil.ToPtr(upres.CertName) updateDomainMultiCertificatesReqBodyContent.CertName = xtypes.ToPtr(upres.CertName)
updateDomainMultiCertificatesReqBodyContent = assign(updateDomainMultiCertificatesReqBodyContent, showDomainFullConfigResp.Configs) updateDomainMultiCertificatesReqBodyContent = assign(updateDomainMultiCertificatesReqBodyContent, showDomainFullConfigResp.Configs)
updateDomainMultiCertificatesReq := &hccdnmodel.UpdateDomainMultiCertificatesRequest{ updateDomainMultiCertificatesReq := &hccdnmodel.UpdateDomainMultiCertificatesRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(d.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(d.config.EnterpriseProjectId),
Body: &hccdnmodel.UpdateDomainMultiCertificatesRequestBody{ Body: &hccdnmodel.UpdateDomainMultiCertificatesRequestBody{
Https: updateDomainMultiCertificatesReqBodyContent, Https: updateDomainMultiCertificatesReqBodyContent,
}, },
@ -164,11 +164,11 @@ func assign(source *hccdnmodel.UpdateDomainMultiCertificatesRequestBodyContent,
} }
if *target.OriginProtocol == "follow" { if *target.OriginProtocol == "follow" {
source.AccessOriginWay = typeutil.ToPtr(int32(1)) source.AccessOriginWay = xtypes.ToPtr(int32(1))
} else if *target.OriginProtocol == "http" { } else if *target.OriginProtocol == "http" {
source.AccessOriginWay = typeutil.ToPtr(int32(2)) source.AccessOriginWay = xtypes.ToPtr(int32(2))
} else if *target.OriginProtocol == "https" { } else if *target.OriginProtocol == "https" {
source.AccessOriginWay = typeutil.ToPtr(int32(3)) source.AccessOriginWay = xtypes.ToPtr(int32(3))
} }
if target.ForceRedirect != nil { if target.ForceRedirect != nil {
@ -186,7 +186,7 @@ func assign(source *hccdnmodel.UpdateDomainMultiCertificatesRequestBodyContent,
if target.Https != nil { if target.Https != nil {
if *target.Https.Http2Status == "on" { if *target.Https.Http2Status == "on" {
source.Http2 = typeutil.ToPtr(int32(1)) source.Http2 = xtypes.ToPtr(int32(1))
} }
} }

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

@ -19,7 +19,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/huaweicloud-elb" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/huaweicloud-elb"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -127,8 +127,8 @@ func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPEM stri
CertificateId: d.config.CertificateId, CertificateId: d.config.CertificateId,
Body: &hcelbmodel.UpdateCertificateRequestBody{ Body: &hcelbmodel.UpdateCertificateRequestBody{
Certificate: &hcelbmodel.UpdateCertificateOption{ Certificate: &hcelbmodel.UpdateCertificateOption{
Certificate: typeutil.ToPtr(certPEM), Certificate: xtypes.ToPtr(certPEM),
PrivateKey: typeutil.ToPtr(privkeyPEM), PrivateKey: xtypes.ToPtr(privkeyPEM),
}, },
}, },
} }
@ -170,13 +170,13 @@ func (d *DeployerProvider) deployToLoadbalancer(ctx context.Context, certPEM str
} }
listListenersReq := &hcelbmodel.ListListenersRequest{ listListenersReq := &hcelbmodel.ListListenersRequest{
Limit: typeutil.ToPtr(listListenersLimit), Limit: xtypes.ToPtr(listListenersLimit),
Marker: listListenersMarker, Marker: listListenersMarker,
Protocol: &[]string{"HTTPS", "TERMINATED_HTTPS"}, Protocol: &[]string{"HTTPS", "TERMINATED_HTTPS"},
LoadbalancerId: &[]string{showLoadBalancerResp.Loadbalancer.Id}, LoadbalancerId: &[]string{showLoadBalancerResp.Loadbalancer.Id},
} }
if d.config.EnterpriseProjectId != "" { if d.config.EnterpriseProjectId != "" {
listListenersReq.EnterpriseProjectId = typeutil.ToPtr([]string{d.config.EnterpriseProjectId}) listListenersReq.EnterpriseProjectId = xtypes.ToPtr([]string{d.config.EnterpriseProjectId})
} }
listListenersResp, err := d.sdkClient.ListListeners(listListenersReq) listListenersResp, err := d.sdkClient.ListListeners(listListenersReq)
d.logger.Debug("sdk request 'elb.ListListeners'", slog.Any("request", listListenersReq), slog.Any("response", listListenersResp)) d.logger.Debug("sdk request 'elb.ListListeners'", slog.Any("request", listListenersReq), slog.Any("response", listListenersResp))
@ -270,7 +270,7 @@ func (d *DeployerProvider) modifyListenerCertificate(ctx context.Context, cloudL
ListenerId: cloudListenerId, ListenerId: cloudListenerId,
Body: &hcelbmodel.UpdateListenerRequestBody{ Body: &hcelbmodel.UpdateListenerRequestBody{
Listener: &hcelbmodel.UpdateListenerOption{ Listener: &hcelbmodel.UpdateListenerOption{
DefaultTlsContainerRef: typeutil.ToPtr(cloudCertId), DefaultTlsContainerRef: xtypes.ToPtr(cloudCertId),
}, },
}, },
} }
@ -319,7 +319,7 @@ func (d *DeployerProvider) modifyListenerCertificate(ctx context.Context, cloudL
} }
if showListenerResp.Listener.SniMatchAlgo != "" { if showListenerResp.Listener.SniMatchAlgo != "" {
updateListenerReq.Body.Listener.SniMatchAlgo = typeutil.ToPtr(showListenerResp.Listener.SniMatchAlgo) updateListenerReq.Body.Listener.SniMatchAlgo = xtypes.ToPtr(showListenerResp.Listener.SniMatchAlgo)
} }
} }
updateListenerResp, err := d.sdkClient.UpdateListener(updateListenerReq) updateListenerResp, err := d.sdkClient.UpdateListener(updateListenerReq)

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

@ -19,7 +19,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/huaweicloud-waf" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/huaweicloud-waf"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -129,7 +129,7 @@ func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPEM stri
// 查询证书 // 查询证书
// REF: https://support.huaweicloud.com/api-waf/ShowCertificate.html // REF: https://support.huaweicloud.com/api-waf/ShowCertificate.html
showCertificateReq := &hcwafmodel.ShowCertificateRequest{ showCertificateReq := &hcwafmodel.ShowCertificateRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(d.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(d.config.EnterpriseProjectId),
CertificateId: d.config.CertificateId, CertificateId: d.config.CertificateId,
} }
showCertificateResp, err := d.sdkClient.ShowCertificate(showCertificateReq) showCertificateResp, err := d.sdkClient.ShowCertificate(showCertificateReq)
@ -141,12 +141,12 @@ func (d *DeployerProvider) deployToCertificate(ctx context.Context, certPEM stri
// 更新证书 // 更新证书
// REF: https://support.huaweicloud.com/api-waf/UpdateCertificate.html // REF: https://support.huaweicloud.com/api-waf/UpdateCertificate.html
updateCertificateReq := &hcwafmodel.UpdateCertificateRequest{ updateCertificateReq := &hcwafmodel.UpdateCertificateRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(d.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(d.config.EnterpriseProjectId),
CertificateId: d.config.CertificateId, CertificateId: d.config.CertificateId,
Body: &hcwafmodel.UpdateCertificateRequestBody{ Body: &hcwafmodel.UpdateCertificateRequestBody{
Name: *showCertificateResp.Name, Name: *showCertificateResp.Name,
Content: typeutil.ToPtr(certPEM), Content: xtypes.ToPtr(certPEM),
Key: typeutil.ToPtr(privkeyPEM), Key: xtypes.ToPtr(privkeyPEM),
}, },
} }
updateCertificateResp, err := d.sdkClient.UpdateCertificate(updateCertificateReq) updateCertificateResp, err := d.sdkClient.UpdateCertificate(updateCertificateReq)
@ -184,10 +184,10 @@ func (d *DeployerProvider) deployToCloudServer(ctx context.Context, certPEM stri
} }
listHostReq := &hcwafmodel.ListHostRequest{ listHostReq := &hcwafmodel.ListHostRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(d.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(d.config.EnterpriseProjectId),
Hostname: typeutil.ToPtr(strings.TrimPrefix(d.config.Domain, "*")), Hostname: xtypes.ToPtr(strings.TrimPrefix(d.config.Domain, "*")),
Page: typeutil.ToPtr(listHostPage), Page: xtypes.ToPtr(listHostPage),
Pagesize: typeutil.ToPtr(listHostPageSize), Pagesize: xtypes.ToPtr(listHostPageSize),
} }
listHostResp, err := d.sdkClient.ListHost(listHostReq) listHostResp, err := d.sdkClient.ListHost(listHostReq)
d.logger.Debug("sdk request 'waf.ListHost'", slog.Any("request", listHostReq), slog.Any("response", listHostResp)) d.logger.Debug("sdk request 'waf.ListHost'", slog.Any("request", listHostReq), slog.Any("response", listHostResp))
@ -217,11 +217,11 @@ func (d *DeployerProvider) deployToCloudServer(ctx context.Context, certPEM stri
// 更新云模式防护域名的配置 // 更新云模式防护域名的配置
// REF: https://support.huaweicloud.com/api-waf/UpdateHost.html // REF: https://support.huaweicloud.com/api-waf/UpdateHost.html
updateHostReq := &hcwafmodel.UpdateHostRequest{ updateHostReq := &hcwafmodel.UpdateHostRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(d.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(d.config.EnterpriseProjectId),
InstanceId: hostId, InstanceId: hostId,
Body: &hcwafmodel.UpdateHostRequestBody{ Body: &hcwafmodel.UpdateHostRequestBody{
Certificateid: typeutil.ToPtr(upres.CertId), Certificateid: xtypes.ToPtr(upres.CertId),
Certificatename: typeutil.ToPtr(upres.CertName), Certificatename: xtypes.ToPtr(upres.CertName),
}, },
} }
updateHostResp, err := d.sdkClient.UpdateHost(updateHostReq) updateHostResp, err := d.sdkClient.UpdateHost(updateHostReq)
@ -259,10 +259,10 @@ func (d *DeployerProvider) deployToPremiumHost(ctx context.Context, certPEM stri
} }
listPremiumHostReq := &hcwafmodel.ListPremiumHostRequest{ listPremiumHostReq := &hcwafmodel.ListPremiumHostRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(d.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(d.config.EnterpriseProjectId),
Hostname: typeutil.ToPtr(strings.TrimPrefix(d.config.Domain, "*")), Hostname: xtypes.ToPtr(strings.TrimPrefix(d.config.Domain, "*")),
Page: typeutil.ToPtr(fmt.Sprintf("%d", listPremiumHostPage)), Page: xtypes.ToPtr(fmt.Sprintf("%d", listPremiumHostPage)),
Pagesize: typeutil.ToPtr(fmt.Sprintf("%d", listPremiumHostPageSize)), Pagesize: xtypes.ToPtr(fmt.Sprintf("%d", listPremiumHostPageSize)),
} }
listPremiumHostResp, err := d.sdkClient.ListPremiumHost(listPremiumHostReq) listPremiumHostResp, err := d.sdkClient.ListPremiumHost(listPremiumHostReq)
d.logger.Debug("sdk request 'waf.ListPremiumHost'", slog.Any("request", listPremiumHostReq), slog.Any("response", listPremiumHostResp)) d.logger.Debug("sdk request 'waf.ListPremiumHost'", slog.Any("request", listPremiumHostReq), slog.Any("response", listPremiumHostResp))
@ -292,11 +292,11 @@ func (d *DeployerProvider) deployToPremiumHost(ctx context.Context, certPEM stri
// 修改独享模式域名配置 // 修改独享模式域名配置
// REF: https://support.huaweicloud.com/api-waf/UpdatePremiumHost.html // REF: https://support.huaweicloud.com/api-waf/UpdatePremiumHost.html
updatePremiumHostReq := &hcwafmodel.UpdatePremiumHostRequest{ updatePremiumHostReq := &hcwafmodel.UpdatePremiumHostRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(d.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(d.config.EnterpriseProjectId),
HostId: hostId, HostId: hostId,
Body: &hcwafmodel.UpdatePremiumHostRequestBody{ Body: &hcwafmodel.UpdatePremiumHostRequestBody{
Certificateid: typeutil.ToPtr(upres.CertId), Certificateid: xtypes.ToPtr(upres.CertId),
Certificatename: typeutil.ToPtr(upres.CertName), Certificatename: xtypes.ToPtr(upres.CertName),
}, },
} }
updatePremiumHostResp, err := d.sdkClient.UpdatePremiumHost(updatePremiumHostReq) updatePremiumHostResp, err := d.sdkClient.UpdatePremiumHost(updatePremiumHostReq)

6
internal/pkg/core/deployer/providers/jdcloud-alb/jdcloud_alb.go
View File

@ -16,7 +16,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/jdcloud-ssl" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/jdcloud-ssl"
sliceutil "github.com/usual2970/certimate/internal/pkg/utils/slice" xslices "github.com/usual2970/certimate/internal/pkg/utils/slices"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -226,7 +226,7 @@ func (d *DeployerProvider) updateListenerCertificate(ctx context.Context, cloudL
} else { } else {
// 指定 SNI，需部署到扩展证书 // 指定 SNI，需部署到扩展证书
extCertSpecs := sliceutil.Filter(describeListenerResp.Result.Listener.ExtensionCertificateSpecs, func(extCertSpec jdlbmodel.ExtensionCertificateSpec) bool { extCertSpecs := xslices.Filter(describeListenerResp.Result.Listener.ExtensionCertificateSpecs, func(extCertSpec jdlbmodel.ExtensionCertificateSpec) bool {
return extCertSpec.Domain == d.config.Domain return extCertSpec.Domain == d.config.Domain
}) })
if len(extCertSpecs) == 0 { if len(extCertSpecs) == 0 {
@ -238,7 +238,7 @@ func (d *DeployerProvider) updateListenerCertificate(ctx context.Context, cloudL
updateListenerCertificatesReq := jdlbapi.NewUpdateListenerCertificatesRequest( updateListenerCertificatesReq := jdlbapi.NewUpdateListenerCertificatesRequest(
d.config.RegionId, d.config.RegionId,
cloudListenerId, cloudListenerId,
sliceutil.Map(extCertSpecs, func(extCertSpec jdlbmodel.ExtensionCertificateSpec) jdlbmodel.ExtCertificateUpdateSpec { xslices.Map(extCertSpecs, func(extCertSpec jdlbmodel.ExtensionCertificateSpec) jdlbmodel.ExtCertificateUpdateSpec {
return jdlbmodel.ExtCertificateUpdateSpec{ return jdlbmodel.ExtCertificateUpdateSpec{
CertificateBindId: extCertSpec.CertificateBindId, CertificateBindId: extCertSpec.CertificateBindId,
CertificateId: &cloudCertId, CertificateId: &cloudCertId,

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

@ -14,7 +14,7 @@ import (
"k8s.io/client-go/tools/clientcmd" "k8s.io/client-go/tools/clientcmd"
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -76,7 +76,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
return nil, errors.New("config `secretDataKeyForKey` is required") return nil, errors.New("config `secretDataKeyForKey` is required")
} }
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }

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

@ -9,8 +9,8 @@ import (
"runtime" "runtime"
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
fileutil "github.com/usual2970/certimate/internal/pkg/utils/file" xfile "github.com/usual2970/certimate/internal/pkg/utils/file"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -76,7 +76,7 @@ func (d *DeployerProvider) WithLogger(logger *slog.Logger) deployer.Deployer {
func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) { func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
// 提取服务器证书和中间证书 // 提取服务器证书和中间证书
serverCertPEM, intermediaCertPEM, err := certutil.ExtractCertificatesFromPEM(certPEM) serverCertPEM, intermediaCertPEM, err := xcert.ExtractCertificatesFromPEM(certPEM)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to extract certs: %w", err) return nil, fmt.Errorf("failed to extract certs: %w", err)
} }
@ -93,50 +93,50 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 写入证书和私钥文件 // 写入证书和私钥文件
switch d.config.OutputFormat { switch d.config.OutputFormat {
case OUTPUT_FORMAT_PEM: case OUTPUT_FORMAT_PEM:
if err := fileutil.WriteString(d.config.OutputCertPath, certPEM); err != nil { if err := xfile.WriteString(d.config.OutputCertPath, certPEM); err != nil {
return nil, fmt.Errorf("failed to save certificate file: %w", err) return nil, fmt.Errorf("failed to save certificate file: %w", err)
} }
d.logger.Info("ssl certificate file saved", slog.String("path", d.config.OutputCertPath)) d.logger.Info("ssl certificate file saved", slog.String("path", d.config.OutputCertPath))
if d.config.OutputServerCertPath != "" { if d.config.OutputServerCertPath != "" {
if err := fileutil.WriteString(d.config.OutputServerCertPath, serverCertPEM); err != nil { if err := xfile.WriteString(d.config.OutputServerCertPath, serverCertPEM); err != nil {
return nil, fmt.Errorf("failed to save server certificate file: %w", err) return nil, fmt.Errorf("failed to save server certificate file: %w", err)
} }
d.logger.Info("ssl server certificate file saved", slog.String("path", d.config.OutputServerCertPath)) d.logger.Info("ssl server certificate file saved", slog.String("path", d.config.OutputServerCertPath))
} }
if d.config.OutputIntermediaCertPath != "" { if d.config.OutputIntermediaCertPath != "" {
if err := fileutil.WriteString(d.config.OutputIntermediaCertPath, intermediaCertPEM); err != nil { if err := xfile.WriteString(d.config.OutputIntermediaCertPath, intermediaCertPEM); err != nil {
return nil, fmt.Errorf("failed to save intermedia certificate file: %w", err) return nil, fmt.Errorf("failed to save intermedia certificate file: %w", err)
} }
d.logger.Info("ssl intermedia certificate file saved", slog.String("path", d.config.OutputIntermediaCertPath)) d.logger.Info("ssl intermedia certificate file saved", slog.String("path", d.config.OutputIntermediaCertPath))
} }
if err := fileutil.WriteString(d.config.OutputKeyPath, privkeyPEM); err != nil { if err := xfile.WriteString(d.config.OutputKeyPath, privkeyPEM); err != nil {
return nil, fmt.Errorf("failed to save private key file: %w", err) return nil, fmt.Errorf("failed to save private key file: %w", err)
} }
d.logger.Info("ssl private key file saved", slog.String("path", d.config.OutputKeyPath)) d.logger.Info("ssl private key file saved", slog.String("path", d.config.OutputKeyPath))
case OUTPUT_FORMAT_PFX: case OUTPUT_FORMAT_PFX:
pfxData, err := certutil.TransformCertificateFromPEMToPFX(certPEM, privkeyPEM, d.config.PfxPassword) pfxData, err := xcert.TransformCertificateFromPEMToPFX(certPEM, privkeyPEM, d.config.PfxPassword)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to transform certificate to PFX: %w", err) return nil, fmt.Errorf("failed to transform certificate to PFX: %w", err)
} }
d.logger.Info("ssl certificate transformed to pfx") d.logger.Info("ssl certificate transformed to pfx")
if err := fileutil.Write(d.config.OutputCertPath, pfxData); err != nil { if err := xfile.Write(d.config.OutputCertPath, pfxData); err != nil {
return nil, fmt.Errorf("failed to save certificate file: %w", err) return nil, fmt.Errorf("failed to save certificate file: %w", err)
} }
d.logger.Info("ssl certificate file saved", slog.String("path", d.config.OutputCertPath)) d.logger.Info("ssl certificate file saved", slog.String("path", d.config.OutputCertPath))
case OUTPUT_FORMAT_JKS: case OUTPUT_FORMAT_JKS:
jksData, err := certutil.TransformCertificateFromPEMToJKS(certPEM, privkeyPEM, d.config.JksAlias, d.config.JksKeypass, d.config.JksStorepass) jksData, err := xcert.TransformCertificateFromPEMToJKS(certPEM, privkeyPEM, d.config.JksAlias, d.config.JksKeypass, d.config.JksStorepass)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to transform certificate to JKS: %w", err) return nil, fmt.Errorf("failed to transform certificate to JKS: %w", err)
} }
d.logger.Info("ssl certificate transformed to jks") d.logger.Info("ssl certificate transformed to jks")
if err := fileutil.Write(d.config.OutputCertPath, jksData); err != nil { if err := xfile.Write(d.config.OutputCertPath, jksData); err != nil {
return nil, fmt.Errorf("failed to save certificate file: %w", err) return nil, fmt.Errorf("failed to save certificate file: %w", err)
} }
d.logger.Info("ssl certificate file saved", slog.String("path", d.config.OutputCertPath)) d.logger.Info("ssl certificate file saved", slog.String("path", d.config.OutputCertPath))

4
internal/pkg/core/deployer/providers/netlify-site/netlify_site.go
View File

@ -8,7 +8,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
netlifysdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/netlify" netlifysdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/netlify"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -58,7 +58,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
} }
// 提取服务器证书和中间证书 // 提取服务器证书和中间证书
serverCertPEM, intermediaCertPEM, err := certutil.ExtractCertificatesFromPEM(certPEM) serverCertPEM, intermediaCertPEM, err := xcert.ExtractCertificatesFromPEM(certPEM)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to extract certs: %w", err) return nil, fmt.Errorf("failed to extract certs: %w", err)
} }

6
internal/pkg/core/deployer/providers/proxmoxve/proxmoxve.go
View File

@ -13,7 +13,7 @@ import (
"github.com/luthermonson/go-proxmox" "github.com/luthermonson/go-proxmox"
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
httputil "github.com/usual2970/certimate/internal/pkg/utils/http" xhttp "github.com/usual2970/certimate/internal/pkg/utils/http"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -102,11 +102,11 @@ func createSdkClient(serverUrl, apiToken, apiTokenSecret string, skipTlsVerify b
} }
httpClient := &http.Client{ httpClient := &http.Client{
Transport: httputil.NewDefaultTransport(), Transport: xhttp.NewDefaultTransport(),
Timeout: http.DefaultClient.Timeout, Timeout: http.DefaultClient.Timeout,
} }
if skipTlsVerify { if skipTlsVerify {
transport := httputil.NewDefaultTransport() transport := xhttp.NewDefaultTransport()
if transport.TLSClientConfig == nil { if transport.TLSClientConfig == nil {
transport.TLSClientConfig = &tls.Config{} transport.TLSClientConfig = &tls.Config{}
} }

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

@ -16,7 +16,7 @@ import (
"golang.org/x/crypto/ssh" "golang.org/x/crypto/ssh"
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type JumpServerConfig struct { type JumpServerConfig struct {
@ -124,7 +124,7 @@ func (d *DeployerProvider) WithLogger(logger *slog.Logger) deployer.Deployer {
func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) { func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
// 提取服务器证书和中间证书 // 提取服务器证书和中间证书
serverCertPEM, intermediaCertPEM, err := certutil.ExtractCertificatesFromPEM(certPEM) serverCertPEM, intermediaCertPEM, err := xcert.ExtractCertificatesFromPEM(certPEM)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to extract certs: %w", err) return nil, fmt.Errorf("failed to extract certs: %w", err)
} }
@ -237,7 +237,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
d.logger.Info("ssl private key file uploaded", slog.String("path", d.config.OutputKeyPath)) d.logger.Info("ssl private key file uploaded", slog.String("path", d.config.OutputKeyPath))
case OUTPUT_FORMAT_PFX: case OUTPUT_FORMAT_PFX:
pfxData, err := certutil.TransformCertificateFromPEMToPFX(certPEM, privkeyPEM, d.config.PfxPassword) pfxData, err := xcert.TransformCertificateFromPEMToPFX(certPEM, privkeyPEM, d.config.PfxPassword)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to transform certificate to PFX: %w", err) return nil, fmt.Errorf("failed to transform certificate to PFX: %w", err)
} }
@ -249,7 +249,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
d.logger.Info("ssl certificate file uploaded", slog.String("path", d.config.OutputCertPath)) d.logger.Info("ssl certificate file uploaded", slog.String("path", d.config.OutputCertPath))
case OUTPUT_FORMAT_JKS: case OUTPUT_FORMAT_JKS:
jksData, err := certutil.TransformCertificateFromPEMToJKS(certPEM, privkeyPEM, d.config.JksAlias, d.config.JksKeypass, d.config.JksStorepass) jksData, err := xcert.TransformCertificateFromPEMToJKS(certPEM, privkeyPEM, d.config.JksAlias, d.config.JksKeypass, d.config.JksStorepass)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to transform certificate to JKS: %w", err) return nil, fmt.Errorf("failed to transform certificate to JKS: %w", err)
} }

4
internal/pkg/core/deployer/providers/tencentcloud-gaap/tencentcloud_gaap.go
View File

@ -13,7 +13,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/tencentcloud-ssl" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/tencentcloud-ssl"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -130,7 +130,7 @@ func (d *DeployerProvider) modifyHttpsListenerCertificate(ctx context.Context, c
// 修改 HTTPS 监听器配置 // 修改 HTTPS 监听器配置
// REF: https://cloud.tencent.com/document/product/608/36996 // REF: https://cloud.tencent.com/document/product/608/36996
modifyHTTPSListenerAttributeReq := tcgaap.NewModifyHTTPSListenerAttributeRequest() modifyHTTPSListenerAttributeReq := tcgaap.NewModifyHTTPSListenerAttributeRequest()
modifyHTTPSListenerAttributeReq.ProxyId = typeutil.ToPtrOrZeroNil(d.config.ProxyId) modifyHTTPSListenerAttributeReq.ProxyId = xtypes.ToPtrOrZeroNil(d.config.ProxyId)
modifyHTTPSListenerAttributeReq.ListenerId = common.StringPtr(cloudListenerId) modifyHTTPSListenerAttributeReq.ListenerId = common.StringPtr(cloudListenerId)
modifyHTTPSListenerAttributeReq.CertificateId = common.StringPtr(cloudCertId) modifyHTTPSListenerAttributeReq.CertificateId = common.StringPtr(cloudCertId)
modifyHTTPSListenerAttributeResp, err := d.sdkClient.ModifyHTTPSListenerAttribute(modifyHTTPSListenerAttributeReq) modifyHTTPSListenerAttributeResp, err := d.sdkClient.ModifyHTTPSListenerAttribute(modifyHTTPSListenerAttributeReq)

6
internal/pkg/core/deployer/providers/volcengine-alb/volcengine_alb.go
View File

@ -13,7 +13,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/volcengine-certcenter" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/volcengine-certcenter"
sliceutil "github.com/usual2970/certimate/internal/pkg/utils/slice" xslices "github.com/usual2970/certimate/internal/pkg/utils/slices"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -233,8 +233,8 @@ func (d *DeployerProvider) updateListenerCertificate(ctx context.Context, cloudL
// REF: https://www.volcengine.com/docs/6767/113683 // REF: https://www.volcengine.com/docs/6767/113683
modifyListenerAttributesReq := &vealb.ModifyListenerAttributesInput{ modifyListenerAttributesReq := &vealb.ModifyListenerAttributesInput{
ListenerId: ve.String(cloudListenerId), ListenerId: ve.String(cloudListenerId),
DomainExtensions: sliceutil.Map( DomainExtensions: xslices.Map(
sliceutil.Filter( xslices.Filter(
describeListenerAttributesResp.DomainExtensions, describeListenerAttributesResp.DomainExtensions,
func(domain *vealb.DomainExtensionForDescribeListenerAttributesOutput) bool { func(domain *vealb.DomainExtensionForDescribeListenerAttributesOutput) bool {
return *domain.Domain == d.config.Domain return *domain.Domain == d.config.Domain

4
internal/pkg/core/deployer/providers/wangsu-cdn/wangsu_cdn.go
View File

@ -12,7 +12,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/wangsu-certificate" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/wangsu-certificate"
wangsusdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/wangsu/cdn" wangsusdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/wangsu/cdn"
sliceutil "github.com/usual2970/certimate/internal/pkg/utils/slice" xslices "github.com/usual2970/certimate/internal/pkg/utils/slices"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -82,7 +82,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
certId, _ := strconv.ParseInt(upres.CertId, 10, 64) certId, _ := strconv.ParseInt(upres.CertId, 10, 64)
batchUpdateCertificateConfigReq := &wangsusdk.BatchUpdateCertificateConfigRequest{ batchUpdateCertificateConfigReq := &wangsusdk.BatchUpdateCertificateConfigRequest{
CertificateId: certId, CertificateId: certId,
DomainNames: sliceutil.Map(d.config.Domains, func(domain string) string { DomainNames: xslices.Map(d.config.Domains, func(domain string) string {
// "*.example.com" → ".example.com"，适配网宿云 CDN 要求的泛域名格式 // "*.example.com" → ".example.com"，适配网宿云 CDN 要求的泛域名格式
return strings.TrimPrefix(domain, "*") return strings.TrimPrefix(domain, "*")
}), }),

32
internal/pkg/core/deployer/providers/wangsu-cdnpro/wangsu_cdnpro.go
View File

@ -18,8 +18,8 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
wangsucdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/wangsu/cdnpro" wangsucdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/wangsu/cdnpro"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -81,7 +81,7 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
} }
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -99,10 +99,10 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
return nil, fmt.Errorf("failed to encrypt private key: %w", err) return nil, fmt.Errorf("failed to encrypt private key: %w", err)
} }
certificateNewVersionInfo := &wangsucdn.CertificateVersion{ certificateNewVersionInfo := &wangsucdn.CertificateVersion{
PrivateKey: typeutil.ToPtr(encryptedPrivateKey), PrivateKey: xtypes.ToPtr(encryptedPrivateKey),
Certificate: typeutil.ToPtr(certPEM), Certificate: xtypes.ToPtr(certPEM),
IdentificationInfo: &wangsucdn.CertificateVersionIdentificationInfo{ IdentificationInfo: &wangsucdn.CertificateVersionIdentificationInfo{
CommonName: typeutil.ToPtr(certX509.Subject.CommonName), CommonName: xtypes.ToPtr(certX509.Subject.CommonName),
SubjectAlternativeNames: &certX509.DNSNames, SubjectAlternativeNames: &certX509.DNSNames,
}, },
} }
@ -121,8 +121,8 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 创建证书 // 创建证书
createCertificateReq := &wangsucdn.CreateCertificateRequest{ createCertificateReq := &wangsucdn.CreateCertificateRequest{
Timestamp: timestamp, Timestamp: timestamp,
Name: typeutil.ToPtr(fmt.Sprintf("certimate_%d", time.Now().UnixMilli())), Name: xtypes.ToPtr(fmt.Sprintf("certimate_%d", time.Now().UnixMilli())),
AutoRenew: typeutil.ToPtr("Off"), AutoRenew: xtypes.ToPtr("Off"),
NewVersion: certificateNewVersionInfo, NewVersion: certificateNewVersionInfo,
} }
createCertificateResp, err := d.sdkClient.CreateCertificate(createCertificateReq) createCertificateResp, err := d.sdkClient.CreateCertificate(createCertificateReq)
@ -144,8 +144,8 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 更新证书 // 更新证书
updateCertificateReq := &wangsucdn.UpdateCertificateRequest{ updateCertificateReq := &wangsucdn.UpdateCertificateRequest{
Timestamp: timestamp, Timestamp: timestamp,
Name: typeutil.ToPtr(fmt.Sprintf("certimate_%d", time.Now().UnixMilli())), Name: xtypes.ToPtr(fmt.Sprintf("certimate_%d", time.Now().UnixMilli())),
AutoRenew: typeutil.ToPtr("Off"), AutoRenew: xtypes.ToPtr("Off"),
NewVersion: certificateNewVersionInfo, NewVersion: certificateNewVersionInfo,
} }
updateCertificateResp, err := d.sdkClient.UpdateCertificate(d.config.CertificateId, updateCertificateReq) updateCertificateResp, err := d.sdkClient.UpdateCertificate(d.config.CertificateId, updateCertificateReq)
@ -172,18 +172,18 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 创建部署任务 // 创建部署任务
// REF: https://www.wangsu.com/document/api-doc/27034 // REF: https://www.wangsu.com/document/api-doc/27034
createDeploymentTaskReq := &wangsucdn.CreateDeploymentTaskRequest{ createDeploymentTaskReq := &wangsucdn.CreateDeploymentTaskRequest{
Name: typeutil.ToPtr(fmt.Sprintf("certimate_%d", time.Now().UnixMilli())), Name: xtypes.ToPtr(fmt.Sprintf("certimate_%d", time.Now().UnixMilli())),
Target: typeutil.ToPtr(d.config.Environment), Target: xtypes.ToPtr(d.config.Environment),
Actions: &[]wangsucdn.DeploymentTaskAction{ Actions: &[]wangsucdn.DeploymentTaskAction{
{ {
Action: typeutil.ToPtr("deploy_cert"), Action: xtypes.ToPtr("deploy_cert"),
CertificateId: typeutil.ToPtr(wangsuCertId), CertificateId: xtypes.ToPtr(wangsuCertId),
Version: typeutil.ToPtr(wangsuCertVer), Version: xtypes.ToPtr(wangsuCertVer),
}, },
}, },
} }
if d.config.WebhookId != "" { if d.config.WebhookId != "" {
createDeploymentTaskReq.Webhook = typeutil.ToPtr(d.config.WebhookId) createDeploymentTaskReq.Webhook = xtypes.ToPtr(d.config.WebhookId)
} }
createDeploymentTaskResp, err := d.sdkClient.CreateDeploymentTask(createDeploymentTaskReq) createDeploymentTaskResp, err := d.sdkClient.CreateDeploymentTask(createDeploymentTaskReq)
d.logger.Debug("sdk request 'cdnpro.CreateCertificate'", slog.Any("request", createDeploymentTaskReq), slog.Any("response", createDeploymentTaskResp)) d.logger.Debug("sdk request 'cdnpro.CreateCertificate'", slog.Any("request", createDeploymentTaskReq), slog.Any("response", createDeploymentTaskResp))

10
internal/pkg/core/deployer/providers/wangsu-certificate/wangsu_certificate.go
View File

@ -11,7 +11,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/wangsu-certificate" uploadersp "github.com/usual2970/certimate/internal/pkg/core/uploader/providers/wangsu-certificate"
wangsusdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/wangsu/certificate" wangsusdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/wangsu/certificate"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -81,10 +81,10 @@ func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPE
// 修改证书 // 修改证书
// REF: https://www.wangsu.com/document/api-doc/25568?productCode=certificatemanagement // REF: https://www.wangsu.com/document/api-doc/25568?productCode=certificatemanagement
updateCertificateReq := &wangsusdk.UpdateCertificateRequest{ updateCertificateReq := &wangsusdk.UpdateCertificateRequest{
Name: typeutil.ToPtr(fmt.Sprintf("certimate_%d", time.Now().UnixMilli())), Name: xtypes.ToPtr(fmt.Sprintf("certimate_%d", time.Now().UnixMilli())),
Certificate: typeutil.ToPtr(certPEM), Certificate: xtypes.ToPtr(certPEM),
PrivateKey: typeutil.ToPtr(privkeyPEM), PrivateKey: xtypes.ToPtr(privkeyPEM),
Comment: typeutil.ToPtr("upload from certimate"), Comment: xtypes.ToPtr("upload from certimate"),
} }
updateCertificateResp, err := d.sdkClient.UpdateCertificate(d.config.CertificateId, updateCertificateReq) updateCertificateResp, err := d.sdkClient.UpdateCertificate(d.config.CertificateId, updateCertificateReq)
d.logger.Debug("sdk request 'certificatemanagement.UpdateCertificate'", slog.Any("request", updateCertificateReq), slog.Any("response", updateCertificateResp)) d.logger.Debug("sdk request 'certificatemanagement.UpdateCertificate'", slog.Any("request", updateCertificateReq), slog.Any("response", updateCertificateResp))

6
internal/pkg/core/deployer/providers/webhook/webhook.go
View File

@ -14,7 +14,7 @@ import (
"github.com/go-resty/resty/v2" "github.com/go-resty/resty/v2"
"github.com/usual2970/certimate/internal/pkg/core/deployer" "github.com/usual2970/certimate/internal/pkg/core/deployer"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type DeployerConfig struct { type DeployerConfig struct {
@ -70,13 +70,13 @@ func (d *DeployerProvider) WithLogger(logger *slog.Logger) deployer.Deployer {
func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) { func (d *DeployerProvider) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to parse x509: %w", err) return nil, fmt.Errorf("failed to parse x509: %w", err)
} }
// 提取服务器证书和中间证书 // 提取服务器证书和中间证书
serverCertPEM, intermediaCertPEM, err := certutil.ExtractCertificatesFromPEM(certPEM) serverCertPEM, intermediaCertPEM, err := xcert.ExtractCertificatesFromPEM(certPEM)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to extract certs: %w", err) return nil, fmt.Errorf("failed to extract certs: %w", err)
} }

14
internal/pkg/core/uploader/providers/aliyun-cas/aliyun_cas.go
View File

@ -12,8 +12,8 @@ import (
"github.com/alibabacloud-go/tea/tea" "github.com/alibabacloud-go/tea/tea"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -63,7 +63,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -81,7 +81,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
} }
listUserCertificateOrderReq := &alicas.ListUserCertificateOrderRequest{ listUserCertificateOrderReq := &alicas.ListUserCertificateOrderRequest{
ResourceGroupId: typeutil.ToPtrOrZeroNil(u.config.ResourceGroupId), ResourceGroupId: xtypes.ToPtrOrZeroNil(u.config.ResourceGroupId),
CurrentPage: tea.Int64(listUserCertificateOrderPage), CurrentPage: tea.Int64(listUserCertificateOrderPage),
ShowSize: tea.Int64(listUserCertificateOrderLimit), ShowSize: tea.Int64(listUserCertificateOrderLimit),
OrderType: tea.String("CERT"), OrderType: tea.String("CERT"),
@ -111,12 +111,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if *getUserCertificateDetailResp.Body.Cert == certPEM { if *getUserCertificateDetailResp.Body.Cert == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(*getUserCertificateDetailResp.Body.Cert) oldCertX509, err := xcert.ParseCertificateFromPEM(*getUserCertificateDetailResp.Body.Cert)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
// 如果已存在相同证书，直接返回 // 如果已存在相同证书，直接返回
@ -147,7 +147,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 上传新证书 // 上传新证书
// REF: https://help.aliyun.com/zh/ssl-certificate/developer-reference/api-cas-2020-04-07-uploadusercertificate // REF: https://help.aliyun.com/zh/ssl-certificate/developer-reference/api-cas-2020-04-07-uploadusercertificate
uploadUserCertificateReq := &alicas.UploadUserCertificateRequest{ uploadUserCertificateReq := &alicas.UploadUserCertificateRequest{
ResourceGroupId: typeutil.ToPtrOrZeroNil(u.config.ResourceGroupId), ResourceGroupId: xtypes.ToPtrOrZeroNil(u.config.ResourceGroupId),
Name: tea.String(certName), Name: tea.String(certName),
Cert: tea.String(certPEM), Cert: tea.String(certPEM),
Key: tea.String(privkeyPEM), Key: tea.String(privkeyPEM),

10
internal/pkg/core/uploader/providers/aliyun-slb/aliyun_slb.go
View File

@ -15,8 +15,8 @@ import (
"github.com/alibabacloud-go/tea/tea" "github.com/alibabacloud-go/tea/tea"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -66,7 +66,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -74,7 +74,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 查询证书列表，避免重复上传 // 查询证书列表，避免重复上传
// REF: https://help.aliyun.com/zh/slb/classic-load-balancer/developer-reference/api-slb-2014-05-15-describeservercertificates // REF: https://help.aliyun.com/zh/slb/classic-load-balancer/developer-reference/api-slb-2014-05-15-describeservercertificates
describeServerCertificatesReq := &alislb.DescribeServerCertificatesRequest{ describeServerCertificatesReq := &alislb.DescribeServerCertificatesRequest{
ResourceGroupId: typeutil.ToPtrOrZeroNil(u.config.ResourceGroupId), ResourceGroupId: xtypes.ToPtrOrZeroNil(u.config.ResourceGroupId),
RegionId: tea.String(u.config.Region), RegionId: tea.String(u.config.Region),
} }
describeServerCertificatesResp, err := u.sdkClient.DescribeServerCertificates(describeServerCertificatesReq) describeServerCertificatesResp, err := u.sdkClient.DescribeServerCertificates(describeServerCertificatesReq)
@ -114,7 +114,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 上传新证书 // 上传新证书
// REF: https://help.aliyun.com/zh/slb/classic-load-balancer/developer-reference/api-slb-2014-05-15-uploadservercertificate // REF: https://help.aliyun.com/zh/slb/classic-load-balancer/developer-reference/api-slb-2014-05-15-uploadservercertificate
uploadServerCertificateReq := &alislb.UploadServerCertificateRequest{ uploadServerCertificateReq := &alislb.UploadServerCertificateRequest{
ResourceGroupId: typeutil.ToPtrOrZeroNil(u.config.ResourceGroupId), ResourceGroupId: xtypes.ToPtrOrZeroNil(u.config.ResourceGroupId),
RegionId: tea.String(u.config.Region), RegionId: tea.String(u.config.Region),
ServerCertificateName: tea.String(certName), ServerCertificateName: tea.String(certName),
ServerCertificate: tea.String(certPEM), ServerCertificate: tea.String(certPEM),

10
internal/pkg/core/uploader/providers/aws-acm/aws_acm.go
View File

@ -12,7 +12,7 @@ import (
"golang.org/x/exp/slices" "golang.org/x/exp/slices"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -60,13 +60,13 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// 提取服务器证书 // 提取服务器证书
serverCertPEM, intermediaCertPEM, err := certutil.ExtractCertificatesFromPEM(certPEM) serverCertPEM, intermediaCertPEM, err := xcert.ExtractCertificatesFromPEM(certPEM)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to extract certs: %w", err) return nil, fmt.Errorf("failed to extract certs: %w", err)
} }
@ -116,12 +116,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
return nil, fmt.Errorf("failed to execute sdk request 'acm.GetCertificate': %w", err) return nil, fmt.Errorf("failed to execute sdk request 'acm.GetCertificate': %w", err)
} else { } else {
oldCertPEM := aws.ToString(getCertificateResp.Certificate) oldCertPEM := aws.ToString(getCertificateResp.Certificate)
oldCertX509, err := certutil.ParseCertificateFromPEM(oldCertPEM) oldCertX509, err := xcert.ParseCertificateFromPEM(oldCertPEM)
if err != nil { if err != nil {
continue continue
} }
if !certutil.EqualCertificate(certX509, oldCertX509) { if !xcert.EqualCertificate(certX509, oldCertX509) {
continue continue
} }
} }

10
internal/pkg/core/uploader/providers/aws-iam/aws_iam.go
View File

@ -12,7 +12,7 @@ import (
awsiam "github.com/aws/aws-sdk-go-v2/service/iam" awsiam "github.com/aws/aws-sdk-go-v2/service/iam"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -63,13 +63,13 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// 提取服务器证书 // 提取服务器证书
serverCertPEM, intermediaCertPEM, err := certutil.ExtractCertificatesFromPEM(certPEM) serverCertPEM, intermediaCertPEM, err := xcert.ExtractCertificatesFromPEM(certPEM)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to extract certs: %w", err) return nil, fmt.Errorf("failed to extract certs: %w", err)
} }
@ -119,12 +119,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
return nil, fmt.Errorf("failed to execute sdk request 'iam.GetServerCertificate': %w", err) return nil, fmt.Errorf("failed to execute sdk request 'iam.GetServerCertificate': %w", err)
} else { } else {
oldCertPEM := aws.ToString(getServerCertificateResp.ServerCertificate.CertificateBody) oldCertPEM := aws.ToString(getServerCertificateResp.ServerCertificate.CertificateBody)
oldCertX509, err := certutil.ParseCertificateFromPEM(oldCertPEM) oldCertX509, err := xcert.ParseCertificateFromPEM(oldCertPEM)
if err != nil { if err != nil {
continue continue
} }
if !certutil.EqualCertificate(certX509, oldCertX509) { if !xcert.EqualCertificate(certX509, oldCertX509) {
continue continue
} }
} }

8
internal/pkg/core/uploader/providers/azure-keyvault/azure_keyvault.go
View File

@ -15,7 +15,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
azcommon "github.com/usual2970/certimate/internal/pkg/sdk3rd/azure/common" azcommon "github.com/usual2970/certimate/internal/pkg/sdk3rd/azure/common"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -67,7 +67,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -124,7 +124,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
continue continue
} }
if !certutil.EqualCertificate(certX509, oldCertX509) { if !xcert.EqualCertificate(certX509, oldCertX509) {
continue continue
} }
} }
@ -144,7 +144,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// Azure Key Vault 不支持导入带有 Certificiate Chain 的 PEM 证书。 // Azure Key Vault 不支持导入带有 Certificiate Chain 的 PEM 证书。
// Issue Link: https://github.com/Azure/azure-cli/issues/19017 // Issue Link: https://github.com/Azure/azure-cli/issues/19017
// 暂时的解决方法是，将 PEM 证书转换成 PFX 格式，然后再导入。 // 暂时的解决方法是，将 PEM 证书转换成 PFX 格式，然后再导入。
certPFX, err := certutil.TransformCertificateFromPEMToPFX(certPEM, privkeyPEM, "") certPFX, err := xcert.TransformCertificateFromPEMToPFX(certPEM, privkeyPEM, "")
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to transform certificate from PEM to PFX: %w", err) return nil, fmt.Errorf("failed to transform certificate from PEM to PFX: %w", err)
} }

8
internal/pkg/core/uploader/providers/baiducloud-cert/baiducloud_cert.go
View File

@ -9,7 +9,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
bdsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/baiducloud/cert" bdsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/baiducloud/cert"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -55,7 +55,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -91,11 +91,11 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cert.GetCertRawData': %w", err) return nil, fmt.Errorf("failed to execute sdk request 'cert.GetCertRawData': %w", err)
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(getCertDetailResp.CertServerData) oldCertX509, err := xcert.ParseCertificateFromPEM(getCertDetailResp.CertServerData)
if err != nil { if err != nil {
continue continue
} }
if !certutil.EqualCertificate(certX509, oldCertX509) { if !xcert.EqualCertificate(certX509, oldCertX509) {
continue continue
} }
} }

4
internal/pkg/core/uploader/providers/byteplus-cdn/byteplus_cdn.go
View File

@ -13,7 +13,7 @@ import (
bytepluscdn "github.com/byteplus-sdk/byteplus-sdk-golang/service/cdn" bytepluscdn "github.com/byteplus-sdk/byteplus-sdk-golang/service/cdn"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -58,7 +58,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }

24
internal/pkg/core/uploader/providers/ctcccloud-ao/ctcccloud_ao.go
View File

@ -10,8 +10,8 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
ctyunao "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/ao" ctyunao "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/ao"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -57,7 +57,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -74,9 +74,9 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
} }
listCertsReq := &ctyunao.ListCertsRequest{ listCertsReq := &ctyunao.ListCertsRequest{
Page: typeutil.ToPtr(listCertPage), Page: xtypes.ToPtr(listCertPage),
PerPage: typeutil.ToPtr(listCertPerPage), PerPage: xtypes.ToPtr(listCertPerPage),
UsageMode: typeutil.ToPtr(int32(0)), UsageMode: xtypes.ToPtr(int32(0)),
} }
listCertsResp, err := u.sdkClient.ListCerts(listCertsReq) listCertsResp, err := u.sdkClient.ListCerts(listCertsReq)
u.logger.Debug("sdk request 'ao.ListCerts'", slog.Any("request", listCertsReq), slog.Any("response", listCertsResp)) u.logger.Debug("sdk request 'ao.ListCerts'", slog.Any("request", listCertsReq), slog.Any("response", listCertsResp))
@ -106,7 +106,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 查询证书详情 // 查询证书详情
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=113&api=13015&data=174&isNormal=1&vid=167 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=113&api=13015&data=174&isNormal=1&vid=167
queryCertReq := &ctyunao.QueryCertRequest{ queryCertReq := &ctyunao.QueryCertRequest{
Id: typeutil.ToPtr(certRecord.Id), Id: xtypes.ToPtr(certRecord.Id),
} }
queryCertResp, err := u.sdkClient.QueryCert(queryCertReq) queryCertResp, err := u.sdkClient.QueryCert(queryCertReq)
u.logger.Debug("sdk request 'ao.QueryCert'", slog.Any("request", queryCertReq), slog.Any("response", queryCertResp)) u.logger.Debug("sdk request 'ao.QueryCert'", slog.Any("request", queryCertReq), slog.Any("response", queryCertResp))
@ -117,12 +117,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if queryCertResp.ReturnObj.Result.Certs == certPEM { if queryCertResp.ReturnObj.Result.Certs == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(queryCertResp.ReturnObj.Result.Certs) oldCertX509, err := xcert.ParseCertificateFromPEM(queryCertResp.ReturnObj.Result.Certs)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
// 如果已存在相同证书，直接返回 // 如果已存在相同证书，直接返回
@ -150,9 +150,9 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 创建证书 // 创建证书
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=113&api=13014&data=174&isNormal=1&vid=167 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=113&api=13014&data=174&isNormal=1&vid=167
createCertReq := &ctyunao.CreateCertRequest{ createCertReq := &ctyunao.CreateCertRequest{
Name: typeutil.ToPtr(certName), Name: xtypes.ToPtr(certName),
Certs: typeutil.ToPtr(certPEM), Certs: xtypes.ToPtr(certPEM),
Key: typeutil.ToPtr(privkeyPEM), Key: xtypes.ToPtr(privkeyPEM),
} }
createCertResp, err := u.sdkClient.CreateCert(createCertReq) createCertResp, err := u.sdkClient.CreateCert(createCertReq)
u.logger.Debug("sdk request 'ao.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp)) u.logger.Debug("sdk request 'ao.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))

24
internal/pkg/core/uploader/providers/ctcccloud-cdn/ctcccloud_cdn.go
View File

@ -10,8 +10,8 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
ctyuncdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/cdn" ctyuncdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/cdn"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -57,7 +57,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -74,9 +74,9 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
} }
queryCertListReq := &ctyuncdn.QueryCertListRequest{ queryCertListReq := &ctyuncdn.QueryCertListRequest{
Page: typeutil.ToPtr(queryCertListPage), Page: xtypes.ToPtr(queryCertListPage),
PerPage: typeutil.ToPtr(queryCertListPerPage), PerPage: xtypes.ToPtr(queryCertListPerPage),
UsageMode: typeutil.ToPtr(int32(0)), UsageMode: xtypes.ToPtr(int32(0)),
} }
queryCertListResp, err := u.sdkClient.QueryCertList(queryCertListReq) queryCertListResp, err := u.sdkClient.QueryCertList(queryCertListReq)
u.logger.Debug("sdk request 'cdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp)) u.logger.Debug("sdk request 'cdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp))
@ -106,7 +106,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 查询证书详情 // 查询证书详情
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=108&api=10899&data=161&isNormal=1&vid=154 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=108&api=10899&data=161&isNormal=1&vid=154
queryCertDetailReq := &ctyuncdn.QueryCertDetailRequest{ queryCertDetailReq := &ctyuncdn.QueryCertDetailRequest{
Id: typeutil.ToPtr(certRecord.Id), Id: xtypes.ToPtr(certRecord.Id),
} }
queryCertDetailResp, err := u.sdkClient.QueryCertDetail(queryCertDetailReq) queryCertDetailResp, err := u.sdkClient.QueryCertDetail(queryCertDetailReq)
u.logger.Debug("sdk request 'cdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp)) u.logger.Debug("sdk request 'cdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp))
@ -117,12 +117,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if queryCertDetailResp.ReturnObj.Result.Certs == certPEM { if queryCertDetailResp.ReturnObj.Result.Certs == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(queryCertDetailResp.ReturnObj.Result.Certs) oldCertX509, err := xcert.ParseCertificateFromPEM(queryCertDetailResp.ReturnObj.Result.Certs)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
// 如果已存在相同证书，直接返回 // 如果已存在相同证书，直接返回
@ -150,9 +150,9 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 创建证书 // 创建证书
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=108&api=10893&data=161&isNormal=1&vid=154 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=108&api=10893&data=161&isNormal=1&vid=154
createCertReq := &ctyuncdn.CreateCertRequest{ createCertReq := &ctyuncdn.CreateCertRequest{
Name: typeutil.ToPtr(certName), Name: xtypes.ToPtr(certName),
Certs: typeutil.ToPtr(certPEM), Certs: xtypes.ToPtr(certPEM),
Key: typeutil.ToPtr(privkeyPEM), Key: xtypes.ToPtr(privkeyPEM),
} }
createCertResp, err := u.sdkClient.CreateCert(createCertReq) createCertResp, err := u.sdkClient.CreateCert(createCertReq)
u.logger.Debug("sdk request 'cdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp)) u.logger.Debug("sdk request 'cdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))

26
internal/pkg/core/uploader/providers/ctcccloud-cms/ctcccloud_cms.go
View File

@ -12,8 +12,8 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
ctyuncms "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/cms" ctyuncms "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/cms"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -64,7 +64,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
} }
// 提取服务器证书 // 提取服务器证书
serverCertPEM, intermediaCertPEM, err := certutil.ExtractCertificatesFromPEM(certPEM) serverCertPEM, intermediaCertPEM, err := xcert.ExtractCertificatesFromPEM(certPEM)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to extract certs: %w", err) return nil, fmt.Errorf("failed to extract certs: %w", err)
} }
@ -75,11 +75,11 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 上传证书 // 上传证书
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=152&api=17243&data=204&isNormal=1&vid=283 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=152&api=17243&data=204&isNormal=1&vid=283
uploadCertificateReq := &ctyuncms.UploadCertificateRequest{ uploadCertificateReq := &ctyuncms.UploadCertificateRequest{
Name: typeutil.ToPtr(certName), Name: xtypes.ToPtr(certName),
Certificate: typeutil.ToPtr(serverCertPEM), Certificate: xtypes.ToPtr(serverCertPEM),
CertificateChain: typeutil.ToPtr(intermediaCertPEM), CertificateChain: xtypes.ToPtr(intermediaCertPEM),
PrivateKey: typeutil.ToPtr(privkeyPEM), PrivateKey: xtypes.ToPtr(privkeyPEM),
EncryptionStandard: typeutil.ToPtr("INTERNATIONAL"), EncryptionStandard: xtypes.ToPtr("INTERNATIONAL"),
} }
uploadCertificateResp, err := u.sdkClient.UploadCertificate(uploadCertificateReq) uploadCertificateResp, err := u.sdkClient.UploadCertificate(uploadCertificateReq)
u.logger.Debug("sdk request 'cms.UploadCertificate'", slog.Any("request", uploadCertificateReq), slog.Any("response", uploadCertificateResp)) u.logger.Debug("sdk request 'cms.UploadCertificate'", slog.Any("request", uploadCertificateReq), slog.Any("response", uploadCertificateResp))
@ -110,7 +110,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
func (u *UploaderProvider) findCertIfExists(ctx context.Context, certPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) findCertIfExists(ctx context.Context, certPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -127,10 +127,10 @@ func (u *UploaderProvider) findCertIfExists(ctx context.Context, certPEM string)
} }
getCertificateListReq := &ctyuncms.GetCertificateListRequest{ getCertificateListReq := &ctyuncms.GetCertificateListRequest{
PageNum: typeutil.ToPtr(getCertificateListPageNum), PageNum: xtypes.ToPtr(getCertificateListPageNum),
PageSize: typeutil.ToPtr(getCertificateListPageSize), PageSize: xtypes.ToPtr(getCertificateListPageSize),
Keyword: typeutil.ToPtr(certX509.Subject.CommonName), Keyword: xtypes.ToPtr(certX509.Subject.CommonName),
Origin: typeutil.ToPtr("UPLOAD"), Origin: xtypes.ToPtr("UPLOAD"),
} }
getCertificateListResp, err := u.sdkClient.GetCertificateList(getCertificateListReq) getCertificateListResp, err := u.sdkClient.GetCertificateList(getCertificateListReq)
u.logger.Debug("sdk request 'cms.GetCertificateList'", slog.Any("request", getCertificateListReq), slog.Any("response", getCertificateListResp)) u.logger.Debug("sdk request 'cms.GetCertificateList'", slog.Any("request", getCertificateListReq), slog.Any("response", getCertificateListResp))

26
internal/pkg/core/uploader/providers/ctcccloud-elb/ctcccloud_elb.go
View File

@ -10,8 +10,8 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
ctyunelb "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/elb" ctyunelb "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/elb"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -59,7 +59,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -67,7 +67,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 查询证书列表，避免重复上传 // 查询证书列表，避免重复上传
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=24&api=5692&data=88&isNormal=1&vid=82 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=24&api=5692&data=88&isNormal=1&vid=82
listCertificatesReq := &ctyunelb.ListCertificatesRequest{ listCertificatesReq := &ctyunelb.ListCertificatesRequest{
RegionID: typeutil.ToPtr(u.config.RegionId), RegionID: xtypes.ToPtr(u.config.RegionId),
} }
listCertificatesResp, err := u.sdkClient.ListCertificates(listCertificatesReq) listCertificatesResp, err := u.sdkClient.ListCertificates(listCertificatesReq)
u.logger.Debug("sdk request 'elb.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp)) u.logger.Debug("sdk request 'elb.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
@ -79,12 +79,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if certRecord.Certificate == certPEM { if certRecord.Certificate == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(certRecord.Certificate) oldCertX509, err := xcert.ParseCertificateFromPEM(certRecord.Certificate)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
// 如果已存在相同证书，直接返回 // 如果已存在相同证书，直接返回
@ -104,13 +104,13 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 创建证书 // 创建证书
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=24&api=5685&data=88&isNormal=1&vid=82 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=24&api=5685&data=88&isNormal=1&vid=82
createCertificateReq := &ctyunelb.CreateCertificateRequest{ createCertificateReq := &ctyunelb.CreateCertificateRequest{
ClientToken: typeutil.ToPtr(generateClientToken()), ClientToken: xtypes.ToPtr(generateClientToken()),
RegionID: typeutil.ToPtr(u.config.RegionId), RegionID: xtypes.ToPtr(u.config.RegionId),
Name: typeutil.ToPtr(certName), Name: xtypes.ToPtr(certName),
Description: typeutil.ToPtr("upload from certimate"), Description: xtypes.ToPtr("upload from certimate"),
Type: typeutil.ToPtr("Server"), Type: xtypes.ToPtr("Server"),
Certificate: typeutil.ToPtr(certPEM), Certificate: xtypes.ToPtr(certPEM),
PrivateKey: typeutil.ToPtr(privkeyPEM), PrivateKey: xtypes.ToPtr(privkeyPEM),
} }
createCertificateResp, err := u.sdkClient.CreateCertificate(createCertificateReq) createCertificateResp, err := u.sdkClient.CreateCertificate(createCertificateReq)
u.logger.Debug("sdk request 'elb.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp)) u.logger.Debug("sdk request 'elb.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))

24
internal/pkg/core/uploader/providers/ctcccloud-icdn/ctcccloud_icdn.go
View File

@ -10,8 +10,8 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
ctyunicdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/icdn" ctyunicdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/icdn"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -57,7 +57,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -74,9 +74,9 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
} }
queryCertListReq := &ctyunicdn.QueryCertListRequest{ queryCertListReq := &ctyunicdn.QueryCertListRequest{
Page: typeutil.ToPtr(queryCertListPage), Page: xtypes.ToPtr(queryCertListPage),
PerPage: typeutil.ToPtr(queryCertListPerPage), PerPage: xtypes.ToPtr(queryCertListPerPage),
UsageMode: typeutil.ToPtr(int32(0)), UsageMode: xtypes.ToPtr(int32(0)),
} }
queryCertListResp, err := u.sdkClient.QueryCertList(queryCertListReq) queryCertListResp, err := u.sdkClient.QueryCertList(queryCertListReq)
u.logger.Debug("sdk request 'icdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp)) u.logger.Debug("sdk request 'icdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp))
@ -106,7 +106,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 查询证书详情 // 查询证书详情
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=112&api=10837&data=173&isNormal=1&vid=166 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=112&api=10837&data=173&isNormal=1&vid=166
queryCertDetailReq := &ctyunicdn.QueryCertDetailRequest{ queryCertDetailReq := &ctyunicdn.QueryCertDetailRequest{
Id: typeutil.ToPtr(certRecord.Id), Id: xtypes.ToPtr(certRecord.Id),
} }
queryCertDetailResp, err := u.sdkClient.QueryCertDetail(queryCertDetailReq) queryCertDetailResp, err := u.sdkClient.QueryCertDetail(queryCertDetailReq)
u.logger.Debug("sdk request 'icdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp)) u.logger.Debug("sdk request 'icdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp))
@ -117,12 +117,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if queryCertDetailResp.ReturnObj.Result.Certs == certPEM { if queryCertDetailResp.ReturnObj.Result.Certs == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(queryCertDetailResp.ReturnObj.Result.Certs) oldCertX509, err := xcert.ParseCertificateFromPEM(queryCertDetailResp.ReturnObj.Result.Certs)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
// 如果已存在相同证书，直接返回 // 如果已存在相同证书，直接返回
@ -150,9 +150,9 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 创建证书 // 创建证书
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=112&api=10835&data=173&isNormal=1&vid=166 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=112&api=10835&data=173&isNormal=1&vid=166
createCertReq := &ctyunicdn.CreateCertRequest{ createCertReq := &ctyunicdn.CreateCertRequest{
Name: typeutil.ToPtr(certName), Name: xtypes.ToPtr(certName),
Certs: typeutil.ToPtr(certPEM), Certs: xtypes.ToPtr(certPEM),
Key: typeutil.ToPtr(privkeyPEM), Key: xtypes.ToPtr(privkeyPEM),
} }
createCertResp, err := u.sdkClient.CreateCert(createCertReq) createCertResp, err := u.sdkClient.CreateCert(createCertReq)
u.logger.Debug("sdk request 'icdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp)) u.logger.Debug("sdk request 'icdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))

24
internal/pkg/core/uploader/providers/ctcccloud-lvdn/ctcccloud_lvdn.go
View File

@ -10,8 +10,8 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
ctyunlvdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/lvdn" ctyunlvdn "github.com/usual2970/certimate/internal/pkg/sdk3rd/ctyun/lvdn"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -57,7 +57,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -74,9 +74,9 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
} }
queryCertListReq := &ctyunlvdn.QueryCertListRequest{ queryCertListReq := &ctyunlvdn.QueryCertListRequest{
Page: typeutil.ToPtr(queryCertListPage), Page: xtypes.ToPtr(queryCertListPage),
PerPage: typeutil.ToPtr(queryCertListPerPage), PerPage: xtypes.ToPtr(queryCertListPerPage),
UsageMode: typeutil.ToPtr(int32(0)), UsageMode: xtypes.ToPtr(int32(0)),
} }
queryCertListResp, err := u.sdkClient.QueryCertList(queryCertListReq) queryCertListResp, err := u.sdkClient.QueryCertList(queryCertListReq)
u.logger.Debug("sdk request 'lvdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp)) u.logger.Debug("sdk request 'lvdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp))
@ -106,7 +106,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 查询证书详情 // 查询证书详情
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=125&api=11449&data=183&isNormal=1&vid=261 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=125&api=11449&data=183&isNormal=1&vid=261
queryCertDetailReq := &ctyunlvdn.QueryCertDetailRequest{ queryCertDetailReq := &ctyunlvdn.QueryCertDetailRequest{
Id: typeutil.ToPtr(certRecord.Id), Id: xtypes.ToPtr(certRecord.Id),
} }
queryCertDetailResp, err := u.sdkClient.QueryCertDetail(queryCertDetailReq) queryCertDetailResp, err := u.sdkClient.QueryCertDetail(queryCertDetailReq)
u.logger.Debug("sdk request 'lvdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp)) u.logger.Debug("sdk request 'lvdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp))
@ -117,12 +117,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if queryCertDetailResp.ReturnObj.Result.Certs == certPEM { if queryCertDetailResp.ReturnObj.Result.Certs == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(queryCertDetailResp.ReturnObj.Result.Certs) oldCertX509, err := xcert.ParseCertificateFromPEM(queryCertDetailResp.ReturnObj.Result.Certs)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
// 如果已存在相同证书，直接返回 // 如果已存在相同证书，直接返回
@ -150,9 +150,9 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 创建证书 // 创建证书
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=125&api=11436&data=183&isNormal=1&vid=261 // REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=125&api=11436&data=183&isNormal=1&vid=261
createCertReq := &ctyunlvdn.CreateCertRequest{ createCertReq := &ctyunlvdn.CreateCertRequest{
Name: typeutil.ToPtr(certName), Name: xtypes.ToPtr(certName),
Certs: typeutil.ToPtr(certPEM), Certs: xtypes.ToPtr(certPEM),
Key: typeutil.ToPtr(privkeyPEM), Key: xtypes.ToPtr(privkeyPEM),
} }
createCertResp, err := u.sdkClient.CreateCert(createCertReq) createCertResp, err := u.sdkClient.CreateCert(createCertReq)
u.logger.Debug("sdk request 'lvdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp)) u.logger.Debug("sdk request 'lvdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))

22
internal/pkg/core/uploader/providers/huaweicloud-elb/huaweicloud_elb.go
View File

@ -17,8 +17,8 @@ import (
hciamregion "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/iam/v3/region" hciamregion "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/iam/v3/region"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -68,7 +68,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -85,7 +85,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
} }
listCertificatesReq := &hcelbmodel.ListCertificatesRequest{ listCertificatesReq := &hcelbmodel.ListCertificatesRequest{
Limit: typeutil.ToPtr(listCertificatesLimit), Limit: xtypes.ToPtr(listCertificatesLimit),
Marker: listCertificatesMarker, Marker: listCertificatesMarker,
Type: &[]string{"server"}, Type: &[]string{"server"},
} }
@ -101,12 +101,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if certDetail.Certificate == certPEM { if certDetail.Certificate == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(certDetail.Certificate) oldCertX509, err := xcert.ParseCertificateFromPEM(certDetail.Certificate)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
// 如果已存在相同证书，直接返回 // 如果已存在相同证书，直接返回
@ -143,11 +143,11 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
createCertificateReq := &hcelbmodel.CreateCertificateRequest{ createCertificateReq := &hcelbmodel.CreateCertificateRequest{
Body: &hcelbmodel.CreateCertificateRequestBody{ Body: &hcelbmodel.CreateCertificateRequestBody{
Certificate: &hcelbmodel.CreateCertificateOption{ Certificate: &hcelbmodel.CreateCertificateOption{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(u.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(u.config.EnterpriseProjectId),
ProjectId: typeutil.ToPtr(projectId), ProjectId: xtypes.ToPtr(projectId),
Name: typeutil.ToPtr(certName), Name: xtypes.ToPtr(certName),
Certificate: typeutil.ToPtr(certPEM), Certificate: xtypes.ToPtr(certPEM),
PrivateKey: typeutil.ToPtr(privkeyPEM), PrivateKey: xtypes.ToPtr(privkeyPEM),
}, },
}, },
} }

22
internal/pkg/core/uploader/providers/huaweicloud-scm/huaweicloud_scm.go
View File

@ -12,8 +12,8 @@ import (
hcscmregion "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/scm/v3/region" hcscmregion "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/scm/v3/region"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -63,7 +63,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -81,11 +81,11 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
} }
listCertificatesReq := &hcscmmodel.ListCertificatesRequest{ listCertificatesReq := &hcscmmodel.ListCertificatesRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(u.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(u.config.EnterpriseProjectId),
Limit: typeutil.ToPtr(listCertificatesLimit), Limit: xtypes.ToPtr(listCertificatesLimit),
Offset: typeutil.ToPtr(listCertificatesOffset), Offset: xtypes.ToPtr(listCertificatesOffset),
SortDir: typeutil.ToPtr("DESC"), SortDir: xtypes.ToPtr("DESC"),
SortKey: typeutil.ToPtr("certExpiredTime"), SortKey: xtypes.ToPtr("certExpiredTime"),
} }
listCertificatesResp, err := u.sdkClient.ListCertificates(listCertificatesReq) listCertificatesResp, err := u.sdkClient.ListCertificates(listCertificatesReq)
u.logger.Debug("sdk request 'scm.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp)) u.logger.Debug("sdk request 'scm.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
@ -111,12 +111,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if *exportCertificateResp.Certificate == certPEM { if *exportCertificateResp.Certificate == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(*exportCertificateResp.Certificate) oldCertX509, err := xcert.ParseCertificateFromPEM(*exportCertificateResp.Certificate)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
// 如果已存在相同证书，直接返回 // 如果已存在相同证书，直接返回
@ -145,7 +145,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// REF: https://support.huaweicloud.com/api-ccm/ImportCertificate.html // REF: https://support.huaweicloud.com/api-ccm/ImportCertificate.html
importCertificateReq := &hcscmmodel.ImportCertificateRequest{ importCertificateReq := &hcscmmodel.ImportCertificateRequest{
Body: &hcscmmodel.ImportCertificateRequestBody{ Body: &hcscmmodel.ImportCertificateRequestBody{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(u.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(u.config.EnterpriseProjectId),
Name: certName, Name: certName,
Certificate: certPEM, Certificate: certPEM,
PrivateKey: privkeyPEM, PrivateKey: privkeyPEM,

20
internal/pkg/core/uploader/providers/huaweicloud-waf/huaweicloud_waf.go
View File

@ -17,8 +17,8 @@ import (
hcwafregion "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/waf/v1/region" hcwafregion "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/waf/v1/region"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -68,7 +68,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -86,9 +86,9 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
} }
listCertificatesReq := &hcwafmodel.ListCertificatesRequest{ listCertificatesReq := &hcwafmodel.ListCertificatesRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(u.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(u.config.EnterpriseProjectId),
Page: typeutil.ToPtr(listCertificatesPage), Page: xtypes.ToPtr(listCertificatesPage),
Pagesize: typeutil.ToPtr(listCertificatesPageSize), Pagesize: xtypes.ToPtr(listCertificatesPageSize),
} }
listCertificatesResp, err := u.sdkClient.ListCertificates(listCertificatesReq) listCertificatesResp, err := u.sdkClient.ListCertificates(listCertificatesReq)
u.logger.Debug("sdk request 'waf.ShowCertificate'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp)) u.logger.Debug("sdk request 'waf.ShowCertificate'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
@ -99,7 +99,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if listCertificatesResp.Items != nil { if listCertificatesResp.Items != nil {
for _, certItem := range *listCertificatesResp.Items { for _, certItem := range *listCertificatesResp.Items {
showCertificateReq := &hcwafmodel.ShowCertificateRequest{ showCertificateReq := &hcwafmodel.ShowCertificateRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(u.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(u.config.EnterpriseProjectId),
CertificateId: certItem.Id, CertificateId: certItem.Id,
} }
showCertificateResp, err := u.sdkClient.ShowCertificate(showCertificateReq) showCertificateResp, err := u.sdkClient.ShowCertificate(showCertificateReq)
@ -112,12 +112,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if *showCertificateResp.Content == certPEM { if *showCertificateResp.Content == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(*showCertificateResp.Content) oldCertX509, err := xcert.ParseCertificateFromPEM(*showCertificateResp.Content)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
// 如果已存在相同证书，直接返回 // 如果已存在相同证书，直接返回
@ -145,7 +145,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 创建证书 // 创建证书
// REF: https://support.huaweicloud.com/api-waf/CreateCertificate.html // REF: https://support.huaweicloud.com/api-waf/CreateCertificate.html
createCertificateReq := &hcwafmodel.CreateCertificateRequest{ createCertificateReq := &hcwafmodel.CreateCertificateRequest{
EnterpriseProjectId: typeutil.ToPtrOrZeroNil(u.config.EnterpriseProjectId), EnterpriseProjectId: xtypes.ToPtrOrZeroNil(u.config.EnterpriseProjectId),
Body: &hcwafmodel.CreateCertificateRequestBody{ Body: &hcwafmodel.CreateCertificateRequestBody{
Name: certName, Name: certName,
Content: certPEM, Content: certPEM,

4
internal/pkg/core/uploader/providers/jdcloud-ssl/jdcloud_ssl.go
View File

@ -15,7 +15,7 @@ import (
"golang.org/x/exp/slices" "golang.org/x/exp/slices"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -61,7 +61,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }

4
internal/pkg/core/uploader/providers/qiniu-sslcert/qiniu_sslcert.go
View File

@ -11,7 +11,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
qiniusdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/qiniu" qiniusdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/qiniu"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -57,7 +57,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }

8
internal/pkg/core/uploader/providers/rainyun-sslcenter/rainyun_sslcenter.go
View File

@ -9,7 +9,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
rainyunsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/rainyun" rainyunsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/rainyun"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -84,7 +84,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
func (u *UploaderProvider) findCertIfExists(ctx context.Context, certPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) findCertIfExists(ctx context.Context, certPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -137,12 +137,12 @@ func (u *UploaderProvider) findCertIfExists(ctx context.Context, certPEM string)
if sslCenterGetResp.Data.Cert == certPEM { if sslCenterGetResp.Data.Cert == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(sslCenterGetResp.Data.Cert) oldCertX509, err := xcert.ParseCertificateFromPEM(sslCenterGetResp.Data.Cert)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
} }

4
internal/pkg/core/uploader/providers/ucloud-ussl/ucloud_ussl.go
View File

@ -17,7 +17,7 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
usslsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/ucloud/ussl" usslsdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/ucloud/ussl"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -113,7 +113,7 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
func (u *UploaderProvider) findCertIfExists(ctx context.Context, certPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) findCertIfExists(ctx context.Context, certPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }

4
internal/pkg/core/uploader/providers/volcengine-cdn/volcengine_cdn.go
View File

@ -14,7 +14,7 @@ import (
ve "github.com/volcengine/volcengine-go-sdk/volcengine" ve "github.com/volcengine/volcengine-go-sdk/volcengine"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -59,7 +59,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }

8
internal/pkg/core/uploader/providers/volcengine-live/volcengine_live.go
View File

@ -11,7 +11,7 @@ import (
ve "github.com/volcengine/volcengine-go-sdk/volcengine" ve "github.com/volcengine/volcengine-go-sdk/volcengine"
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -56,7 +56,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -87,12 +87,12 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
if certificate == certPEM { if certificate == certPEM {
isSameCert = true isSameCert = true
} else { } else {
oldCertX509, err := certutil.ParseCertificateFromPEM(certificate) oldCertX509, err := xcert.ParseCertificateFromPEM(certificate)
if err != nil { if err != nil {
continue continue
} }
isSameCert = certutil.EqualCertificate(certX509, oldCertX509) isSameCert = xcert.EqualCertificate(certX509, oldCertX509)
} }
// 如果已存在相同证书，直接返回 // 如果已存在相同证书，直接返回

14
internal/pkg/core/uploader/providers/wangsu-certificate/wangsu_certificate.go
View File

@ -11,8 +11,8 @@ import (
"github.com/usual2970/certimate/internal/pkg/core/uploader" "github.com/usual2970/certimate/internal/pkg/core/uploader"
wangsusdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/wangsu/certificate" wangsusdk "github.com/usual2970/certimate/internal/pkg/sdk3rd/wangsu/certificate"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
typeutil "github.com/usual2970/certimate/internal/pkg/utils/type" xtypes "github.com/usual2970/certimate/internal/pkg/utils/types"
) )
type UploaderConfig struct { type UploaderConfig struct {
@ -58,7 +58,7 @@ func (u *UploaderProvider) WithLogger(logger *slog.Logger) uploader.Uploader {
func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) { func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*uploader.UploadResult, error) {
// 解析证书内容 // 解析证书内容
certX509, err := certutil.ParseCertificateFromPEM(certPEM) certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -102,10 +102,10 @@ func (u *UploaderProvider) Upload(ctx context.Context, certPEM string, privkeyPE
// 新增证书 // 新增证书
// REF: https://www.wangsu.com/document/api-doc/25199?productCode=certificatemanagement // REF: https://www.wangsu.com/document/api-doc/25199?productCode=certificatemanagement
createCertificateReq := &wangsusdk.CreateCertificateRequest{ createCertificateReq := &wangsusdk.CreateCertificateRequest{
Name: typeutil.ToPtr(certName), Name: xtypes.ToPtr(certName),
Certificate: typeutil.ToPtr(certPEM), Certificate: xtypes.ToPtr(certPEM),
PrivateKey: typeutil.ToPtr(privkeyPEM), PrivateKey: xtypes.ToPtr(privkeyPEM),
Comment: typeutil.ToPtr("upload from certimate"), Comment: xtypes.ToPtr("upload from certimate"),
} }
createCertificateResp, err := u.sdkClient.CreateCertificate(createCertificateReq) createCertificateResp, err := u.sdkClient.CreateCertificate(createCertificateReq)
u.logger.Debug("sdk request 'certificatemanagement.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp)) u.logger.Debug("sdk request 'certificatemanagement.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))

2
internal/pkg/utils/cert/common.go
View File

@ -1,4 +1,4 @@
package certutil package cert
import ( import (
"crypto/x509" "crypto/x509"

2
internal/pkg/utils/cert/converter.go
View File

@ -1,4 +1,4 @@
package certutil package cert
import ( import (
"crypto/ecdsa" "crypto/ecdsa"

2
internal/pkg/utils/cert/extractor.go
View File

@ -1,4 +1,4 @@
package certutil package cert
import ( import (
"encoding/pem" "encoding/pem"

2
internal/pkg/utils/cert/parser.go
View File

@ -1,4 +1,4 @@
package certutil package cert
import ( import (
"crypto" "crypto"

2
internal/pkg/utils/cert/transformer.go
View File

@ -1,4 +1,4 @@
package certutil package cert
import ( import (
"bytes" "bytes"

2
internal/pkg/utils/file/io.go
View File

@ -1,4 +1,4 @@
package fileutil package file
import ( import (
"fmt" "fmt"

2
internal/pkg/utils/http/parser.go
View File

@ -1,4 +1,4 @@
package httputil package http
import ( import (
"bufio" "bufio"

2
internal/pkg/utils/http/transport.go
View File

@ -1,4 +1,4 @@
package httputil package http
import ( import (
"net" "net"

8
internal/pkg/utils/map/getter.go → internal/pkg/utils/maps/get.go
View File

@ -1,4 +1,4 @@
package maputil package maps
import ( import (
"strconv" "strconv"
@ -103,7 +103,7 @@ func GetOrDefaultInt32(dict map[string]any, key string, defaultValue int32) int3
} }
if result != 0 { if result != 0 {
return int32(result) return result
} }
} }
@ -166,13 +166,13 @@ func GetOrDefaultInt64(dict map[string]any, key string, defaultValue int64) int6
result = int64(v) result = int64(v)
case string: case string:
// 兼容字符串类型的值 // 兼容字符串类型的值
if t, err := strconv.ParseInt(v, 10, 32); err == nil { if t, err := strconv.ParseInt(v, 10, 64); err == nil {
result = t result = t
} }
} }
if result != 0 { if result != 0 {
return int64(result) return result
} }
} }

2
internal/pkg/utils/map/marshal.go → internal/pkg/utils/maps/marshal.go
View File

@ -1,4 +1,4 @@
package maputil package maps
import ( import (
mapstructure "github.com/go-viper/mapstructure/v2" mapstructure "github.com/go-viper/mapstructure/v2"

2
internal/pkg/utils/slice/iter.go → internal/pkg/utils/slices/iter.go
View File

@ -1,4 +1,4 @@
package sliceutil package slices
// 创建给定切片一部分的浅拷贝，其包含通过所提供函数实现的测试的所有元素。 // 创建给定切片一部分的浅拷贝，其包含通过所提供函数实现的测试的所有元素。
// //

2
internal/pkg/utils/type/assert.go → internal/pkg/utils/types/assert.go
View File

@ -1,4 +1,4 @@
package typeutil package types
import ( import (
"reflect" "reflect"

2
internal/pkg/utils/type/cast.go → internal/pkg/utils/types/cast.go
View File

@ -1,4 +1,4 @@
package typeutil package types
import ( import (
"reflect" "reflect"

4
internal/workflow/dispatcher/dispatcher.go
View File

@ -14,7 +14,7 @@ import (
"github.com/usual2970/certimate/internal/app" "github.com/usual2970/certimate/internal/app"
"github.com/usual2970/certimate/internal/domain" "github.com/usual2970/certimate/internal/domain"
sliceutil "github.com/usual2970/certimate/internal/pkg/utils/slice" xslices "github.com/usual2970/certimate/internal/pkg/utils/slices"
) )
var maxWorkers = 1 var maxWorkers = 1
@ -126,7 +126,7 @@ func (d *WorkflowDispatcher) Cancel(runId string) {
// 移除排队中的 WorkflowRun // 移除排队中的 WorkflowRun
d.queueMutex.Lock() d.queueMutex.Lock()
d.queue = sliceutil.Filter(d.queue, func(d *WorkflowWorkerData) bool { d.queue = xslices.Filter(d.queue, func(d *WorkflowWorkerData) bool {
return d.RunId != runId return d.RunId != runId
}) })
d.queueMutex.Unlock() d.queueMutex.Unlock()

4
internal/workflow/node-processor/apply_node.go
View File

@ -11,7 +11,7 @@ import (
"github.com/usual2970/certimate/internal/applicant" "github.com/usual2970/certimate/internal/applicant"
"github.com/usual2970/certimate/internal/domain" "github.com/usual2970/certimate/internal/domain"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
"github.com/usual2970/certimate/internal/repository" "github.com/usual2970/certimate/internal/repository"
) )
@ -72,7 +72,7 @@ func (n *applyNode) Process(ctx context.Context) error {
} }
// 解析证书并生成实体 // 解析证书并生成实体
certX509, err := certutil.ParseCertificateFromPEM(applyResult.FullChainCertificate) certX509, err := xcert.ParseCertificateFromPEM(applyResult.FullChainCertificate)
if err != nil { if err != nil {
n.logger.Warn("failed to parse certificate, may be the CA responded error") n.logger.Warn("failed to parse certificate, may be the CA responded error")
return err return err

4
internal/workflow/node-processor/monitor_node.go
View File

@ -14,7 +14,7 @@ import (
"time" "time"
"github.com/usual2970/certimate/internal/domain" "github.com/usual2970/certimate/internal/domain"
httputil "github.com/usual2970/certimate/internal/pkg/utils/http" xhttp "github.com/usual2970/certimate/internal/pkg/utils/http"
) )
type monitorNode struct { type monitorNode struct {
@ -116,7 +116,7 @@ func (n *monitorNode) Process(ctx context.Context) error {
} }
func (n *monitorNode) tryRetrievePeerCertificates(ctx context.Context, addr, domain, requestPath string) ([]*x509.Certificate, error) { func (n *monitorNode) tryRetrievePeerCertificates(ctx context.Context, addr, domain, requestPath string) ([]*x509.Certificate, error) {
transport := httputil.NewDefaultTransport() transport := xhttp.NewDefaultTransport()
if transport.TLSClientConfig == nil { if transport.TLSClientConfig == nil {
transport.TLSClientConfig = &tls.Config{} transport.TLSClientConfig = &tls.Config{}
} }

8
migrations/1739462400_collections_snapshot.go
View File

@ -6,7 +6,7 @@ import (
"github.com/pocketbase/pocketbase/core" "github.com/pocketbase/pocketbase/core"
m "github.com/pocketbase/pocketbase/migrations" m "github.com/pocketbase/pocketbase/migrations"
certutil "github.com/usual2970/certimate/internal/pkg/utils/cert" xcert "github.com/usual2970/certimate/internal/pkg/utils/cert"
) )
func init() { func init() {
@ -1753,21 +1753,21 @@ func init() {
case "certificate": case "certificate":
{ {
if record.GetString("issuer") == "" { if record.GetString("issuer") == "" {
cert, _ := certutil.ParseCertificateFromPEM(record.GetString("certificate")) cert, _ := xcert.ParseCertificateFromPEM(record.GetString("certificate"))
if cert != nil { if cert != nil {
record.Set("issuer", strings.Join(cert.Issuer.Organization, ";")) record.Set("issuer", strings.Join(cert.Issuer.Organization, ";"))
changed = true changed = true
} }
} }
if record.GetString("serialNumber") == "" { if record.GetString("serialNumber") == "" {
cert, _ := certutil.ParseCertificateFromPEM(record.GetString("certificate")) cert, _ := xcert.ParseCertificateFromPEM(record.GetString("certificate"))
if cert != nil { if cert != nil {
record.Set("serialNumber", strings.ToUpper(cert.SerialNumber.Text(16))) record.Set("serialNumber", strings.ToUpper(cert.SerialNumber.Text(16)))
changed = true changed = true
} }
} }
if record.GetString("keyAlgorithm") == "" { if record.GetString("keyAlgorithm") == "" {
cert, _ := certutil.ParseCertificateFromPEM(record.GetString("certificate")) cert, _ := xcert.ParseCertificateFromPEM(record.GetString("certificate"))
if cert != nil { if cert != nil {
switch cert.SignatureAlgorithm { switch cert.SignatureAlgorithm {
case x509.SHA256WithRSA, x509.SHA256WithRSAPSS: case x509.SHA256WithRSA, x509.SHA256WithRSAPSS: