Add DNS Provider for ALIYUN DNS (#620)

Gopkg.lock

@@ -66,6 +66,25 @@
   revision = "196fbdab2db66d0e231cc363efb63454f55fed1c"
   version = "v0.6.2"
 
+[[projects]]
+  digest = "1:823e87ae25170339e2bfd1d6f7c2e27554c6bb5655f91c67b37bd5be45bb6b32"
+  name = "github.com/aliyun/alibaba-cloud-sdk-go"
+  packages = [
+    "sdk",
+    "sdk/auth",
+    "sdk/auth/credentials",
+    "sdk/auth/signers",
+    "sdk/endpoints",
+    "sdk/errors",
+    "sdk/requests",
+    "sdk/responses",
+    "sdk/utils",
+    "services/alidns",
+  ]
+  pruneopts = "NUT"
+  revision = "cad214d7d71fba7883fcf3b7e550ba782c15b400"
+  version = "1.27.7"
+
 [[projects]]
   digest = "1:1634c57333a07adf7d7e206d3329340f1c36e82bca9e61e2cff08c064ab85046"
   name = "github.com/aws/aws-sdk-go"
@@ -503,6 +522,8 @@
     "github.com/OpenDNS/vegadns2client",
     "github.com/akamai/AkamaiOPEN-edgegrid-golang/configdns-v1",
     "github.com/akamai/AkamaiOPEN-edgegrid-golang/edgegrid",
+    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests",
+    "github.com/aliyun/alibaba-cloud-sdk-go/services/alidns",
     "github.com/aws/aws-sdk-go/aws",
     "github.com/aws/aws-sdk-go/aws/client",
     "github.com/aws/aws-sdk-go/aws/credentials",

cli.go

@@ -203,6 +203,7 @@ Here is an example bash command using the CloudFlare DNS provider:
 	fmt.Fprintln(w, "Valid providers and their associated credential environment variables:")
 	fmt.Fprintln(w)
 	fmt.Fprintln(w, "\tacme-dns:\tACME_DNS_API_BASE, ACME_DNS_STORAGE_PATH")
+	fmt.Fprintln(w, "\talidns:\tALIDNS_API_KEY, ALIDNS_SECRET_KEY")
 	fmt.Fprintln(w, "\tazure:\tAZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_SUBSCRIPTION_ID, AZURE_TENANT_ID, AZURE_RESOURCE_GROUP")
 	fmt.Fprintln(w, "\tauroradns:\tAURORA_USER_ID, AURORA_KEY, AURORA_ENDPOINT")
 	fmt.Fprintln(w, "\tbluecat:\tBLUECAT_SERVER_URL, BLUECAT_USER_NAME, BLUECAT_PASSWORD, BLUECAT_CONFIG_NAME, BLUECAT_DNS_VIEW")

providers/dns/alidns/alidns.go

@@ -0,0 +1,166 @@
+// Package alidns implements a DNS provider for solving the DNS-01 challenge
+// using Alibaba Cloud DNS.
+package alidns
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/services/alidns"
+	"github.com/xenolf/lego/acme"
+	"github.com/xenolf/lego/platform/config/env"
+)
+
+const defaultRegionID = "cn-hangzhou"
+
+// DNSProvider is an implementation of the acme.ChallengeProvider interface
+type DNSProvider struct {
+	client *alidns.Client
+}
+
+// NewDNSProvider returns a DNSProvider instance configured for Alibaba Cloud DNS.
+// Credentials must be passed in the environment variables: ALIDNS_API_KEY and ALIDNS_SECRET_KEY.
+func NewDNSProvider() (*DNSProvider, error) {
+	values, err := env.Get("ALIDNS_API_KEY", "ALIDNS_SECRET_KEY")
+	if err != nil {
+		return nil, fmt.Errorf("AliDNS: %v", err)
+	}
+
+	regionID := os.Getenv("ALIDNS_REGION_ID")
+
+	return NewDNSProviderCredentials(values["ALIDNS_API_KEY"], values["ALIDNS_SECRET_KEY"], regionID)
+}
+
+// NewDNSProviderCredentials uses the supplied credentials to return a DNSProvider instance configured for alidns.
+func NewDNSProviderCredentials(apiKey, secretKey, regionID string) (*DNSProvider, error) {
+	if apiKey == "" || secretKey == "" {
+		return nil, fmt.Errorf("AliDNS: credentials missing")
+	}
+
+	if len(regionID) == 0 {
+		regionID = defaultRegionID
+	}
+
+	client, err := alidns.NewClientWithAccessKey(regionID, apiKey, secretKey)
+	if err != nil {
+		return nil, fmt.Errorf("AliDNS: credentials failed: %v", err)
+	}
+
+	return &DNSProvider{
+		client: client,
+	}, nil
+}
+
+// Present creates a TXT record to fulfil the dns-01 challenge.
+func (d *DNSProvider) Present(domain, token, keyAuth string) error {
+	fqdn, value, ttl := acme.DNS01Record(domain, keyAuth)
+
+	_, zoneName, err := d.getHostedZone(domain)
+	if err != nil {
+		return err
+	}
+
+	recordAttributes := d.newTxtRecord(zoneName, fqdn, value, ttl)
+
+	_, err = d.client.AddDomainRecord(recordAttributes)
+	if err != nil {
+		return fmt.Errorf("AliDNS: API call failed: %v", err)
+	}
+	return nil
+}
+
+// CleanUp removes the TXT record matching the specified parameters.
+func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
+	fqdn, _, _ := acme.DNS01Record(domain, keyAuth)
+
+	records, err := d.findTxtRecords(domain, fqdn)
+	if err != nil {
+		return err
+	}
+
+	_, _, err = d.getHostedZone(domain)
+	if err != nil {
+		return err
+	}
+
+	for _, rec := range records {
+		request := alidns.CreateDeleteDomainRecordRequest()
+		request.RecordId = rec.RecordId
+		_, err = d.client.DeleteDomainRecord(request)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (d *DNSProvider) getHostedZone(domain string) (string, string, error) {
+	request := alidns.CreateDescribeDomainsRequest()
+	zones, err := d.client.DescribeDomains(request)
+	if err != nil {
+		return "", "", fmt.Errorf("AliDNS: API call failed: %v", err)
+	}
+
+	authZone, err := acme.FindZoneByFqdn(acme.ToFqdn(domain), acme.RecursiveNameservers)
+	if err != nil {
+		return "", "", err
+	}
+
+	var hostedZone alidns.Domain
+	for _, zone := range zones.Domains.Domain {
+		if zone.DomainName == acme.UnFqdn(authZone) {
+			hostedZone = zone
+		}
+	}
+
+	if hostedZone.DomainId == "" {
+		return "", "", fmt.Errorf("AliDNS: zone %s not found in AliDNS for domain %s", authZone, domain)
+	}
+	return fmt.Sprintf("%v", hostedZone.DomainId), hostedZone.DomainName, nil
+}
+
+func (d *DNSProvider) newTxtRecord(zone, fqdn, value string, ttl int) *alidns.AddDomainRecordRequest {
+	request := alidns.CreateAddDomainRecordRequest()
+	request.Type = "TXT"
+	request.DomainName = zone
+	request.RR = d.extractRecordName(fqdn, zone)
+	request.Value = value
+	request.TTL = requests.NewInteger(600)
+	return request
+}
+
+func (d *DNSProvider) findTxtRecords(domain, fqdn string) ([]alidns.Record, error) {
+	_, zoneName, err := d.getHostedZone(domain)
+	if err != nil {
+		return nil, err
+	}
+
+	request := alidns.CreateDescribeDomainRecordsRequest()
+	request.DomainName = zoneName
+	request.PageSize = requests.NewInteger(500)
+
+	var records []alidns.Record
+
+	result, err := d.client.DescribeDomainRecords(request)
+	if err != nil {
+		return records, fmt.Errorf("AliDNS: API call has failed: %v", err)
+	}
+
+	recordName := d.extractRecordName(fqdn, zoneName)
+	for _, record := range result.DomainRecords.Record {
+		if record.RR == recordName {
+			records = append(records, record)
+		}
+	}
+	return records, nil
+}
+
+func (d *DNSProvider) extractRecordName(fqdn, domain string) string {
+	name := acme.UnFqdn(fqdn)
+	if idx := strings.Index(name, "."+domain); idx != -1 {
+		return name[:idx]
+	}
+	return name
+}

providers/dns/alidns/alidns_test.go

@@ -0,0 +1,82 @@
+package alidns
+
+import (
+	"os"
+	"testing"
+	"time"
+	// "time"
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	alidnsLiveTest  bool
+	alidnsAPIKey    string
+	alidnsSecretKey string
+	alidnsDomain    string
+)
+
+func init() {
+	alidnsAPIKey = os.Getenv("ALIDNS_API_KEY")
+	alidnsSecretKey = os.Getenv("ALIDNS_SECRET_KEY")
+	alidnsDomain = os.Getenv("ALIDNS_DOMAIN")
+
+	if len(alidnsAPIKey) > 0 && len(alidnsSecretKey) > 0 && len(alidnsDomain) > 0 {
+		alidnsLiveTest = true
+	}
+}
+
+func restoreEnv() {
+	os.Setenv("ALIDNS_API_KEY", alidnsAPIKey)
+	os.Setenv("ALIDNS_SECRET_KEY", alidnsSecretKey)
+}
+
+func TestNewDNSProviderValid(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("ALIDNS_API_KEY", "")
+	os.Setenv("ALIDNS_SECRET_KEY", "")
+
+	_, err := NewDNSProviderCredentials("123", "123", "")
+	assert.NoError(t, err)
+}
+
+func TestNewDNSProviderValidEnv(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("ALIDNS_API_KEY", "123")
+	os.Setenv("ALIDNS_SECRET_KEY", "123")
+
+	_, err := NewDNSProvider()
+	assert.NoError(t, err)
+}
+
+func TestNewDNSProviderMissingCredErr(t *testing.T) {
+	defer restoreEnv()
+	os.Setenv("CLOUDXNS_API_KEY", "")
+	os.Setenv("CLOUDXNS_SECRET_KEY", "")
+
+	_, err := NewDNSProvider()
+	assert.EqualError(t, err, "AliDNS: some credentials information are missing: ALIDNS_API_KEY,ALIDNS_SECRET_KEY")
+}
+
+func TestCloudXNSPresent(t *testing.T) {
+	if !alidnsLiveTest {
+		t.Skip("skipping live test")
+	}
+
+	provider, err := NewDNSProviderCredentials(alidnsAPIKey, alidnsSecretKey, "")
+	assert.NoError(t, err)
+
+	err = provider.Present(alidnsDomain, "", "123d==")
+	assert.NoError(t, err)
+}
+
+func TestLivednspodCleanUp(t *testing.T) {
+	if !alidnsLiveTest {
+		t.Skip("skipping live test")
+	}
+
+	time.Sleep(time.Second * 1)
+	provider, err := NewDNSProviderCredentials(alidnsAPIKey, alidnsSecretKey, "")
+	assert.NoError(t, err)
+	err = provider.CleanUp(alidnsDomain, "", "123d==")
+	assert.NoError(t, err)
+}

providers/dns/dns_providers.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/xenolf/lego/acme"
 	"github.com/xenolf/lego/providers/dns/acmedns"
+	"github.com/xenolf/lego/providers/dns/alidns"
 	"github.com/xenolf/lego/providers/dns/auroradns"
 	"github.com/xenolf/lego/providers/dns/azure"
 	"github.com/xenolf/lego/providers/dns/bluecat"
@@ -48,6 +49,8 @@ func NewDNSChallengeProviderByName(name string) (acme.ChallengeProvider, error)
 	switch name {
 	case "acme-dns":
 		return acmedns.NewDNSProvider()
+	case "alidns":
+		return alidns.NewDNSProvider()
 	case "azure":
 		return azure.NewDNSProvider()
 	case "auroradns":

vendor/github.com/aliyun/alibaba-cloud-sdk-go/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credential.go

@@ -0,0 +1,18 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package auth
+
+type Credential interface {
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/access_key_credential.go

@@ -0,0 +1,34 @@
+package credentials
+
+// Deprecated: Use AccessKeyCredential in this package instead.
+type BaseCredential struct {
+	AccessKeyId     string
+	AccessKeySecret string
+}
+
+type AccessKeyCredential struct {
+	AccessKeyId     string
+	AccessKeySecret string
+}
+
+// Deprecated: Use NewAccessKeyCredential in this package instead.
+func NewBaseCredential(accessKeyId, accessKeySecret string) *BaseCredential {
+	return &BaseCredential{
+		AccessKeyId:     accessKeyId,
+		AccessKeySecret: accessKeySecret,
+	}
+}
+
+func (baseCred *BaseCredential) ToAccessKeyCredential() *AccessKeyCredential {
+	return &AccessKeyCredential{
+		AccessKeyId:     baseCred.AccessKeyId,
+		AccessKeySecret: baseCred.AccessKeySecret,
+	}
+}
+
+func NewAccessKeyCredential(accessKeyId, accessKeySecret string) *AccessKeyCredential {
+	return &AccessKeyCredential{
+		AccessKeyId:     accessKeyId,
+		AccessKeySecret: accessKeySecret,
+	}
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/ecs_ram_role.go

@@ -0,0 +1,29 @@
+package credentials
+
+// Deprecated: Use EcsRamRoleCredential in this package instead.
+type StsRoleNameOnEcsCredential struct {
+	RoleName string
+}
+
+// Deprecated: Use NewEcsRamRoleCredential in this package instead.
+func NewStsRoleNameOnEcsCredential(roleName string) *StsRoleNameOnEcsCredential {
+	return &StsRoleNameOnEcsCredential{
+		RoleName: roleName,
+	}
+}
+
+func (oldCred *StsRoleNameOnEcsCredential) ToEcsRamRoleCredential() *EcsRamRoleCredential {
+	return &EcsRamRoleCredential{
+		RoleName: oldCred.RoleName,
+	}
+}
+
+type EcsRamRoleCredential struct {
+	RoleName string
+}
+
+func NewEcsRamRoleCredential(roleName string) *EcsRamRoleCredential {
+	return &EcsRamRoleCredential{
+		RoleName: roleName,
+	}
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/rsa_key_pair_credential.go

@@ -0,0 +1,15 @@
+package credentials
+
+type RsaKeyPairCredential struct {
+	PrivateKey        string
+	PublicKeyId       string
+	SessionExpiration int
+}
+
+func NewRsaKeyPairCredential(privateKey, publicKeyId string, sessionExpiration int) *RsaKeyPairCredential {
+	return &RsaKeyPairCredential{
+		PrivateKey:        privateKey,
+		PublicKeyId:       publicKeyId,
+		SessionExpiration: sessionExpiration,
+	}
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/sts_credential.go

@@ -0,0 +1,15 @@
+package credentials
+
+type StsTokenCredential struct {
+	AccessKeyId       string
+	AccessKeySecret   string
+	AccessKeyStsToken string
+}
+
+func NewStsTokenCredential(accessKeyId, accessKeySecret, accessKeyStsToken string) *StsTokenCredential {
+	return &StsTokenCredential{
+		AccessKeyId:       accessKeyId,
+		AccessKeySecret:   accessKeySecret,
+		AccessKeyStsToken: accessKeyStsToken,
+	}
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/sts_role_arn_credential.go

@@ -0,0 +1,49 @@
+package credentials
+
+// Deprecated: Use RamRoleArnCredential in this package instead.
+type StsRoleArnCredential struct {
+	AccessKeyId           string
+	AccessKeySecret       string
+	RoleArn               string
+	RoleSessionName       string
+	RoleSessionExpiration int
+}
+
+type RamRoleArnCredential struct {
+	AccessKeyId           string
+	AccessKeySecret       string
+	RoleArn               string
+	RoleSessionName       string
+	RoleSessionExpiration int
+}
+
+// Deprecated: Use RamRoleArnCredential in this package instead.
+func NewStsRoleArnCredential(accessKeyId, accessKeySecret, roleArn, roleSessionName string, roleSessionExpiration int) *StsRoleArnCredential {
+	return &StsRoleArnCredential{
+		AccessKeyId:           accessKeyId,
+		AccessKeySecret:       accessKeySecret,
+		RoleArn:               roleArn,
+		RoleSessionName:       roleSessionName,
+		RoleSessionExpiration: roleSessionExpiration,
+	}
+}
+
+func (oldCred *StsRoleArnCredential) ToRamRoleArnCredential() *RamRoleArnCredential {
+	return &RamRoleArnCredential{
+		AccessKeyId:           oldCred.AccessKeyId,
+		AccessKeySecret:       oldCred.AccessKeySecret,
+		RoleArn:               oldCred.RoleArn,
+		RoleSessionName:       oldCred.RoleSessionName,
+		RoleSessionExpiration: oldCred.RoleSessionExpiration,
+	}
+}
+
+func NewRamRoleArnCredential(accessKeyId, accessKeySecret, roleArn, roleSessionName string, roleSessionExpiration int) *RamRoleArnCredential {
+	return &RamRoleArnCredential{
+		AccessKeyId:           accessKeyId,
+		AccessKeySecret:       accessKeySecret,
+		RoleArn:               roleArn,
+		RoleSessionName:       roleSessionName,
+		RoleSessionExpiration: roleSessionExpiration,
+	}
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/roa_signature_composer.go

@@ -0,0 +1,121 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package auth
+
+import (
+	"bytes"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils"
+	"sort"
+	"strings"
+)
+
+func signRoaRequest(request requests.AcsRequest, signer Signer, regionId string) (err error) {
+	completeROASignParams(request, signer, regionId)
+	stringToSign := buildRoaStringToSign(request)
+	request.SetStringToSign(stringToSign)
+	signature := signer.Sign(stringToSign, "")
+	accessKeyId, err := signer.GetAccessKeyId()
+	if err != nil {
+		return nil
+	}
+
+	request.GetHeaders()["Authorization"] = "acs " + accessKeyId + ":" + signature
+
+	return
+}
+
+func completeROASignParams(request requests.AcsRequest, signer Signer, regionId string) {
+	headerParams := request.GetHeaders()
+
+	// complete query params
+	queryParams := request.GetQueryParams()
+	//if _, ok := queryParams["RegionId"]; !ok {
+	//	queryParams["RegionId"] = regionId
+	//}
+	if extraParam := signer.GetExtraParam(); extraParam != nil {
+		for key, value := range extraParam {
+			if key == "SecurityToken" {
+				headerParams["x-acs-security-token"] = value
+				continue
+			}
+
+			queryParams[key] = value
+		}
+	}
+
+	// complete header params
+	headerParams["Date"] = utils.GetTimeInFormatRFC2616()
+	headerParams["x-acs-signature-method"] = signer.GetName()
+	headerParams["x-acs-signature-version"] = signer.GetVersion()
+	if request.GetFormParams() != nil && len(request.GetFormParams()) > 0 {
+		formString := utils.GetUrlFormedMap(request.GetFormParams())
+		request.SetContent([]byte(formString))
+		headerParams["Content-Type"] = requests.Form
+	}
+	contentMD5 := utils.GetMD5Base64(request.GetContent())
+	headerParams["Content-MD5"] = contentMD5
+	if _, contains := headerParams["Content-Type"]; !contains {
+		headerParams["Content-Type"] = requests.Raw
+	}
+	switch format := request.GetAcceptFormat(); format {
+	case "JSON":
+		headerParams["Accept"] = requests.Json
+	case "XML":
+		headerParams["Accept"] = requests.Xml
+	default:
+		headerParams["Accept"] = requests.Raw
+	}
+}
+
+func buildRoaStringToSign(request requests.AcsRequest) (stringToSign string) {
+
+	headers := request.GetHeaders()
+
+	stringToSignBuilder := bytes.Buffer{}
+	stringToSignBuilder.WriteString(request.GetMethod())
+	stringToSignBuilder.WriteString(requests.HeaderSeparator)
+
+	// append header keys for sign
+	appendIfContain(headers, &stringToSignBuilder, "Accept", requests.HeaderSeparator)
+	appendIfContain(headers, &stringToSignBuilder, "Content-MD5", requests.HeaderSeparator)
+	appendIfContain(headers, &stringToSignBuilder, "Content-Type", requests.HeaderSeparator)
+	appendIfContain(headers, &stringToSignBuilder, "Date", requests.HeaderSeparator)
+
+	// sort and append headers witch starts with 'x-acs-'
+	var acsHeaders []string
+	for key := range headers {
+		if strings.HasPrefix(key, "x-acs-") {
+			acsHeaders = append(acsHeaders, key)
+		}
+	}
+	sort.Strings(acsHeaders)
+	for _, key := range acsHeaders {
+		stringToSignBuilder.WriteString(key + ":" + headers[key])
+		stringToSignBuilder.WriteString(requests.HeaderSeparator)
+	}
+
+	// append query params
+	stringToSignBuilder.WriteString(request.BuildQueries())
+	stringToSign = stringToSignBuilder.String()
+	return
+}
+
+func appendIfContain(sourceMap map[string]string, target *bytes.Buffer, key, separator string) {
+	if value, contain := sourceMap[key]; contain && len(value) > 0 {
+		target.WriteString(sourceMap[key])
+		target.WriteString(separator)
+	}
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/rpc_signature_composer.go

@@ -0,0 +1,96 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package auth
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils"
+	"net/url"
+	"sort"
+	"strings"
+)
+
+func signRpcRequest(request requests.AcsRequest, signer Signer, regionId string) (err error) {
+	err = completeRpcSignParams(request, signer, regionId)
+	if err != nil {
+		return
+	}
+	// remove while retry
+	if _, containsSign := request.GetQueryParams()["Signature"]; containsSign {
+		delete(request.GetQueryParams(), "Signature")
+	}
+	stringToSign := buildRpcStringToSign(request)
+	request.SetStringToSign(stringToSign)
+	signature := signer.Sign(stringToSign, "&")
+	request.GetQueryParams()["Signature"] = signature
+
+	return
+}
+
+func completeRpcSignParams(request requests.AcsRequest, signer Signer, regionId string) (err error) {
+	queryParams := request.GetQueryParams()
+	queryParams["Version"] = request.GetVersion()
+	queryParams["Action"] = request.GetActionName()
+	queryParams["Format"] = request.GetAcceptFormat()
+	queryParams["Timestamp"] = utils.GetTimeInFormatISO8601()
+	queryParams["SignatureMethod"] = signer.GetName()
+	queryParams["SignatureType"] = signer.GetType()
+	queryParams["SignatureVersion"] = signer.GetVersion()
+	queryParams["SignatureNonce"] = utils.GetUUIDV4()
+	queryParams["AccessKeyId"], err = signer.GetAccessKeyId()
+
+	if err != nil {
+		return
+	}
+
+	if _, contains := queryParams["RegionId"]; !contains {
+		queryParams["RegionId"] = regionId
+	}
+	if extraParam := signer.GetExtraParam(); extraParam != nil {
+		for key, value := range extraParam {
+			queryParams[key] = value
+		}
+	}
+
+	request.GetHeaders()["Content-Type"] = requests.Form
+	formString := utils.GetUrlFormedMap(request.GetFormParams())
+	request.SetContent([]byte(formString))
+
+	return
+}
+
+func buildRpcStringToSign(request requests.AcsRequest) (stringToSign string) {
+	signParams := make(map[string]string)
+	for key, value := range request.GetQueryParams() {
+		signParams[key] = value
+	}
+	for key, value := range request.GetFormParams() {
+		signParams[key] = value
+	}
+
+	// sort params by key
+	var paramKeySlice []string
+	for key := range signParams {
+		paramKeySlice = append(paramKeySlice, key)
+	}
+	sort.Strings(paramKeySlice)
+	stringToSign = utils.GetUrlFormedMap(signParams)
+	stringToSign = strings.Replace(stringToSign, "+", "%20", -1)
+	stringToSign = strings.Replace(stringToSign, "*", "%2A", -1)
+	stringToSign = strings.Replace(stringToSign, "%7E", "~", -1)
+	stringToSign = url.QueryEscape(stringToSign)
+	stringToSign = request.GetMethod() + "&%2F&" + stringToSign
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signer.go

@@ -0,0 +1,95 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package auth
+
+import (
+	"fmt"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+	"reflect"
+)
+
+type Signer interface {
+	GetName() string
+	GetType() string
+	GetVersion() string
+	GetAccessKeyId() (string, error)
+	GetExtraParam() map[string]string
+	Sign(stringToSign, secretSuffix string) string
+	Shutdown()
+}
+
+func NewSignerWithCredential(credential Credential, commonApi func(request *requests.CommonRequest, signer interface{}) (response *responses.CommonResponse, err error)) (signer Signer, err error) {
+	switch instance := credential.(type) {
+	case *credentials.AccessKeyCredential:
+		{
+			signer, err = signers.NewAccessKeySigner(instance)
+		}
+	case *credentials.StsTokenCredential:
+		{
+			signer, err = signers.NewStsTokenSigner(instance)
+		}
+
+	case *credentials.RamRoleArnCredential:
+		{
+			signer, err = signers.NewRamRoleArnSigner(instance, commonApi)
+		}
+	case *credentials.RsaKeyPairCredential:
+		{
+			signer, err = signers.NewSignerKeyPair(instance, commonApi)
+		}
+	case *credentials.EcsRamRoleCredential:
+		{
+			signer, err = signers.NewEcsRamRoleSigner(instance, commonApi)
+		}
+	case *credentials.BaseCredential: // deprecated user interface
+		{
+			signer, err = signers.NewAccessKeySigner(instance.ToAccessKeyCredential())
+		}
+	case *credentials.StsRoleArnCredential: // deprecated user interface
+		{
+			signer, err = signers.NewRamRoleArnSigner(instance.ToRamRoleArnCredential(), commonApi)
+		}
+	case *credentials.StsRoleNameOnEcsCredential: // deprecated user interface
+		{
+			signer, err = signers.NewEcsRamRoleSigner(instance.ToEcsRamRoleCredential(), commonApi)
+		}
+	default:
+		message := fmt.Sprintf(errors.UnsupportedCredentialErrorMessage, reflect.TypeOf(credential))
+		err = errors.NewClientError(errors.UnsupportedCredentialErrorCode, message, nil)
+	}
+	return
+}
+
+func Sign(request requests.AcsRequest, signer Signer, regionId string) (err error) {
+	switch request.GetStyle() {
+	case requests.ROA:
+		{
+			signRoaRequest(request, signer, regionId)
+		}
+	case requests.RPC:
+		{
+			err = signRpcRequest(request, signer, regionId)
+		}
+	default:
+		message := fmt.Sprintf(errors.UnknownRequestTypeErrorMessage, reflect.TypeOf(request))
+		err = errors.NewClientError(errors.UnknownRequestTypeErrorCode, message, nil)
+	}
+
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/algorithms.go

@@ -0,0 +1,63 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package signers
+
+import (
+	"crypto"
+	"crypto/hmac"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha1"
+	"crypto/x509"
+	"encoding/base64"
+	"fmt"
+	/*"encoding/pem"
+	"io/ioutil"
+	"os/user"
+	"crypto/sha256"*/)
+
+func ShaHmac1(source, secret string) string {
+	key := []byte(secret)
+	hmac := hmac.New(sha1.New, key)
+	hmac.Write([]byte(source))
+	signedBytes := hmac.Sum(nil)
+	signedString := base64.StdEncoding.EncodeToString(signedBytes)
+	return signedString
+}
+
+func Sha256WithRsa(source, secret string) string {
+	decodeString, err := base64.StdEncoding.DecodeString(secret)
+	if err != nil {
+		fmt.Println("DecodeString err", err)
+	}
+	private, err := x509.ParsePKCS8PrivateKey(decodeString)
+	if err != nil {
+		fmt.Println("ParsePKCS8PrivateKey err", err)
+	}
+
+	h := crypto.Hash.New(crypto.SHA256)
+	h.Write([]byte(source))
+	hashed := h.Sum(nil)
+	signature, err := rsa.SignPKCS1v15(rand.Reader, private.(*rsa.PrivateKey),
+		crypto.SHA256, hashed)
+	if err != nil {
+		fmt.Println("Error from signing:", err)
+		return ""
+	}
+
+	signedString := base64.StdEncoding.EncodeToString(signature)
+	//fmt.Printf("Encoded: %v\n", signedString)
+	return signedString
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/credential_updater.go

@@ -0,0 +1,53 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package signers
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+	"time"
+)
+
+const defaultInAdvanceScale = 0.8
+
+type credentialUpdater struct {
+	credentialExpiration int
+	lastUpdateTimestamp  int64
+	inAdvanceScale       float64
+	buildRequestMethod   func() (*requests.CommonRequest, error)
+	responseCallBack     func(response *responses.CommonResponse) error
+	refreshApi           func(request *requests.CommonRequest) (response *responses.CommonResponse, err error)
+}
+
+func (updater *credentialUpdater) needUpdateCredential() (result bool) {
+	if updater.inAdvanceScale == 0 {
+		updater.inAdvanceScale = defaultInAdvanceScale
+	}
+	return time.Now().Unix()-updater.lastUpdateTimestamp >= int64(float64(updater.credentialExpiration)*updater.inAdvanceScale)
+}
+
+func (updater *credentialUpdater) updateCredential() (err error) {
+	request, err := updater.buildRequestMethod()
+	if err != nil {
+		return
+	}
+	response, err := updater.refreshApi(request)
+	if err != nil {
+		return
+	}
+	updater.lastUpdateTimestamp = time.Now().Unix()
+	err = updater.responseCallBack(response)
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/session_credential.go

@@ -0,0 +1,7 @@
+package signers
+
+type SessionCredential struct {
+	AccessKeyId     string
+	AccessKeySecret string
+	StsToken        string
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_access_key.go

@@ -0,0 +1,58 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package signers
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
+)
+
+type AccessKeySigner struct {
+	credential *credentials.AccessKeyCredential
+}
+
+func (signer *AccessKeySigner) GetExtraParam() map[string]string {
+	return nil
+}
+
+func NewAccessKeySigner(credential *credentials.AccessKeyCredential) (*AccessKeySigner, error) {
+	return &AccessKeySigner{
+		credential: credential,
+	}, nil
+}
+
+func (*AccessKeySigner) GetName() string {
+	return "HMAC-SHA1"
+}
+
+func (*AccessKeySigner) GetType() string {
+	return ""
+}
+
+func (*AccessKeySigner) GetVersion() string {
+	return "1.0"
+}
+
+func (signer *AccessKeySigner) GetAccessKeyId() (accessKeyId string, err error) {
+	return signer.credential.AccessKeyId, nil
+}
+
+func (signer *AccessKeySigner) Sign(stringToSign, secretSuffix string) string {
+	secret := signer.credential.AccessKeySecret + secretSuffix
+	return ShaHmac1(stringToSign, secret)
+}
+
+func (signer *AccessKeySigner) Shutdown() {
+
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_ecs_ram_role.go

@@ -0,0 +1,175 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package signers
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+	"github.com/jmespath/go-jmespath"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type EcsRamRoleSigner struct {
+	*credentialUpdater
+	sessionCredential *SessionCredential
+	credential        *credentials.EcsRamRoleCredential
+	commonApi         func(request *requests.CommonRequest, signer interface{}) (response *responses.CommonResponse, err error)
+}
+
+func NewEcsRamRoleSigner(credential *credentials.EcsRamRoleCredential, commonApi func(*requests.CommonRequest, interface{}) (response *responses.CommonResponse, err error)) (signer *EcsRamRoleSigner, err error) {
+	signer = &EcsRamRoleSigner{
+		credential: credential,
+		commonApi:  commonApi,
+	}
+
+	signer.credentialUpdater = &credentialUpdater{
+		credentialExpiration: defaultDurationSeconds / 60,
+		buildRequestMethod:   signer.buildCommonRequest,
+		responseCallBack:     signer.refreshCredential,
+		refreshApi:           signer.refreshApi,
+	}
+
+	return
+}
+
+func (*EcsRamRoleSigner) GetName() string {
+	return "HMAC-SHA1"
+}
+
+func (*EcsRamRoleSigner) GetType() string {
+	return ""
+}
+
+func (*EcsRamRoleSigner) GetVersion() string {
+	return "1.0"
+}
+
+func (signer *EcsRamRoleSigner) GetAccessKeyId() (accessKeyId string, err error) {
+	if signer.sessionCredential == nil || signer.needUpdateCredential() {
+		err = signer.updateCredential()
+	}
+	if err != nil && (signer.sessionCredential == nil || len(signer.sessionCredential.AccessKeyId) <= 0) {
+		return "", err
+	}
+	return signer.sessionCredential.AccessKeyId, nil
+}
+
+func (signer *EcsRamRoleSigner) GetExtraParam() map[string]string {
+	if signer.sessionCredential == nil {
+		return make(map[string]string)
+	}
+	if len(signer.sessionCredential.StsToken) <= 0 {
+		return make(map[string]string)
+	}
+	return map[string]string{"SecurityToken": signer.sessionCredential.StsToken}
+}
+
+func (signer *EcsRamRoleSigner) Sign(stringToSign, secretSuffix string) string {
+	secret := signer.sessionCredential.AccessKeyId + secretSuffix
+	return ShaHmac1(stringToSign, secret)
+}
+
+func (signer *EcsRamRoleSigner) buildCommonRequest() (request *requests.CommonRequest, err error) {
+	request = requests.NewCommonRequest()
+	return
+}
+
+func (signer *EcsRamRoleSigner) refreshApi(request *requests.CommonRequest) (response *responses.CommonResponse, err error) {
+	requestUrl := "http://100.100.100.200/latest/meta-data/ram/security-credentials/" + signer.credential.RoleName
+	httpRequest, err := http.NewRequest(requests.GET, requestUrl, strings.NewReader(""))
+	if err != nil {
+		fmt.Println("refresh Ecs sts token err", err)
+		return
+	}
+	httpClient := &http.Client{}
+	httpResponse, err := httpClient.Do(httpRequest)
+	if err != nil {
+		fmt.Println("refresh Ecs sts token err", err)
+		return
+	}
+
+	response = responses.NewCommonResponse()
+	err = responses.Unmarshal(response, httpResponse, "")
+
+	return
+}
+
+func (signer *EcsRamRoleSigner) refreshCredential(response *responses.CommonResponse) (err error) {
+	if response.GetHttpStatus() != http.StatusOK {
+		fmt.Println("refresh Ecs sts token err, httpStatus: " + string(response.GetHttpStatus()) + ", message = " + response.GetHttpContentString())
+		return
+	}
+	var data interface{}
+	err = json.Unmarshal(response.GetHttpContentBytes(), &data)
+	if err != nil {
+		fmt.Println("refresh Ecs sts token err, json.Unmarshal fail", err)
+		return
+	}
+	code, err := jmespath.Search("Code", data)
+	if err != nil {
+		fmt.Println("refresh Ecs sts token err, fail to get Code", err)
+		return
+	}
+	if code.(string) != "Success" {
+		fmt.Println("refresh Ecs sts token err, Code is not Success", err)
+		return
+	}
+	accessKeyId, err := jmespath.Search("AccessKeyId", data)
+	if err != nil {
+		fmt.Println("refresh Ecs sts token err, fail to get AccessKeyId", err)
+		return
+	}
+	accessKeySecret, err := jmespath.Search("AccessKeySecret", data)
+	if err != nil {
+		fmt.Println("refresh Ecs sts token err, fail to get AccessKeySecret", err)
+		return
+	}
+	securityToken, err := jmespath.Search("SecurityToken", data)
+	if err != nil {
+		fmt.Println("refresh Ecs sts token err, fail to get SecurityToken", err)
+		return
+	}
+	expiration, err := jmespath.Search("Expiration", data)
+	if err != nil {
+		fmt.Println("refresh Ecs sts token err, fail to get Expiration", err)
+		return
+	}
+	if accessKeyId == nil || accessKeySecret == nil || securityToken == nil {
+		return
+	}
+
+	expirationTime, err := time.Parse("2006-01-02T15:04:05Z", expiration.(string))
+	signer.credentialExpiration = int(expirationTime.Unix() - time.Now().Unix())
+	signer.sessionCredential = &SessionCredential{
+		AccessKeyId:     accessKeyId.(string),
+		AccessKeySecret: accessKeySecret.(string),
+		StsToken:        securityToken.(string),
+	}
+
+	return
+}
+
+func (signer *EcsRamRoleSigner) GetSessionCredential() *SessionCredential {
+	return signer.sessionCredential
+}
+
+func (signer *EcsRamRoleSigner) Shutdown() {
+
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_key_pair.go

@@ -0,0 +1,148 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package signers
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+	"github.com/jmespath/go-jmespath"
+	"net/http"
+	"strconv"
+)
+
+type SignerKeyPair struct {
+	*credentialUpdater
+	sessionCredential *SessionCredential
+	credential        *credentials.RsaKeyPairCredential
+	commonApi         func(request *requests.CommonRequest, signer interface{}) (response *responses.CommonResponse, err error)
+}
+
+func NewSignerKeyPair(credential *credentials.RsaKeyPairCredential, commonApi func(*requests.CommonRequest, interface{}) (response *responses.CommonResponse, err error)) (signer *SignerKeyPair, err error) {
+	signer = &SignerKeyPair{
+		credential: credential,
+		commonApi:  commonApi,
+	}
+
+	signer.credentialUpdater = &credentialUpdater{
+		credentialExpiration: credential.SessionExpiration,
+		buildRequestMethod:   signer.buildCommonRequest,
+		responseCallBack:     signer.refreshCredential,
+		refreshApi:           signer.refreshApi,
+	}
+
+	if credential.SessionExpiration > 0 {
+		if credential.SessionExpiration >= 900 && credential.SessionExpiration <= 3600 {
+			signer.credentialExpiration = credential.SessionExpiration
+		} else {
+			err = errors.NewClientError(errors.InvalidParamErrorCode, "Key Pair session duration should be in the range of 15min - 1Hr", nil)
+		}
+	} else {
+		signer.credentialExpiration = defaultDurationSeconds
+	}
+	return
+}
+
+func (*SignerKeyPair) GetName() string {
+	return "HMAC-SHA1"
+}
+
+func (*SignerKeyPair) GetType() string {
+	return ""
+}
+
+func (*SignerKeyPair) GetVersion() string {
+	return "1.0"
+}
+
+func (signer *SignerKeyPair) GetAccessKeyId() (accessKeyId string, err error) {
+	if signer.sessionCredential == nil || signer.needUpdateCredential() {
+		err = signer.updateCredential()
+	}
+	if err != nil && (signer.sessionCredential == nil || len(signer.sessionCredential.AccessKeyId) <= 0) {
+		return "", err
+	}
+	return signer.sessionCredential.AccessKeyId, err
+}
+
+func (signer *SignerKeyPair) GetExtraParam() map[string]string {
+	if signer.sessionCredential == nil || signer.needUpdateCredential() {
+		signer.updateCredential()
+	}
+	if signer.sessionCredential == nil || len(signer.sessionCredential.AccessKeyId) <= 0 {
+		return make(map[string]string)
+	}
+	return make(map[string]string)
+}
+
+func (signer *SignerKeyPair) Sign(stringToSign, secretSuffix string) string {
+	secret := signer.sessionCredential.AccessKeyId + secretSuffix
+	return ShaHmac1(stringToSign, secret)
+}
+
+func (signer *SignerKeyPair) buildCommonRequest() (request *requests.CommonRequest, err error) {
+	request = requests.NewCommonRequest()
+	request.Product = "Sts"
+	request.Version = "2015-04-01"
+	request.ApiName = "GenerateSessionAccessKey"
+	request.Scheme = requests.HTTPS
+	request.QueryParams["PublicKeyId"] = signer.credential.PublicKeyId
+	request.QueryParams["DurationSeconds"] = strconv.Itoa(signer.credentialExpiration)
+	return
+}
+
+func (signerKeyPair *SignerKeyPair) refreshApi(request *requests.CommonRequest) (response *responses.CommonResponse, err error) {
+	signerV2, err := NewSignerV2(signerKeyPair.credential)
+	return signerKeyPair.commonApi(request, signerV2)
+}
+
+func (signer *SignerKeyPair) refreshCredential(response *responses.CommonResponse) (err error) {
+	if response.GetHttpStatus() != http.StatusOK {
+		message := "refresh session AccessKey failed"
+		err = errors.NewServerError(response.GetHttpStatus(), response.GetHttpContentString(), message)
+		return
+	}
+	var data interface{}
+	err = json.Unmarshal(response.GetHttpContentBytes(), &data)
+	if err != nil {
+		fmt.Println("refresh KeyPair err, json.Unmarshal fail", err)
+		return
+	}
+	accessKeyId, err := jmespath.Search("SessionAccessKey.SessionAccessKeyId", data)
+	if err != nil {
+		fmt.Println("refresh KeyPair err, fail to get SessionAccessKeyId", err)
+		return
+	}
+	accessKeySecret, err := jmespath.Search("SessionAccessKey.SessionAccessKeySecret", data)
+	if err != nil {
+		fmt.Println("refresh KeyPair err, fail to get SessionAccessKeySecret", err)
+		return
+	}
+	if accessKeyId == nil || accessKeySecret == nil {
+		return
+	}
+	signer.sessionCredential = &SessionCredential{
+		AccessKeyId:     accessKeyId.(string),
+		AccessKeySecret: accessKeySecret.(string),
+	}
+	return
+}
+
+func (signer *SignerKeyPair) Shutdown() {
+
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_ram_role_arn.go

@@ -0,0 +1,174 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package signers
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+	"github.com/jmespath/go-jmespath"
+	"net/http"
+	"strconv"
+	"time"
+)
+
+const (
+	defaultDurationSeconds = 3600
+)
+
+type RamRoleArnSigner struct {
+	*credentialUpdater
+	roleSessionName   string
+	sessionCredential *SessionCredential
+	credential        *credentials.RamRoleArnCredential
+	commonApi         func(request *requests.CommonRequest, signer interface{}) (response *responses.CommonResponse, err error)
+}
+
+func NewRamRoleArnSigner(credential *credentials.RamRoleArnCredential, commonApi func(request *requests.CommonRequest, signer interface{}) (response *responses.CommonResponse, err error)) (signer *RamRoleArnSigner, err error) {
+	signer = &RamRoleArnSigner{
+		credential: credential,
+		commonApi:  commonApi,
+	}
+
+	signer.credentialUpdater = &credentialUpdater{
+		credentialExpiration: credential.RoleSessionExpiration,
+		buildRequestMethod:   signer.buildCommonRequest,
+		responseCallBack:     signer.refreshCredential,
+		refreshApi:           signer.refreshApi,
+	}
+
+	if len(credential.RoleSessionName) > 0 {
+		signer.roleSessionName = credential.RoleSessionName
+	} else {
+		signer.roleSessionName = "aliyun-go-sdk-" + strconv.FormatInt(time.Now().UnixNano()/1000, 10)
+	}
+	if credential.RoleSessionExpiration > 0 {
+		if credential.RoleSessionExpiration >= 900 && credential.RoleSessionExpiration <= 3600 {
+			signer.credentialExpiration = credential.RoleSessionExpiration
+		} else {
+			err = errors.NewClientError(errors.InvalidParamErrorCode, "Assume Role session duration should be in the range of 15min - 1Hr", nil)
+		}
+	} else {
+		signer.credentialExpiration = defaultDurationSeconds
+	}
+	return
+}
+
+func (*RamRoleArnSigner) GetName() string {
+	return "HMAC-SHA1"
+}
+
+func (*RamRoleArnSigner) GetType() string {
+	return ""
+}
+
+func (*RamRoleArnSigner) GetVersion() string {
+	return "1.0"
+}
+
+func (signer *RamRoleArnSigner) GetAccessKeyId() (accessKeyId string, err error) {
+	if signer.sessionCredential == nil || signer.needUpdateCredential() {
+		err = signer.updateCredential()
+	}
+	if err != nil && (signer.sessionCredential == nil || len(signer.sessionCredential.AccessKeyId) <= 0) {
+		return "", err
+	}
+	return signer.sessionCredential.AccessKeyId, nil
+}
+
+func (signer *RamRoleArnSigner) GetExtraParam() map[string]string {
+	if signer.sessionCredential == nil || signer.needUpdateCredential() {
+		signer.updateCredential()
+	}
+	if signer.sessionCredential == nil || len(signer.sessionCredential.StsToken) <= 0 {
+		return make(map[string]string)
+	}
+	return map[string]string{"SecurityToken": signer.sessionCredential.StsToken}
+}
+
+func (signer *RamRoleArnSigner) Sign(stringToSign, secretSuffix string) string {
+	secret := signer.sessionCredential.AccessKeySecret + secretSuffix
+	return ShaHmac1(stringToSign, secret)
+}
+
+func (signer *RamRoleArnSigner) buildCommonRequest() (request *requests.CommonRequest, err error) {
+	request = requests.NewCommonRequest()
+	request.Product = "Sts"
+	request.Version = "2015-04-01"
+	request.ApiName = "AssumeRole"
+	request.Scheme = requests.HTTPS
+	request.QueryParams["RoleArn"] = signer.credential.RoleArn
+	request.QueryParams["RoleSessionName"] = signer.credential.RoleSessionName
+	request.QueryParams["DurationSeconds"] = strconv.Itoa(signer.credentialExpiration)
+	return
+}
+
+func (signer *RamRoleArnSigner) refreshApi(request *requests.CommonRequest) (response *responses.CommonResponse, err error) {
+	credential := &credentials.AccessKeyCredential{
+		AccessKeyId:     signer.credential.AccessKeyId,
+		AccessKeySecret: signer.credential.AccessKeySecret,
+	}
+	signerV1, err := NewAccessKeySigner(credential)
+	return signer.commonApi(request, signerV1)
+}
+
+func (signer *RamRoleArnSigner) refreshCredential(response *responses.CommonResponse) (err error) {
+	if response.GetHttpStatus() != http.StatusOK {
+		message := "refresh session token failed"
+		err = errors.NewServerError(response.GetHttpStatus(), response.GetHttpContentString(), message)
+		return
+	}
+	var data interface{}
+	err = json.Unmarshal(response.GetHttpContentBytes(), &data)
+	if err != nil {
+		fmt.Println("refresh RoleArn sts token err, json.Unmarshal fail", err)
+		return
+	}
+	accessKeyId, err := jmespath.Search("Credentials.AccessKeyId", data)
+	if err != nil {
+		fmt.Println("refresh RoleArn sts token err, fail to get AccessKeyId", err)
+		return
+	}
+	accessKeySecret, err := jmespath.Search("Credentials.AccessKeySecret", data)
+	if err != nil {
+		fmt.Println("refresh RoleArn sts token err, fail to get AccessKeySecret", err)
+		return
+	}
+	securityToken, err := jmespath.Search("Credentials.SecurityToken", data)
+	if err != nil {
+		fmt.Println("refresh RoleArn sts token err, fail to get SecurityToken", err)
+		return
+	}
+	if accessKeyId == nil || accessKeySecret == nil || securityToken == nil {
+		return
+	}
+	signer.sessionCredential = &SessionCredential{
+		AccessKeyId:     accessKeyId.(string),
+		AccessKeySecret: accessKeySecret.(string),
+		StsToken:        securityToken.(string),
+	}
+	return
+}
+
+func (signer *RamRoleArnSigner) GetSessionCredential() *SessionCredential {
+	return signer.sessionCredential
+}
+
+func (signer *RamRoleArnSigner) Shutdown() {
+
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_sts_token.go

@@ -0,0 +1,58 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package signers
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
+)
+
+type StsTokenSigner struct {
+	credential *credentials.StsTokenCredential
+}
+
+func NewStsTokenSigner(credential *credentials.StsTokenCredential) (*StsTokenSigner, error) {
+	return &StsTokenSigner{
+		credential: credential,
+	}, nil
+}
+
+func (*StsTokenSigner) GetName() string {
+	return "HMAC-SHA1"
+}
+
+func (*StsTokenSigner) GetType() string {
+	return ""
+}
+
+func (*StsTokenSigner) GetVersion() string {
+	return "1.0"
+}
+
+func (signer *StsTokenSigner) GetAccessKeyId() (accessKeyId string, err error) {
+	return signer.credential.AccessKeyId, nil
+}
+
+func (signer *StsTokenSigner) GetExtraParam() map[string]string {
+	return map[string]string{"SecurityToken": signer.credential.AccessKeyStsToken}
+}
+
+func (signer *StsTokenSigner) Sign(stringToSign, secretSuffix string) string {
+	secret := signer.credential.AccessKeySecret + secretSuffix
+	return ShaHmac1(stringToSign, secret)
+}
+
+func (signer *StsTokenSigner) Shutdown() {
+
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_v2.go

@@ -0,0 +1,58 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package signers
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
+)
+
+type SignerV2 struct {
+	credential *credentials.RsaKeyPairCredential
+}
+
+func (signer *SignerV2) GetExtraParam() map[string]string {
+	return nil
+}
+
+func NewSignerV2(credential *credentials.RsaKeyPairCredential) (*SignerV2, error) {
+	return &SignerV2{
+		credential: credential,
+	}, nil
+}
+
+func (*SignerV2) GetName() string {
+	return "SHA256withRSA"
+}
+
+func (*SignerV2) GetType() string {
+	return "PRIVATEKEY"
+}
+
+func (*SignerV2) GetVersion() string {
+	return "1.0"
+}
+
+func (signer *SignerV2) GetAccessKeyId() (accessKeyId string, err error) {
+	return signer.credential.PublicKeyId, err
+}
+
+func (signer *SignerV2) Sign(stringToSign, secretSuffix string) string {
+	secret := signer.credential.PrivateKey
+	return Sha256WithRsa(stringToSign, secret)
+}
+
+func (signer *SignerV2) Shutdown() {
+
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/client.go

@@ -0,0 +1,419 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sdk
+
+import (
+	"fmt"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+	"net"
+	"net/http"
+	"strconv"
+	"sync"
+)
+
+// this value will be replaced while build: -ldflags="-X sdk.version=x.x.x"
+var Version = "0.0.1"
+
+type Client struct {
+	regionId       string
+	config         *Config
+	signer         auth.Signer
+	httpClient     *http.Client
+	asyncTaskQueue chan func()
+
+	debug     bool
+	isRunning bool
+	// void "panic(write to close channel)" cause of addAsync() after Shutdown()
+	asyncChanLock *sync.RWMutex
+}
+
+func (client *Client) Init() (err error) {
+	panic("not support yet")
+}
+
+func (client *Client) InitWithOptions(regionId string, config *Config, credential auth.Credential) (err error) {
+	client.isRunning = true
+	client.asyncChanLock = new(sync.RWMutex)
+	client.regionId = regionId
+	client.config = config
+	if err != nil {
+		return
+	}
+	client.httpClient = &http.Client{}
+
+	if config.HttpTransport != nil {
+		client.httpClient.Transport = config.HttpTransport
+	}
+
+	if config.Timeout > 0 {
+		client.httpClient.Timeout = config.Timeout
+	}
+
+	if config.EnableAsync {
+		client.EnableAsync(config.GoRoutinePoolSize, config.MaxTaskQueueSize)
+	}
+
+	client.signer, err = auth.NewSignerWithCredential(credential, client.ProcessCommonRequestWithSigner)
+
+	return
+}
+
+func (client *Client) EnableAsync(routinePoolSize, maxTaskQueueSize int) {
+	client.asyncTaskQueue = make(chan func(), maxTaskQueueSize)
+	for i := 0; i < routinePoolSize; i++ {
+		go func() {
+			for client.isRunning {
+				select {
+				case task, notClosed := <-client.asyncTaskQueue:
+					if notClosed {
+						task()
+					}
+				}
+			}
+		}()
+	}
+}
+
+func (client *Client) InitWithAccessKey(regionId, accessKeyId, accessKeySecret string) (err error) {
+	config := client.InitClientConfig()
+	credential := &credentials.BaseCredential{
+		AccessKeyId:     accessKeyId,
+		AccessKeySecret: accessKeySecret,
+	}
+	return client.InitWithOptions(regionId, config, credential)
+}
+
+func (client *Client) InitWithStsToken(regionId, accessKeyId, accessKeySecret, securityToken string) (err error) {
+	config := client.InitClientConfig()
+	credential := &credentials.StsTokenCredential{
+		AccessKeyId:       accessKeyId,
+		AccessKeySecret:   accessKeySecret,
+		AccessKeyStsToken: securityToken,
+	}
+	return client.InitWithOptions(regionId, config, credential)
+}
+
+func (client *Client) InitWithRamRoleArn(regionId, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (err error) {
+	config := client.InitClientConfig()
+	credential := &credentials.RamRoleArnCredential{
+		AccessKeyId:     accessKeyId,
+		AccessKeySecret: accessKeySecret,
+		RoleArn:         roleArn,
+		RoleSessionName: roleSessionName,
+	}
+	return client.InitWithOptions(regionId, config, credential)
+}
+
+func (client *Client) InitWithRsaKeyPair(regionId, publicKeyId, privateKey string, sessionExpiration int) (err error) {
+	config := client.InitClientConfig()
+	credential := &credentials.RsaKeyPairCredential{
+		PrivateKey:        privateKey,
+		PublicKeyId:       publicKeyId,
+		SessionExpiration: sessionExpiration,
+	}
+	return client.InitWithOptions(regionId, config, credential)
+}
+
+func (client *Client) InitWithEcsRamRole(regionId, roleName string) (err error) {
+	config := client.InitClientConfig()
+	credential := &credentials.EcsRamRoleCredential{
+		RoleName: roleName,
+	}
+	return client.InitWithOptions(regionId, config, credential)
+}
+
+func (client *Client) InitClientConfig() (config *Config) {
+	if client.config != nil {
+		return client.config
+	} else {
+		return NewConfig()
+	}
+}
+
+func (client *Client) DoAction(request requests.AcsRequest, response responses.AcsResponse) (err error) {
+	return client.DoActionWithSigner(request, response, nil)
+}
+
+func (client *Client) BuildRequestWithSigner(request requests.AcsRequest, signer auth.Signer) (err error) {
+	// add clientVersion
+	request.GetHeaders()["x-sdk-core-version"] = Version
+
+	regionId := client.regionId
+	if len(request.GetRegionId()) > 0 {
+		regionId = request.GetRegionId()
+	}
+
+	// resolve endpoint
+	resolveParam := &endpoints.ResolveParam{
+		Domain:               request.GetDomain(),
+		Product:              request.GetProduct(),
+		RegionId:             regionId,
+		LocationProduct:      request.GetLocationServiceCode(),
+		LocationEndpointType: request.GetLocationEndpointType(),
+		CommonApi:            client.ProcessCommonRequest,
+	}
+	endpoint, err := endpoints.Resolve(resolveParam)
+	if err != nil {
+		return
+	}
+	request.SetDomain(endpoint)
+
+	// init request params
+	err = requests.InitParams(request)
+	if err != nil {
+		return
+	}
+
+	// signature
+	var finalSigner auth.Signer
+	if signer != nil {
+		finalSigner = signer
+	} else {
+		finalSigner = client.signer
+	}
+	httpRequest, err := buildHttpRequest(request, finalSigner, regionId)
+	if client.config.UserAgent != "" {
+		httpRequest.Header.Set("User-Agent", client.config.UserAgent)
+	}
+	return err
+}
+
+func (client *Client) DoActionWithSigner(request requests.AcsRequest, response responses.AcsResponse, signer auth.Signer) (err error) {
+
+	// add clientVersion
+	request.GetHeaders()["x-sdk-core-version"] = Version
+
+	regionId := client.regionId
+	if len(request.GetRegionId()) > 0 {
+		regionId = request.GetRegionId()
+	}
+
+	// resolve endpoint
+	resolveParam := &endpoints.ResolveParam{
+		Domain:               request.GetDomain(),
+		Product:              request.GetProduct(),
+		RegionId:             regionId,
+		LocationProduct:      request.GetLocationServiceCode(),
+		LocationEndpointType: request.GetLocationEndpointType(),
+		CommonApi:            client.ProcessCommonRequest,
+	}
+	endpoint, err := endpoints.Resolve(resolveParam)
+	if err != nil {
+		return
+	}
+	request.SetDomain(endpoint)
+
+	if request.GetScheme() == "" {
+		request.SetScheme(client.config.Scheme)
+	}
+	// init request params
+	err = requests.InitParams(request)
+	if err != nil {
+		return
+	}
+
+	// signature
+	var finalSigner auth.Signer
+	if signer != nil {
+		finalSigner = signer
+	} else {
+		finalSigner = client.signer
+	}
+	httpRequest, err := buildHttpRequest(request, finalSigner, regionId)
+	if client.config.UserAgent != "" {
+		httpRequest.Header.Set("User-Agent", client.config.UserAgent)
+	}
+	if err != nil {
+		return
+	}
+	var httpResponse *http.Response
+	for retryTimes := 0; retryTimes <= client.config.MaxRetryTime; retryTimes++ {
+		httpResponse, err = client.httpClient.Do(httpRequest)
+
+		var timeout bool
+		// receive error
+		if err != nil {
+			if !client.config.AutoRetry {
+				return
+			} else if timeout = isTimeout(err); !timeout {
+				// if not timeout error, return
+				return
+			} else if retryTimes >= client.config.MaxRetryTime {
+				// timeout but reached the max retry times, return
+				timeoutErrorMsg := fmt.Sprintf(errors.TimeoutErrorMessage, strconv.Itoa(retryTimes+1), strconv.Itoa(retryTimes+1))
+				err = errors.NewClientError(errors.TimeoutErrorCode, timeoutErrorMsg, err)
+				return
+			}
+		}
+		//  if status code >= 500 or timeout, will trigger retry
+		if client.config.AutoRetry && (timeout || isServerError(httpResponse)) {
+			// rewrite signatureNonce and signature
+			httpRequest, err = buildHttpRequest(request, finalSigner, regionId)
+			if err != nil {
+				return
+			}
+			continue
+		}
+		break
+	}
+	err = responses.Unmarshal(response, httpResponse, request.GetAcceptFormat())
+	// wrap server errors
+	if serverErr, ok := err.(*errors.ServerError); ok {
+		var wrapInfo = map[string]string{}
+		wrapInfo["StringToSign"] = request.GetStringToSign()
+		err = errors.WrapServerError(serverErr, wrapInfo)
+	}
+	return
+}
+
+func buildHttpRequest(request requests.AcsRequest, singer auth.Signer, regionId string) (httpRequest *http.Request, err error) {
+	err = auth.Sign(request, singer, regionId)
+	if err != nil {
+		return
+	}
+	requestMethod := request.GetMethod()
+	requestUrl := request.BuildUrl()
+	body := request.GetBodyReader()
+	httpRequest, err = http.NewRequest(requestMethod, requestUrl, body)
+	if err != nil {
+		return
+	}
+	for key, value := range request.GetHeaders() {
+		httpRequest.Header[key] = []string{value}
+	}
+	// host is a special case
+	if host, containsHost := request.GetHeaders()["Host"]; containsHost {
+		httpRequest.Host = host
+	}
+	return
+}
+
+func isTimeout(err error) bool {
+	if err == nil {
+		return false
+	}
+	netErr, isNetError := err.(net.Error)
+	return isNetError && netErr.Timeout()
+}
+
+func isServerError(httpResponse *http.Response) bool {
+	return httpResponse.StatusCode >= http.StatusInternalServerError
+}
+
+/**
+only block when any one of the following occurs:
+1. the asyncTaskQueue is full, increase the queue size to avoid this
+2. Shutdown() in progressing, the client is being closed
+**/
+func (client *Client) AddAsyncTask(task func()) (err error) {
+	if client.asyncTaskQueue != nil {
+		client.asyncChanLock.RLock()
+		defer client.asyncChanLock.RUnlock()
+		if client.isRunning {
+			client.asyncTaskQueue <- task
+		}
+	} else {
+		err = errors.NewClientError(errors.AsyncFunctionNotEnabledCode, errors.AsyncFunctionNotEnabledMessage, nil)
+	}
+	return
+}
+
+func (client *Client) GetConfig() *Config {
+	return client.config
+}
+
+func NewClient() (client *Client, err error) {
+	client = &Client{}
+	err = client.Init()
+	return
+}
+
+func NewClientWithOptions(regionId string, config *Config, credential auth.Credential) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithOptions(regionId, config, credential)
+	return
+}
+
+func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
+	return
+}
+
+func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken)
+	return
+}
+
+func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithRamRoleArn(regionId, accessKeyId, accessKeySecret, roleArn, roleSessionName)
+	return
+}
+
+func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithEcsRamRole(regionId, roleName)
+	return
+}
+
+func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithRsaKeyPair(regionId, publicKeyId, privateKey, sessionExpiration)
+	return
+}
+
+// Deprecated: Use NewClientWithRamRoleArn in this package instead.
+func NewClientWithStsRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error) {
+	return NewClientWithRamRoleArn(regionId, accessKeyId, accessKeySecret, roleArn, roleSessionName)
+}
+
+// Deprecated: Use NewClientWithEcsRamRole in this package instead.
+func NewClientWithStsRoleNameOnEcs(regionId string, roleName string) (client *Client, err error) {
+	return NewClientWithEcsRamRole(regionId, roleName)
+}
+
+func (client *Client) ProcessCommonRequest(request *requests.CommonRequest) (response *responses.CommonResponse, err error) {
+	request.TransToAcsRequest()
+	response = responses.NewCommonResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+func (client *Client) ProcessCommonRequestWithSigner(request *requests.CommonRequest, signerInterface interface{}) (response *responses.CommonResponse, err error) {
+	if signer, isSigner := signerInterface.(auth.Signer); isSigner {
+		request.TransToAcsRequest()
+		response = responses.NewCommonResponse()
+		err = client.DoActionWithSigner(request, response, signer)
+		return
+	} else {
+		panic("should not be here")
+	}
+}
+
+func (client *Client) Shutdown() {
+	client.signer.Shutdown()
+	// lock the addAsync()
+	client.asyncChanLock.Lock()
+	defer client.asyncChanLock.Unlock()
+	client.isRunning = false
+	close(client.asyncTaskQueue)
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/config.go

@@ -0,0 +1,85 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sdk
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils"
+	"net/http"
+	"time"
+)
+
+type Config struct {
+	AutoRetry         bool            `default:"true"`
+	MaxRetryTime      int             `default:"3"`
+	UserAgent         string          `default:""`
+	Debug             bool            `default:"false"`
+	Timeout           time.Duration   `default:"10000000000"`
+	HttpTransport     *http.Transport `default:""`
+	EnableAsync       bool            `default:"false"`
+	MaxTaskQueueSize  int             `default:"1000"`
+	GoRoutinePoolSize int             `default:"5"`
+	Scheme            string          `default:"HTTP"`
+}
+
+func NewConfig() (config *Config) {
+	config = &Config{}
+	utils.InitStructWithDefaultTag(config)
+	return
+}
+
+func (c *Config) WithTimeout(timeout time.Duration) *Config {
+	c.Timeout = timeout
+	return c
+}
+
+func (c *Config) WithAutoRetry(isAutoRetry bool) *Config {
+	c.AutoRetry = isAutoRetry
+	return c
+}
+
+func (c *Config) WithMaxRetryTime(maxRetryTime int) *Config {
+	c.MaxRetryTime = maxRetryTime
+	return c
+}
+
+func (c *Config) WithUserAgent(userAgent string) *Config {
+	c.UserAgent = userAgent
+	return c
+}
+
+func (c *Config) WithHttpTransport(httpTransport *http.Transport) *Config {
+	c.HttpTransport = httpTransport
+	return c
+}
+
+func (c *Config) WithEnableAsync(isEnableAsync bool) *Config {
+	c.EnableAsync = isEnableAsync
+	return c
+}
+
+func (c *Config) WithMaxTaskQueueSize(maxTaskQueueSize int) *Config {
+	c.MaxTaskQueueSize = maxTaskQueueSize
+	return c
+}
+
+func (c *Config) WithGoRoutinePoolSize(goRoutinePoolSize int) *Config {
+	c.GoRoutinePoolSize = goRoutinePoolSize
+	return c
+}
+
+func (c *Config) WithDebug(isDebug bool) *Config {
+	c.Debug = isDebug
+	return c
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/endpoints_config.go

@@ -0,0 +1,505 @@
+package endpoints
+
+import (
+	"encoding/json"
+	"fmt"
+	"sync"
+)
+
+const endpointsJson = "{" +
+	"  \"products\":[" +
+	"  {" +
+	"    \"code\": \"aegis\"," +
+	"    \"document_id\": \"28449\"," +
+	"    \"location_service_code\": \"vipaegis\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"aegis.cn-hangzhou.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"alidns\"," +
+	"    \"document_id\": \"29739\"," +
+	"    \"location_service_code\": \"alidns\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"alidns.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"arms\"," +
+	"    \"document_id\": \"42924\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": [ {" +
+	"       \"region\": \"ap-southeast-1\"," +
+	"       \"endpoint\": \"arms.ap-southeast-1.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-beijing\"," +
+	"       \"endpoint\": \"arms.cn-beijing.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-hangzhou\"," +
+	"       \"endpoint\": \"arms.cn-hangzhou.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-hongkong\"," +
+	"       \"endpoint\": \"arms.cn-hongkong.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-qingdao\"," +
+	"       \"endpoint\": \"arms.cn-qingdao.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-shanghai\"," +
+	"       \"endpoint\": \"arms.cn-shanghai.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-shenzhen\"," +
+	"       \"endpoint\": \"arms.cn-shenzhen.aliyuncs.com\"" +
+	"    }]," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"arms.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"batchcompute\"," +
+	"    \"document_id\": \"44717\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": [ {" +
+	"       \"region\": \"ap-southeast-1\"," +
+	"       \"endpoint\": \"batchcompute.ap-southeast-1.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-beijing\"," +
+	"       \"endpoint\": \"batchcompute.cn-beijing.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-hangzhou\"," +
+	"       \"endpoint\": \"batchcompute.cn-hangzhou.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-huhehaote\"," +
+	"       \"endpoint\": \"batchcompute.cn-huhehaote.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-qingdao\"," +
+	"       \"endpoint\": \"batchcompute.cn-qingdao.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-shanghai\"," +
+	"       \"endpoint\": \"batchcompute.cn-shanghai.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-shenzhen\"," +
+	"       \"endpoint\": \"batchcompute.cn-shenzhen.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-zhangjiakou\"," +
+	"       \"endpoint\": \"batchcompute.cn-zhangjiakou.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"us-west-1\"," +
+	"       \"endpoint\": \"batchcompute.us-west-1.aliyuncs.com\"" +
+	"    }]," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"batchcompute.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"ccc\"," +
+	"    \"document_id\": \"63027\"," +
+	"    \"location_service_code\": \"ccc\"," +
+	"    \"regional_endpoints\": [ {" +
+	"       \"region\": \"cn-hangzhou\"," +
+	"       \"endpoint\": \"ccc.cn-hangzhou.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-shanghai\"," +
+	"       \"endpoint\": \"ccc.cn-shanghai.aliyuncs.com\"" +
+	"    }]," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"ccc.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"cdn\"," +
+	"    \"document_id\": \"27148\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"cdn.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"cds\"," +
+	"    \"document_id\": \"62887\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"cds.cn-beijing.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"chatbot\"," +
+	"    \"document_id\": \"60760\"," +
+	"    \"location_service_code\": \"beebot\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"chatbot.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"cloudapi\"," +
+	"    \"document_id\": \"43590\"," +
+	"    \"location_service_code\": \"apigateway\"," +
+	"    \"regional_endpoints\": [ {" +
+	"       \"region\": \"ap-northeast-1\"," +
+	"       \"endpoint\": \"apigateway.ap-northeast-1.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"us-west-1\"," +
+	"       \"endpoint\": \"apigateway.us-west-1.aliyuncs.com\"" +
+	"    }]," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"apigateway.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"cloudauth\"," +
+	"    \"document_id\": \"60687\"," +
+	"    \"location_service_code\": \"cloudauth\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"cloudauth.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"cloudphoto\"," +
+	"    \"document_id\": \"59902\"," +
+	"    \"location_service_code\": \"cloudphoto\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"cloudphoto.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"cloudwf\"," +
+	"    \"document_id\": \"58111\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"cloudwf.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"cms\"," +
+	"    \"document_id\": \"28615\"," +
+	"    \"location_service_code\": \"cms\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"cr\"," +
+	"    \"document_id\": \"60716\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"cr.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"cs\"," +
+	"    \"document_id\": \"26043\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"cs.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"csb\"," +
+	"    \"document_id\": \"64837\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": [ {" +
+	"       \"region\": \"cn-beijing\"," +
+	"       \"endpoint\": \"csb.cn-beijing.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-hangzhou\"," +
+	"       \"endpoint\": \"csb.cn-hangzhou.aliyuncs.com\"" +
+	"    }]," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"csb.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"dds\"," +
+	"    \"document_id\": \"61715\"," +
+	"    \"location_service_code\": \"dds\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"mongodb.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"mongodb.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"dm\"," +
+	"    \"document_id\": \"29434\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": [ {" +
+	"       \"region\": \"ap-southeast-1\"," +
+	"       \"endpoint\": \"dm.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"ap-southeast-2\"," +
+	"       \"endpoint\": \"dm.ap-southeast-2.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-beijing\"," +
+	"       \"endpoint\": \"dm.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-hangzhou\"," +
+	"       \"endpoint\": \"dm.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-hongkong\"," +
+	"       \"endpoint\": \"dm.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-qingdao\"," +
+	"       \"endpoint\": \"dm.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-shanghai\"," +
+	"       \"endpoint\": \"dm.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"cn-shenzhen\"," +
+	"       \"endpoint\": \"dm.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"us-east-1\"," +
+	"       \"endpoint\": \"dm.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"us-west-1\"," +
+	"       \"endpoint\": \"dm.aliyuncs.com\"" +
+	"    }]," +
+	"    \"global_endpoint\": \"dm.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"dm.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"domain\"," +
+	"    \"document_id\": \"42875\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"domain.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"domain.aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"domain-intl\"," +
+	"    \"document_id\": \"\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"domain-intl.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"domain-intl.aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"drds\"," +
+	"    \"document_id\": \"51111\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"drds.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"drds.aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"ecs\"," +
+	"    \"document_id\": \"25484\"," +
+	"    \"location_service_code\": \"ecs\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"emr\"," +
+	"    \"document_id\": \"28140\"," +
+	"    \"location_service_code\": \"emr\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"emr.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"ess\"," +
+	"    \"document_id\": \"25925\"," +
+	"    \"location_service_code\": \"ess\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"ess.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"green\"," +
+	"    \"document_id\": \"28427\"," +
+	"    \"location_service_code\": \"green\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"green.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"hpc\"," +
+	"    \"document_id\": \"35201\"," +
+	"    \"location_service_code\": \"hpc\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"hpc.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"httpdns\"," +
+	"    \"document_id\": \"52679\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"httpdns-api.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"iot\"," +
+	"    \"document_id\": \"30557\"," +
+	"    \"location_service_code\": \"iot\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"iot.[RegionId].aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"itaas\"," +
+	"    \"document_id\": \"55759\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"itaas.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"jaq\"," +
+	"    \"document_id\": \"35037\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"jaq.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"live\"," +
+	"    \"document_id\": \"48207\"," +
+	"    \"location_service_code\": \"live\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"live.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"mts\"," +
+	"    \"document_id\": \"29212\"," +
+	"    \"location_service_code\": \"mts\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"nas\"," +
+	"    \"document_id\": \"62598\"," +
+	"    \"location_service_code\": \"nas\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"ons\"," +
+	"    \"document_id\": \"44416\"," +
+	"    \"location_service_code\": \"ons\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"polardb\"," +
+	"    \"document_id\": \"58764\"," +
+	"    \"location_service_code\": \"polardb\"," +
+	"    \"regional_endpoints\": [ {" +
+	"       \"region\": \"ap-south-1\"," +
+	"       \"endpoint\": \"polardb.ap-south-1.aliyuncs.com\"" +
+	"    }, {" +
+	"       \"region\": \"ap-southeast-5\"," +
+	"       \"endpoint\": \"polardb.ap-southeast-5.aliyuncs.com\"" +
+	"    }]," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"polardb.aliyuncs.com\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"push\"," +
+	"    \"document_id\": \"30074\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"cloudpush.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"qualitycheck\"," +
+	"    \"document_id\": \"50807\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": [ {" +
+	"       \"region\": \"cn-hangzhou\"," +
+	"       \"endpoint\": \"qualitycheck.cn-hangzhou.aliyuncs.com\"" +
+	"    }]," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"r-kvstore\"," +
+	"    \"document_id\": \"60831\"," +
+	"    \"location_service_code\": \"redisa\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"ram\"," +
+	"    \"document_id\": \"28672\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"ram.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"rds\"," +
+	"    \"document_id\": \"26223\"," +
+	"    \"location_service_code\": \"rds\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"ros\"," +
+	"    \"document_id\": \"28899\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"ros.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"sas-api\"," +
+	"    \"document_id\": \"28498\"," +
+	"    \"location_service_code\": \"sas\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"slb\"," +
+	"    \"document_id\": \"27565\"," +
+	"    \"location_service_code\": \"slb\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"sts\"," +
+	"    \"document_id\": \"28756\"," +
+	"    \"location_service_code\": \"\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"sts.aliyuncs.com\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"vod\"," +
+	"    \"document_id\": \"60574\"," +
+	"    \"location_service_code\": \"vod\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"vpc\"," +
+	"    \"document_id\": \"34962\"," +
+	"    \"location_service_code\": \"vpc\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }," +
+	"  {" +
+	"    \"code\": \"waf\"," +
+	"    \"document_id\": \"62847\"," +
+	"    \"location_service_code\": \"waf\"," +
+	"    \"regional_endpoints\": []," +
+	"    \"global_endpoint\": \"\"," +
+	"    \"regional_endpoint_pattern\": \"\"" +
+	"  }]" +
+	"}"
+
+var initOnce sync.Once
+var data interface{}
+
+func getEndpointConfigData() interface{} {
+	initOnce.Do(func() {
+		err := json.Unmarshal([]byte(endpointsJson), &data)
+		if err != nil {
+			fmt.Println("init endpoint config data failed.", err)
+		}
+	})
+	return data
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/local_global_resolver.go

@@ -0,0 +1,37 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package endpoints
+
+import (
+	"fmt"
+	"github.com/jmespath/go-jmespath"
+	"strings"
+)
+
+type LocalGlobalResolver struct {
+}
+
+func (resolver *LocalGlobalResolver) TryResolve(param *ResolveParam) (endpoint string, support bool, err error) {
+	// get the global endpoints configs
+	endpointExpression := fmt.Sprintf("products[?code=='%s'].global_endpoint", strings.ToLower(param.Product))
+	endpointData, err := jmespath.Search(endpointExpression, getEndpointConfigData())
+	if err == nil && endpointData != nil && len(endpointData.([]interface{})) > 0 {
+		endpoint = endpointData.([]interface{})[0].(string)
+		support = len(endpoint) > 0
+		return endpoint, support, nil
+	}
+	support = false
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/local_regional_resolver.go

@@ -0,0 +1,41 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package endpoints
+
+import (
+	"fmt"
+	"github.com/jmespath/go-jmespath"
+	"strings"
+)
+
+type LocalRegionalResolver struct {
+}
+
+func (resolver *LocalRegionalResolver) TryResolve(param *ResolveParam) (endpoint string, support bool, err error) {
+	// get the regional endpoints configs
+	regionalExpression := fmt.Sprintf("products[?code=='%s'].regional_endpoints", strings.ToLower(param.Product))
+	regionalData, err := jmespath.Search(regionalExpression, getEndpointConfigData())
+	if err == nil && regionalData != nil && len(regionalData.([]interface{})) > 0 {
+		endpointExpression := fmt.Sprintf("[0][?region=='%s'].endpoint", strings.ToLower(param.RegionId))
+		endpointData, err := jmespath.Search(endpointExpression, regionalData)
+		if err == nil && endpointData != nil && len(endpointData.([]interface{})) > 0 {
+			endpoint = endpointData.([]interface{})[0].(string)
+			support = len(endpoint) > 0
+			return endpoint, support, nil
+		}
+	}
+	support = false
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/location_resolver.go

@@ -0,0 +1,139 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package endpoints
+
+import (
+	"encoding/json"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"sync"
+	"time"
+)
+
+const (
+	EndpointCacheExpireTime = 3600 //Seconds
+)
+
+var lastClearTimePerProduct = struct {
+	sync.RWMutex
+	cache map[string]int64
+}{cache: make(map[string]int64)}
+
+var endpointCache = struct {
+	sync.RWMutex
+	cache map[string]string
+}{cache: make(map[string]string)}
+
+type LocationResolver struct {
+}
+
+func (resolver *LocationResolver) TryResolve(param *ResolveParam) (endpoint string, support bool, err error) {
+	if len(param.LocationProduct) <= 0 {
+		support = false
+		return
+	}
+
+	//get from cache
+	cacheKey := param.Product + "#" + param.RegionId
+	if endpointCache.cache != nil && len(endpointCache.cache[cacheKey]) > 0 && !CheckCacheIsExpire(cacheKey) {
+		endpoint = endpointCache.cache[cacheKey]
+		support = true
+		return
+	}
+
+	//get from remote
+	getEndpointRequest := requests.NewCommonRequest()
+
+	getEndpointRequest.Product = "Location"
+	getEndpointRequest.Version = "2015-06-12"
+	getEndpointRequest.ApiName = "DescribeEndpoints"
+	getEndpointRequest.Domain = "location.aliyuncs.com"
+	getEndpointRequest.Method = "GET"
+	getEndpointRequest.Scheme = requests.HTTPS
+
+	getEndpointRequest.QueryParams["Id"] = param.RegionId
+	getEndpointRequest.QueryParams["ServiceCode"] = param.LocationProduct
+	if len(param.LocationEndpointType) > 0 {
+		getEndpointRequest.QueryParams["Type"] = param.LocationEndpointType
+	} else {
+		getEndpointRequest.QueryParams["Type"] = "openAPI"
+	}
+
+	response, err := param.CommonApi(getEndpointRequest)
+	var getEndpointResponse GetEndpointResponse
+	if !response.IsSuccess() {
+		support = false
+		return
+	}
+
+	json.Unmarshal([]byte(response.GetHttpContentString()), &getEndpointResponse)
+	if !getEndpointResponse.Success || getEndpointResponse.Endpoints == nil {
+		support = false
+		return
+	}
+	if len(getEndpointResponse.Endpoints.Endpoint) <= 0 {
+		support = false
+		return
+	}
+	if len(getEndpointResponse.Endpoints.Endpoint[0].Endpoint) > 0 {
+		endpoint = getEndpointResponse.Endpoints.Endpoint[0].Endpoint
+		endpointCache.Lock()
+		endpointCache.cache[cacheKey] = endpoint
+		endpointCache.Unlock()
+		lastClearTimePerProduct.Lock()
+		lastClearTimePerProduct.cache[cacheKey] = time.Now().Unix()
+		lastClearTimePerProduct.Unlock()
+		support = true
+		return
+	}
+
+	support = false
+	return
+}
+
+func CheckCacheIsExpire(cacheKey string) bool {
+	lastClearTime := lastClearTimePerProduct.cache[cacheKey]
+	if lastClearTime <= 0 {
+		lastClearTime = time.Now().Unix()
+		lastClearTimePerProduct.Lock()
+		lastClearTimePerProduct.cache[cacheKey] = lastClearTime
+		lastClearTimePerProduct.Unlock()
+	}
+
+	now := time.Now().Unix()
+	elapsedTime := now - lastClearTime
+	if elapsedTime > EndpointCacheExpireTime {
+		return true
+	}
+
+	return false
+}
+
+type GetEndpointResponse struct {
+	Endpoints *EndpointsObj
+	RequestId string
+	Success   bool
+}
+
+type EndpointsObj struct {
+	Endpoint []EndpointObj
+}
+
+type EndpointObj struct {
+	Protocols   map[string]string
+	Type        string
+	Namespace   string
+	Id          string
+	SerivceCode string
+	Endpoint    string
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/mapping_resolver.go

@@ -0,0 +1,39 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package endpoints
+
+import (
+	"fmt"
+	"strings"
+)
+
+const keyFormatter = "%s::%s"
+
+var endpointMapping = make(map[string]string)
+
+func AddEndpointMapping(regionId, productId, endpoint string) (err error) {
+	key := fmt.Sprintf(keyFormatter, strings.ToLower(regionId), strings.ToLower(productId))
+	endpointMapping[key] = endpoint
+	return nil
+}
+
+type MappingResolver struct {
+}
+
+func (resolver *MappingResolver) TryResolve(param *ResolveParam) (endpoint string, support bool, err error) {
+	key := fmt.Sprintf(keyFormatter, strings.ToLower(param.RegionId), strings.ToLower(param.Product))
+	endpoint, contains := endpointMapping[key]
+	return endpoint, contains, nil
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/resolver.go

@@ -0,0 +1,80 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package endpoints
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+	"sync"
+)
+
+const (
+	ResolveEndpointUserGuideLink = ""
+)
+
+var once sync.Once
+var resolvers []Resolver
+
+type Resolver interface {
+	TryResolve(param *ResolveParam) (endpoint string, support bool, err error)
+}
+
+func Resolve(param *ResolveParam) (endpoint string, err error) {
+	supportedResolvers := getAllResolvers()
+	for _, resolver := range supportedResolvers {
+		endpoint, supported, err := resolver.TryResolve(param)
+		if supported {
+			return endpoint, err
+		}
+	}
+
+	// not support
+	errorMsg := fmt.Sprintf(errors.CanNotResolveEndpointErrorMessage, param, ResolveEndpointUserGuideLink)
+	err = errors.NewClientError(errors.CanNotResolveEndpointErrorCode, errorMsg, nil)
+	return
+}
+
+func getAllResolvers() []Resolver {
+	once.Do(func() {
+		resolvers = []Resolver{
+			&SimpleHostResolver{},
+			&MappingResolver{},
+			&LocationResolver{},
+			&LocalRegionalResolver{},
+			&LocalGlobalResolver{},
+		}
+	})
+	return resolvers
+}
+
+type ResolveParam struct {
+	Domain               string
+	Product              string
+	RegionId             string
+	LocationProduct      string
+	LocationEndpointType string
+	CommonApi            func(request *requests.CommonRequest) (response *responses.CommonResponse, err error) `json:"-"`
+}
+
+func (param *ResolveParam) String() string {
+	jsonBytes, err := json.Marshal(param)
+	if err != nil {
+		return fmt.Sprint("ResolveParam.String() process error:", err)
+	}
+	return string(jsonBytes)
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/simple_host_resolver.go

@@ -0,0 +1,25 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package endpoints
+
+type SimpleHostResolver struct {
+}
+
+func (resolver *SimpleHostResolver) TryResolve(param *ResolveParam) (endpoint string, support bool, err error) {
+	if support = len(param.Domain) > 0; support {
+		endpoint = param.Domain
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors/client_error.go

@@ -0,0 +1,92 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package errors
+
+import "fmt"
+
+const (
+	DefaultClientErrorStatus = 400
+	DefaultClientErrorCode   = "SDK.ClientError"
+
+	UnsupportedCredentialErrorCode    = "SDK.UnsupportedCredential"
+	UnsupportedCredentialErrorMessage = "Specified credential (type = %s) is not supported, please check"
+
+	CanNotResolveEndpointErrorCode    = "SDK.CanNotResolveEndpoint"
+	CanNotResolveEndpointErrorMessage = "Can not resolve endpoint(param = %s), please check your accessKey with secret, and read the user guide\n %s"
+
+	UnsupportedParamPositionErrorCode    = "SDK.UnsupportedParamPosition"
+	UnsupportedParamPositionErrorMessage = "Specified param position (%s) is not supported, please upgrade sdk and retry"
+
+	AsyncFunctionNotEnabledCode    = "SDK.AsyncFunctionNotEnabled"
+	AsyncFunctionNotEnabledMessage = "Async function is not enabled in client, please invoke 'client.EnableAsync' function"
+
+	UnknownRequestTypeErrorCode    = "SDK.UnknownRequestType"
+	UnknownRequestTypeErrorMessage = "Unknown Request Type: %s"
+
+	MissingParamErrorCode = "SDK.MissingParam"
+	InvalidParamErrorCode = "SDK.InvalidParam"
+
+	JsonUnmarshalErrorCode    = "SDK.JsonUnmarshalError"
+	JsonUnmarshalErrorMessage = "Failed to unmarshal response, but you can get the data via response.GetHttpStatusCode() and response.GetHttpContentString()"
+
+	TimeoutErrorCode    = "SDK.TimeoutError"
+	TimeoutErrorMessage = "The request timed out %s times(%s for retry), perhaps we should have the threshold raised a little?"
+)
+
+type ClientError struct {
+	errorCode   string
+	message     string
+	originError error
+}
+
+func NewClientError(errorCode, message string, originErr error) Error {
+	return &ClientError{
+		errorCode:   errorCode,
+		message:     message,
+		originError: originErr,
+	}
+}
+
+func (err *ClientError) Error() string {
+	clientErrMsg := fmt.Sprintf("[%s] %s", err.errorCode, err.message)
+	if err.originError != nil {
+		return clientErrMsg + "\ncaused by:\n" + err.originError.Error()
+	}
+	return clientErrMsg
+}
+
+func (err *ClientError) OriginError() error {
+	return err.originError
+}
+
+func (*ClientError) HttpStatus() int {
+	return DefaultClientErrorStatus
+}
+
+func (err *ClientError) ErrorCode() string {
+	if err.errorCode == "" {
+		return DefaultClientErrorCode
+	} else {
+		return err.errorCode
+	}
+}
+
+func (err *ClientError) Message() string {
+	return err.message
+}
+
+func (err *ClientError) String() string {
+	return err.Error()
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors/error.go

@@ -0,0 +1,23 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package errors
+
+type Error interface {
+	error
+	HttpStatus() int
+	ErrorCode() string
+	Message() string
+	OriginError() error
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors/server_error.go

@@ -0,0 +1,122 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package errors
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/jmespath/go-jmespath"
+)
+
+var wrapperList = []ServerErrorWrapper{
+	&SignatureDostNotMatchWrapper{},
+}
+
+type ServerError struct {
+	httpStatus int
+	requestId  string
+	hostId     string
+	errorCode  string
+	recommend  string
+	message    string
+	comment    string
+}
+
+type ServerErrorWrapper interface {
+	tryWrap(error *ServerError, wrapInfo map[string]string) (bool, *ServerError)
+}
+
+func (err *ServerError) Error() string {
+	return fmt.Sprintf("SDK.ServerError\nErrorCode: %s\nRecommend: %s\nRequestId: %s\nMessage: %s",
+		err.errorCode, err.comment+err.recommend, err.requestId, err.message)
+}
+
+func NewServerError(httpStatus int, responseContent, comment string) Error {
+	result := &ServerError{
+		httpStatus: httpStatus,
+		message:    responseContent,
+		comment:    comment,
+	}
+
+	var data interface{}
+	err := json.Unmarshal([]byte(responseContent), &data)
+	if err == nil {
+		requestId, _ := jmespath.Search("RequestId", data)
+		hostId, _ := jmespath.Search("HostId", data)
+		errorCode, _ := jmespath.Search("Code", data)
+		recommend, _ := jmespath.Search("Recommend", data)
+		message, _ := jmespath.Search("Message", data)
+
+		if requestId != nil {
+			result.requestId = requestId.(string)
+		}
+		if hostId != nil {
+			result.hostId = hostId.(string)
+		}
+		if errorCode != nil {
+			result.errorCode = errorCode.(string)
+		}
+		if recommend != nil {
+			result.recommend = recommend.(string)
+		}
+		if message != nil {
+			result.message = message.(string)
+		}
+	}
+
+	return result
+}
+
+func WrapServerError(originError *ServerError, wrapInfo map[string]string) *ServerError {
+	for _, wrapper := range wrapperList {
+		ok, newError := wrapper.tryWrap(originError, wrapInfo)
+		if ok {
+			return newError
+		}
+	}
+	return originError
+}
+
+func (err *ServerError) HttpStatus() int {
+	return err.httpStatus
+}
+
+func (err *ServerError) ErrorCode() string {
+	return err.errorCode
+}
+
+func (err *ServerError) Message() string {
+	return err.message
+}
+
+func (err *ServerError) OriginError() error {
+	return nil
+}
+
+func (err *ServerError) HostId() string {
+	return err.hostId
+}
+
+func (err *ServerError) RequestId() string {
+	return err.requestId
+}
+
+func (err *ServerError) Recommend() string {
+	return err.recommend
+}
+
+func (err *ServerError) Comment() string {
+	return err.comment
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors/signature_does_not_match_wrapper.go

@@ -0,0 +1,29 @@
+package errors
+
+import "strings"
+
+const SignatureDostNotMatchErrorCode = "SignatureDoesNotMatch"
+const MessagePrefix = "Specified signature is not matched with our calculation. server string to sign is:"
+
+type SignatureDostNotMatchWrapper struct {
+}
+
+func (*SignatureDostNotMatchWrapper) tryWrap(error *ServerError, wrapInfo map[string]string) (bool, *ServerError) {
+	clientStringToSign := wrapInfo["StringToSign"]
+	if error.errorCode == SignatureDostNotMatchErrorCode && clientStringToSign != "" {
+		message := error.message
+		if strings.HasPrefix(message, MessagePrefix) {
+			serverStringToSign := message[len(MessagePrefix):]
+			if clientStringToSign == serverStringToSign {
+				// user secret is error
+				error.recommend = "Please check you AccessKeySecret"
+			} else {
+				error.recommend = "This may be a bug with the SDK and we hope you can submit this question in the " +
+					"github issue(https://github.com/aliyun/alibaba-cloud-sdk-go/issues), thanks very much"
+			}
+		}
+		return true, error
+	} else {
+		return false, nil
+	}
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/acs_reqeust.go

@@ -0,0 +1,309 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package requests
+
+import (
+	"fmt"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"io"
+	"reflect"
+	"strconv"
+)
+
+const (
+	RPC = "RPC"
+	ROA = "ROA"
+
+	HTTP  = "HTTP"
+	HTTPS = "HTTPS"
+
+	DefaultHttpPort = "80"
+
+	GET     = "GET"
+	PUT     = "PUT"
+	POST    = "POST"
+	DELETE  = "DELETE"
+	HEAD    = "HEAD"
+	OPTIONS = "OPTIONS"
+
+	Json = "application/json"
+	Xml  = "application/xml"
+	Raw  = "application/octet-stream"
+	Form = "application/x-www-form-urlencoded"
+
+	Header = "Header"
+	Query  = "Query"
+	Body   = "Body"
+	Path   = "Path"
+
+	HeaderSeparator = "\n"
+)
+
+// interface
+type AcsRequest interface {
+	GetScheme() string
+	GetMethod() string
+	GetDomain() string
+	GetPort() string
+	GetRegionId() string
+	GetUrl() string
+	GetQueries() string
+	GetHeaders() map[string]string
+	GetQueryParams() map[string]string
+	GetFormParams() map[string]string
+	GetContent() []byte
+	GetBodyReader() io.Reader
+	GetStyle() string
+	GetProduct() string
+	GetVersion() string
+	GetActionName() string
+	GetAcceptFormat() string
+	GetLocationServiceCode() string
+	GetLocationEndpointType() string
+
+	SetStringToSign(stringToSign string)
+	GetStringToSign() string
+
+	SetDomain(domain string)
+	SetContent(content []byte)
+	SetScheme(scheme string)
+	BuildUrl() string
+	BuildQueries() string
+
+	addHeaderParam(key, value string)
+	addQueryParam(key, value string)
+	addFormParam(key, value string)
+	addPathParam(key, value string)
+}
+
+// base class
+type baseRequest struct {
+	Scheme   string
+	Method   string
+	Domain   string
+	Port     string
+	RegionId string
+
+	product string
+	version string
+
+	actionName string
+
+	AcceptFormat string
+
+	QueryParams map[string]string
+	Headers     map[string]string
+	FormParams  map[string]string
+	Content     []byte
+
+	locationServiceCode  string
+	locationEndpointType string
+
+	queries string
+
+	stringToSign string
+}
+
+func (request *baseRequest) GetQueryParams() map[string]string {
+	return request.QueryParams
+}
+
+func (request *baseRequest) GetFormParams() map[string]string {
+	return request.FormParams
+}
+
+func (request *baseRequest) GetContent() []byte {
+	return request.Content
+}
+
+func (request *baseRequest) GetVersion() string {
+	return request.version
+}
+
+func (request *baseRequest) GetActionName() string {
+	return request.actionName
+}
+
+func (request *baseRequest) SetContent(content []byte) {
+	request.Content = content
+}
+
+func (request *baseRequest) addHeaderParam(key, value string) {
+	request.Headers[key] = value
+}
+
+func (request *baseRequest) addQueryParam(key, value string) {
+	request.QueryParams[key] = value
+}
+
+func (request *baseRequest) addFormParam(key, value string) {
+	request.FormParams[key] = value
+}
+
+func (request *baseRequest) GetAcceptFormat() string {
+	return request.AcceptFormat
+}
+
+func (request *baseRequest) GetLocationServiceCode() string {
+	return request.locationServiceCode
+}
+
+func (request *baseRequest) GetLocationEndpointType() string {
+	return request.locationEndpointType
+}
+
+func (request *baseRequest) GetProduct() string {
+	return request.product
+}
+
+func (request *baseRequest) GetScheme() string {
+	return request.Scheme
+}
+
+func (request *baseRequest) SetScheme(scheme string) {
+	request.Scheme = scheme
+}
+
+func (request *baseRequest) GetMethod() string {
+	return request.Method
+}
+
+func (request *baseRequest) GetDomain() string {
+	return request.Domain
+}
+
+func (request *baseRequest) SetDomain(host string) {
+	request.Domain = host
+}
+
+func (request *baseRequest) GetPort() string {
+	return request.Port
+}
+
+func (request *baseRequest) GetRegionId() string {
+	return request.RegionId
+}
+
+func (request *baseRequest) GetHeaders() map[string]string {
+	return request.Headers
+}
+
+func (request *baseRequest) SetContentType(contentType string) {
+	request.Headers["Content-Type"] = contentType
+}
+
+func (request *baseRequest) GetContentType() (contentType string, contains bool) {
+	contentType, contains = request.Headers["Content-Type"]
+	return
+}
+
+func (request *baseRequest) SetStringToSign(stringToSign string) {
+	request.stringToSign = stringToSign
+}
+
+func (request *baseRequest) GetStringToSign() string {
+	return request.stringToSign
+}
+
+func defaultBaseRequest() (request *baseRequest) {
+	request = &baseRequest{
+		Scheme:       "",
+		AcceptFormat: "JSON",
+		Method:       GET,
+		QueryParams:  make(map[string]string),
+		Headers: map[string]string{
+			"x-sdk-client":      "golang/1.0.0",
+			"x-sdk-invoke-type": "normal",
+			"Accept-Encoding": "identity",
+		},
+		FormParams: make(map[string]string),
+	}
+	return
+}
+
+func InitParams(request AcsRequest) (err error) {
+	requestValue := reflect.ValueOf(request).Elem()
+	err = flatRepeatedList(requestValue, request, "", "")
+	return
+}
+
+func flatRepeatedList(dataValue reflect.Value, request AcsRequest, position, prefix string) (err error) {
+	dataType := dataValue.Type()
+	for i := 0; i < dataType.NumField(); i++ {
+		field := dataType.Field(i)
+		name, containsNameTag := field.Tag.Lookup("name")
+		fieldPosition := position
+		if fieldPosition == "" {
+			fieldPosition, _ = field.Tag.Lookup("position")
+		}
+		typeTag, containsTypeTag := field.Tag.Lookup("type")
+		if containsNameTag {
+			if !containsTypeTag {
+				// simple param
+				key := prefix + name
+				value := dataValue.Field(i).String()
+				err = addParam(request, fieldPosition, key, value)
+				if err != nil {
+					return
+				}
+			} else if typeTag == "Repeated" {
+				// repeated param
+				repeatedFieldValue := dataValue.Field(i)
+				if repeatedFieldValue.Kind() != reflect.Slice {
+					// possible value: {"[]string", "*[]struct"}, we must call Elem() in the last condition
+					repeatedFieldValue = repeatedFieldValue.Elem()
+				}
+				if repeatedFieldValue.IsValid() && !repeatedFieldValue.IsNil() {
+					for m := 0; m < repeatedFieldValue.Len(); m++ {
+						elementValue := repeatedFieldValue.Index(m)
+						key := prefix + name + "." + strconv.Itoa(m+1)
+						if elementValue.Type().String() == "string" {
+							value := elementValue.String()
+							err = addParam(request, fieldPosition, key, value)
+							if err != nil {
+								return
+							}
+						} else {
+							err = flatRepeatedList(elementValue, request, fieldPosition, key+".")
+							if err != nil {
+								return
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return
+}
+
+func addParam(request AcsRequest, position, name, value string) (err error) {
+	if len(value) > 0 {
+		switch position {
+		case Header:
+			request.addHeaderParam(name, value)
+		case Query:
+			request.addQueryParam(name, value)
+		case Path:
+			request.addPathParam(name, value)
+		case Body:
+			request.addFormParam(name, value)
+		default:
+			errMsg := fmt.Sprintf(errors.UnsupportedParamPositionErrorMessage, position)
+			err = errors.NewClientError(errors.UnsupportedParamPositionErrorCode, errMsg, nil)
+		}
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/common_request.go

@@ -0,0 +1,128 @@
+package requests
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"io"
+	"strings"
+)
+
+type CommonRequest struct {
+	*baseRequest
+
+	Version string
+	ApiName string
+	Product string
+
+	// roa params
+	PathPattern string
+	PathParams  map[string]string
+
+	Ontology AcsRequest
+}
+
+func NewCommonRequest() (request *CommonRequest) {
+	request = &CommonRequest{
+		baseRequest: defaultBaseRequest(),
+	}
+	request.Headers["x-sdk-invoke-type"] = "common"
+	request.PathParams = make(map[string]string)
+	return
+}
+
+func (request *CommonRequest) String() string {
+	request.TransToAcsRequest()
+	request.BuildQueries()
+	request.BuildUrl()
+
+	resultBuilder := bytes.Buffer{}
+
+	mapOutput := func(m map[string]string) {
+		if len(m) > 0 {
+			for key, value := range m {
+				resultBuilder.WriteString(key + ": " + value + "\n")
+			}
+		}
+	}
+
+	// Request Line
+	resultBuilder.WriteString("\n")
+	resultBuilder.WriteString(fmt.Sprintf("%s %s %s/1.1\n", request.Method, request.GetQueries(), strings.ToUpper(request.Scheme)))
+
+	// Headers
+	resultBuilder.WriteString("Host" + ": " + request.Domain + "\n")
+	mapOutput(request.Headers)
+
+	resultBuilder.WriteString("\n")
+	// Body
+	if len(request.Content) > 0 {
+		resultBuilder.WriteString(string(request.Content) + "\n")
+	} else {
+		mapOutput(request.FormParams)
+	}
+
+	return resultBuilder.String()
+}
+
+func (request *CommonRequest) TransToAcsRequest() {
+	if len(request.Version) == 0 {
+		errors.NewClientError(errors.MissingParamErrorCode, "Common request [version] is required", nil)
+	}
+	if len(request.ApiName) == 0 && len(request.PathPattern) == 0 {
+		errors.NewClientError(errors.MissingParamErrorCode, "At least one of [ApiName] and [PathPattern] should has a value", nil)
+	}
+	if len(request.Domain) == 0 && len(request.Product) == 0 {
+		errors.NewClientError(errors.MissingParamErrorCode, "At least one of [Domain] and [Product] should has a value", nil)
+	}
+
+	if len(request.PathPattern) > 0 {
+		roaRequest := &RoaRequest{}
+		roaRequest.initWithCommonRequest(request)
+		request.Ontology = roaRequest
+	} else {
+		rpcRequest := &RpcRequest{}
+		rpcRequest.baseRequest = request.baseRequest
+		rpcRequest.product = request.Product
+		rpcRequest.version = request.Version
+		rpcRequest.actionName = request.ApiName
+		request.Ontology = rpcRequest
+	}
+
+}
+
+func (request *CommonRequest) BuildUrl() string {
+	if len(request.Port) > 0 {
+		return strings.ToLower(request.Scheme) + "://" + request.Domain + ":" + request.Port + request.BuildQueries()
+	}
+
+	return strings.ToLower(request.Scheme) + "://" + request.Domain + request.BuildQueries()
+}
+
+func (request *CommonRequest) BuildQueries() string {
+	return request.Ontology.BuildQueries()
+}
+
+func (request *CommonRequest) GetUrl() string {
+	if len(request.Port) > 0 {
+		return strings.ToLower(request.Scheme) + "://" + request.Domain + ":" + request.Port + request.GetQueries()
+	}
+
+	return strings.ToLower(request.Scheme) + "://" + request.Domain + request.GetQueries()
+}
+
+func (request *CommonRequest) GetQueries() string {
+	return request.Ontology.GetQueries()
+}
+
+func (request *CommonRequest) GetBodyReader() io.Reader {
+	return request.Ontology.GetBodyReader()
+}
+
+func (request *CommonRequest) GetStyle() string {
+	return request.Ontology.GetStyle()
+}
+
+func (request *CommonRequest) addPathParam(key, value string) {
+	request.PathParams[key] = value
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/roa_request.go

@@ -0,0 +1,146 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package requests
+
+import (
+	"bytes"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils"
+	"io"
+	"net/url"
+	"sort"
+	"strings"
+)
+
+type RoaRequest struct {
+	*baseRequest
+	pathPattern string
+	PathParams  map[string]string
+}
+
+func (*RoaRequest) GetStyle() string {
+	return ROA
+}
+
+func (request *RoaRequest) GetBodyReader() io.Reader {
+	if request.FormParams != nil && len(request.FormParams) > 0 {
+		formString := utils.GetUrlFormedMap(request.FormParams)
+		return strings.NewReader(formString)
+	} else if len(request.Content) > 0 {
+		return bytes.NewReader(request.Content)
+	} else {
+		return nil
+	}
+}
+
+func (request *RoaRequest) GetQueries() string {
+	return request.queries
+}
+
+// for sign method, need not url encoded
+func (request *RoaRequest) BuildQueries() string {
+	return request.buildQueries(false)
+}
+
+func (request *RoaRequest) buildQueries(needParamEncode bool) string {
+	// replace path params with value
+	path := request.pathPattern
+	for key, value := range request.PathParams {
+		path = strings.Replace(path, "["+key+"]", value, 1)
+	}
+
+	queryParams := request.QueryParams
+	// check if path contains params
+	splitArray := strings.Split(path, "?")
+	path = splitArray[0]
+	if len(splitArray) > 1 && len(splitArray[1]) > 0 {
+		queryParams[splitArray[1]] = ""
+	}
+	// sort QueryParams by key
+	var queryKeys []string
+	for key := range queryParams {
+		queryKeys = append(queryKeys, key)
+	}
+	sort.Strings(queryKeys)
+
+	// append urlBuilder
+	urlBuilder := bytes.Buffer{}
+	urlBuilder.WriteString(path)
+	if len(queryKeys) > 0 {
+		urlBuilder.WriteString("?")
+	}
+	for i := 0; i < len(queryKeys); i++ {
+		queryKey := queryKeys[i]
+		urlBuilder.WriteString(queryKey)
+		if value := queryParams[queryKey]; len(value) > 0 {
+			urlBuilder.WriteString("=")
+			if needParamEncode {
+				urlBuilder.WriteString(url.QueryEscape(value))
+			} else {
+				urlBuilder.WriteString(value)
+			}
+		}
+		if i < len(queryKeys)-1 {
+			urlBuilder.WriteString("&")
+		}
+	}
+	result := urlBuilder.String()
+	result = popStandardUrlencode(result)
+	request.queries = result
+	return request.queries
+}
+
+func popStandardUrlencode(stringToSign string) (result string) {
+	result = strings.Replace(stringToSign, "+", "%20", -1)
+	result = strings.Replace(result, "*", "%2A", -1)
+	result = strings.Replace(result, "%7E", "~", -1)
+	return
+}
+
+func (request *RoaRequest) GetUrl() string {
+	return strings.ToLower(request.Scheme) + "://" + request.Domain + ":" + request.Port + request.GetQueries()
+}
+
+func (request *RoaRequest) BuildUrl() string {
+	// for network trans, need url encoded
+	return strings.ToLower(request.Scheme) + "://" + request.Domain + ":" + request.Port + request.buildQueries(true)
+}
+
+func (request *RoaRequest) addPathParam(key, value string) {
+	request.PathParams[key] = value
+}
+
+func (request *RoaRequest) InitWithApiInfo(product, version, action, uriPattern, serviceCode, endpointType string) {
+	request.baseRequest = defaultBaseRequest()
+	request.PathParams = make(map[string]string)
+	request.Headers["x-acs-version"] = version
+	request.pathPattern = uriPattern
+	request.locationServiceCode = serviceCode
+	request.locationEndpointType = endpointType
+	//request.product = product
+	//request.version = version
+	//request.actionName = action
+}
+
+func (request *RoaRequest) initWithCommonRequest(commonRequest *CommonRequest) {
+	request.baseRequest = commonRequest.baseRequest
+	request.PathParams = commonRequest.PathParams
+	//request.product = commonRequest.Product
+	//request.version = commonRequest.Version
+	request.Headers["x-acs-version"] = commonRequest.Version
+	//request.actionName = commonRequest.ApiName
+	request.pathPattern = commonRequest.PathPattern
+	request.locationServiceCode = ""
+	request.locationEndpointType = ""
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/rpc_request.go

@@ -0,0 +1,81 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package requests
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils"
+	"io"
+	"strings"
+)
+
+type RpcRequest struct {
+	*baseRequest
+}
+
+func (request *RpcRequest) init() {
+	request.baseRequest = defaultBaseRequest()
+	request.Method = POST
+}
+
+func (*RpcRequest) GetStyle() string {
+	return RPC
+}
+
+func (request *RpcRequest) GetBodyReader() io.Reader {
+	if request.FormParams != nil && len(request.FormParams) > 0 {
+		formString := utils.GetUrlFormedMap(request.FormParams)
+		return strings.NewReader(formString)
+	} else {
+		return strings.NewReader("")
+	}
+}
+
+func (request *RpcRequest) BuildQueries() string {
+	request.queries = "/?" + utils.GetUrlFormedMap(request.QueryParams)
+	return request.queries
+}
+
+func (request *RpcRequest) GetQueries() string {
+	return request.queries
+}
+
+func (request *RpcRequest) BuildUrl() string {
+	return strings.ToLower(request.Scheme) + "://" + request.Domain + ":" + request.Port + request.BuildQueries()
+}
+
+func (request *RpcRequest) GetUrl() string {
+	return strings.ToLower(request.Scheme) + "://" + request.Domain + request.GetQueries()
+}
+
+func (request *RpcRequest) GetVersion() string {
+	return request.version
+}
+
+func (request *RpcRequest) GetActionName() string {
+	return request.actionName
+}
+
+func (request *RpcRequest) addPathParam(key, value string) {
+	panic("not support")
+}
+
+func (request *RpcRequest) InitWithApiInfo(product, version, action, serviceCode, endpointType string) {
+	request.init()
+	request.product = product
+	request.version = version
+	request.actionName = action
+	request.locationServiceCode = serviceCode
+	request.locationEndpointType = endpointType
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/types.go

@@ -0,0 +1,53 @@
+package requests
+
+import "strconv"
+
+type Integer string
+
+func NewInteger(integer int) Integer {
+	return Integer(strconv.Itoa(integer))
+}
+
+func (integer Integer) HasValue() bool {
+	return integer != ""
+}
+
+func (integer Integer) GetValue() (int, error) {
+	return strconv.Atoi(string(integer))
+}
+
+func NewInteger64(integer int64) Integer {
+	return Integer(strconv.FormatInt(integer, 10))
+}
+
+func (integer Integer) GetValue64() (int64, error) {
+	return strconv.ParseInt(string(integer), 10, 0)
+}
+
+type Boolean string
+
+func NewBoolean(bool bool) Boolean {
+	return Boolean(strconv.FormatBool(bool))
+}
+
+func (boolean Boolean) HasValue() bool {
+	return boolean != ""
+}
+
+func (boolean Boolean) GetValue() (bool, error) {
+	return strconv.ParseBool(string(boolean))
+}
+
+type Float string
+
+func NewFloat(f float64) Float {
+	return Float(strconv.FormatFloat(f, 'f', 6, 64))
+}
+
+func (float Float) HasValue() bool {
+	return float != ""
+}
+
+func (float Float) GetValue() (float64, error) {
+	return strconv.ParseFloat(string(float), 64)
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses/json_parser.go

@@ -0,0 +1,341 @@
+package responses
+
+import (
+	"encoding/json"
+	"github.com/json-iterator/go"
+	"io"
+	"math"
+	"strconv"
+	"strings"
+	"sync"
+	"unsafe"
+)
+
+const maxUint = ^uint(0)
+const maxInt = int(maxUint >> 1)
+const minInt = -maxInt - 1
+
+var jsonParser jsoniter.API
+var initJson = &sync.Once{}
+
+func initJsonParserOnce() {
+	initJson.Do(func() {
+		registerBetterFuzzyDecoder()
+		jsonParser = jsoniter.ConfigCompatibleWithStandardLibrary
+	})
+}
+
+func registerBetterFuzzyDecoder() {
+	jsoniter.RegisterTypeDecoder("string", &nullableFuzzyStringDecoder{})
+	jsoniter.RegisterTypeDecoder("bool", &fuzzyBoolDecoder{})
+	jsoniter.RegisterTypeDecoder("float32", &nullableFuzzyFloat32Decoder{})
+	jsoniter.RegisterTypeDecoder("float64", &nullableFuzzyFloat64Decoder{})
+	jsoniter.RegisterTypeDecoder("int", &nullableFuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(maxInt) || val < float64(minInt) {
+				iter.ReportError("fuzzy decode int", "exceed range")
+				return
+			}
+			*((*int)(ptr)) = int(val)
+		} else {
+			*((*int)(ptr)) = iter.ReadInt()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("uint", &nullableFuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(maxUint) || val < 0 {
+				iter.ReportError("fuzzy decode uint", "exceed range")
+				return
+			}
+			*((*uint)(ptr)) = uint(val)
+		} else {
+			*((*uint)(ptr)) = iter.ReadUint()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("int8", &nullableFuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxInt8) || val < float64(math.MinInt8) {
+				iter.ReportError("fuzzy decode int8", "exceed range")
+				return
+			}
+			*((*int8)(ptr)) = int8(val)
+		} else {
+			*((*int8)(ptr)) = iter.ReadInt8()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("uint8", &nullableFuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxUint8) || val < 0 {
+				iter.ReportError("fuzzy decode uint8", "exceed range")
+				return
+			}
+			*((*uint8)(ptr)) = uint8(val)
+		} else {
+			*((*uint8)(ptr)) = iter.ReadUint8()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("int16", &nullableFuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxInt16) || val < float64(math.MinInt16) {
+				iter.ReportError("fuzzy decode int16", "exceed range")
+				return
+			}
+			*((*int16)(ptr)) = int16(val)
+		} else {
+			*((*int16)(ptr)) = iter.ReadInt16()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("uint16", &nullableFuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxUint16) || val < 0 {
+				iter.ReportError("fuzzy decode uint16", "exceed range")
+				return
+			}
+			*((*uint16)(ptr)) = uint16(val)
+		} else {
+			*((*uint16)(ptr)) = iter.ReadUint16()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("int32", &nullableFuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxInt32) || val < float64(math.MinInt32) {
+				iter.ReportError("fuzzy decode int32", "exceed range")
+				return
+			}
+			*((*int32)(ptr)) = int32(val)
+		} else {
+			*((*int32)(ptr)) = iter.ReadInt32()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("uint32", &nullableFuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxUint32) || val < 0 {
+				iter.ReportError("fuzzy decode uint32", "exceed range")
+				return
+			}
+			*((*uint32)(ptr)) = uint32(val)
+		} else {
+			*((*uint32)(ptr)) = iter.ReadUint32()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("int64", &nullableFuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxInt64) || val < float64(math.MinInt64) {
+				iter.ReportError("fuzzy decode int64", "exceed range")
+				return
+			}
+			*((*int64)(ptr)) = int64(val)
+		} else {
+			*((*int64)(ptr)) = iter.ReadInt64()
+		}
+	}})
+	jsoniter.RegisterTypeDecoder("uint64", &nullableFuzzyIntegerDecoder{func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+		if isFloat {
+			val := iter.ReadFloat64()
+			if val > float64(math.MaxUint64) || val < 0 {
+				iter.ReportError("fuzzy decode uint64", "exceed range")
+				return
+			}
+			*((*uint64)(ptr)) = uint64(val)
+		} else {
+			*((*uint64)(ptr)) = iter.ReadUint64()
+		}
+	}})
+}
+
+type nullableFuzzyStringDecoder struct {
+}
+
+func (decoder *nullableFuzzyStringDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	valueType := iter.WhatIsNext()
+	switch valueType {
+	case jsoniter.NumberValue:
+		var number json.Number
+		iter.ReadVal(&number)
+		*((*string)(ptr)) = string(number)
+	case jsoniter.StringValue:
+		*((*string)(ptr)) = iter.ReadString()
+	case jsoniter.BoolValue:
+		*((*string)(ptr)) = strconv.FormatBool(iter.ReadBool())
+	case jsoniter.NilValue:
+		iter.ReadNil()
+		*((*string)(ptr)) = ""
+	default:
+		iter.ReportError("fuzzyStringDecoder", "not number or string or bool")
+	}
+}
+
+type fuzzyBoolDecoder struct {
+}
+
+func (decoder *fuzzyBoolDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	valueType := iter.WhatIsNext()
+	switch valueType {
+	case jsoniter.BoolValue:
+		*((*bool)(ptr)) = iter.ReadBool()
+	case jsoniter.NumberValue:
+		var number json.Number
+		iter.ReadVal(&number)
+		num, err := number.Int64()
+		if err != nil {
+			iter.ReportError("fuzzyBoolDecoder", "get value from json.number failed")
+		}
+		if num == 0 {
+			*((*bool)(ptr)) = false
+		} else {
+			*((*bool)(ptr)) = true
+		}
+	case jsoniter.StringValue:
+		strValue := strings.ToLower(iter.ReadString())
+		if strValue == "true" {
+			*((*bool)(ptr)) = true
+		} else if strValue == "false" || strValue == "" {
+			*((*bool)(ptr)) = false
+		} else {
+			iter.ReportError("fuzzyBoolDecoder", "unsupported bool value: "+strValue)
+		}
+	case jsoniter.NilValue:
+		iter.ReadNil()
+		*((*bool)(ptr)) = false
+	default:
+		iter.ReportError("fuzzyBoolDecoder", "not number or string or nil")
+	}
+}
+
+type tolerateEmptyArrayDecoder struct {
+	valDecoder jsoniter.ValDecoder
+}
+
+func (decoder *tolerateEmptyArrayDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	if iter.WhatIsNext() == jsoniter.ArrayValue {
+		iter.Skip()
+		newIter := iter.Pool().BorrowIterator([]byte("{}"))
+		defer iter.Pool().ReturnIterator(newIter)
+		decoder.valDecoder.Decode(ptr, newIter)
+	} else {
+		decoder.valDecoder.Decode(ptr, iter)
+	}
+}
+
+type nullableFuzzyIntegerDecoder struct {
+	fun func(isFloat bool, ptr unsafe.Pointer, iter *jsoniter.Iterator)
+}
+
+func (decoder *nullableFuzzyIntegerDecoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	valueType := iter.WhatIsNext()
+	var str string
+	switch valueType {
+	case jsoniter.NumberValue:
+		var number json.Number
+		iter.ReadVal(&number)
+		str = string(number)
+	case jsoniter.StringValue:
+		str = iter.ReadString()
+		// support empty string
+		if str == "" {
+			str = "0"
+		}
+	case jsoniter.BoolValue:
+		if iter.ReadBool() {
+			str = "1"
+		} else {
+			str = "0"
+		}
+	case jsoniter.NilValue:
+		iter.ReadNil()
+		str = "0"
+	default:
+		iter.ReportError("fuzzyIntegerDecoder", "not number or string")
+	}
+	newIter := iter.Pool().BorrowIterator([]byte(str))
+	defer iter.Pool().ReturnIterator(newIter)
+	isFloat := strings.IndexByte(str, '.') != -1
+	decoder.fun(isFloat, ptr, newIter)
+	if newIter.Error != nil && newIter.Error != io.EOF {
+		iter.Error = newIter.Error
+	}
+}
+
+type nullableFuzzyFloat32Decoder struct {
+}
+
+func (decoder *nullableFuzzyFloat32Decoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	valueType := iter.WhatIsNext()
+	var str string
+	switch valueType {
+	case jsoniter.NumberValue:
+		*((*float32)(ptr)) = iter.ReadFloat32()
+	case jsoniter.StringValue:
+		str = iter.ReadString()
+		// support empty string
+		if str == "" {
+			*((*float32)(ptr)) = 0
+			return
+		}
+		newIter := iter.Pool().BorrowIterator([]byte(str))
+		defer iter.Pool().ReturnIterator(newIter)
+		*((*float32)(ptr)) = newIter.ReadFloat32()
+		if newIter.Error != nil && newIter.Error != io.EOF {
+			iter.Error = newIter.Error
+		}
+	case jsoniter.BoolValue:
+		// support bool to float32
+		if iter.ReadBool() {
+			*((*float32)(ptr)) = 1
+		} else {
+			*((*float32)(ptr)) = 0
+		}
+	case jsoniter.NilValue:
+		iter.ReadNil()
+		*((*float32)(ptr)) = 0
+	default:
+		iter.ReportError("nullableFuzzyFloat32Decoder", "not number or string")
+	}
+}
+
+type nullableFuzzyFloat64Decoder struct {
+}
+
+func (decoder *nullableFuzzyFloat64Decoder) Decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
+	valueType := iter.WhatIsNext()
+	var str string
+	switch valueType {
+	case jsoniter.NumberValue:
+		*((*float64)(ptr)) = iter.ReadFloat64()
+	case jsoniter.StringValue:
+		str = iter.ReadString()
+		// support empty string
+		if str == "" {
+			*((*float64)(ptr)) = 0
+			return
+		}
+		newIter := iter.Pool().BorrowIterator([]byte(str))
+		defer iter.Pool().ReturnIterator(newIter)
+		*((*float64)(ptr)) = newIter.ReadFloat64()
+		if newIter.Error != nil && newIter.Error != io.EOF {
+			iter.Error = newIter.Error
+		}
+	case jsoniter.BoolValue:
+		// support bool to float64
+		if iter.ReadBool() {
+			*((*float64)(ptr)) = 1
+		} else {
+			*((*float64)(ptr)) = 0
+		}
+	case jsoniter.NilValue:
+		// support empty string
+		iter.ReadNil()
+		*((*float64)(ptr)) = 0
+	default:
+		iter.ReportError("nullableFuzzyFloat32Decoder", "not number or string")
+	}
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses/response.go

@@ -0,0 +1,142 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package responses
+
+import (
+	"bytes"
+	"encoding/xml"
+	"fmt"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors"
+	"io/ioutil"
+	"net/http"
+	"strings"
+)
+
+type AcsResponse interface {
+	IsSuccess() bool
+	GetHttpStatus() int
+	GetHttpHeaders() map[string][]string
+	GetHttpContentString() string
+	GetHttpContentBytes() []byte
+	GetOriginHttpResponse() *http.Response
+	parseFromHttpResponse(httpResponse *http.Response) error
+}
+
+func Unmarshal(response AcsResponse, httpResponse *http.Response, format string) (err error) {
+	err = response.parseFromHttpResponse(httpResponse)
+	if err != nil {
+		return
+	}
+	if !response.IsSuccess() {
+		err = errors.NewServerError(response.GetHttpStatus(), response.GetHttpContentString(), "")
+		return
+	}
+	if _, isCommonResponse := response.(CommonResponse); isCommonResponse {
+		// common response need not unmarshal
+		return
+	}
+
+	if len(response.GetHttpContentBytes()) == 0 {
+		return
+	}
+
+	if strings.ToUpper(format) == "JSON" {
+		initJsonParserOnce()
+		err = jsonParser.Unmarshal(response.GetHttpContentBytes(), response)
+		if err != nil {
+			err = errors.NewClientError(errors.JsonUnmarshalErrorCode, errors.JsonUnmarshalErrorMessage, err)
+		}
+	} else if strings.ToUpper(format) == "XML" {
+		err = xml.Unmarshal(response.GetHttpContentBytes(), response)
+	}
+	return
+}
+
+type BaseResponse struct {
+	httpStatus         int
+	httpHeaders        map[string][]string
+	httpContentString  string
+	httpContentBytes   []byte
+	originHttpResponse *http.Response
+}
+
+func (baseResponse *BaseResponse) GetHttpStatus() int {
+	return baseResponse.httpStatus
+}
+
+func (baseResponse *BaseResponse) GetHttpHeaders() map[string][]string {
+	return baseResponse.httpHeaders
+}
+
+func (baseResponse *BaseResponse) GetHttpContentString() string {
+	return baseResponse.httpContentString
+}
+
+func (baseResponse *BaseResponse) GetHttpContentBytes() []byte {
+	return baseResponse.httpContentBytes
+}
+
+func (baseResponse *BaseResponse) GetOriginHttpResponse() *http.Response {
+	return baseResponse.originHttpResponse
+}
+
+func (baseResponse *BaseResponse) IsSuccess() bool {
+	if baseResponse.GetHttpStatus() >= 200 && baseResponse.GetHttpStatus() < 300 {
+		return true
+	}
+
+	return false
+}
+
+func (baseResponse *BaseResponse) parseFromHttpResponse(httpResponse *http.Response) (err error) {
+	defer httpResponse.Body.Close()
+	body, err := ioutil.ReadAll(httpResponse.Body)
+	if err != nil {
+		return
+	}
+	baseResponse.httpStatus = httpResponse.StatusCode
+	baseResponse.httpHeaders = httpResponse.Header
+	baseResponse.httpContentBytes = body
+	baseResponse.httpContentString = string(body)
+	baseResponse.originHttpResponse = httpResponse
+	return
+}
+
+func (baseResponse *BaseResponse) String() string {
+	resultBuilder := bytes.Buffer{}
+	// statusCode
+	resultBuilder.WriteString("\n")
+	resultBuilder.WriteString(fmt.Sprintf("%s %s\n", baseResponse.originHttpResponse.Proto, baseResponse.originHttpResponse.Status))
+	// httpHeaders
+	//resultBuilder.WriteString("Headers:\n")
+	for key, value := range baseResponse.httpHeaders {
+		resultBuilder.WriteString(key + ": " + strings.Join(value, ";") + "\n")
+	}
+	resultBuilder.WriteString("\n")
+	// content
+	//resultBuilder.WriteString("Content:\n")
+	resultBuilder.WriteString(baseResponse.httpContentString + "\n")
+	return resultBuilder.String()
+}
+
+type CommonResponse struct {
+	*BaseResponse
+}
+
+func NewCommonResponse() (response *CommonResponse) {
+	return &CommonResponse{
+		BaseResponse: &BaseResponse{},
+	}
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils/utils.go

@@ -0,0 +1,117 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package utils
+
+import (
+	"crypto/md5"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"github.com/satori/go.uuid"
+	"net/url"
+	"reflect"
+	"strconv"
+	"time"
+)
+
+// if you use go 1.10 or higher, you can hack this util by these to avoid "TimeZone.zip not found" on Windows
+var LoadLocationFromTZData func(name string, data []byte) (*time.Location, error) = nil
+var TZData []byte = nil
+
+func GetUUIDV4() (uuidHex string) {
+	uuidV4 := uuid.NewV4()
+	uuidHex = hex.EncodeToString(uuidV4.Bytes())
+	return
+}
+
+func GetMD5Base64(bytes []byte) (base64Value string) {
+	md5Ctx := md5.New()
+	md5Ctx.Write(bytes)
+	md5Value := md5Ctx.Sum(nil)
+	base64Value = base64.StdEncoding.EncodeToString(md5Value)
+	return
+}
+
+func GetGMTLocation() (*time.Location, error) {
+	if LoadLocationFromTZData != nil && TZData != nil {
+		return LoadLocationFromTZData("GMT", TZData)
+	} else {
+		return time.LoadLocation("GMT")
+	}
+}
+
+func GetTimeInFormatISO8601() (timeStr string) {
+	gmt, err := GetGMTLocation()
+
+	if err != nil {
+		panic(err)
+	}
+	return time.Now().In(gmt).Format("2006-01-02T15:04:05Z")
+}
+
+func GetTimeInFormatRFC2616() (timeStr string) {
+	gmt, err := GetGMTLocation()
+
+	if err != nil {
+		panic(err)
+	}
+	return time.Now().In(gmt).Format("Mon, 02 Jan 2006 15:04:05 GMT")
+}
+
+func GetUrlFormedMap(source map[string]string) (urlEncoded string) {
+	urlEncoder := url.Values{}
+	for key, value := range source {
+		urlEncoder.Add(key, value)
+	}
+	urlEncoded = urlEncoder.Encode()
+	return
+}
+
+func GetFromJsonString(jsonString, key string) (result string, err error) {
+	var responseMap map[string]*json.RawMessage
+	err = json.Unmarshal([]byte(jsonString), &responseMap)
+	if err != nil {
+		return
+	}
+	fmt.Println(string(*responseMap[key]))
+	err = json.Unmarshal(*responseMap[key], &result)
+	return
+}
+
+func InitStructWithDefaultTag(bean interface{}) {
+	configType := reflect.TypeOf(bean)
+	for i := 0; i < configType.Elem().NumField(); i++ {
+		field := configType.Elem().Field(i)
+		defaultValue := field.Tag.Get("default")
+		if defaultValue == "" {
+			continue
+		}
+		setter := reflect.ValueOf(bean).Elem().Field(i)
+		switch field.Type.String() {
+		case "int":
+			intValue, _ := strconv.ParseInt(defaultValue, 10, 64)
+			setter.SetInt(intValue)
+		case "time.Duration":
+			intValue, _ := strconv.ParseInt(defaultValue, 10, 64)
+			setter.SetInt(intValue)
+		case "string":
+			setter.SetString(defaultValue)
+		case "bool":
+			boolValue, _ := strconv.ParseBool(defaultValue)
+			setter.SetBool(boolValue)
+		}
+	}
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/add_batch_domain_records.go

@@ -0,0 +1,106 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// AddBatchDomainRecords invokes the alidns.AddBatchDomainRecords API synchronously
+// api document: https://help.aliyun.com/api/alidns/addbatchdomainrecords.html
+func (client *Client) AddBatchDomainRecords(request *AddBatchDomainRecordsRequest) (response *AddBatchDomainRecordsResponse, err error) {
+	response = CreateAddBatchDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// AddBatchDomainRecordsWithChan invokes the alidns.AddBatchDomainRecords API asynchronously
+// api document: https://help.aliyun.com/api/alidns/addbatchdomainrecords.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) AddBatchDomainRecordsWithChan(request *AddBatchDomainRecordsRequest) (<-chan *AddBatchDomainRecordsResponse, <-chan error) {
+	responseChan := make(chan *AddBatchDomainRecordsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.AddBatchDomainRecords(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// AddBatchDomainRecordsWithCallback invokes the alidns.AddBatchDomainRecords API asynchronously
+// api document: https://help.aliyun.com/api/alidns/addbatchdomainrecords.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) AddBatchDomainRecordsWithCallback(request *AddBatchDomainRecordsRequest, callback func(response *AddBatchDomainRecordsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *AddBatchDomainRecordsResponse
+		var err error
+		defer close(result)
+		response, err = client.AddBatchDomainRecords(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// AddBatchDomainRecordsRequest is the request struct for api AddBatchDomainRecords
+type AddBatchDomainRecordsRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Records      string `position:"Query" name:"Records"`
+}
+
+// AddBatchDomainRecordsResponse is the response struct for api AddBatchDomainRecords
+type AddBatchDomainRecordsResponse struct {
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	TraceId   string `json:"TraceId" xml:"TraceId"`
+}
+
+// CreateAddBatchDomainRecordsRequest creates a request to invoke AddBatchDomainRecords API
+func CreateAddBatchDomainRecordsRequest() (request *AddBatchDomainRecordsRequest) {
+	request = &AddBatchDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "AddBatchDomainRecords", "", "")
+	return
+}
+
+// CreateAddBatchDomainRecordsResponse creates a response to parse from AddBatchDomainRecords response
+func CreateAddBatchDomainRecordsResponse() (response *AddBatchDomainRecordsResponse) {
+	response = &AddBatchDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/add_domain.go

@@ -0,0 +1,112 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// AddDomain invokes the alidns.AddDomain API synchronously
+// api document: https://help.aliyun.com/api/alidns/adddomain.html
+func (client *Client) AddDomain(request *AddDomainRequest) (response *AddDomainResponse, err error) {
+	response = CreateAddDomainResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// AddDomainWithChan invokes the alidns.AddDomain API asynchronously
+// api document: https://help.aliyun.com/api/alidns/adddomain.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) AddDomainWithChan(request *AddDomainRequest) (<-chan *AddDomainResponse, <-chan error) {
+	responseChan := make(chan *AddDomainResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.AddDomain(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// AddDomainWithCallback invokes the alidns.AddDomain API asynchronously
+// api document: https://help.aliyun.com/api/alidns/adddomain.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) AddDomainWithCallback(request *AddDomainRequest, callback func(response *AddDomainResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *AddDomainResponse
+		var err error
+		defer close(result)
+		response, err = client.AddDomain(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// AddDomainRequest is the request struct for api AddDomain
+type AddDomainRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	DomainName   string `position:"Query" name:"DomainName"`
+	GroupId      string `position:"Query" name:"GroupId"`
+}
+
+// AddDomainResponse is the response struct for api AddDomain
+type AddDomainResponse struct {
+	*responses.BaseResponse
+	RequestId  string                `json:"RequestId" xml:"RequestId"`
+	DomainId   string                `json:"DomainId" xml:"DomainId"`
+	DomainName string                `json:"DomainName" xml:"DomainName"`
+	PunyCode   string                `json:"PunyCode" xml:"PunyCode"`
+	GroupId    string                `json:"GroupId" xml:"GroupId"`
+	GroupName  string                `json:"GroupName" xml:"GroupName"`
+	DnsServers DnsServersInAddDomain `json:"DnsServers" xml:"DnsServers"`
+}
+
+// CreateAddDomainRequest creates a request to invoke AddDomain API
+func CreateAddDomainRequest() (request *AddDomainRequest) {
+	request = &AddDomainRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomain", "", "")
+	return
+}
+
+// CreateAddDomainResponse creates a response to parse from AddDomain response
+func CreateAddDomainResponse() (response *AddDomainResponse) {
+	response = &AddDomainResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/add_domain_group.go

@@ -0,0 +1,107 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// AddDomainGroup invokes the alidns.AddDomainGroup API synchronously
+// api document: https://help.aliyun.com/api/alidns/adddomaingroup.html
+func (client *Client) AddDomainGroup(request *AddDomainGroupRequest) (response *AddDomainGroupResponse, err error) {
+	response = CreateAddDomainGroupResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// AddDomainGroupWithChan invokes the alidns.AddDomainGroup API asynchronously
+// api document: https://help.aliyun.com/api/alidns/adddomaingroup.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) AddDomainGroupWithChan(request *AddDomainGroupRequest) (<-chan *AddDomainGroupResponse, <-chan error) {
+	responseChan := make(chan *AddDomainGroupResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.AddDomainGroup(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// AddDomainGroupWithCallback invokes the alidns.AddDomainGroup API asynchronously
+// api document: https://help.aliyun.com/api/alidns/adddomaingroup.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) AddDomainGroupWithCallback(request *AddDomainGroupRequest, callback func(response *AddDomainGroupResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *AddDomainGroupResponse
+		var err error
+		defer close(result)
+		response, err = client.AddDomainGroup(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// AddDomainGroupRequest is the request struct for api AddDomainGroup
+type AddDomainGroupRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	GroupName    string `position:"Query" name:"GroupName"`
+}
+
+// AddDomainGroupResponse is the response struct for api AddDomainGroup
+type AddDomainGroupResponse struct {
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	GroupId   string `json:"GroupId" xml:"GroupId"`
+	GroupName string `json:"GroupName" xml:"GroupName"`
+}
+
+// CreateAddDomainGroupRequest creates a request to invoke AddDomainGroup API
+func CreateAddDomainGroupRequest() (request *AddDomainGroupRequest) {
+	request = &AddDomainGroupRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomainGroup", "", "")
+	return
+}
+
+// CreateAddDomainGroupResponse creates a response to parse from AddDomainGroup response
+func CreateAddDomainGroupResponse() (response *AddDomainGroupResponse) {
+	response = &AddDomainGroupResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/add_domain_record.go

@@ -0,0 +1,112 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// AddDomainRecord invokes the alidns.AddDomainRecord API synchronously
+// api document: https://help.aliyun.com/api/alidns/adddomainrecord.html
+func (client *Client) AddDomainRecord(request *AddDomainRecordRequest) (response *AddDomainRecordResponse, err error) {
+	response = CreateAddDomainRecordResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// AddDomainRecordWithChan invokes the alidns.AddDomainRecord API asynchronously
+// api document: https://help.aliyun.com/api/alidns/adddomainrecord.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) AddDomainRecordWithChan(request *AddDomainRecordRequest) (<-chan *AddDomainRecordResponse, <-chan error) {
+	responseChan := make(chan *AddDomainRecordResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.AddDomainRecord(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// AddDomainRecordWithCallback invokes the alidns.AddDomainRecord API asynchronously
+// api document: https://help.aliyun.com/api/alidns/adddomainrecord.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) AddDomainRecordWithCallback(request *AddDomainRecordRequest, callback func(response *AddDomainRecordResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *AddDomainRecordResponse
+		var err error
+		defer close(result)
+		response, err = client.AddDomainRecord(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// AddDomainRecordRequest is the request struct for api AddDomainRecord
+type AddDomainRecordRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	DomainName   string           `position:"Query" name:"DomainName"`
+	RR           string           `position:"Query" name:"RR"`
+	Type         string           `position:"Query" name:"Type"`
+	Value        string           `position:"Query" name:"Value"`
+	TTL          requests.Integer `position:"Query" name:"TTL"`
+	Priority     requests.Integer `position:"Query" name:"Priority"`
+	Line         string           `position:"Query" name:"Line"`
+}
+
+// AddDomainRecordResponse is the response struct for api AddDomainRecord
+type AddDomainRecordResponse struct {
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	RecordId  string `json:"RecordId" xml:"RecordId"`
+}
+
+// CreateAddDomainRecordRequest creates a request to invoke AddDomainRecord API
+func CreateAddDomainRecordRequest() (request *AddDomainRecordRequest) {
+	request = &AddDomainRecordRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomainRecord", "", "")
+	return
+}
+
+// CreateAddDomainRecordResponse creates a response to parse from AddDomainRecord response
+func CreateAddDomainRecordResponse() (response *AddDomainRecordResponse) {
+	response = &AddDomainRecordResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/apply_for_retrieval_domain_name.go

@@ -0,0 +1,106 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// ApplyForRetrievalDomainName invokes the alidns.ApplyForRetrievalDomainName API synchronously
+// api document: https://help.aliyun.com/api/alidns/applyforretrievaldomainname.html
+func (client *Client) ApplyForRetrievalDomainName(request *ApplyForRetrievalDomainNameRequest) (response *ApplyForRetrievalDomainNameResponse, err error) {
+	response = CreateApplyForRetrievalDomainNameResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// ApplyForRetrievalDomainNameWithChan invokes the alidns.ApplyForRetrievalDomainName API asynchronously
+// api document: https://help.aliyun.com/api/alidns/applyforretrievaldomainname.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ApplyForRetrievalDomainNameWithChan(request *ApplyForRetrievalDomainNameRequest) (<-chan *ApplyForRetrievalDomainNameResponse, <-chan error) {
+	responseChan := make(chan *ApplyForRetrievalDomainNameResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.ApplyForRetrievalDomainName(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// ApplyForRetrievalDomainNameWithCallback invokes the alidns.ApplyForRetrievalDomainName API asynchronously
+// api document: https://help.aliyun.com/api/alidns/applyforretrievaldomainname.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ApplyForRetrievalDomainNameWithCallback(request *ApplyForRetrievalDomainNameRequest, callback func(response *ApplyForRetrievalDomainNameResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *ApplyForRetrievalDomainNameResponse
+		var err error
+		defer close(result)
+		response, err = client.ApplyForRetrievalDomainName(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// ApplyForRetrievalDomainNameRequest is the request struct for api ApplyForRetrievalDomainName
+type ApplyForRetrievalDomainNameRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	DomainName   string `position:"Query" name:"DomainName"`
+}
+
+// ApplyForRetrievalDomainNameResponse is the response struct for api ApplyForRetrievalDomainName
+type ApplyForRetrievalDomainNameResponse struct {
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	DomainName string `json:"DomainName" xml:"DomainName"`
+}
+
+// CreateApplyForRetrievalDomainNameRequest creates a request to invoke ApplyForRetrievalDomainName API
+func CreateApplyForRetrievalDomainNameRequest() (request *ApplyForRetrievalDomainNameRequest) {
+	request = &ApplyForRetrievalDomainNameRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "ApplyForRetrievalDomainName", "", "")
+	return
+}
+
+// CreateApplyForRetrievalDomainNameResponse creates a response to parse from ApplyForRetrievalDomainName response
+func CreateApplyForRetrievalDomainNameResponse() (response *ApplyForRetrievalDomainNameResponse) {
+	response = &ApplyForRetrievalDomainNameResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/change_domain_group.go

@@ -0,0 +1,108 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// ChangeDomainGroup invokes the alidns.ChangeDomainGroup API synchronously
+// api document: https://help.aliyun.com/api/alidns/changedomaingroup.html
+func (client *Client) ChangeDomainGroup(request *ChangeDomainGroupRequest) (response *ChangeDomainGroupResponse, err error) {
+	response = CreateChangeDomainGroupResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// ChangeDomainGroupWithChan invokes the alidns.ChangeDomainGroup API asynchronously
+// api document: https://help.aliyun.com/api/alidns/changedomaingroup.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ChangeDomainGroupWithChan(request *ChangeDomainGroupRequest) (<-chan *ChangeDomainGroupResponse, <-chan error) {
+	responseChan := make(chan *ChangeDomainGroupResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.ChangeDomainGroup(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// ChangeDomainGroupWithCallback invokes the alidns.ChangeDomainGroup API asynchronously
+// api document: https://help.aliyun.com/api/alidns/changedomaingroup.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ChangeDomainGroupWithCallback(request *ChangeDomainGroupRequest, callback func(response *ChangeDomainGroupResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *ChangeDomainGroupResponse
+		var err error
+		defer close(result)
+		response, err = client.ChangeDomainGroup(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// ChangeDomainGroupRequest is the request struct for api ChangeDomainGroup
+type ChangeDomainGroupRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	DomainName   string `position:"Query" name:"DomainName"`
+	GroupId      string `position:"Query" name:"GroupId"`
+}
+
+// ChangeDomainGroupResponse is the response struct for api ChangeDomainGroup
+type ChangeDomainGroupResponse struct {
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	GroupId   string `json:"GroupId" xml:"GroupId"`
+	GroupName string `json:"GroupName" xml:"GroupName"`
+}
+
+// CreateChangeDomainGroupRequest creates a request to invoke ChangeDomainGroup API
+func CreateChangeDomainGroupRequest() (request *ChangeDomainGroupRequest) {
+	request = &ChangeDomainGroupRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "ChangeDomainGroup", "", "")
+	return
+}
+
+// CreateChangeDomainGroupResponse creates a response to parse from ChangeDomainGroup response
+func CreateChangeDomainGroupResponse() (response *ChangeDomainGroupResponse) {
+	response = &ChangeDomainGroupResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/change_domain_of_dns_product.go

@@ -0,0 +1,108 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// ChangeDomainOfDnsProduct invokes the alidns.ChangeDomainOfDnsProduct API synchronously
+// api document: https://help.aliyun.com/api/alidns/changedomainofdnsproduct.html
+func (client *Client) ChangeDomainOfDnsProduct(request *ChangeDomainOfDnsProductRequest) (response *ChangeDomainOfDnsProductResponse, err error) {
+	response = CreateChangeDomainOfDnsProductResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// ChangeDomainOfDnsProductWithChan invokes the alidns.ChangeDomainOfDnsProduct API asynchronously
+// api document: https://help.aliyun.com/api/alidns/changedomainofdnsproduct.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ChangeDomainOfDnsProductWithChan(request *ChangeDomainOfDnsProductRequest) (<-chan *ChangeDomainOfDnsProductResponse, <-chan error) {
+	responseChan := make(chan *ChangeDomainOfDnsProductResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.ChangeDomainOfDnsProduct(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// ChangeDomainOfDnsProductWithCallback invokes the alidns.ChangeDomainOfDnsProduct API asynchronously
+// api document: https://help.aliyun.com/api/alidns/changedomainofdnsproduct.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ChangeDomainOfDnsProductWithCallback(request *ChangeDomainOfDnsProductRequest, callback func(response *ChangeDomainOfDnsProductResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *ChangeDomainOfDnsProductResponse
+		var err error
+		defer close(result)
+		response, err = client.ChangeDomainOfDnsProduct(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// ChangeDomainOfDnsProductRequest is the request struct for api ChangeDomainOfDnsProduct
+type ChangeDomainOfDnsProductRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	InstanceId   string           `position:"Query" name:"InstanceId"`
+	NewDomain    string           `position:"Query" name:"NewDomain"`
+	Force        requests.Boolean `position:"Query" name:"Force"`
+}
+
+// ChangeDomainOfDnsProductResponse is the response struct for api ChangeDomainOfDnsProduct
+type ChangeDomainOfDnsProductResponse struct {
+	*responses.BaseResponse
+	RequestId      string `json:"RequestId" xml:"RequestId"`
+	OriginalDomain string `json:"OriginalDomain" xml:"OriginalDomain"`
+}
+
+// CreateChangeDomainOfDnsProductRequest creates a request to invoke ChangeDomainOfDnsProduct API
+func CreateChangeDomainOfDnsProductRequest() (request *ChangeDomainOfDnsProductRequest) {
+	request = &ChangeDomainOfDnsProductRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "ChangeDomainOfDnsProduct", "", "")
+	return
+}
+
+// CreateChangeDomainOfDnsProductResponse creates a response to parse from ChangeDomainOfDnsProduct response
+func CreateChangeDomainOfDnsProductResponse() (response *ChangeDomainOfDnsProductResponse) {
+	response = &ChangeDomainOfDnsProductResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/check_domain_record.go

@@ -0,0 +1,109 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// CheckDomainRecord invokes the alidns.CheckDomainRecord API synchronously
+// api document: https://help.aliyun.com/api/alidns/checkdomainrecord.html
+func (client *Client) CheckDomainRecord(request *CheckDomainRecordRequest) (response *CheckDomainRecordResponse, err error) {
+	response = CreateCheckDomainRecordResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// CheckDomainRecordWithChan invokes the alidns.CheckDomainRecord API asynchronously
+// api document: https://help.aliyun.com/api/alidns/checkdomainrecord.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CheckDomainRecordWithChan(request *CheckDomainRecordRequest) (<-chan *CheckDomainRecordResponse, <-chan error) {
+	responseChan := make(chan *CheckDomainRecordResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.CheckDomainRecord(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// CheckDomainRecordWithCallback invokes the alidns.CheckDomainRecord API asynchronously
+// api document: https://help.aliyun.com/api/alidns/checkdomainrecord.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) CheckDomainRecordWithCallback(request *CheckDomainRecordRequest, callback func(response *CheckDomainRecordResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *CheckDomainRecordResponse
+		var err error
+		defer close(result)
+		response, err = client.CheckDomainRecord(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// CheckDomainRecordRequest is the request struct for api CheckDomainRecord
+type CheckDomainRecordRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	DomainName   string `position:"Query" name:"DomainName"`
+	RR           string `position:"Query" name:"RR"`
+	Type         string `position:"Query" name:"Type"`
+	Value        string `position:"Query" name:"Value"`
+}
+
+// CheckDomainRecordResponse is the response struct for api CheckDomainRecord
+type CheckDomainRecordResponse struct {
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	IsExist   bool   `json:"IsExist" xml:"IsExist"`
+}
+
+// CreateCheckDomainRecordRequest creates a request to invoke CheckDomainRecord API
+func CreateCheckDomainRecordRequest() (request *CheckDomainRecordRequest) {
+	request = &CheckDomainRecordRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "CheckDomainRecord", "", "")
+	return
+}
+
+// CreateCheckDomainRecordResponse creates a response to parse from CheckDomainRecord response
+func CreateCheckDomainRecordResponse() (response *CheckDomainRecordResponse) {
+	response = &CheckDomainRecordResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/client.go

@@ -0,0 +1,81 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
+)
+
+// Client is the sdk client struct, each func corresponds to an OpenAPI
+type Client struct {
+	sdk.Client
+}
+
+// NewClient creates a sdk client with environment variables
+func NewClient() (client *Client, err error) {
+	client = &Client{}
+	err = client.Init()
+	return
+}
+
+// NewClientWithOptions creates a sdk client with regionId/sdkConfig/credential
+// this is the common api to create a sdk client
+func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithOptions(regionId, config, credential)
+	return
+}
+
+// NewClientWithAccessKey is a shortcut to create sdk client with accesskey
+// usage: https://help.aliyun.com/document_detail/66217.html
+func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
+	return
+}
+
+// NewClientWithStsToken is a shortcut to create sdk client with sts token
+// usage: https://help.aliyun.com/document_detail/66222.html
+func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken)
+	return
+}
+
+// NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn
+// usage: https://help.aliyun.com/document_detail/66222.html
+func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithRamRoleArn(regionId, accessKeyId, accessKeySecret, roleArn, roleSessionName)
+	return
+}
+
+// NewClientWithEcsRamRole is a shortcut to create sdk client with ecs ram role
+// usage: https://help.aliyun.com/document_detail/66223.html
+func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithEcsRamRole(regionId, roleName)
+	return
+}
+
+// NewClientWithRsaKeyPair is a shortcut to create sdk client with rsa key pair
+// attention: rsa key pair auth is only Japan regions available
+func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error) {
+	client = &Client{}
+	err = client.InitWithRsaKeyPair(regionId, publicKeyId, privateKey, sessionExpiration)
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/delete_batch_domain_records.go

@@ -0,0 +1,106 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DeleteBatchDomainRecords invokes the alidns.DeleteBatchDomainRecords API synchronously
+// api document: https://help.aliyun.com/api/alidns/deletebatchdomainrecords.html
+func (client *Client) DeleteBatchDomainRecords(request *DeleteBatchDomainRecordsRequest) (response *DeleteBatchDomainRecordsResponse, err error) {
+	response = CreateDeleteBatchDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DeleteBatchDomainRecordsWithChan invokes the alidns.DeleteBatchDomainRecords API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletebatchdomainrecords.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteBatchDomainRecordsWithChan(request *DeleteBatchDomainRecordsRequest) (<-chan *DeleteBatchDomainRecordsResponse, <-chan error) {
+	responseChan := make(chan *DeleteBatchDomainRecordsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteBatchDomainRecords(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DeleteBatchDomainRecordsWithCallback invokes the alidns.DeleteBatchDomainRecords API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletebatchdomainrecords.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteBatchDomainRecordsWithCallback(request *DeleteBatchDomainRecordsRequest, callback func(response *DeleteBatchDomainRecordsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteBatchDomainRecordsResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteBatchDomainRecords(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DeleteBatchDomainRecordsRequest is the request struct for api DeleteBatchDomainRecords
+type DeleteBatchDomainRecordsRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Records      string `position:"Query" name:"Records"`
+}
+
+// DeleteBatchDomainRecordsResponse is the response struct for api DeleteBatchDomainRecords
+type DeleteBatchDomainRecordsResponse struct {
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	TraceId   string `json:"TraceId" xml:"TraceId"`
+}
+
+// CreateDeleteBatchDomainRecordsRequest creates a request to invoke DeleteBatchDomainRecords API
+func CreateDeleteBatchDomainRecordsRequest() (request *DeleteBatchDomainRecordsRequest) {
+	request = &DeleteBatchDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteBatchDomainRecords", "", "")
+	return
+}
+
+// CreateDeleteBatchDomainRecordsResponse creates a response to parse from DeleteBatchDomainRecords response
+func CreateDeleteBatchDomainRecordsResponse() (response *DeleteBatchDomainRecordsResponse) {
+	response = &DeleteBatchDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/delete_batch_domains.go

@@ -0,0 +1,106 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DeleteBatchDomains invokes the alidns.DeleteBatchDomains API synchronously
+// api document: https://help.aliyun.com/api/alidns/deletebatchdomains.html
+func (client *Client) DeleteBatchDomains(request *DeleteBatchDomainsRequest) (response *DeleteBatchDomainsResponse, err error) {
+	response = CreateDeleteBatchDomainsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DeleteBatchDomainsWithChan invokes the alidns.DeleteBatchDomains API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletebatchdomains.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteBatchDomainsWithChan(request *DeleteBatchDomainsRequest) (<-chan *DeleteBatchDomainsResponse, <-chan error) {
+	responseChan := make(chan *DeleteBatchDomainsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteBatchDomains(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DeleteBatchDomainsWithCallback invokes the alidns.DeleteBatchDomains API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletebatchdomains.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteBatchDomainsWithCallback(request *DeleteBatchDomainsRequest, callback func(response *DeleteBatchDomainsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteBatchDomainsResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteBatchDomains(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DeleteBatchDomainsRequest is the request struct for api DeleteBatchDomains
+type DeleteBatchDomainsRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Domains      string `position:"Query" name:"Domains"`
+}
+
+// DeleteBatchDomainsResponse is the response struct for api DeleteBatchDomains
+type DeleteBatchDomainsResponse struct {
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	TraceId   string `json:"TraceId" xml:"TraceId"`
+}
+
+// CreateDeleteBatchDomainsRequest creates a request to invoke DeleteBatchDomains API
+func CreateDeleteBatchDomainsRequest() (request *DeleteBatchDomainsRequest) {
+	request = &DeleteBatchDomainsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteBatchDomains", "", "")
+	return
+}
+
+// CreateDeleteBatchDomainsResponse creates a response to parse from DeleteBatchDomains response
+func CreateDeleteBatchDomainsResponse() (response *DeleteBatchDomainsResponse) {
+	response = &DeleteBatchDomainsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/delete_domain.go

@@ -0,0 +1,106 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DeleteDomain invokes the alidns.DeleteDomain API synchronously
+// api document: https://help.aliyun.com/api/alidns/deletedomain.html
+func (client *Client) DeleteDomain(request *DeleteDomainRequest) (response *DeleteDomainResponse, err error) {
+	response = CreateDeleteDomainResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DeleteDomainWithChan invokes the alidns.DeleteDomain API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletedomain.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteDomainWithChan(request *DeleteDomainRequest) (<-chan *DeleteDomainResponse, <-chan error) {
+	responseChan := make(chan *DeleteDomainResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteDomain(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DeleteDomainWithCallback invokes the alidns.DeleteDomain API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletedomain.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteDomainWithCallback(request *DeleteDomainRequest, callback func(response *DeleteDomainResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteDomainResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteDomain(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DeleteDomainRequest is the request struct for api DeleteDomain
+type DeleteDomainRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	DomainName   string `position:"Query" name:"DomainName"`
+}
+
+// DeleteDomainResponse is the response struct for api DeleteDomain
+type DeleteDomainResponse struct {
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	DomainName string `json:"DomainName" xml:"DomainName"`
+}
+
+// CreateDeleteDomainRequest creates a request to invoke DeleteDomain API
+func CreateDeleteDomainRequest() (request *DeleteDomainRequest) {
+	request = &DeleteDomainRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomain", "", "")
+	return
+}
+
+// CreateDeleteDomainResponse creates a response to parse from DeleteDomain response
+func CreateDeleteDomainResponse() (response *DeleteDomainResponse) {
+	response = &DeleteDomainResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/delete_domain_group.go

@@ -0,0 +1,106 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DeleteDomainGroup invokes the alidns.DeleteDomainGroup API synchronously
+// api document: https://help.aliyun.com/api/alidns/deletedomaingroup.html
+func (client *Client) DeleteDomainGroup(request *DeleteDomainGroupRequest) (response *DeleteDomainGroupResponse, err error) {
+	response = CreateDeleteDomainGroupResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DeleteDomainGroupWithChan invokes the alidns.DeleteDomainGroup API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletedomaingroup.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteDomainGroupWithChan(request *DeleteDomainGroupRequest) (<-chan *DeleteDomainGroupResponse, <-chan error) {
+	responseChan := make(chan *DeleteDomainGroupResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteDomainGroup(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DeleteDomainGroupWithCallback invokes the alidns.DeleteDomainGroup API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletedomaingroup.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteDomainGroupWithCallback(request *DeleteDomainGroupRequest, callback func(response *DeleteDomainGroupResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteDomainGroupResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteDomainGroup(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DeleteDomainGroupRequest is the request struct for api DeleteDomainGroup
+type DeleteDomainGroupRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	GroupId      string `position:"Query" name:"GroupId"`
+}
+
+// DeleteDomainGroupResponse is the response struct for api DeleteDomainGroup
+type DeleteDomainGroupResponse struct {
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	GroupName string `json:"GroupName" xml:"GroupName"`
+}
+
+// CreateDeleteDomainGroupRequest creates a request to invoke DeleteDomainGroup API
+func CreateDeleteDomainGroupRequest() (request *DeleteDomainGroupRequest) {
+	request = &DeleteDomainGroupRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomainGroup", "", "")
+	return
+}
+
+// CreateDeleteDomainGroupResponse creates a response to parse from DeleteDomainGroup response
+func CreateDeleteDomainGroupResponse() (response *DeleteDomainGroupResponse) {
+	response = &DeleteDomainGroupResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/delete_domain_record.go

@@ -0,0 +1,106 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DeleteDomainRecord invokes the alidns.DeleteDomainRecord API synchronously
+// api document: https://help.aliyun.com/api/alidns/deletedomainrecord.html
+func (client *Client) DeleteDomainRecord(request *DeleteDomainRecordRequest) (response *DeleteDomainRecordResponse, err error) {
+	response = CreateDeleteDomainRecordResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DeleteDomainRecordWithChan invokes the alidns.DeleteDomainRecord API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletedomainrecord.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteDomainRecordWithChan(request *DeleteDomainRecordRequest) (<-chan *DeleteDomainRecordResponse, <-chan error) {
+	responseChan := make(chan *DeleteDomainRecordResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteDomainRecord(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DeleteDomainRecordWithCallback invokes the alidns.DeleteDomainRecord API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletedomainrecord.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteDomainRecordWithCallback(request *DeleteDomainRecordRequest, callback func(response *DeleteDomainRecordResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteDomainRecordResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteDomainRecord(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DeleteDomainRecordRequest is the request struct for api DeleteDomainRecord
+type DeleteDomainRecordRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	RecordId     string `position:"Query" name:"RecordId"`
+}
+
+// DeleteDomainRecordResponse is the response struct for api DeleteDomainRecord
+type DeleteDomainRecordResponse struct {
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	RecordId  string `json:"RecordId" xml:"RecordId"`
+}
+
+// CreateDeleteDomainRecordRequest creates a request to invoke DeleteDomainRecord API
+func CreateDeleteDomainRecordRequest() (request *DeleteDomainRecordRequest) {
+	request = &DeleteDomainRecordRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomainRecord", "", "")
+	return
+}
+
+// CreateDeleteDomainRecordResponse creates a response to parse from DeleteDomainRecord response
+func CreateDeleteDomainRecordResponse() (response *DeleteDomainRecordResponse) {
+	response = &DeleteDomainRecordResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/delete_sub_domain_records.go

@@ -0,0 +1,109 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DeleteSubDomainRecords invokes the alidns.DeleteSubDomainRecords API synchronously
+// api document: https://help.aliyun.com/api/alidns/deletesubdomainrecords.html
+func (client *Client) DeleteSubDomainRecords(request *DeleteSubDomainRecordsRequest) (response *DeleteSubDomainRecordsResponse, err error) {
+	response = CreateDeleteSubDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DeleteSubDomainRecordsWithChan invokes the alidns.DeleteSubDomainRecords API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletesubdomainrecords.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteSubDomainRecordsWithChan(request *DeleteSubDomainRecordsRequest) (<-chan *DeleteSubDomainRecordsResponse, <-chan error) {
+	responseChan := make(chan *DeleteSubDomainRecordsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteSubDomainRecords(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DeleteSubDomainRecordsWithCallback invokes the alidns.DeleteSubDomainRecords API asynchronously
+// api document: https://help.aliyun.com/api/alidns/deletesubdomainrecords.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DeleteSubDomainRecordsWithCallback(request *DeleteSubDomainRecordsRequest, callback func(response *DeleteSubDomainRecordsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteSubDomainRecordsResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteSubDomainRecords(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DeleteSubDomainRecordsRequest is the request struct for api DeleteSubDomainRecords
+type DeleteSubDomainRecordsRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	DomainName   string `position:"Query" name:"DomainName"`
+	RR           string `position:"Query" name:"RR"`
+	Type         string `position:"Query" name:"Type"`
+}
+
+// DeleteSubDomainRecordsResponse is the response struct for api DeleteSubDomainRecords
+type DeleteSubDomainRecordsResponse struct {
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	RR         string `json:"RR" xml:"RR"`
+	TotalCount string `json:"TotalCount" xml:"TotalCount"`
+}
+
+// CreateDeleteSubDomainRecordsRequest creates a request to invoke DeleteSubDomainRecords API
+func CreateDeleteSubDomainRecordsRequest() (request *DeleteSubDomainRecordsRequest) {
+	request = &DeleteSubDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteSubDomainRecords", "", "")
+	return
+}
+
+// CreateDeleteSubDomainRecordsResponse creates a response to parse from DeleteSubDomainRecords response
+func CreateDeleteSubDomainRecordsResponse() (response *DeleteSubDomainRecordsResponse) {
+	response = &DeleteSubDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_batch_result.go

@@ -0,0 +1,110 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeBatchResult invokes the alidns.DescribeBatchResult API synchronously
+// api document: https://help.aliyun.com/api/alidns/describebatchresult.html
+func (client *Client) DescribeBatchResult(request *DescribeBatchResultRequest) (response *DescribeBatchResultResponse, err error) {
+	response = CreateDescribeBatchResultResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeBatchResultWithChan invokes the alidns.DescribeBatchResult API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describebatchresult.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeBatchResultWithChan(request *DescribeBatchResultRequest) (<-chan *DescribeBatchResultResponse, <-chan error) {
+	responseChan := make(chan *DescribeBatchResultResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeBatchResult(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeBatchResultWithCallback invokes the alidns.DescribeBatchResult API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describebatchresult.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeBatchResultWithCallback(request *DescribeBatchResultRequest, callback func(response *DescribeBatchResultResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeBatchResultResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeBatchResult(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeBatchResultRequest is the request struct for api DescribeBatchResult
+type DescribeBatchResultRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	TraceId      string `position:"Query" name:"TraceId"`
+}
+
+// DescribeBatchResultResponse is the response struct for api DescribeBatchResult
+type DescribeBatchResultResponse struct {
+	*responses.BaseResponse
+	RequestId     string      `json:"RequestId" xml:"RequestId"`
+	TraceId       string      `json:"TraceId" xml:"TraceId"`
+	Status        int         `json:"Status" xml:"Status"`
+	BatchCount    int         `json:"BatchCount" xml:"BatchCount"`
+	SuccessNumber int         `json:"SuccessNumber" xml:"SuccessNumber"`
+	FailResults   FailResults `json:"FailResults" xml:"FailResults"`
+}
+
+// CreateDescribeBatchResultRequest creates a request to invoke DescribeBatchResult API
+func CreateDescribeBatchResultRequest() (request *DescribeBatchResultRequest) {
+	request = &DescribeBatchResultRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeBatchResult", "", "")
+	return
+}
+
+// CreateDescribeBatchResultResponse creates a response to parse from DescribeBatchResult response
+func CreateDescribeBatchResultResponse() (response *DescribeBatchResultResponse) {
+	response = &DescribeBatchResultResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_dns_product_instance.go

@@ -0,0 +1,134 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDnsProductInstance invokes the alidns.DescribeDnsProductInstance API synchronously
+// api document: https://help.aliyun.com/api/alidns/describednsproductinstance.html
+func (client *Client) DescribeDnsProductInstance(request *DescribeDnsProductInstanceRequest) (response *DescribeDnsProductInstanceResponse, err error) {
+	response = CreateDescribeDnsProductInstanceResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDnsProductInstanceWithChan invokes the alidns.DescribeDnsProductInstance API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describednsproductinstance.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDnsProductInstanceWithChan(request *DescribeDnsProductInstanceRequest) (<-chan *DescribeDnsProductInstanceResponse, <-chan error) {
+	responseChan := make(chan *DescribeDnsProductInstanceResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDnsProductInstance(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDnsProductInstanceWithCallback invokes the alidns.DescribeDnsProductInstance API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describednsproductinstance.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDnsProductInstanceWithCallback(request *DescribeDnsProductInstanceRequest, callback func(response *DescribeDnsProductInstanceResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDnsProductInstanceResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDnsProductInstance(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDnsProductInstanceRequest is the request struct for api DescribeDnsProductInstance
+type DescribeDnsProductInstanceRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	InstanceId   string `position:"Query" name:"InstanceId"`
+}
+
+// DescribeDnsProductInstanceResponse is the response struct for api DescribeDnsProductInstance
+type DescribeDnsProductInstanceResponse struct {
+	*responses.BaseResponse
+	RequestId             string                                 `json:"RequestId" xml:"RequestId"`
+	InstanceId            string                                 `json:"InstanceId" xml:"InstanceId"`
+	VersionCode           string                                 `json:"VersionCode" xml:"VersionCode"`
+	VersionName           string                                 `json:"VersionName" xml:"VersionName"`
+	StartTime             string                                 `json:"StartTime" xml:"StartTime"`
+	StartTimestamp        int                                    `json:"StartTimestamp" xml:"StartTimestamp"`
+	EndTime               string                                 `json:"EndTime" xml:"EndTime"`
+	EndTimestamp          int                                    `json:"EndTimestamp" xml:"EndTimestamp"`
+	Domain                string                                 `json:"Domain" xml:"Domain"`
+	BindCount             int                                    `json:"BindCount" xml:"BindCount"`
+	BindUsedCount         int                                    `json:"BindUsedCount" xml:"BindUsedCount"`
+	TTLMinValue           int                                    `json:"TTLMinValue" xml:"TTLMinValue"`
+	SubDomainLevel        int                                    `json:"SubDomainLevel" xml:"SubDomainLevel"`
+	DnsSLBCount           int                                    `json:"DnsSLBCount" xml:"DnsSLBCount"`
+	URLForwardCount       int                                    `json:"URLForwardCount" xml:"URLForwardCount"`
+	DDosDefendFlow        int                                    `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
+	DDosDefendQuery       int                                    `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
+	OverseaDDosDefendFlow int                                    `json:"OverseaDDosDefendFlow" xml:"OverseaDDosDefendFlow"`
+	SearchEngineLines     string                                 `json:"SearchEngineLines" xml:"SearchEngineLines"`
+	ISPLines              string                                 `json:"ISPLines" xml:"ISPLines"`
+	ISPRegionLines        string                                 `json:"ISPRegionLines" xml:"ISPRegionLines"`
+	OverseaLine           string                                 `json:"OverseaLine" xml:"OverseaLine"`
+	MonitorNodeCount      int                                    `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
+	MonitorFrequency      int                                    `json:"MonitorFrequency" xml:"MonitorFrequency"`
+	MonitorTaskCount      int                                    `json:"MonitorTaskCount" xml:"MonitorTaskCount"`
+	RegionLines           bool                                   `json:"RegionLines" xml:"RegionLines"`
+	Gslb                  bool                                   `json:"Gslb" xml:"Gslb"`
+	InClean               bool                                   `json:"InClean" xml:"InClean"`
+	InBlackHole           bool                                   `json:"InBlackHole" xml:"InBlackHole"`
+	DnsServers            DnsServersInDescribeDnsProductInstance `json:"DnsServers" xml:"DnsServers"`
+}
+
+// CreateDescribeDnsProductInstanceRequest creates a request to invoke DescribeDnsProductInstance API
+func CreateDescribeDnsProductInstanceRequest() (request *DescribeDnsProductInstanceRequest) {
+	request = &DescribeDnsProductInstanceRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDnsProductInstance", "", "")
+	return
+}
+
+// CreateDescribeDnsProductInstanceResponse creates a response to parse from DescribeDnsProductInstance response
+func CreateDescribeDnsProductInstanceResponse() (response *DescribeDnsProductInstanceResponse) {
+	response = &DescribeDnsProductInstanceResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_dns_product_instances.go

@@ -0,0 +1,111 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDnsProductInstances invokes the alidns.DescribeDnsProductInstances API synchronously
+// api document: https://help.aliyun.com/api/alidns/describednsproductinstances.html
+func (client *Client) DescribeDnsProductInstances(request *DescribeDnsProductInstancesRequest) (response *DescribeDnsProductInstancesResponse, err error) {
+	response = CreateDescribeDnsProductInstancesResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDnsProductInstancesWithChan invokes the alidns.DescribeDnsProductInstances API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describednsproductinstances.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDnsProductInstancesWithChan(request *DescribeDnsProductInstancesRequest) (<-chan *DescribeDnsProductInstancesResponse, <-chan error) {
+	responseChan := make(chan *DescribeDnsProductInstancesResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDnsProductInstances(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDnsProductInstancesWithCallback invokes the alidns.DescribeDnsProductInstances API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describednsproductinstances.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDnsProductInstancesWithCallback(request *DescribeDnsProductInstancesRequest, callback func(response *DescribeDnsProductInstancesResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDnsProductInstancesResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDnsProductInstances(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDnsProductInstancesRequest is the request struct for api DescribeDnsProductInstances
+type DescribeDnsProductInstancesRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	PageNumber   requests.Integer `position:"Query" name:"PageNumber"`
+	PageSize     requests.Integer `position:"Query" name:"PageSize"`
+	VersionCode  string           `position:"Query" name:"VersionCode"`
+}
+
+// DescribeDnsProductInstancesResponse is the response struct for api DescribeDnsProductInstances
+type DescribeDnsProductInstancesResponse struct {
+	*responses.BaseResponse
+	RequestId   string      `json:"RequestId" xml:"RequestId"`
+	TotalCount  int         `json:"TotalCount" xml:"TotalCount"`
+	PageNumber  int         `json:"PageNumber" xml:"PageNumber"`
+	PageSize    int         `json:"PageSize" xml:"PageSize"`
+	DnsProducts DnsProducts `json:"DnsProducts" xml:"DnsProducts"`
+}
+
+// CreateDescribeDnsProductInstancesRequest creates a request to invoke DescribeDnsProductInstances API
+func CreateDescribeDnsProductInstancesRequest() (request *DescribeDnsProductInstancesRequest) {
+	request = &DescribeDnsProductInstancesRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDnsProductInstances", "", "")
+	return
+}
+
+// CreateDescribeDnsProductInstancesResponse creates a response to parse from DescribeDnsProductInstances response
+func CreateDescribeDnsProductInstancesResponse() (response *DescribeDnsProductInstancesResponse) {
+	response = &DescribeDnsProductInstancesResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_dnsslb_sub_domains.go

@@ -0,0 +1,111 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDNSSLBSubDomains invokes the alidns.DescribeDNSSLBSubDomains API synchronously
+// api document: https://help.aliyun.com/api/alidns/describednsslbsubdomains.html
+func (client *Client) DescribeDNSSLBSubDomains(request *DescribeDNSSLBSubDomainsRequest) (response *DescribeDNSSLBSubDomainsResponse, err error) {
+	response = CreateDescribeDNSSLBSubDomainsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDNSSLBSubDomainsWithChan invokes the alidns.DescribeDNSSLBSubDomains API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describednsslbsubdomains.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDNSSLBSubDomainsWithChan(request *DescribeDNSSLBSubDomainsRequest) (<-chan *DescribeDNSSLBSubDomainsResponse, <-chan error) {
+	responseChan := make(chan *DescribeDNSSLBSubDomainsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDNSSLBSubDomains(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDNSSLBSubDomainsWithCallback invokes the alidns.DescribeDNSSLBSubDomains API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describednsslbsubdomains.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDNSSLBSubDomainsWithCallback(request *DescribeDNSSLBSubDomainsRequest, callback func(response *DescribeDNSSLBSubDomainsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDNSSLBSubDomainsResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDNSSLBSubDomains(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDNSSLBSubDomainsRequest is the request struct for api DescribeDNSSLBSubDomains
+type DescribeDNSSLBSubDomainsRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	DomainName   string           `position:"Query" name:"DomainName"`
+	PageNumber   requests.Integer `position:"Query" name:"PageNumber"`
+	PageSize     requests.Integer `position:"Query" name:"PageSize"`
+}
+
+// DescribeDNSSLBSubDomainsResponse is the response struct for api DescribeDNSSLBSubDomains
+type DescribeDNSSLBSubDomainsResponse struct {
+	*responses.BaseResponse
+	RequestId     string        `json:"RequestId" xml:"RequestId"`
+	TotalCount    int           `json:"TotalCount" xml:"TotalCount"`
+	PageNumber    int           `json:"PageNumber" xml:"PageNumber"`
+	PageSize      int           `json:"PageSize" xml:"PageSize"`
+	SlbSubDomains SlbSubDomains `json:"SlbSubDomains" xml:"SlbSubDomains"`
+}
+
+// CreateDescribeDNSSLBSubDomainsRequest creates a request to invoke DescribeDNSSLBSubDomains API
+func CreateDescribeDNSSLBSubDomainsRequest() (request *DescribeDNSSLBSubDomainsRequest) {
+	request = &DescribeDNSSLBSubDomainsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDNSSLBSubDomains", "", "")
+	return
+}
+
+// CreateDescribeDNSSLBSubDomainsResponse creates a response to parse from DescribeDNSSLBSubDomains response
+func CreateDescribeDNSSLBSubDomainsResponse() (response *DescribeDNSSLBSubDomainsResponse) {
+	response = &DescribeDNSSLBSubDomainsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_domain_groups.go

@@ -0,0 +1,111 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDomainGroups invokes the alidns.DescribeDomainGroups API synchronously
+// api document: https://help.aliyun.com/api/alidns/describedomaingroups.html
+func (client *Client) DescribeDomainGroups(request *DescribeDomainGroupsRequest) (response *DescribeDomainGroupsResponse, err error) {
+	response = CreateDescribeDomainGroupsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDomainGroupsWithChan invokes the alidns.DescribeDomainGroups API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomaingroups.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainGroupsWithChan(request *DescribeDomainGroupsRequest) (<-chan *DescribeDomainGroupsResponse, <-chan error) {
+	responseChan := make(chan *DescribeDomainGroupsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainGroups(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDomainGroupsWithCallback invokes the alidns.DescribeDomainGroups API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomaingroups.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainGroupsWithCallback(request *DescribeDomainGroupsRequest, callback func(response *DescribeDomainGroupsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainGroupsResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainGroups(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDomainGroupsRequest is the request struct for api DescribeDomainGroups
+type DescribeDomainGroupsRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	KeyWord      string           `position:"Query" name:"KeyWord"`
+	PageNumber   requests.Integer `position:"Query" name:"PageNumber"`
+	PageSize     requests.Integer `position:"Query" name:"PageSize"`
+}
+
+// DescribeDomainGroupsResponse is the response struct for api DescribeDomainGroups
+type DescribeDomainGroupsResponse struct {
+	*responses.BaseResponse
+	RequestId    string       `json:"RequestId" xml:"RequestId"`
+	TotalCount   int          `json:"TotalCount" xml:"TotalCount"`
+	PageNumber   int          `json:"PageNumber" xml:"PageNumber"`
+	PageSize     int          `json:"PageSize" xml:"PageSize"`
+	DomainGroups DomainGroups `json:"DomainGroups" xml:"DomainGroups"`
+}
+
+// CreateDescribeDomainGroupsRequest creates a request to invoke DescribeDomainGroups API
+func CreateDescribeDomainGroupsRequest() (request *DescribeDomainGroupsRequest) {
+	request = &DescribeDomainGroupsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainGroups", "", "")
+	return
+}
+
+// CreateDescribeDomainGroupsResponse creates a response to parse from DescribeDomainGroups response
+func CreateDescribeDomainGroupsResponse() (response *DescribeDomainGroupsResponse) {
+	response = &DescribeDomainGroupsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_domain_info.go

@@ -0,0 +1,123 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDomainInfo invokes the alidns.DescribeDomainInfo API synchronously
+// api document: https://help.aliyun.com/api/alidns/describedomaininfo.html
+func (client *Client) DescribeDomainInfo(request *DescribeDomainInfoRequest) (response *DescribeDomainInfoResponse, err error) {
+	response = CreateDescribeDomainInfoResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDomainInfoWithChan invokes the alidns.DescribeDomainInfo API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomaininfo.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainInfoWithChan(request *DescribeDomainInfoRequest) (<-chan *DescribeDomainInfoResponse, <-chan error) {
+	responseChan := make(chan *DescribeDomainInfoResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainInfo(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDomainInfoWithCallback invokes the alidns.DescribeDomainInfo API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomaininfo.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainInfoWithCallback(request *DescribeDomainInfoRequest, callback func(response *DescribeDomainInfoResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainInfoResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainInfo(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDomainInfoRequest is the request struct for api DescribeDomainInfo
+type DescribeDomainInfoRequest struct {
+	*requests.RpcRequest
+	Lang                 string           `position:"Query" name:"Lang"`
+	UserClientIp         string           `position:"Query" name:"UserClientIp"`
+	DomainName           string           `position:"Query" name:"DomainName"`
+	NeedDetailAttributes requests.Boolean `position:"Query" name:"NeedDetailAttributes"`
+}
+
+// DescribeDomainInfoResponse is the response struct for api DescribeDomainInfo
+type DescribeDomainInfoResponse struct {
+	*responses.BaseResponse
+	RequestId          string                          `json:"RequestId" xml:"RequestId"`
+	DomainId           string                          `json:"DomainId" xml:"DomainId"`
+	DomainName         string                          `json:"DomainName" xml:"DomainName"`
+	PunyCode           string                          `json:"PunyCode" xml:"PunyCode"`
+	AliDomain          bool                            `json:"AliDomain" xml:"AliDomain"`
+	Remark             string                          `json:"Remark" xml:"Remark"`
+	GroupId            string                          `json:"GroupId" xml:"GroupId"`
+	GroupName          string                          `json:"GroupName" xml:"GroupName"`
+	InstanceId         string                          `json:"InstanceId" xml:"InstanceId"`
+	VersionCode        string                          `json:"VersionCode" xml:"VersionCode"`
+	VersionName        string                          `json:"VersionName" xml:"VersionName"`
+	MinTtl             int                             `json:"MinTtl" xml:"MinTtl"`
+	RecordLineTreeJson string                          `json:"RecordLineTreeJson" xml:"RecordLineTreeJson"`
+	LineType           string                          `json:"LineType" xml:"LineType"`
+	RegionLines        bool                            `json:"RegionLines" xml:"RegionLines"`
+	DnsServers         DnsServersInDescribeDomainInfo  `json:"DnsServers" xml:"DnsServers"`
+	AvailableTtls      AvailableTtls                   `json:"AvailableTtls" xml:"AvailableTtls"`
+	RecordLines        RecordLinesInDescribeDomainInfo `json:"RecordLines" xml:"RecordLines"`
+}
+
+// CreateDescribeDomainInfoRequest creates a request to invoke DescribeDomainInfo API
+func CreateDescribeDomainInfoRequest() (request *DescribeDomainInfoRequest) {
+	request = &DescribeDomainInfoRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainInfo", "", "")
+	return
+}
+
+// CreateDescribeDomainInfoResponse creates a response to parse from DescribeDomainInfo response
+func CreateDescribeDomainInfoResponse() (response *DescribeDomainInfoResponse) {
+	response = &DescribeDomainInfoResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_domain_logs.go

@@ -0,0 +1,114 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDomainLogs invokes the alidns.DescribeDomainLogs API synchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainlogs.html
+func (client *Client) DescribeDomainLogs(request *DescribeDomainLogsRequest) (response *DescribeDomainLogsResponse, err error) {
+	response = CreateDescribeDomainLogsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDomainLogsWithChan invokes the alidns.DescribeDomainLogs API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainlogs.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainLogsWithChan(request *DescribeDomainLogsRequest) (<-chan *DescribeDomainLogsResponse, <-chan error) {
+	responseChan := make(chan *DescribeDomainLogsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainLogs(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDomainLogsWithCallback invokes the alidns.DescribeDomainLogs API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainlogs.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainLogsWithCallback(request *DescribeDomainLogsRequest, callback func(response *DescribeDomainLogsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainLogsResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainLogs(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDomainLogsRequest is the request struct for api DescribeDomainLogs
+type DescribeDomainLogsRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	KeyWord      string           `position:"Query" name:"KeyWord"`
+	GroupId      string           `position:"Query" name:"GroupId"`
+	PageNumber   requests.Integer `position:"Query" name:"PageNumber"`
+	PageSize     requests.Integer `position:"Query" name:"PageSize"`
+	StartDate    string           `position:"Query" name:"StartDate"`
+	EndDate      string           `position:"Query" name:"endDate"`
+}
+
+// DescribeDomainLogsResponse is the response struct for api DescribeDomainLogs
+type DescribeDomainLogsResponse struct {
+	*responses.BaseResponse
+	RequestId  string     `json:"RequestId" xml:"RequestId"`
+	TotalCount int        `json:"TotalCount" xml:"TotalCount"`
+	PageNumber int        `json:"PageNumber" xml:"PageNumber"`
+	PageSize   int        `json:"PageSize" xml:"PageSize"`
+	DomainLogs DomainLogs `json:"DomainLogs" xml:"DomainLogs"`
+}
+
+// CreateDescribeDomainLogsRequest creates a request to invoke DescribeDomainLogs API
+func CreateDescribeDomainLogsRequest() (request *DescribeDomainLogsRequest) {
+	request = &DescribeDomainLogsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainLogs", "", "")
+	return
+}
+
+// CreateDescribeDomainLogsResponse creates a response to parse from DescribeDomainLogs response
+func CreateDescribeDomainLogsResponse() (response *DescribeDomainLogsResponse) {
+	response = &DescribeDomainLogsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_domain_ns.go

@@ -0,0 +1,109 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDomainNs invokes the alidns.DescribeDomainNs API synchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainns.html
+func (client *Client) DescribeDomainNs(request *DescribeDomainNsRequest) (response *DescribeDomainNsResponse, err error) {
+	response = CreateDescribeDomainNsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDomainNsWithChan invokes the alidns.DescribeDomainNs API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainns.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainNsWithChan(request *DescribeDomainNsRequest) (<-chan *DescribeDomainNsResponse, <-chan error) {
+	responseChan := make(chan *DescribeDomainNsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainNs(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDomainNsWithCallback invokes the alidns.DescribeDomainNs API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainns.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainNsWithCallback(request *DescribeDomainNsRequest, callback func(response *DescribeDomainNsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainNsResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainNs(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDomainNsRequest is the request struct for api DescribeDomainNs
+type DescribeDomainNsRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	DomainName   string `position:"Query" name:"DomainName"`
+}
+
+// DescribeDomainNsResponse is the response struct for api DescribeDomainNs
+type DescribeDomainNsResponse struct {
+	*responses.BaseResponse
+	RequestId        string                       `json:"RequestId" xml:"RequestId"`
+	AllAliDns        bool                         `json:"AllAliDns" xml:"AllAliDns"`
+	IncludeAliDns    bool                         `json:"IncludeAliDns" xml:"IncludeAliDns"`
+	DnsServers       DnsServersInDescribeDomainNs `json:"DnsServers" xml:"DnsServers"`
+	ExpectDnsServers ExpectDnsServers             `json:"ExpectDnsServers" xml:"ExpectDnsServers"`
+}
+
+// CreateDescribeDomainNsRequest creates a request to invoke DescribeDomainNs API
+func CreateDescribeDomainNsRequest() (request *DescribeDomainNsRequest) {
+	request = &DescribeDomainNsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainNs", "", "")
+	return
+}
+
+// CreateDescribeDomainNsResponse creates a response to parse from DescribeDomainNs response
+func CreateDescribeDomainNsResponse() (response *DescribeDomainNsResponse) {
+	response = &DescribeDomainNsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_domain_record_info.go

@@ -0,0 +1,119 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDomainRecordInfo invokes the alidns.DescribeDomainRecordInfo API synchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainrecordinfo.html
+func (client *Client) DescribeDomainRecordInfo(request *DescribeDomainRecordInfoRequest) (response *DescribeDomainRecordInfoResponse, err error) {
+	response = CreateDescribeDomainRecordInfoResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDomainRecordInfoWithChan invokes the alidns.DescribeDomainRecordInfo API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainrecordinfo.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainRecordInfoWithChan(request *DescribeDomainRecordInfoRequest) (<-chan *DescribeDomainRecordInfoResponse, <-chan error) {
+	responseChan := make(chan *DescribeDomainRecordInfoResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainRecordInfo(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDomainRecordInfoWithCallback invokes the alidns.DescribeDomainRecordInfo API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainrecordinfo.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainRecordInfoWithCallback(request *DescribeDomainRecordInfoRequest, callback func(response *DescribeDomainRecordInfoResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainRecordInfoResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainRecordInfo(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDomainRecordInfoRequest is the request struct for api DescribeDomainRecordInfo
+type DescribeDomainRecordInfoRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	RecordId     string `position:"Query" name:"RecordId"`
+}
+
+// DescribeDomainRecordInfoResponse is the response struct for api DescribeDomainRecordInfo
+type DescribeDomainRecordInfoResponse struct {
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	DomainId   string `json:"DomainId" xml:"DomainId"`
+	DomainName string `json:"DomainName" xml:"DomainName"`
+	PunyCode   string `json:"PunyCode" xml:"PunyCode"`
+	GroupId    string `json:"GroupId" xml:"GroupId"`
+	GroupName  string `json:"GroupName" xml:"GroupName"`
+	RecordId   string `json:"RecordId" xml:"RecordId"`
+	RR         string `json:"RR" xml:"RR"`
+	Type       string `json:"Type" xml:"Type"`
+	Value      string `json:"Value" xml:"Value"`
+	TTL        int    `json:"TTL" xml:"TTL"`
+	Priority   int    `json:"Priority" xml:"Priority"`
+	Line       string `json:"Line" xml:"Line"`
+	Status     string `json:"Status" xml:"Status"`
+	Locked     bool   `json:"Locked" xml:"Locked"`
+}
+
+// CreateDescribeDomainRecordInfoRequest creates a request to invoke DescribeDomainRecordInfo API
+func CreateDescribeDomainRecordInfoRequest() (request *DescribeDomainRecordInfoRequest) {
+	request = &DescribeDomainRecordInfoRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainRecordInfo", "", "")
+	return
+}
+
+// CreateDescribeDomainRecordInfoResponse creates a response to parse from DescribeDomainRecordInfo response
+func CreateDescribeDomainRecordInfoResponse() (response *DescribeDomainRecordInfoResponse) {
+	response = &DescribeDomainRecordInfoResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_domain_records.go

@@ -0,0 +1,117 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDomainRecords invokes the alidns.DescribeDomainRecords API synchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainrecords.html
+func (client *Client) DescribeDomainRecords(request *DescribeDomainRecordsRequest) (response *DescribeDomainRecordsResponse, err error) {
+	response = CreateDescribeDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDomainRecordsWithChan invokes the alidns.DescribeDomainRecords API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainrecords.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainRecordsWithChan(request *DescribeDomainRecordsRequest) (<-chan *DescribeDomainRecordsResponse, <-chan error) {
+	responseChan := make(chan *DescribeDomainRecordsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainRecords(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDomainRecordsWithCallback invokes the alidns.DescribeDomainRecords API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainrecords.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainRecordsWithCallback(request *DescribeDomainRecordsRequest, callback func(response *DescribeDomainRecordsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainRecordsResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainRecords(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDomainRecordsRequest is the request struct for api DescribeDomainRecords
+type DescribeDomainRecordsRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	DomainName   string           `position:"Query" name:"DomainName"`
+	PageNumber   requests.Integer `position:"Query" name:"PageNumber"`
+	PageSize     requests.Integer `position:"Query" name:"PageSize"`
+	KeyWord      string           `position:"Query" name:"KeyWord"`
+	RRKeyWord    string           `position:"Query" name:"RRKeyWord"`
+	TypeKeyWord  string           `position:"Query" name:"TypeKeyWord"`
+	ValueKeyWord string           `position:"Query" name:"ValueKeyWord"`
+	OrderBy      string           `position:"Query" name:"OrderBy"`
+	Direction    string           `position:"Query" name:"Direction"`
+}
+
+// DescribeDomainRecordsResponse is the response struct for api DescribeDomainRecords
+type DescribeDomainRecordsResponse struct {
+	*responses.BaseResponse
+	RequestId     string                               `json:"RequestId" xml:"RequestId"`
+	TotalCount    int                                  `json:"TotalCount" xml:"TotalCount"`
+	PageNumber    int                                  `json:"PageNumber" xml:"PageNumber"`
+	PageSize      int                                  `json:"PageSize" xml:"PageSize"`
+	DomainRecords DomainRecordsInDescribeDomainRecords `json:"DomainRecords" xml:"DomainRecords"`
+}
+
+// CreateDescribeDomainRecordsRequest creates a request to invoke DescribeDomainRecords API
+func CreateDescribeDomainRecordsRequest() (request *DescribeDomainRecordsRequest) {
+	request = &DescribeDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainRecords", "", "")
+	return
+}
+
+// CreateDescribeDomainRecordsResponse creates a response to parse from DescribeDomainRecords response
+func CreateDescribeDomainRecordsResponse() (response *DescribeDomainRecordsResponse) {
+	response = &DescribeDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_domain_whois_info.go

@@ -0,0 +1,113 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDomainWhoisInfo invokes the alidns.DescribeDomainWhoisInfo API synchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainwhoisinfo.html
+func (client *Client) DescribeDomainWhoisInfo(request *DescribeDomainWhoisInfoRequest) (response *DescribeDomainWhoisInfoResponse, err error) {
+	response = CreateDescribeDomainWhoisInfoResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDomainWhoisInfoWithChan invokes the alidns.DescribeDomainWhoisInfo API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainwhoisinfo.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainWhoisInfoWithChan(request *DescribeDomainWhoisInfoRequest) (<-chan *DescribeDomainWhoisInfoResponse, <-chan error) {
+	responseChan := make(chan *DescribeDomainWhoisInfoResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainWhoisInfo(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDomainWhoisInfoWithCallback invokes the alidns.DescribeDomainWhoisInfo API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomainwhoisinfo.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainWhoisInfoWithCallback(request *DescribeDomainWhoisInfoRequest, callback func(response *DescribeDomainWhoisInfoResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainWhoisInfoResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainWhoisInfo(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDomainWhoisInfoRequest is the request struct for api DescribeDomainWhoisInfo
+type DescribeDomainWhoisInfoRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	DomainName   string `position:"Query" name:"DomainName"`
+	GroupId      string `position:"Query" name:"GroupId"`
+}
+
+// DescribeDomainWhoisInfoResponse is the response struct for api DescribeDomainWhoisInfo
+type DescribeDomainWhoisInfoResponse struct {
+	*responses.BaseResponse
+	RequestId        string                              `json:"RequestId" xml:"RequestId"`
+	RegistrantName   string                              `json:"RegistrantName" xml:"RegistrantName"`
+	RegistrantEmail  string                              `json:"RegistrantEmail" xml:"RegistrantEmail"`
+	Registrar        string                              `json:"Registrar" xml:"Registrar"`
+	RegistrationDate string                              `json:"RegistrationDate" xml:"RegistrationDate"`
+	ExpirationDate   string                              `json:"ExpirationDate" xml:"ExpirationDate"`
+	StatusList       StatusList                          `json:"StatusList" xml:"StatusList"`
+	DnsServers       DnsServersInDescribeDomainWhoisInfo `json:"DnsServers" xml:"DnsServers"`
+}
+
+// CreateDescribeDomainWhoisInfoRequest creates a request to invoke DescribeDomainWhoisInfo API
+func CreateDescribeDomainWhoisInfoRequest() (request *DescribeDomainWhoisInfoRequest) {
+	request = &DescribeDomainWhoisInfoRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainWhoisInfo", "", "")
+	return
+}
+
+// CreateDescribeDomainWhoisInfoResponse creates a response to parse from DescribeDomainWhoisInfo response
+func CreateDescribeDomainWhoisInfoResponse() (response *DescribeDomainWhoisInfoResponse) {
+	response = &DescribeDomainWhoisInfoResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_domains.go

@@ -0,0 +1,112 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeDomains invokes the alidns.DescribeDomains API synchronously
+// api document: https://help.aliyun.com/api/alidns/describedomains.html
+func (client *Client) DescribeDomains(request *DescribeDomainsRequest) (response *DescribeDomainsResponse, err error) {
+	response = CreateDescribeDomainsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeDomainsWithChan invokes the alidns.DescribeDomains API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomains.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainsWithChan(request *DescribeDomainsRequest) (<-chan *DescribeDomainsResponse, <-chan error) {
+	responseChan := make(chan *DescribeDomainsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomains(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeDomainsWithCallback invokes the alidns.DescribeDomains API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describedomains.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeDomainsWithCallback(request *DescribeDomainsRequest, callback func(response *DescribeDomainsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainsResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomains(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeDomainsRequest is the request struct for api DescribeDomains
+type DescribeDomainsRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	KeyWord      string           `position:"Query" name:"KeyWord"`
+	GroupId      string           `position:"Query" name:"GroupId"`
+	PageNumber   requests.Integer `position:"Query" name:"PageNumber"`
+	PageSize     requests.Integer `position:"Query" name:"PageSize"`
+}
+
+// DescribeDomainsResponse is the response struct for api DescribeDomains
+type DescribeDomainsResponse struct {
+	*responses.BaseResponse
+	RequestId  string  `json:"RequestId" xml:"RequestId"`
+	TotalCount int     `json:"TotalCount" xml:"TotalCount"`
+	PageNumber int     `json:"PageNumber" xml:"PageNumber"`
+	PageSize   int     `json:"PageSize" xml:"PageSize"`
+	Domains    Domains `json:"Domains" xml:"Domains"`
+}
+
+// CreateDescribeDomainsRequest creates a request to invoke DescribeDomains API
+func CreateDescribeDomainsRequest() (request *DescribeDomainsRequest) {
+	request = &DescribeDomainsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomains", "", "")
+	return
+}
+
+// CreateDescribeDomainsResponse creates a response to parse from DescribeDomains response
+func CreateDescribeDomainsResponse() (response *DescribeDomainsResponse) {
+	response = &DescribeDomainsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_record_logs.go

@@ -0,0 +1,114 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeRecordLogs invokes the alidns.DescribeRecordLogs API synchronously
+// api document: https://help.aliyun.com/api/alidns/describerecordlogs.html
+func (client *Client) DescribeRecordLogs(request *DescribeRecordLogsRequest) (response *DescribeRecordLogsResponse, err error) {
+	response = CreateDescribeRecordLogsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeRecordLogsWithChan invokes the alidns.DescribeRecordLogs API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describerecordlogs.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeRecordLogsWithChan(request *DescribeRecordLogsRequest) (<-chan *DescribeRecordLogsResponse, <-chan error) {
+	responseChan := make(chan *DescribeRecordLogsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeRecordLogs(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeRecordLogsWithCallback invokes the alidns.DescribeRecordLogs API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describerecordlogs.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeRecordLogsWithCallback(request *DescribeRecordLogsRequest, callback func(response *DescribeRecordLogsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeRecordLogsResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeRecordLogs(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeRecordLogsRequest is the request struct for api DescribeRecordLogs
+type DescribeRecordLogsRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	DomainName   string           `position:"Query" name:"DomainName"`
+	PageNumber   requests.Integer `position:"Query" name:"PageNumber"`
+	PageSize     requests.Integer `position:"Query" name:"PageSize"`
+	KeyWord      string           `position:"Query" name:"KeyWord"`
+	StartDate    string           `position:"Query" name:"StartDate"`
+	EndDate      string           `position:"Query" name:"endDate"`
+}
+
+// DescribeRecordLogsResponse is the response struct for api DescribeRecordLogs
+type DescribeRecordLogsResponse struct {
+	*responses.BaseResponse
+	RequestId  string     `json:"RequestId" xml:"RequestId"`
+	TotalCount int        `json:"TotalCount" xml:"TotalCount"`
+	PageNumber int        `json:"PageNumber" xml:"PageNumber"`
+	PageSize   int        `json:"PageSize" xml:"PageSize"`
+	RecordLogs RecordLogs `json:"RecordLogs" xml:"RecordLogs"`
+}
+
+// CreateDescribeRecordLogsRequest creates a request to invoke DescribeRecordLogs API
+func CreateDescribeRecordLogsRequest() (request *DescribeRecordLogsRequest) {
+	request = &DescribeRecordLogsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeRecordLogs", "", "")
+	return
+}
+
+// CreateDescribeRecordLogsResponse creates a response to parse from DescribeRecordLogs response
+func CreateDescribeRecordLogsResponse() (response *DescribeRecordLogsResponse) {
+	response = &DescribeRecordLogsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_sub_domain_records.go

@@ -0,0 +1,112 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeSubDomainRecords invokes the alidns.DescribeSubDomainRecords API synchronously
+// api document: https://help.aliyun.com/api/alidns/describesubdomainrecords.html
+func (client *Client) DescribeSubDomainRecords(request *DescribeSubDomainRecordsRequest) (response *DescribeSubDomainRecordsResponse, err error) {
+	response = CreateDescribeSubDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeSubDomainRecordsWithChan invokes the alidns.DescribeSubDomainRecords API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describesubdomainrecords.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeSubDomainRecordsWithChan(request *DescribeSubDomainRecordsRequest) (<-chan *DescribeSubDomainRecordsResponse, <-chan error) {
+	responseChan := make(chan *DescribeSubDomainRecordsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeSubDomainRecords(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeSubDomainRecordsWithCallback invokes the alidns.DescribeSubDomainRecords API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describesubdomainrecords.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeSubDomainRecordsWithCallback(request *DescribeSubDomainRecordsRequest, callback func(response *DescribeSubDomainRecordsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeSubDomainRecordsResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeSubDomainRecords(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeSubDomainRecordsRequest is the request struct for api DescribeSubDomainRecords
+type DescribeSubDomainRecordsRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	SubDomain    string           `position:"Query" name:"SubDomain"`
+	PageNumber   requests.Integer `position:"Query" name:"PageNumber"`
+	PageSize     requests.Integer `position:"Query" name:"PageSize"`
+	Type         string           `position:"Query" name:"Type"`
+}
+
+// DescribeSubDomainRecordsResponse is the response struct for api DescribeSubDomainRecords
+type DescribeSubDomainRecordsResponse struct {
+	*responses.BaseResponse
+	RequestId     string                                  `json:"RequestId" xml:"RequestId"`
+	TotalCount    int                                     `json:"TotalCount" xml:"TotalCount"`
+	PageNumber    int                                     `json:"PageNumber" xml:"PageNumber"`
+	PageSize      int                                     `json:"PageSize" xml:"PageSize"`
+	DomainRecords DomainRecordsInDescribeSubDomainRecords `json:"DomainRecords" xml:"DomainRecords"`
+}
+
+// CreateDescribeSubDomainRecordsRequest creates a request to invoke DescribeSubDomainRecords API
+func CreateDescribeSubDomainRecordsRequest() (request *DescribeSubDomainRecordsRequest) {
+	request = &DescribeSubDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeSubDomainRecords", "", "")
+	return
+}
+
+// CreateDescribeSubDomainRecordsResponse creates a response to parse from DescribeSubDomainRecords response
+func CreateDescribeSubDomainRecordsResponse() (response *DescribeSubDomainRecordsResponse) {
+	response = &DescribeSubDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/describe_support_lines.go

@@ -0,0 +1,105 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// DescribeSupportLines invokes the alidns.DescribeSupportLines API synchronously
+// api document: https://help.aliyun.com/api/alidns/describesupportlines.html
+func (client *Client) DescribeSupportLines(request *DescribeSupportLinesRequest) (response *DescribeSupportLinesResponse, err error) {
+	response = CreateDescribeSupportLinesResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// DescribeSupportLinesWithChan invokes the alidns.DescribeSupportLines API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describesupportlines.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeSupportLinesWithChan(request *DescribeSupportLinesRequest) (<-chan *DescribeSupportLinesResponse, <-chan error) {
+	responseChan := make(chan *DescribeSupportLinesResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeSupportLines(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// DescribeSupportLinesWithCallback invokes the alidns.DescribeSupportLines API asynchronously
+// api document: https://help.aliyun.com/api/alidns/describesupportlines.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) DescribeSupportLinesWithCallback(request *DescribeSupportLinesRequest, callback func(response *DescribeSupportLinesResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeSupportLinesResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeSupportLines(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// DescribeSupportLinesRequest is the request struct for api DescribeSupportLines
+type DescribeSupportLinesRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+}
+
+// DescribeSupportLinesResponse is the response struct for api DescribeSupportLines
+type DescribeSupportLinesResponse struct {
+	*responses.BaseResponse
+	RequestId   string                            `json:"RequestId" xml:"RequestId"`
+	RecordLines RecordLinesInDescribeSupportLines `json:"RecordLines" xml:"RecordLines"`
+}
+
+// CreateDescribeSupportLinesRequest creates a request to invoke DescribeSupportLines API
+func CreateDescribeSupportLinesRequest() (request *DescribeSupportLinesRequest) {
+	request = &DescribeSupportLinesRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeSupportLines", "", "")
+	return
+}
+
+// CreateDescribeSupportLinesResponse creates a response to parse from DescribeSupportLines response
+func CreateDescribeSupportLinesResponse() (response *DescribeSupportLinesResponse) {
+	response = &DescribeSupportLinesResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/get_main_domain_name.go

@@ -0,0 +1,108 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// GetMainDomainName invokes the alidns.GetMainDomainName API synchronously
+// api document: https://help.aliyun.com/api/alidns/getmaindomainname.html
+func (client *Client) GetMainDomainName(request *GetMainDomainNameRequest) (response *GetMainDomainNameResponse, err error) {
+	response = CreateGetMainDomainNameResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// GetMainDomainNameWithChan invokes the alidns.GetMainDomainName API asynchronously
+// api document: https://help.aliyun.com/api/alidns/getmaindomainname.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) GetMainDomainNameWithChan(request *GetMainDomainNameRequest) (<-chan *GetMainDomainNameResponse, <-chan error) {
+	responseChan := make(chan *GetMainDomainNameResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.GetMainDomainName(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// GetMainDomainNameWithCallback invokes the alidns.GetMainDomainName API asynchronously
+// api document: https://help.aliyun.com/api/alidns/getmaindomainname.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) GetMainDomainNameWithCallback(request *GetMainDomainNameRequest, callback func(response *GetMainDomainNameResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *GetMainDomainNameResponse
+		var err error
+		defer close(result)
+		response, err = client.GetMainDomainName(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// GetMainDomainNameRequest is the request struct for api GetMainDomainName
+type GetMainDomainNameRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	InputString  string `position:"Query" name:"InputString"`
+}
+
+// GetMainDomainNameResponse is the response struct for api GetMainDomainName
+type GetMainDomainNameResponse struct {
+	*responses.BaseResponse
+	RequestId   string `json:"RequestId" xml:"RequestId"`
+	DomainName  string `json:"DomainName" xml:"DomainName"`
+	RR          string `json:"RR" xml:"RR"`
+	DomainLevel int    `json:"DomainLevel" xml:"DomainLevel"`
+}
+
+// CreateGetMainDomainNameRequest creates a request to invoke GetMainDomainName API
+func CreateGetMainDomainNameRequest() (request *GetMainDomainNameRequest) {
+	request = &GetMainDomainNameRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "GetMainDomainName", "", "")
+	return
+}
+
+// CreateGetMainDomainNameResponse creates a response to parse from GetMainDomainName response
+func CreateGetMainDomainNameResponse() (response *GetMainDomainNameResponse) {
+	response = &GetMainDomainNameResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/modify_hichina_domain_dns.go

@@ -0,0 +1,107 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// ModifyHichinaDomainDNS invokes the alidns.ModifyHichinaDomainDNS API synchronously
+// api document: https://help.aliyun.com/api/alidns/modifyhichinadomaindns.html
+func (client *Client) ModifyHichinaDomainDNS(request *ModifyHichinaDomainDNSRequest) (response *ModifyHichinaDomainDNSResponse, err error) {
+	response = CreateModifyHichinaDomainDNSResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// ModifyHichinaDomainDNSWithChan invokes the alidns.ModifyHichinaDomainDNS API asynchronously
+// api document: https://help.aliyun.com/api/alidns/modifyhichinadomaindns.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ModifyHichinaDomainDNSWithChan(request *ModifyHichinaDomainDNSRequest) (<-chan *ModifyHichinaDomainDNSResponse, <-chan error) {
+	responseChan := make(chan *ModifyHichinaDomainDNSResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.ModifyHichinaDomainDNS(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// ModifyHichinaDomainDNSWithCallback invokes the alidns.ModifyHichinaDomainDNS API asynchronously
+// api document: https://help.aliyun.com/api/alidns/modifyhichinadomaindns.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) ModifyHichinaDomainDNSWithCallback(request *ModifyHichinaDomainDNSRequest, callback func(response *ModifyHichinaDomainDNSResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *ModifyHichinaDomainDNSResponse
+		var err error
+		defer close(result)
+		response, err = client.ModifyHichinaDomainDNS(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// ModifyHichinaDomainDNSRequest is the request struct for api ModifyHichinaDomainDNS
+type ModifyHichinaDomainDNSRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	DomainName   string `position:"Query" name:"DomainName"`
+}
+
+// ModifyHichinaDomainDNSResponse is the response struct for api ModifyHichinaDomainDNS
+type ModifyHichinaDomainDNSResponse struct {
+	*responses.BaseResponse
+	RequestId          string             `json:"RequestId" xml:"RequestId"`
+	OriginalDnsServers OriginalDnsServers `json:"OriginalDnsServers" xml:"OriginalDnsServers"`
+	NewDnsServers      NewDnsServers      `json:"NewDnsServers" xml:"NewDnsServers"`
+}
+
+// CreateModifyHichinaDomainDNSRequest creates a request to invoke ModifyHichinaDomainDNS API
+func CreateModifyHichinaDomainDNSRequest() (request *ModifyHichinaDomainDNSRequest) {
+	request = &ModifyHichinaDomainDNSRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "ModifyHichinaDomainDNS", "", "")
+	return
+}
+
+// CreateModifyHichinaDomainDNSResponse creates a response to parse from ModifyHichinaDomainDNS response
+func CreateModifyHichinaDomainDNSResponse() (response *ModifyHichinaDomainDNSResponse) {
+	response = &ModifyHichinaDomainDNSResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/retrieval_domain_name.go

@@ -0,0 +1,107 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// RetrievalDomainName invokes the alidns.RetrievalDomainName API synchronously
+// api document: https://help.aliyun.com/api/alidns/retrievaldomainname.html
+func (client *Client) RetrievalDomainName(request *RetrievalDomainNameRequest) (response *RetrievalDomainNameResponse, err error) {
+	response = CreateRetrievalDomainNameResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// RetrievalDomainNameWithChan invokes the alidns.RetrievalDomainName API asynchronously
+// api document: https://help.aliyun.com/api/alidns/retrievaldomainname.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) RetrievalDomainNameWithChan(request *RetrievalDomainNameRequest) (<-chan *RetrievalDomainNameResponse, <-chan error) {
+	responseChan := make(chan *RetrievalDomainNameResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.RetrievalDomainName(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// RetrievalDomainNameWithCallback invokes the alidns.RetrievalDomainName API asynchronously
+// api document: https://help.aliyun.com/api/alidns/retrievaldomainname.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) RetrievalDomainNameWithCallback(request *RetrievalDomainNameRequest, callback func(response *RetrievalDomainNameResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *RetrievalDomainNameResponse
+		var err error
+		defer close(result)
+		response, err = client.RetrievalDomainName(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// RetrievalDomainNameRequest is the request struct for api RetrievalDomainName
+type RetrievalDomainNameRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	DomainName   string `position:"Query" name:"DomainName"`
+}
+
+// RetrievalDomainNameResponse is the response struct for api RetrievalDomainName
+type RetrievalDomainNameResponse struct {
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	DomainName string `json:"DomainName" xml:"DomainName"`
+	WhoisEmail string `json:"WhoisEmail" xml:"WhoisEmail"`
+}
+
+// CreateRetrievalDomainNameRequest creates a request to invoke RetrievalDomainName API
+func CreateRetrievalDomainNameRequest() (request *RetrievalDomainNameRequest) {
+	request = &RetrievalDomainNameRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "RetrievalDomainName", "", "")
+	return
+}
+
+// CreateRetrievalDomainNameResponse creates a response to parse from RetrievalDomainName response
+func CreateRetrievalDomainNameResponse() (response *RetrievalDomainNameResponse) {
+	response = &RetrievalDomainNameResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/set_dnsslb_status.go

@@ -0,0 +1,108 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// SetDNSSLBStatus invokes the alidns.SetDNSSLBStatus API synchronously
+// api document: https://help.aliyun.com/api/alidns/setdnsslbstatus.html
+func (client *Client) SetDNSSLBStatus(request *SetDNSSLBStatusRequest) (response *SetDNSSLBStatusResponse, err error) {
+	response = CreateSetDNSSLBStatusResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// SetDNSSLBStatusWithChan invokes the alidns.SetDNSSLBStatus API asynchronously
+// api document: https://help.aliyun.com/api/alidns/setdnsslbstatus.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) SetDNSSLBStatusWithChan(request *SetDNSSLBStatusRequest) (<-chan *SetDNSSLBStatusResponse, <-chan error) {
+	responseChan := make(chan *SetDNSSLBStatusResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.SetDNSSLBStatus(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// SetDNSSLBStatusWithCallback invokes the alidns.SetDNSSLBStatus API asynchronously
+// api document: https://help.aliyun.com/api/alidns/setdnsslbstatus.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) SetDNSSLBStatusWithCallback(request *SetDNSSLBStatusRequest, callback func(response *SetDNSSLBStatusResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *SetDNSSLBStatusResponse
+		var err error
+		defer close(result)
+		response, err = client.SetDNSSLBStatus(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// SetDNSSLBStatusRequest is the request struct for api SetDNSSLBStatus
+type SetDNSSLBStatusRequest struct {
+	*requests.RpcRequest
+	Lang         string           `position:"Query" name:"Lang"`
+	UserClientIp string           `position:"Query" name:"UserClientIp"`
+	SubDomain    string           `position:"Query" name:"SubDomain"`
+	Open         requests.Boolean `position:"Query" name:"Open"`
+}
+
+// SetDNSSLBStatusResponse is the response struct for api SetDNSSLBStatus
+type SetDNSSLBStatusResponse struct {
+	*responses.BaseResponse
+	RequestId   string `json:"RequestId" xml:"RequestId"`
+	RecordCount int    `json:"RecordCount" xml:"RecordCount"`
+	Open        bool   `json:"Open" xml:"Open"`
+}
+
+// CreateSetDNSSLBStatusRequest creates a request to invoke SetDNSSLBStatus API
+func CreateSetDNSSLBStatusRequest() (request *SetDNSSLBStatusRequest) {
+	request = &SetDNSSLBStatusRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "SetDNSSLBStatus", "", "")
+	return
+}
+
+// CreateSetDNSSLBStatusResponse creates a response to parse from SetDNSSLBStatus response
+func CreateSetDNSSLBStatusResponse() (response *SetDNSSLBStatusResponse) {
+	response = &SetDNSSLBStatusResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/set_domain_record_status.go

@@ -0,0 +1,108 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
+)
+
+// SetDomainRecordStatus invokes the alidns.SetDomainRecordStatus API synchronously
+// api document: https://help.aliyun.com/api/alidns/setdomainrecordstatus.html
+func (client *Client) SetDomainRecordStatus(request *SetDomainRecordStatusRequest) (response *SetDomainRecordStatusResponse, err error) {
+	response = CreateSetDomainRecordStatusResponse()
+	err = client.DoAction(request, response)
+	return
+}
+
+// SetDomainRecordStatusWithChan invokes the alidns.SetDomainRecordStatus API asynchronously
+// api document: https://help.aliyun.com/api/alidns/setdomainrecordstatus.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) SetDomainRecordStatusWithChan(request *SetDomainRecordStatusRequest) (<-chan *SetDomainRecordStatusResponse, <-chan error) {
+	responseChan := make(chan *SetDomainRecordStatusResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.SetDomainRecordStatus(request)
+		if err != nil {
+			errChan <- err
+		} else {
+			responseChan <- response
+		}
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
+}
+
+// SetDomainRecordStatusWithCallback invokes the alidns.SetDomainRecordStatus API asynchronously
+// api document: https://help.aliyun.com/api/alidns/setdomainrecordstatus.html
+// asynchronous document: https://help.aliyun.com/document_detail/66220.html
+func (client *Client) SetDomainRecordStatusWithCallback(request *SetDomainRecordStatusRequest, callback func(response *SetDomainRecordStatusResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *SetDomainRecordStatusResponse
+		var err error
+		defer close(result)
+		response, err = client.SetDomainRecordStatus(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
+}
+
+// SetDomainRecordStatusRequest is the request struct for api SetDomainRecordStatus
+type SetDomainRecordStatusRequest struct {
+	*requests.RpcRequest
+	Lang         string `position:"Query" name:"Lang"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	RecordId     string `position:"Query" name:"RecordId"`
+	Status       string `position:"Query" name:"Status"`
+}
+
+// SetDomainRecordStatusResponse is the response struct for api SetDomainRecordStatus
+type SetDomainRecordStatusResponse struct {
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	RecordId  string `json:"RecordId" xml:"RecordId"`
+	Status    string `json:"Status" xml:"Status"`
+}
+
+// CreateSetDomainRecordStatusRequest creates a request to invoke SetDomainRecordStatus API
+func CreateSetDomainRecordStatusRequest() (request *SetDomainRecordStatusRequest) {
+	request = &SetDomainRecordStatusRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "SetDomainRecordStatus", "", "")
+	return
+}
+
+// CreateSetDomainRecordStatusResponse creates a response to parse from SetDomainRecordStatus response
+func CreateSetDomainRecordStatusResponse() (response *SetDomainRecordStatusResponse) {
+	response = &SetDomainRecordStatusResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_available_ttls.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// AvailableTtls is a nested struct in alidns response
+type AvailableTtls struct {
+	AvailableTtl []string `json:"AvailableTtl" xml:"AvailableTtl"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_dns_product.go

@@ -0,0 +1,48 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DnsProduct is a nested struct in alidns response
+type DnsProduct struct {
+	InstanceId            string `json:"InstanceId" xml:"InstanceId"`
+	VersionCode           string `json:"VersionCode" xml:"VersionCode"`
+	VersionName           string `json:"VersionName" xml:"VersionName"`
+	StartTime             string `json:"StartTime" xml:"StartTime"`
+	EndTime               string `json:"EndTime" xml:"EndTime"`
+	StartTimestamp        int    `json:"StartTimestamp" xml:"StartTimestamp"`
+	EndTimestamp          int    `json:"EndTimestamp" xml:"EndTimestamp"`
+	Domain                string `json:"Domain" xml:"Domain"`
+	BindCount             int    `json:"BindCount" xml:"BindCount"`
+	BindUsedCount         int    `json:"BindUsedCount" xml:"BindUsedCount"`
+	TTLMinValue           int    `json:"TTLMinValue" xml:"TTLMinValue"`
+	SubDomainLevel        int    `json:"SubDomainLevel" xml:"SubDomainLevel"`
+	DnsSLBCount           int    `json:"DnsSLBCount" xml:"DnsSLBCount"`
+	URLForwardCount       int    `json:"URLForwardCount" xml:"URLForwardCount"`
+	DDosDefendFlow        int    `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
+	DDosDefendQuery       int    `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
+	OverseaDDosDefendFlow int    `json:"OverseaDDosDefendFlow" xml:"OverseaDDosDefendFlow"`
+	SearchEngineLines     string `json:"SearchEngineLines" xml:"SearchEngineLines"`
+	ISPLines              string `json:"ISPLines" xml:"ISPLines"`
+	ISPRegionLines        string `json:"ISPRegionLines" xml:"ISPRegionLines"`
+	OverseaLine           string `json:"OverseaLine" xml:"OverseaLine"`
+	MonitorNodeCount      int    `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
+	MonitorFrequency      int    `json:"MonitorFrequency" xml:"MonitorFrequency"`
+	MonitorTaskCount      int    `json:"MonitorTaskCount" xml:"MonitorTaskCount"`
+	RegionLines           bool   `json:"RegionLines" xml:"RegionLines"`
+	Gslb                  bool   `json:"Gslb" xml:"Gslb"`
+	InClean               bool   `json:"InClean" xml:"InClean"`
+	InBlackHole           bool   `json:"InBlackHole" xml:"InBlackHole"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_dns_products.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DnsProducts is a nested struct in alidns response
+type DnsProducts struct {
+	DnsProduct []DnsProduct `json:"DnsProduct" xml:"DnsProduct"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_dns_servers_in_add_domain.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DnsServersInAddDomain is a nested struct in alidns response
+type DnsServersInAddDomain struct {
+	DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_dns_servers_in_describe_dns_product_instance.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DnsServersInDescribeDnsProductInstance is a nested struct in alidns response
+type DnsServersInDescribeDnsProductInstance struct {
+	DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_dns_servers_in_describe_domain_info.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DnsServersInDescribeDomainInfo is a nested struct in alidns response
+type DnsServersInDescribeDomainInfo struct {
+	DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_dns_servers_in_describe_domain_ns.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DnsServersInDescribeDomainNs is a nested struct in alidns response
+type DnsServersInDescribeDomainNs struct {
+	DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_dns_servers_in_describe_domain_whois_info.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DnsServersInDescribeDomainWhoisInfo is a nested struct in alidns response
+type DnsServersInDescribeDomainWhoisInfo struct {
+	DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_dns_servers_in_describe_domains.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DnsServersInDescribeDomains is a nested struct in alidns response
+type DnsServersInDescribeDomains struct {
+	DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_domain.go

@@ -0,0 +1,35 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// Domain is a nested struct in alidns response
+type Domain struct {
+	DomainId        string                      `json:"DomainId" xml:"DomainId"`
+	DomainName      string                      `json:"DomainName" xml:"DomainName"`
+	PunyCode        string                      `json:"PunyCode" xml:"PunyCode"`
+	AliDomain       bool                        `json:"AliDomain" xml:"AliDomain"`
+	RecordCount     int                         `json:"RecordCount" xml:"RecordCount"`
+	RegistrantEmail string                      `json:"RegistrantEmail" xml:"RegistrantEmail"`
+	Remark          string                      `json:"Remark" xml:"Remark"`
+	GroupId         string                      `json:"GroupId" xml:"GroupId"`
+	GroupName       string                      `json:"GroupName" xml:"GroupName"`
+	InstanceId      string                      `json:"InstanceId" xml:"InstanceId"`
+	VersionCode     string                      `json:"VersionCode" xml:"VersionCode"`
+	VersionName     string                      `json:"VersionName" xml:"VersionName"`
+	InstanceEndTime string                      `json:"InstanceEndTime" xml:"InstanceEndTime"`
+	InstanceExpired bool                        `json:"InstanceExpired" xml:"InstanceExpired"`
+	DnsServers      DnsServersInDescribeDomains `json:"DnsServers" xml:"DnsServers"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_domain_group.go

@@ -0,0 +1,23 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DomainGroup is a nested struct in alidns response
+type DomainGroup struct {
+	GroupId     string `json:"GroupId" xml:"GroupId"`
+	GroupName   string `json:"GroupName" xml:"GroupName"`
+	DomainCount int    `json:"DomainCount" xml:"DomainCount"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_domain_groups.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DomainGroups is a nested struct in alidns response
+type DomainGroups struct {
+	DomainGroup []DomainGroup `json:"DomainGroup" xml:"DomainGroup"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_domain_log.go

@@ -0,0 +1,26 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DomainLog is a nested struct in alidns response
+type DomainLog struct {
+	ActionTime      string `json:"ActionTime" xml:"ActionTime"`
+	ActionTimestamp int    `json:"ActionTimestamp" xml:"ActionTimestamp"`
+	DomainName      string `json:"DomainName" xml:"DomainName"`
+	Action          string `json:"Action" xml:"Action"`
+	Message         string `json:"Message" xml:"Message"`
+	ClientIp        string `json:"ClientIp" xml:"ClientIp"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_domain_logs.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DomainLogs is a nested struct in alidns response
+type DomainLogs struct {
+	DomainLog []DomainLog `json:"DomainLog" xml:"DomainLog"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_domain_records_in_describe_domain_records.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DomainRecordsInDescribeDomainRecords is a nested struct in alidns response
+type DomainRecordsInDescribeDomainRecords struct {
+	Record []Record `json:"Record" xml:"Record"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_domain_records_in_describe_sub_domain_records.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// DomainRecordsInDescribeSubDomainRecords is a nested struct in alidns response
+type DomainRecordsInDescribeSubDomainRecords struct {
+	Record []Record `json:"Record" xml:"Record"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_domains.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// Domains is a nested struct in alidns response
+type Domains struct {
+	Domain []Domain `json:"Domain" xml:"Domain"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_expect_dns_servers.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// ExpectDnsServers is a nested struct in alidns response
+type ExpectDnsServers struct {
+	ExpectDnsServer []string `json:"ExpectDnsServer" xml:"ExpectDnsServer"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_fail_result.go

@@ -0,0 +1,22 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// FailResult is a nested struct in alidns response
+type FailResult struct {
+	BatchIndex string `json:"BatchIndex" xml:"BatchIndex"`
+	ErrorCode  string `json:"ErrorCode" xml:"ErrorCode"`
+}

vendor/github.com/aliyun/alibaba-cloud-sdk-go/services/alidns/struct_fail_results.go

@@ -0,0 +1,21 @@
+package alidns
+
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+//
+// Code generated by Alibaba Cloud SDK Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// FailResults is a nested struct in alidns response
+type FailResults struct {
+	FailResult []FailResult `json:"FailResult" xml:"FailResult"`
+}