diff --git a/pkg/core/ssl-applicator/acme-dns01/providers/jdcloud/internal/client.go b/pkg/core/ssl-applicator/acme-dns01/providers/jdcloud/internal/client.go new file mode 100644 index 000000000..bdcaaa2f2 --- /dev/null +++ b/pkg/core/ssl-applicator/acme-dns01/providers/jdcloud/internal/client.go @@ -0,0 +1,94 @@ +package internal + +import ( + "encoding/json" + "errors" + + "github.com/jdcloud-api/jdcloud-sdk-go/core" + domainservice "github.com/jdcloud-api/jdcloud-sdk-go/services/domainservice/apis" +) + +// This is a partial copy of https://github.com/jdcloud-api/jdcloud-sdk-go/blob/master/services/domainservice/client/DomainserviceClient.go +// to lightweight the vendor packages in the built binary. +type DomainserviceClient struct { + core.JDCloudClient +} + +func NewDomainserviceClient(credential *core.Credential) *DomainserviceClient { + if credential == nil { + return nil + } + + config := core.NewConfig() + config.SetEndpoint("domainservice.jdcloud-api.com") + + return &DomainserviceClient{ + core.JDCloudClient{ + Credential: *credential, + Config: *config, + ServiceName: "domainservice", + Revision: "2.0.3", + Logger: core.NewDummyLogger(), + }, + } +} + +func (c *DomainserviceClient) CreateResourceRecord(request *domainservice.CreateResourceRecordRequest) (*domainservice.CreateResourceRecordResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &domainservice.CreateResourceRecordResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} + +func (c *DomainserviceClient) DescribeDomains(request *domainservice.DescribeDomainsRequest) (*domainservice.DescribeDomainsResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &domainservice.DescribeDomainsResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} + +func (c *DomainserviceClient) DeleteResourceRecord(request *domainservice.DeleteResourceRecordRequest) (*domainservice.DeleteResourceRecordResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &domainservice.DeleteResourceRecordResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} diff --git a/pkg/core/ssl-applicator/acme-dns01/providers/jdcloud/internal/lego.go b/pkg/core/ssl-applicator/acme-dns01/providers/jdcloud/internal/lego.go index 78bc5ac27..95322aa6c 100644 --- a/pkg/core/ssl-applicator/acme-dns01/providers/jdcloud/internal/lego.go +++ b/pkg/core/ssl-applicator/acme-dns01/providers/jdcloud/internal/lego.go @@ -10,8 +10,7 @@ import ( "github.com/go-acme/lego/v4/challenge/dns01" "github.com/go-acme/lego/v4/platform/config/env" jdcore "github.com/jdcloud-api/jdcloud-sdk-go/core" - jddnsapi "github.com/jdcloud-api/jdcloud-sdk-go/services/domainservice/apis" - jddnsclient "github.com/jdcloud-api/jdcloud-sdk-go/services/domainservice/client" + jddns "github.com/jdcloud-api/jdcloud-sdk-go/services/domainservice/apis" jddnsmodel "github.com/jdcloud-api/jdcloud-sdk-go/services/domainservice/models" ) @@ -42,7 +41,7 @@ type Config struct { } type DNSProvider struct { - client *jddnsclient.DomainserviceClient + client *DomainserviceClient config *Config recordIDs map[string]int @@ -78,11 +77,8 @@ func NewDNSProviderConfig(config *Config) (*DNSProvider, error) { } clientCredentials := jdcore.NewCredentials(config.AccessKeyID, config.AccessKeySecret) - client := jddnsclient.NewDomainserviceClient(clientCredentials) - clientConfig := &client.Config - clientConfig.SetTimeout(config.HTTPTimeout) - client.SetConfig(clientConfig) - client.DisableLogger() + client := NewDomainserviceClient(clientCredentials) + client.Config.SetTimeout(config.HTTPTimeout) return &DNSProvider{ client: client, @@ -111,7 +107,10 @@ func (d *DNSProvider) Present(domain, token, keyAuth string) error { } // REF: https://docs.jdcloud.com/cn/jd-cloud-dns/api/createresourcerecord - jddnsCreateResourceRecordReq := jddnsapi.NewCreateResourceRecordRequest(d.config.RegionId, fmt.Sprintf("%d", zone.Id), &jddnsmodel.AddRR{ + jddnsCreateResourceRecordReq := jddns.NewCreateResourceRecordRequestWithoutParam() + jddnsCreateResourceRecordReq.SetRegionId(d.config.RegionId) + jddnsCreateResourceRecordReq.SetDomainId(fmt.Sprintf("%d", zone.Id)) + jddnsCreateResourceRecordReq.SetReq(&jddnsmodel.AddRR{ Type: "TXT", HostRecord: subDomain, HostValue: info.Value, @@ -151,7 +150,10 @@ func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error { } // REF: https://docs.jdcloud.com/cn/jd-cloud-dns/api/deleteresourcerecord - jddnsDeleteResourceRecordReq := jddnsapi.NewDeleteResourceRecordRequest(d.config.RegionId, fmt.Sprintf("%d", zone.Id), fmt.Sprintf("%d", recordID)) + jddnsDeleteResourceRecordReq := jddns.NewDeleteResourceRecordRequestWithoutParam() + jddnsDeleteResourceRecordReq.SetRegionId(d.config.RegionId) + jddnsDeleteResourceRecordReq.SetDomainId(fmt.Sprintf("%d", zone.Id)) + jddnsDeleteResourceRecordReq.SetResourceRecordId(fmt.Sprintf("%d", recordID)) _, err = d.client.DeleteResourceRecord(jddnsDeleteResourceRecordReq) if err != nil { return fmt.Errorf("jdcloud: error when delete record: %w", err) @@ -169,7 +171,10 @@ func (d *DNSProvider) getDNSZone(zoneName string) (*jddnsmodel.DomainInfo, error pageSize := 10 for { // REF: https://docs.jdcloud.com/cn/jd-cloud-dns/api/describedomains - jddnsDescribeDomainsReq := jddnsapi.NewDescribeDomainsRequest(d.config.RegionId, pageNumber, pageSize) + jddnsDescribeDomainsReq := jddns.NewDescribeDomainsRequestWithoutParam() + jddnsDescribeDomainsReq.SetRegionId(d.config.RegionId) + jddnsDescribeDomainsReq.SetPageNumber(pageNumber) + jddnsDescribeDomainsReq.SetPageSize(pageSize) jddnsDescribeDomainsReq.SetDomainName(zoneName) jddnsDescribeDomainsResp, err := d.client.DescribeDomains(jddnsDescribeDomainsReq) diff --git a/pkg/core/ssl-deployer/providers/jdcloud-alb/internal/client.go b/pkg/core/ssl-deployer/providers/jdcloud-alb/internal/client.go new file mode 100644 index 000000000..5a5b6991e --- /dev/null +++ b/pkg/core/ssl-deployer/providers/jdcloud-alb/internal/client.go @@ -0,0 +1,134 @@ +package internal + +import ( + "encoding/json" + "errors" + + "github.com/jdcloud-api/jdcloud-sdk-go/core" + lb "github.com/jdcloud-api/jdcloud-sdk-go/services/lb/apis" +) + +// This is a partial copy of https://github.com/jdcloud-api/jdcloud-sdk-go/blob/master/services/lb/client/LbClient.go +// to lightweight the vendor packages in the built binary. +type LbClient struct { + core.JDCloudClient +} + +func NewLbClient(credential *core.Credential) *LbClient { + if credential == nil { + return nil + } + + config := core.NewConfig() + config.SetEndpoint("lb.jdcloud-api.com") + + return &LbClient{ + core.JDCloudClient{ + Credential: *credential, + Config: *config, + ServiceName: "lb", + Revision: "0.6.6", + Logger: core.NewDefaultLogger(core.LogInfo), + }, + } +} + +func (c *LbClient) DescribeListener(request *lb.DescribeListenerRequest) (*lb.DescribeListenerResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &lb.DescribeListenerResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} + +func (c *LbClient) DescribeListeners(request *lb.DescribeListenersRequest) (*lb.DescribeListenersResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &lb.DescribeListenersResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} + +func (c *LbClient) DescribeLoadBalancer(request *lb.DescribeLoadBalancerRequest) (*lb.DescribeLoadBalancerResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &lb.DescribeLoadBalancerResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} + +func (c *LbClient) UpdateListener(request *lb.UpdateListenerRequest) (*lb.UpdateListenerResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &lb.UpdateListenerResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} + +func (c *LbClient) UpdateListenerCertificates(request *lb.UpdateListenerCertificatesRequest) (*lb.UpdateListenerCertificatesResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &lb.UpdateListenerCertificatesResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} diff --git a/pkg/core/ssl-deployer/providers/jdcloud-alb/jdcloud_alb.go b/pkg/core/ssl-deployer/providers/jdcloud-alb/jdcloud_alb.go index 3f641e98d..b69d2cf86 100644 --- a/pkg/core/ssl-deployer/providers/jdcloud-alb/jdcloud_alb.go +++ b/pkg/core/ssl-deployer/providers/jdcloud-alb/jdcloud_alb.go @@ -9,12 +9,12 @@ import ( jdcore "github.com/jdcloud-api/jdcloud-sdk-go/core" jdcommon "github.com/jdcloud-api/jdcloud-sdk-go/services/common/models" - jdlbapi "github.com/jdcloud-api/jdcloud-sdk-go/services/lb/apis" - jdlbclient "github.com/jdcloud-api/jdcloud-sdk-go/services/lb/client" + jdlb "github.com/jdcloud-api/jdcloud-sdk-go/services/lb/apis" jdlbmodel "github.com/jdcloud-api/jdcloud-sdk-go/services/lb/models" "github.com/samber/lo" "github.com/certimate-go/certimate/pkg/core" + "github.com/certimate-go/certimate/pkg/core/ssl-deployer/providers/jdcloud-alb/internal" sslmgrsp "github.com/certimate-go/certimate/pkg/core/ssl-manager/providers/jdcloud-ssl" ) @@ -41,7 +41,7 @@ type SSLDeployerProviderConfig struct { type SSLDeployerProvider struct { config *SSLDeployerProviderConfig logger *slog.Logger - sdkClient *jdlbclient.LbClient + sdkClient *internal.LbClient sslManager core.SSLManager } @@ -118,7 +118,9 @@ func (d *SSLDeployerProvider) deployToLoadbalancer(ctx context.Context, cloudCer // 查询负载均衡器详情 // REF: https://docs.jdcloud.com/cn/load-balancer/api/describeloadbalancer - describeLoadBalancerReq := jdlbapi.NewDescribeLoadBalancerRequest(d.config.RegionId, d.config.LoadbalancerId) + describeLoadBalancerReq := jdlb.NewDescribeLoadBalancerRequestWithoutParam() + describeLoadBalancerReq.SetRegionId(d.config.RegionId) + describeLoadBalancerReq.SetLoadBalancerId(d.config.LoadbalancerId) describeLoadBalancerResp, err := d.sdkClient.DescribeLoadBalancer(describeLoadBalancerReq) d.logger.Debug("sdk request 'lb.DescribeLoadBalancer'", slog.Any("request", describeLoadBalancerReq), slog.Any("response", describeLoadBalancerResp)) if err != nil { @@ -137,7 +139,8 @@ func (d *SSLDeployerProvider) deployToLoadbalancer(ctx context.Context, cloudCer default: } - describeListenersReq := jdlbapi.NewDescribeListenersRequest(d.config.RegionId) + describeListenersReq := jdlb.NewDescribeListenersRequestWithoutParam() + describeListenersReq.SetRegionId(d.config.RegionId) describeListenersReq.SetFilters([]jdcommon.Filter{{Name: "loadBalancerId", Values: []string{d.config.LoadbalancerId}}}) describeListenersReq.SetPageSize(describeListenersPageNumber) describeListenersReq.SetPageSize(describeListenersPageSize) @@ -203,7 +206,9 @@ func (d *SSLDeployerProvider) deployToListener(ctx context.Context, cloudCertId func (d *SSLDeployerProvider) updateListenerCertificate(ctx context.Context, cloudListenerId string, cloudCertId string) error { // 查询监听器详情 // REF: https://docs.jdcloud.com/cn/load-balancer/api/describelistener - describeListenerReq := jdlbapi.NewDescribeListenerRequest(d.config.RegionId, cloudListenerId) + describeListenerReq := jdlb.NewDescribeListenerRequestWithoutParam() + describeListenerReq.SetRegionId(d.config.RegionId) + describeListenerReq.SetListenerId(cloudListenerId) describeListenerResp, err := d.sdkClient.DescribeListener(describeListenerReq) d.logger.Debug("sdk request 'lb.DescribeListener'", slog.Any("request", describeListenerReq), slog.Any("response", describeListenerResp)) if err != nil { @@ -215,7 +220,9 @@ func (d *SSLDeployerProvider) updateListenerCertificate(ctx context.Context, clo // 修改监听器信息 // REF: https://docs.jdcloud.com/cn/load-balancer/api/updatelistener - updateListenerReq := jdlbapi.NewUpdateListenerRequest(d.config.RegionId, cloudListenerId) + updateListenerReq := jdlb.NewUpdateListenerRequestWithoutParam() + updateListenerReq.SetRegionId(d.config.RegionId) + updateListenerReq.SetListenerId(cloudListenerId) updateListenerReq.SetCertificateSpecs([]jdlbmodel.CertificateSpec{{CertificateId: cloudCertId}}) updateListenerResp, err := d.sdkClient.UpdateListener(updateListenerReq) d.logger.Debug("sdk request 'lb.UpdateListener'", slog.Any("request", updateListenerReq), slog.Any("response", updateListenerResp)) @@ -234,17 +241,16 @@ func (d *SSLDeployerProvider) updateListenerCertificate(ctx context.Context, clo // 批量修改扩展证书 // REF: https://docs.jdcloud.com/cn/load-balancer/api/updatelistenercertificates - updateListenerCertificatesReq := jdlbapi.NewUpdateListenerCertificatesRequest( - d.config.RegionId, - cloudListenerId, - lo.Map(extCertSpecs, func(extCertSpec jdlbmodel.ExtensionCertificateSpec, _ int) jdlbmodel.ExtCertificateUpdateSpec { - return jdlbmodel.ExtCertificateUpdateSpec{ - CertificateBindId: extCertSpec.CertificateBindId, - CertificateId: &cloudCertId, - Domain: &extCertSpec.Domain, - } - }), - ) + updateListenerCertificatesReq := jdlb.NewUpdateListenerCertificatesRequestWithoutParam() + updateListenerCertificatesReq.SetRegionId(d.config.RegionId) + updateListenerCertificatesReq.SetListenerId(cloudListenerId) + updateListenerCertificatesReq.SetCertificates(lo.Map(extCertSpecs, func(extCertSpec jdlbmodel.ExtensionCertificateSpec, _ int) jdlbmodel.ExtCertificateUpdateSpec { + return jdlbmodel.ExtCertificateUpdateSpec{ + CertificateBindId: extCertSpec.CertificateBindId, + CertificateId: &cloudCertId, + Domain: &extCertSpec.Domain, + } + })) updateListenerCertificatesResp, err := d.sdkClient.UpdateListenerCertificates(updateListenerCertificatesReq) d.logger.Debug("sdk request 'lb.UpdateListenerCertificates'", slog.Any("request", updateListenerCertificatesReq), slog.Any("response", updateListenerCertificatesResp)) if err != nil { @@ -255,9 +261,8 @@ func (d *SSLDeployerProvider) updateListenerCertificate(ctx context.Context, clo return nil } -func createSDKClient(accessKeyId, accessKeySecret string) (*jdlbclient.LbClient, error) { +func createSDKClient(accessKeyId, accessKeySecret string) (*internal.LbClient, error) { clientCredentials := jdcore.NewCredentials(accessKeyId, accessKeySecret) - client := jdlbclient.NewLbClient(clientCredentials) - client.DisableLogger() + client := internal.NewLbClient(clientCredentials) return client, nil } diff --git a/pkg/core/ssl-deployer/providers/jdcloud-cdn/internal/client.go b/pkg/core/ssl-deployer/providers/jdcloud-cdn/internal/client.go new file mode 100644 index 000000000..44d4971da --- /dev/null +++ b/pkg/core/ssl-deployer/providers/jdcloud-cdn/internal/client.go @@ -0,0 +1,74 @@ +package internal + +import ( + "encoding/json" + "errors" + + "github.com/jdcloud-api/jdcloud-sdk-go/core" + cdn "github.com/jdcloud-api/jdcloud-sdk-go/services/cdn/apis" +) + +// This is a partial copy of https://github.com/jdcloud-api/jdcloud-sdk-go/blob/master/services/cdn/client/CdnClient.go +// to lightweight the vendor packages in the built binary. +type CdnClient struct { + core.JDCloudClient +} + +func NewCdnClient(credential *core.Credential) *CdnClient { + if credential == nil { + return nil + } + + config := core.NewConfig() + config.SetEndpoint("cdn.jdcloud-api.com") + + return &CdnClient{ + core.JDCloudClient{ + Credential: *credential, + Config: *config, + ServiceName: "cdn", + Revision: "0.10.47", + Logger: core.NewDummyLogger(), + }, + } +} + +func (c *CdnClient) QueryDomainConfig(request *cdn.QueryDomainConfigRequest) (*cdn.QueryDomainConfigResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &cdn.QueryDomainConfigResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} + +func (c *CdnClient) SetHttpType(request *cdn.SetHttpTypeRequest) (*cdn.SetHttpTypeResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &cdn.SetHttpTypeResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} diff --git a/pkg/core/ssl-deployer/providers/jdcloud-cdn/jdcloud_cdn.go b/pkg/core/ssl-deployer/providers/jdcloud-cdn/jdcloud_cdn.go index 9415e9a58..64866b1c0 100644 --- a/pkg/core/ssl-deployer/providers/jdcloud-cdn/jdcloud_cdn.go +++ b/pkg/core/ssl-deployer/providers/jdcloud-cdn/jdcloud_cdn.go @@ -7,10 +7,10 @@ import ( "log/slog" jdcore "github.com/jdcloud-api/jdcloud-sdk-go/core" - jdcdnapi "github.com/jdcloud-api/jdcloud-sdk-go/services/cdn/apis" - jdcdnclient "github.com/jdcloud-api/jdcloud-sdk-go/services/cdn/client" + jdcdn "github.com/jdcloud-api/jdcloud-sdk-go/services/cdn/apis" "github.com/certimate-go/certimate/pkg/core" + "github.com/certimate-go/certimate/pkg/core/ssl-deployer/providers/jdcloud-cdn/internal" sslmgrsp "github.com/certimate-go/certimate/pkg/core/ssl-manager/providers/jdcloud-ssl" ) @@ -26,7 +26,7 @@ type SSLDeployerProviderConfig struct { type SSLDeployerProvider struct { config *SSLDeployerProviderConfig logger *slog.Logger - sdkClient *jdcdnclient.CdnClient + sdkClient *internal.CdnClient sslManager core.SSLManager } @@ -75,7 +75,8 @@ func (d *SSLDeployerProvider) Deploy(ctx context.Context, certPEM string, privke // 查询域名配置信息 // REF: https://docs.jdcloud.com/cn/cdn/api/querydomainconfig - queryDomainConfigReq := jdcdnapi.NewQueryDomainConfigRequest(d.config.Domain) + queryDomainConfigReq := jdcdn.NewQueryDomainConfigRequestWithoutParam() + queryDomainConfigReq.SetDomain(d.config.Domain) queryDomainConfigResp, err := d.sdkClient.QueryDomainConfig(queryDomainConfigReq) d.logger.Debug("sdk request 'cdn.QueryDomainConfig'", slog.Any("request", queryDomainConfigReq), slog.Any("response", queryDomainConfigResp)) if err != nil { @@ -92,7 +93,8 @@ func (d *SSLDeployerProvider) Deploy(ctx context.Context, certPEM string, privke // 设置通讯协议 // REF: https://docs.jdcloud.com/cn/cdn/api/sethttptype - setHttpTypeReq := jdcdnapi.NewSetHttpTypeRequest(d.config.Domain) + setHttpTypeReq := jdcdn.NewSetHttpTypeRequestWithoutParam() + setHttpTypeReq.SetDomain(d.config.Domain) setHttpTypeReq.SetHttpType("https") setHttpTypeReq.SetCertificate(certPEM) setHttpTypeReq.SetRsaKey(privkeyPEM) @@ -108,9 +110,8 @@ func (d *SSLDeployerProvider) Deploy(ctx context.Context, certPEM string, privke return &core.SSLDeployResult{}, nil } -func createSDKClient(accessKeyId, accessKeySecret string) (*jdcdnclient.CdnClient, error) { +func createSDKClient(accessKeyId, accessKeySecret string) (*internal.CdnClient, error) { clientCredentials := jdcore.NewCredentials(accessKeyId, accessKeySecret) - client := jdcdnclient.NewCdnClient(clientCredentials) - client.DisableLogger() + client := internal.NewCdnClient(clientCredentials) return client, nil } diff --git a/pkg/core/ssl-deployer/providers/jdcloud-live/internal/client.go b/pkg/core/ssl-deployer/providers/jdcloud-live/internal/client.go new file mode 100644 index 000000000..bdbc6044c --- /dev/null +++ b/pkg/core/ssl-deployer/providers/jdcloud-live/internal/client.go @@ -0,0 +1,54 @@ +package internal + +import ( + "encoding/json" + "errors" + + "github.com/jdcloud-api/jdcloud-sdk-go/core" + live "github.com/jdcloud-api/jdcloud-sdk-go/services/live/apis" +) + +// This is a partial copy of https://github.com/jdcloud-api/jdcloud-sdk-go/blob/master/services/live/client/LiveClient.go +// to lightweight the vendor packages in the built binary. +type LiveClient struct { + core.JDCloudClient +} + +func NewLiveClient(credential *core.Credential) *LiveClient { + if credential == nil { + return nil + } + + config := core.NewConfig() + config.SetEndpoint("live.jdcloud-api.com") + + return &LiveClient{ + core.JDCloudClient{ + Credential: *credential, + Config: *config, + ServiceName: "live", + Revision: "1.0.22", + Logger: core.NewDummyLogger(), + }, + } +} + +func (c *LiveClient) SetLiveDomainCertificate(request *live.SetLiveDomainCertificateRequest) (*live.SetLiveDomainCertificateResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &live.SetLiveDomainCertificateResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} diff --git a/pkg/core/ssl-deployer/providers/jdcloud-live/jdcloud_live.go b/pkg/core/ssl-deployer/providers/jdcloud-live/jdcloud_live.go index fb4dc7b7b..ae2da9acc 100644 --- a/pkg/core/ssl-deployer/providers/jdcloud-live/jdcloud_live.go +++ b/pkg/core/ssl-deployer/providers/jdcloud-live/jdcloud_live.go @@ -8,8 +8,9 @@ import ( "github.com/certimate-go/certimate/pkg/core" jdcore "github.com/jdcloud-api/jdcloud-sdk-go/core" - jdliveapi "github.com/jdcloud-api/jdcloud-sdk-go/services/live/apis" - jdliveclient "github.com/jdcloud-api/jdcloud-sdk-go/services/live/client" + jdlive "github.com/jdcloud-api/jdcloud-sdk-go/services/live/apis" + + "github.com/certimate-go/certimate/pkg/core/ssl-deployer/providers/jdcloud-live/internal" ) type SSLDeployerProviderConfig struct { @@ -24,7 +25,7 @@ type SSLDeployerProviderConfig struct { type SSLDeployerProvider struct { config *SSLDeployerProviderConfig logger *slog.Logger - sdkClient *jdliveclient.LiveClient + sdkClient *internal.LiveClient } var _ core.SSLDeployer = (*SSLDeployerProvider)(nil) @@ -61,7 +62,9 @@ func (d *SSLDeployerProvider) Deploy(ctx context.Context, certPEM string, privke // 设置直播证书 // REF: https://docs.jdcloud.com/cn/live-video/api/setlivedomaincertificate - setLiveDomainCertificateReq := jdliveapi.NewSetLiveDomainCertificateRequest(d.config.Domain, "on") + setLiveDomainCertificateReq := jdlive.NewSetLiveDomainCertificateRequestWithoutParam() + setLiveDomainCertificateReq.SetPlayDomain(d.config.Domain) + setLiveDomainCertificateReq.SetCertStatus("on") setLiveDomainCertificateReq.SetCert(certPEM) setLiveDomainCertificateReq.SetKey(privkeyPEM) setLiveDomainCertificateResp, err := d.sdkClient.SetLiveDomainCertificate(setLiveDomainCertificateReq) @@ -73,9 +76,8 @@ func (d *SSLDeployerProvider) Deploy(ctx context.Context, certPEM string, privke return &core.SSLDeployResult{}, nil } -func createSDKClient(accessKeyId, accessKeySecret string) (*jdliveclient.LiveClient, error) { +func createSDKClient(accessKeyId, accessKeySecret string) (*internal.LiveClient, error) { clientCredentials := jdcore.NewCredentials(accessKeyId, accessKeySecret) - client := jdliveclient.NewLiveClient(clientCredentials) - client.DisableLogger() + client := internal.NewLiveClient(clientCredentials) return client, nil } diff --git a/pkg/core/ssl-deployer/providers/jdcloud-vod/internal/client.go b/pkg/core/ssl-deployer/providers/jdcloud-vod/internal/client.go new file mode 100644 index 000000000..c69cb4cf3 --- /dev/null +++ b/pkg/core/ssl-deployer/providers/jdcloud-vod/internal/client.go @@ -0,0 +1,94 @@ +package internal + +import ( + "encoding/json" + "errors" + + "github.com/jdcloud-api/jdcloud-sdk-go/core" + vod "github.com/jdcloud-api/jdcloud-sdk-go/services/vod/apis" +) + +// This is a partial copy of https://github.com/jdcloud-api/jdcloud-sdk-go/blob/master/services/vod/client/VodClient.go +// to lightweight the vendor packages in the built binary. +type VodClient struct { + core.JDCloudClient +} + +func NewVodClient(credential *core.Credential) *VodClient { + if credential == nil { + return nil + } + + config := core.NewConfig() + config.SetEndpoint("vod.jdcloud-api.com") + + return &VodClient{ + core.JDCloudClient{ + Credential: *credential, + Config: *config, + ServiceName: "vod", + Revision: "1.2.1", + Logger: core.NewDummyLogger(), + }, + } +} + +func (c *VodClient) ListDomains(request *vod.ListDomainsRequest) (*vod.ListDomainsResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &vod.ListDomainsResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} + +func (c *VodClient) GetHttpSsl(request *vod.GetHttpSslRequest) (*vod.GetHttpSslResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &vod.GetHttpSslResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} + +func (c *VodClient) SetHttpSsl(request *vod.SetHttpSslRequest) (*vod.SetHttpSslResponse, error) { + if request == nil { + return nil, errors.New("Request object is nil.") + } + + resp, err := c.Send(request, c.ServiceName) + if err != nil { + return nil, err + } + + jdResp := &vod.SetHttpSslResponse{} + err = json.Unmarshal(resp, jdResp) + if err != nil { + c.Logger.Log(core.LogError, "Unmarshal json failed, resp: %s", string(resp)) + return nil, err + } + + return jdResp, err +} diff --git a/pkg/core/ssl-deployer/providers/jdcloud-vod/jdcloud_vod.go b/pkg/core/ssl-deployer/providers/jdcloud-vod/jdcloud_vod.go index c18d033bd..82d90eb2f 100644 --- a/pkg/core/ssl-deployer/providers/jdcloud-vod/jdcloud_vod.go +++ b/pkg/core/ssl-deployer/providers/jdcloud-vod/jdcloud_vod.go @@ -10,8 +10,9 @@ import ( "github.com/certimate-go/certimate/pkg/core" jdcore "github.com/jdcloud-api/jdcloud-sdk-go/core" - jdvodapi "github.com/jdcloud-api/jdcloud-sdk-go/services/vod/apis" - jdvodclient "github.com/jdcloud-api/jdcloud-sdk-go/services/vod/client" + jdvod "github.com/jdcloud-api/jdcloud-sdk-go/services/vod/apis" + + "github.com/certimate-go/certimate/pkg/core/ssl-deployer/providers/jdcloud-vod/internal" ) type SSLDeployerProviderConfig struct { @@ -26,7 +27,7 @@ type SSLDeployerProviderConfig struct { type SSLDeployerProvider struct { config *SSLDeployerProviderConfig logger *slog.Logger - sdkClient *jdvodclient.VodClient + sdkClient *internal.VodClient } var _ core.SSLDeployer = (*SSLDeployerProvider)(nil) @@ -69,9 +70,9 @@ func (d *SSLDeployerProvider) Deploy(ctx context.Context, certPEM string, privke default: } - listDomainsReq := jdvodapi.NewListDomainsRequest() - listDomainsReq.SetPageNumber(1) - listDomainsReq.SetPageSize(100) + listDomainsReq := jdvod.NewListDomainsRequestWithoutParam() + listDomainsReq.SetPageNumber(listDomainsPageNumber) + listDomainsReq.SetPageSize(listDomainsPageSize) listDomainsResp, err := d.sdkClient.ListDomains(listDomainsReq) d.logger.Debug("sdk request 'vod.ListDomains'", slog.Any("request", listDomainsReq), slog.Any("response", listDomainsResp)) if err != nil { @@ -97,7 +98,8 @@ func (d *SSLDeployerProvider) Deploy(ctx context.Context, certPEM string, privke // 查询域名 SSL 配置 // REF: https://docs.jdcloud.com/cn/video-on-demand/api/gethttpssl - getHttpSslReq := jdvodapi.NewGetHttpSslRequest(domainId) + getHttpSslReq := jdvod.NewGetHttpSslRequestWithoutParam() + getHttpSslReq.SetDomainId(domainId) getHttpSslResp, err := d.sdkClient.GetHttpSsl(getHttpSslReq) d.logger.Debug("sdk request 'vod.GetHttpSsl'", slog.Any("request", getHttpSslReq), slog.Any("response", getHttpSslResp)) if err != nil { @@ -106,7 +108,8 @@ func (d *SSLDeployerProvider) Deploy(ctx context.Context, certPEM string, privke // 设置域名 SSL 配置 // REF: https://docs.jdcloud.com/cn/video-on-demand/api/sethttpssl - setHttpSslReq := jdvodapi.NewSetHttpSslRequest(domainId) + setHttpSslReq := jdvod.NewSetHttpSslRequestWithoutParam() + setHttpSslReq.SetDomainId(domainId) setHttpSslReq.SetTitle(fmt.Sprintf("certimate-%d", time.Now().UnixMilli())) setHttpSslReq.SetSslCert(certPEM) setHttpSslReq.SetSslKey(privkeyPEM) @@ -122,9 +125,8 @@ func (d *SSLDeployerProvider) Deploy(ctx context.Context, certPEM string, privke return &core.SSLDeployResult{}, nil } -func createSDKClient(accessKeyId, accessKeySecret string) (*jdvodclient.VodClient, error) { +func createSDKClient(accessKeyId, accessKeySecret string) (*internal.VodClient, error) { clientCredentials := jdcore.NewCredentials(accessKeyId, accessKeySecret) - client := jdvodclient.NewVodClient(clientCredentials) - client.DisableLogger() + client := internal.NewVodClient(clientCredentials) return client, nil } diff --git a/pkg/core/ssl-manager/providers/jdcloud-ssl/jdcloud_ssl.go b/pkg/core/ssl-manager/providers/jdcloud-ssl/jdcloud_ssl.go index d667fbe30..7f3861f27 100644 --- a/pkg/core/ssl-manager/providers/jdcloud-ssl/jdcloud_ssl.go +++ b/pkg/core/ssl-manager/providers/jdcloud-ssl/jdcloud_ssl.go @@ -82,7 +82,7 @@ func (m *SSLManagerProvider) Upload(ctx context.Context, certPEM string, privkey default: } - describeCertsReq := jdsslapi.NewDescribeCertsRequest() + describeCertsReq := jdsslapi.NewDescribeCertsRequestWithoutParam() describeCertsReq.SetDomainName(certX509.Subject.CommonName) describeCertsReq.SetPageNumber(describeCertsPageNumber) describeCertsReq.SetPageSize(describeCertsPageSize) @@ -137,7 +137,10 @@ func (m *SSLManagerProvider) Upload(ctx context.Context, certPEM string, privkey // 上传证书 // REF: https://docs.jdcloud.com/cn/ssl-certificate/api/uploadcert - uploadCertReq := jdsslapi.NewUploadCertRequest(certName, privkeyPEM, certPEM) + uploadCertReq := jdsslapi.NewUploadCertRequestWithoutParam() + 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)) if err != nil { @@ -153,6 +156,6 @@ func (m *SSLManagerProvider) Upload(ctx context.Context, certPEM string, privkey func createSDKClient(accessKeyId, accessKeySecret string) (*jdsslclient.SslClient, error) { clientCredentials := jdcore.NewCredentials(accessKeyId, accessKeySecret) client := jdsslclient.NewSslClient(clientCredentials) - client.SetLogger(jdcore.NewDefaultLogger(jdcore.LogWarn)) + client.DisableLogger() return client, nil }