opensource/certimate
3
0
Fork 0
mirror of https://github.com/certimate-go/certimate.git synced 2026-09-01 15:39:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: clean code

Browse Source
This commit is contained in:
Fu Diwei
2025-11-19 20:58:50 +08:00
parent ca813e709b
commit c25458439f
269 changed files with 2122 additions and 1989 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/core/certmgr/providers/1panel-ssl/1panel_ssl.go
-236
View File
@@ -1,236 +0,0 @@
package onepanelssl
import (
"context"
"crypto/tls"
"errors"
"fmt"
"log/slog"
"strings"
"time"
"github.com/certimate-go/certimate/pkg/core/certmgr"
opsdk "github.com/certimate-go/certimate/pkg/sdk3rd/1panel"
opsdkv2 "github.com/certimate-go/certimate/pkg/sdk3rd/1panel/v2"
)
type CertmgrConfig struct {
// 1Panel 服务地址。
ServerUrl string `json:"serverUrl"`
// 1Panel 版本。
ApiVersion string `json:"apiVersion"`
// 1Panel 接口密钥。
ApiKey string `json:"apiKey"`
// 是否允许不安全的连接。
AllowInsecureConnections bool `json:"allowInsecureConnections,omitempty"`
}
type Certmgr struct {
config *CertmgrConfig
logger *slog.Logger
sdkClient any
}
var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
}
client, err := createSDKClient(config.ServerUrl, config.ApiVersion, config.ApiKey, config.AllowInsecureConnections)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
}
return &Certmgr{
config: config,
logger: slog.Default(),
sdkClient: client,
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
// 避免重复上传
if res, err := m.tryFindCert(ctx, certPEM, privkeyPEM); err != nil {
return nil, err
} else if res != nil {
m.logger.Info("ssl certificate already exists")
return res, nil
}
// 生成新证书名（需符合 1Panel 命名规则）
certName := fmt.Sprintf("certimate-%d", time.Now().UnixMilli())
// 上传证书
switch sdkClient := m.sdkClient.(type) {
case *opsdk.Client:
{
uploadWebsiteSSLReq := &opsdk.UploadWebsiteSSLRequest{
Type: "paste",
Description: certName,
Certificate: certPEM,
PrivateKey: privkeyPEM,
}
uploadWebsiteSSLResp, err := sdkClient.UploadWebsiteSSL(uploadWebsiteSSLReq)
m.logger.Debug("sdk request '1panel.UploadWebsiteSSL'", slog.Any("request", uploadWebsiteSSLReq), slog.Any("response", uploadWebsiteSSLResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.UploadWebsiteSSL': %w", err)
}
}
case *opsdkv2.Client:
{
uploadWebsiteSSLReq := &opsdkv2.UploadWebsiteSSLRequest{
Type: "paste",
Description: certName,
Certificate: certPEM,
PrivateKey: privkeyPEM,
}
uploadWebsiteSSLResp, err := sdkClient.UploadWebsiteSSL(uploadWebsiteSSLReq)
m.logger.Debug("sdk request '1panel.UploadWebsiteSSL'", slog.Any("request", uploadWebsiteSSLReq), slog.Any("response", uploadWebsiteSSLResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.UploadWebsiteSSL': %w", err)
}
}
default:
panic("sdk client is not implemented")
}
// 获取刚刚上传证书 ID
if res, err := m.tryFindCert(ctx, certPEM, privkeyPEM); err != nil {
return nil, err
} else if res == nil {
return nil, fmt.Errorf("could not find ssl certificate, may be upload failed")
} else {
return res, nil
}
}
func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
searchWebsiteSSLPageNumber := 1
searchWebsiteSSLPageSize := 100
searchWebsiteSSLItemsCount := 0
for {
select {
case <-ctx.Done():
return nil, ctx.Err()
default:
}
switch sdkClient := m.sdkClient.(type) {
case *opsdk.Client:
{
searchWebsiteSSLReq := &opsdk.SearchWebsiteSSLRequest{
Page: int32(searchWebsiteSSLPageNumber),
PageSize: int32(searchWebsiteSSLPageSize),
}
searchWebsiteSSLResp, err := sdkClient.SearchWebsiteSSL(searchWebsiteSSLReq)
m.logger.Debug("sdk request '1panel.SearchWebsiteSSL'", slog.Any("request", searchWebsiteSSLReq), slog.Any("response", searchWebsiteSSLResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.SearchWebsiteSSL': %w", err)
}
if searchWebsiteSSLResp.Data == nil {
break
}
for _, sslItem := range searchWebsiteSSLResp.Data.Items {
if strings.TrimSpace(sslItem.PEM) == strings.TrimSpace(certPEM) &&
strings.TrimSpace(sslItem.PrivateKey) == strings.TrimSpace(privkeyPEM) {
// 如果已存在相同证书，直接返回
return &certmgr.UploadResult{
CertId: fmt.Sprintf("%d", sslItem.ID),
CertName: sslItem.Description,
}, nil
}
}
searchWebsiteSSLItemsCount = int(searchWebsiteSSLResp.Data.Total)
}
case *opsdkv2.Client:
{
searchWebsiteSSLReq := &opsdkv2.SearchWebsiteSSLRequest{
Page: int32(searchWebsiteSSLPageNumber),
PageSize: int32(searchWebsiteSSLPageSize),
}
searchWebsiteSSLResp, err := sdkClient.SearchWebsiteSSL(searchWebsiteSSLReq)
m.logger.Debug("sdk request '1panel.SearchWebsiteSSL'", slog.Any("request", searchWebsiteSSLReq), slog.Any("response", searchWebsiteSSLResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.SearchWebsiteSSL': %w", err)
}
if searchWebsiteSSLResp.Data == nil {
break
}
for _, sslItem := range searchWebsiteSSLResp.Data.Items {
if strings.TrimSpace(sslItem.PEM) == strings.TrimSpace(certPEM) &&
strings.TrimSpace(sslItem.PrivateKey) == strings.TrimSpace(privkeyPEM) {
// 如果已存在相同证书，直接返回
return &certmgr.UploadResult{
CertId: fmt.Sprintf("%d", sslItem.ID),
CertName: sslItem.Description,
}, nil
}
}
searchWebsiteSSLItemsCount = int(searchWebsiteSSLResp.Data.Total)
}
default:
panic("sdk client is not implemented")
}
if searchWebsiteSSLItemsCount < searchWebsiteSSLPageSize {
break
} else {
searchWebsiteSSLPageNumber++
}
}
return nil, nil
}
const (
sdkVersionV1 = "v1"
sdkVersionV2 = "v2"
)
func createSDKClient(serverUrl, apiVersion, apiKey string, skipTlsVerify bool) (any, error) {
if apiVersion == sdkVersionV1 {
client, err := opsdk.NewClient(serverUrl, apiKey)
if err != nil {
return nil, err
}
if skipTlsVerify {
client.SetTLSConfig(&tls.Config{InsecureSkipVerify: true})
}
return client, nil
} else if apiVersion == sdkVersionV2 {
client, err := opsdkv2.NewClient(serverUrl, apiKey)
if err != nil {
return nil, err
}
if skipTlsVerify {
client.SetTLSConfig(&tls.Config{InsecureSkipVerify: true})
}
return client, nil
}
return nil, fmt.Errorf("invalid 1panel api version")
}
pkg/core/certmgr/providers/1panel/1panel.go
+316
View File
@@ -0,0 +1,316 @@
package onepanelssl
import (
"context"
"crypto/tls"
"errors"
"fmt"
"log/slog"
"strconv"
"strings"
"time"
"github.com/certimate-go/certimate/pkg/core/certmgr"
onepanelsdk "github.com/certimate-go/certimate/pkg/sdk3rd/1panel"
onepanelsdk2 "github.com/certimate-go/certimate/pkg/sdk3rd/1panel/v2"
)
type CertmgrConfig struct {
// 1Panel 服务地址。
ServerUrl string `json:"serverUrl"`
// 1Panel 版本。
ApiVersion string `json:"apiVersion"`
// 1Panel 接口密钥。
ApiKey string `json:"apiKey"`
// 是否允许不安全的连接。
AllowInsecureConnections bool `json:"allowInsecureConnections,omitempty"`
}
type Certmgr struct {
config *CertmgrConfig
logger *slog.Logger
sdkClient any
}
var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.ServerUrl, config.ApiVersion, config.ApiKey, config.AllowInsecureConnections)
if err != nil {
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
config: config,
logger: slog.Default(),
sdkClient: client,
}, nil
}
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
c.logger = slog.New(slog.DiscardHandler)
} else {
c.logger = logger
}
}
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 避免重复上传
if upres, upok, err := c.tryGetResultIfCertExists(ctx, certPEM, privkeyPEM); err != nil {
return nil, err
} else if upok {
c.logger.Info("ssl certificate already exists")
return upres, nil
}
// 生成新证书名（需符合 1Panel 命名规则）
certName := fmt.Sprintf("certimate-%d", time.Now().UnixMilli())
// 上传证书
switch sdkClient := c.sdkClient.(type) {
case *onepanelsdk.Client:
{
websiteSSLUploadReq := &onepanelsdk.WebsiteSSLUploadRequest{
Type: "paste",
Description: certName,
Certificate: certPEM,
PrivateKey: privkeyPEM,
}
websiteSSLUploadResp, err := sdkClient.WebsiteSSLUpload(websiteSSLUploadReq)
c.logger.Debug("sdk request '1panel.WebsiteSSLUpload'", slog.Any("request", websiteSSLUploadReq), slog.Any("response", websiteSSLUploadResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.WebsiteSSLUpload': %w", err)
}
}
case *onepanelsdk2.Client:
{
websiteSSLUploadReq := &onepanelsdk2.WebsiteSSLUploadRequest{
Type: "paste",
Description: certName,
Certificate: certPEM,
PrivateKey: privkeyPEM,
}
websiteSSLUploadResp, err := sdkClient.WebsiteSSLUpload(websiteSSLUploadReq)
c.logger.Debug("sdk request '1panel.WebsiteSSLUpload'", slog.Any("request", websiteSSLUploadReq), slog.Any("response", websiteSSLUploadResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.WebsiteSSLUpload': %w", err)
}
}
default:
panic("unreachable")
}
// 获取刚刚上传证书 ID
if upres, upok, err := c.tryGetResultIfCertExists(ctx, certPEM, privkeyPEM); err != nil {
return nil, err
} else if !upok {
return nil, fmt.Errorf("could not find ssl certificate, may be upload failed")
} else {
return upres, nil
}
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
sslId, err := strconv.ParseInt(certIdOrName, 10, 64)
if err != nil {
return nil, err
}
switch sdkClient := c.sdkClient.(type) {
case *onepanelsdk.Client:
{
// 获取证书详情
websiteSSLGetResp, err := sdkClient.WebsiteSSLGet(sslId)
c.logger.Debug("sdk request '1panel.WebsiteSSLGet'", slog.Int64("sslId", sslId), slog.Any("response", websiteSSLGetResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.WebsiteSSLGet': %w", err)
}
// 更新证书
websiteSSLUploadReq := &onepanelsdk.WebsiteSSLUploadRequest{
SSLID: sslId,
Type: "paste",
Description: websiteSSLGetResp.Data.Description,
Certificate: certPEM,
PrivateKey: privkeyPEM,
}
websiteSSLUploadResp, err := sdkClient.WebsiteSSLUpload(websiteSSLUploadReq)
c.logger.Debug("sdk request '1panel.WebsiteSSLUpload'", slog.Any("request", websiteSSLUploadReq), slog.Any("response", websiteSSLUploadResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.WebsiteSSLUpload': %w", err)
}
}
case *onepanelsdk2.Client:
{
// 获取证书详情
websiteSSLGetResp, err := sdkClient.WebsiteSSLGet(sslId)
c.logger.Debug("sdk request '1panel.WebsiteSSLGet'", slog.Any("sslId", sslId), slog.Any("response", websiteSSLGetResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.WebsiteSSLGet': %w", err)
}
// 更新证书
websiteSSLUploadReq := &onepanelsdk2.WebsiteSSLUploadRequest{
SSLID: sslId,
Type: "paste",
Description: websiteSSLGetResp.Data.Description,
Certificate: certPEM,
PrivateKey: privkeyPEM,
}
websiteSSLUploadResp, err := sdkClient.WebsiteSSLUpload(websiteSSLUploadReq)
c.logger.Debug("sdk request '1panel.WebsiteSSLUpload'", slog.Any("request", websiteSSLUploadReq), slog.Any("response", websiteSSLUploadResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.WebsiteSSLUpload': %w", err)
}
}
default:
panic("unreachable")
}
return &certmgr.OperateResult{}, nil
}
func (c *Certmgr) tryGetResultIfCertExists(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, bool, error) {
switch sdkClient := c.sdkClient.(type) {
case *onepanelsdk.Client:
{
searchWebsiteSSLPage := 1
searchWebsiteSSLPageSize := 100
for {
select {
case <-ctx.Done():
return nil, false, ctx.Err()
default:
}
websiteSSLSearchReq := &onepanelsdk.WebsiteSSLSearchRequest{
Page: int32(searchWebsiteSSLPage),
PageSize: int32(searchWebsiteSSLPageSize),
}
websiteSSLSearchResp, err := sdkClient.WebsiteSSLSearch(websiteSSLSearchReq)
c.logger.Debug("sdk request '1panel.WebsiteSSLSearch'", slog.Any("request", websiteSSLSearchReq), slog.Any("response", websiteSSLSearchResp))
if err != nil {
return nil, false, fmt.Errorf("failed to execute sdk request '1panel.WebsiteSSLSearch': %w", err)
}
if websiteSSLSearchResp.Data == nil {
break
}
for _, sslItem := range websiteSSLSearchResp.Data.Items {
oldCertPEM := strings.TrimSpace(strings.ReplaceAll(strings.ReplaceAll(sslItem.PEM, "\r", ""), "\n", ""))
oldPrivkeyPEM := strings.TrimSpace(strings.ReplaceAll(strings.ReplaceAll(sslItem.PrivateKey, "\r", ""), "\n", ""))
newCertPEM := strings.TrimSpace(strings.ReplaceAll(strings.ReplaceAll(certPEM, "\r", ""), "\n", ""))
newPrivkeyPEM := strings.TrimSpace(strings.ReplaceAll(strings.ReplaceAll(privkeyPEM, "\r", ""), "\n", ""))
if oldCertPEM == newCertPEM && oldPrivkeyPEM == newPrivkeyPEM {
// 如果已存在相同证书，直接返回
return &certmgr.UploadResult{
CertId: fmt.Sprintf("%d", sslItem.ID),
CertName: sslItem.Description,
}, true, nil
}
}
if len(websiteSSLSearchResp.Data.Items) < int(websiteSSLSearchResp.Data.Total) {
break
}
searchWebsiteSSLPage++
}
}
case *onepanelsdk2.Client:
{
searchWebsiteSSLPage := 1
searchWebsiteSSLPageSize := 100
for {
select {
case <-ctx.Done():
return nil, false, ctx.Err()
default:
}
websiteSSLSearchReq := &onepanelsdk2.WebsiteSSLSearchRequest{
Page: int32(searchWebsiteSSLPage),
PageSize: int32(searchWebsiteSSLPageSize),
}
websiteSSLSearchResp, err := sdkClient.WebsiteSSLSearch(websiteSSLSearchReq)
c.logger.Debug("sdk request '1panel.WebsiteSSLSearch'", slog.Any("request", websiteSSLSearchReq), slog.Any("response", websiteSSLSearchResp))
if err != nil {
return nil, false, fmt.Errorf("failed to execute sdk request '1panel.WebsiteSSLSearch': %w", err)
}
if websiteSSLSearchResp.Data == nil {
break
}
for _, sslItem := range websiteSSLSearchResp.Data.Items {
oldCertPEM := strings.TrimSpace(strings.ReplaceAll(strings.ReplaceAll(sslItem.PEM, "\r", ""), "\n", ""))
oldPrivkeyPEM := strings.TrimSpace(strings.ReplaceAll(strings.ReplaceAll(sslItem.PrivateKey, "\r", ""), "\n", ""))
newCertPEM := strings.TrimSpace(strings.ReplaceAll(strings.ReplaceAll(certPEM, "\r", ""), "\n", ""))
newPrivkeyPEM := strings.TrimSpace(strings.ReplaceAll(strings.ReplaceAll(privkeyPEM, "\r", ""), "\n", ""))
if oldCertPEM == newCertPEM && oldPrivkeyPEM == newPrivkeyPEM {
// 如果已存在相同证书，直接返回
return &certmgr.UploadResult{
CertId: fmt.Sprintf("%d", sslItem.ID),
CertName: sslItem.Description,
}, true, nil
}
}
if len(websiteSSLSearchResp.Data.Items) < int(websiteSSLSearchResp.Data.Total) {
break
}
searchWebsiteSSLPage++
}
}
default:
panic("unreachable")
}
return nil, false, nil
}
const (
sdkVersionV1 = "v1"
sdkVersionV2 = "v2"
)
func createSDKClient(serverUrl, apiVersion, apiKey string, skipTlsVerify bool) (any, error) {
if apiVersion == sdkVersionV1 {
client, err := onepanelsdk.NewClient(serverUrl, apiKey)
if err != nil {
return nil, err
}
if skipTlsVerify {
client.SetTLSConfig(&tls.Config{InsecureSkipVerify: true})
}
return client, nil
} else if apiVersion == sdkVersionV2 {
client, err := onepanelsdk2.NewClient(serverUrl, apiKey)
if err != nil {
return nil, err
}
if skipTlsVerify {
client.SetTLSConfig(&tls.Config{InsecureSkipVerify: true})
}
return client, nil
}
return nil, fmt.Errorf("invalid 1panel api version")
}
pkg/core/certmgr/providers/1panel-ssl/1panel_ssl_test.go → pkg/core/certmgr/providers/1panel/1panel_test.go
+8 -8
View File
@@ -9,7 +9,7 @@ import (
"strings"
"testing"
provider "github.com/certimate-go/certimate/pkg/core/certmgr/providers/1panel-ssl"
provider "github.com/certimate-go/certimate/pkg/core/certmgr/providers/1panel"
)
var (
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_1PANELSSL_"
argsPrefix := "1PANEL_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -33,12 +33,12 @@ func init() {
/*
Shell command to run this test:
go test -v ./1panel_ssl_test.go -args \
--CERTIMATE_SSLMANAGER_1PANELSSL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_1PANELSSL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_1PANELSSL_SERVERURL="http://127.0.0.1:20410" \
--CERTIMATE_SSLMANAGER_1PANELSSL_APIVERSION="v1" \
--CERTIMATE_SSLMANAGER_1PANELSSL_APIKEY="your-api-key"
go test -v ./1panel_test.go -args \
--1PANEL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--1PANEL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--1PANEL_SERVERURL="http://127.0.0.1:20410" \
--1PANEL_APIVERSION="v1" \
--1PANEL_APIKEY="your-api-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/aliyun-cas/aliyun_cas.go
+21 -17
View File
@@ -40,12 +40,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -55,15 +55,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -83,13 +83,13 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
listUserCertificateOrderReq := &alicas.ListUserCertificateOrderRequest{
ResourceGroupId: lo.EmptyableToPtr(m.config.ResourceGroupId),
ResourceGroupId: lo.EmptyableToPtr(c.config.ResourceGroupId),
CurrentPage: tea.Int64(int64(listUserCertificateOrderPage)),
ShowSize: tea.Int64(int64(listUserCertificateOrderLimit)),
OrderType: tea.String("CERT"),
}
listUserCertificateOrderResp, err := m.sdkClient.ListUserCertificateOrderWithContext(ctx, listUserCertificateOrderReq, &dara.RuntimeOptions{})
m.logger.Debug("sdk request 'cas.ListUserCertificateOrder'", slog.Any("request", listUserCertificateOrderReq), slog.Any("response", listUserCertificateOrderResp))
listUserCertificateOrderResp, err := c.sdkClient.ListUserCertificateOrderWithContext(ctx, listUserCertificateOrderReq, &dara.RuntimeOptions{})
c.logger.Debug("sdk request 'cas.ListUserCertificateOrder'", slog.Any("request", listUserCertificateOrderReq), slog.Any("response", listUserCertificateOrderResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cas.ListUserCertificateOrder': %w", err)
}
@@ -116,8 +116,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
getUserCertificateDetailReq := &alicas.GetUserCertificateDetailRequest{
CertId: certItem.CertificateId,
}
getUserCertificateDetailResp, err := m.sdkClient.GetUserCertificateDetailWithContext(ctx, getUserCertificateDetailReq, &dara.RuntimeOptions{})
m.logger.Debug("sdk request 'cas.GetUserCertificateDetail'", slog.Any("request", getUserCertificateDetailReq), slog.Any("response", getUserCertificateDetailResp))
getUserCertificateDetailResp, err := c.sdkClient.GetUserCertificateDetailWithContext(ctx, getUserCertificateDetailReq, &dara.RuntimeOptions{})
c.logger.Debug("sdk request 'cas.GetUserCertificateDetail'", slog.Any("request", getUserCertificateDetailReq), slog.Any("response", getUserCertificateDetailResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cas.GetUserCertificateDetail': %w", err)
} else {
@@ -127,7 +127,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: fmt.Sprintf("%d", tea.Int64Value(certItem.CertificateId)),
CertName: *certItem.Name,
@@ -151,13 +151,13 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// 上传新证书
// REF: https://help.aliyun.com/zh/ssl-certificate/developer-reference/api-cas-2020-04-07-uploadusercertificate
uploadUserCertificateReq := &alicas.UploadUserCertificateRequest{
ResourceGroupId: lo.EmptyableToPtr(m.config.ResourceGroupId),
ResourceGroupId: lo.EmptyableToPtr(c.config.ResourceGroupId),
Name: tea.String(certName),
Cert: tea.String(certPEM),
Key: tea.String(privkeyPEM),
}
uploadUserCertificateResp, err := m.sdkClient.UploadUserCertificateWithContext(ctx, uploadUserCertificateReq, &dara.RuntimeOptions{})
m.logger.Debug("sdk request 'cas.UploadUserCertificate'", slog.Any("request", uploadUserCertificateReq), slog.Any("response", uploadUserCertificateResp))
uploadUserCertificateResp, err := c.sdkClient.UploadUserCertificateWithContext(ctx, uploadUserCertificateReq, &dara.RuntimeOptions{})
c.logger.Debug("sdk request 'cas.UploadUserCertificate'", slog.Any("request", uploadUserCertificateReq), slog.Any("response", uploadUserCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cas.UploadUserCertificate': %w", err)
}
@@ -168,8 +168,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
CertId: uploadUserCertificateResp.Body.CertId,
CertFilter: tea.Bool(true),
}
getUserCertificateDetailResp, err := m.sdkClient.GetUserCertificateDetailWithContext(ctx, getUserCertificateDetailReq, &dara.RuntimeOptions{})
m.logger.Debug("sdk request 'cas.GetUserCertificateDetail'", slog.Any("request", getUserCertificateDetailReq), slog.Any("response", getUserCertificateDetailResp))
getUserCertificateDetailResp, err := c.sdkClient.GetUserCertificateDetailWithContext(ctx, getUserCertificateDetailReq, &dara.RuntimeOptions{})
c.logger.Debug("sdk request 'cas.GetUserCertificateDetail'", slog.Any("request", getUserCertificateDetailReq), slog.Any("response", getUserCertificateDetailResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cas.GetUserCertificateDetail': %w", err)
}
@@ -184,6 +184,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, accessKeySecret, region string) (*internal.CasClient, error) {
// 接入点一览 https://api.aliyun.com/product/cas
var endpoint string
pkg/core/certmgr/providers/aliyun-cas/aliyun_cas_test.go
+6 -6
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_ALIYUNCAS_"
argsPrefix := "ALIYUNCAS_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -34,11 +34,11 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_cas_test.go -args \
--CERTIMATE_SSLMANAGER_ALIYUNCAS_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_ALIYUNCAS_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_ALIYUNCAS_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_ALIYUNCAS_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLMANAGER_ALIYUNCAS_REGION="cn-hangzhou"
--ALIYUNCAS_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNCAS_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNCAS_ACCESSKEYID="your-access-key-id" \
--ALIYUNCAS_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNCAS_REGION="cn-hangzhou"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/aliyun-slb/aliyun_slb.go
+19 -15
View File
@@ -42,12 +42,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -57,15 +57,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -75,11 +75,11 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// 查询证书列表，避免重复上传
// REF: https://help.aliyun.com/zh/slb/classic-load-balancer/developer-reference/api-slb-2014-05-15-describeservercertificates
describeServerCertificatesReq := &alislb.DescribeServerCertificatesRequest{
ResourceGroupId: lo.EmptyableToPtr(m.config.ResourceGroupId),
RegionId: tea.String(m.config.Region),
ResourceGroupId: lo.EmptyableToPtr(c.config.ResourceGroupId),
RegionId: tea.String(c.config.Region),
}
describeServerCertificatesResp, err := m.sdkClient.DescribeServerCertificates(describeServerCertificatesReq)
m.logger.Debug("sdk request 'slb.DescribeServerCertificates'", slog.Any("request", describeServerCertificatesReq), slog.Any("response", describeServerCertificatesResp))
describeServerCertificatesResp, err := c.sdkClient.DescribeServerCertificates(describeServerCertificatesReq)
c.logger.Debug("sdk request 'slb.DescribeServerCertificates'", slog.Any("request", describeServerCertificatesReq), slog.Any("response", describeServerCertificatesResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'slb.DescribeServerCertificates': %w", err)
}
@@ -99,7 +99,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: *certItem.ServerCertificateId,
CertName: *certItem.ServerCertificateName,
@@ -119,14 +119,14 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// 上传新证书
// REF: https://help.aliyun.com/zh/slb/classic-load-balancer/developer-reference/api-slb-2014-05-15-uploadservercertificate
uploadServerCertificateReq := &alislb.UploadServerCertificateRequest{
ResourceGroupId: lo.EmptyableToPtr(m.config.ResourceGroupId),
RegionId: tea.String(m.config.Region),
ResourceGroupId: lo.EmptyableToPtr(c.config.ResourceGroupId),
RegionId: tea.String(c.config.Region),
ServerCertificateName: tea.String(certName),
ServerCertificate: tea.String(certPEM),
PrivateKey: tea.String(privkeyPEM),
}
uploadServerCertificateResp, err := m.sdkClient.UploadServerCertificate(uploadServerCertificateReq)
m.logger.Debug("sdk request 'slb.UploadServerCertificate'", slog.Any("request", uploadServerCertificateReq), slog.Any("response", uploadServerCertificateResp))
uploadServerCertificateResp, err := c.sdkClient.UploadServerCertificate(uploadServerCertificateReq)
c.logger.Debug("sdk request 'slb.UploadServerCertificate'", slog.Any("request", uploadServerCertificateReq), slog.Any("response", uploadServerCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'slb.UploadServerCertificate': %w", err)
}
@@ -137,6 +137,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, accessKeySecret, region string) (*internal.SlbClient, error) {
// 接入点一览 https://api.aliyun.com/product/Slb
var endpoint string
pkg/core/certmgr/providers/aliyun-slb/aliyun_slb_test.go
+6 -6
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_ALIYUNSLB_"
argsPrefix := "ALIYUNSLB_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -34,11 +34,11 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_slb_test.go -args \
--CERTIMATE_SSLMANAGER_ALIYUNSLB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_ALIYUNSLB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_ALIYUNSLB_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_ALIYUNSLB_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLMANAGER_ALIYUNSLB_REGION="cn-hangzhou"
--ALIYUNSLB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNSLB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNSLB_ACCESSKEYID="your-access-key-id" \
--ALIYUNSLB_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNSLB_REGION="cn-hangzhou"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/aws-acm/aws_acm.go
+15 -15
View File
@@ -35,12 +35,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -50,15 +50,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -86,8 +86,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
NextToken: listCertificatesNextToken,
MaxItems: aws.Int32(1000),
}
listCertificatesResp, err := m.sdkClient.ListCertificates(ctx, listCertificatesReq)
m.logger.Debug("sdk request 'acm.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
listCertificatesResp, err := c.sdkClient.ListCertificates(ctx, listCertificatesReq)
c.logger.Debug("sdk request 'acm.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'acm.ListCertificates': %w", err)
}
@@ -110,7 +110,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
getCertificateReq := &awsacm.GetCertificateInput{
CertificateArn: certItem.CertificateArn,
}
getCertificateResp, err := m.sdkClient.GetCertificate(ctx, getCertificateReq)
getCertificateResp, err := c.sdkClient.GetCertificate(ctx, getCertificateReq)
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'acm.GetCertificate': %w", err)
} else {
@@ -120,7 +120,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: *certItem.CertificateArn,
}, nil
@@ -140,8 +140,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
CertificateChain: ([]byte)(intermediaCertPEM),
PrivateKey: ([]byte)(privkeyPEM),
}
importCertificateResp, err := m.sdkClient.ImportCertificate(ctx, importCertificateReq)
m.logger.Debug("sdk request 'acm.ImportCertificate'", slog.Any("request", importCertificateReq), slog.Any("response", importCertificateResp))
importCertificateResp, err := c.sdkClient.ImportCertificate(ctx, importCertificateReq)
c.logger.Debug("sdk request 'acm.ImportCertificate'", slog.Any("request", importCertificateReq), slog.Any("response", importCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'acm.ImportCertificate': %w", err)
}
@@ -151,7 +151,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
}, nil
}
func (m *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
// 提取服务器证书
serverCertPEM, intermediaCertPEM, err := xcert.ExtractCertificatesFromPEM(certPEM)
if err != nil {
@@ -166,8 +166,8 @@ func (m *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, pri
CertificateChain: ([]byte)(intermediaCertPEM),
PrivateKey: ([]byte)(privkeyPEM),
}
importCertificateResp, err := m.sdkClient.ImportCertificate(ctx, importCertificateReq)
m.logger.Debug("sdk request 'acm.ImportCertificate'", slog.Any("request", importCertificateReq), slog.Any("response", importCertificateResp))
importCertificateResp, err := c.sdkClient.ImportCertificate(ctx, importCertificateReq)
c.logger.Debug("sdk request 'acm.ImportCertificate'", slog.Any("request", importCertificateReq), slog.Any("response", importCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'acm.ImportCertificate': %w", err)
}
pkg/core/certmgr/providers/aws-iam/aws_iam.go
+21 -17
View File
@@ -38,12 +38,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -53,15 +53,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -89,18 +89,18 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
Marker: listServerCertificatesMarker,
MaxItems: aws.Int32(1000),
}
if m.config.CertificatePath != "" {
listServerCertificatesReq.PathPrefix = aws.String(m.config.CertificatePath)
if c.config.CertificatePath != "" {
listServerCertificatesReq.PathPrefix = aws.String(c.config.CertificatePath)
}
listServerCertificatesResp, err := m.sdkClient.ListServerCertificates(ctx, listServerCertificatesReq)
m.logger.Debug("sdk request 'iam.ListServerCertificates'", slog.Any("request", listServerCertificatesReq), slog.Any("response", listServerCertificatesResp))
listServerCertificatesResp, err := c.sdkClient.ListServerCertificates(ctx, listServerCertificatesReq)
c.logger.Debug("sdk request 'iam.ListServerCertificates'", slog.Any("request", listServerCertificatesReq), slog.Any("response", listServerCertificatesResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'iam.ListServerCertificates': %w", err)
}
for _, certItem := range listServerCertificatesResp.ServerCertificateMetadataList {
// 对比证书路径
if m.config.CertificatePath != "" && aws.ToString(certItem.Path) != m.config.CertificatePath {
if c.config.CertificatePath != "" && aws.ToString(certItem.Path) != c.config.CertificatePath {
continue
}
@@ -113,7 +113,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
getServerCertificateReq := &awsiam.GetServerCertificateInput{
ServerCertificateName: certItem.ServerCertificateName,
}
getServerCertificateResp, err := m.sdkClient.GetServerCertificate(ctx, getServerCertificateReq)
getServerCertificateResp, err := c.sdkClient.GetServerCertificate(ctx, getServerCertificateReq)
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'iam.GetServerCertificate': %w", err)
} else {
@@ -123,7 +123,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: aws.ToString(certItem.ServerCertificateId),
CertName: aws.ToString(certItem.ServerCertificateName),
@@ -144,16 +144,16 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// REF: https://docs.aws.amazon.com/en_us/IAM/latest/APIReference/API_UploadServerCertificate.html
uploadServerCertificateReq := &awsiam.UploadServerCertificateInput{
ServerCertificateName: aws.String(certName),
Path: aws.String(m.config.CertificatePath),
Path: aws.String(c.config.CertificatePath),
CertificateBody: aws.String(serverCertPEM),
CertificateChain: aws.String(intermediaCertPEM),
PrivateKey: aws.String(privkeyPEM),
}
if m.config.CertificatePath == "" {
if c.config.CertificatePath == "" {
uploadServerCertificateReq.Path = aws.String("/")
}
uploadServerCertificateResp, err := m.sdkClient.UploadServerCertificate(ctx, uploadServerCertificateReq)
m.logger.Debug("sdk request 'iam.UploadServerCertificate'", slog.Any("request", uploadServerCertificateReq), slog.Any("response", uploadServerCertificateResp))
uploadServerCertificateResp, err := c.sdkClient.UploadServerCertificate(ctx, uploadServerCertificateReq)
c.logger.Debug("sdk request 'iam.UploadServerCertificate'", slog.Any("request", uploadServerCertificateReq), slog.Any("response", uploadServerCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'iam.UploadServerCertificate': %w", err)
}
@@ -164,6 +164,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, secretAccessKey, region string) (*awsiam.Client, error) {
cfg, err := awscfg.LoadDefaultConfig(context.Background())
if err != nil {
pkg/core/certmgr/providers/azure-keyvault/azure_keyvault.go
+17 -17
View File
@@ -41,12 +41,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.TenantId, config.ClientId, config.ClientSecret, config.CloudName, config.KeyVaultName)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -56,15 +56,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -79,7 +79,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
// 获取证书列表，避免重复上传
// REF: https://learn.microsoft.com/en-us/rest/api/keyvault/certificates/get-certificates/get-certificates
listCertificatesPager := m.sdkClient.NewListCertificatePropertiesPager(nil)
listCertificatesPager := c.sdkClient.NewListCertificatePropertiesPager(nil)
for listCertificatesPager.More() {
page, err := listCertificatesPager.NextPage(context.TODO())
if err != nil {
@@ -113,8 +113,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
}
// 对比证书内容
getCertificateResp, err := m.sdkClient.GetCertificate(ctx, certItem.ID.Name(), certItem.ID.Version(), nil)
m.logger.Debug("sdk request 'keyvault.GetCertificate'", slog.String("request.certificateName", certItem.ID.Name()), slog.String("request.certificateVersion", certItem.ID.Version()), slog.Any("response", getCertificateResp))
getCertificateResp, err := c.sdkClient.GetCertificate(ctx, certItem.ID.Name(), certItem.ID.Version(), nil)
c.logger.Debug("sdk request 'keyvault.GetCertificate'", slog.String("request.certificateName", certItem.ID.Name()), slog.String("request.certificateVersion", certItem.ID.Version()), slog.Any("response", getCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'keyvault.GetCertificate': %w", err)
} else {
@@ -124,7 +124,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: string(*certItem.ID),
CertName: certItem.ID.Name(),
@@ -157,8 +157,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
TAG_CERTSN: to.Ptr(certSN),
},
}
importCertificateResp, err := m.sdkClient.ImportCertificate(ctx, certName, importCertificateParams, nil)
m.logger.Debug("sdk request 'keyvault.ImportCertificate'", slog.String("request.certificateName", certName), slog.Any("request.parameters", importCertificateParams), slog.Any("response", importCertificateResp))
importCertificateResp, err := c.sdkClient.ImportCertificate(ctx, certName, importCertificateParams, nil)
c.logger.Debug("sdk request 'keyvault.ImportCertificate'", slog.String("request.certificateName", certName), slog.Any("request.parameters", importCertificateParams), slog.Any("response", importCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'keyvault.ImportCertificate': %w", err)
}
@@ -169,7 +169,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
}, nil
}
func (m *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -184,8 +184,8 @@ func (m *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, pri
// 获取证书
// REF: https://learn.microsoft.com/en-us/rest/api/keyvault/certificates/get-certificate/get-certificate
getCertificateResp, err := m.sdkClient.GetCertificate(ctx, certIdOrName, "", nil)
m.logger.Debug("sdk request 'keyvault.GetCertificate'", slog.String("request.certificateName", certIdOrName), slog.Any("response", getCertificateResp))
getCertificateResp, err := c.sdkClient.GetCertificate(ctx, certIdOrName, "", nil)
c.logger.Debug("sdk request 'keyvault.GetCertificate'", slog.String("request.certificateName", certIdOrName), slog.Any("response", getCertificateResp))
if err != nil {
var respErr *azcore.ResponseError
if !errors.As(err, &respErr) || (respErr.ErrorCode != "ResourceNotFound" && respErr.ErrorCode != "CertificateNotFound") {
@@ -212,8 +212,8 @@ func (m *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, pri
"certimate/cert-sn": to.Ptr(certX509.SerialNumber.Text(16)),
},
}
importCertificateResp, err := m.sdkClient.ImportCertificate(ctx, certIdOrName, importCertificateParams, nil)
m.logger.Debug("sdk request 'keyvault.ImportCertificate'", slog.String("request.certificateName", certIdOrName), slog.Any("request.parameters", importCertificateParams), slog.Any("response", importCertificateResp))
importCertificateResp, err := c.sdkClient.ImportCertificate(ctx, certIdOrName, importCertificateParams, nil)
c.logger.Debug("sdk request 'keyvault.ImportCertificate'", slog.String("request.certificateName", certIdOrName), slog.Any("request.parameters", importCertificateParams), slog.Any("response", importCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'keyvault.ImportCertificate': %w", err)
}
pkg/core/certmgr/providers/azure-keyvault/azure_keyvault_test.go
+8 -8
View File
@@ -23,7 +23,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_AZUREKEYVAULT_"
argsPrefix := "AZUREKEYVAULT_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -38,13 +38,13 @@ func init() {
Shell command to run this test:
go test -v ./azure_keyvault_test.go -args \
--CERTIMATE_SSLMANAGER_AZUREKEYVAULT_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_AZUREKEYVAULT_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_AZUREKEYVAULT_TENANTID="your-tenant-id" \
--CERTIMATE_SSLMANAGER_AZUREKEYVAULT_CLIENTID="your-app-registration-client-id" \
--CERTIMATE_SSLMANAGER_AZUREKEYVAULT_CLIENTSECRET="your-app-registration-client-secret" \
--CERTIMATE_SSLMANAGER_AZUREKEYVAULT_CLOUDNAME="china" \
--CERTIMATE_SSLMANAGER_AZUREKEYVAULT_KEYVAULTNAME="your-keyvault-name"
--AZUREKEYVAULT_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--AZUREKEYVAULT_INPUTKEYPATH="/path/to/your-input-key.pem" \
--AZUREKEYVAULT_TENANTID="your-tenant-id" \
--AZUREKEYVAULT_CLIENTID="your-app-registration-client-id" \
--AZUREKEYVAULT_CLIENTSECRET="your-app-registration-client-secret" \
--AZUREKEYVAULT_CLOUDNAME="china" \
--AZUREKEYVAULT_KEYVAULTNAME="your-keyvault-name"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/baiducloud-cert/baiducloud_cert.go
+22 -18
View File
@@ -9,7 +9,7 @@ import (
"time"
"github.com/certimate-go/certimate/pkg/core/certmgr"
bdsdk "github.com/certimate-go/certimate/pkg/sdk3rd/baiducloud/cert"
baiducert "github.com/certimate-go/certimate/pkg/sdk3rd/baiducloud/cert"
xcert "github.com/certimate-go/certimate/pkg/utils/cert"
)
@@ -23,19 +23,19 @@ type CertmgrConfig struct {
type Certmgr struct {
config *CertmgrConfig
logger *slog.Logger
sdkClient *bdsdk.Client
sdkClient *baiducert.Client
}
var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -45,15 +45,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -62,8 +62,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// 查看证书列表
// REF: https://cloud.baidu.com/doc/Reference/s/Gjwvz27xu#35-%E6%9F%A5%E7%9C%8B%E8%AF%81%E4%B9%A6%E5%88%97%E8%A1%A8%E8%AF%A6%E6%83%85
listCertDetail, err := m.sdkClient.ListCertDetail()
m.logger.Debug("sdk request 'cert.ListCertDetail'", slog.Any("response", listCertDetail))
listCertDetail, err := c.sdkClient.ListCertDetail()
c.logger.Debug("sdk request 'cert.ListCertDetail'", slog.Any("response", listCertDetail))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cert.ListCertDetail': %w", err)
} else {
@@ -86,8 +86,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 对比证书内容
getCertDetailResp, err := m.sdkClient.GetCertRawData(certItem.CertId)
m.logger.Debug("sdk request 'cert.GetCertRawData'", slog.Any("certId", certItem.CertId), slog.Any("response", getCertDetailResp))
getCertDetailResp, err := c.sdkClient.GetCertRawData(certItem.CertId)
c.logger.Debug("sdk request 'cert.GetCertRawData'", slog.Any("certId", certItem.CertId), slog.Any("response", getCertDetailResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cert.GetCertRawData': %w", err)
} else {
@@ -97,7 +97,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: certItem.CertId,
CertName: certItem.CertName,
@@ -107,12 +107,12 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// 创建证书
// REF: https://cloud.baidu.com/doc/Reference/s/Gjwvz27xu#31-%E5%88%9B%E5%BB%BA%E8%AF%81%E4%B9%A6
createCertReq := &bdsdk.CreateCertArgs{}
createCertReq := &baiducert.CreateCertArgs{}
createCertReq.CertName = fmt.Sprintf("certimate-%d", time.Now().UnixMilli())
createCertReq.CertServerData = certPEM
createCertReq.CertPrivateData = privkeyPEM
createCertResp, err := m.sdkClient.CreateCert(createCertReq)
m.logger.Debug("sdk request 'cert.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
createCertResp, err := c.sdkClient.CreateCert(createCertReq)
c.logger.Debug("sdk request 'cert.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cert.CreateCert': %w", err)
}
@@ -123,8 +123,12 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func createSDKClient(accessKeyId, secretAccessKey string) (*bdsdk.Client, error) {
client, err := bdsdk.NewClient(accessKeyId, secretAccessKey, "")
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, secretAccessKey string) (*baiducert.Client, error) {
client, err := baiducert.NewClient(accessKeyId, secretAccessKey, "")
if err != nil {
return nil, err
}
pkg/core/certmgr/providers/baiducloud-cert/baiducloud_cert_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_BAIDUCLOUDCERT_"
argsPrefix := "BAIDUCLOUDCERT_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./baiducloud_cert_test.go -args \
--CERTIMATE_SSLMANAGER_BAIDUCLOUDCERT_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_BAIDUCLOUDCERT_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_BAIDUCLOUDCERT_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_BAIDUCLOUDCERT_SECRETACCESSKEY="your-access-key-secret"
--BAIDUCLOUDCERT_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--BAIDUCLOUDCERT_INPUTKEYPATH="/path/to/your-input-key.pem" \
--BAIDUCLOUDCERT_ACCESSKEYID="your-access-key-id" \
--BAIDUCLOUDCERT_SECRETACCESSKEY="your-access-key-secret"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/baishan-cdn/baishan_cdn.go
+2 -2
View File
@@ -30,12 +30,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.ApiToken)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
pkg/core/certmgr/providers/baishan-cdn/baishan_cdn_test.go
+4 -4
View File
@@ -18,7 +18,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_BAISHANCDN_"
argsPrefix := "BAISHANCDN_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -29,9 +29,9 @@ func init() {
Shell command to run this test:
go test -v ./baishan_cdn_test.go -args \
--CERTIMATE_SSLMANAGER_BAISHANCDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_BAISHANCDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_BAISHANCDN_APITOKEN="your-api-token"
--BAISHANCDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--BAISHANCDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--BAISHANCDN_APITOKEN="your-api-token"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/byteplus-cdn/byteplus_cdn.go
+14 -10
View File
@@ -34,7 +34,7 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client := bytepluscdn.NewInstance()
@@ -48,15 +48,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -79,8 +79,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
PageSize: bytepluscdn.GetInt64Ptr(int64(listCertInfoPageSize)),
Source: bytepluscdn.GetStrPtr("cert_center"),
}
listCertInfoResp, err := m.sdkClient.ListCertInfo(listCertInfoReq)
m.logger.Debug("sdk request 'cdn.ListCertInfo'", slog.Any("request", listCertInfoReq), slog.Any("response", listCertInfoResp))
listCertInfoResp, err := c.sdkClient.ListCertInfo(listCertInfoReq)
c.logger.Debug("sdk request 'cdn.ListCertInfo'", slog.Any("request", listCertInfoReq), slog.Any("response", listCertInfoResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cdn.ListCertInfo': %w", err)
}
@@ -99,7 +99,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: certItem.CertId,
CertName: certItem.Desc,
@@ -124,8 +124,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
Source: bytepluscdn.GetStrPtr("cert_center"),
Desc: bytepluscdn.GetStrPtr(certName),
}
addCertificateResp, err := m.sdkClient.AddCertificate(addCertificateReq)
m.logger.Debug("sdk request 'cdn.AddCertificate'", slog.Any("request", addCertificateReq), slog.Any("response", addCertificateResp))
addCertificateResp, err := c.sdkClient.AddCertificate(addCertificateReq)
c.logger.Debug("sdk request 'cdn.AddCertificate'", slog.Any("request", addCertificateReq), slog.Any("response", addCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cdn.AddCertificate': %w", err)
}
@@ -135,3 +135,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
CertName: certName,
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
pkg/core/certmgr/providers/ctcccloud-ao/ctcccloud_ao.go
+17 -13
View File
@@ -33,12 +33,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -48,15 +48,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -80,8 +80,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
PerPage: lo.ToPtr(int32(listCertPerPage)),
UsageMode: lo.ToPtr(int32(0)),
}
listCertsResp, err := m.sdkClient.ListCerts(listCertsReq)
m.logger.Debug("sdk request 'ao.ListCerts'", slog.Any("request", listCertsReq), slog.Any("response", listCertsResp))
listCertsResp, err := c.sdkClient.ListCerts(listCertsReq)
c.logger.Debug("sdk request 'ao.ListCerts'", slog.Any("request", listCertsReq), slog.Any("response", listCertsResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'ao.ListCerts': %w", err)
}
@@ -112,8 +112,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
queryCertReq := &ctyunao.QueryCertRequest{
Id: lo.ToPtr(certItem.Id),
}
queryCertResp, err := m.sdkClient.QueryCert(queryCertReq)
m.logger.Debug("sdk request 'ao.QueryCert'", slog.Any("request", queryCertReq), slog.Any("response", queryCertResp))
queryCertResp, err := c.sdkClient.QueryCert(queryCertReq)
c.logger.Debug("sdk request 'ao.QueryCert'", slog.Any("request", queryCertReq), slog.Any("response", queryCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'ao.QueryCert': %w", err)
} else if queryCertResp.ReturnObj != nil && queryCertResp.ReturnObj.Result != nil {
@@ -123,7 +123,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: fmt.Sprintf("%d", queryCertResp.ReturnObj.Result.Id),
CertName: queryCertResp.ReturnObj.Result.Name,
@@ -147,8 +147,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
Certs: lo.ToPtr(certPEM),
Key: lo.ToPtr(privkeyPEM),
}
createCertResp, err := m.sdkClient.CreateCert(createCertReq)
m.logger.Debug("sdk request 'ao.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
createCertResp, err := c.sdkClient.CreateCert(createCertReq)
c.logger.Debug("sdk request 'ao.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'ao.CreateCert': %w", err)
}
@@ -159,6 +159,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, secretAccessKey string) (*ctyunao.Client, error) {
return ctyunao.NewClient(accessKeyId, secretAccessKey)
}
pkg/core/certmgr/providers/ctcccloud-ao/ctcccloud_ao_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_CTCCCLOUDAO_"
argsPrefix := "CTCCCLOUDAO_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./ctcccloud_ao_test.go -args \
--CERTIMATE_SSLMANAGER_CTCCCLOUDAO_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDAO_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDAO_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDAO_SECRETACCESSKEY="your-secret-access-key"
--CTCCCLOUDAO_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CTCCCLOUDAO_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CTCCCLOUDAO_ACCESSKEYID="your-access-key-id" \
--CTCCCLOUDAO_SECRETACCESSKEY="your-secret-access-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/ctcccloud-cdn/ctcccloud_cdn.go
+17 -13
View File
@@ -33,12 +33,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -48,15 +48,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -80,8 +80,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
PerPage: lo.ToPtr(int32(queryCertListPerPage)),
UsageMode: lo.ToPtr(int32(0)),
}
queryCertListResp, err := m.sdkClient.QueryCertList(queryCertListReq)
m.logger.Debug("sdk request 'cdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp))
queryCertListResp, err := c.sdkClient.QueryCertList(queryCertListReq)
c.logger.Debug("sdk request 'cdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cdn.QueryCertList': %w", err)
}
@@ -112,8 +112,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
queryCertDetailReq := &ctyuncdn.QueryCertDetailRequest{
Id: lo.ToPtr(certItem.Id),
}
queryCertDetailResp, err := m.sdkClient.QueryCertDetail(queryCertDetailReq)
m.logger.Debug("sdk request 'cdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp))
queryCertDetailResp, err := c.sdkClient.QueryCertDetail(queryCertDetailReq)
c.logger.Debug("sdk request 'cdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cdn.QueryCertDetail': %w", err)
} else if queryCertDetailResp.ReturnObj != nil && queryCertDetailResp.ReturnObj.Result != nil {
@@ -123,7 +123,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: fmt.Sprintf("%d", queryCertDetailResp.ReturnObj.Result.Id),
CertName: queryCertDetailResp.ReturnObj.Result.Name,
@@ -147,8 +147,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
Certs: lo.ToPtr(certPEM),
Key: lo.ToPtr(privkeyPEM),
}
createCertResp, err := m.sdkClient.CreateCert(createCertReq)
m.logger.Debug("sdk request 'cdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
createCertResp, err := c.sdkClient.CreateCert(createCertReq)
c.logger.Debug("sdk request 'cdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cdn.CreateCert': %w", err)
}
@@ -159,6 +159,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, secretAccessKey string) (*ctyuncdn.Client, error) {
return ctyuncdn.NewClient(accessKeyId, secretAccessKey)
}
pkg/core/certmgr/providers/ctcccloud-cdn/ctcccloud_cdn_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_CTCCCLOUDCDN_"
argsPrefix := "CTCCCLOUDCDN_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./ctcccloud_cdn_test.go -args \
--CERTIMATE_SSLMANAGER_CTCCCLOUDCDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDCDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDCDN_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDCDN_SECRETACCESSKEY="your-secret-access-key"
--CTCCCLOUDCDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CTCCCLOUDCDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CTCCCLOUDCDN_ACCESSKEYID="your-access-key-id" \
--CTCCCLOUDCDN_SECRETACCESSKEY="your-secret-access-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/ctcccloud-cms/ctcccloud_cms.go
+32 -28
View File
@@ -34,12 +34,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -49,21 +49,21 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 避免重复上传
if res, err := m.tryFindCert(ctx, certPEM); err != nil {
if upres, upok, err := c.tryGetResultIfCertExists(ctx, certPEM); err != nil {
return nil, err
} else if res != nil {
m.logger.Info("ssl certificate already exists")
return res, nil
} else if upok {
c.logger.Info("ssl certificate already exists")
return upres, nil
}
// 提取服务器证书
@@ -84,17 +84,17 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
PrivateKey: lo.ToPtr(privkeyPEM),
EncryptionStandard: lo.ToPtr("INTERNATIONAL"),
}
uploadCertificateResp, err := m.sdkClient.UploadCertificate(uploadCertificateReq)
m.logger.Debug("sdk request 'cms.UploadCertificate'", slog.Any("request", uploadCertificateReq), slog.Any("response", uploadCertificateResp))
uploadCertificateResp, err := c.sdkClient.UploadCertificate(uploadCertificateReq)
c.logger.Debug("sdk request 'cms.UploadCertificate'", slog.Any("request", uploadCertificateReq), slog.Any("response", uploadCertificateResp))
if err != nil {
if uploadCertificateResp != nil && uploadCertificateResp.GetError() == "CCMS_100000067" {
if res, err := m.tryFindCert(ctx, certPEM); err != nil {
if upres, upok, err := c.tryGetResultIfCertExists(ctx, certPEM); err != nil {
return nil, err
} else if res == nil {
} else if !upok {
return nil, errors.New("ctyun cms: no certificate found")
} else {
m.logger.Info("ssl certificate already exists")
return res, nil
c.logger.Info("ssl certificate already exists")
return upres, nil
}
}
@@ -102,20 +102,24 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 获取刚刚上传证书 ID
if res, err := m.tryFindCert(ctx, certPEM); err != nil {
if upres, upok, err := c.tryGetResultIfCertExists(ctx, certPEM); err != nil {
return nil, err
} else if res == nil {
} else if !upok {
return nil, fmt.Errorf("could not find ssl certificate, may be upload failed")
} else {
return res, nil
return upres, nil
}
}
func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func (c *Certmgr) tryGetResultIfCertExists(ctx context.Context, certPEM string) (*certmgr.UploadResult, bool, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
return nil, err
return nil, false, err
}
// 查询用户证书列表
@@ -125,7 +129,7 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
for {
select {
case <-ctx.Done():
return nil, ctx.Err()
return nil, false, ctx.Err()
default:
}
@@ -135,10 +139,10 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
Keyword: lo.ToPtr(certX509.Subject.CommonName),
Origin: lo.ToPtr("UPLOAD"),
}
getCertificateListResp, err := m.sdkClient.GetCertificateList(getCertificateListReq)
m.logger.Debug("sdk request 'cms.GetCertificateList'", slog.Any("request", getCertificateListReq), slog.Any("response", getCertificateListResp))
getCertificateListResp, err := c.sdkClient.GetCertificateList(getCertificateListReq)
c.logger.Debug("sdk request 'cms.GetCertificateList'", slog.Any("request", getCertificateListReq), slog.Any("response", getCertificateListResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cms.GetCertificateList': %w", err)
return nil, false, fmt.Errorf("failed to execute sdk request 'cms.GetCertificateList': %w", err)
}
if getCertificateListResp.ReturnObj == nil {
@@ -168,11 +172,11 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: certItem.Id,
CertName: certItem.Name,
}, nil
}, true, nil
}
if len(getCertificateListResp.ReturnObj.List) < getCertificateListPageSize {
@@ -182,7 +186,7 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
getCertificateListPageNum++
}
return nil, nil
return nil, false, nil
}
func createSDKClient(accessKeyId, secretAccessKey string) (*ctyuncms.Client, error) {
pkg/core/certmgr/providers/ctcccloud-cms/ctcccloud_cms_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_CTCCCLOUDCMS_"
argsPrefix := "CTCCCLOUDCMS_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./ctcccloud_cms_test.go -args \
--CERTIMATE_SSLMANAGER_CTCCCLOUDCMS_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDCMS_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDCMS_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDCMS_SECRETACCESSKEY="your-secret-access-key"
--CTCCCLOUDCMS_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CTCCCLOUDCMS_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CTCCCLOUDCMS_ACCESSKEYID="your-access-key-id" \
--CTCCCLOUDCMS_SECRETACCESSKEY="your-secret-access-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/ctcccloud-elb/ctcccloud_elb.go
+17 -13
View File
@@ -34,12 +34,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -49,29 +49,29 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 查询证书列表，避免重复上传
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=24&api=5692&data=88&isNormal=1&vid=82
listCertificatesReq := &ctyunelb.ListCertificatesRequest{
RegionID: lo.ToPtr(m.config.RegionId),
RegionID: lo.ToPtr(c.config.RegionId),
}
listCertificatesResp, err := m.sdkClient.ListCertificates(listCertificatesReq)
m.logger.Debug("sdk request 'elb.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
listCertificatesResp, err := c.sdkClient.ListCertificates(listCertificatesReq)
c.logger.Debug("sdk request 'elb.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'elb.ListCertificates': %w", err)
} else {
for _, certItem := range listCertificatesResp.ReturnObj {
// 如果已存在相同证书，直接返回
if xcert.EqualCertificatesFromPEM(certPEM, certItem.Certificate) {
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: certItem.ID,
CertName: certItem.Name,
@@ -87,15 +87,15 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// REF: https://eop.ctyun.cn/ebp/ctapiDocument/search?sid=24&api=5685&data=88&isNormal=1&vid=82
createCertificateReq := &ctyunelb.CreateCertificateRequest{
ClientToken: lo.ToPtr(security.RandomString(32)),
RegionID: lo.ToPtr(m.config.RegionId),
RegionID: lo.ToPtr(c.config.RegionId),
Name: lo.ToPtr(certName),
Description: lo.ToPtr("upload from certimate"),
Type: lo.ToPtr("Server"),
Certificate: lo.ToPtr(certPEM),
PrivateKey: lo.ToPtr(privkeyPEM),
}
createCertificateResp, err := m.sdkClient.CreateCertificate(createCertificateReq)
m.logger.Debug("sdk request 'elb.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))
createCertificateResp, err := c.sdkClient.CreateCertificate(createCertificateReq)
c.logger.Debug("sdk request 'elb.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'elb.CreateCertificate': %w", err)
}
@@ -106,6 +106,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, secretAccessKey string) (*ctyunelb.Client, error) {
return ctyunelb.NewClient(accessKeyId, secretAccessKey)
}
pkg/core/certmgr/providers/ctcccloud-elb/ctcccloud_elb_test.go
+6 -6
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_CTCCCLOUDELB_"
argsPrefix := "CTCCCLOUDELB_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -34,11 +34,11 @@ func init() {
Shell command to run this test:
go test -v ./ctcccloud_elb_test.go -args \
--CERTIMATE_SSLMANAGER_CTCCCLOUDELB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDELB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDELB_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDELB_SECRETACCESSKEY="your-secret-access-key" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDELB_REGIONID="your-region-id"
--CTCCCLOUDELB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CTCCCLOUDELB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CTCCCLOUDELB_ACCESSKEYID="your-access-key-id" \
--CTCCCLOUDELB_SECRETACCESSKEY="your-secret-access-key" \
--CTCCCLOUDELB_REGIONID="your-region-id"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/ctcccloud-icdn/ctcccloud_icdn.go
+17 -13
View File
@@ -33,12 +33,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -48,15 +48,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -80,8 +80,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
PerPage: lo.ToPtr(int32(queryCertListPerPage)),
UsageMode: lo.ToPtr(int32(0)),
}
queryCertListResp, err := m.sdkClient.QueryCertList(queryCertListReq)
m.logger.Debug("sdk request 'icdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp))
queryCertListResp, err := c.sdkClient.QueryCertList(queryCertListReq)
c.logger.Debug("sdk request 'icdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'icdn.QueryCertList': %w", err)
}
@@ -112,8 +112,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
queryCertDetailReq := &ctyunicdn.QueryCertDetailRequest{
Id: lo.ToPtr(certItem.Id),
}
queryCertDetailResp, err := m.sdkClient.QueryCertDetail(queryCertDetailReq)
m.logger.Debug("sdk request 'icdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp))
queryCertDetailResp, err := c.sdkClient.QueryCertDetail(queryCertDetailReq)
c.logger.Debug("sdk request 'icdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'icdn.QueryCertDetail': %w", err)
} else if queryCertDetailResp.ReturnObj != nil && queryCertDetailResp.ReturnObj.Result != nil {
@@ -123,7 +123,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: fmt.Sprintf("%d", queryCertDetailResp.ReturnObj.Result.Id),
CertName: queryCertDetailResp.ReturnObj.Result.Name,
@@ -147,8 +147,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
Certs: lo.ToPtr(certPEM),
Key: lo.ToPtr(privkeyPEM),
}
createCertResp, err := m.sdkClient.CreateCert(createCertReq)
m.logger.Debug("sdk request 'icdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
createCertResp, err := c.sdkClient.CreateCert(createCertReq)
c.logger.Debug("sdk request 'icdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'icdn.CreateCert': %w", err)
}
@@ -159,6 +159,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, secretAccessKey string) (*ctyunicdn.Client, error) {
return ctyunicdn.NewClient(accessKeyId, secretAccessKey)
}
pkg/core/certmgr/providers/ctcccloud-icdn/ctcccloud_icdn_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_CTCCCLOUDICDN_"
argsPrefix := "CTCCCLOUDICDN_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./ctcccloud_icdn_test.go -args \
--CERTIMATE_SSLMANAGER_CTCCCLOUDICDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDICDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDICDN_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDICDN_SECRETACCESSKEY="your-secret-access-key"
--CTCCCLOUDICDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CTCCCLOUDICDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CTCCCLOUDICDN_ACCESSKEYID="your-access-key-id" \
--CTCCCLOUDICDN_SECRETACCESSKEY="your-secret-access-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/ctcccloud-lvdn/ctcccloud_lvdn.go
+17 -13
View File
@@ -33,12 +33,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -48,15 +48,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -80,8 +80,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
PerPage: lo.ToPtr(int32(queryCertListPerPage)),
UsageMode: lo.ToPtr(int32(0)),
}
queryCertListResp, err := m.sdkClient.QueryCertList(queryCertListReq)
m.logger.Debug("sdk request 'lvdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp))
queryCertListResp, err := c.sdkClient.QueryCertList(queryCertListReq)
c.logger.Debug("sdk request 'lvdn.QueryCertList'", slog.Any("request", queryCertListReq), slog.Any("response", queryCertListResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'lvdn.QueryCertList': %w", err)
}
@@ -112,8 +112,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
queryCertDetailReq := &ctyunlvdn.QueryCertDetailRequest{
Id: lo.ToPtr(certItem.Id),
}
queryCertDetailResp, err := m.sdkClient.QueryCertDetail(queryCertDetailReq)
m.logger.Debug("sdk request 'lvdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp))
queryCertDetailResp, err := c.sdkClient.QueryCertDetail(queryCertDetailReq)
c.logger.Debug("sdk request 'lvdn.QueryCertDetail'", slog.Any("request", queryCertDetailReq), slog.Any("response", queryCertDetailResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'lvdn.QueryCertDetail': %w", err)
} else if queryCertDetailResp.ReturnObj != nil && queryCertDetailResp.ReturnObj.Result != nil {
@@ -123,7 +123,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: fmt.Sprintf("%d", queryCertDetailResp.ReturnObj.Result.Id),
CertName: queryCertDetailResp.ReturnObj.Result.Name,
@@ -147,8 +147,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
Certs: lo.ToPtr(certPEM),
Key: lo.ToPtr(privkeyPEM),
}
createCertResp, err := m.sdkClient.CreateCert(createCertReq)
m.logger.Debug("sdk request 'lvdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
createCertResp, err := c.sdkClient.CreateCert(createCertReq)
c.logger.Debug("sdk request 'lvdn.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'lvdn.CreateCert': %w", err)
}
@@ -159,6 +159,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, secretAccessKey string) (*ctyunlvdn.Client, error) {
return ctyunlvdn.NewClient(accessKeyId, secretAccessKey)
}
pkg/core/certmgr/providers/ctcccloud-lvdn/ctcccloud_lvdn_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_CTCCCLOUDLVDN_"
argsPrefix := "CTCCCLOUDLVDN_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./ctcccloud_lvdn_test.go -args \
--CERTIMATE_SSLMANAGER_CTCCCLOUDLVDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDLVDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDLVDN_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_CTCCCLOUDLVDN_SECRETACCESSKEY="your-secret-access-key"
--CTCCCLOUDLVDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CTCCCLOUDLVDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CTCCCLOUDLVDN_ACCESSKEYID="your-access-key-id" \
--CTCCCLOUDLVDN_SECRETACCESSKEY="your-secret-access-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/dogecloud/dogecloud.go
+12 -8
View File
@@ -28,12 +28,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKey, config.SecretKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -43,15 +43,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 生成新证书名（需符合多吉云命名规则）
certName := fmt.Sprintf("certimate-%d", time.Now().UnixMilli())
@@ -62,8 +62,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
Certificate: certPEM,
PrivateKey: privkeyPEM,
}
uploadSslCertResp, err := m.sdkClient.UploadCdnCert(uploadSslCertReq)
m.logger.Debug("sdk request 'cdn.UploadCdnCert'", slog.Any("request", uploadSslCertReq), slog.Any("response", uploadSslCertResp))
uploadSslCertResp, err := c.sdkClient.UploadCdnCert(uploadSslCertReq)
c.logger.Debug("sdk request 'cdn.UploadCdnCert'", slog.Any("request", uploadSslCertReq), slog.Any("response", uploadSslCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cdn.UploadCdnCert': %w", err)
}
@@ -74,6 +74,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKey, secretKey string) (*dogesdk.Client, error) {
return dogesdk.NewClient(accessKey, secretKey)
}
pkg/core/certmgr/providers/gcore-cdn/gcore_cdn.go
+12 -8
View File
@@ -29,12 +29,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.ApiToken)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -44,15 +44,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 新增证书
// REF: https://api.gcore.com/docs/cdn#tag/SSL-certificates/operation/add_ssl_certificates
createCertificateReq := &sslcerts.CreateRequest{
@@ -62,8 +62,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
Automated: false,
ValidateRootCA: false,
}
createCertificateResp, err := m.sdkClient.Create(ctx, createCertificateReq)
m.logger.Debug("sdk request 'sslcerts.Create'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))
createCertificateResp, err := c.sdkClient.Create(ctx, createCertificateReq)
c.logger.Debug("sdk request 'sslcerts.Create'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'sslcerts.Create': %w", err)
}
@@ -74,6 +74,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(apiToken string) (*sslcerts.Service, error) {
if apiToken == "" {
return nil, errors.New("invalid gcore api token")
pkg/core/certmgr/providers/huaweicloud-elb/huaweicloud_elb.go
+16 -16
View File
@@ -43,12 +43,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -58,15 +58,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 查询已有证书，避免重复上传
// REF: https://support.huaweicloud.com/api-elb/ListCertificates.html
listCertificatesMarker := (*string)(nil)
@@ -82,8 +82,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
Limit: lo.ToPtr(int32(2000)),
Type: lo.ToPtr([]string{"server"}),
}
listCertificatesResp, err := m.sdkClient.ListCertificates(listCertificatesReq)
m.logger.Debug("sdk request 'elb.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
listCertificatesResp, err := c.sdkClient.ListCertificates(listCertificatesReq)
c.logger.Debug("sdk request 'elb.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'elb.ListCertificates': %w", err)
}
@@ -95,7 +95,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
for _, certItem := range *listCertificatesResp.Certificates {
// 如果已存在相同证书，直接返回
if xcert.EqualCertificatesFromPEM(certPEM, certItem.Certificate) {
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: certItem.Id,
CertName: certItem.Name,
@@ -112,7 +112,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
// 获取项目 ID
// REF: https://support.huaweicloud.com/api-iam/iam_06_0001.html
projectId, err := getSdkProjectId(m.config.AccessKeyId, m.config.SecretAccessKey, m.config.Region)
projectId, err := getSdkProjectId(c.config.AccessKeyId, c.config.SecretAccessKey, c.config.Region)
if err != nil {
return nil, fmt.Errorf("failed to get SDK project id: %w", err)
}
@@ -125,7 +125,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
createCertificateReq := &hcelbmodel.CreateCertificateRequest{
Body: &hcelbmodel.CreateCertificateRequestBody{
Certificate: &hcelbmodel.CreateCertificateOption{
EnterpriseProjectId: lo.EmptyableToPtr(m.config.EnterpriseProjectId),
EnterpriseProjectId: lo.EmptyableToPtr(c.config.EnterpriseProjectId),
ProjectId: lo.ToPtr(projectId),
Name: lo.ToPtr(certName),
Certificate: lo.ToPtr(certPEM),
@@ -133,8 +133,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
},
},
}
createCertificateResp, err := m.sdkClient.CreateCertificate(createCertificateReq)
m.logger.Debug("sdk request 'elb.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))
createCertificateResp, err := c.sdkClient.CreateCertificate(createCertificateReq)
c.logger.Debug("sdk request 'elb.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'elb.CreateCertificate': %w", err)
}
@@ -145,7 +145,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
}, nil
}
func (m *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
// 更新证书
// REF: https://support.huaweicloud.com/api-elb/UpdateCertificate.html
updateCertificateReq := &hcelbmodel.UpdateCertificateRequest{
@@ -157,8 +157,8 @@ func (m *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, pri
},
},
}
updateCertificateResp, err := m.sdkClient.UpdateCertificate(updateCertificateReq)
m.logger.Debug("sdk request 'elb.UpdateCertificate'", slog.Any("request", updateCertificateReq), slog.Any("response", updateCertificateResp))
updateCertificateResp, err := c.sdkClient.UpdateCertificate(updateCertificateReq)
c.logger.Debug("sdk request 'elb.UpdateCertificate'", slog.Any("request", updateCertificateReq), slog.Any("response", updateCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'elb.UpdateCertificate': %w", err)
}
pkg/core/certmgr/providers/huaweicloud-scm/huaweicloud_scm.go
+19 -15
View File
@@ -40,12 +40,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -55,15 +55,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -83,14 +83,14 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
listCertificatesReq := &hcscmmodel.ListCertificatesRequest{
EnterpriseProjectId: lo.EmptyableToPtr(m.config.EnterpriseProjectId),
EnterpriseProjectId: lo.EmptyableToPtr(c.config.EnterpriseProjectId),
Limit: lo.ToPtr(int32(listCertificatesLimit)),
Offset: lo.ToPtr(int32(listCertificatesOffset)),
SortDir: lo.ToPtr("DESC"),
SortKey: lo.ToPtr("certExpiredTime"),
}
listCertificatesResp, err := m.sdkClient.ListCertificates(listCertificatesReq)
m.logger.Debug("sdk request 'scm.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
listCertificatesResp, err := c.sdkClient.ListCertificates(listCertificatesReq)
c.logger.Debug("sdk request 'scm.ListCertificates'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'scm.ListCertificates': %w", err)
}
@@ -114,8 +114,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
exportCertificateReq := &hcscmmodel.ExportCertificateRequest{
CertificateId: certItem.Id,
}
exportCertificateResp, err := m.sdkClient.ExportCertificate(exportCertificateReq)
m.logger.Debug("sdk request 'scm.ExportCertificate'", slog.Any("request", exportCertificateReq), slog.Any("response", exportCertificateResp))
exportCertificateResp, err := c.sdkClient.ExportCertificate(exportCertificateReq)
c.logger.Debug("sdk request 'scm.ExportCertificate'", slog.Any("request", exportCertificateReq), slog.Any("response", exportCertificateResp))
if err != nil {
if exportCertificateResp != nil && exportCertificateResp.HttpStatusCode == 404 {
continue
@@ -128,7 +128,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: certItem.Id,
CertName: certItem.Name,
@@ -149,14 +149,14 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// REF: https://support.huaweicloud.com/api-ccm/ImportCertificate.html
importCertificateReq := &hcscmmodel.ImportCertificateRequest{
Body: &hcscmmodel.ImportCertificateRequestBody{
EnterpriseProjectId: lo.EmptyableToPtr(m.config.EnterpriseProjectId),
EnterpriseProjectId: lo.EmptyableToPtr(c.config.EnterpriseProjectId),
Name: certName,
Certificate: certPEM,
PrivateKey: privkeyPEM,
},
}
importCertificateResp, err := m.sdkClient.ImportCertificate(importCertificateReq)
m.logger.Debug("sdk request 'scm.ImportCertificate'", slog.Any("request", importCertificateReq), slog.Any("response", importCertificateResp))
importCertificateResp, err := c.sdkClient.ImportCertificate(importCertificateReq)
c.logger.Debug("sdk request 'scm.ImportCertificate'", slog.Any("request", importCertificateReq), slog.Any("response", importCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'scm.ImportCertificate': %w", err)
}
@@ -167,6 +167,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, secretAccessKey, region string) (*internal.ScmClient, error) {
if region == "" {
region = "cn-north-4" // SCM 服务默认区域：华北四北京
pkg/core/certmgr/providers/huaweicloud-waf/huaweicloud_waf.go
+20 -16
View File
@@ -43,12 +43,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -58,15 +58,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 查询已有证书，避免重复上传
// REF: https://support.huaweicloud.com/api-waf/ListCertificates.html
// REF: https://support.huaweicloud.com/api-waf/ShowCertificate.html
@@ -80,12 +80,12 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
listCertificatesReq := &hcwafmodel.ListCertificatesRequest{
EnterpriseProjectId: lo.EmptyableToPtr(m.config.EnterpriseProjectId),
EnterpriseProjectId: lo.EmptyableToPtr(c.config.EnterpriseProjectId),
Page: lo.ToPtr(int32(listCertificatesPage)),
Pagesize: lo.ToPtr(int32(listCertificatesPageSize)),
}
listCertificatesResp, err := m.sdkClient.ListCertificates(listCertificatesReq)
m.logger.Debug("sdk request 'waf.ShowCertificate'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
listCertificatesResp, err := c.sdkClient.ListCertificates(listCertificatesReq)
c.logger.Debug("sdk request 'waf.ShowCertificate'", slog.Any("request", listCertificatesReq), slog.Any("response", listCertificatesResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'waf.ListCertificates': %w", err)
}
@@ -96,18 +96,18 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
for _, certItem := range *listCertificatesResp.Items {
showCertificateReq := &hcwafmodel.ShowCertificateRequest{
EnterpriseProjectId: lo.EmptyableToPtr(m.config.EnterpriseProjectId),
EnterpriseProjectId: lo.EmptyableToPtr(c.config.EnterpriseProjectId),
CertificateId: certItem.Id,
}
showCertificateResp, err := m.sdkClient.ShowCertificate(showCertificateReq)
m.logger.Debug("sdk request 'waf.ShowCertificate'", slog.Any("request", showCertificateReq), slog.Any("response", showCertificateResp))
showCertificateResp, err := c.sdkClient.ShowCertificate(showCertificateReq)
c.logger.Debug("sdk request 'waf.ShowCertificate'", slog.Any("request", showCertificateReq), slog.Any("response", showCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'waf.ShowCertificate': %w", err)
}
// 如果已存在相同证书，直接返回
if xcert.EqualCertificatesFromPEM(certPEM, lo.FromPtr(showCertificateResp.Content)) {
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: certItem.Id,
CertName: certItem.Name,
@@ -128,15 +128,15 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// 创建证书
// REF: https://support.huaweicloud.com/api-waf/CreateCertificate.html
createCertificateReq := &hcwafmodel.CreateCertificateRequest{
EnterpriseProjectId: lo.EmptyableToPtr(m.config.EnterpriseProjectId),
EnterpriseProjectId: lo.EmptyableToPtr(c.config.EnterpriseProjectId),
Body: &hcwafmodel.CreateCertificateRequestBody{
Name: certName,
Content: certPEM,
Key: privkeyPEM,
},
}
createCertificateResp, err := m.sdkClient.CreateCertificate(createCertificateReq)
m.logger.Debug("sdk request 'waf.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))
createCertificateResp, err := c.sdkClient.CreateCertificate(createCertificateReq)
c.logger.Debug("sdk request 'waf.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'waf.CreateCertificate': %w", err)
}
@@ -147,6 +147,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, secretAccessKey, region string) (*internal.WafClient, error) {
projectId, err := getSdkProjectId(accessKeyId, secretAccessKey, region)
if err != nil {
pkg/core/certmgr/providers/jdcloud-ssl/jdcloud_ssl.go
+15 -11
View File
@@ -35,12 +35,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -50,15 +50,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -86,8 +86,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
describeCertsReq.SetDomainName(certX509.Subject.CommonName)
describeCertsReq.SetPageNumber(describeCertsPageNumber)
describeCertsReq.SetPageSize(describeCertsPageSize)
describeCertsResp, err := m.sdkClient.DescribeCerts(describeCertsReq)
m.logger.Debug("sdk request 'ssl.DescribeCerts'", slog.Any("request", describeCertsReq), slog.Any("response", describeCertsResp))
describeCertsResp, err := c.sdkClient.DescribeCerts(describeCertsReq)
c.logger.Debug("sdk request 'ssl.DescribeCerts'", slog.Any("request", describeCertsReq), slog.Any("response", describeCertsResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'ssl.DescribeCerts': %w", err)
}
@@ -118,7 +118,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: certItem.CertId,
CertName: certItem.CertName,
@@ -141,8 +141,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
uploadCertReq.SetCertName(certName)
uploadCertReq.SetCertFile(certPEM)
uploadCertReq.SetKeyFile(privkeyPEM)
uploadCertResp, err := m.sdkClient.UploadCert(uploadCertReq)
m.logger.Debug("sdk request 'ssl.UploadCertificate'", slog.Any("request", uploadCertReq), slog.Any("response", uploadCertResp))
uploadCertResp, err := c.sdkClient.UploadCert(uploadCertReq)
c.logger.Debug("sdk request 'ssl.UploadCertificate'", slog.Any("request", uploadCertReq), slog.Any("response", uploadCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'ssl.UploadCertificate': %w", err)
}
@@ -153,6 +153,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, accessKeySecret string) (*jdsslclient.SslClient, error) {
clientCredentials := jdcore.NewCredentials(accessKeyId, accessKeySecret)
client := jdsslclient.NewSslClient(clientCredentials)
pkg/core/certmgr/providers/jdcloud-ssl/jdcloud_ssl_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_JDCLOUDSSL_"
argsPrefix := "JDCLOUDSSL_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./jdcloud_ssl_test.go -args \
--CERTIMATE_SSLMANAGER_JDCLOUDSSL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_JDCLOUDSSL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_JDCLOUDSSL_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_JDCLOUDSSL_ACCESSKEYSECRET="your-access-key-secret"
--JDCLOUDSSL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--JDCLOUDSSL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--JDCLOUDSSL_ACCESSKEYID="your-access-key-id" \
--JDCLOUDSSL_ACCESSKEYSECRET="your-access-key-secret"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/qiniu-sslcert/qiniu_sslcert.go
+15 -11
View File
@@ -34,12 +34,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKey, config.SecretKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -49,15 +49,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -76,8 +76,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
default:
}
getSslCertListResp, err := m.sdkClient.GetSslCertList(ctx, getSslCertListMarker, 200)
m.logger.Debug("sdk request 'sslcert.GetList'", slog.Any("request.marker", getSslCertListMarker), slog.Any("response", getSslCertListResp))
getSslCertListResp, err := c.sdkClient.GetSslCertList(ctx, getSslCertListMarker, 200)
c.logger.Debug("sdk request 'sslcert.GetList'", slog.Any("request.marker", getSslCertListMarker), slog.Any("response", getSslCertListResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'sslcert.GetList': %w", err)
}
@@ -118,7 +118,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: sslItem.CertID,
CertName: sslItem.Name,
@@ -134,8 +134,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// 上传新证书
// REF: https://developer.qiniu.com/fusion/8593/interface-related-certificate
uploadSslCertResp, err := m.sdkClient.UploadSslCert(ctx, certName, certX509.Subject.CommonName, certPEM, privkeyPEM)
m.logger.Debug("sdk request 'sslcert.Upload'", slog.Any("response", uploadSslCertResp))
uploadSslCertResp, err := c.sdkClient.UploadSslCert(ctx, certName, certX509.Subject.CommonName, certPEM, privkeyPEM)
c.logger.Debug("sdk request 'sslcert.Upload'", slog.Any("response", uploadSslCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'sslcert.Upload': %w", err)
}
@@ -146,6 +146,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKey, secretKey string) (*qiniusdk.SslCertManager, error) {
if secretKey == "" {
return nil, errors.New("invalid qiniu access key")
pkg/core/certmgr/providers/qiniu-sslcert/qiniu_sslcert_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_QINIUSSLCERT_"
argsPrefix := "QINIUSSLCERT_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./qiniu_sslcert_test.go -args \
--CERTIMATE_SSLMANAGER_QINIUSSLCERT_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_QINIUSSLCERT_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_QINIUSSLCERT_ACCESSKEY="your-access-key" \
--CERTIMATE_SSLMANAGER_QINIUSSLCERT_SECRETKEY="your-secret-key"
--QINIUSSLCERT_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--QINIUSSLCERT_INPUTKEYPATH="/path/to/your-input-key.pem" \
--QINIUSSLCERT_ACCESSKEY="your-access-key" \
--QINIUSSLCERT_SECRETKEY="your-secret-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/rainyun-sslcenter/rainyun_sslcenter.go
+28 -28
View File
@@ -30,12 +30,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.ApiKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -45,21 +45,21 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 避免重复上传
if res, err := m.tryFindCert(ctx, certPEM); err != nil {
if upres, upok, err := c.tryGetResultIfCertExists(ctx, certPEM); err != nil {
return nil, err
} else if res != nil {
m.logger.Info("ssl certificate already exists")
return res, nil
} else if upok {
c.logger.Info("ssl certificate already exists")
return upres, nil
}
// SSL 证书上传
@@ -68,23 +68,23 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*cert
Cert: certPEM,
Key: privkeyPEM,
}
sslCenterCreateResp, err := m.sdkClient.SslCenterCreate(sslCenterCreateReq)
m.logger.Debug("sdk request 'sslcenter.Create'", slog.Any("request", sslCenterCreateReq), slog.Any("response", sslCenterCreateResp))
sslCenterCreateResp, err := c.sdkClient.SslCenterCreate(sslCenterCreateReq)
c.logger.Debug("sdk request 'sslcenter.Create'", slog.Any("request", sslCenterCreateReq), slog.Any("response", sslCenterCreateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'sslcenter.Create': %w", err)
}
// 获取刚刚上传证书 ID
if res, err := m.tryFindCert(ctx, certPEM); err != nil {
if upres, upok, err := c.tryGetResultIfCertExists(ctx, certPEM); err != nil {
return nil, err
} else if res == nil {
} else if !upok {
return nil, errors.New("could not find ssl certificate, may be upload failed")
} else {
return res, nil
return upres, nil
}
}
func (m *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
certId, err := strconv.ParseInt(certIdOrName, 10, 64)
if err != nil {
return nil, err
@@ -96,8 +96,8 @@ func (m *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, pri
Cert: certPEM,
Key: privkeyPEM,
}
sslCenterUpdateResp, err := m.sdkClient.SslCenterUpdate(certId, sslCenterUpdateReq)
m.logger.Debug("sdk request 'sslcenter.Update'", slog.Int64("certId", certId), slog.Any("request", sslCenterUpdateReq), slog.Any("response", sslCenterUpdateResp))
sslCenterUpdateResp, err := c.sdkClient.SslCenterUpdate(certId, sslCenterUpdateReq)
c.logger.Debug("sdk request 'sslcenter.Update'", slog.Int64("certId", certId), slog.Any("request", sslCenterUpdateReq), slog.Any("response", sslCenterUpdateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'sslcenter.Update': %w", err)
}
@@ -105,11 +105,11 @@ func (m *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, pri
return &certmgr.OperateResult{}, nil
}
func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) tryGetResultIfCertExists(ctx context.Context, certPEM string) (*certmgr.UploadResult, bool, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
return nil, err
return nil, false, err
}
// 获取 SSL 证书列表
@@ -120,7 +120,7 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
for {
select {
case <-ctx.Done():
return nil, ctx.Err()
return nil, false, ctx.Err()
default:
}
@@ -131,10 +131,10 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
Page: lo.ToPtr(int32(sslCenterListPage)),
PerPage: lo.ToPtr(int32(sslCenterListPerPage)),
}
sslCenterListResp, err := m.sdkClient.SslCenterList(sslCenterListReq)
m.logger.Debug("sdk request 'sslcenter.List'", slog.Any("request", sslCenterListReq), slog.Any("response", sslCenterListResp))
sslCenterListResp, err := c.sdkClient.SslCenterList(sslCenterListReq)
c.logger.Debug("sdk request 'sslcenter.List'", slog.Any("request", sslCenterListReq), slog.Any("response", sslCenterListResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'sslcenter.List': %w", err)
return nil, false, fmt.Errorf("failed to execute sdk request 'sslcenter.List': %w", err)
}
if sslCenterListResp.Data == nil {
@@ -153,9 +153,9 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
}
// 对比证书内容
sslCenterGetResp, err := m.sdkClient.SslCenterGet(sslItem.ID)
sslCenterGetResp, err := c.sdkClient.SslCenterGet(sslItem.ID)
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'sslcenter.Get': %w", err)
return nil, false, fmt.Errorf("failed to execute sdk request 'sslcenter.Get': %w", err)
} else {
if !xcert.EqualCertificatesFromPEM(certPEM, sslCenterGetResp.Data.Cert) {
continue
@@ -165,7 +165,7 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
// 如果以上信息都一致，则视为已存在相同证书，直接返回
return &certmgr.UploadResult{
CertId: fmt.Sprintf("%d", sslItem.ID),
}, nil
}, true, nil
}
if len(sslCenterListResp.Data.Records) < sslCenterListPerPage {
@@ -175,7 +175,7 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
sslCenterListPage++
}
return nil, nil
return nil, false, nil
}
func createSDKClient(apiKey string) (*rainyunsdk.Client, error) {
pkg/core/certmgr/providers/rainyun-sslcenter/rainyun_sslcenter_test.go
+4 -4
View File
@@ -19,7 +19,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_RAINYUNSSLCENTER_"
argsPrefix := "RAINYUNSSLCENTER_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -30,9 +30,9 @@ func init() {
Shell command to run this test:
go test -v ./rainyun_sslcenter_test.go -args \
--CERTIMATE_SSLMANAGER_RAINYUNSSLCENTER_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_RAINYUNSSLCENTER_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_RAINYUNSSLCENTER_APIKEY="your-api-key"
--RAINYUNSSLCENTER_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--RAINYUNSSLCENTER_INPUTKEYPATH="/path/to/your-input-key.pem" \
--RAINYUNSSLCENTER_APIKEY="your-api-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/tencentcloud-ssl/tencentcloud_ssl.go
+12 -8
View File
@@ -33,12 +33,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.SecretId, config.SecretKey, config.Endpoint)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -48,23 +48,23 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 上传新证书
// REF: https://cloud.tencent.com/document/api/400/41665
uploadCertificateReq := tcssl.NewUploadCertificateRequest()
uploadCertificateReq.CertificatePublicKey = common.StringPtr(certPEM)
uploadCertificateReq.CertificatePrivateKey = common.StringPtr(privkeyPEM)
uploadCertificateReq.Repeatable = common.BoolPtr(false)
uploadCertificateResp, err := m.sdkClient.UploadCertificate(uploadCertificateReq)
m.logger.Debug("sdk request 'ssl.UploadCertificate'", slog.Any("request", uploadCertificateReq), slog.Any("response", uploadCertificateResp))
uploadCertificateResp, err := c.sdkClient.UploadCertificate(uploadCertificateReq)
c.logger.Debug("sdk request 'ssl.UploadCertificate'", slog.Any("request", uploadCertificateReq), slog.Any("response", uploadCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'ssl.UploadCertificate': %w", err)
}
@@ -74,6 +74,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(secretId, secretKey, endpoint string) (*internal.SslClient, error) {
credential := common.NewCredential(secretId, secretKey)
pkg/core/certmgr/providers/tencentcloud-ssl/tencentcloud_ssl_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_TENCENTCLOUDSSL_"
argsPrefix := "TENCENTCLOUDSSL_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./tencentcloud_ssl_test.go -args \
--CERTIMATE_SSLMANAGER_TENCENTCLOUDSSL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_TENCENTCLOUDSSL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_TENCENTCLOUDSSL_SECRETID="your-secret-id" \
--CERTIMATE_SSLMANAGER_TENCENTCLOUDSSL_SECRETKEY="your-secret-key"
--TENCENTCLOUDSSL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--TENCENTCLOUDSSL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--TENCENTCLOUDSSL_SECRETID="your-secret-id" \
--TENCENTCLOUDSSL_SECRETKEY="your-secret-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/ucloud-ussl/ucloud_ussl.go
+39 -35
View File
@@ -16,7 +16,7 @@ import (
ucloudauth "github.com/ucloud/ucloud-sdk-go/ucloud/auth"
"github.com/certimate-go/certimate/pkg/core/certmgr"
usslsdk "github.com/certimate-go/certimate/pkg/sdk3rd/ucloud/ussl"
ucloudssl "github.com/certimate-go/certimate/pkg/sdk3rd/ucloud/ussl"
xcert "github.com/certimate-go/certimate/pkg/utils/cert"
)
@@ -32,19 +32,19 @@ type CertmgrConfig struct {
type Certmgr struct {
config *CertmgrConfig
logger *slog.Logger
sdkClient *usslsdk.USSLClient
sdkClient *ucloudssl.USSLClient
}
var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.PrivateKey, config.PublicKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -54,15 +54,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 生成新证书名（需符合优刻得命名规则）
certName := fmt.Sprintf("certimate-%d", time.Now().UnixMilli())
@@ -74,25 +74,25 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// 上传托管证书
// REF: https://docs.ucloud.cn/api/usslcertificate-api/upload_normal_certificate
uploadNormalCertificateReq := m.sdkClient.NewUploadNormalCertificateRequest()
uploadNormalCertificateReq := c.sdkClient.NewUploadNormalCertificateRequest()
uploadNormalCertificateReq.CertificateName = ucloud.String(certName)
uploadNormalCertificateReq.SslPublicKey = ucloud.String(certPEMBase64)
uploadNormalCertificateReq.SslPrivateKey = ucloud.String(privkeyPEMBase64)
uploadNormalCertificateReq.SslMD5 = ucloud.String(certMd5Hex)
if m.config.ProjectId != "" {
uploadNormalCertificateReq.ProjectId = ucloud.String(m.config.ProjectId)
if c.config.ProjectId != "" {
uploadNormalCertificateReq.ProjectId = ucloud.String(c.config.ProjectId)
}
uploadNormalCertificateResp, err := m.sdkClient.UploadNormalCertificate(uploadNormalCertificateReq)
m.logger.Debug("sdk request 'ussl.UploadNormalCertificate'", slog.Any("request", uploadNormalCertificateReq), slog.Any("response", uploadNormalCertificateResp))
uploadNormalCertificateResp, err := c.sdkClient.UploadNormalCertificate(uploadNormalCertificateReq)
c.logger.Debug("sdk request 'ussl.UploadNormalCertificate'", slog.Any("request", uploadNormalCertificateReq), slog.Any("response", uploadNormalCertificateResp))
if err != nil {
if uploadNormalCertificateResp != nil && uploadNormalCertificateResp.GetRetCode() == 80035 {
if res, err := m.tryFindCert(ctx, certPEM); err != nil {
if upres, upok, err := c.tryGetResultIfCertExists(ctx, certPEM); err != nil {
return nil, err
} else if res == nil {
} else if !upok {
return nil, errors.New("could not find ssl certificate, may be upload failed")
} else {
m.logger.Info("ssl certificate already exists")
return res, nil
c.logger.Info("ssl certificate already exists")
return upres, nil
}
}
@@ -108,11 +108,15 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func (c *Certmgr) tryGetResultIfCertExists(ctx context.Context, certPEM string) (*certmgr.UploadResult, bool, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
return nil, err
return nil, false, err
}
// 查询用户证书列表
@@ -123,23 +127,23 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
for {
select {
case <-ctx.Done():
return nil, ctx.Err()
return nil, false, ctx.Err()
default:
}
getCertificateListReq := m.sdkClient.NewGetCertificateListRequest()
getCertificateListReq := c.sdkClient.NewGetCertificateListRequest()
getCertificateListReq.Mode = ucloud.String("trust")
getCertificateListReq.Domain = ucloud.String(certX509.Subject.CommonName)
getCertificateListReq.Sort = ucloud.String("2")
getCertificateListReq.Page = ucloud.Int(getCertificateListPage)
getCertificateListReq.PageSize = ucloud.Int(getCertificateListLimit)
if m.config.ProjectId != "" {
getCertificateListReq.ProjectId = ucloud.String(m.config.ProjectId)
if c.config.ProjectId != "" {
getCertificateListReq.ProjectId = ucloud.String(c.config.ProjectId)
}
getCertificateListResp, err := m.sdkClient.GetCertificateList(getCertificateListReq)
m.logger.Debug("sdk request 'ussl.GetCertificateList'", slog.Any("request", getCertificateListReq), slog.Any("response", getCertificateListResp))
getCertificateListResp, err := c.sdkClient.GetCertificateList(getCertificateListReq)
c.logger.Debug("sdk request 'ussl.GetCertificateList'", slog.Any("request", getCertificateListReq), slog.Any("response", getCertificateListResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'ussl.GetCertificateList': %w", err)
return nil, false, fmt.Errorf("failed to execute sdk request 'ussl.GetCertificateList': %w", err)
}
for _, certItem := range getCertificateListResp.CertificateList {
@@ -158,14 +162,14 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
continue
}
getCertificateDetailInfoReq := m.sdkClient.NewGetCertificateDetailInfoRequest()
getCertificateDetailInfoReq := c.sdkClient.NewGetCertificateDetailInfoRequest()
getCertificateDetailInfoReq.CertificateID = ucloud.Int(certItem.CertificateID)
if m.config.ProjectId != "" {
getCertificateDetailInfoReq.ProjectId = ucloud.String(m.config.ProjectId)
if c.config.ProjectId != "" {
getCertificateDetailInfoReq.ProjectId = ucloud.String(c.config.ProjectId)
}
getCertificateDetailInfoResp, err := m.sdkClient.GetCertificateDetailInfo(getCertificateDetailInfoReq)
getCertificateDetailInfoResp, err := c.sdkClient.GetCertificateDetailInfo(getCertificateDetailInfoReq)
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'ussl.GetCertificateDetailInfo': %w", err)
return nil, false, fmt.Errorf("failed to execute sdk request 'ussl.GetCertificateDetailInfo': %w", err)
}
switch certX509.SignatureAlgorithm {
@@ -216,7 +220,7 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
ExtendedData: map[string]any{
"ResourceId": certItem.CertificateSN,
},
}, nil
}, true, nil
}
if len(getCertificateListResp.CertificateList) < getCertificateListLimit {
@@ -226,16 +230,16 @@ func (m *Certmgr) tryFindCert(ctx context.Context, certPEM string) (*certmgr.Upl
getCertificateListPage++
}
return nil, nil
return nil, false, nil
}
func createSDKClient(privateKey, publicKey string) (*usslsdk.USSLClient, error) {
func createSDKClient(privateKey, publicKey string) (*ucloudssl.USSLClient, error) {
cfg := ucloud.NewConfig()
credential := ucloudauth.NewCredential()
credential.PrivateKey = privateKey
credential.PublicKey = publicKey
client := usslsdk.NewClient(&cfg, &credential)
client := ucloudssl.NewClient(&cfg, &credential)
return client, nil
}
pkg/core/certmgr/providers/ucloud-ussl/ucloud_ussl_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_UCLOUDUSSL_"
argsPrefix := "UCLOUDUSSL_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./ucloud_ussl_test.go -args \
--CERTIMATE_SSLMANAGER_UCLOUDUSSL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_UCLOUDUSSL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_UCLOUDUSSL_PRIVATEKEY="your-private-key" \
--CERTIMATE_SSLMANAGER_UCLOUDUSSL_PUBLICKEY="your-public-key"
--UCLOUDUSSL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--UCLOUDUSSL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--UCLOUDUSSL_PRIVATEKEY="your-private-key" \
--UCLOUDUSSL_PUBLICKEY="your-public-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/upyun-ssl/upyun_ssl.go
+12 -8
View File
@@ -27,12 +27,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.Username, config.Password)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -42,22 +42,22 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 上传证书
uploadHttpsCertificateReq := &upyunsdk.UploadHttpsCertificateRequest{
Certificate: certPEM,
PrivateKey: privkeyPEM,
}
uploadHttpsCertificateResp, err := m.sdkClient.UploadHttpsCertificate(uploadHttpsCertificateReq)
m.logger.Debug("sdk request 'console.UploadHttpsCertificate'", slog.Any("response", uploadHttpsCertificateResp))
uploadHttpsCertificateResp, err := c.sdkClient.UploadHttpsCertificate(uploadHttpsCertificateReq)
c.logger.Debug("sdk request 'console.UploadHttpsCertificate'", slog.Any("response", uploadHttpsCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'console.UploadHttpsCertificate': %w", err)
}
@@ -67,6 +67,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(username, password string) (*upyunsdk.Client, error) {
return upyunsdk.NewClient(username, password)
}
pkg/core/certmgr/providers/upyun-ssl/upyun_ssl_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_UPYUNSSL_"
argsPrefix := "UPYUNSSL_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./upyun_ssl_test.go -args \
--CERTIMATE_SSLMANAGER_UPYUNSSL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_UPYUNSSL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_UPYUNSSL_USERNAME="your-username" \
--CERTIMATE_SSLMANAGER_UPYUNSSL_PASSWORD="your-password"
--UPYUNSSL_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--UPYUNSSL_INPUTKEYPATH="/path/to/your-input-key.pem" \
--UPYUNSSL_USERNAME="your-username" \
--UPYUNSSL_PASSWORD="your-password"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/volcengine-cdn/volcengine_cdn.go
+15 -11
View File
@@ -37,12 +37,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -52,15 +52,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -83,8 +83,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
PageNum: ve.Int32(int32(listCertInfoPageNum)),
PageSize: ve.Int32(int32(listCertInfoPageSize)),
}
listCertInfoResp, err := m.sdkClient.ListCertInfo(listCertInfoReq)
m.logger.Debug("sdk request 'cdn.ListCertInfo'", slog.Any("request", listCertInfoReq), slog.Any("response", listCertInfoResp))
listCertInfoResp, err := c.sdkClient.ListCertInfo(listCertInfoReq)
c.logger.Debug("sdk request 'cdn.ListCertInfo'", slog.Any("request", listCertInfoReq), slog.Any("response", listCertInfoResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cdn.ListCertInfo': %w", err)
}
@@ -103,7 +103,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: ve.StringValue(certItem.CertId),
CertName: ve.StringValue(certItem.Desc),
@@ -128,8 +128,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
PrivateKey: ve.String(privkeyPEM),
Desc: ve.String(certName),
}
addCertificateResp, err := m.sdkClient.AddCertificate(addCertificateReq)
m.logger.Debug("sdk request 'cdn.AddCertificate'", slog.Any("request", addCertificateResp), slog.Any("response", addCertificateResp))
addCertificateResp, err := c.sdkClient.AddCertificate(addCertificateReq)
c.logger.Debug("sdk request 'cdn.AddCertificate'", slog.Any("request", addCertificateResp), slog.Any("response", addCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'cdn.AddCertificate': %w", err)
}
@@ -140,6 +140,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, accessKeySecret string) (*internal.CdnClient, error) {
config := ve.NewConfig().
WithAkSk(accessKeyId, accessKeySecret)
pkg/core/certmgr/providers/volcengine-certcenter/volcengine_certcenter.go
+12 -8
View File
@@ -33,12 +33,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -48,15 +48,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 上传证书
// REF: https://www.volcengine.com/docs/6638/1365580
importCertificateReq := &vecs.ImportCertificateInput{
@@ -66,8 +66,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
},
Repeatable: ve.Bool(false),
}
importCertificateResp, err := m.sdkClient.ImportCertificate(importCertificateReq)
m.logger.Debug("sdk request 'certcenter.ImportCertificate'", slog.Any("request", importCertificateReq), slog.Any("response", importCertificateResp))
importCertificateResp, err := c.sdkClient.ImportCertificate(importCertificateReq)
c.logger.Debug("sdk request 'certcenter.ImportCertificate'", slog.Any("request", importCertificateReq), slog.Any("response", importCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'certcenter.ImportCertificate': %w", err)
}
@@ -89,6 +89,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, accessKeySecret, region string) (*internal.CertificateserviceClient, error) {
if region == "" {
region = "cn-beijing" // 证书中心默认区域：北京
pkg/core/certmgr/providers/volcengine-certcenter/volcengine_certcenter_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_VOLCENGINECERTCENTER_"
argsPrefix := "VOLCENGINECERTCENTER_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./volcengine_certcenter_test.go -args \
--CERTIMATE_SSLMANAGER_VOLCENGINECERTCENTER_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_VOLCENGINECERTCENTER_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_VOLCENGINECERTCENTER_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_VOLCENGINECERTCENTER_ACCESSKEYSECRET="your-access-key-secret"
--VOLCENGINECERTCENTER_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--VOLCENGINECERTCENTER_INPUTKEYPATH="/path/to/your-input-key.pem" \
--VOLCENGINECERTCENTER_ACCESSKEYID="your-access-key-id" \
--VOLCENGINECERTCENTER_ACCESSKEYSECRET="your-access-key-secret"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/certmgr/providers/volcengine-live/volcengine_live.go
+16 -12
View File
@@ -32,7 +32,7 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client := velive.NewInstance()
@@ -46,20 +46,20 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 查询证书列表，避免重复上传
// REF: https://www.volcengine.com/docs/6469/1186278#%E6%9F%A5%E8%AF%A2%E8%AF%81%E4%B9%A6%E5%88%97%E8%A1%A8
listCertReq := &velive.ListCertV2Body{}
listCertResp, err := m.sdkClient.ListCertV2(ctx, listCertReq)
m.logger.Debug("sdk request 'live.ListCertV2'", slog.Any("request", listCertReq), slog.Any("response", listCertResp))
listCertResp, err := c.sdkClient.ListCertV2(ctx, listCertReq)
c.logger.Debug("sdk request 'live.ListCertV2'", slog.Any("request", listCertReq), slog.Any("response", listCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'live.ListCertV2': %w", err)
}
@@ -70,8 +70,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
describeCertDetailSecretReq := &velive.DescribeCertDetailSecretV2Body{
ChainID: ve.String(certItem.ChainID),
}
describeCertDetailSecretResp, err := m.sdkClient.DescribeCertDetailSecretV2(ctx, describeCertDetailSecretReq)
m.logger.Debug("sdk request 'live.DescribeCertDetailSecretV2'", slog.Any("request", describeCertDetailSecretReq), slog.Any("response", describeCertDetailSecretResp))
describeCertDetailSecretResp, err := c.sdkClient.DescribeCertDetailSecretV2(ctx, describeCertDetailSecretReq)
c.logger.Debug("sdk request 'live.DescribeCertDetailSecretV2'", slog.Any("request", describeCertDetailSecretReq), slog.Any("response", describeCertDetailSecretResp))
if err != nil {
continue
}
@@ -79,7 +79,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// 如果已存在相同证书，直接返回
oldCertPEM := strings.Join(describeCertDetailSecretResp.Result.SSL.Chain, "\n\n")
if xcert.EqualCertificatesFromPEM(certPEM, oldCertPEM) {
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: certItem.ChainID,
CertName: certItem.CertName,
@@ -101,8 +101,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
},
UseWay: "https",
}
createCertResp, err := m.sdkClient.CreateCert(ctx, createCertReq)
m.logger.Debug("sdk request 'live.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
createCertResp, err := c.sdkClient.CreateCert(ctx, createCertReq)
c.logger.Debug("sdk request 'live.CreateCert'", slog.Any("request", createCertReq), slog.Any("response", createCertResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'live.CreateCert': %w", err)
}
@@ -112,3 +112,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
CertName: certName,
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
pkg/core/certmgr/providers/wangsu-certificate/wangsu_certificate.go
+15 -11
View File
@@ -33,12 +33,12 @@ var _ certmgr.Provider = (*Certmgr)(nil)
func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl manager provider is nil")
return nil, errors.New("the configuration of the certmgr provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Certmgr{
@@ -48,15 +48,15 @@ func NewCertmgr(config *CertmgrConfig) (*Certmgr, error) {
}, nil
}
func (m *Certmgr) SetLogger(logger *slog.Logger) {
func (c *Certmgr) SetLogger(logger *slog.Logger) {
if logger == nil {
m.logger = slog.New(slog.DiscardHandler)
c.logger = slog.New(slog.DiscardHandler)
} else {
m.logger = logger
c.logger = logger
}
}
func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string) (*certmgr.UploadResult, error) {
func (c *Certmgr) Upload(ctx context.Context, certPEM, privkeyPEM string) (*certmgr.UploadResult, error) {
// 解析证书内容
certX509, err := xcert.ParseCertificateFromPEM(certPEM)
if err != nil {
@@ -65,8 +65,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
// 查询证书列表，避免重复上传
// REF: https://www.wangsu.com/document/api-doc/22675?productCode=certificatemanagement
listCertificatesResp, err := m.sdkClient.ListCertificates()
m.logger.Debug("sdk request 'certificatemanagement.ListCertificates'", slog.Any("response", listCertificatesResp))
listCertificatesResp, err := c.sdkClient.ListCertificates()
c.logger.Debug("sdk request 'certificatemanagement.ListCertificates'", slog.Any("response", listCertificatesResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'certificatemanagement.ListCertificates': %w", err)
}
@@ -87,7 +87,7 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}
// 如果以上信息都一致，则视为已存在相同证书，直接返回
m.logger.Info("ssl certificate already exists")
c.logger.Info("ssl certificate already exists")
return &certmgr.UploadResult{
CertId: certItem.CertificateId,
CertName: certItem.Name,
@@ -106,8 +106,8 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
PrivateKey: lo.ToPtr(privkeyPEM),
Comment: lo.ToPtr("upload from certimate"),
}
createCertificateResp, err := m.sdkClient.CreateCertificate(createCertificateReq)
m.logger.Debug("sdk request 'certificatemanagement.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))
createCertificateResp, err := c.sdkClient.CreateCertificate(createCertificateReq)
c.logger.Debug("sdk request 'certificatemanagement.CreateCertificate'", slog.Any("request", createCertificateReq), slog.Any("response", createCertificateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request 'certificatemanagement.CreateCertificate': %w", err)
}
@@ -126,6 +126,10 @@ func (m *Certmgr) Upload(ctx context.Context, certPEM string, privkeyPEM string)
}, nil
}
func (c *Certmgr) Replace(ctx context.Context, certIdOrName string, certPEM, privkeyPEM string) (*certmgr.OperateResult, error) {
return nil, certmgr.ErrUnsupported
}
func createSDKClient(accessKeyId, accessKeySecret string) (*wangsusdk.Client, error) {
return wangsusdk.NewClient(accessKeyId, accessKeySecret)
}
pkg/core/certmgr/providers/wangsu-certificate/wangsu_certificate_test.go
+5 -5
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLMANAGER_WANGSUCERTIFICATE_"
argsPrefix := "WANGSUCERTIFICATE_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -32,10 +32,10 @@ func init() {
Shell command to run this test:
go test -v ./wangsu_certificate_test.go -args \
--CERTIMATE_SSLMANAGER_WANGSUCERTIFICATE_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLMANAGER_WANGSUCERTIFICATE_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLMANAGER_WANGSUCERTIFICATE_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLMANAGER_WANGSUCERTIFICATE_ACCESSKEYSECRET="your-access-key-secret"
--WANGSUCERTIFICATE_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--WANGSUCERTIFICATE_INPUTKEYPATH="/path/to/your-input-key.pem" \
--WANGSUCERTIFICATE_ACCESSKEYID="your-access-key-id" \
--WANGSUCERTIFICATE_ACCESSKEYSECRET="your-access-key-secret"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/provider.go
+1 -1
View File
@@ -23,7 +23,7 @@ type Provider interface {
// 出参：
// - res：部署结果。
// - err: 错误。
Deploy(ctx context.Context, certPEM string, privkeyPEM string) (_res *DeployResult, _err error)
Deploy(ctx context.Context, certPEM, privkeyPEM string) (_res *DeployResult, _err error)
}
// 表示 SSL 证书部署结果的数据结构。
pkg/core/deployer/providers/1panel-console/1panel_console.go
+18 -18
View File
@@ -9,8 +9,8 @@ import (
"strconv"
"github.com/certimate-go/certimate/pkg/core/deployer"
opsdk "github.com/certimate-go/certimate/pkg/sdk3rd/1panel"
opsdkv2 "github.com/certimate-go/certimate/pkg/sdk3rd/1panel/v2"
onepanelsdk "github.com/certimate-go/certimate/pkg/sdk3rd/1panel"
onepanelsdk2 "github.com/certimate-go/certimate/pkg/sdk3rd/1panel/v2"
)
type DeployerConfig struct {
@@ -37,12 +37,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.ServerUrl, config.ApiVersion, config.ApiKey, config.AllowInsecureConnections)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Deployer{
@@ -60,43 +60,43 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 设置面板 SSL 证书
switch sdkClient := d.sdkClient.(type) {
case *opsdk.Client:
case *onepanelsdk.Client:
{
updateSettingsSSLReq := &opsdk.UpdateSettingsSSLRequest{
settingsSSLUpdateReq := &onepanelsdk.SettingsSSLUpdateRequest{
Cert: certPEM,
Key: privkeyPEM,
SSL: "enable",
SSLType: "import-paste",
AutoRestart: strconv.FormatBool(d.config.AutoRestart),
}
updateSystemSSLResp, err := sdkClient.UpdateSettingsSSL(updateSettingsSSLReq)
d.logger.Debug("sdk request '1panel.UpdateSettingsSSL'", slog.Any("request", updateSettingsSSLReq), slog.Any("response", updateSystemSSLResp))
settingsSSLUpdateResp, err := sdkClient.SettingsSSLUpdate(settingsSSLUpdateReq)
d.logger.Debug("sdk request '1panel.SettingsSSLUpdate'", slog.Any("request", settingsSSLUpdateReq), slog.Any("response", settingsSSLUpdateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.UpdateSettingsSSL': %w", err)
return nil, fmt.Errorf("failed to execute sdk request '1panel.SettingsSSLUpdate': %w", err)
}
}
case *opsdkv2.Client:
case *onepanelsdk2.Client:
{
updateCoreSettingsSSLReq := &opsdkv2.UpdateCoreSettingsSSLRequest{
coreSettingsSSLUpdateReq := &onepanelsdk2.CoreSettingsSSLUpdateRequest{
Cert: certPEM,
Key: privkeyPEM,
SSL: "Enable",
SSLType: "import-paste",
AutoRestart: strconv.FormatBool(d.config.AutoRestart),
}
updateCoreSystemSSLResp, err := sdkClient.UpdateCoreSettingsSSL(updateCoreSettingsSSLReq)
d.logger.Debug("sdk request '1panel.UpdateCoreSettingsSSL'", slog.Any("request", updateCoreSettingsSSLReq), slog.Any("response", updateCoreSystemSSLResp))
coreSettingsSSLUpdateResp, err := sdkClient.CoreSettingsSSLUpdate(coreSettingsSSLUpdateReq)
d.logger.Debug("sdk request '1panel.CoreSettingsSSLUpdate'", slog.Any("request", coreSettingsSSLUpdateReq), slog.Any("response", coreSettingsSSLUpdateResp))
if err != nil {
return nil, fmt.Errorf("failed to execute sdk request '1panel.UpdateCoreSettingsSSL': %w", err)
return nil, fmt.Errorf("failed to execute sdk request '1panel.CoreSettingsSSLUpdate': %w", err)
}
}
default:
panic("sdk client is not implemented")
panic("unreachable")
}
return &deployer.DeployResult{}, nil
@@ -109,7 +109,7 @@ const (
func createSDKClient(serverUrl, apiVersion, apiKey string, skipTlsVerify bool) (any, error) {
if apiVersion == sdkVersionV1 {
client, err := opsdk.NewClient(serverUrl, apiKey)
client, err := onepanelsdk.NewClient(serverUrl, apiKey)
if err != nil {
return nil, err
}
@@ -120,7 +120,7 @@ func createSDKClient(serverUrl, apiVersion, apiKey string, skipTlsVerify bool) (
return client, nil
} else if apiVersion == sdkVersionV2 {
client, err := opsdkv2.NewClient(serverUrl, apiKey)
client, err := onepanelsdk2.NewClient(serverUrl, apiKey)
if err != nil {
return nil, err
}
pkg/core/deployer/providers/1panel-console/1panel_console_test.go
+6 -6
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_1PANELCONSOLE_"
argsPrefix := "1PANELCONSOLE_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -33,11 +33,11 @@ func init() {
Shell command to run this test:
go test -v ./1panel_console_test.go -args \
--CERTIMATE_SSLDEPLOYER_1PANELCONSOLE_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_1PANELCONSOLE_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_1PANELCONSOLE_SERVERURL="http://127.0.0.1:20410" \
--CERTIMATE_SSLDEPLOYER_1PANELCONSOLE_APIVERSION="v1" \
--CERTIMATE_SSLDEPLOYER_1PANELCONSOLE_APIKEY="your-api-key"
--1PANELCONSOLE_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--1PANELCONSOLE_INPUTKEYPATH="/path/to/your-input-key.pem" \
--1PANELCONSOLE_SERVERURL="http://127.0.0.1:20410" \
--1PANELCONSOLE_APIVERSION="v1" \
--1PANELCONSOLE_APIKEY="your-api-key"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/1panel-site/1panel_site.go
+50 -95
View File
@@ -9,10 +9,10 @@ import (
"strconv"
"github.com/certimate-go/certimate/pkg/core/certmgr"
mcertmgr "github.com/certimate-go/certimate/pkg/core/certmgr/providers/1panel-ssl"
mcertmgr "github.com/certimate-go/certimate/pkg/core/certmgr/providers/1panel"
"github.com/certimate-go/certimate/pkg/core/deployer"
opsdk "github.com/certimate-go/certimate/pkg/sdk3rd/1panel"
opsdkv2 "github.com/certimate-go/certimate/pkg/sdk3rd/1panel/v2"
onepanelsdk "github.com/certimate-go/certimate/pkg/sdk3rd/1panel"
onepanelsdk2 "github.com/certimate-go/certimate/pkg/sdk3rd/1panel/v2"
)
type DeployerConfig struct {
@@ -49,12 +49,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.ServerUrl, config.ApiVersion, config.ApiKey, config.AllowInsecureConnections, config.NodeName)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -64,7 +64,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
AllowInsecureConnections: config.AllowInsecureConnections,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -85,7 +85,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 根据部署资源类型决定部署方式
switch d.config.ResourceType {
case RESOURCE_TYPE_WEBSITE:
@@ -105,7 +105,7 @@ func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string
return &deployer.DeployResult{}, nil
}
func (d *Deployer) deployToWebsite(ctx context.Context, certPEM string, privkeyPEM string) error {
func (d *Deployer) deployToWebsite(ctx context.Context, certPEM, privkeyPEM string) error {
if d.config.WebsiteId == 0 {
return errors.New("config `websiteId` is required")
}
@@ -119,125 +119,80 @@ func (d *Deployer) deployToWebsite(ctx context.Context, certPEM string, privkeyP
}
switch sdkClient := d.sdkClient.(type) {
case *opsdk.Client:
case *onepanelsdk.Client:
{
// 获取网站 HTTPS 配置
getHttpsConfResp, err := sdkClient.GetHttpsConf(d.config.WebsiteId)
d.logger.Debug("sdk request '1panel.GetHttpsConf'", slog.Int64("websiteId", d.config.WebsiteId), slog.Any("response", getHttpsConfResp))
websiteHttpsGetResp, err := sdkClient.WebsiteHttpsGet(d.config.WebsiteId)
d.logger.Debug("sdk request '1panel.WebsiteHttpsGet'", slog.Int64("websiteId", d.config.WebsiteId), slog.Any("response", websiteHttpsGetResp))
if err != nil {
return fmt.Errorf("failed to execute sdk request '1panel.GetHttpsConf': %w", err)
return fmt.Errorf("failed to execute sdk request '1panel.WebsiteHttpsGet': %w", err)
}
// 修改网站 HTTPS 配置
certId, _ := strconv.ParseInt(upres.CertId, 10, 64)
updateHttpsConfReq := &opsdk.UpdateHttpsConfRequest{
sslId, _ := strconv.ParseInt(upres.CertId, 10, 64)
websiteHttpsPostReq := &onepanelsdk.WebsiteHttpsPostRequest{
WebsiteID: d.config.WebsiteId,
Type: "existed",
WebsiteSSLID: certId,
Enable: getHttpsConfResp.Data.Enable,
HttpConfig: getHttpsConfResp.Data.HttpConfig,
SSLProtocol: getHttpsConfResp.Data.SSLProtocol,
Algorithm: getHttpsConfResp.Data.Algorithm,
Hsts: getHttpsConfResp.Data.Hsts,
WebsiteSSLID: sslId,
Enable: websiteHttpsGetResp.Data.Enable,
HttpConfig: websiteHttpsGetResp.Data.HttpConfig,
SSLProtocol: websiteHttpsGetResp.Data.SSLProtocol,
Algorithm: websiteHttpsGetResp.Data.Algorithm,
Hsts: websiteHttpsGetResp.Data.Hsts,
}
updateHttpsConfResp, err := sdkClient.UpdateHttpsConf(d.config.WebsiteId, updateHttpsConfReq)
d.logger.Debug("sdk request '1panel.UpdateHttpsConf'", slog.Int64("websiteId", d.config.WebsiteId), slog.Any("request", updateHttpsConfReq), slog.Any("response", updateHttpsConfResp))
websiteHttpsPostResp, err := sdkClient.WebsiteHttpsPost(d.config.WebsiteId, websiteHttpsPostReq)
d.logger.Debug("sdk request '1panel.WebsiteHttpsPost'", slog.Int64("websiteId", d.config.WebsiteId), slog.Any("request", websiteHttpsPostReq), slog.Any("response", websiteHttpsPostResp))
if err != nil {
return fmt.Errorf("failed to execute sdk request '1panel.UpdateHttpsConf': %w", err)
return fmt.Errorf("failed to execute sdk request '1panel.WebsiteHttpsPost': %w", err)
}
}
case *opsdkv2.Client:
case *onepanelsdk2.Client:
{
// 获取网站 HTTPS 配置
getHttpsConfResp, err := sdkClient.GetHttpsConf(d.config.WebsiteId)
d.logger.Debug("sdk request '1panel.GetHttpsConf'", slog.Int64("websiteId", d.config.WebsiteId), slog.Any("response", getHttpsConfResp))
websiteHttpsGetResp, err := sdkClient.WebsiteHttpsGet(d.config.WebsiteId)
d.logger.Debug("sdk request '1panel.WebsiteHttpsGet'", slog.Int64("websiteId", d.config.WebsiteId), slog.Any("response", websiteHttpsGetResp))
if err != nil {
return fmt.Errorf("failed to execute sdk request '1panel.GetHttpsConf': %w", err)
return fmt.Errorf("failed to execute sdk request '1panel.WebsiteHttpsGet': %w", err)
}
// 修改网站 HTTPS 配置
certId, _ := strconv.ParseInt(upres.CertId, 10, 64)
updateHttpsConfReq := &opsdkv2.UpdateHttpsConfRequest{
sslId, _ := strconv.ParseInt(upres.CertId, 10, 64)
websiteHttpsPostReq := &onepanelsdk2.WebsiteHttpsPostRequest{
WebsiteID: d.config.WebsiteId,
Type: "existed",
WebsiteSSLID: certId,
Enable: getHttpsConfResp.Data.Enable,
HttpConfig: getHttpsConfResp.Data.HttpConfig,
SSLProtocol: getHttpsConfResp.Data.SSLProtocol,
Algorithm: getHttpsConfResp.Data.Algorithm,
Hsts: getHttpsConfResp.Data.Hsts,
WebsiteSSLID: sslId,
Enable: websiteHttpsGetResp.Data.Enable,
HttpConfig: websiteHttpsGetResp.Data.HttpConfig,
SSLProtocol: websiteHttpsGetResp.Data.SSLProtocol,
Algorithm: websiteHttpsGetResp.Data.Algorithm,
Hsts: websiteHttpsGetResp.Data.Hsts,
}
updateHttpsConfResp, err := sdkClient.UpdateHttpsConf(d.config.WebsiteId, updateHttpsConfReq)
d.logger.Debug("sdk request '1panel.UpdateHttpsConf'", slog.Int64("websiteId", d.config.WebsiteId), slog.Any("request", updateHttpsConfReq), slog.Any("response", updateHttpsConfResp))
websiteHttpsPostResp, err := sdkClient.WebsiteHttpsPost(d.config.WebsiteId, websiteHttpsPostReq)
d.logger.Debug("sdk request '1panel.WebsiteHttpsPost'", slog.Int64("websiteId", d.config.WebsiteId), slog.Any("request", websiteHttpsPostReq), slog.Any("response", websiteHttpsPostResp))
if err != nil {
return fmt.Errorf("failed to execute sdk request '1panel.UpdateHttpsConf': %w", err)
return fmt.Errorf("failed to execute sdk request '1panel.WebsiteHttpsPost': %w", err)
}
}
default:
panic("sdk client is not implemented")
panic("unreachable")
}
return nil
}
func (d *Deployer) deployToCertificate(ctx context.Context, certPEM string, privkeyPEM string) error {
func (d *Deployer) deployToCertificate(ctx context.Context, certPEM, privkeyPEM string) error {
if d.config.CertificateId == 0 {
return errors.New("config `certificateId` is required")
}
switch sdkClient := d.sdkClient.(type) {
case *opsdk.Client:
{
// 获取证书详情
getWebsiteSSLResp, err := sdkClient.GetWebsiteSSL(d.config.CertificateId)
d.logger.Debug("sdk request '1panel.GetWebsiteSSL'", slog.Int64("sslId", d.config.CertificateId), slog.Any("response", getWebsiteSSLResp))
if err != nil {
return fmt.Errorf("failed to execute sdk request '1panel.GetWebsiteSSL': %w", err)
}
// 更新证书
uploadWebsiteSSLReq := &opsdk.UploadWebsiteSSLRequest{
SSLID: d.config.CertificateId,
Type: "paste",
Description: getWebsiteSSLResp.Data.Description,
Certificate: certPEM,
PrivateKey: privkeyPEM,
}
uploadWebsiteSSLResp, err := sdkClient.UploadWebsiteSSL(uploadWebsiteSSLReq)
d.logger.Debug("sdk request '1panel.UploadWebsiteSSL'", slog.Any("request", uploadWebsiteSSLReq), slog.Any("response", uploadWebsiteSSLResp))
if err != nil {
return fmt.Errorf("failed to execute sdk request '1panel.UploadWebsiteSSL': %w", err)
}
}
case *opsdkv2.Client:
{
// 获取证书详情
getWebsiteSSLResp, err := sdkClient.GetWebsiteSSL(d.config.CertificateId)
d.logger.Debug("sdk request '1panel.GetWebsiteSSL'", slog.Any("sslId", d.config.CertificateId), slog.Any("response", getWebsiteSSLResp))
if err != nil {
return fmt.Errorf("failed to execute sdk request '1panel.GetWebsiteSSL': %w", err)
}
// 更新证书
uploadWebsiteSSLReq := &opsdkv2.UploadWebsiteSSLRequest{
SSLID: d.config.CertificateId,
Type: "paste",
Description: getWebsiteSSLResp.Data.Description,
Certificate: certPEM,
PrivateKey: privkeyPEM,
}
uploadWebsiteSSLResp, err := sdkClient.UploadWebsiteSSL(uploadWebsiteSSLReq)
d.logger.Debug("sdk request '1panel.UploadWebsiteSSL'", slog.Any("request", uploadWebsiteSSLReq), slog.Any("response", uploadWebsiteSSLResp))
if err != nil {
return fmt.Errorf("failed to execute sdk request '1panel.UploadWebsiteSSL': %w", err)
}
}
default:
panic("sdk client is not implemented")
// 替换证书
opres, err := d.sdkCertmgr.Replace(ctx, fmt.Sprintf("%d", d.config.CertificateId), certPEM, privkeyPEM)
if err != nil {
return fmt.Errorf("failed to replace certificate file: %w", err)
} else {
d.logger.Info("ssl certificate replaced", slog.Any("result", opres))
}
return nil
@@ -250,7 +205,7 @@ const (
func createSDKClient(serverUrl, apiVersion, apiKey string, skipTlsVerify bool, nodeName string) (any, error) {
if apiVersion == sdkVersionV1 {
client, err := opsdk.NewClient(serverUrl, apiKey)
client, err := onepanelsdk.NewClient(serverUrl, apiKey)
if err != nil {
return nil, err
}
@@ -261,15 +216,15 @@ func createSDKClient(serverUrl, apiVersion, apiKey string, skipTlsVerify bool, n
return client, nil
} else if apiVersion == sdkVersionV2 {
var client *opsdkv2.Client
var client *onepanelsdk2.Client
if nodeName == "" {
temp, err := opsdkv2.NewClient(serverUrl, apiKey)
temp, err := onepanelsdk2.NewClient(serverUrl, apiKey)
if err != nil {
return nil, err
}
client = temp
} else {
temp, err := opsdkv2.NewClientWithNode(serverUrl, apiKey, nodeName)
temp, err := onepanelsdk2.NewClientWithNode(serverUrl, apiKey, nodeName)
if err != nil {
return nil, err
}
pkg/core/deployer/providers/1panel-site/1panel_site_test.go
+7 -7
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_1PANELSITE_"
argsPrefix := "1PANELSITE_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -35,12 +35,12 @@ func init() {
Shell command to run this test:
go test -v ./1panel_site_test.go -args \
--CERTIMATE_SSLDEPLOYER_1PANELSITE_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_1PANELSITE_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_1PANELSITE_SERVERURL="http://127.0.0.1:20410" \
--CERTIMATE_SSLDEPLOYER_1PANELSITE_APIVERSION="v1" \
--CERTIMATE_SSLDEPLOYER_1PANELSITE_APIKEY="your-api-key" \
--CERTIMATE_SSLDEPLOYER_1PANELSITE_WEBSITEID="your-website-id"
--1PANELSITE_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--1PANELSITE_INPUTKEYPATH="/path/to/your-input-key.pem" \
--1PANELSITE_SERVERURL="http://127.0.0.1:20410" \
--1PANELSITE_APIVERSION="v1" \
--1PANELSITE_APIKEY="your-api-key" \
--1PANELSITE_WEBSITEID="your-website-id"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-alb/aliyun_alb.go
+4 -4
View File
@@ -60,12 +60,12 @@ type wSDKClients struct {
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
clients, err := createSDKClients(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -77,7 +77,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Else("ap-southeast-1"),
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -98,7 +98,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/aliyun-alb/aliyun_alb_test.go
+9 -9
View File
@@ -23,7 +23,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNALB_"
argsPrefix := "ALIYUNALB_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -39,14 +39,14 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_alb_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNALB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNALB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNALB_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNALB_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNALB_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNALB_LOADBALANCERID="your-alb-instance-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNALB_LISTENERID="your-alb-listener-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNALB_DOMAIN="your-alb-sni-domain"
--ALIYUNALB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNALB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNALB_ACCESSKEYID="your-access-key-id" \
--ALIYUNALB_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNALB_REGION="cn-hangzhou" \
--ALIYUNALB_LOADBALANCERID="your-alb-instance-id" \
--ALIYUNALB_LISTENERID="your-alb-listener-id" \
--ALIYUNALB_DOMAIN="your-alb-sni-domain"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-apigw/aliyun_apigw.go
+6 -6
View File
@@ -63,12 +63,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
clients, err := createSDKClients(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -80,7 +80,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Else("ap-southeast-1"),
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -99,7 +99,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
switch d.config.ServiceType {
case SERVICE_TYPE_TRADITIONAL:
if err := d.deployToTraditional(ctx, certPEM, privkeyPEM); err != nil {
@@ -118,7 +118,7 @@ func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string
return &deployer.DeployResult{}, nil
}
func (d *Deployer) deployToTraditional(ctx context.Context, certPEM string, privkeyPEM string) error {
func (d *Deployer) deployToTraditional(ctx context.Context, certPEM, privkeyPEM string) error {
if d.config.GroupId == "" {
return errors.New("config `groupId` is required")
}
@@ -208,7 +208,7 @@ func (d *Deployer) deployToTraditional(ctx context.Context, certPEM string, priv
return nil
}
func (d *Deployer) deployToCloudNative(ctx context.Context, certPEM string, privkeyPEM string) error {
func (d *Deployer) deployToCloudNative(ctx context.Context, certPEM, privkeyPEM string) error {
if d.config.GatewayId == "" {
return errors.New("config `gatewayId` is required")
}
pkg/core/deployer/providers/aliyun-apigw/aliyun_apigw_test.go
+10 -10
View File
@@ -24,7 +24,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNAPIGW_"
argsPrefix := "ALIYUNAPIGW_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -41,15 +41,15 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_apigw_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNAPIGW_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNAPIGW_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNAPIGW_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNAPIGW_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNAPIGW_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNAPIGW_SERVICETYPE="cloudnative" \
--CERTIMATE_SSLDEPLOYER_ALIYUNAPIGW_GATEWAYID="your-api-gateway-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNAPIGW_GROUPID="your-api-group-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNAPIGW_DOMAIN="example.com"
--ALIYUNAPIGW_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNAPIGW_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNAPIGW_ACCESSKEYID="your-access-key-id" \
--ALIYUNAPIGW_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNAPIGW_REGION="cn-hangzhou" \
--ALIYUNAPIGW_SERVICETYPE="cloudnative" \
--ALIYUNAPIGW_GATEWAYID="your-api-gateway-id" \
--ALIYUNAPIGW_GROUPID="your-api-group-id" \
--ALIYUNAPIGW_DOMAIN="example.com"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-cas-deploy/aliyun_cas_deploy.go
+4 -4
View File
@@ -46,12 +46,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -61,7 +61,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Region: config.Region,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -82,7 +82,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
if len(d.config.ResourceIds) == 0 {
return nil, errors.New("config `resourceIds` is required")
}
pkg/core/deployer/providers/aliyun-cas/aliyun_cas.go
+3 -3
View File
@@ -32,7 +32,7 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -42,7 +42,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Region: config.Region,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -62,7 +62,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/aliyun-cdn/aliyun_cdn.go
+4 -4
View File
@@ -49,12 +49,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -66,7 +66,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Else("ap-southeast-1"),
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -85,7 +85,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/aliyun-cdn/aliyun_cdn_test.go
+6 -6
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNCDN_"
argsPrefix := "ALIYUNCDN_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -33,11 +33,11 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_cdn_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNCDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNCDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNCDN_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNCDN_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNCDN_DOMAIN="example.com"
--ALIYUNCDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNCDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNCDN_ACCESSKEYID="your-access-key-id" \
--ALIYUNCDN_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNCDN_DOMAIN="example.com"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-clb/aliyun_clb.go
+4 -4
View File
@@ -49,12 +49,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -64,7 +64,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Region: config.Region,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -85,7 +85,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/aliyun-clb/aliyun_clb_test.go
+9 -9
View File
@@ -23,7 +23,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNCLB_"
argsPrefix := "ALIYUNCLB_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -39,14 +39,14 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_clb_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNCLB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNCLB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNCLB_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNCLB_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNCLB_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNCLB_LOADBALANCERID="your-clb-instance-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNCLB_LISTENERPORT=443 \
--CERTIMATE_SSLDEPLOYER_ALIYUNCLB_DOMAIN="your-clb-sni-domain"
--ALIYUNCLB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNCLB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNCLB_ACCESSKEYID="your-access-key-id" \
--ALIYUNCLB_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNCLB_REGION="cn-hangzhou" \
--ALIYUNCLB_LOADBALANCERID="your-clb-instance-id" \
--ALIYUNCLB_LISTENERPORT=443 \
--ALIYUNCLB_DOMAIN="your-clb-sni-domain"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-dcdn/aliyun_dcdn.go
+4 -4
View File
@@ -49,12 +49,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -66,7 +66,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Else("ap-southeast-1"),
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -85,7 +85,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/aliyun-dcdn/aliyun_dcdn_test.go
+6 -6
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNDCDN_"
argsPrefix := "ALIYUNDCDN_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -33,11 +33,11 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_dcdn_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNDCDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNDCDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNDCDN_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNDCDN_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNDCDN_DOMAIN="example.com"
--ALIYUNDCDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNDCDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNDCDN_ACCESSKEYID="your-access-key-id" \
--ALIYUNDCDN_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNDCDN_DOMAIN="example.com"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-ddospro/aliyun_ddospro.go
+4 -4
View File
@@ -48,12 +48,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -65,7 +65,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Else("ap-southeast-1"),
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -86,7 +86,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/aliyun-ddospro/aliyun_ddospro_test.go
+7 -7
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNDDOSPRO_"
argsPrefix := "ALIYUNDDOSPRO_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -35,12 +35,12 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_ddospro_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNDDOSPRO_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNDDOSPRO_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNDDOSPRO_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNDDOSPRO_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNDDOSPRO_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNDDOSPRO_DOMAIN="example.com"
--ALIYUNDDOSPRO_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNDDOSPRO_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNDDOSPRO_ACCESSKEYID="your-access-key-id" \
--ALIYUNDDOSPRO_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNDDOSPRO_REGION="cn-hangzhou" \
--ALIYUNDDOSPRO_DOMAIN="example.com"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-esa/aliyun_esa.go
+4 -4
View File
@@ -44,12 +44,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -61,7 +61,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Else("ap-southeast-1"),
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -82,7 +82,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
if d.config.SiteId == 0 {
return nil, errors.New("config `siteId` is required")
}
pkg/core/deployer/providers/aliyun-esa/aliyun_esa_test.go
+7 -7
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNESA_"
argsPrefix := "ALIYUNESA_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -35,12 +35,12 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_esa_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNESA_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNESA_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNESA_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNESA_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNESA_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNESA_SITEID="your-esa-site-id"
--ALIYUNESA_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNESA_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNESA_ACCESSKEYID="your-access-key-id" \
--ALIYUNESA_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNESA_REGION="cn-hangzhou" \
--ALIYUNESA_SITEID="your-esa-site-id"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-fc/aliyun_fc.go
+5 -5
View File
@@ -55,12 +55,12 @@ type wSDKClients struct {
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
clients, err := createSDKClients(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Deployer{
@@ -78,7 +78,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
switch d.config.ServiceVersion {
case "3", "3.0":
if err := d.deployToFC3(ctx, certPEM, privkeyPEM); err != nil {
@@ -97,7 +97,7 @@ func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string
return &deployer.DeployResult{}, nil
}
func (d *Deployer) deployToFC3(ctx context.Context, certPEM string, privkeyPEM string) error {
func (d *Deployer) deployToFC3(ctx context.Context, certPEM, privkeyPEM string) error {
// 获取待部署的域名列表
var domains []string
switch d.config.DomainMatchPattern {
@@ -183,7 +183,7 @@ func (d *Deployer) deployToFC3(ctx context.Context, certPEM string, privkeyPEM s
return nil
}
func (d *Deployer) deployToFC2(ctx context.Context, certPEM string, privkeyPEM string) error {
func (d *Deployer) deployToFC2(ctx context.Context, certPEM, privkeyPEM string) error {
// 获取待部署的域名列表
var domains []string
switch d.config.DomainMatchPattern {
pkg/core/deployer/providers/aliyun-fc/aliyun_fc_test.go
+7 -7
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNFC_"
argsPrefix := "ALIYUNFC_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -35,12 +35,12 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_fc_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNFC_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNFC_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNFC_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNFC_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNFC_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNFC_DOMAIN="example.com"
--ALIYUNFC_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNFC_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNFC_ACCESSKEYID="your-access-key-id" \
--ALIYUNFC_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNFC_REGION="cn-hangzhou" \
--ALIYUNFC_DOMAIN="example.com"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-ga/aliyun_ga.go
+4 -4
View File
@@ -48,12 +48,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -63,7 +63,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Region: "cn-hangzhou",
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -84,7 +84,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/aliyun-ga/aliyun_ga_test.go
+8 -8
View File
@@ -22,7 +22,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNGA_"
argsPrefix := "ALIYUNGA_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -37,13 +37,13 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_ga_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNGA_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNGA_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNGA_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNGA_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNGA_ACCELERATORID="your-ga-accelerator-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNGA_LISTENERID="your-ga-listener-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNGA_DOMAIN="your-ga-sni-domain"
--ALIYUNGA_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNGA_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNGA_ACCESSKEYID="your-access-key-id" \
--ALIYUNGA_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNGA_ACCELERATORID="your-ga-accelerator-id" \
--ALIYUNGA_LISTENERID="your-ga-listener-id" \
--ALIYUNGA_DOMAIN="your-ga-sni-domain"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-live/aliyun_live.go
+3 -3
View File
@@ -46,12 +46,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Deployer{
@@ -69,7 +69,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 获取待部署的域名列表
var domains []string
switch d.config.DomainMatchPattern {
pkg/core/deployer/providers/aliyun-live/aliyun_live_test.go
+7 -7
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNLIVE_"
argsPrefix := "ALIYUNLIVE_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -35,12 +35,12 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_live_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNLIVE_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNLIVE_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNLIVE_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNLIVE_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNLIVE_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNLIVE_DOMAIN="example.com"
--ALIYUNLIVE_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNLIVE_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNLIVE_ACCESSKEYID="your-access-key-id" \
--ALIYUNLIVE_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNLIVE_REGION="cn-hangzhou" \
--ALIYUNLIVE_DOMAIN="example.com"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-nlb/aliyun_nlb.go
+4 -4
View File
@@ -49,12 +49,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -66,7 +66,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Else("ap-southeast-1"),
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -87,7 +87,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/aliyun-nlb/aliyun_nlb_test.go
+8 -8
View File
@@ -22,7 +22,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNNLB_"
argsPrefix := "ALIYUNNLB_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -37,13 +37,13 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_nlb_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNNLB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNNLB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNNLB_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNNLB_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNNLB_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNNLB_LOADBALANCERID="your-nlb-instance-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNNLB_LISTENERID="your-nlb-listener-id"
--ALIYUNNLB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNNLB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNNLB_ACCESSKEYID="your-access-key-id" \
--ALIYUNNLB_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNNLB_REGION="cn-hangzhou" \
--ALIYUNNLB_LOADBALANCERID="your-nlb-instance-id" \
--ALIYUNNLB_LISTENERID="your-nlb-listener-id"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-oss/aliyun_oss.go
+3 -3
View File
@@ -38,12 +38,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Deployer{
@@ -61,7 +61,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
if d.config.Bucket == "" {
return nil, errors.New("config `bucket` is required")
}
pkg/core/deployer/providers/aliyun-oss/aliyun_oss_test.go
+8 -8
View File
@@ -22,7 +22,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNOSS_"
argsPrefix := "ALIYUNOSS_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -37,13 +37,13 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_oss_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNOSS_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNOSS_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNOSS_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNOSS_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNOSS_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNOSS_BUCKET="your-oss-bucket" \
--CERTIMATE_SSLDEPLOYER_ALIYUNOSS_DOMAIN="example.com"
--ALIYUNOSS_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNOSS_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNOSS_ACCESSKEYID="your-access-key-id" \
--ALIYUNOSS_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNOSS_REGION="cn-hangzhou" \
--ALIYUNOSS_BUCKET="your-oss-bucket" \
--ALIYUNOSS_DOMAIN="example.com"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-vod/aliyun_vod.go
+4 -4
View File
@@ -49,12 +49,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -66,7 +66,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Else("ap-southeast-1"),
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -85,7 +85,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 获取待部署的域名列表
var domains []string
switch d.config.DomainMatchPattern {
pkg/core/deployer/providers/aliyun-vod/aliyun_vod_test.go
+7 -7
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNVOD_"
argsPrefix := "ALIYUNVOD_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -35,12 +35,12 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_vod_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNVOD_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNVOD_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNVOD_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNVOD_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNVOD_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNVOD_DOMAIN="example.com"
--ALIYUNVOD_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNVOD_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNVOD_ACCESSKEYID="your-access-key-id" \
--ALIYUNVOD_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNVOD_REGION="cn-hangzhou" \
--ALIYUNVOD_DOMAIN="example.com"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aliyun-waf/aliyun_waf.go
+5 -5
View File
@@ -60,12 +60,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.AccessKeySecret, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -77,7 +77,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Else("ap-southeast-1"),
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -98,7 +98,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
switch d.config.ServiceVersion {
case "3", "3.0":
if err := d.deployToWAF3(ctx, certPEM, privkeyPEM); err != nil {
@@ -112,7 +112,7 @@ func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string
return &deployer.DeployResult{}, nil
}
func (d *Deployer) deployToWAF3(ctx context.Context, certPEM string, privkeyPEM string) error {
func (d *Deployer) deployToWAF3(ctx context.Context, certPEM, privkeyPEM string) error {
if d.config.InstanceId == "" {
return errors.New("config `instanceId` is required")
}
pkg/core/deployer/providers/aliyun-waf/aliyun_waf_test.go
+7 -7
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_ALIYUNWAF_"
argsPrefix := "ALIYUNWAF_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -35,12 +35,12 @@ func init() {
Shell command to run this test:
go test -v ./aliyun_waf_test.go -args \
--CERTIMATE_SSLDEPLOYER_ALIYUNWAF_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNWAF_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_ALIYUNWAF_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_ALIYUNWAF_ACCESSKEYSECRET="your-access-key-secret" \
--CERTIMATE_SSLDEPLOYER_ALIYUNWAF_REGION="cn-hangzhou" \
--CERTIMATE_SSLDEPLOYER_ALIYUNWAF_INSTANCEID="your-waf-instance-id"
--ALIYUNWAF_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--ALIYUNWAF_INPUTKEYPATH="/path/to/your-input-key.pem" \
--ALIYUNWAF_ACCESSKEYID="your-access-key-id" \
--ALIYUNWAF_ACCESSKEYSECRET="your-access-key-secret" \
--ALIYUNWAF_REGION="cn-hangzhou" \
--ALIYUNWAF_INSTANCEID="your-waf-instance-id"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/apisix/apisix.go
+4 -4
View File
@@ -39,12 +39,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.ServerUrl, config.ApiKey, config.AllowInsecureConnections)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Deployer{
@@ -62,7 +62,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 根据部署资源类型决定部署方式
switch d.config.ResourceType {
case RESOURCE_TYPE_CERTIFICATE:
@@ -77,7 +77,7 @@ func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string
return &deployer.DeployResult{}, nil
}
func (d *Deployer) deployToCertificate(ctx context.Context, certPEM string, privkeyPEM string) error {
func (d *Deployer) deployToCertificate(ctx context.Context, certPEM, privkeyPEM string) error {
if d.config.CertificateId == "" {
return errors.New("config `certificateId` is required")
}
pkg/core/deployer/providers/apisix/apisix_test.go
+6 -6
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_APISIX_"
argsPrefix := "APISIX_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -33,11 +33,11 @@ func init() {
Shell command to run this test:
go test -v ./apisix_test.go -args \
--CERTIMATE_SSLDEPLOYER_APISIX_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_APISIX_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_APISIX_SERVERURL="http://127.0.0.1:9080" \
--CERTIMATE_SSLDEPLOYER_APISIX_APIKEY="your-api-key" \
--CERTIMATE_SSLDEPLOYER_APISIX_CERTIFICATEID="your-certificate-id"
--APISIX_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--APISIX_INPUTKEYPATH="/path/to/your-input-key.pem" \
--APISIX_SERVERURL="http://127.0.0.1:9080" \
--APISIX_APIKEY="your-api-key" \
--APISIX_CERTIFICATEID="your-certificate-id"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aws-acm/aws_acm.go
+2 -2
View File
@@ -33,7 +33,7 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -42,7 +42,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Region: config.Region,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
pkg/core/deployer/providers/aws-cloudfront/aws_cloudfront.go
+5 -5
View File
@@ -43,12 +43,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
var pcertmgr certmgr.Provider
@@ -60,7 +60,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
Region: config.Region,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
case CERTIFICATE_SOURCE_IAM:
@@ -71,7 +71,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
CertificatePath: "/cloudfront/",
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
default:
@@ -96,7 +96,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
if d.config.DistributionId == "" {
return nil, errors.New("config `distribuitionId` is required")
}
pkg/core/deployer/providers/aws-cloudfront/aws_cloudfront_test.go
+7 -7
View File
@@ -21,7 +21,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_AWSCLOUDFRONT_"
argsPrefix := "AWSCLOUDFRONT_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -35,12 +35,12 @@ func init() {
Shell command to run this test:
go test -v ./aws_cloudfront_test.go -args \
--CERTIMATE_SSLDEPLOYER_AWSCLOUDFRONT_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_AWSCLOUDFRONT_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_AWSCLOUDFRONT_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_AWSCLOUDFRONT_SECRETACCESSKEY="your-secret-access-id" \
--CERTIMATE_SSLDEPLOYER_AWSCLOUDFRONT_REGION="us-east-1" \
--CERTIMATE_SSLDEPLOYER_AWSCLOUDFRONT_DISTRIBUTIONID="your-distribution-id"
--AWSCLOUDFRONT_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--AWSCLOUDFRONT_INPUTKEYPATH="/path/to/your-input-key.pem" \
--AWSCLOUDFRONT_ACCESSKEYID="your-access-key-id" \
--AWSCLOUDFRONT_SECRETACCESSKEY="your-secret-access-id" \
--AWSCLOUDFRONT_REGION="us-east-1" \
--AWSCLOUDFRONT_DISTRIBUTIONID="your-distribution-id"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/aws-iam/aws_iam.go
+3 -3
View File
@@ -33,7 +33,7 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -43,7 +43,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
CertificatePath: config.CertificatePath,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -63,7 +63,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
d.sdkCertmgr.SetLogger(logger)
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/azure-keyvault/azure_keyvault.go
+3 -3
View File
@@ -43,12 +43,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.TenantId, config.ClientId, config.ClientSecret, config.CloudName, config.KeyVaultName)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -59,7 +59,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
KeyVaultName: config.KeyVaultName,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
pkg/core/deployer/providers/baiducloud-appblb/baiducloud_appblb.go
+4 -4
View File
@@ -48,12 +48,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -61,7 +61,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
SecretAccessKey: config.SecretAccessKey,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -80,7 +80,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/baiducloud-appblb/baiducloud_appblb_test.go
+8 -8
View File
@@ -22,7 +22,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_BAIDUCLOUDAPPBLB_"
argsPrefix := "BAIDUCLOUDAPPBLB_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -37,13 +37,13 @@ func init() {
Shell command to run this test:
go test -v ./baiducloud_appblb_test.go -args \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDAPPBLB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDAPPBLB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDAPPBLB_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDAPPBLB_SECRETACCESSKEY="your-secret-access-key" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDAPPBLB_REGION="bj" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDAPPBLB_LOADBALANCERID="your-blb-loadbalancer-id" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDAPPBLB_DOMAIN="your-blb-sni-domain"
--BAIDUCLOUDAPPBLB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--BAIDUCLOUDAPPBLB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--BAIDUCLOUDAPPBLB_ACCESSKEYID="your-access-key-id" \
--BAIDUCLOUDAPPBLB_SECRETACCESSKEY="your-secret-access-key" \
--BAIDUCLOUDAPPBLB_REGION="bj" \
--BAIDUCLOUDAPPBLB_LOADBALANCERID="your-blb-loadbalancer-id" \
--BAIDUCLOUDAPPBLB_DOMAIN="your-blb-sni-domain"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/baiducloud-blb/baiducloud_blb.go
+4 -4
View File
@@ -48,12 +48,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey, config.Region)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -61,7 +61,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
SecretAccessKey: config.SecretAccessKey,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -80,7 +80,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {
pkg/core/deployer/providers/baiducloud-blb/baiducloud_blb_test.go
+8 -8
View File
@@ -22,7 +22,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_BAIDUCLOUDBLB_"
argsPrefix := "BAIDUCLOUDBLB_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -37,13 +37,13 @@ func init() {
Shell command to run this test:
go test -v ./baiducloud_blb_test.go -args \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDBLB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDBLB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDBLB_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDBLB_SECRETACCESSKEY="your-secret-access-key" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDBLB_REGION="bj" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDBLB_LOADBALANCERID="your-blb-loadbalancer-id" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDBLB_DOMAIN="your-blb-sni-domain"
--BAIDUCLOUDBLB_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--BAIDUCLOUDBLB_INPUTKEYPATH="/path/to/your-input-key.pem" \
--BAIDUCLOUDBLB_ACCESSKEYID="your-access-key-id" \
--BAIDUCLOUDBLB_SECRETACCESSKEY="your-secret-access-key" \
--BAIDUCLOUDBLB_REGION="bj" \
--BAIDUCLOUDBLB_LOADBALANCERID="your-blb-loadbalancer-id" \
--BAIDUCLOUDBLB_DOMAIN="your-blb-sni-domain"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/baiducloud-cdn/baiducloud_cdn.go
+3 -3
View File
@@ -39,12 +39,12 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
client, err := createSDKClient(config.AccessKeyId, config.SecretAccessKey)
if err != nil {
return nil, fmt.Errorf("could not create sdk client: %w", err)
return nil, fmt.Errorf("could not create client: %w", err)
}
return &Deployer{
@@ -62,7 +62,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 获取待部署的域名列表
var domains []string
switch d.config.DomainMatchPattern {
pkg/core/deployer/providers/baiducloud-cdn/baiducloud_cdn_test.go
+6 -6
View File
@@ -20,7 +20,7 @@ var (
)
func init() {
argsPrefix := "CERTIMATE_SSLDEPLOYER_BAIDUCLOUDCDN_"
argsPrefix := "BAIDUCLOUDCDN_"
flag.StringVar(&fInputCertPath, argsPrefix+"INPUTCERTPATH", "", "")
flag.StringVar(&fInputKeyPath, argsPrefix+"INPUTKEYPATH", "", "")
@@ -33,11 +33,11 @@ func init() {
Shell command to run this test:
go test -v ./baiducloud_cdn_test.go -args \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDCDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDCDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDCDN_ACCESSKEYID="your-access-key-id" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDCDN_SECRETACCESSKEY="your-secret-access-key" \
--CERTIMATE_SSLDEPLOYER_BAIDUCLOUDCDN_DOMAIN="example.com"
--BAIDUCLOUDCDN_INPUTCERTPATH="/path/to/your-input-cert.pem" \
--BAIDUCLOUDCDN_INPUTKEYPATH="/path/to/your-input-key.pem" \
--BAIDUCLOUDCDN_ACCESSKEYID="your-access-key-id" \
--BAIDUCLOUDCDN_SECRETACCESSKEY="your-secret-access-key" \
--BAIDUCLOUDCDN_DOMAIN="example.com"
*/
func TestDeploy(t *testing.T) {
flag.Parse()
pkg/core/deployer/providers/baiducloud-cert/baiducloud_cert.go
+3 -3
View File
@@ -28,7 +28,7 @@ var _ deployer.Provider = (*Deployer)(nil)
func NewDeployer(config *DeployerConfig) (*Deployer, error) {
if config == nil {
return nil, errors.New("the configuration of the ssl deployer provider is nil")
return nil, errors.New("the configuration of the deployer provider is nil")
}
pcertmgr, err := mcertmgr.NewCertmgr(&mcertmgr.CertmgrConfig{
@@ -36,7 +36,7 @@ func NewDeployer(config *DeployerConfig) (*Deployer, error) {
SecretAccessKey: config.SecretAccessKey,
})
if err != nil {
return nil, fmt.Errorf("could not create ssl manager: %w", err)
return nil, fmt.Errorf("could not create certmgr: %w", err)
}
return &Deployer{
@@ -54,7 +54,7 @@ func (d *Deployer) SetLogger(logger *slog.Logger) {
}
}
func (d *Deployer) Deploy(ctx context.Context, certPEM string, privkeyPEM string) (*deployer.DeployResult, error) {
func (d *Deployer) Deploy(ctx context.Context, certPEM, privkeyPEM string) (*deployer.DeployResult, error) {
// 上传证书
upres, err := d.sdkCertmgr.Upload(ctx, certPEM, privkeyPEM)
if err != nil {

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