init

Signed-off-by: 高汝彤 <rutong.grt@alibaba-inc.com>

services/alidns/add_batch_domain_records.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddBatchDomainRecords(request *AddBatchDomainRecordsRequest) (response *AddBatchDomainRecordsResponse, err error) {
-response = CreateAddBatchDomainRecordsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateAddBatchDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type AddBatchDomainRecordsRequest struct {
-*requests.RpcRequest
-                Records  string `position:"Query" name:"Records"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	Records      string `position:"Query" name:"Records"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type AddBatchDomainRecordsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TraceId     string `json:"TraceId" xml:"TraceId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	TraceId   string `json:"TraceId" xml:"TraceId"`
 }
 
 func CreateAddBatchDomainRecordsRequest() (request *AddBatchDomainRecordsRequest) {
-request = &AddBatchDomainRecordsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "AddBatchDomainRecords", "", "")
-return
+	request = &AddBatchDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "AddBatchDomainRecords", "", "")
+	return
 }
 
 func CreateAddBatchDomainRecordsResponse() (response *AddBatchDomainRecordsResponse) {
-response = &AddBatchDomainRecordsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &AddBatchDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/add_domain.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,86 +16,84 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddDomain(request *AddDomainRequest) (response *AddDomainResponse, err error) {
-response = CreateAddDomainResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateAddDomainResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type AddDomainRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                GroupId  string `position:"Query" name:"GroupId"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	GroupId      string `position:"Query" name:"GroupId"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 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 struct {
-                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
-                } `json:"DnsServers" xml:"DnsServers"`
+	*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 struct {
+		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+	} `json:"DnsServers" xml:"DnsServers"`
 }
 
 func CreateAddDomainRequest() (request *AddDomainRequest) {
-request = &AddDomainRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomain", "", "")
-return
+	request = &AddDomainRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomain", "", "")
+	return
 }
 
 func CreateAddDomainResponse() (response *AddDomainResponse) {
-response = &AddDomainResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &AddDomainResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/add_domain_group.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,79 +16,77 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddDomainGroup(request *AddDomainGroupRequest) (response *AddDomainGroupResponse, err error) {
-response = CreateAddDomainGroupResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateAddDomainGroupResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type AddDomainGroupRequest struct {
-*requests.RpcRequest
-                GroupName  string `position:"Query" name:"GroupName"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	GroupName    string `position:"Query" name:"GroupName"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type AddDomainGroupResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            GroupId     string `json:"GroupId" xml:"GroupId"`
-            GroupName     string `json:"GroupName" xml:"GroupName"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	GroupId   string `json:"GroupId" xml:"GroupId"`
+	GroupName string `json:"GroupName" xml:"GroupName"`
 }
 
 func CreateAddDomainGroupRequest() (request *AddDomainGroupRequest) {
-request = &AddDomainGroupRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomainGroup", "", "")
-return
+	request = &AddDomainGroupRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomainGroup", "", "")
+	return
 }
 
 func CreateAddDomainGroupResponse() (response *AddDomainGroupResponse) {
-response = &AddDomainGroupResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &AddDomainGroupResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/add_domain_record.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,84 +16,82 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddDomainRecord(request *AddDomainRecordRequest) (response *AddDomainRecordResponse, err error) {
-response = CreateAddDomainRecordResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateAddDomainRecordResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type AddDomainRecordRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                Priority  string `position:"Query" name:"Priority"`
-                Value  string `position:"Query" name:"Value"`
-                RR  string `position:"Query" name:"RR"`
-                Line  string `position:"Query" name:"Line"`
-                TTL  string `position:"Query" name:"TTL"`
-                Type  string `position:"Query" name:"Type"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	Priority     string `position:"Query" name:"Priority"`
+	Value        string `position:"Query" name:"Value"`
+	RR           string `position:"Query" name:"RR"`
+	Line         string `position:"Query" name:"Line"`
+	TTL          string `position:"Query" name:"TTL"`
+	Type         string `position:"Query" name:"Type"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type AddDomainRecordResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            RecordId     string `json:"RecordId" xml:"RecordId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	RecordId  string `json:"RecordId" xml:"RecordId"`
 }
 
 func CreateAddDomainRecordRequest() (request *AddDomainRecordRequest) {
-request = &AddDomainRecordRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomainRecord", "", "")
-return
+	request = &AddDomainRecordRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "AddDomainRecord", "", "")
+	return
 }
 
 func CreateAddDomainRecordResponse() (response *AddDomainRecordResponse) {
-response = &AddDomainRecordResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &AddDomainRecordResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/apply_for_retrieval_domain_name.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ApplyForRetrievalDomainName(request *ApplyForRetrievalDomainNameRequest) (response *ApplyForRetrievalDomainNameResponse, err error) {
-response = CreateApplyForRetrievalDomainNameResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateApplyForRetrievalDomainNameResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type ApplyForRetrievalDomainNameRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type ApplyForRetrievalDomainNameResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	DomainName string `json:"DomainName" xml:"DomainName"`
 }
 
 func CreateApplyForRetrievalDomainNameRequest() (request *ApplyForRetrievalDomainNameRequest) {
-request = &ApplyForRetrievalDomainNameRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "ApplyForRetrievalDomainName", "", "")
-return
+	request = &ApplyForRetrievalDomainNameRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "ApplyForRetrievalDomainName", "", "")
+	return
 }
 
 func CreateApplyForRetrievalDomainNameResponse() (response *ApplyForRetrievalDomainNameResponse) {
-response = &ApplyForRetrievalDomainNameResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &ApplyForRetrievalDomainNameResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/change_domain_group.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ChangeDomainGroup(request *ChangeDomainGroupRequest) (response *ChangeDomainGroupResponse, err error) {
-response = CreateChangeDomainGroupResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateChangeDomainGroupResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type ChangeDomainGroupRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                GroupId  string `position:"Query" name:"GroupId"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	GroupId      string `position:"Query" name:"GroupId"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type ChangeDomainGroupResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            GroupId     string `json:"GroupId" xml:"GroupId"`
-            GroupName     string `json:"GroupName" xml:"GroupName"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	GroupId   string `json:"GroupId" xml:"GroupId"`
+	GroupName string `json:"GroupName" xml:"GroupName"`
 }
 
 func CreateChangeDomainGroupRequest() (request *ChangeDomainGroupRequest) {
-request = &ChangeDomainGroupRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "ChangeDomainGroup", "", "")
-return
+	request = &ChangeDomainGroupRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "ChangeDomainGroup", "", "")
+	return
 }
 
 func CreateChangeDomainGroupResponse() (response *ChangeDomainGroupResponse) {
-response = &ChangeDomainGroupResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &ChangeDomainGroupResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/change_domain_of_dns_product.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ChangeDomainOfDnsProduct(request *ChangeDomainOfDnsProductRequest) (response *ChangeDomainOfDnsProductResponse, err error) {
-response = CreateChangeDomainOfDnsProductResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateChangeDomainOfDnsProductResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type ChangeDomainOfDnsProductRequest struct {
-*requests.RpcRequest
-                NewDomain  string `position:"Query" name:"NewDomain"`
-                Force  string `position:"Query" name:"Force"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*requests.RpcRequest
+	NewDomain    string `position:"Query" name:"NewDomain"`
+	Force        string `position:"Query" name:"Force"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
+	InstanceId   string `position:"Query" name:"InstanceId"`
 }
 
-
 type ChangeDomainOfDnsProductResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            OriginalDomain     string `json:"OriginalDomain" xml:"OriginalDomain"`
+	*responses.BaseResponse
+	RequestId      string `json:"RequestId" xml:"RequestId"`
+	OriginalDomain string `json:"OriginalDomain" xml:"OriginalDomain"`
 }
 
 func CreateChangeDomainOfDnsProductRequest() (request *ChangeDomainOfDnsProductRequest) {
-request = &ChangeDomainOfDnsProductRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "ChangeDomainOfDnsProduct", "", "")
-return
+	request = &ChangeDomainOfDnsProductRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "ChangeDomainOfDnsProduct", "", "")
+	return
 }
 
 func CreateChangeDomainOfDnsProductResponse() (response *ChangeDomainOfDnsProductResponse) {
-response = &ChangeDomainOfDnsProductResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &ChangeDomainOfDnsProductResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/check_domain_record.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,81 +16,79 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) CheckDomainRecord(request *CheckDomainRecordRequest) (response *CheckDomainRecordResponse, err error) {
-response = CreateCheckDomainRecordResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateCheckDomainRecordResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type CheckDomainRecordRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                Value  string `position:"Query" name:"Value"`
-                RR  string `position:"Query" name:"RR"`
-                Type  string `position:"Query" name:"Type"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	Value        string `position:"Query" name:"Value"`
+	RR           string `position:"Query" name:"RR"`
+	Type         string `position:"Query" name:"Type"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type CheckDomainRecordResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            IsExist     bool `json:"IsExist" xml:"IsExist"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	IsExist   bool   `json:"IsExist" xml:"IsExist"`
 }
 
 func CreateCheckDomainRecordRequest() (request *CheckDomainRecordRequest) {
-request = &CheckDomainRecordRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "CheckDomainRecord", "", "")
-return
+	request = &CheckDomainRecordRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "CheckDomainRecord", "", "")
+	return
 }
 
 func CreateCheckDomainRecordResponse() (response *CheckDomainRecordResponse) {
-response = &CheckDomainRecordResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &CheckDomainRecordResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/client.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,28 +16,28 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
 )
 
 type Client struct {
-    sdk.Client
+	sdk.Client
 }
 
 func NewClient() (client *Client, err error) {
-    client = &Client{}
-    err = client.Init()
-    return
+	client = &Client{}
+	err = client.Init()
+	return
 }
 
 func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error) {
-    client = &Client{}
-    err = client.InitWithOptions(regionId, config, credential)
-    return
+	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
+	client = &Client{}
+	err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
+	return
 }

services/alidns/delete_batch_domain_records.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteBatchDomainRecords(request *DeleteBatchDomainRecordsRequest) (response *DeleteBatchDomainRecordsResponse, err error) {
-response = CreateDeleteBatchDomainRecordsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteBatchDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DeleteBatchDomainRecordsRequest struct {
-*requests.RpcRequest
-                Records  string `position:"Query" name:"Records"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	Records      string `position:"Query" name:"Records"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DeleteBatchDomainRecordsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TraceId     string `json:"TraceId" xml:"TraceId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	TraceId   string `json:"TraceId" xml:"TraceId"`
 }
 
 func CreateDeleteBatchDomainRecordsRequest() (request *DeleteBatchDomainRecordsRequest) {
-request = &DeleteBatchDomainRecordsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteBatchDomainRecords", "", "")
-return
+	request = &DeleteBatchDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteBatchDomainRecords", "", "")
+	return
 }
 
 func CreateDeleteBatchDomainRecordsResponse() (response *DeleteBatchDomainRecordsResponse) {
-response = &DeleteBatchDomainRecordsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteBatchDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/delete_batch_domains.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteBatchDomains(request *DeleteBatchDomainsRequest) (response *DeleteBatchDomainsResponse, err error) {
-response = CreateDeleteBatchDomainsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteBatchDomainsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DeleteBatchDomainsRequest struct {
-*requests.RpcRequest
-                Domains  string `position:"Query" name:"Domains"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	Domains      string `position:"Query" name:"Domains"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DeleteBatchDomainsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TraceId     string `json:"TraceId" xml:"TraceId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	TraceId   string `json:"TraceId" xml:"TraceId"`
 }
 
 func CreateDeleteBatchDomainsRequest() (request *DeleteBatchDomainsRequest) {
-request = &DeleteBatchDomainsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteBatchDomains", "", "")
-return
+	request = &DeleteBatchDomainsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteBatchDomains", "", "")
+	return
 }
 
 func CreateDeleteBatchDomainsResponse() (response *DeleteBatchDomainsResponse) {
-response = &DeleteBatchDomainsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteBatchDomainsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/delete_domain.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteDomain(request *DeleteDomainRequest) (response *DeleteDomainResponse, err error) {
-response = CreateDeleteDomainResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteDomainResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DeleteDomainRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DeleteDomainResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	DomainName string `json:"DomainName" xml:"DomainName"`
 }
 
 func CreateDeleteDomainRequest() (request *DeleteDomainRequest) {
-request = &DeleteDomainRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomain", "", "")
-return
+	request = &DeleteDomainRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomain", "", "")
+	return
 }
 
 func CreateDeleteDomainResponse() (response *DeleteDomainResponse) {
-response = &DeleteDomainResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteDomainResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/delete_domain_group.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteDomainGroup(request *DeleteDomainGroupRequest) (response *DeleteDomainGroupResponse, err error) {
-response = CreateDeleteDomainGroupResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteDomainGroupResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DeleteDomainGroupRequest struct {
-*requests.RpcRequest
-                GroupId  string `position:"Query" name:"GroupId"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	GroupId      string `position:"Query" name:"GroupId"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DeleteDomainGroupResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            GroupName     string `json:"GroupName" xml:"GroupName"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	GroupName string `json:"GroupName" xml:"GroupName"`
 }
 
 func CreateDeleteDomainGroupRequest() (request *DeleteDomainGroupRequest) {
-request = &DeleteDomainGroupRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomainGroup", "", "")
-return
+	request = &DeleteDomainGroupRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomainGroup", "", "")
+	return
 }
 
 func CreateDeleteDomainGroupResponse() (response *DeleteDomainGroupResponse) {
-response = &DeleteDomainGroupResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteDomainGroupResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/delete_domain_record.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteDomainRecord(request *DeleteDomainRecordRequest) (response *DeleteDomainRecordResponse, err error) {
-response = CreateDeleteDomainRecordResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteDomainRecordResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DeleteDomainRecordRequest struct {
-*requests.RpcRequest
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
-                RecordId  string `position:"Query" name:"RecordId"`
+	*requests.RpcRequest
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
+	RecordId     string `position:"Query" name:"RecordId"`
 }
 
-
 type DeleteDomainRecordResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            RecordId     string `json:"RecordId" xml:"RecordId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	RecordId  string `json:"RecordId" xml:"RecordId"`
 }
 
 func CreateDeleteDomainRecordRequest() (request *DeleteDomainRecordRequest) {
-request = &DeleteDomainRecordRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomainRecord", "", "")
-return
+	request = &DeleteDomainRecordRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteDomainRecord", "", "")
+	return
 }
 
 func CreateDeleteDomainRecordResponse() (response *DeleteDomainRecordResponse) {
-response = &DeleteDomainRecordResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteDomainRecordResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/delete_sub_domain_records.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,81 +16,79 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteSubDomainRecords(request *DeleteSubDomainRecordsRequest) (response *DeleteSubDomainRecordsResponse, err error) {
-response = CreateDeleteSubDomainRecordsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteSubDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DeleteSubDomainRecordsRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                RR  string `position:"Query" name:"RR"`
-                Type  string `position:"Query" name:"Type"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	RR           string `position:"Query" name:"RR"`
+	Type         string `position:"Query" name:"Type"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DeleteSubDomainRecordsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            RR     string `json:"RR" xml:"RR"`
-            TotalCount     string `json:"TotalCount" xml:"TotalCount"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	RR         string `json:"RR" xml:"RR"`
+	TotalCount string `json:"TotalCount" xml:"TotalCount"`
 }
 
 func CreateDeleteSubDomainRecordsRequest() (request *DeleteSubDomainRecordsRequest) {
-request = &DeleteSubDomainRecordsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteSubDomainRecords", "", "")
-return
+	request = &DeleteSubDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DeleteSubDomainRecords", "", "")
+	return
 }
 
 func CreateDeleteSubDomainRecordsResponse() (response *DeleteSubDomainRecordsResponse) {
-response = &DeleteSubDomainRecordsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteSubDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_batch_result.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,87 +16,85 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeBatchResult(request *DescribeBatchResultRequest) (response *DescribeBatchResultResponse, err error) {
-response = CreateDescribeBatchResultResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeBatchResultResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeBatchResultRequest struct {
-*requests.RpcRequest
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
-                TraceId  string `position:"Query" name:"TraceId"`
+	*requests.RpcRequest
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
+	TraceId      string `position:"Query" name:"TraceId"`
 }
 
-
 type DescribeBatchResultResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TraceId     string `json:"TraceId" xml:"TraceId"`
-            Status     int64 `json:"Status" xml:"Status"`
-            BatchCount     int64 `json:"BatchCount" xml:"BatchCount"`
-            SuccessNumber     int64 `json:"SuccessNumber" xml:"SuccessNumber"`
-                FailResults struct {
-                    FailResult []struct {
-            BatchIndex     string `json:"BatchIndex" xml:"BatchIndex"`
-            ErrorCode     string `json:"ErrorCode" xml:"ErrorCode"`
-                    }   `json:"FailResult" xml:"FailResult"`
-                } `json:"FailResults" xml:"FailResults"`
+	*responses.BaseResponse
+	RequestId     string `json:"RequestId" xml:"RequestId"`
+	TraceId       string `json:"TraceId" xml:"TraceId"`
+	Status        int64  `json:"Status" xml:"Status"`
+	BatchCount    int64  `json:"BatchCount" xml:"BatchCount"`
+	SuccessNumber int64  `json:"SuccessNumber" xml:"SuccessNumber"`
+	FailResults   struct {
+		FailResult []struct {
+			BatchIndex string `json:"BatchIndex" xml:"BatchIndex"`
+			ErrorCode  string `json:"ErrorCode" xml:"ErrorCode"`
+		} `json:"FailResult" xml:"FailResult"`
+	} `json:"FailResults" xml:"FailResults"`
 }
 
 func CreateDescribeBatchResultRequest() (request *DescribeBatchResultRequest) {
-request = &DescribeBatchResultRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeBatchResult", "", "")
-return
+	request = &DescribeBatchResultRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeBatchResult", "", "")
+	return
 }
 
 func CreateDescribeBatchResultResponse() (response *DescribeBatchResultResponse) {
-response = &DescribeBatchResultResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeBatchResultResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_d_n_s_s_l_b_sub_domains.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,90 +16,88 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDNSSLBSubDomains(request *DescribeDNSSLBSubDomainsRequest) (response *DescribeDNSSLBSubDomainsResponse, err error) {
-response = CreateDescribeDNSSLBSubDomainsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDNSSLBSubDomainsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDNSSLBSubDomainsRequest struct {
-*requests.RpcRequest
-                PageSize  string `position:"Query" name:"PageSize"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	PageSize     string `position:"Query" name:"PageSize"`
+	DomainName   string `position:"Query" name:"DomainName"`
+	PageNumber   string `position:"Query" name:"PageNumber"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DescribeDNSSLBSubDomainsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
-            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int64 `json:"PageSize" xml:"PageSize"`
-                SlbSubDomains struct {
-                    SlbSubDomain []struct {
-            SubDomain     string `json:"SubDomain" xml:"SubDomain"`
-            RecordCount     int64 `json:"RecordCount" xml:"RecordCount"`
-            Open     bool `json:"Open" xml:"Open"`
-            Type     string `json:"Type" xml:"Type"`
-                    }   `json:"SlbSubDomain" xml:"SlbSubDomain"`
-                } `json:"SlbSubDomains" xml:"SlbSubDomains"`
+	*responses.BaseResponse
+	RequestId     string `json:"RequestId" xml:"RequestId"`
+	TotalCount    int64  `json:"TotalCount" xml:"TotalCount"`
+	PageNumber    int64  `json:"PageNumber" xml:"PageNumber"`
+	PageSize      int64  `json:"PageSize" xml:"PageSize"`
+	SlbSubDomains struct {
+		SlbSubDomain []struct {
+			SubDomain   string `json:"SubDomain" xml:"SubDomain"`
+			RecordCount int64  `json:"RecordCount" xml:"RecordCount"`
+			Open        bool   `json:"Open" xml:"Open"`
+			Type        string `json:"Type" xml:"Type"`
+		} `json:"SlbSubDomain" xml:"SlbSubDomain"`
+	} `json:"SlbSubDomains" xml:"SlbSubDomains"`
 }
 
 func CreateDescribeDNSSLBSubDomainsRequest() (request *DescribeDNSSLBSubDomainsRequest) {
-request = &DescribeDNSSLBSubDomainsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDNSSLBSubDomains", "", "")
-return
+	request = &DescribeDNSSLBSubDomainsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDNSSLBSubDomains", "", "")
+	return
 }
 
 func CreateDescribeDNSSLBSubDomainsResponse() (response *DescribeDNSSLBSubDomainsResponse) {
-response = &DescribeDNSSLBSubDomainsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDNSSLBSubDomainsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_dns_product_instance.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,108 +16,106 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDnsProductInstance(request *DescribeDnsProductInstanceRequest) (response *DescribeDnsProductInstanceResponse, err error) {
-response = CreateDescribeDnsProductInstanceResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDnsProductInstanceResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDnsProductInstanceRequest struct {
-*requests.RpcRequest
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
-                InstanceId  string `position:"Query" name:"InstanceId"`
+	*requests.RpcRequest
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
+	InstanceId   string `position:"Query" name:"InstanceId"`
 }
 
-
 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     int64 `json:"StartTimestamp" xml:"StartTimestamp"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-            EndTimestamp     int64 `json:"EndTimestamp" xml:"EndTimestamp"`
-            Domain     string `json:"Domain" xml:"Domain"`
-            BindCount     int64 `json:"BindCount" xml:"BindCount"`
-            BindUsedCount     int64 `json:"BindUsedCount" xml:"BindUsedCount"`
-            TTLMinValue     int64 `json:"TTLMinValue" xml:"TTLMinValue"`
-            SubDomainLevel     int64 `json:"SubDomainLevel" xml:"SubDomainLevel"`
-            DnsSLBCount     int64 `json:"DnsSLBCount" xml:"DnsSLBCount"`
-            URLForwardCount     int64 `json:"URLForwardCount" xml:"URLForwardCount"`
-            DDosDefendFlow     int64 `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
-            DDosDefendQuery     int64 `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
-            OverseaDDosDefendFlow     int64 `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     int64 `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
-            MonitorFrequency     int64 `json:"MonitorFrequency" xml:"MonitorFrequency"`
-            MonitorTaskCount     int64 `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 struct {
-                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
-                } `json:"DnsServers" xml:"DnsServers"`
+	*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        int64  `json:"StartTimestamp" xml:"StartTimestamp"`
+	EndTime               string `json:"EndTime" xml:"EndTime"`
+	EndTimestamp          int64  `json:"EndTimestamp" xml:"EndTimestamp"`
+	Domain                string `json:"Domain" xml:"Domain"`
+	BindCount             int64  `json:"BindCount" xml:"BindCount"`
+	BindUsedCount         int64  `json:"BindUsedCount" xml:"BindUsedCount"`
+	TTLMinValue           int64  `json:"TTLMinValue" xml:"TTLMinValue"`
+	SubDomainLevel        int64  `json:"SubDomainLevel" xml:"SubDomainLevel"`
+	DnsSLBCount           int64  `json:"DnsSLBCount" xml:"DnsSLBCount"`
+	URLForwardCount       int64  `json:"URLForwardCount" xml:"URLForwardCount"`
+	DDosDefendFlow        int64  `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
+	DDosDefendQuery       int64  `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
+	OverseaDDosDefendFlow int64  `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      int64  `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
+	MonitorFrequency      int64  `json:"MonitorFrequency" xml:"MonitorFrequency"`
+	MonitorTaskCount      int64  `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            struct {
+		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+	} `json:"DnsServers" xml:"DnsServers"`
 }
 
 func CreateDescribeDnsProductInstanceRequest() (request *DescribeDnsProductInstanceRequest) {
-request = &DescribeDnsProductInstanceRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDnsProductInstance", "", "")
-return
+	request = &DescribeDnsProductInstanceRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDnsProductInstance", "", "")
+	return
 }
 
 func CreateDescribeDnsProductInstanceResponse() (response *DescribeDnsProductInstanceResponse) {
-response = &DescribeDnsProductInstanceResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDnsProductInstanceResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_dns_product_instances.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,114 +16,112 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDnsProductInstances(request *DescribeDnsProductInstancesRequest) (response *DescribeDnsProductInstancesResponse, err error) {
-response = CreateDescribeDnsProductInstancesResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDnsProductInstancesResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDnsProductInstancesRequest struct {
-*requests.RpcRequest
-                PageSize  string `position:"Query" name:"PageSize"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                VersionCode  string `position:"Query" name:"VersionCode"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	PageSize     string `position:"Query" name:"PageSize"`
+	PageNumber   string `position:"Query" name:"PageNumber"`
+	VersionCode  string `position:"Query" name:"VersionCode"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DescribeDnsProductInstancesResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
-            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int64 `json:"PageSize" xml:"PageSize"`
-                DnsProducts struct {
-                    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     int64 `json:"StartTimestamp" xml:"StartTimestamp"`
-            EndTimestamp     int64 `json:"EndTimestamp" xml:"EndTimestamp"`
-            Domain     string `json:"Domain" xml:"Domain"`
-            BindCount     int64 `json:"BindCount" xml:"BindCount"`
-            BindUsedCount     int64 `json:"BindUsedCount" xml:"BindUsedCount"`
-            TTLMinValue     int64 `json:"TTLMinValue" xml:"TTLMinValue"`
-            SubDomainLevel     int64 `json:"SubDomainLevel" xml:"SubDomainLevel"`
-            DnsSLBCount     int64 `json:"DnsSLBCount" xml:"DnsSLBCount"`
-            URLForwardCount     int64 `json:"URLForwardCount" xml:"URLForwardCount"`
-            DDosDefendFlow     int64 `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
-            DDosDefendQuery     int64 `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
-            OverseaDDosDefendFlow     int64 `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     int64 `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
-            MonitorFrequency     int64 `json:"MonitorFrequency" xml:"MonitorFrequency"`
-            MonitorTaskCount     int64 `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"`
-                    }   `json:"DnsProduct" xml:"DnsProduct"`
-                } `json:"DnsProducts" xml:"DnsProducts"`
+	*responses.BaseResponse
+	RequestId   string `json:"RequestId" xml:"RequestId"`
+	TotalCount  int64  `json:"TotalCount" xml:"TotalCount"`
+	PageNumber  int64  `json:"PageNumber" xml:"PageNumber"`
+	PageSize    int64  `json:"PageSize" xml:"PageSize"`
+	DnsProducts struct {
+		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        int64  `json:"StartTimestamp" xml:"StartTimestamp"`
+			EndTimestamp          int64  `json:"EndTimestamp" xml:"EndTimestamp"`
+			Domain                string `json:"Domain" xml:"Domain"`
+			BindCount             int64  `json:"BindCount" xml:"BindCount"`
+			BindUsedCount         int64  `json:"BindUsedCount" xml:"BindUsedCount"`
+			TTLMinValue           int64  `json:"TTLMinValue" xml:"TTLMinValue"`
+			SubDomainLevel        int64  `json:"SubDomainLevel" xml:"SubDomainLevel"`
+			DnsSLBCount           int64  `json:"DnsSLBCount" xml:"DnsSLBCount"`
+			URLForwardCount       int64  `json:"URLForwardCount" xml:"URLForwardCount"`
+			DDosDefendFlow        int64  `json:"DDosDefendFlow" xml:"DDosDefendFlow"`
+			DDosDefendQuery       int64  `json:"DDosDefendQuery" xml:"DDosDefendQuery"`
+			OverseaDDosDefendFlow int64  `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      int64  `json:"MonitorNodeCount" xml:"MonitorNodeCount"`
+			MonitorFrequency      int64  `json:"MonitorFrequency" xml:"MonitorFrequency"`
+			MonitorTaskCount      int64  `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"`
+		} `json:"DnsProduct" xml:"DnsProduct"`
+	} `json:"DnsProducts" xml:"DnsProducts"`
 }
 
 func CreateDescribeDnsProductInstancesRequest() (request *DescribeDnsProductInstancesRequest) {
-request = &DescribeDnsProductInstancesRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDnsProductInstances", "", "")
-return
+	request = &DescribeDnsProductInstancesRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDnsProductInstances", "", "")
+	return
 }
 
 func CreateDescribeDnsProductInstancesResponse() (response *DescribeDnsProductInstancesResponse) {
-response = &DescribeDnsProductInstancesResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDnsProductInstancesResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_domain_groups.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,87 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainGroups(request *DescribeDomainGroupsRequest) (response *DescribeDomainGroupsResponse, err error) {
-response = CreateDescribeDomainGroupsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainGroupsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDomainGroupsRequest struct {
-*requests.RpcRequest
-                PageSize  string `position:"Query" name:"PageSize"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                KeyWord  string `position:"Query" name:"KeyWord"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	PageSize     string `position:"Query" name:"PageSize"`
+	PageNumber   string `position:"Query" name:"PageNumber"`
+	KeyWord      string `position:"Query" name:"KeyWord"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DescribeDomainGroupsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
-            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int64 `json:"PageSize" xml:"PageSize"`
-                DomainGroups struct {
-                    DomainGroup []struct {
-            GroupId     string `json:"GroupId" xml:"GroupId"`
-            GroupName     string `json:"GroupName" xml:"GroupName"`
-            DomainCount     int64 `json:"DomainCount" xml:"DomainCount"`
-                    }   `json:"DomainGroup" xml:"DomainGroup"`
-                } `json:"DomainGroups" xml:"DomainGroups"`
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	TotalCount   int64  `json:"TotalCount" xml:"TotalCount"`
+	PageNumber   int64  `json:"PageNumber" xml:"PageNumber"`
+	PageSize     int64  `json:"PageSize" xml:"PageSize"`
+	DomainGroups struct {
+		DomainGroup []struct {
+			GroupId     string `json:"GroupId" xml:"GroupId"`
+			GroupName   string `json:"GroupName" xml:"GroupName"`
+			DomainCount int64  `json:"DomainCount" xml:"DomainCount"`
+		} `json:"DomainGroup" xml:"DomainGroup"`
+	} `json:"DomainGroups" xml:"DomainGroups"`
 }
 
 func CreateDescribeDomainGroupsRequest() (request *DescribeDomainGroupsRequest) {
-request = &DescribeDomainGroupsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainGroups", "", "")
-return
+	request = &DescribeDomainGroupsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainGroups", "", "")
+	return
 }
 
 func CreateDescribeDomainGroupsResponse() (response *DescribeDomainGroupsResponse) {
-response = &DescribeDomainGroupsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainGroupsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_domain_info.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,106 +16,104 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainInfo(request *DescribeDomainInfoRequest) (response *DescribeDomainInfoResponse, err error) {
-response = CreateDescribeDomainInfoResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainInfoResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDomainInfoRequest struct {
-*requests.RpcRequest
-                NeedDetailAttributes  string `position:"Query" name:"NeedDetailAttributes"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	NeedDetailAttributes string `position:"Query" name:"NeedDetailAttributes"`
+	DomainName           string `position:"Query" name:"DomainName"`
+	UserClientIp         string `position:"Query" name:"UserClientIp"`
+	Lang                 string `position:"Query" name:"Lang"`
 }
 
-
 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     int64 `json:"MinTtl" xml:"MinTtl"`
-            RecordLineTreeJson     string `json:"RecordLineTreeJson" xml:"RecordLineTreeJson"`
-            LineType     string `json:"LineType" xml:"LineType"`
-            RegionLines     bool `json:"RegionLines" xml:"RegionLines"`
-                DnsServers struct {
-                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
-                } `json:"DnsServers" xml:"DnsServers"`
-                AvailableTtls struct {
-                AvailableTtl []    string `json:"AvailableTtl" xml:"AvailableTtl"`
-                } `json:"AvailableTtls" xml:"AvailableTtls"`
-                RecordLines struct {
-                    RecordLine []struct {
-            LineCode     string `json:"LineCode" xml:"LineCode"`
-            FatherCode     string `json:"FatherCode" xml:"FatherCode"`
-            LineName     string `json:"LineName" xml:"LineName"`
-            LineDisplayName     string `json:"LineDisplayName" xml:"LineDisplayName"`
-                    }   `json:"RecordLine" xml:"RecordLine"`
-                } `json:"RecordLines" xml:"RecordLines"`
+	*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             int64  `json:"MinTtl" xml:"MinTtl"`
+	RecordLineTreeJson string `json:"RecordLineTreeJson" xml:"RecordLineTreeJson"`
+	LineType           string `json:"LineType" xml:"LineType"`
+	RegionLines        bool   `json:"RegionLines" xml:"RegionLines"`
+	DnsServers         struct {
+		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+	} `json:"DnsServers" xml:"DnsServers"`
+	AvailableTtls struct {
+		AvailableTtl []string `json:"AvailableTtl" xml:"AvailableTtl"`
+	} `json:"AvailableTtls" xml:"AvailableTtls"`
+	RecordLines struct {
+		RecordLine []struct {
+			LineCode        string `json:"LineCode" xml:"LineCode"`
+			FatherCode      string `json:"FatherCode" xml:"FatherCode"`
+			LineName        string `json:"LineName" xml:"LineName"`
+			LineDisplayName string `json:"LineDisplayName" xml:"LineDisplayName"`
+		} `json:"RecordLine" xml:"RecordLine"`
+	} `json:"RecordLines" xml:"RecordLines"`
 }
 
 func CreateDescribeDomainInfoRequest() (request *DescribeDomainInfoRequest) {
-request = &DescribeDomainInfoRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainInfo", "", "")
-return
+	request = &DescribeDomainInfoRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainInfo", "", "")
+	return
 }
 
 func CreateDescribeDomainInfoResponse() (response *DescribeDomainInfoResponse) {
-response = &DescribeDomainInfoResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainInfoResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_domain_logs.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,95 +16,93 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainLogs(request *DescribeDomainLogsRequest) (response *DescribeDomainLogsResponse, err error) {
-response = CreateDescribeDomainLogsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainLogsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDomainLogsRequest struct {
-*requests.RpcRequest
-                PageSize  string `position:"Query" name:"PageSize"`
-                StartDate  string `position:"Query" name:"StartDate"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                KeyWord  string `position:"Query" name:"KeyWord"`
-                GroupId  string `position:"Query" name:"GroupId"`
-                EndDate  string `position:"Query" name:"endDate"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	PageSize     string `position:"Query" name:"PageSize"`
+	StartDate    string `position:"Query" name:"StartDate"`
+	PageNumber   string `position:"Query" name:"PageNumber"`
+	KeyWord      string `position:"Query" name:"KeyWord"`
+	GroupId      string `position:"Query" name:"GroupId"`
+	EndDate      string `position:"Query" name:"endDate"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DescribeDomainLogsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
-            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int64 `json:"PageSize" xml:"PageSize"`
-                DomainLogs struct {
-                    DomainLog []struct {
-            ActionTime     string `json:"ActionTime" xml:"ActionTime"`
-            ActionTimestamp     int64 `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"`
-                    }   `json:"DomainLog" xml:"DomainLog"`
-                } `json:"DomainLogs" xml:"DomainLogs"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	TotalCount int64  `json:"TotalCount" xml:"TotalCount"`
+	PageNumber int64  `json:"PageNumber" xml:"PageNumber"`
+	PageSize   int64  `json:"PageSize" xml:"PageSize"`
+	DomainLogs struct {
+		DomainLog []struct {
+			ActionTime      string `json:"ActionTime" xml:"ActionTime"`
+			ActionTimestamp int64  `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"`
+		} `json:"DomainLog" xml:"DomainLog"`
+	} `json:"DomainLogs" xml:"DomainLogs"`
 }
 
 func CreateDescribeDomainLogsRequest() (request *DescribeDomainLogsRequest) {
-request = &DescribeDomainLogsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainLogs", "", "")
-return
+	request = &DescribeDomainLogsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainLogs", "", "")
+	return
 }
 
 func CreateDescribeDomainLogsResponse() (response *DescribeDomainLogsResponse) {
-response = &DescribeDomainLogsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainLogsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_domain_ns.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,85 +16,83 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainNs(request *DescribeDomainNsRequest) (response *DescribeDomainNsResponse, err error) {
-response = CreateDescribeDomainNsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainNsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDomainNsRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DescribeDomainNsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            AllAliDns     bool `json:"AllAliDns" xml:"AllAliDns"`
-            IncludeAliDns     bool `json:"IncludeAliDns" xml:"IncludeAliDns"`
-                DnsServers struct {
-                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
-                } `json:"DnsServers" xml:"DnsServers"`
-                ExpectDnsServers struct {
-                ExpectDnsServer []    string `json:"ExpectDnsServer" xml:"ExpectDnsServer"`
-                } `json:"ExpectDnsServers" xml:"ExpectDnsServers"`
+	*responses.BaseResponse
+	RequestId     string `json:"RequestId" xml:"RequestId"`
+	AllAliDns     bool   `json:"AllAliDns" xml:"AllAliDns"`
+	IncludeAliDns bool   `json:"IncludeAliDns" xml:"IncludeAliDns"`
+	DnsServers    struct {
+		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+	} `json:"DnsServers" xml:"DnsServers"`
+	ExpectDnsServers struct {
+		ExpectDnsServer []string `json:"ExpectDnsServer" xml:"ExpectDnsServer"`
+	} `json:"ExpectDnsServers" xml:"ExpectDnsServers"`
 }
 
 func CreateDescribeDomainNsRequest() (request *DescribeDomainNsRequest) {
-request = &DescribeDomainNsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainNs", "", "")
-return
+	request = &DescribeDomainNsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainNs", "", "")
+	return
 }
 
 func CreateDescribeDomainNsResponse() (response *DescribeDomainNsResponse) {
-response = &DescribeDomainNsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainNsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_domain_record_info.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,91 +16,89 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainRecordInfo(request *DescribeDomainRecordInfoRequest) (response *DescribeDomainRecordInfoResponse, err error) {
-response = CreateDescribeDomainRecordInfoResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainRecordInfoResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDomainRecordInfoRequest struct {
-*requests.RpcRequest
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
-                RecordId  string `position:"Query" name:"RecordId"`
+	*requests.RpcRequest
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
+	RecordId     string `position:"Query" name:"RecordId"`
 }
 
-
 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     int64 `json:"TTL" xml:"TTL"`
-            Priority     int64 `json:"Priority" xml:"Priority"`
-            Line     string `json:"Line" xml:"Line"`
-            Status     string `json:"Status" xml:"Status"`
-            Locked     bool `json:"Locked" xml:"Locked"`
+	*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        int64  `json:"TTL" xml:"TTL"`
+	Priority   int64  `json:"Priority" xml:"Priority"`
+	Line       string `json:"Line" xml:"Line"`
+	Status     string `json:"Status" xml:"Status"`
+	Locked     bool   `json:"Locked" xml:"Locked"`
 }
 
 func CreateDescribeDomainRecordInfoRequest() (request *DescribeDomainRecordInfoRequest) {
-request = &DescribeDomainRecordInfoRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainRecordInfo", "", "")
-return
+	request = &DescribeDomainRecordInfoRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainRecordInfo", "", "")
+	return
 }
 
 func CreateDescribeDomainRecordInfoResponse() (response *DescribeDomainRecordInfoResponse) {
-response = &DescribeDomainRecordInfoResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainRecordInfoResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_domain_records.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,102 +16,100 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainRecords(request *DescribeDomainRecordsRequest) (response *DescribeDomainRecordsResponse, err error) {
-response = CreateDescribeDomainRecordsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDomainRecordsRequest struct {
-*requests.RpcRequest
-                PageSize  string `position:"Query" name:"PageSize"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                ValueKeyWord  string `position:"Query" name:"ValueKeyWord"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                KeyWord  string `position:"Query" name:"KeyWord"`
-                TypeKeyWord  string `position:"Query" name:"TypeKeyWord"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
-                RRKeyWord  string `position:"Query" name:"RRKeyWord"`
+	*requests.RpcRequest
+	PageSize     string `position:"Query" name:"PageSize"`
+	DomainName   string `position:"Query" name:"DomainName"`
+	ValueKeyWord string `position:"Query" name:"ValueKeyWord"`
+	PageNumber   string `position:"Query" name:"PageNumber"`
+	KeyWord      string `position:"Query" name:"KeyWord"`
+	TypeKeyWord  string `position:"Query" name:"TypeKeyWord"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
+	RRKeyWord    string `position:"Query" name:"RRKeyWord"`
 }
 
-
 type DescribeDomainRecordsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
-            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int64 `json:"PageSize" xml:"PageSize"`
-                DomainRecords struct {
-                    Record []struct {
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            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     int64 `json:"TTL" xml:"TTL"`
-            Priority     int64 `json:"Priority" xml:"Priority"`
-            Line     string `json:"Line" xml:"Line"`
-            Status     string `json:"Status" xml:"Status"`
-            Locked     bool `json:"Locked" xml:"Locked"`
-            Weight     int `json:"Weight" xml:"Weight"`
-            Remark     string `json:"Remark" xml:"Remark"`
-                    }   `json:"Record" xml:"Record"`
-                } `json:"DomainRecords" xml:"DomainRecords"`
+	*responses.BaseResponse
+	RequestId     string `json:"RequestId" xml:"RequestId"`
+	TotalCount    int64  `json:"TotalCount" xml:"TotalCount"`
+	PageNumber    int64  `json:"PageNumber" xml:"PageNumber"`
+	PageSize      int64  `json:"PageSize" xml:"PageSize"`
+	DomainRecords struct {
+		Record []struct {
+			DomainName string `json:"DomainName" xml:"DomainName"`
+			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        int64  `json:"TTL" xml:"TTL"`
+			Priority   int64  `json:"Priority" xml:"Priority"`
+			Line       string `json:"Line" xml:"Line"`
+			Status     string `json:"Status" xml:"Status"`
+			Locked     bool   `json:"Locked" xml:"Locked"`
+			Weight     int    `json:"Weight" xml:"Weight"`
+			Remark     string `json:"Remark" xml:"Remark"`
+		} `json:"Record" xml:"Record"`
+	} `json:"DomainRecords" xml:"DomainRecords"`
 }
 
 func CreateDescribeDomainRecordsRequest() (request *DescribeDomainRecordsRequest) {
-request = &DescribeDomainRecordsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainRecords", "", "")
-return
+	request = &DescribeDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainRecords", "", "")
+	return
 }
 
 func CreateDescribeDomainRecordsResponse() (response *DescribeDomainRecordsResponse) {
-response = &DescribeDomainRecordsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_domain_whois_info.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,87 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainWhoisInfo(request *DescribeDomainWhoisInfoRequest) (response *DescribeDomainWhoisInfoResponse, err error) {
-response = CreateDescribeDomainWhoisInfoResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainWhoisInfoResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDomainWhoisInfoRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                GroupId  string `position:"Query" name:"GroupId"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	GroupId      string `position:"Query" name:"GroupId"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 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 struct {
-                Status []    string `json:"Status" xml:"Status"`
-                } `json:"StatusList" xml:"StatusList"`
-                DnsServers struct {
-                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
-                } `json:"DnsServers" xml:"DnsServers"`
+	*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       struct {
+		Status []string `json:"Status" xml:"Status"`
+	} `json:"StatusList" xml:"StatusList"`
+	DnsServers struct {
+		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+	} `json:"DnsServers" xml:"DnsServers"`
 }
 
 func CreateDescribeDomainWhoisInfoRequest() (request *DescribeDomainWhoisInfoRequest) {
-request = &DescribeDomainWhoisInfoRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainWhoisInfo", "", "")
-return
+	request = &DescribeDomainWhoisInfoRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomainWhoisInfo", "", "")
+	return
 }
 
 func CreateDescribeDomainWhoisInfoResponse() (response *DescribeDomainWhoisInfoResponse) {
-response = &DescribeDomainWhoisInfoResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainWhoisInfoResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_domains.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,104 +16,102 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomains(request *DescribeDomainsRequest) (response *DescribeDomainsResponse, err error) {
-response = CreateDescribeDomainsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeDomainsRequest struct {
-*requests.RpcRequest
-                PageSize  string `position:"Query" name:"PageSize"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                KeyWord  string `position:"Query" name:"KeyWord"`
-                GroupId  string `position:"Query" name:"GroupId"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	PageSize     string `position:"Query" name:"PageSize"`
+	PageNumber   string `position:"Query" name:"PageNumber"`
+	KeyWord      string `position:"Query" name:"KeyWord"`
+	GroupId      string `position:"Query" name:"GroupId"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DescribeDomainsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
-            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int64 `json:"PageSize" xml:"PageSize"`
-                Domains struct {
-                    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     int64 `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 struct {
-                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
-                } `json:"DnsServers" xml:"DnsServers"`
-                    }   `json:"Domain" xml:"Domain"`
-                } `json:"Domains" xml:"Domains"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	TotalCount int64  `json:"TotalCount" xml:"TotalCount"`
+	PageNumber int64  `json:"PageNumber" xml:"PageNumber"`
+	PageSize   int64  `json:"PageSize" xml:"PageSize"`
+	Domains    struct {
+		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     int64  `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      struct {
+				DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+			} `json:"DnsServers" xml:"DnsServers"`
+		} `json:"Domain" xml:"Domain"`
+	} `json:"Domains" xml:"Domains"`
 }
 
 func CreateDescribeDomainsRequest() (request *DescribeDomainsRequest) {
-request = &DescribeDomainsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomains", "", "")
-return
+	request = &DescribeDomainsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeDomains", "", "")
+	return
 }
 
 func CreateDescribeDomainsResponse() (response *DescribeDomainsResponse) {
-response = &DescribeDomainsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_record_logs.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,94 +16,92 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeRecordLogs(request *DescribeRecordLogsRequest) (response *DescribeRecordLogsResponse, err error) {
-response = CreateDescribeRecordLogsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeRecordLogsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeRecordLogsRequest struct {
-*requests.RpcRequest
-                PageSize  string `position:"Query" name:"PageSize"`
-                StartDate  string `position:"Query" name:"StartDate"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                KeyWord  string `position:"Query" name:"KeyWord"`
-                EndDate  string `position:"Query" name:"endDate"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	PageSize     string `position:"Query" name:"PageSize"`
+	StartDate    string `position:"Query" name:"StartDate"`
+	DomainName   string `position:"Query" name:"DomainName"`
+	PageNumber   string `position:"Query" name:"PageNumber"`
+	KeyWord      string `position:"Query" name:"KeyWord"`
+	EndDate      string `position:"Query" name:"endDate"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DescribeRecordLogsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
-            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int64 `json:"PageSize" xml:"PageSize"`
-                RecordLogs struct {
-                    RecordLog []struct {
-            ActionTime     string `json:"ActionTime" xml:"ActionTime"`
-            ActionTimestamp     int64 `json:"ActionTimestamp" xml:"ActionTimestamp"`
-            Action     string `json:"Action" xml:"Action"`
-            Message     string `json:"Message" xml:"Message"`
-            ClientIp     string `json:"ClientIp" xml:"ClientIp"`
-                    }   `json:"RecordLog" xml:"RecordLog"`
-                } `json:"RecordLogs" xml:"RecordLogs"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	TotalCount int64  `json:"TotalCount" xml:"TotalCount"`
+	PageNumber int64  `json:"PageNumber" xml:"PageNumber"`
+	PageSize   int64  `json:"PageSize" xml:"PageSize"`
+	RecordLogs struct {
+		RecordLog []struct {
+			ActionTime      string `json:"ActionTime" xml:"ActionTime"`
+			ActionTimestamp int64  `json:"ActionTimestamp" xml:"ActionTimestamp"`
+			Action          string `json:"Action" xml:"Action"`
+			Message         string `json:"Message" xml:"Message"`
+			ClientIp        string `json:"ClientIp" xml:"ClientIp"`
+		} `json:"RecordLog" xml:"RecordLog"`
+	} `json:"RecordLogs" xml:"RecordLogs"`
 }
 
 func CreateDescribeRecordLogsRequest() (request *DescribeRecordLogsRequest) {
-request = &DescribeRecordLogsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeRecordLogs", "", "")
-return
+	request = &DescribeRecordLogsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeRecordLogs", "", "")
+	return
 }
 
 func CreateDescribeRecordLogsResponse() (response *DescribeRecordLogsResponse) {
-response = &DescribeRecordLogsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeRecordLogsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_sub_domain_records.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,98 +16,96 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeSubDomainRecords(request *DescribeSubDomainRecordsRequest) (response *DescribeSubDomainRecordsResponse, err error) {
-response = CreateDescribeSubDomainRecordsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeSubDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeSubDomainRecordsRequest struct {
-*requests.RpcRequest
-                PageSize  string `position:"Query" name:"PageSize"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                SubDomain  string `position:"Query" name:"SubDomain"`
-                Type  string `position:"Query" name:"Type"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	PageSize     string `position:"Query" name:"PageSize"`
+	PageNumber   string `position:"Query" name:"PageNumber"`
+	SubDomain    string `position:"Query" name:"SubDomain"`
+	Type         string `position:"Query" name:"Type"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DescribeSubDomainRecordsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
-            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int64 `json:"PageSize" xml:"PageSize"`
-                DomainRecords struct {
-                    Record []struct {
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            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     int64 `json:"TTL" xml:"TTL"`
-            Priority     int64 `json:"Priority" xml:"Priority"`
-            Line     string `json:"Line" xml:"Line"`
-            Status     string `json:"Status" xml:"Status"`
-            Locked     bool `json:"Locked" xml:"Locked"`
-            Weight     int `json:"Weight" xml:"Weight"`
-                    }   `json:"Record" xml:"Record"`
-                } `json:"DomainRecords" xml:"DomainRecords"`
+	*responses.BaseResponse
+	RequestId     string `json:"RequestId" xml:"RequestId"`
+	TotalCount    int64  `json:"TotalCount" xml:"TotalCount"`
+	PageNumber    int64  `json:"PageNumber" xml:"PageNumber"`
+	PageSize      int64  `json:"PageSize" xml:"PageSize"`
+	DomainRecords struct {
+		Record []struct {
+			DomainName string `json:"DomainName" xml:"DomainName"`
+			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        int64  `json:"TTL" xml:"TTL"`
+			Priority   int64  `json:"Priority" xml:"Priority"`
+			Line       string `json:"Line" xml:"Line"`
+			Status     string `json:"Status" xml:"Status"`
+			Locked     bool   `json:"Locked" xml:"Locked"`
+			Weight     int    `json:"Weight" xml:"Weight"`
+		} `json:"Record" xml:"Record"`
+	} `json:"DomainRecords" xml:"DomainRecords"`
 }
 
 func CreateDescribeSubDomainRecordsRequest() (request *DescribeSubDomainRecordsRequest) {
-request = &DescribeSubDomainRecordsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeSubDomainRecords", "", "")
-return
+	request = &DescribeSubDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeSubDomainRecords", "", "")
+	return
 }
 
 func CreateDescribeSubDomainRecordsResponse() (response *DescribeSubDomainRecordsResponse) {
-response = &DescribeSubDomainRecordsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeSubDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/describe_support_lines.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,84 +16,82 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeSupportLines(request *DescribeSupportLinesRequest) (response *DescribeSupportLinesResponse, err error) {
-response = CreateDescribeSupportLinesResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeSupportLinesResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type DescribeSupportLinesRequest struct {
-*requests.RpcRequest
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type DescribeSupportLinesResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-                RecordLines struct {
-                    RecordLine []struct {
-            LineCode     string `json:"LineCode" xml:"LineCode"`
-            FatherCode     string `json:"FatherCode" xml:"FatherCode"`
-            LineName     string `json:"LineName" xml:"LineName"`
-            LineDisplayName     string `json:"LineDisplayName" xml:"LineDisplayName"`
-                    }   `json:"RecordLine" xml:"RecordLine"`
-                } `json:"RecordLines" xml:"RecordLines"`
+	*responses.BaseResponse
+	RequestId   string `json:"RequestId" xml:"RequestId"`
+	RecordLines struct {
+		RecordLine []struct {
+			LineCode        string `json:"LineCode" xml:"LineCode"`
+			FatherCode      string `json:"FatherCode" xml:"FatherCode"`
+			LineName        string `json:"LineName" xml:"LineName"`
+			LineDisplayName string `json:"LineDisplayName" xml:"LineDisplayName"`
+		} `json:"RecordLine" xml:"RecordLine"`
+	} `json:"RecordLines" xml:"RecordLines"`
 }
 
 func CreateDescribeSupportLinesRequest() (request *DescribeSupportLinesRequest) {
-request = &DescribeSupportLinesRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeSupportLines", "", "")
-return
+	request = &DescribeSupportLinesRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "DescribeSupportLines", "", "")
+	return
 }
 
 func CreateDescribeSupportLinesResponse() (response *DescribeSupportLinesResponse) {
-response = &DescribeSupportLinesResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeSupportLinesResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/get_main_domain_name.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) GetMainDomainName(request *GetMainDomainNameRequest) (response *GetMainDomainNameResponse, err error) {
-response = CreateGetMainDomainNameResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateGetMainDomainNameResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type GetMainDomainNameRequest struct {
-*requests.RpcRequest
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                InputString  string `position:"Query" name:"InputString"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	InputString  string `position:"Query" name:"InputString"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type GetMainDomainNameResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            RR     string `json:"RR" xml:"RR"`
-            DomainLevel     int64 `json:"DomainLevel" xml:"DomainLevel"`
+	*responses.BaseResponse
+	RequestId   string `json:"RequestId" xml:"RequestId"`
+	DomainName  string `json:"DomainName" xml:"DomainName"`
+	RR          string `json:"RR" xml:"RR"`
+	DomainLevel int64  `json:"DomainLevel" xml:"DomainLevel"`
 }
 
 func CreateGetMainDomainNameRequest() (request *GetMainDomainNameRequest) {
-request = &GetMainDomainNameRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "GetMainDomainName", "", "")
-return
+	request = &GetMainDomainNameRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "GetMainDomainName", "", "")
+	return
 }
 
 func CreateGetMainDomainNameResponse() (response *GetMainDomainNameResponse) {
-response = &GetMainDomainNameResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &GetMainDomainNameResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/modify_hichina_domain_d_n_s.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,83 +16,81 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ModifyHichinaDomainDNS(request *ModifyHichinaDomainDNSRequest) (response *ModifyHichinaDomainDNSResponse, err error) {
-response = CreateModifyHichinaDomainDNSResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateModifyHichinaDomainDNSResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type ModifyHichinaDomainDNSRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type ModifyHichinaDomainDNSResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-                OriginalDnsServers struct {
-                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
-                } `json:"OriginalDnsServers" xml:"OriginalDnsServers"`
-                NewDnsServers struct {
-                DnsServer []    string `json:"DnsServer" xml:"DnsServer"`
-                } `json:"NewDnsServers" xml:"NewDnsServers"`
+	*responses.BaseResponse
+	RequestId          string `json:"RequestId" xml:"RequestId"`
+	OriginalDnsServers struct {
+		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+	} `json:"OriginalDnsServers" xml:"OriginalDnsServers"`
+	NewDnsServers struct {
+		DnsServer []string `json:"DnsServer" xml:"DnsServer"`
+	} `json:"NewDnsServers" xml:"NewDnsServers"`
 }
 
 func CreateModifyHichinaDomainDNSRequest() (request *ModifyHichinaDomainDNSRequest) {
-request = &ModifyHichinaDomainDNSRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "ModifyHichinaDomainDNS", "", "")
-return
+	request = &ModifyHichinaDomainDNSRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "ModifyHichinaDomainDNS", "", "")
+	return
 }
 
 func CreateModifyHichinaDomainDNSResponse() (response *ModifyHichinaDomainDNSResponse) {
-response = &ModifyHichinaDomainDNSResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &ModifyHichinaDomainDNSResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/retrieval_domain_name.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,79 +16,77 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) RetrievalDomainName(request *RetrievalDomainNameRequest) (response *RetrievalDomainNameResponse, err error) {
-response = CreateRetrievalDomainNameResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateRetrievalDomainNameResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type RetrievalDomainNameRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	DomainName   string `position:"Query" name:"DomainName"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type RetrievalDomainNameResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            WhoisEmail     string `json:"WhoisEmail" xml:"WhoisEmail"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	DomainName string `json:"DomainName" xml:"DomainName"`
+	WhoisEmail string `json:"WhoisEmail" xml:"WhoisEmail"`
 }
 
 func CreateRetrievalDomainNameRequest() (request *RetrievalDomainNameRequest) {
-request = &RetrievalDomainNameRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "RetrievalDomainName", "", "")
-return
+	request = &RetrievalDomainNameRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "RetrievalDomainName", "", "")
+	return
 }
 
 func CreateRetrievalDomainNameResponse() (response *RetrievalDomainNameResponse) {
-response = &RetrievalDomainNameResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &RetrievalDomainNameResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/set_d_n_s_s_l_b_status.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) SetDNSSLBStatus(request *SetDNSSLBStatusRequest) (response *SetDNSSLBStatusResponse, err error) {
-response = CreateSetDNSSLBStatusResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateSetDNSSLBStatusResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type SetDNSSLBStatusRequest struct {
-*requests.RpcRequest
-                Open  string `position:"Query" name:"Open"`
-                SubDomain  string `position:"Query" name:"SubDomain"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	Open         string `position:"Query" name:"Open"`
+	SubDomain    string `position:"Query" name:"SubDomain"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type SetDNSSLBStatusResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            RecordCount     int64 `json:"RecordCount" xml:"RecordCount"`
-            Open     bool `json:"Open" xml:"Open"`
+	*responses.BaseResponse
+	RequestId   string `json:"RequestId" xml:"RequestId"`
+	RecordCount int64  `json:"RecordCount" xml:"RecordCount"`
+	Open        bool   `json:"Open" xml:"Open"`
 }
 
 func CreateSetDNSSLBStatusRequest() (request *SetDNSSLBStatusRequest) {
-request = &SetDNSSLBStatusRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "SetDNSSLBStatus", "", "")
-return
+	request = &SetDNSSLBStatusRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "SetDNSSLBStatus", "", "")
+	return
 }
 
 func CreateSetDNSSLBStatusResponse() (response *SetDNSSLBStatusResponse) {
-response = &SetDNSSLBStatusResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &SetDNSSLBStatusResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/set_domain_record_status.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) SetDomainRecordStatus(request *SetDomainRecordStatusRequest) (response *SetDomainRecordStatusResponse, err error) {
-response = CreateSetDomainRecordStatusResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateSetDomainRecordStatusResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 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)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	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)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-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
+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
 }
 
 type SetDomainRecordStatusRequest struct {
-*requests.RpcRequest
-                Status  string `position:"Query" name:"Status"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
-                RecordId  string `position:"Query" name:"RecordId"`
+	*requests.RpcRequest
+	Status       string `position:"Query" name:"Status"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
+	RecordId     string `position:"Query" name:"RecordId"`
 }
 
-
 type SetDomainRecordStatusResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            RecordId     string `json:"RecordId" xml:"RecordId"`
-            Status     string `json:"Status" xml:"Status"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	RecordId  string `json:"RecordId" xml:"RecordId"`
+	Status    string `json:"Status" xml:"Status"`
 }
 
 func CreateSetDomainRecordStatusRequest() (request *SetDomainRecordStatusRequest) {
-request = &SetDomainRecordStatusRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "SetDomainRecordStatus", "", "")
-return
+	request = &SetDomainRecordStatusRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "SetDomainRecordStatus", "", "")
+	return
 }
 
 func CreateSetDomainRecordStatusResponse() (response *SetDomainRecordStatusResponse) {
-response = &SetDomainRecordStatusResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &SetDomainRecordStatusResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/update_batch_domain_records.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) UpdateBatchDomainRecords(request *UpdateBatchDomainRecordsRequest) (response *UpdateBatchDomainRecordsResponse, err error) {
-response = CreateUpdateBatchDomainRecordsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateUpdateBatchDomainRecordsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) UpdateBatchDomainRecordsWithChan(request *UpdateBatchDomainRecordsRequest) (<-chan *UpdateBatchDomainRecordsResponse, <-chan error) {
-responseChan := make(chan *UpdateBatchDomainRecordsResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.UpdateBatchDomainRecords(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *UpdateBatchDomainRecordsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.UpdateBatchDomainRecords(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) UpdateBatchDomainRecordsWithCallback(request *UpdateBatchDomainRecordsRequest, callback func(response *UpdateBatchDomainRecordsResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *UpdateBatchDomainRecordsResponse
-var err error
-defer close(result)
-response, err = client.UpdateBatchDomainRecords(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) UpdateBatchDomainRecordsWithCallback(request *UpdateBatchDomainRecordsRequest, callback func(response *UpdateBatchDomainRecordsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *UpdateBatchDomainRecordsResponse
+		var err error
+		defer close(result)
+		response, err = client.UpdateBatchDomainRecords(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type UpdateBatchDomainRecordsRequest struct {
-*requests.RpcRequest
-                Records  string `position:"Query" name:"Records"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	Records      string `position:"Query" name:"Records"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type UpdateBatchDomainRecordsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            TraceId     string `json:"TraceId" xml:"TraceId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	TraceId   string `json:"TraceId" xml:"TraceId"`
 }
 
 func CreateUpdateBatchDomainRecordsRequest() (request *UpdateBatchDomainRecordsRequest) {
-request = &UpdateBatchDomainRecordsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateBatchDomainRecords", "", "")
-return
+	request = &UpdateBatchDomainRecordsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateBatchDomainRecords", "", "")
+	return
 }
 
 func CreateUpdateBatchDomainRecordsResponse() (response *UpdateBatchDomainRecordsResponse) {
-response = &UpdateBatchDomainRecordsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &UpdateBatchDomainRecordsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/update_d_n_s_s_l_b_weight.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) UpdateDNSSLBWeight(request *UpdateDNSSLBWeightRequest) (response *UpdateDNSSLBWeightResponse, err error) {
-response = CreateUpdateDNSSLBWeightResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateUpdateDNSSLBWeightResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) UpdateDNSSLBWeightWithChan(request *UpdateDNSSLBWeightRequest) (<-chan *UpdateDNSSLBWeightResponse, <-chan error) {
-responseChan := make(chan *UpdateDNSSLBWeightResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.UpdateDNSSLBWeight(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *UpdateDNSSLBWeightResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.UpdateDNSSLBWeight(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) UpdateDNSSLBWeightWithCallback(request *UpdateDNSSLBWeightRequest, callback func(response *UpdateDNSSLBWeightResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *UpdateDNSSLBWeightResponse
-var err error
-defer close(result)
-response, err = client.UpdateDNSSLBWeight(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) UpdateDNSSLBWeightWithCallback(request *UpdateDNSSLBWeightRequest, callback func(response *UpdateDNSSLBWeightResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *UpdateDNSSLBWeightResponse
+		var err error
+		defer close(result)
+		response, err = client.UpdateDNSSLBWeight(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type UpdateDNSSLBWeightRequest struct {
-*requests.RpcRequest
-                Weight  string `position:"Query" name:"Weight"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
-                RecordId  string `position:"Query" name:"RecordId"`
+	*requests.RpcRequest
+	Weight       string `position:"Query" name:"Weight"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
+	RecordId     string `position:"Query" name:"RecordId"`
 }
 
-
 type UpdateDNSSLBWeightResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            RecordId     string `json:"RecordId" xml:"RecordId"`
-            Weight     int `json:"Weight" xml:"Weight"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	RecordId  string `json:"RecordId" xml:"RecordId"`
+	Weight    int    `json:"Weight" xml:"Weight"`
 }
 
 func CreateUpdateDNSSLBWeightRequest() (request *UpdateDNSSLBWeightRequest) {
-request = &UpdateDNSSLBWeightRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDNSSLBWeight", "", "")
-return
+	request = &UpdateDNSSLBWeightRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDNSSLBWeight", "", "")
+	return
 }
 
 func CreateUpdateDNSSLBWeightResponse() (response *UpdateDNSSLBWeightResponse) {
-response = &UpdateDNSSLBWeightResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &UpdateDNSSLBWeightResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/update_domain_group.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) UpdateDomainGroup(request *UpdateDomainGroupRequest) (response *UpdateDomainGroupResponse, err error) {
-response = CreateUpdateDomainGroupResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateUpdateDomainGroupResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) UpdateDomainGroupWithChan(request *UpdateDomainGroupRequest) (<-chan *UpdateDomainGroupResponse, <-chan error) {
-responseChan := make(chan *UpdateDomainGroupResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.UpdateDomainGroup(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *UpdateDomainGroupResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.UpdateDomainGroup(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) UpdateDomainGroupWithCallback(request *UpdateDomainGroupRequest, callback func(response *UpdateDomainGroupResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *UpdateDomainGroupResponse
-var err error
-defer close(result)
-response, err = client.UpdateDomainGroup(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) UpdateDomainGroupWithCallback(request *UpdateDomainGroupRequest, callback func(response *UpdateDomainGroupResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *UpdateDomainGroupResponse
+		var err error
+		defer close(result)
+		response, err = client.UpdateDomainGroup(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type UpdateDomainGroupRequest struct {
-*requests.RpcRequest
-                GroupName  string `position:"Query" name:"GroupName"`
-                GroupId  string `position:"Query" name:"GroupId"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
+	*requests.RpcRequest
+	GroupName    string `position:"Query" name:"GroupName"`
+	GroupId      string `position:"Query" name:"GroupId"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
 }
 
-
 type UpdateDomainGroupResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            GroupId     string `json:"GroupId" xml:"GroupId"`
-            GroupName     string `json:"GroupName" xml:"GroupName"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	GroupId   string `json:"GroupId" xml:"GroupId"`
+	GroupName string `json:"GroupName" xml:"GroupName"`
 }
 
 func CreateUpdateDomainGroupRequest() (request *UpdateDomainGroupRequest) {
-request = &UpdateDomainGroupRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDomainGroup", "", "")
-return
+	request = &UpdateDomainGroupRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDomainGroup", "", "")
+	return
 }
 
 func CreateUpdateDomainGroupResponse() (response *UpdateDomainGroupResponse) {
-response = &UpdateDomainGroupResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &UpdateDomainGroupResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/alidns/update_domain_record.go

@@ -1,4 +1,3 @@
-
 package alidns
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,84 +16,82 @@ package alidns
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) UpdateDomainRecord(request *UpdateDomainRecordRequest) (response *UpdateDomainRecordResponse, err error) {
-response = CreateUpdateDomainRecordResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateUpdateDomainRecordResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) UpdateDomainRecordWithChan(request *UpdateDomainRecordRequest) (<-chan *UpdateDomainRecordResponse, <-chan error) {
-responseChan := make(chan *UpdateDomainRecordResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.UpdateDomainRecord(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *UpdateDomainRecordResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.UpdateDomainRecord(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) UpdateDomainRecordWithCallback(request *UpdateDomainRecordRequest, callback func(response *UpdateDomainRecordResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *UpdateDomainRecordResponse
-var err error
-defer close(result)
-response, err = client.UpdateDomainRecord(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) UpdateDomainRecordWithCallback(request *UpdateDomainRecordRequest, callback func(response *UpdateDomainRecordResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *UpdateDomainRecordResponse
+		var err error
+		defer close(result)
+		response, err = client.UpdateDomainRecord(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type UpdateDomainRecordRequest struct {
-*requests.RpcRequest
-                Priority  string `position:"Query" name:"Priority"`
-                Value  string `position:"Query" name:"Value"`
-                RR  string `position:"Query" name:"RR"`
-                Line  string `position:"Query" name:"Line"`
-                TTL  string `position:"Query" name:"TTL"`
-                Type  string `position:"Query" name:"Type"`
-                UserClientIp  string `position:"Query" name:"UserClientIp"`
-                Lang  string `position:"Query" name:"Lang"`
-                RecordId  string `position:"Query" name:"RecordId"`
+	*requests.RpcRequest
+	Priority     string `position:"Query" name:"Priority"`
+	Value        string `position:"Query" name:"Value"`
+	RR           string `position:"Query" name:"RR"`
+	Line         string `position:"Query" name:"Line"`
+	TTL          string `position:"Query" name:"TTL"`
+	Type         string `position:"Query" name:"Type"`
+	UserClientIp string `position:"Query" name:"UserClientIp"`
+	Lang         string `position:"Query" name:"Lang"`
+	RecordId     string `position:"Query" name:"RecordId"`
 }
 
-
 type UpdateDomainRecordResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            RecordId     string `json:"RecordId" xml:"RecordId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	RecordId  string `json:"RecordId" xml:"RecordId"`
 }
 
 func CreateUpdateDomainRecordRequest() (request *UpdateDomainRecordRequest) {
-request = &UpdateDomainRecordRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDomainRecord", "", "")
-return
+	request = &UpdateDomainRecordRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Alidns", "2015-01-09", "UpdateDomainRecord", "", "")
+	return
 }
 
 func CreateUpdateDomainRecordResponse() (response *UpdateDomainRecordResponse) {
-response = &UpdateDomainRecordResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &UpdateDomainRecordResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/add_cdn_domain.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,87 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddCdnDomain(request *AddCdnDomainRequest) (response *AddCdnDomainResponse, err error) {
-response = CreateAddCdnDomainResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateAddCdnDomainResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) AddCdnDomainWithChan(request *AddCdnDomainRequest) (<-chan *AddCdnDomainResponse, <-chan error) {
-responseChan := make(chan *AddCdnDomainResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.AddCdnDomain(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *AddCdnDomainResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.AddCdnDomain(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) AddCdnDomainWithCallback(request *AddCdnDomainRequest, callback func(response *AddCdnDomainResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *AddCdnDomainResponse
-var err error
-defer close(result)
-response, err = client.AddCdnDomain(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) AddCdnDomainWithCallback(request *AddCdnDomainRequest, callback func(response *AddCdnDomainResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *AddCdnDomainResponse
+		var err error
+		defer close(result)
+		response, err = client.AddCdnDomain(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type AddCdnDomainRequest struct {
-*requests.RpcRequest
-                Region  string `position:"Query" name:"Region"`
-                CheckUrl  string `position:"Query" name:"CheckUrl"`
-                TopLevelDomain  string `position:"Query" name:"TopLevelDomain"`
-                Scope  string `position:"Query" name:"Scope"`
-                ResourceGroupId  string `position:"Query" name:"ResourceGroupId"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                Sources  string `position:"Query" name:"Sources"`
-                SourcePort  string `position:"Query" name:"SourcePort"`
-                Priorities  string `position:"Query" name:"Priorities"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                LiveType  string `position:"Query" name:"LiveType"`
-                CdnType  string `position:"Query" name:"CdnType"`
-                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-                SourceType  string `position:"Query" name:"SourceType"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	Region          string `position:"Query" name:"Region"`
+	CheckUrl        string `position:"Query" name:"CheckUrl"`
+	TopLevelDomain  string `position:"Query" name:"TopLevelDomain"`
+	Scope           string `position:"Query" name:"Scope"`
+	ResourceGroupId string `position:"Query" name:"ResourceGroupId"`
+	OwnerId         string `position:"Query" name:"OwnerId"`
+	Sources         string `position:"Query" name:"Sources"`
+	SourcePort      string `position:"Query" name:"SourcePort"`
+	Priorities      string `position:"Query" name:"Priorities"`
+	DomainName      string `position:"Query" name:"DomainName"`
+	LiveType        string `position:"Query" name:"LiveType"`
+	CdnType         string `position:"Query" name:"CdnType"`
+	OwnerAccount    string `position:"Query" name:"OwnerAccount"`
+	SourceType      string `position:"Query" name:"SourceType"`
+	SecurityToken   string `position:"Query" name:"SecurityToken"`
 }
 
-
 type AddCdnDomainResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddCdnDomainRequest() (request *AddCdnDomainRequest) {
-request = &AddCdnDomainRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "AddCdnDomain", "", "")
-return
+	request = &AddCdnDomainRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "AddCdnDomain", "", "")
+	return
 }
 
 func CreateAddCdnDomainResponse() (response *AddCdnDomainResponse) {
-response = &AddCdnDomainResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &AddCdnDomainResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/add_live_app_record_config.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,81 +16,79 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddLiveAppRecordConfig(request *AddLiveAppRecordConfigRequest) (response *AddLiveAppRecordConfigResponse, err error) {
-response = CreateAddLiveAppRecordConfigResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateAddLiveAppRecordConfigResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) AddLiveAppRecordConfigWithChan(request *AddLiveAppRecordConfigRequest) (<-chan *AddLiveAppRecordConfigResponse, <-chan error) {
-responseChan := make(chan *AddLiveAppRecordConfigResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.AddLiveAppRecordConfig(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *AddLiveAppRecordConfigResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.AddLiveAppRecordConfig(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) AddLiveAppRecordConfigWithCallback(request *AddLiveAppRecordConfigRequest, callback func(response *AddLiveAppRecordConfigResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *AddLiveAppRecordConfigResponse
-var err error
-defer close(result)
-response, err = client.AddLiveAppRecordConfig(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) AddLiveAppRecordConfigWithCallback(request *AddLiveAppRecordConfigRequest, callback func(response *AddLiveAppRecordConfigResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *AddLiveAppRecordConfigResponse
+		var err error
+		defer close(result)
+		response, err = client.AddLiveAppRecordConfig(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type AddLiveAppRecordConfigRequest struct {
-*requests.RpcRequest
-                OssBucket  string `position:"Query" name:"OssBucket"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OssEndpoint  string `position:"Query" name:"OssEndpoint"`
-                AppName  string `position:"Query" name:"AppName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                OssObjectPrefix  string `position:"Query" name:"OssObjectPrefix"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	OssBucket       string `position:"Query" name:"OssBucket"`
+	DomainName      string `position:"Query" name:"DomainName"`
+	OssEndpoint     string `position:"Query" name:"OssEndpoint"`
+	AppName         string `position:"Query" name:"AppName"`
+	OwnerId         string `position:"Query" name:"OwnerId"`
+	OssObjectPrefix string `position:"Query" name:"OssObjectPrefix"`
+	SecurityToken   string `position:"Query" name:"SecurityToken"`
 }
 
-
 type AddLiveAppRecordConfigResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddLiveAppRecordConfigRequest() (request *AddLiveAppRecordConfigRequest) {
-request = &AddLiveAppRecordConfigRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveAppRecordConfig", "", "")
-return
+	request = &AddLiveAppRecordConfigRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveAppRecordConfig", "", "")
+	return
 }
 
 func CreateAddLiveAppRecordConfigResponse() (response *AddLiveAppRecordConfigResponse) {
-response = &AddLiveAppRecordConfigResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &AddLiveAppRecordConfigResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/add_live_app_snapshot_config.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,83 +16,81 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddLiveAppSnapshotConfig(request *AddLiveAppSnapshotConfigRequest) (response *AddLiveAppSnapshotConfigResponse, err error) {
-response = CreateAddLiveAppSnapshotConfigResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateAddLiveAppSnapshotConfigResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) AddLiveAppSnapshotConfigWithChan(request *AddLiveAppSnapshotConfigRequest) (<-chan *AddLiveAppSnapshotConfigResponse, <-chan error) {
-responseChan := make(chan *AddLiveAppSnapshotConfigResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.AddLiveAppSnapshotConfig(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *AddLiveAppSnapshotConfigResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.AddLiveAppSnapshotConfig(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) AddLiveAppSnapshotConfigWithCallback(request *AddLiveAppSnapshotConfigRequest, callback func(response *AddLiveAppSnapshotConfigResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *AddLiveAppSnapshotConfigResponse
-var err error
-defer close(result)
-response, err = client.AddLiveAppSnapshotConfig(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) AddLiveAppSnapshotConfigWithCallback(request *AddLiveAppSnapshotConfigRequest, callback func(response *AddLiveAppSnapshotConfigResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *AddLiveAppSnapshotConfigResponse
+		var err error
+		defer close(result)
+		response, err = client.AddLiveAppSnapshotConfig(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type AddLiveAppSnapshotConfigRequest struct {
-*requests.RpcRequest
-                TimeInterval  string `position:"Query" name:"TimeInterval"`
-                OssBucket  string `position:"Query" name:"OssBucket"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OssEndpoint  string `position:"Query" name:"OssEndpoint"`
-                AppName  string `position:"Query" name:"AppName"`
-                SequenceOssObject  string `position:"Query" name:"SequenceOssObject"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                OverwriteOssObject  string `position:"Query" name:"OverwriteOssObject"`
+	*requests.RpcRequest
+	TimeInterval       string `position:"Query" name:"TimeInterval"`
+	OssBucket          string `position:"Query" name:"OssBucket"`
+	DomainName         string `position:"Query" name:"DomainName"`
+	OssEndpoint        string `position:"Query" name:"OssEndpoint"`
+	AppName            string `position:"Query" name:"AppName"`
+	SequenceOssObject  string `position:"Query" name:"SequenceOssObject"`
+	OwnerId            string `position:"Query" name:"OwnerId"`
+	SecurityToken      string `position:"Query" name:"SecurityToken"`
+	OverwriteOssObject string `position:"Query" name:"OverwriteOssObject"`
 }
 
-
 type AddLiveAppSnapshotConfigResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddLiveAppSnapshotConfigRequest() (request *AddLiveAppSnapshotConfigRequest) {
-request = &AddLiveAppSnapshotConfigRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveAppSnapshotConfig", "", "")
-return
+	request = &AddLiveAppSnapshotConfigRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveAppSnapshotConfig", "", "")
+	return
 }
 
 func CreateAddLiveAppSnapshotConfigResponse() (response *AddLiveAppSnapshotConfigResponse) {
-response = &AddLiveAppSnapshotConfigResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &AddLiveAppSnapshotConfigResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/add_live_domain_mapping.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddLiveDomainMapping(request *AddLiveDomainMappingRequest) (response *AddLiveDomainMappingResponse, err error) {
-response = CreateAddLiveDomainMappingResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateAddLiveDomainMappingResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) AddLiveDomainMappingWithChan(request *AddLiveDomainMappingRequest) (<-chan *AddLiveDomainMappingResponse, <-chan error) {
-responseChan := make(chan *AddLiveDomainMappingResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.AddLiveDomainMapping(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *AddLiveDomainMappingResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.AddLiveDomainMapping(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) AddLiveDomainMappingWithCallback(request *AddLiveDomainMappingRequest, callback func(response *AddLiveDomainMappingResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *AddLiveDomainMappingResponse
-var err error
-defer close(result)
-response, err = client.AddLiveDomainMapping(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) AddLiveDomainMappingWithCallback(request *AddLiveDomainMappingRequest, callback func(response *AddLiveDomainMappingResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *AddLiveDomainMappingResponse
+		var err error
+		defer close(result)
+		response, err = client.AddLiveDomainMapping(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type AddLiveDomainMappingRequest struct {
-*requests.RpcRequest
-                PullDomain  string `position:"Query" name:"PullDomain"`
-                PushDomain  string `position:"Query" name:"PushDomain"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	PullDomain    string `position:"Query" name:"PullDomain"`
+	PushDomain    string `position:"Query" name:"PushDomain"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type AddLiveDomainMappingResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddLiveDomainMappingRequest() (request *AddLiveDomainMappingRequest) {
-request = &AddLiveDomainMappingRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveDomainMapping", "", "")
-return
+	request = &AddLiveDomainMappingRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveDomainMapping", "", "")
+	return
 }
 
 func CreateAddLiveDomainMappingResponse() (response *AddLiveDomainMappingResponse) {
-response = &AddLiveDomainMappingResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &AddLiveDomainMappingResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/add_live_pull_stream_info.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,82 +16,80 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddLivePullStreamInfo(request *AddLivePullStreamInfoRequest) (response *AddLivePullStreamInfoResponse, err error) {
-response = CreateAddLivePullStreamInfoResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateAddLivePullStreamInfoResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) AddLivePullStreamInfoWithChan(request *AddLivePullStreamInfoRequest) (<-chan *AddLivePullStreamInfoResponse, <-chan error) {
-responseChan := make(chan *AddLivePullStreamInfoResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.AddLivePullStreamInfo(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *AddLivePullStreamInfoResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.AddLivePullStreamInfo(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) AddLivePullStreamInfoWithCallback(request *AddLivePullStreamInfoRequest, callback func(response *AddLivePullStreamInfoResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *AddLivePullStreamInfoResponse
-var err error
-defer close(result)
-response, err = client.AddLivePullStreamInfo(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) AddLivePullStreamInfoWithCallback(request *AddLivePullStreamInfoRequest, callback func(response *AddLivePullStreamInfoResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *AddLivePullStreamInfoResponse
+		var err error
+		defer close(result)
+		response, err = client.AddLivePullStreamInfo(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type AddLivePullStreamInfoRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StreamName  string `position:"Query" name:"StreamName"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                SourceUrl  string `position:"Query" name:"SourceUrl"`
-                AppName  string `position:"Query" name:"AppName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StreamName    string `position:"Query" name:"StreamName"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	SourceUrl     string `position:"Query" name:"SourceUrl"`
+	AppName       string `position:"Query" name:"AppName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type AddLivePullStreamInfoResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddLivePullStreamInfoRequest() (request *AddLivePullStreamInfoRequest) {
-request = &AddLivePullStreamInfoRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "AddLivePullStreamInfo", "", "")
-return
+	request = &AddLivePullStreamInfoRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "AddLivePullStreamInfo", "", "")
+	return
 }
 
 func CreateAddLivePullStreamInfoResponse() (response *AddLivePullStreamInfoResponse) {
-response = &AddLivePullStreamInfoResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &AddLivePullStreamInfoResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/add_live_stream_transcode.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,82 +16,80 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) AddLiveStreamTranscode(request *AddLiveStreamTranscodeRequest) (response *AddLiveStreamTranscodeResponse, err error) {
-response = CreateAddLiveStreamTranscodeResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateAddLiveStreamTranscodeResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) AddLiveStreamTranscodeWithChan(request *AddLiveStreamTranscodeRequest) (<-chan *AddLiveStreamTranscodeResponse, <-chan error) {
-responseChan := make(chan *AddLiveStreamTranscodeResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.AddLiveStreamTranscode(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *AddLiveStreamTranscodeResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.AddLiveStreamTranscode(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) AddLiveStreamTranscodeWithCallback(request *AddLiveStreamTranscodeRequest, callback func(response *AddLiveStreamTranscodeResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *AddLiveStreamTranscodeResponse
-var err error
-defer close(result)
-response, err = client.AddLiveStreamTranscode(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) AddLiveStreamTranscodeWithCallback(request *AddLiveStreamTranscodeRequest, callback func(response *AddLiveStreamTranscodeResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *AddLiveStreamTranscodeResponse
+		var err error
+		defer close(result)
+		response, err = client.AddLiveStreamTranscode(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type AddLiveStreamTranscodeRequest struct {
-*requests.RpcRequest
-                Template  string `position:"Query" name:"Template"`
-                App  string `position:"Query" name:"App"`
-                Record  string `position:"Query" name:"Record"`
-                Snapshot  string `position:"Query" name:"Snapshot"`
-                Domain  string `position:"Query" name:"Domain"`
-                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	Template      string `position:"Query" name:"Template"`
+	App           string `position:"Query" name:"App"`
+	Record        string `position:"Query" name:"Record"`
+	Snapshot      string `position:"Query" name:"Snapshot"`
+	Domain        string `position:"Query" name:"Domain"`
+	OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type AddLiveStreamTranscodeResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateAddLiveStreamTranscodeRequest() (request *AddLiveStreamTranscodeRequest) {
-request = &AddLiveStreamTranscodeRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveStreamTranscode", "", "")
-return
+	request = &AddLiveStreamTranscodeRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "AddLiveStreamTranscode", "", "")
+	return
 }
 
 func CreateAddLiveStreamTranscodeResponse() (response *AddLiveStreamTranscodeResponse) {
-response = &AddLiveStreamTranscodeResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &AddLiveStreamTranscodeResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/batch_describe_domain_bps_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,92 +16,90 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) BatchDescribeDomainBpsData(request *BatchDescribeDomainBpsDataRequest) (response *BatchDescribeDomainBpsDataResponse, err error) {
-response = CreateBatchDescribeDomainBpsDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateBatchDescribeDomainBpsDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) BatchDescribeDomainBpsDataWithChan(request *BatchDescribeDomainBpsDataRequest) (<-chan *BatchDescribeDomainBpsDataResponse, <-chan error) {
-responseChan := make(chan *BatchDescribeDomainBpsDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.BatchDescribeDomainBpsData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *BatchDescribeDomainBpsDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.BatchDescribeDomainBpsData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) BatchDescribeDomainBpsDataWithCallback(request *BatchDescribeDomainBpsDataRequest, callback func(response *BatchDescribeDomainBpsDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *BatchDescribeDomainBpsDataResponse
-var err error
-defer close(result)
-response, err = client.BatchDescribeDomainBpsData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) BatchDescribeDomainBpsDataWithCallback(request *BatchDescribeDomainBpsDataRequest, callback func(response *BatchDescribeDomainBpsDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *BatchDescribeDomainBpsDataResponse
+		var err error
+		defer close(result)
+		response, err = client.BatchDescribeDomainBpsData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type BatchDescribeDomainBpsDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                PageSize  string `position:"Query" name:"PageSize"`
-                Version  string `position:"Query" name:"Version"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	PageSize      string `position:"Query" name:"PageSize"`
+	Version       string `position:"Query" name:"Version"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	PageNumber    string `position:"Query" name:"PageNumber"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type BatchDescribeDomainBpsDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            PageNumber     int `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int `json:"PageSize" xml:"PageSize"`
-            TotalCount     int `json:"TotalCount" xml:"TotalCount"`
-                BpsDatas struct {
-                    DataModule []struct {
-            Timestamp     string `json:"Timestamp" xml:"Timestamp"`
-            L1Bps     float64 `json:"L1Bps" xml:"L1Bps"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"BpsDatas" xml:"BpsDatas"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	PageNumber int    `json:"PageNumber" xml:"PageNumber"`
+	PageSize   int    `json:"PageSize" xml:"PageSize"`
+	TotalCount int    `json:"TotalCount" xml:"TotalCount"`
+	BpsDatas   struct {
+		DataModule []struct {
+			Timestamp  string  `json:"Timestamp" xml:"Timestamp"`
+			L1Bps      float64 `json:"L1Bps" xml:"L1Bps"`
+			DomainName string  `json:"DomainName" xml:"DomainName"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"BpsDatas" xml:"BpsDatas"`
 }
 
 func CreateBatchDescribeDomainBpsDataRequest() (request *BatchDescribeDomainBpsDataRequest) {
-request = &BatchDescribeDomainBpsDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "BatchDescribeDomainBpsData", "", "")
-return
+	request = &BatchDescribeDomainBpsDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "BatchDescribeDomainBpsData", "", "")
+	return
 }
 
 func CreateBatchDescribeDomainBpsDataResponse() (response *BatchDescribeDomainBpsDataResponse) {
-response = &BatchDescribeDomainBpsDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &BatchDescribeDomainBpsDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/clear_user_black_list.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,77 +16,75 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ClearUserBlackList(request *ClearUserBlackListRequest) (response *ClearUserBlackListResponse, err error) {
-response = CreateClearUserBlackListResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateClearUserBlackListResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) ClearUserBlackListWithChan(request *ClearUserBlackListRequest) (<-chan *ClearUserBlackListResponse, <-chan error) {
-responseChan := make(chan *ClearUserBlackListResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.ClearUserBlackList(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *ClearUserBlackListResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.ClearUserBlackList(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) ClearUserBlackListWithCallback(request *ClearUserBlackListRequest, callback func(response *ClearUserBlackListResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *ClearUserBlackListResponse
-var err error
-defer close(result)
-response, err = client.ClearUserBlackList(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) ClearUserBlackListWithCallback(request *ClearUserBlackListRequest, callback func(response *ClearUserBlackListResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *ClearUserBlackListResponse
+		var err error
+		defer close(result)
+		response, err = client.ClearUserBlackList(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type ClearUserBlackListRequest struct {
-*requests.RpcRequest
-                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type ClearUserBlackListResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateClearUserBlackListRequest() (request *ClearUserBlackListRequest) {
-request = &ClearUserBlackListRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "ClearUserBlackList", "", "")
-return
+	request = &ClearUserBlackListRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "ClearUserBlackList", "", "")
+	return
 }
 
 func CreateClearUserBlackListResponse() (response *ClearUserBlackListResponse) {
-response = &ClearUserBlackListResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &ClearUserBlackListResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/clear_user_domain_black_list.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) ClearUserDomainBlackList(request *ClearUserDomainBlackListRequest) (response *ClearUserDomainBlackListResponse, err error) {
-response = CreateClearUserDomainBlackListResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateClearUserDomainBlackListResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) ClearUserDomainBlackListWithChan(request *ClearUserDomainBlackListRequest) (<-chan *ClearUserDomainBlackListResponse, <-chan error) {
-responseChan := make(chan *ClearUserDomainBlackListResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.ClearUserDomainBlackList(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *ClearUserDomainBlackListResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.ClearUserDomainBlackList(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) ClearUserDomainBlackListWithCallback(request *ClearUserDomainBlackListRequest, callback func(response *ClearUserDomainBlackListResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *ClearUserDomainBlackListResponse
-var err error
-defer close(result)
-response, err = client.ClearUserDomainBlackList(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) ClearUserDomainBlackListWithCallback(request *ClearUserDomainBlackListRequest, callback func(response *ClearUserDomainBlackListResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *ClearUserDomainBlackListResponse
+		var err error
+		defer close(result)
+		response, err = client.ClearUserDomainBlackList(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type ClearUserDomainBlackListRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type ClearUserDomainBlackListResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateClearUserDomainBlackListRequest() (request *ClearUserDomainBlackListRequest) {
-request = &ClearUserDomainBlackListRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "ClearUserDomainBlackList", "", "")
-return
+	request = &ClearUserDomainBlackListRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "ClearUserDomainBlackList", "", "")
+	return
 }
 
 func CreateClearUserDomainBlackListResponse() (response *ClearUserDomainBlackListResponse) {
-response = &ClearUserDomainBlackListResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &ClearUserDomainBlackListResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/client.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,28 +16,28 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth"
 )
 
 type Client struct {
-    sdk.Client
+	sdk.Client
 }
 
 func NewClient() (client *Client, err error) {
-    client = &Client{}
-    err = client.Init()
-    return
+	client = &Client{}
+	err = client.Init()
+	return
 }
 
 func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error) {
-    client = &Client{}
-    err = client.InitWithOptions(regionId, config, credential)
-    return
+	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
+	client = &Client{}
+	err = client.InitWithAccessKey(regionId, accessKeyId, accessKeySecret)
+	return
 }

services/cdn/create_live_stream_record_index_files.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,92 +16,90 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) CreateLiveStreamRecordIndexFiles(request *CreateLiveStreamRecordIndexFilesRequest) (response *CreateLiveStreamRecordIndexFilesResponse, err error) {
-response = CreateCreateLiveStreamRecordIndexFilesResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateCreateLiveStreamRecordIndexFilesResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) CreateLiveStreamRecordIndexFilesWithChan(request *CreateLiveStreamRecordIndexFilesRequest) (<-chan *CreateLiveStreamRecordIndexFilesResponse, <-chan error) {
-responseChan := make(chan *CreateLiveStreamRecordIndexFilesResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.CreateLiveStreamRecordIndexFiles(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *CreateLiveStreamRecordIndexFilesResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.CreateLiveStreamRecordIndexFiles(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) CreateLiveStreamRecordIndexFilesWithCallback(request *CreateLiveStreamRecordIndexFilesRequest, callback func(response *CreateLiveStreamRecordIndexFilesResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *CreateLiveStreamRecordIndexFilesResponse
-var err error
-defer close(result)
-response, err = client.CreateLiveStreamRecordIndexFiles(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) CreateLiveStreamRecordIndexFilesWithCallback(request *CreateLiveStreamRecordIndexFilesRequest, callback func(response *CreateLiveStreamRecordIndexFilesResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *CreateLiveStreamRecordIndexFilesResponse
+		var err error
+		defer close(result)
+		response, err = client.CreateLiveStreamRecordIndexFiles(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type CreateLiveStreamRecordIndexFilesRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StreamName  string `position:"Query" name:"StreamName"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                OssBucket  string `position:"Query" name:"OssBucket"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OssEndpoint  string `position:"Query" name:"OssEndpoint"`
-                AppName  string `position:"Query" name:"AppName"`
-                OssObject  string `position:"Query" name:"OssObject"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StreamName    string `position:"Query" name:"StreamName"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	OssBucket     string `position:"Query" name:"OssBucket"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OssEndpoint   string `position:"Query" name:"OssEndpoint"`
+	AppName       string `position:"Query" name:"AppName"`
+	OssObject     string `position:"Query" name:"OssObject"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type CreateLiveStreamRecordIndexFilesResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            RecordInfo struct {
-            RecordId     string `json:"RecordId" xml:"RecordId"`
-            RecordUrl     string `json:"RecordUrl" xml:"RecordUrl"`
-            Duration     float64 `json:"Duration" xml:"Duration"`
-            Height     int `json:"Height" xml:"Height"`
-            Width     int `json:"Width" xml:"Width"`
-            CreateTime     string `json:"CreateTime" xml:"CreateTime"`
-            }  `json:"RecordInfo" xml:"RecordInfo"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	RecordInfo struct {
+		RecordId   string  `json:"RecordId" xml:"RecordId"`
+		RecordUrl  string  `json:"RecordUrl" xml:"RecordUrl"`
+		Duration   float64 `json:"Duration" xml:"Duration"`
+		Height     int     `json:"Height" xml:"Height"`
+		Width      int     `json:"Width" xml:"Width"`
+		CreateTime string  `json:"CreateTime" xml:"CreateTime"`
+	} `json:"RecordInfo" xml:"RecordInfo"`
 }
 
 func CreateCreateLiveStreamRecordIndexFilesRequest() (request *CreateLiveStreamRecordIndexFilesRequest) {
-request = &CreateLiveStreamRecordIndexFilesRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "CreateLiveStreamRecordIndexFiles", "", "")
-return
+	request = &CreateLiveStreamRecordIndexFilesRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "CreateLiveStreamRecordIndexFiles", "", "")
+	return
 }
 
 func CreateCreateLiveStreamRecordIndexFilesResponse() (response *CreateLiveStreamRecordIndexFilesResponse) {
-response = &CreateLiveStreamRecordIndexFilesResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &CreateLiveStreamRecordIndexFilesResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/delete_cdn_domain.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteCdnDomain(request *DeleteCdnDomainRequest) (response *DeleteCdnDomainResponse, err error) {
-response = CreateDeleteCdnDomainResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteCdnDomainResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DeleteCdnDomainWithChan(request *DeleteCdnDomainRequest) (<-chan *DeleteCdnDomainResponse, <-chan error) {
-responseChan := make(chan *DeleteCdnDomainResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DeleteCdnDomain(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DeleteCdnDomainResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteCdnDomain(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DeleteCdnDomainWithCallback(request *DeleteCdnDomainRequest, callback func(response *DeleteCdnDomainResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DeleteCdnDomainResponse
-var err error
-defer close(result)
-response, err = client.DeleteCdnDomain(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DeleteCdnDomainWithCallback(request *DeleteCdnDomainRequest, callback func(response *DeleteCdnDomainResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteCdnDomainResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteCdnDomain(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DeleteCdnDomainRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                ResourceGroupId  string `position:"Query" name:"ResourceGroupId"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	DomainName      string `position:"Query" name:"DomainName"`
+	ResourceGroupId string `position:"Query" name:"ResourceGroupId"`
+	OwnerId         string `position:"Query" name:"OwnerId"`
+	SecurityToken   string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DeleteCdnDomainResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteCdnDomainRequest() (request *DeleteCdnDomainRequest) {
-request = &DeleteCdnDomainRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteCdnDomain", "", "")
-return
+	request = &DeleteCdnDomainRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteCdnDomain", "", "")
+	return
 }
 
 func CreateDeleteCdnDomainResponse() (response *DeleteCdnDomainResponse) {
-response = &DeleteCdnDomainResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteCdnDomainResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/delete_http_header_config.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteHttpHeaderConfig(request *DeleteHttpHeaderConfigRequest) (response *DeleteHttpHeaderConfigResponse, err error) {
-response = CreateDeleteHttpHeaderConfigResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteHttpHeaderConfigResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DeleteHttpHeaderConfigWithChan(request *DeleteHttpHeaderConfigRequest) (<-chan *DeleteHttpHeaderConfigResponse, <-chan error) {
-responseChan := make(chan *DeleteHttpHeaderConfigResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DeleteHttpHeaderConfig(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DeleteHttpHeaderConfigResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteHttpHeaderConfig(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DeleteHttpHeaderConfigWithCallback(request *DeleteHttpHeaderConfigRequest, callback func(response *DeleteHttpHeaderConfigResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DeleteHttpHeaderConfigResponse
-var err error
-defer close(result)
-response, err = client.DeleteHttpHeaderConfig(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DeleteHttpHeaderConfigWithCallback(request *DeleteHttpHeaderConfigRequest, callback func(response *DeleteHttpHeaderConfigResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteHttpHeaderConfigResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteHttpHeaderConfig(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DeleteHttpHeaderConfigRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                ConfigID  string `position:"Query" name:"ConfigID"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	DomainName    string `position:"Query" name:"DomainName"`
+	ConfigID      string `position:"Query" name:"ConfigID"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DeleteHttpHeaderConfigResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteHttpHeaderConfigRequest() (request *DeleteHttpHeaderConfigRequest) {
-request = &DeleteHttpHeaderConfigRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteHttpHeaderConfig", "", "")
-return
+	request = &DeleteHttpHeaderConfigRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteHttpHeaderConfig", "", "")
+	return
 }
 
 func CreateDeleteHttpHeaderConfigResponse() (response *DeleteHttpHeaderConfigResponse) {
-response = &DeleteHttpHeaderConfigResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteHttpHeaderConfigResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/delete_live_app_record_config.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteLiveAppRecordConfig(request *DeleteLiveAppRecordConfigRequest) (response *DeleteLiveAppRecordConfigResponse, err error) {
-response = CreateDeleteLiveAppRecordConfigResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteLiveAppRecordConfigResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DeleteLiveAppRecordConfigWithChan(request *DeleteLiveAppRecordConfigRequest) (<-chan *DeleteLiveAppRecordConfigResponse, <-chan error) {
-responseChan := make(chan *DeleteLiveAppRecordConfigResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DeleteLiveAppRecordConfig(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DeleteLiveAppRecordConfigResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteLiveAppRecordConfig(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DeleteLiveAppRecordConfigWithCallback(request *DeleteLiveAppRecordConfigRequest, callback func(response *DeleteLiveAppRecordConfigResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DeleteLiveAppRecordConfigResponse
-var err error
-defer close(result)
-response, err = client.DeleteLiveAppRecordConfig(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DeleteLiveAppRecordConfigWithCallback(request *DeleteLiveAppRecordConfigRequest, callback func(response *DeleteLiveAppRecordConfigResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteLiveAppRecordConfigResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteLiveAppRecordConfig(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DeleteLiveAppRecordConfigRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                AppName  string `position:"Query" name:"AppName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	DomainName    string `position:"Query" name:"DomainName"`
+	AppName       string `position:"Query" name:"AppName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DeleteLiveAppRecordConfigResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteLiveAppRecordConfigRequest() (request *DeleteLiveAppRecordConfigRequest) {
-request = &DeleteLiveAppRecordConfigRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveAppRecordConfig", "", "")
-return
+	request = &DeleteLiveAppRecordConfigRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveAppRecordConfig", "", "")
+	return
 }
 
 func CreateDeleteLiveAppRecordConfigResponse() (response *DeleteLiveAppRecordConfigResponse) {
-response = &DeleteLiveAppRecordConfigResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteLiveAppRecordConfigResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/delete_live_app_snapshot_config.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteLiveAppSnapshotConfig(request *DeleteLiveAppSnapshotConfigRequest) (response *DeleteLiveAppSnapshotConfigResponse, err error) {
-response = CreateDeleteLiveAppSnapshotConfigResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteLiveAppSnapshotConfigResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DeleteLiveAppSnapshotConfigWithChan(request *DeleteLiveAppSnapshotConfigRequest) (<-chan *DeleteLiveAppSnapshotConfigResponse, <-chan error) {
-responseChan := make(chan *DeleteLiveAppSnapshotConfigResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DeleteLiveAppSnapshotConfig(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DeleteLiveAppSnapshotConfigResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteLiveAppSnapshotConfig(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DeleteLiveAppSnapshotConfigWithCallback(request *DeleteLiveAppSnapshotConfigRequest, callback func(response *DeleteLiveAppSnapshotConfigResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DeleteLiveAppSnapshotConfigResponse
-var err error
-defer close(result)
-response, err = client.DeleteLiveAppSnapshotConfig(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DeleteLiveAppSnapshotConfigWithCallback(request *DeleteLiveAppSnapshotConfigRequest, callback func(response *DeleteLiveAppSnapshotConfigResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteLiveAppSnapshotConfigResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteLiveAppSnapshotConfig(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DeleteLiveAppSnapshotConfigRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                AppName  string `position:"Query" name:"AppName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	DomainName    string `position:"Query" name:"DomainName"`
+	AppName       string `position:"Query" name:"AppName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DeleteLiveAppSnapshotConfigResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteLiveAppSnapshotConfigRequest() (request *DeleteLiveAppSnapshotConfigRequest) {
-request = &DeleteLiveAppSnapshotConfigRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveAppSnapshotConfig", "", "")
-return
+	request = &DeleteLiveAppSnapshotConfigRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveAppSnapshotConfig", "", "")
+	return
 }
 
 func CreateDeleteLiveAppSnapshotConfigResponse() (response *DeleteLiveAppSnapshotConfigResponse) {
-response = &DeleteLiveAppSnapshotConfigResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteLiveAppSnapshotConfigResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/delete_live_domain_mapping.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,78 +16,76 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteLiveDomainMapping(request *DeleteLiveDomainMappingRequest) (response *DeleteLiveDomainMappingResponse, err error) {
-response = CreateDeleteLiveDomainMappingResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteLiveDomainMappingResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DeleteLiveDomainMappingWithChan(request *DeleteLiveDomainMappingRequest) (<-chan *DeleteLiveDomainMappingResponse, <-chan error) {
-responseChan := make(chan *DeleteLiveDomainMappingResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DeleteLiveDomainMapping(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DeleteLiveDomainMappingResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteLiveDomainMapping(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DeleteLiveDomainMappingWithCallback(request *DeleteLiveDomainMappingRequest, callback func(response *DeleteLiveDomainMappingResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DeleteLiveDomainMappingResponse
-var err error
-defer close(result)
-response, err = client.DeleteLiveDomainMapping(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DeleteLiveDomainMappingWithCallback(request *DeleteLiveDomainMappingRequest, callback func(response *DeleteLiveDomainMappingResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteLiveDomainMappingResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteLiveDomainMapping(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DeleteLiveDomainMappingRequest struct {
-*requests.RpcRequest
-                PullDomain  string `position:"Query" name:"PullDomain"`
-                PushDomain  string `position:"Query" name:"PushDomain"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	PullDomain    string `position:"Query" name:"PullDomain"`
+	PushDomain    string `position:"Query" name:"PushDomain"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DeleteLiveDomainMappingResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteLiveDomainMappingRequest() (request *DeleteLiveDomainMappingRequest) {
-request = &DeleteLiveDomainMappingRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveDomainMapping", "", "")
-return
+	request = &DeleteLiveDomainMappingRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveDomainMapping", "", "")
+	return
 }
 
 func CreateDeleteLiveDomainMappingResponse() (response *DeleteLiveDomainMappingResponse) {
-response = &DeleteLiveDomainMappingResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteLiveDomainMappingResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/delete_live_pull_stream_info.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,79 +16,77 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteLivePullStreamInfo(request *DeleteLivePullStreamInfoRequest) (response *DeleteLivePullStreamInfoResponse, err error) {
-response = CreateDeleteLivePullStreamInfoResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteLivePullStreamInfoResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DeleteLivePullStreamInfoWithChan(request *DeleteLivePullStreamInfoRequest) (<-chan *DeleteLivePullStreamInfoResponse, <-chan error) {
-responseChan := make(chan *DeleteLivePullStreamInfoResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DeleteLivePullStreamInfo(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DeleteLivePullStreamInfoResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteLivePullStreamInfo(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DeleteLivePullStreamInfoWithCallback(request *DeleteLivePullStreamInfoRequest, callback func(response *DeleteLivePullStreamInfoResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DeleteLivePullStreamInfoResponse
-var err error
-defer close(result)
-response, err = client.DeleteLivePullStreamInfo(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DeleteLivePullStreamInfoWithCallback(request *DeleteLivePullStreamInfoRequest, callback func(response *DeleteLivePullStreamInfoResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteLivePullStreamInfoResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteLivePullStreamInfo(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DeleteLivePullStreamInfoRequest struct {
-*requests.RpcRequest
-                StreamName  string `position:"Query" name:"StreamName"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                AppName  string `position:"Query" name:"AppName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	StreamName    string `position:"Query" name:"StreamName"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	AppName       string `position:"Query" name:"AppName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DeleteLivePullStreamInfoResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteLivePullStreamInfoRequest() (request *DeleteLivePullStreamInfoRequest) {
-request = &DeleteLivePullStreamInfoRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLivePullStreamInfo", "", "")
-return
+	request = &DeleteLivePullStreamInfoRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLivePullStreamInfo", "", "")
+	return
 }
 
 func CreateDeleteLivePullStreamInfoResponse() (response *DeleteLivePullStreamInfoResponse) {
-response = &DeleteLivePullStreamInfoResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteLivePullStreamInfoResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/delete_live_stream_transcode.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,80 +16,78 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DeleteLiveStreamTranscode(request *DeleteLiveStreamTranscodeRequest) (response *DeleteLiveStreamTranscodeResponse, err error) {
-response = CreateDeleteLiveStreamTranscodeResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDeleteLiveStreamTranscodeResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DeleteLiveStreamTranscodeWithChan(request *DeleteLiveStreamTranscodeRequest) (<-chan *DeleteLiveStreamTranscodeResponse, <-chan error) {
-responseChan := make(chan *DeleteLiveStreamTranscodeResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DeleteLiveStreamTranscode(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DeleteLiveStreamTranscodeResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DeleteLiveStreamTranscode(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DeleteLiveStreamTranscodeWithCallback(request *DeleteLiveStreamTranscodeRequest, callback func(response *DeleteLiveStreamTranscodeResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DeleteLiveStreamTranscodeResponse
-var err error
-defer close(result)
-response, err = client.DeleteLiveStreamTranscode(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DeleteLiveStreamTranscodeWithCallback(request *DeleteLiveStreamTranscodeRequest, callback func(response *DeleteLiveStreamTranscodeResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DeleteLiveStreamTranscodeResponse
+		var err error
+		defer close(result)
+		response, err = client.DeleteLiveStreamTranscode(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DeleteLiveStreamTranscodeRequest struct {
-*requests.RpcRequest
-                Template  string `position:"Query" name:"Template"`
-                App  string `position:"Query" name:"App"`
-                Domain  string `position:"Query" name:"Domain"`
-                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	Template      string `position:"Query" name:"Template"`
+	App           string `position:"Query" name:"App"`
+	Domain        string `position:"Query" name:"Domain"`
+	OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DeleteLiveStreamTranscodeResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
 }
 
 func CreateDeleteLiveStreamTranscodeRequest() (request *DeleteLiveStreamTranscodeRequest) {
-request = &DeleteLiveStreamTranscodeRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveStreamTranscode", "", "")
-return
+	request = &DeleteLiveStreamTranscodeRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DeleteLiveStreamTranscode", "", "")
+	return
 }
 
 func CreateDeleteLiveStreamTranscodeResponse() (response *DeleteLiveStreamTranscodeResponse) {
-response = &DeleteLiveStreamTranscodeResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DeleteLiveStreamTranscodeResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_cdn_domain_base_detail.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,91 +16,89 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnDomainBaseDetail(request *DescribeCdnDomainBaseDetailRequest) (response *DescribeCdnDomainBaseDetailResponse, err error) {
-response = CreateDescribeCdnDomainBaseDetailResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeCdnDomainBaseDetailResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeCdnDomainBaseDetailWithChan(request *DescribeCdnDomainBaseDetailRequest) (<-chan *DescribeCdnDomainBaseDetailResponse, <-chan error) {
-responseChan := make(chan *DescribeCdnDomainBaseDetailResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeCdnDomainBaseDetail(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeCdnDomainBaseDetailResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeCdnDomainBaseDetail(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnDomainBaseDetailWithCallback(request *DescribeCdnDomainBaseDetailRequest, callback func(response *DescribeCdnDomainBaseDetailResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeCdnDomainBaseDetailResponse
-var err error
-defer close(result)
-response, err = client.DescribeCdnDomainBaseDetail(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeCdnDomainBaseDetailWithCallback(request *DescribeCdnDomainBaseDetailRequest, callback func(response *DescribeCdnDomainBaseDetailResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeCdnDomainBaseDetailResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeCdnDomainBaseDetail(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeCdnDomainBaseDetailRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeCdnDomainBaseDetailResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainBaseDetailModel struct {
-            Cname     string `json:"Cname" xml:"Cname"`
-            CdnType     string `json:"CdnType" xml:"CdnType"`
-            DomainStatus     string `json:"DomainStatus" xml:"DomainStatus"`
-            SourceType     string `json:"SourceType" xml:"SourceType"`
-            Region     string `json:"Region" xml:"Region"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            Remark     string `json:"Remark" xml:"Remark"`
-            GmtModified     string `json:"GmtModified" xml:"GmtModified"`
-            GmtCreated     string `json:"GmtCreated" xml:"GmtCreated"`
-                Sources struct {
-                Source []    string `json:"Source" xml:"Source"`
-                } `json:"Sources" xml:"Sources"`
-            }  `json:"DomainBaseDetailModel" xml:"DomainBaseDetailModel"`
+	*responses.BaseResponse
+	RequestId             string `json:"RequestId" xml:"RequestId"`
+	DomainBaseDetailModel struct {
+		Cname        string `json:"Cname" xml:"Cname"`
+		CdnType      string `json:"CdnType" xml:"CdnType"`
+		DomainStatus string `json:"DomainStatus" xml:"DomainStatus"`
+		SourceType   string `json:"SourceType" xml:"SourceType"`
+		Region       string `json:"Region" xml:"Region"`
+		DomainName   string `json:"DomainName" xml:"DomainName"`
+		Remark       string `json:"Remark" xml:"Remark"`
+		GmtModified  string `json:"GmtModified" xml:"GmtModified"`
+		GmtCreated   string `json:"GmtCreated" xml:"GmtCreated"`
+		Sources      struct {
+			Source []string `json:"Source" xml:"Source"`
+		} `json:"Sources" xml:"Sources"`
+	} `json:"DomainBaseDetailModel" xml:"DomainBaseDetailModel"`
 }
 
 func CreateDescribeCdnDomainBaseDetailRequest() (request *DescribeCdnDomainBaseDetailRequest) {
-request = &DescribeCdnDomainBaseDetailRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainBaseDetail", "", "")
-return
+	request = &DescribeCdnDomainBaseDetailRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainBaseDetail", "", "")
+	return
 }
 
 func CreateDescribeCdnDomainBaseDetailResponse() (response *DescribeCdnDomainBaseDetailResponse) {
-response = &DescribeCdnDomainBaseDetailResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeCdnDomainBaseDetailResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_cdn_domain_detail.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,107 +16,105 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnDomainDetail(request *DescribeCdnDomainDetailRequest) (response *DescribeCdnDomainDetailResponse, err error) {
-response = CreateDescribeCdnDomainDetailResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeCdnDomainDetailResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeCdnDomainDetailWithChan(request *DescribeCdnDomainDetailRequest) (<-chan *DescribeCdnDomainDetailResponse, <-chan error) {
-responseChan := make(chan *DescribeCdnDomainDetailResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeCdnDomainDetail(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeCdnDomainDetailResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeCdnDomainDetail(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnDomainDetailWithCallback(request *DescribeCdnDomainDetailRequest, callback func(response *DescribeCdnDomainDetailResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeCdnDomainDetailResponse
-var err error
-defer close(result)
-response, err = client.DescribeCdnDomainDetail(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeCdnDomainDetailWithCallback(request *DescribeCdnDomainDetailRequest, callback func(response *DescribeCdnDomainDetailResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeCdnDomainDetailResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeCdnDomainDetail(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeCdnDomainDetailRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeCdnDomainDetailResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            GetDomainDetailModel struct {
-            GmtCreated     string `json:"GmtCreated" xml:"GmtCreated"`
-            GmtModified     string `json:"GmtModified" xml:"GmtModified"`
-            SourceType     string `json:"SourceType" xml:"SourceType"`
-            DomainStatus     string `json:"DomainStatus" xml:"DomainStatus"`
-            SourcePort     int `json:"SourcePort" xml:"SourcePort"`
-            CdnType     string `json:"CdnType" xml:"CdnType"`
-            Cname     string `json:"Cname" xml:"Cname"`
-            HttpsCname     string `json:"HttpsCname" xml:"HttpsCname"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            Description     string `json:"Description" xml:"Description"`
-            ServerCertificateStatus     string `json:"ServerCertificateStatus" xml:"ServerCertificateStatus"`
-            ServerCertificate     string `json:"ServerCertificate" xml:"ServerCertificate"`
-            Region     string `json:"Region" xml:"Region"`
-            Scope     string `json:"Scope" xml:"Scope"`
-            CertificateName     string `json:"CertificateName" xml:"CertificateName"`
-            ResourceGroupId     string `json:"ResourceGroupId" xml:"ResourceGroupId"`
-                Sources struct {
-                Source []    string `json:"Source" xml:"Source"`
-                } `json:"Sources" xml:"Sources"`
-                SourceModels struct {
-                    SourceModel []struct {
-            Content     string `json:"Content" xml:"Content"`
-            Type     string `json:"Type" xml:"Type"`
-            Port     int `json:"Port" xml:"Port"`
-            Enabled     string `json:"Enabled" xml:"Enabled"`
-            Priority     string `json:"Priority" xml:"Priority"`
-                    }   `json:"SourceModel" xml:"SourceModel"`
-                } `json:"SourceModels" xml:"SourceModels"`
-            }  `json:"GetDomainDetailModel" xml:"GetDomainDetailModel"`
+	*responses.BaseResponse
+	RequestId            string `json:"RequestId" xml:"RequestId"`
+	GetDomainDetailModel struct {
+		GmtCreated              string `json:"GmtCreated" xml:"GmtCreated"`
+		GmtModified             string `json:"GmtModified" xml:"GmtModified"`
+		SourceType              string `json:"SourceType" xml:"SourceType"`
+		DomainStatus            string `json:"DomainStatus" xml:"DomainStatus"`
+		SourcePort              int    `json:"SourcePort" xml:"SourcePort"`
+		CdnType                 string `json:"CdnType" xml:"CdnType"`
+		Cname                   string `json:"Cname" xml:"Cname"`
+		HttpsCname              string `json:"HttpsCname" xml:"HttpsCname"`
+		DomainName              string `json:"DomainName" xml:"DomainName"`
+		Description             string `json:"Description" xml:"Description"`
+		ServerCertificateStatus string `json:"ServerCertificateStatus" xml:"ServerCertificateStatus"`
+		ServerCertificate       string `json:"ServerCertificate" xml:"ServerCertificate"`
+		Region                  string `json:"Region" xml:"Region"`
+		Scope                   string `json:"Scope" xml:"Scope"`
+		CertificateName         string `json:"CertificateName" xml:"CertificateName"`
+		ResourceGroupId         string `json:"ResourceGroupId" xml:"ResourceGroupId"`
+		Sources                 struct {
+			Source []string `json:"Source" xml:"Source"`
+		} `json:"Sources" xml:"Sources"`
+		SourceModels struct {
+			SourceModel []struct {
+				Content  string `json:"Content" xml:"Content"`
+				Type     string `json:"Type" xml:"Type"`
+				Port     int    `json:"Port" xml:"Port"`
+				Enabled  string `json:"Enabled" xml:"Enabled"`
+				Priority string `json:"Priority" xml:"Priority"`
+			} `json:"SourceModel" xml:"SourceModel"`
+		} `json:"SourceModels" xml:"SourceModels"`
+	} `json:"GetDomainDetailModel" xml:"GetDomainDetailModel"`
 }
 
 func CreateDescribeCdnDomainDetailRequest() (request *DescribeCdnDomainDetailRequest) {
-request = &DescribeCdnDomainDetailRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainDetail", "", "")
-return
+	request = &DescribeCdnDomainDetailRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainDetail", "", "")
+	return
 }
 
 func CreateDescribeCdnDomainDetailResponse() (response *DescribeCdnDomainDetailResponse) {
-response = &DescribeCdnDomainDetailResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeCdnDomainDetailResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_cdn_domain_logs.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,97 +16,95 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnDomainLogs(request *DescribeCdnDomainLogsRequest) (response *DescribeCdnDomainLogsResponse, err error) {
-response = CreateDescribeCdnDomainLogsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeCdnDomainLogsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeCdnDomainLogsWithChan(request *DescribeCdnDomainLogsRequest) (<-chan *DescribeCdnDomainLogsResponse, <-chan error) {
-responseChan := make(chan *DescribeCdnDomainLogsResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeCdnDomainLogs(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeCdnDomainLogsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeCdnDomainLogs(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnDomainLogsWithCallback(request *DescribeCdnDomainLogsRequest, callback func(response *DescribeCdnDomainLogsResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeCdnDomainLogsResponse
-var err error
-defer close(result)
-response, err = client.DescribeCdnDomainLogs(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeCdnDomainLogsWithCallback(request *DescribeCdnDomainLogsRequest, callback func(response *DescribeCdnDomainLogsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeCdnDomainLogsResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeCdnDomainLogs(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeCdnDomainLogsRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                PageSize  string `position:"Query" name:"PageSize"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                LogDay  string `position:"Query" name:"LogDay"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	PageSize      string `position:"Query" name:"PageSize"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	PageNumber    string `position:"Query" name:"PageNumber"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	LogDay        string `position:"Query" name:"LogDay"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeCdnDomainLogsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            PageNumber     int64 `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int64 `json:"PageSize" xml:"PageSize"`
-            TotalCount     int64 `json:"TotalCount" xml:"TotalCount"`
-            DomainLogModel struct {
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-                DomainLogDetails struct {
-                    DomainLogDetail []struct {
-            LogName     string `json:"LogName" xml:"LogName"`
-            LogPath     string `json:"LogPath" xml:"LogPath"`
-            LogSize     int64 `json:"LogSize" xml:"LogSize"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                    }   `json:"DomainLogDetail" xml:"DomainLogDetail"`
-                } `json:"DomainLogDetails" xml:"DomainLogDetails"`
-            }  `json:"DomainLogModel" xml:"DomainLogModel"`
+	*responses.BaseResponse
+	RequestId      string `json:"RequestId" xml:"RequestId"`
+	PageNumber     int64  `json:"PageNumber" xml:"PageNumber"`
+	PageSize       int64  `json:"PageSize" xml:"PageSize"`
+	TotalCount     int64  `json:"TotalCount" xml:"TotalCount"`
+	DomainLogModel struct {
+		DomainName       string `json:"DomainName" xml:"DomainName"`
+		DomainLogDetails struct {
+			DomainLogDetail []struct {
+				LogName   string `json:"LogName" xml:"LogName"`
+				LogPath   string `json:"LogPath" xml:"LogPath"`
+				LogSize   int64  `json:"LogSize" xml:"LogSize"`
+				StartTime string `json:"StartTime" xml:"StartTime"`
+				EndTime   string `json:"EndTime" xml:"EndTime"`
+			} `json:"DomainLogDetail" xml:"DomainLogDetail"`
+		} `json:"DomainLogDetails" xml:"DomainLogDetails"`
+	} `json:"DomainLogModel" xml:"DomainLogModel"`
 }
 
 func CreateDescribeCdnDomainLogsRequest() (request *DescribeCdnDomainLogsRequest) {
-request = &DescribeCdnDomainLogsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainLogs", "", "")
-return
+	request = &DescribeCdnDomainLogsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnDomainLogs", "", "")
+	return
 }
 
 func CreateDescribeCdnDomainLogsResponse() (response *DescribeCdnDomainLogsResponse) {
-response = &DescribeCdnDomainLogsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeCdnDomainLogsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_cdn_monitor_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,94 +16,92 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnMonitorData(request *DescribeCdnMonitorDataRequest) (response *DescribeCdnMonitorDataResponse, err error) {
-response = CreateDescribeCdnMonitorDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeCdnMonitorDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeCdnMonitorDataWithChan(request *DescribeCdnMonitorDataRequest) (<-chan *DescribeCdnMonitorDataResponse, <-chan error) {
-responseChan := make(chan *DescribeCdnMonitorDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeCdnMonitorData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeCdnMonitorDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeCdnMonitorData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnMonitorDataWithCallback(request *DescribeCdnMonitorDataRequest, callback func(response *DescribeCdnMonitorDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeCdnMonitorDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeCdnMonitorData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeCdnMonitorDataWithCallback(request *DescribeCdnMonitorDataRequest, callback func(response *DescribeCdnMonitorDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeCdnMonitorDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeCdnMonitorData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeCdnMonitorDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                Interval  string `position:"Query" name:"Interval"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	Interval      string `position:"Query" name:"Interval"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeCdnMonitorDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            MonitorInterval     int64 `json:"MonitorInterval" xml:"MonitorInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                MonitorDatas struct {
-                    CDNMonitorData []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            QueryPerSecond     string `json:"QueryPerSecond" xml:"QueryPerSecond"`
-            BytesPerSecond     string `json:"BytesPerSecond" xml:"BytesPerSecond"`
-            BytesHitRate     string `json:"BytesHitRate" xml:"BytesHitRate"`
-            RequestHitRate     string `json:"RequestHitRate" xml:"RequestHitRate"`
-            AverageObjectSize     string `json:"AverageObjectSize" xml:"AverageObjectSize"`
-                    }   `json:"CDNMonitorData" xml:"CDNMonitorData"`
-                } `json:"MonitorDatas" xml:"MonitorDatas"`
+	*responses.BaseResponse
+	RequestId       string `json:"RequestId" xml:"RequestId"`
+	DomainName      string `json:"DomainName" xml:"DomainName"`
+	MonitorInterval int64  `json:"MonitorInterval" xml:"MonitorInterval"`
+	StartTime       string `json:"StartTime" xml:"StartTime"`
+	EndTime         string `json:"EndTime" xml:"EndTime"`
+	MonitorDatas    struct {
+		CDNMonitorData []struct {
+			TimeStamp         string `json:"TimeStamp" xml:"TimeStamp"`
+			QueryPerSecond    string `json:"QueryPerSecond" xml:"QueryPerSecond"`
+			BytesPerSecond    string `json:"BytesPerSecond" xml:"BytesPerSecond"`
+			BytesHitRate      string `json:"BytesHitRate" xml:"BytesHitRate"`
+			RequestHitRate    string `json:"RequestHitRate" xml:"RequestHitRate"`
+			AverageObjectSize string `json:"AverageObjectSize" xml:"AverageObjectSize"`
+		} `json:"CDNMonitorData" xml:"CDNMonitorData"`
+	} `json:"MonitorDatas" xml:"MonitorDatas"`
 }
 
 func CreateDescribeCdnMonitorDataRequest() (request *DescribeCdnMonitorDataRequest) {
-request = &DescribeCdnMonitorDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnMonitorData", "", "")
-return
+	request = &DescribeCdnMonitorDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnMonitorData", "", "")
+	return
 }
 
 func CreateDescribeCdnMonitorDataResponse() (response *DescribeCdnMonitorDataResponse) {
-response = &DescribeCdnMonitorDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeCdnMonitorDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_cdn_region_and_isp.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,88 +16,86 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnRegionAndIsp(request *DescribeCdnRegionAndIspRequest) (response *DescribeCdnRegionAndIspResponse, err error) {
-response = CreateDescribeCdnRegionAndIspResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeCdnRegionAndIspResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeCdnRegionAndIspWithChan(request *DescribeCdnRegionAndIspRequest) (<-chan *DescribeCdnRegionAndIspResponse, <-chan error) {
-responseChan := make(chan *DescribeCdnRegionAndIspResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeCdnRegionAndIsp(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeCdnRegionAndIspResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeCdnRegionAndIsp(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnRegionAndIspWithCallback(request *DescribeCdnRegionAndIspRequest, callback func(response *DescribeCdnRegionAndIspResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeCdnRegionAndIspResponse
-var err error
-defer close(result)
-response, err = client.DescribeCdnRegionAndIsp(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeCdnRegionAndIspWithCallback(request *DescribeCdnRegionAndIspRequest, callback func(response *DescribeCdnRegionAndIspResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeCdnRegionAndIspResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeCdnRegionAndIsp(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeCdnRegionAndIspRequest struct {
-*requests.RpcRequest
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeCdnRegionAndIspResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-                Regions struct {
-                    Region []struct {
-            NameZh     string `json:"NameZh" xml:"NameZh"`
-            NameEn     string `json:"NameEn" xml:"NameEn"`
-                    }   `json:"Region" xml:"Region"`
-                } `json:"Regions" xml:"Regions"`
-                Isps struct {
-                    Isp []struct {
-            NameZh     string `json:"NameZh" xml:"NameZh"`
-            NameEn     string `json:"NameEn" xml:"NameEn"`
-                    }   `json:"Isp" xml:"Isp"`
-                } `json:"Isps" xml:"Isps"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	Regions   struct {
+		Region []struct {
+			NameZh string `json:"NameZh" xml:"NameZh"`
+			NameEn string `json:"NameEn" xml:"NameEn"`
+		} `json:"Region" xml:"Region"`
+	} `json:"Regions" xml:"Regions"`
+	Isps struct {
+		Isp []struct {
+			NameZh string `json:"NameZh" xml:"NameZh"`
+			NameEn string `json:"NameEn" xml:"NameEn"`
+		} `json:"Isp" xml:"Isp"`
+	} `json:"Isps" xml:"Isps"`
 }
 
 func CreateDescribeCdnRegionAndIspRequest() (request *DescribeCdnRegionAndIspRequest) {
-request = &DescribeCdnRegionAndIspRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnRegionAndIsp", "", "")
-return
+	request = &DescribeCdnRegionAndIspRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnRegionAndIsp", "", "")
+	return
 }
 
 func CreateDescribeCdnRegionAndIspResponse() (response *DescribeCdnRegionAndIspResponse) {
-response = &DescribeCdnRegionAndIspResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeCdnRegionAndIspResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_cdn_service.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,86 +16,84 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnService(request *DescribeCdnServiceRequest) (response *DescribeCdnServiceResponse, err error) {
-response = CreateDescribeCdnServiceResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeCdnServiceResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeCdnServiceWithChan(request *DescribeCdnServiceRequest) (<-chan *DescribeCdnServiceResponse, <-chan error) {
-responseChan := make(chan *DescribeCdnServiceResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeCdnService(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeCdnServiceResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeCdnService(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnServiceWithCallback(request *DescribeCdnServiceRequest, callback func(response *DescribeCdnServiceResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeCdnServiceResponse
-var err error
-defer close(result)
-response, err = client.DescribeCdnService(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeCdnServiceWithCallback(request *DescribeCdnServiceRequest, callback func(response *DescribeCdnServiceResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeCdnServiceResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeCdnService(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeCdnServiceRequest struct {
-*requests.RpcRequest
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeCdnServiceResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            InstanceId     string `json:"InstanceId" xml:"InstanceId"`
-            InternetChargeType     string `json:"InternetChargeType" xml:"InternetChargeType"`
-            OpeningTime     string `json:"OpeningTime" xml:"OpeningTime"`
-            ChangingChargeType     string `json:"ChangingChargeType" xml:"ChangingChargeType"`
-            ChangingAffectTime     string `json:"ChangingAffectTime" xml:"ChangingAffectTime"`
-                OperationLocks struct {
-                    LockReason []struct {
-            LockReason     string `json:"LockReason" xml:"LockReason"`
-                    }   `json:"LockReason" xml:"LockReason"`
-                } `json:"OperationLocks" xml:"OperationLocks"`
+	*responses.BaseResponse
+	RequestId          string `json:"RequestId" xml:"RequestId"`
+	InstanceId         string `json:"InstanceId" xml:"InstanceId"`
+	InternetChargeType string `json:"InternetChargeType" xml:"InternetChargeType"`
+	OpeningTime        string `json:"OpeningTime" xml:"OpeningTime"`
+	ChangingChargeType string `json:"ChangingChargeType" xml:"ChangingChargeType"`
+	ChangingAffectTime string `json:"ChangingAffectTime" xml:"ChangingAffectTime"`
+	OperationLocks     struct {
+		LockReason []struct {
+			LockReason string `json:"LockReason" xml:"LockReason"`
+		} `json:"LockReason" xml:"LockReason"`
+	} `json:"OperationLocks" xml:"OperationLocks"`
 }
 
 func CreateDescribeCdnServiceRequest() (request *DescribeCdnServiceRequest) {
-request = &DescribeCdnServiceRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnService", "", "")
-return
+	request = &DescribeCdnServiceRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnService", "", "")
+	return
 }
 
 func CreateDescribeCdnServiceResponse() (response *DescribeCdnServiceResponse) {
-response = &DescribeCdnServiceResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeCdnServiceResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_cdn_types.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,83 +16,81 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeCdnTypes(request *DescribeCdnTypesRequest) (response *DescribeCdnTypesResponse, err error) {
-response = CreateDescribeCdnTypesResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeCdnTypesResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeCdnTypesWithChan(request *DescribeCdnTypesRequest) (<-chan *DescribeCdnTypesResponse, <-chan error) {
-responseChan := make(chan *DescribeCdnTypesResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeCdnTypes(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeCdnTypesResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeCdnTypes(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeCdnTypesWithCallback(request *DescribeCdnTypesRequest, callback func(response *DescribeCdnTypesResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeCdnTypesResponse
-var err error
-defer close(result)
-response, err = client.DescribeCdnTypes(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeCdnTypesWithCallback(request *DescribeCdnTypesRequest, callback func(response *DescribeCdnTypesResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeCdnTypesResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeCdnTypes(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeCdnTypesRequest struct {
-*requests.RpcRequest
-                OwnerAccount  string `position:"Query" name:"OwnerAccount"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	OwnerAccount  string `position:"Query" name:"OwnerAccount"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeCdnTypesResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-                CdnTypes struct {
-                    CdnType []struct {
-            Type     string `json:"Type" xml:"Type"`
-            Desc     string `json:"Desc" xml:"Desc"`
-                    }   `json:"CdnType" xml:"CdnType"`
-                } `json:"CdnTypes" xml:"CdnTypes"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	CdnTypes  struct {
+		CdnType []struct {
+			Type string `json:"Type" xml:"Type"`
+			Desc string `json:"Desc" xml:"Desc"`
+		} `json:"CdnType" xml:"CdnType"`
+	} `json:"CdnTypes" xml:"CdnTypes"`
 }
 
 func CreateDescribeCdnTypesRequest() (request *DescribeCdnTypesRequest) {
-request = &DescribeCdnTypesRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnTypes", "", "")
-return
+	request = &DescribeCdnTypesRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeCdnTypes", "", "")
+	return
 }
 
 func CreateDescribeCdnTypesResponse() (response *DescribeCdnTypesResponse) {
-response = &DescribeCdnTypesResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeCdnTypesResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_average_response_time.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,91 +16,89 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainAverageResponseTime(request *DescribeDomainAverageResponseTimeRequest) (response *DescribeDomainAverageResponseTimeResponse, err error) {
-response = CreateDescribeDomainAverageResponseTimeResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainAverageResponseTimeResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainAverageResponseTimeWithChan(request *DescribeDomainAverageResponseTimeRequest) (<-chan *DescribeDomainAverageResponseTimeResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainAverageResponseTimeResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainAverageResponseTime(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainAverageResponseTimeResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainAverageResponseTime(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainAverageResponseTimeWithCallback(request *DescribeDomainAverageResponseTimeRequest, callback func(response *DescribeDomainAverageResponseTimeResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainAverageResponseTimeResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainAverageResponseTime(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainAverageResponseTimeWithCallback(request *DescribeDomainAverageResponseTimeRequest, callback func(response *DescribeDomainAverageResponseTimeResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainAverageResponseTimeResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainAverageResponseTime(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainAverageResponseTimeRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                Interval  string `position:"Query" name:"Interval"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                TimeMerge  string `position:"Query" name:"TimeMerge"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	Interval      string `position:"Query" name:"Interval"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
+	TimeMerge     string `position:"Query" name:"TimeMerge"`
 }
 
-
 type DescribeDomainAverageResponseTimeResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                AvgRTPerInterval struct {
-                    DataModule []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"AvgRTPerInterval" xml:"AvgRTPerInterval"`
+	*responses.BaseResponse
+	RequestId        string `json:"RequestId" xml:"RequestId"`
+	DomainName       string `json:"DomainName" xml:"DomainName"`
+	DataInterval     string `json:"DataInterval" xml:"DataInterval"`
+	StartTime        string `json:"StartTime" xml:"StartTime"`
+	EndTime          string `json:"EndTime" xml:"EndTime"`
+	AvgRTPerInterval struct {
+		DataModule []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     string `json:"Value" xml:"Value"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"AvgRTPerInterval" xml:"AvgRTPerInterval"`
 }
 
 func CreateDescribeDomainAverageResponseTimeRequest() (request *DescribeDomainAverageResponseTimeRequest) {
-request = &DescribeDomainAverageResponseTimeRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainAverageResponseTime", "", "")
-return
+	request = &DescribeDomainAverageResponseTimeRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainAverageResponseTime", "", "")
+	return
 }
 
 func CreateDescribeDomainAverageResponseTimeResponse() (response *DescribeDomainAverageResponseTimeResponse) {
-response = &DescribeDomainAverageResponseTimeResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainAverageResponseTimeResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_bps_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,116 +16,114 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainBpsData(request *DescribeDomainBpsDataRequest) (response *DescribeDomainBpsDataResponse, err error) {
-response = CreateDescribeDomainBpsDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainBpsDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainBpsDataWithChan(request *DescribeDomainBpsDataRequest) (<-chan *DescribeDomainBpsDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainBpsDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainBpsData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainBpsDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainBpsData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainBpsDataWithCallback(request *DescribeDomainBpsDataRequest, callback func(response *DescribeDomainBpsDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainBpsDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainBpsData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainBpsDataWithCallback(request *DescribeDomainBpsDataRequest, callback func(response *DescribeDomainBpsDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainBpsDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainBpsData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainBpsDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                Interval  string `position:"Query" name:"Interval"`
-                FixTimeGap  string `position:"Query" name:"FixTimeGap"`
-                LocationNameEn  string `position:"Query" name:"LocationNameEn"`
-                IspNameEn  string `position:"Query" name:"IspNameEn"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                DomainType  string `position:"Query" name:"DomainType"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                TimeMerge  string `position:"Query" name:"TimeMerge"`
+	*requests.RpcRequest
+	EndTime        string `position:"Query" name:"EndTime"`
+	StartTime      string `position:"Query" name:"StartTime"`
+	Interval       string `position:"Query" name:"Interval"`
+	FixTimeGap     string `position:"Query" name:"FixTimeGap"`
+	LocationNameEn string `position:"Query" name:"LocationNameEn"`
+	IspNameEn      string `position:"Query" name:"IspNameEn"`
+	OwnerId        string `position:"Query" name:"OwnerId"`
+	DomainType     string `position:"Query" name:"DomainType"`
+	DomainName     string `position:"Query" name:"DomainName"`
+	SecurityToken  string `position:"Query" name:"SecurityToken"`
+	TimeMerge      string `position:"Query" name:"TimeMerge"`
 }
 
-
 type DescribeDomainBpsDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-            LocationNameEn     string `json:"LocationNameEn" xml:"LocationNameEn"`
-            IspNameEn     string `json:"IspNameEn" xml:"IspNameEn"`
-            LocationName     string `json:"LocationName" xml:"LocationName"`
-            IspName     string `json:"IspName" xml:"IspName"`
-                BpsDataPerInterval struct {
-                    DataModule []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-            DomesticValue     string `json:"DomesticValue" xml:"DomesticValue"`
-            OverseasValue     string `json:"OverseasValue" xml:"OverseasValue"`
-            DynamicValue     string `json:"DynamicValue" xml:"DynamicValue"`
-            DynamicDomesticValue     string `json:"DynamicDomesticValue" xml:"DynamicDomesticValue"`
-            DynamicOverseasValue     string `json:"DynamicOverseasValue" xml:"DynamicOverseasValue"`
-            StaticValue     string `json:"StaticValue" xml:"StaticValue"`
-            StaticDomesticValue     string `json:"StaticDomesticValue" xml:"StaticDomesticValue"`
-            StaticOverseasValue     string `json:"StaticOverseasValue" xml:"StaticOverseasValue"`
-            L2Value     string `json:"L2Value" xml:"L2Value"`
-            DomesticL2Value     string `json:"DomesticL2Value" xml:"DomesticL2Value"`
-            OverseasL2Value     string `json:"OverseasL2Value" xml:"OverseasL2Value"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"BpsDataPerInterval" xml:"BpsDataPerInterval"`
-                SupplyBpsDatas struct {
-                    DataModule []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"SupplyBpsDatas" xml:"SupplyBpsDatas"`
+	*responses.BaseResponse
+	RequestId          string `json:"RequestId" xml:"RequestId"`
+	DomainName         string `json:"DomainName" xml:"DomainName"`
+	DataInterval       string `json:"DataInterval" xml:"DataInterval"`
+	StartTime          string `json:"StartTime" xml:"StartTime"`
+	EndTime            string `json:"EndTime" xml:"EndTime"`
+	LocationNameEn     string `json:"LocationNameEn" xml:"LocationNameEn"`
+	IspNameEn          string `json:"IspNameEn" xml:"IspNameEn"`
+	LocationName       string `json:"LocationName" xml:"LocationName"`
+	IspName            string `json:"IspName" xml:"IspName"`
+	BpsDataPerInterval struct {
+		DataModule []struct {
+			TimeStamp            string `json:"TimeStamp" xml:"TimeStamp"`
+			Value                string `json:"Value" xml:"Value"`
+			DomesticValue        string `json:"DomesticValue" xml:"DomesticValue"`
+			OverseasValue        string `json:"OverseasValue" xml:"OverseasValue"`
+			DynamicValue         string `json:"DynamicValue" xml:"DynamicValue"`
+			DynamicDomesticValue string `json:"DynamicDomesticValue" xml:"DynamicDomesticValue"`
+			DynamicOverseasValue string `json:"DynamicOverseasValue" xml:"DynamicOverseasValue"`
+			StaticValue          string `json:"StaticValue" xml:"StaticValue"`
+			StaticDomesticValue  string `json:"StaticDomesticValue" xml:"StaticDomesticValue"`
+			StaticOverseasValue  string `json:"StaticOverseasValue" xml:"StaticOverseasValue"`
+			L2Value              string `json:"L2Value" xml:"L2Value"`
+			DomesticL2Value      string `json:"DomesticL2Value" xml:"DomesticL2Value"`
+			OverseasL2Value      string `json:"OverseasL2Value" xml:"OverseasL2Value"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"BpsDataPerInterval" xml:"BpsDataPerInterval"`
+	SupplyBpsDatas struct {
+		DataModule []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     string `json:"Value" xml:"Value"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"SupplyBpsDatas" xml:"SupplyBpsDatas"`
 }
 
 func CreateDescribeDomainBpsDataRequest() (request *DescribeDomainBpsDataRequest) {
-request = &DescribeDomainBpsDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainBpsData", "", "")
-return
+	request = &DescribeDomainBpsDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainBpsData", "", "")
+	return
 }
 
 func CreateDescribeDomainBpsDataResponse() (response *DescribeDomainBpsDataResponse) {
-response = &DescribeDomainBpsDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainBpsDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_bps_data_by_time_stamp.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,87 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainBpsDataByTimeStamp(request *DescribeDomainBpsDataByTimeStampRequest) (response *DescribeDomainBpsDataByTimeStampResponse, err error) {
-response = CreateDescribeDomainBpsDataByTimeStampResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainBpsDataByTimeStampResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainBpsDataByTimeStampWithChan(request *DescribeDomainBpsDataByTimeStampRequest) (<-chan *DescribeDomainBpsDataByTimeStampResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainBpsDataByTimeStampResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainBpsDataByTimeStamp(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainBpsDataByTimeStampResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainBpsDataByTimeStamp(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainBpsDataByTimeStampWithCallback(request *DescribeDomainBpsDataByTimeStampRequest, callback func(response *DescribeDomainBpsDataByTimeStampResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainBpsDataByTimeStampResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainBpsDataByTimeStamp(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainBpsDataByTimeStampWithCallback(request *DescribeDomainBpsDataByTimeStampRequest, callback func(response *DescribeDomainBpsDataByTimeStampResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainBpsDataByTimeStampResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainBpsDataByTimeStamp(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainBpsDataByTimeStampRequest struct {
-*requests.RpcRequest
-                IspNames  string `position:"Query" name:"IspNames"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                LocationNames  string `position:"Query" name:"LocationNames"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                TimePoint  string `position:"Query" name:"TimePoint"`
+	*requests.RpcRequest
+	IspNames      string `position:"Query" name:"IspNames"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	LocationNames string `position:"Query" name:"LocationNames"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
+	TimePoint     string `position:"Query" name:"TimePoint"`
 }
 
-
 type DescribeDomainBpsDataByTimeStampResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-                BpsDataList struct {
-                    BpsDataModel []struct {
-            LocationName     string `json:"LocationName" xml:"LocationName"`
-            IspName     string `json:"IspName" xml:"IspName"`
-            Bps     int64 `json:"Bps" xml:"Bps"`
-                    }   `json:"BpsDataModel" xml:"BpsDataModel"`
-                } `json:"BpsDataList" xml:"BpsDataList"`
+	*responses.BaseResponse
+	RequestId   string `json:"RequestId" xml:"RequestId"`
+	DomainName  string `json:"DomainName" xml:"DomainName"`
+	TimeStamp   string `json:"TimeStamp" xml:"TimeStamp"`
+	BpsDataList struct {
+		BpsDataModel []struct {
+			LocationName string `json:"LocationName" xml:"LocationName"`
+			IspName      string `json:"IspName" xml:"IspName"`
+			Bps          int64  `json:"Bps" xml:"Bps"`
+		} `json:"BpsDataModel" xml:"BpsDataModel"`
+	} `json:"BpsDataList" xml:"BpsDataList"`
 }
 
 func CreateDescribeDomainBpsDataByTimeStampRequest() (request *DescribeDomainBpsDataByTimeStampRequest) {
-request = &DescribeDomainBpsDataByTimeStampRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainBpsDataByTimeStamp", "", "")
-return
+	request = &DescribeDomainBpsDataByTimeStampRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainBpsDataByTimeStamp", "", "")
+	return
 }
 
 func CreateDescribeDomainBpsDataByTimeStampResponse() (response *DescribeDomainBpsDataByTimeStampResponse) {
-response = &DescribeDomainBpsDataByTimeStampResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainBpsDataByTimeStampResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_c_c_attack_info.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,96 +16,94 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainCCAttackInfo(request *DescribeDomainCCAttackInfoRequest) (response *DescribeDomainCCAttackInfoResponse, err error) {
-response = CreateDescribeDomainCCAttackInfoResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainCCAttackInfoResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainCCAttackInfoWithChan(request *DescribeDomainCCAttackInfoRequest) (<-chan *DescribeDomainCCAttackInfoResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainCCAttackInfoResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainCCAttackInfo(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainCCAttackInfoResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainCCAttackInfo(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainCCAttackInfoWithCallback(request *DescribeDomainCCAttackInfoRequest, callback func(response *DescribeDomainCCAttackInfoResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainCCAttackInfoResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainCCAttackInfo(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainCCAttackInfoWithCallback(request *DescribeDomainCCAttackInfoRequest, callback func(response *DescribeDomainCCAttackInfoResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainCCAttackInfoResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainCCAttackInfo(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainCCAttackInfoRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainCCAttackInfoResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                AttackIpDataList struct {
-                    AttackIpDatas []struct {
-            Ip     string `json:"Ip" xml:"Ip"`
-            AttackCount     string `json:"AttackCount" xml:"AttackCount"`
-            Result     string `json:"Result" xml:"Result"`
-                    }   `json:"AttackIpDatas" xml:"AttackIpDatas"`
-                } `json:"AttackIpDataList" xml:"AttackIpDataList"`
-                AttackedUrlDataList struct {
-                    AttackedUrlDatas []struct {
-            Url     string `json:"Url" xml:"Url"`
-            AttackCount     string `json:"AttackCount" xml:"AttackCount"`
-            Result     string `json:"Result" xml:"Result"`
-                    }   `json:"AttackedUrlDatas" xml:"AttackedUrlDatas"`
-                } `json:"AttackedUrlDataList" xml:"AttackedUrlDataList"`
+	*responses.BaseResponse
+	RequestId        string `json:"RequestId" xml:"RequestId"`
+	DomainName       string `json:"DomainName" xml:"DomainName"`
+	StartTime        string `json:"StartTime" xml:"StartTime"`
+	EndTime          string `json:"EndTime" xml:"EndTime"`
+	AttackIpDataList struct {
+		AttackIpDatas []struct {
+			Ip          string `json:"Ip" xml:"Ip"`
+			AttackCount string `json:"AttackCount" xml:"AttackCount"`
+			Result      string `json:"Result" xml:"Result"`
+		} `json:"AttackIpDatas" xml:"AttackIpDatas"`
+	} `json:"AttackIpDataList" xml:"AttackIpDataList"`
+	AttackedUrlDataList struct {
+		AttackedUrlDatas []struct {
+			Url         string `json:"Url" xml:"Url"`
+			AttackCount string `json:"AttackCount" xml:"AttackCount"`
+			Result      string `json:"Result" xml:"Result"`
+		} `json:"AttackedUrlDatas" xml:"AttackedUrlDatas"`
+	} `json:"AttackedUrlDataList" xml:"AttackedUrlDataList"`
 }
 
 func CreateDescribeDomainCCAttackInfoRequest() (request *DescribeDomainCCAttackInfoRequest) {
-request = &DescribeDomainCCAttackInfoRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainCCAttackInfo", "", "")
-return
+	request = &DescribeDomainCCAttackInfoRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainCCAttackInfo", "", "")
+	return
 }
 
 func CreateDescribeDomainCCAttackInfoResponse() (response *DescribeDomainCCAttackInfoResponse) {
-response = &DescribeDomainCCAttackInfoResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainCCAttackInfoResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_c_c_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,87 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainCCData(request *DescribeDomainCCDataRequest) (response *DescribeDomainCCDataResponse, err error) {
-response = CreateDescribeDomainCCDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainCCDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainCCDataWithChan(request *DescribeDomainCCDataRequest) (<-chan *DescribeDomainCCDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainCCDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainCCData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainCCDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainCCData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainCCDataWithCallback(request *DescribeDomainCCDataRequest, callback func(response *DescribeDomainCCDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainCCDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainCCData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainCCDataWithCallback(request *DescribeDomainCCDataRequest, callback func(response *DescribeDomainCCDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainCCDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainCCData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainCCDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainCCDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                CCDataList struct {
-                    CCDatas []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Count     string `json:"Count" xml:"Count"`
-                    }   `json:"CCDatas" xml:"CCDatas"`
-                } `json:"CCDataList" xml:"CCDataList"`
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	DomainName   string `json:"DomainName" xml:"DomainName"`
+	DataInterval string `json:"DataInterval" xml:"DataInterval"`
+	StartTime    string `json:"StartTime" xml:"StartTime"`
+	EndTime      string `json:"EndTime" xml:"EndTime"`
+	CCDataList   struct {
+		CCDatas []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Count     string `json:"Count" xml:"Count"`
+		} `json:"CCDatas" xml:"CCDatas"`
+	} `json:"CCDataList" xml:"CCDataList"`
 }
 
 func CreateDescribeDomainCCDataRequest() (request *DescribeDomainCCDataRequest) {
-request = &DescribeDomainCCDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainCCData", "", "")
-return
+	request = &DescribeDomainCCDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainCCData", "", "")
+	return
 }
 
 func CreateDescribeDomainCCDataResponse() (response *DescribeDomainCCDataResponse) {
-response = &DescribeDomainCCDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainCCDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_configs.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,256 +16,254 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainConfigs(request *DescribeDomainConfigsRequest) (response *DescribeDomainConfigsResponse, err error) {
-response = CreateDescribeDomainConfigsResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainConfigsResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainConfigsWithChan(request *DescribeDomainConfigsRequest) (<-chan *DescribeDomainConfigsResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainConfigsResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainConfigs(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainConfigsResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainConfigs(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainConfigsWithCallback(request *DescribeDomainConfigsRequest, callback func(response *DescribeDomainConfigsResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainConfigsResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainConfigs(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainConfigsWithCallback(request *DescribeDomainConfigsRequest, callback func(response *DescribeDomainConfigsResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainConfigsResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainConfigs(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainConfigsRequest struct {
-*requests.RpcRequest
-                ConfigList  string `position:"Query" name:"ConfigList"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	ConfigList    string `position:"Query" name:"ConfigList"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainConfigsResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainConfigs struct {
-            CcConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Enable     string `json:"Enable" xml:"Enable"`
-            AllowIps     string `json:"AllowIps" xml:"AllowIps"`
-            BlockIps     string `json:"BlockIps" xml:"BlockIps"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"CcConfig" xml:"CcConfig"`
-            ErrorPageConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            ErrorCode     string `json:"ErrorCode" xml:"ErrorCode"`
-            PageType     string `json:"PageType" xml:"PageType"`
-            CustomPageUrl     string `json:"CustomPageUrl" xml:"CustomPageUrl"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"ErrorPageConfig" xml:"ErrorPageConfig"`
-            OptimizeConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Enable     string `json:"Enable" xml:"Enable"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"OptimizeConfig" xml:"OptimizeConfig"`
-            PageCompressConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Enable     string `json:"Enable" xml:"Enable"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"PageCompressConfig" xml:"PageCompressConfig"`
-            IgnoreQueryStringConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            HashKeyArgs     string `json:"HashKeyArgs" xml:"HashKeyArgs"`
-            Enable     string `json:"Enable" xml:"Enable"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"IgnoreQueryStringConfig" xml:"IgnoreQueryStringConfig"`
-            RangeConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Enable     string `json:"Enable" xml:"Enable"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"RangeConfig" xml:"RangeConfig"`
-            RefererConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            ReferType     string `json:"ReferType" xml:"ReferType"`
-            ReferList     string `json:"ReferList" xml:"ReferList"`
-            AllowEmpty     string `json:"AllowEmpty" xml:"AllowEmpty"`
-            DisableAst     string `json:"DisableAst" xml:"DisableAst"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"RefererConfig" xml:"RefererConfig"`
-            ReqAuthConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            AuthType     string `json:"AuthType" xml:"AuthType"`
-            Key1     string `json:"Key1" xml:"Key1"`
-            Key2     string `json:"Key2" xml:"Key2"`
-            Status     string `json:"Status" xml:"Status"`
-            AliAuthWhiteList     string `json:"AliAuthWhiteList" xml:"AliAuthWhiteList"`
-            AuthM3u8     string `json:"AuthM3u8" xml:"AuthM3u8"`
-            AuthAddr     string `json:"AuthAddr" xml:"AuthAddr"`
-            AuthRemoteDesc     string `json:"AuthRemoteDesc" xml:"AuthRemoteDesc"`
-            TimeOut     string `json:"TimeOut" xml:"TimeOut"`
-            }  `json:"ReqAuthConfig" xml:"ReqAuthConfig"`
-            SrcHostConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"SrcHostConfig" xml:"SrcHostConfig"`
-            VideoSeekConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Enable     string `json:"Enable" xml:"Enable"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"VideoSeekConfig" xml:"VideoSeekConfig"`
-            WafConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Enable     string `json:"Enable" xml:"Enable"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"WafConfig" xml:"WafConfig"`
-            NotifyUrlConfig struct {
-            Enable     string `json:"Enable" xml:"Enable"`
-            NotifyUrl     string `json:"NotifyUrl" xml:"NotifyUrl"`
-            }  `json:"NotifyUrlConfig" xml:"NotifyUrlConfig"`
-            RedirectTypeConfig struct {
-            RedirectType     string `json:"RedirectType" xml:"RedirectType"`
-            }  `json:"RedirectTypeConfig" xml:"RedirectTypeConfig"`
-            ForwardSchemeConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Enable     string `json:"Enable" xml:"Enable"`
-            SchemeOrigin     string `json:"SchemeOrigin" xml:"SchemeOrigin"`
-            SchemeOriginPort     string `json:"SchemeOriginPort" xml:"SchemeOriginPort"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"ForwardSchemeConfig" xml:"ForwardSchemeConfig"`
-            RemoveQueryStringConfig struct {
-            AliRemoveArgs     string `json:"AliRemoveArgs" xml:"AliRemoveArgs"`
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"RemoveQueryStringConfig" xml:"RemoveQueryStringConfig"`
-            L2OssKeyConfig struct {
-            PrivateOssAuth     string `json:"PrivateOssAuth" xml:"PrivateOssAuth"`
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"L2OssKeyConfig" xml:"L2OssKeyConfig"`
-            MacServiceConfig struct {
-            AppList     string `json:"AppList" xml:"AppList"`
-            Enabled     string `json:"Enabled" xml:"Enabled"`
-            ProcessResult     string `json:"ProcessResult" xml:"ProcessResult"`
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"MacServiceConfig" xml:"MacServiceConfig"`
-            GreenManagerConfig struct {
-            Enabled     string `json:"Enabled" xml:"Enabled"`
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"GreenManagerConfig" xml:"GreenManagerConfig"`
-            HttpsOptionConfig struct {
-            Http2     string `json:"Http2" xml:"Http2"`
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"HttpsOptionConfig" xml:"HttpsOptionConfig"`
-            AliBusinessConfig struct {
-            AliBusinessTable     string `json:"AliBusinessTable" xml:"AliBusinessTable"`
-            AliBusinessType     string `json:"AliBusinessType" xml:"AliBusinessType"`
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"AliBusinessConfig" xml:"AliBusinessConfig"`
-            IpAllowListConfig struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            IpList     string `json:"IpList" xml:"IpList"`
-            IpAclXfwd     string `json:"IpAclXfwd" xml:"IpAclXfwd"`
-            Status     string `json:"Status" xml:"Status"`
-            }  `json:"IpAllowListConfig" xml:"IpAllowListConfig"`
-                CacheExpiredConfigs struct {
-                    CacheExpiredConfig []struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            CacheType     string `json:"CacheType" xml:"CacheType"`
-            CacheContent     string `json:"CacheContent" xml:"CacheContent"`
-            TTL     string `json:"TTL" xml:"TTL"`
-            Weight     string `json:"Weight" xml:"Weight"`
-            Status     string `json:"Status" xml:"Status"`
-                    }   `json:"CacheExpiredConfig" xml:"CacheExpiredConfig"`
-                } `json:"CacheExpiredConfigs" xml:"CacheExpiredConfigs"`
-                HttpErrorPageConfigs struct {
-                    HttpErrorPageConfig []struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            ErrorCode     string `json:"ErrorCode" xml:"ErrorCode"`
-            PageUrl     string `json:"PageUrl" xml:"PageUrl"`
-            Status     string `json:"Status" xml:"Status"`
-                    }   `json:"HttpErrorPageConfig" xml:"HttpErrorPageConfig"`
-                } `json:"HttpErrorPageConfigs" xml:"HttpErrorPageConfigs"`
-                HttpHeaderConfigs struct {
-                    HttpHeaderConfig []struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            HeaderKey     string `json:"HeaderKey" xml:"HeaderKey"`
-            HeaderValue     string `json:"HeaderValue" xml:"HeaderValue"`
-            Status     string `json:"Status" xml:"Status"`
-                    }   `json:"HttpHeaderConfig" xml:"HttpHeaderConfig"`
-                } `json:"HttpHeaderConfigs" xml:"HttpHeaderConfigs"`
-                DynamicConfigs struct {
-                    DynamicConfig []struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            DynamicOrigin     string `json:"DynamicOrigin" xml:"DynamicOrigin"`
-            StaticType     string `json:"StaticType" xml:"StaticType"`
-            StaticUri     string `json:"StaticUri" xml:"StaticUri"`
-            StaticPath     string `json:"StaticPath" xml:"StaticPath"`
-            DynamicCacheControl     string `json:"DynamicCacheControl" xml:"DynamicCacheControl"`
-            Status     string `json:"Status" xml:"Status"`
-                    }   `json:"DynamicConfig" xml:"DynamicConfig"`
-                } `json:"DynamicConfigs" xml:"DynamicConfigs"`
-                ReqHeaderConfigs struct {
-                    ReqHeaderConfig []struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            Key     string `json:"Key" xml:"Key"`
-            Value     string `json:"Value" xml:"Value"`
-            Status     string `json:"Status" xml:"Status"`
-                    }   `json:"ReqHeaderConfig" xml:"ReqHeaderConfig"`
-                } `json:"ReqHeaderConfigs" xml:"ReqHeaderConfigs"`
-                SetVarsConfigs struct {
-                    SetVarsConfig []struct {
-            ConfigId     string `json:"ConfigId" xml:"ConfigId"`
-            VarName     string `json:"VarName" xml:"VarName"`
-            VarValue     string `json:"VarValue" xml:"VarValue"`
-            Status     string `json:"Status" xml:"Status"`
-                    }   `json:"SetVarsConfig" xml:"SetVarsConfig"`
-                } `json:"SetVarsConfigs" xml:"SetVarsConfigs"`
-            }  `json:"DomainConfigs" xml:"DomainConfigs"`
+	*responses.BaseResponse
+	RequestId     string `json:"RequestId" xml:"RequestId"`
+	DomainConfigs struct {
+		CcConfig struct {
+			ConfigId string `json:"ConfigId" xml:"ConfigId"`
+			Enable   string `json:"Enable" xml:"Enable"`
+			AllowIps string `json:"AllowIps" xml:"AllowIps"`
+			BlockIps string `json:"BlockIps" xml:"BlockIps"`
+			Status   string `json:"Status" xml:"Status"`
+		} `json:"CcConfig" xml:"CcConfig"`
+		ErrorPageConfig struct {
+			ConfigId      string `json:"ConfigId" xml:"ConfigId"`
+			ErrorCode     string `json:"ErrorCode" xml:"ErrorCode"`
+			PageType      string `json:"PageType" xml:"PageType"`
+			CustomPageUrl string `json:"CustomPageUrl" xml:"CustomPageUrl"`
+			Status        string `json:"Status" xml:"Status"`
+		} `json:"ErrorPageConfig" xml:"ErrorPageConfig"`
+		OptimizeConfig struct {
+			ConfigId string `json:"ConfigId" xml:"ConfigId"`
+			Enable   string `json:"Enable" xml:"Enable"`
+			Status   string `json:"Status" xml:"Status"`
+		} `json:"OptimizeConfig" xml:"OptimizeConfig"`
+		PageCompressConfig struct {
+			ConfigId string `json:"ConfigId" xml:"ConfigId"`
+			Enable   string `json:"Enable" xml:"Enable"`
+			Status   string `json:"Status" xml:"Status"`
+		} `json:"PageCompressConfig" xml:"PageCompressConfig"`
+		IgnoreQueryStringConfig struct {
+			ConfigId    string `json:"ConfigId" xml:"ConfigId"`
+			HashKeyArgs string `json:"HashKeyArgs" xml:"HashKeyArgs"`
+			Enable      string `json:"Enable" xml:"Enable"`
+			Status      string `json:"Status" xml:"Status"`
+		} `json:"IgnoreQueryStringConfig" xml:"IgnoreQueryStringConfig"`
+		RangeConfig struct {
+			ConfigId string `json:"ConfigId" xml:"ConfigId"`
+			Enable   string `json:"Enable" xml:"Enable"`
+			Status   string `json:"Status" xml:"Status"`
+		} `json:"RangeConfig" xml:"RangeConfig"`
+		RefererConfig struct {
+			ConfigId   string `json:"ConfigId" xml:"ConfigId"`
+			ReferType  string `json:"ReferType" xml:"ReferType"`
+			ReferList  string `json:"ReferList" xml:"ReferList"`
+			AllowEmpty string `json:"AllowEmpty" xml:"AllowEmpty"`
+			DisableAst string `json:"DisableAst" xml:"DisableAst"`
+			Status     string `json:"Status" xml:"Status"`
+		} `json:"RefererConfig" xml:"RefererConfig"`
+		ReqAuthConfig struct {
+			ConfigId         string `json:"ConfigId" xml:"ConfigId"`
+			AuthType         string `json:"AuthType" xml:"AuthType"`
+			Key1             string `json:"Key1" xml:"Key1"`
+			Key2             string `json:"Key2" xml:"Key2"`
+			Status           string `json:"Status" xml:"Status"`
+			AliAuthWhiteList string `json:"AliAuthWhiteList" xml:"AliAuthWhiteList"`
+			AuthM3u8         string `json:"AuthM3u8" xml:"AuthM3u8"`
+			AuthAddr         string `json:"AuthAddr" xml:"AuthAddr"`
+			AuthRemoteDesc   string `json:"AuthRemoteDesc" xml:"AuthRemoteDesc"`
+			TimeOut          string `json:"TimeOut" xml:"TimeOut"`
+		} `json:"ReqAuthConfig" xml:"ReqAuthConfig"`
+		SrcHostConfig struct {
+			ConfigId   string `json:"ConfigId" xml:"ConfigId"`
+			DomainName string `json:"DomainName" xml:"DomainName"`
+			Status     string `json:"Status" xml:"Status"`
+		} `json:"SrcHostConfig" xml:"SrcHostConfig"`
+		VideoSeekConfig struct {
+			ConfigId string `json:"ConfigId" xml:"ConfigId"`
+			Enable   string `json:"Enable" xml:"Enable"`
+			Status   string `json:"Status" xml:"Status"`
+		} `json:"VideoSeekConfig" xml:"VideoSeekConfig"`
+		WafConfig struct {
+			ConfigId string `json:"ConfigId" xml:"ConfigId"`
+			Enable   string `json:"Enable" xml:"Enable"`
+			Status   string `json:"Status" xml:"Status"`
+		} `json:"WafConfig" xml:"WafConfig"`
+		NotifyUrlConfig struct {
+			Enable    string `json:"Enable" xml:"Enable"`
+			NotifyUrl string `json:"NotifyUrl" xml:"NotifyUrl"`
+		} `json:"NotifyUrlConfig" xml:"NotifyUrlConfig"`
+		RedirectTypeConfig struct {
+			RedirectType string `json:"RedirectType" xml:"RedirectType"`
+		} `json:"RedirectTypeConfig" xml:"RedirectTypeConfig"`
+		ForwardSchemeConfig struct {
+			ConfigId         string `json:"ConfigId" xml:"ConfigId"`
+			Enable           string `json:"Enable" xml:"Enable"`
+			SchemeOrigin     string `json:"SchemeOrigin" xml:"SchemeOrigin"`
+			SchemeOriginPort string `json:"SchemeOriginPort" xml:"SchemeOriginPort"`
+			Status           string `json:"Status" xml:"Status"`
+		} `json:"ForwardSchemeConfig" xml:"ForwardSchemeConfig"`
+		RemoveQueryStringConfig struct {
+			AliRemoveArgs string `json:"AliRemoveArgs" xml:"AliRemoveArgs"`
+			ConfigId      string `json:"ConfigId" xml:"ConfigId"`
+			Status        string `json:"Status" xml:"Status"`
+		} `json:"RemoveQueryStringConfig" xml:"RemoveQueryStringConfig"`
+		L2OssKeyConfig struct {
+			PrivateOssAuth string `json:"PrivateOssAuth" xml:"PrivateOssAuth"`
+			ConfigId       string `json:"ConfigId" xml:"ConfigId"`
+			Status         string `json:"Status" xml:"Status"`
+		} `json:"L2OssKeyConfig" xml:"L2OssKeyConfig"`
+		MacServiceConfig struct {
+			AppList       string `json:"AppList" xml:"AppList"`
+			Enabled       string `json:"Enabled" xml:"Enabled"`
+			ProcessResult string `json:"ProcessResult" xml:"ProcessResult"`
+			ConfigId      string `json:"ConfigId" xml:"ConfigId"`
+			Status        string `json:"Status" xml:"Status"`
+		} `json:"MacServiceConfig" xml:"MacServiceConfig"`
+		GreenManagerConfig struct {
+			Enabled  string `json:"Enabled" xml:"Enabled"`
+			ConfigId string `json:"ConfigId" xml:"ConfigId"`
+			Status   string `json:"Status" xml:"Status"`
+		} `json:"GreenManagerConfig" xml:"GreenManagerConfig"`
+		HttpsOptionConfig struct {
+			Http2    string `json:"Http2" xml:"Http2"`
+			ConfigId string `json:"ConfigId" xml:"ConfigId"`
+			Status   string `json:"Status" xml:"Status"`
+		} `json:"HttpsOptionConfig" xml:"HttpsOptionConfig"`
+		AliBusinessConfig struct {
+			AliBusinessTable string `json:"AliBusinessTable" xml:"AliBusinessTable"`
+			AliBusinessType  string `json:"AliBusinessType" xml:"AliBusinessType"`
+			ConfigId         string `json:"ConfigId" xml:"ConfigId"`
+			Status           string `json:"Status" xml:"Status"`
+		} `json:"AliBusinessConfig" xml:"AliBusinessConfig"`
+		IpAllowListConfig struct {
+			ConfigId  string `json:"ConfigId" xml:"ConfigId"`
+			IpList    string `json:"IpList" xml:"IpList"`
+			IpAclXfwd string `json:"IpAclXfwd" xml:"IpAclXfwd"`
+			Status    string `json:"Status" xml:"Status"`
+		} `json:"IpAllowListConfig" xml:"IpAllowListConfig"`
+		CacheExpiredConfigs struct {
+			CacheExpiredConfig []struct {
+				ConfigId     string `json:"ConfigId" xml:"ConfigId"`
+				CacheType    string `json:"CacheType" xml:"CacheType"`
+				CacheContent string `json:"CacheContent" xml:"CacheContent"`
+				TTL          string `json:"TTL" xml:"TTL"`
+				Weight       string `json:"Weight" xml:"Weight"`
+				Status       string `json:"Status" xml:"Status"`
+			} `json:"CacheExpiredConfig" xml:"CacheExpiredConfig"`
+		} `json:"CacheExpiredConfigs" xml:"CacheExpiredConfigs"`
+		HttpErrorPageConfigs struct {
+			HttpErrorPageConfig []struct {
+				ConfigId  string `json:"ConfigId" xml:"ConfigId"`
+				ErrorCode string `json:"ErrorCode" xml:"ErrorCode"`
+				PageUrl   string `json:"PageUrl" xml:"PageUrl"`
+				Status    string `json:"Status" xml:"Status"`
+			} `json:"HttpErrorPageConfig" xml:"HttpErrorPageConfig"`
+		} `json:"HttpErrorPageConfigs" xml:"HttpErrorPageConfigs"`
+		HttpHeaderConfigs struct {
+			HttpHeaderConfig []struct {
+				ConfigId    string `json:"ConfigId" xml:"ConfigId"`
+				HeaderKey   string `json:"HeaderKey" xml:"HeaderKey"`
+				HeaderValue string `json:"HeaderValue" xml:"HeaderValue"`
+				Status      string `json:"Status" xml:"Status"`
+			} `json:"HttpHeaderConfig" xml:"HttpHeaderConfig"`
+		} `json:"HttpHeaderConfigs" xml:"HttpHeaderConfigs"`
+		DynamicConfigs struct {
+			DynamicConfig []struct {
+				ConfigId            string `json:"ConfigId" xml:"ConfigId"`
+				DynamicOrigin       string `json:"DynamicOrigin" xml:"DynamicOrigin"`
+				StaticType          string `json:"StaticType" xml:"StaticType"`
+				StaticUri           string `json:"StaticUri" xml:"StaticUri"`
+				StaticPath          string `json:"StaticPath" xml:"StaticPath"`
+				DynamicCacheControl string `json:"DynamicCacheControl" xml:"DynamicCacheControl"`
+				Status              string `json:"Status" xml:"Status"`
+			} `json:"DynamicConfig" xml:"DynamicConfig"`
+		} `json:"DynamicConfigs" xml:"DynamicConfigs"`
+		ReqHeaderConfigs struct {
+			ReqHeaderConfig []struct {
+				ConfigId string `json:"ConfigId" xml:"ConfigId"`
+				Key      string `json:"Key" xml:"Key"`
+				Value    string `json:"Value" xml:"Value"`
+				Status   string `json:"Status" xml:"Status"`
+			} `json:"ReqHeaderConfig" xml:"ReqHeaderConfig"`
+		} `json:"ReqHeaderConfigs" xml:"ReqHeaderConfigs"`
+		SetVarsConfigs struct {
+			SetVarsConfig []struct {
+				ConfigId string `json:"ConfigId" xml:"ConfigId"`
+				VarName  string `json:"VarName" xml:"VarName"`
+				VarValue string `json:"VarValue" xml:"VarValue"`
+				Status   string `json:"Status" xml:"Status"`
+			} `json:"SetVarsConfig" xml:"SetVarsConfig"`
+		} `json:"SetVarsConfigs" xml:"SetVarsConfigs"`
+	} `json:"DomainConfigs" xml:"DomainConfigs"`
 }
 
 func CreateDescribeDomainConfigsRequest() (request *DescribeDomainConfigsRequest) {
-request = &DescribeDomainConfigsRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainConfigs", "", "")
-return
+	request = &DescribeDomainConfigsRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainConfigs", "", "")
+	return
 }
 
 func CreateDescribeDomainConfigsResponse() (response *DescribeDomainConfigsResponse) {
-response = &DescribeDomainConfigsResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainConfigsResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_downstream_bps_of_edge.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,85 +16,83 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainDownstreamBpsOfEdge(request *DescribeDomainDownstreamBpsOfEdgeRequest) (response *DescribeDomainDownstreamBpsOfEdgeResponse, err error) {
-response = CreateDescribeDomainDownstreamBpsOfEdgeResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainDownstreamBpsOfEdgeResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainDownstreamBpsOfEdgeWithChan(request *DescribeDomainDownstreamBpsOfEdgeRequest) (<-chan *DescribeDomainDownstreamBpsOfEdgeResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainDownstreamBpsOfEdgeResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainDownstreamBpsOfEdge(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainDownstreamBpsOfEdgeResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainDownstreamBpsOfEdge(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainDownstreamBpsOfEdgeWithCallback(request *DescribeDomainDownstreamBpsOfEdgeRequest, callback func(response *DescribeDomainDownstreamBpsOfEdgeResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainDownstreamBpsOfEdgeResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainDownstreamBpsOfEdge(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainDownstreamBpsOfEdgeWithCallback(request *DescribeDomainDownstreamBpsOfEdgeRequest, callback func(response *DescribeDomainDownstreamBpsOfEdgeResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainDownstreamBpsOfEdgeResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainDownstreamBpsOfEdge(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainDownstreamBpsOfEdgeRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainDownstreamBpsOfEdgeResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-                BpsDatas struct {
-                    DomainBpsModel []struct {
-            Time     string `json:"Time" xml:"Time"`
-            Bps     float64 `json:"Bps" xml:"Bps"`
-                    }   `json:"DomainBpsModel" xml:"DomainBpsModel"`
-                } `json:"BpsDatas" xml:"BpsDatas"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	BpsDatas  struct {
+		DomainBpsModel []struct {
+			Time string  `json:"Time" xml:"Time"`
+			Bps  float64 `json:"Bps" xml:"Bps"`
+		} `json:"DomainBpsModel" xml:"DomainBpsModel"`
+	} `json:"BpsDatas" xml:"BpsDatas"`
 }
 
 func CreateDescribeDomainDownstreamBpsOfEdgeRequest() (request *DescribeDomainDownstreamBpsOfEdgeRequest) {
-request = &DescribeDomainDownstreamBpsOfEdgeRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainDownstreamBpsOfEdge", "", "")
-return
+	request = &DescribeDomainDownstreamBpsOfEdgeRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainDownstreamBpsOfEdge", "", "")
+	return
 }
 
 func CreateDescribeDomainDownstreamBpsOfEdgeResponse() (response *DescribeDomainDownstreamBpsOfEdgeResponse) {
-response = &DescribeDomainDownstreamBpsOfEdgeResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainDownstreamBpsOfEdgeResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_file_size_proportion_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,94 +16,92 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainFileSizeProportionData(request *DescribeDomainFileSizeProportionDataRequest) (response *DescribeDomainFileSizeProportionDataResponse, err error) {
-response = CreateDescribeDomainFileSizeProportionDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainFileSizeProportionDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainFileSizeProportionDataWithChan(request *DescribeDomainFileSizeProportionDataRequest) (<-chan *DescribeDomainFileSizeProportionDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainFileSizeProportionDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainFileSizeProportionData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainFileSizeProportionDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainFileSizeProportionData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainFileSizeProportionDataWithCallback(request *DescribeDomainFileSizeProportionDataRequest, callback func(response *DescribeDomainFileSizeProportionDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainFileSizeProportionDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainFileSizeProportionData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainFileSizeProportionDataWithCallback(request *DescribeDomainFileSizeProportionDataRequest, callback func(response *DescribeDomainFileSizeProportionDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainFileSizeProportionDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainFileSizeProportionData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainFileSizeProportionDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainFileSizeProportionDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                FileSizeProportionDataInterval struct {
-                    UsageData []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-                Value struct {
-                    FileSizeProportionData []struct {
-            FileSize     string `json:"FileSize" xml:"FileSize"`
-            Proportion     string `json:"Proportion" xml:"Proportion"`
-                    }   `json:"FileSizeProportionData" xml:"FileSizeProportionData"`
-                } `json:"Value" xml:"Value"`
-                    }   `json:"UsageData" xml:"UsageData"`
-                } `json:"FileSizeProportionDataInterval" xml:"FileSizeProportionDataInterval"`
+	*responses.BaseResponse
+	RequestId                      string `json:"RequestId" xml:"RequestId"`
+	DomainName                     string `json:"DomainName" xml:"DomainName"`
+	DataInterval                   string `json:"DataInterval" xml:"DataInterval"`
+	StartTime                      string `json:"StartTime" xml:"StartTime"`
+	EndTime                        string `json:"EndTime" xml:"EndTime"`
+	FileSizeProportionDataInterval struct {
+		UsageData []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     struct {
+				FileSizeProportionData []struct {
+					FileSize   string `json:"FileSize" xml:"FileSize"`
+					Proportion string `json:"Proportion" xml:"Proportion"`
+				} `json:"FileSizeProportionData" xml:"FileSizeProportionData"`
+			} `json:"Value" xml:"Value"`
+		} `json:"UsageData" xml:"UsageData"`
+	} `json:"FileSizeProportionDataInterval" xml:"FileSizeProportionDataInterval"`
 }
 
 func CreateDescribeDomainFileSizeProportionDataRequest() (request *DescribeDomainFileSizeProportionDataRequest) {
-request = &DescribeDomainFileSizeProportionDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainFileSizeProportionData", "", "")
-return
+	request = &DescribeDomainFileSizeProportionDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainFileSizeProportionData", "", "")
+	return
 }
 
 func CreateDescribeDomainFileSizeProportionDataResponse() (response *DescribeDomainFileSizeProportionDataResponse) {
-response = &DescribeDomainFileSizeProportionDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainFileSizeProportionDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_flow_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,103 +16,101 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainFlowData(request *DescribeDomainFlowDataRequest) (response *DescribeDomainFlowDataResponse, err error) {
-response = CreateDescribeDomainFlowDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainFlowDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainFlowDataWithChan(request *DescribeDomainFlowDataRequest) (<-chan *DescribeDomainFlowDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainFlowDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainFlowData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainFlowDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainFlowData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainFlowDataWithCallback(request *DescribeDomainFlowDataRequest, callback func(response *DescribeDomainFlowDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainFlowDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainFlowData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainFlowDataWithCallback(request *DescribeDomainFlowDataRequest, callback func(response *DescribeDomainFlowDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainFlowDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainFlowData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainFlowDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                Interval  string `position:"Query" name:"Interval"`
-                FixTimeGap  string `position:"Query" name:"FixTimeGap"`
-                LocationNameEn  string `position:"Query" name:"LocationNameEn"`
-                IspNameEn  string `position:"Query" name:"IspNameEn"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                DomainType  string `position:"Query" name:"DomainType"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                TimeMerge  string `position:"Query" name:"TimeMerge"`
+	*requests.RpcRequest
+	EndTime        string `position:"Query" name:"EndTime"`
+	StartTime      string `position:"Query" name:"StartTime"`
+	Interval       string `position:"Query" name:"Interval"`
+	FixTimeGap     string `position:"Query" name:"FixTimeGap"`
+	LocationNameEn string `position:"Query" name:"LocationNameEn"`
+	IspNameEn      string `position:"Query" name:"IspNameEn"`
+	OwnerId        string `position:"Query" name:"OwnerId"`
+	DomainType     string `position:"Query" name:"DomainType"`
+	DomainName     string `position:"Query" name:"DomainName"`
+	SecurityToken  string `position:"Query" name:"SecurityToken"`
+	TimeMerge      string `position:"Query" name:"TimeMerge"`
 }
 
-
 type DescribeDomainFlowDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                FlowDataPerInterval struct {
-                    DataModule []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-            DomesticValue     string `json:"DomesticValue" xml:"DomesticValue"`
-            OverseasValue     string `json:"OverseasValue" xml:"OverseasValue"`
-            DynamicValue     string `json:"DynamicValue" xml:"DynamicValue"`
-            DynamicDomesticValue     string `json:"DynamicDomesticValue" xml:"DynamicDomesticValue"`
-            DynamicOverseasValue     string `json:"DynamicOverseasValue" xml:"DynamicOverseasValue"`
-            StaticValue     string `json:"StaticValue" xml:"StaticValue"`
-            StaticDomesticValue     string `json:"StaticDomesticValue" xml:"StaticDomesticValue"`
-            StaticOverseasValue     string `json:"StaticOverseasValue" xml:"StaticOverseasValue"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"FlowDataPerInterval" xml:"FlowDataPerInterval"`
+	*responses.BaseResponse
+	RequestId           string `json:"RequestId" xml:"RequestId"`
+	DomainName          string `json:"DomainName" xml:"DomainName"`
+	DataInterval        string `json:"DataInterval" xml:"DataInterval"`
+	StartTime           string `json:"StartTime" xml:"StartTime"`
+	EndTime             string `json:"EndTime" xml:"EndTime"`
+	FlowDataPerInterval struct {
+		DataModule []struct {
+			TimeStamp            string `json:"TimeStamp" xml:"TimeStamp"`
+			Value                string `json:"Value" xml:"Value"`
+			DomesticValue        string `json:"DomesticValue" xml:"DomesticValue"`
+			OverseasValue        string `json:"OverseasValue" xml:"OverseasValue"`
+			DynamicValue         string `json:"DynamicValue" xml:"DynamicValue"`
+			DynamicDomesticValue string `json:"DynamicDomesticValue" xml:"DynamicDomesticValue"`
+			DynamicOverseasValue string `json:"DynamicOverseasValue" xml:"DynamicOverseasValue"`
+			StaticValue          string `json:"StaticValue" xml:"StaticValue"`
+			StaticDomesticValue  string `json:"StaticDomesticValue" xml:"StaticDomesticValue"`
+			StaticOverseasValue  string `json:"StaticOverseasValue" xml:"StaticOverseasValue"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"FlowDataPerInterval" xml:"FlowDataPerInterval"`
 }
 
 func CreateDescribeDomainFlowDataRequest() (request *DescribeDomainFlowDataRequest) {
-request = &DescribeDomainFlowDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainFlowData", "", "")
-return
+	request = &DescribeDomainFlowDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainFlowData", "", "")
+	return
 }
 
 func CreateDescribeDomainFlowDataResponse() (response *DescribeDomainFlowDataResponse) {
-response = &DescribeDomainFlowDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainFlowDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_hit_rate_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,93 +16,91 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainHitRateData(request *DescribeDomainHitRateDataRequest) (response *DescribeDomainHitRateDataResponse, err error) {
-response = CreateDescribeDomainHitRateDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainHitRateDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainHitRateDataWithChan(request *DescribeDomainHitRateDataRequest) (<-chan *DescribeDomainHitRateDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainHitRateDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainHitRateData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainHitRateDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainHitRateData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainHitRateDataWithCallback(request *DescribeDomainHitRateDataRequest, callback func(response *DescribeDomainHitRateDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainHitRateDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainHitRateData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainHitRateDataWithCallback(request *DescribeDomainHitRateDataRequest, callback func(response *DescribeDomainHitRateDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainHitRateDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainHitRateData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainHitRateDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                Interval  string `position:"Query" name:"Interval"`
-                IspNameEn  string `position:"Query" name:"IspNameEn"`
-                LocationNameEn  string `position:"Query" name:"LocationNameEn"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                TimeMerge  string `position:"Query" name:"TimeMerge"`
+	*requests.RpcRequest
+	EndTime        string `position:"Query" name:"EndTime"`
+	StartTime      string `position:"Query" name:"StartTime"`
+	DomainName     string `position:"Query" name:"DomainName"`
+	Interval       string `position:"Query" name:"Interval"`
+	IspNameEn      string `position:"Query" name:"IspNameEn"`
+	LocationNameEn string `position:"Query" name:"LocationNameEn"`
+	OwnerId        string `position:"Query" name:"OwnerId"`
+	SecurityToken  string `position:"Query" name:"SecurityToken"`
+	TimeMerge      string `position:"Query" name:"TimeMerge"`
 }
 
-
 type DescribeDomainHitRateDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                HitRateInterval struct {
-                    DataModule []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"HitRateInterval" xml:"HitRateInterval"`
+	*responses.BaseResponse
+	RequestId       string `json:"RequestId" xml:"RequestId"`
+	DomainName      string `json:"DomainName" xml:"DomainName"`
+	DataInterval    string `json:"DataInterval" xml:"DataInterval"`
+	StartTime       string `json:"StartTime" xml:"StartTime"`
+	EndTime         string `json:"EndTime" xml:"EndTime"`
+	HitRateInterval struct {
+		DataModule []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     string `json:"Value" xml:"Value"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"HitRateInterval" xml:"HitRateInterval"`
 }
 
 func CreateDescribeDomainHitRateDataRequest() (request *DescribeDomainHitRateDataRequest) {
-request = &DescribeDomainHitRateDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainHitRateData", "", "")
-return
+	request = &DescribeDomainHitRateDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainHitRateData", "", "")
+	return
 }
 
 func CreateDescribeDomainHitRateDataResponse() (response *DescribeDomainHitRateDataResponse) {
-response = &DescribeDomainHitRateDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainHitRateDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_http_code_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,99 +16,97 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainHttpCodeData(request *DescribeDomainHttpCodeDataRequest) (response *DescribeDomainHttpCodeDataResponse, err error) {
-response = CreateDescribeDomainHttpCodeDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainHttpCodeDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainHttpCodeDataWithChan(request *DescribeDomainHttpCodeDataRequest) (<-chan *DescribeDomainHttpCodeDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainHttpCodeDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainHttpCodeData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainHttpCodeDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainHttpCodeData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainHttpCodeDataWithCallback(request *DescribeDomainHttpCodeDataRequest, callback func(response *DescribeDomainHttpCodeDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainHttpCodeDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainHttpCodeData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainHttpCodeDataWithCallback(request *DescribeDomainHttpCodeDataRequest, callback func(response *DescribeDomainHttpCodeDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainHttpCodeDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainHttpCodeData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainHttpCodeDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                Interval  string `position:"Query" name:"Interval"`
-                IspNameEn  string `position:"Query" name:"IspNameEn"`
-                LocationNameEn  string `position:"Query" name:"LocationNameEn"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                TimeMerge  string `position:"Query" name:"TimeMerge"`
+	*requests.RpcRequest
+	EndTime        string `position:"Query" name:"EndTime"`
+	StartTime      string `position:"Query" name:"StartTime"`
+	DomainName     string `position:"Query" name:"DomainName"`
+	Interval       string `position:"Query" name:"Interval"`
+	IspNameEn      string `position:"Query" name:"IspNameEn"`
+	LocationNameEn string `position:"Query" name:"LocationNameEn"`
+	OwnerId        string `position:"Query" name:"OwnerId"`
+	SecurityToken  string `position:"Query" name:"SecurityToken"`
+	TimeMerge      string `position:"Query" name:"TimeMerge"`
 }
 
-
 type DescribeDomainHttpCodeDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                HttpCodeData struct {
-                    UsageData []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-                Value struct {
-                    CodeProportionData []struct {
-            Code     string `json:"Code" xml:"Code"`
-            Proportion     string `json:"Proportion" xml:"Proportion"`
-            Count     string `json:"Count" xml:"Count"`
-                    }   `json:"CodeProportionData" xml:"CodeProportionData"`
-                } `json:"Value" xml:"Value"`
-                    }   `json:"UsageData" xml:"UsageData"`
-                } `json:"HttpCodeData" xml:"HttpCodeData"`
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	DomainName   string `json:"DomainName" xml:"DomainName"`
+	DataInterval string `json:"DataInterval" xml:"DataInterval"`
+	StartTime    string `json:"StartTime" xml:"StartTime"`
+	EndTime      string `json:"EndTime" xml:"EndTime"`
+	HttpCodeData struct {
+		UsageData []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     struct {
+				CodeProportionData []struct {
+					Code       string `json:"Code" xml:"Code"`
+					Proportion string `json:"Proportion" xml:"Proportion"`
+					Count      string `json:"Count" xml:"Count"`
+				} `json:"CodeProportionData" xml:"CodeProportionData"`
+			} `json:"Value" xml:"Value"`
+		} `json:"UsageData" xml:"UsageData"`
+	} `json:"HttpCodeData" xml:"HttpCodeData"`
 }
 
 func CreateDescribeDomainHttpCodeDataRequest() (request *DescribeDomainHttpCodeDataRequest) {
-request = &DescribeDomainHttpCodeDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainHttpCodeData", "", "")
-return
+	request = &DescribeDomainHttpCodeDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainHttpCodeData", "", "")
+	return
 }
 
 func CreateDescribeDomainHttpCodeDataResponse() (response *DescribeDomainHttpCodeDataResponse) {
-response = &DescribeDomainHttpCodeDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainHttpCodeDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_https_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,132 +16,130 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainHttpsData(request *DescribeDomainHttpsDataRequest) (response *DescribeDomainHttpsDataResponse, err error) {
-response = CreateDescribeDomainHttpsDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainHttpsDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainHttpsDataWithChan(request *DescribeDomainHttpsDataRequest) (<-chan *DescribeDomainHttpsDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainHttpsDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainHttpsData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainHttpsDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainHttpsData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainHttpsDataWithCallback(request *DescribeDomainHttpsDataRequest, callback func(response *DescribeDomainHttpsDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainHttpsDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainHttpsData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainHttpsDataWithCallback(request *DescribeDomainHttpsDataRequest, callback func(response *DescribeDomainHttpsDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainHttpsDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainHttpsData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainHttpsDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                Cls  string `position:"Query" name:"Cls"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                Interval  string `position:"Query" name:"Interval"`
-                FixTimeGap  string `position:"Query" name:"FixTimeGap"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                DomainType  string `position:"Query" name:"DomainType"`
-                DomainNames  string `position:"Query" name:"DomainNames"`
-                TimeMerge  string `position:"Query" name:"TimeMerge"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	Cls           string `position:"Query" name:"Cls"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	Interval      string `position:"Query" name:"Interval"`
+	FixTimeGap    string `position:"Query" name:"FixTimeGap"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
+	DomainType    string `position:"Query" name:"DomainType"`
+	DomainNames   string `position:"Query" name:"DomainNames"`
+	TimeMerge     string `position:"Query" name:"TimeMerge"`
 }
 
-
 type DescribeDomainHttpsDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainNames     string `json:"DomainNames" xml:"DomainNames"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-                HttpsStatisticsInfos struct {
-                    HttpsStatisticsInfo []struct {
-            Time     string `json:"Time" xml:"Time"`
-            L1HttpsBps     float64 `json:"L1HttpsBps" xml:"L1HttpsBps"`
-            L1HttpsInnerBps     float64 `json:"L1HttpsInnerBps" xml:"L1HttpsInnerBps"`
-            L1HttpsOutBps     float64 `json:"L1HttpsOutBps" xml:"L1HttpsOutBps"`
-            L1HttpsQps     int64 `json:"L1HttpsQps" xml:"L1HttpsQps"`
-            L1HttpsInnerQps     int64 `json:"L1HttpsInnerQps" xml:"L1HttpsInnerQps"`
-            L1HttpsOutQps     int64 `json:"L1HttpsOutQps" xml:"L1HttpsOutQps"`
-            L1HttpsTtraf     int64 `json:"L1HttpsTtraf" xml:"L1HttpsTtraf"`
-            HttpsSrcBps     int64 `json:"HttpsSrcBps" xml:"HttpsSrcBps"`
-            HttpsSrcTraf     int64 `json:"HttpsSrcTraf" xml:"HttpsSrcTraf"`
-            L1HttpsInnerTraf     int64 `json:"L1HttpsInnerTraf" xml:"L1HttpsInnerTraf"`
-            L1HttpsOutTraf     int64 `json:"L1HttpsOutTraf" xml:"L1HttpsOutTraf"`
-            HttpsByteHitRate     float64 `json:"HttpsByteHitRate" xml:"HttpsByteHitRate"`
-            HttpsReqHitRate     float64 `json:"HttpsReqHitRate" xml:"HttpsReqHitRate"`
-            L1HttpsHitRate     float64 `json:"L1HttpsHitRate" xml:"L1HttpsHitRate"`
-            L1HttpsInnerAcc     float64 `json:"L1HttpsInner_acc" xml:"L1HttpsInner_acc"`
-            L1HttpsOutAcc     float64 `json:"L1HttpsOut_acc" xml:"L1HttpsOut_acc"`
-            L1HttpsTacc     float64 `json:"L1HttpsTacc" xml:"L1HttpsTacc"`
-            L1DyHttpsBps     float64 `json:"L1DyHttpsBps" xml:"L1DyHttpsBps"`
-            L1DyHttpsInnerBps     float64 `json:"L1DyHttpsInnerBps" xml:"L1DyHttpsInnerBps"`
-            L1DyHttpsOutBps     float64 `json:"L1DyHttpsOutBps" xml:"L1DyHttpsOutBps"`
-            L1StHttpsBps     float64 `json:"L1StHttpsBps" xml:"L1StHttpsBps"`
-            L1StHttpsInnerBps     float64 `json:"L1StHttpsInnerBps" xml:"L1StHttpsInnerBps"`
-            L1StHttpsOutBps     float64 `json:"L1StHttpsOutBps" xml:"L1StHttpsOutBps"`
-            L1DyHttpsTraf     float64 `json:"l1DyHttpsTraf" xml:"l1DyHttpsTraf"`
-            L1DyHttpsInnerTraf     float64 `json:"L1DyHttpsInnerTraf" xml:"L1DyHttpsInnerTraf"`
-            L1DyHttpsOutTraf     float64 `json:"L1DyHttpsOutTraf" xml:"L1DyHttpsOutTraf"`
-            L1StHttpsTraf     float64 `json:"L1StHttpsTraf" xml:"L1StHttpsTraf"`
-            L1StHttpsInnerTraf     float64 `json:"L1StHttpsInnerTraf" xml:"L1StHttpsInnerTraf"`
-            L1StHttpsOutTraf     float64 `json:"L1StHttpsOutTraf" xml:"L1StHttpsOutTraf"`
-            L1DyHttpsQps     float64 `json:"L1DyHttpsQps" xml:"L1DyHttpsQps"`
-            L1DyHttpsInnerQps     float64 `json:"L1DyHttpsInnerQps" xml:"L1DyHttpsInnerQps"`
-            L1DyHttpsOutQps     float64 `json:"L1DyHttpsOutQps" xml:"L1DyHttpsOutQps"`
-            L1StHttpsQps     float64 `json:"L1StHttpsQps" xml:"L1StHttpsQps"`
-            L1StHttpsInnerQps     float64 `json:"L1StHttpsInnerQps" xml:"L1StHttpsInnerQps"`
-            L1StHttpsOutQps     float64 `json:"L1StHttpsOutQps" xml:"L1StHttpsOutQps"`
-            L1DyHttpsAcc     float64 `json:"L1DyHttpsAcc" xml:"L1DyHttpsAcc"`
-            L1DyHttpsInnerAcc     float64 `json:"L1DyHttpsInnerAcc" xml:"L1DyHttpsInnerAcc"`
-            L1DyHttpsOutAcc     float64 `json:"L1DyHttpsOutAcc" xml:"L1DyHttpsOutAcc"`
-            L1StHttpsAcc     float64 `json:"L1StHttpsAcc" xml:"L1StHttpsAcc"`
-            L1StHttpsInnerAcc     float64 `json:"L1StHttpsInnerAcc" xml:"L1StHttpsInnerAcc"`
-            L1StHttpsOutAcc     float64 `json:"L1StHttpsOutAcc" xml:"L1StHttpsOutAcc"`
-                    }   `json:"HttpsStatisticsInfo" xml:"HttpsStatisticsInfo"`
-                } `json:"HttpsStatisticsInfos" xml:"HttpsStatisticsInfos"`
+	*responses.BaseResponse
+	RequestId            string `json:"RequestId" xml:"RequestId"`
+	DomainNames          string `json:"DomainNames" xml:"DomainNames"`
+	DataInterval         string `json:"DataInterval" xml:"DataInterval"`
+	HttpsStatisticsInfos struct {
+		HttpsStatisticsInfo []struct {
+			Time               string  `json:"Time" xml:"Time"`
+			L1HttpsBps         float64 `json:"L1HttpsBps" xml:"L1HttpsBps"`
+			L1HttpsInnerBps    float64 `json:"L1HttpsInnerBps" xml:"L1HttpsInnerBps"`
+			L1HttpsOutBps      float64 `json:"L1HttpsOutBps" xml:"L1HttpsOutBps"`
+			L1HttpsQps         int64   `json:"L1HttpsQps" xml:"L1HttpsQps"`
+			L1HttpsInnerQps    int64   `json:"L1HttpsInnerQps" xml:"L1HttpsInnerQps"`
+			L1HttpsOutQps      int64   `json:"L1HttpsOutQps" xml:"L1HttpsOutQps"`
+			L1HttpsTtraf       int64   `json:"L1HttpsTtraf" xml:"L1HttpsTtraf"`
+			HttpsSrcBps        int64   `json:"HttpsSrcBps" xml:"HttpsSrcBps"`
+			HttpsSrcTraf       int64   `json:"HttpsSrcTraf" xml:"HttpsSrcTraf"`
+			L1HttpsInnerTraf   int64   `json:"L1HttpsInnerTraf" xml:"L1HttpsInnerTraf"`
+			L1HttpsOutTraf     int64   `json:"L1HttpsOutTraf" xml:"L1HttpsOutTraf"`
+			HttpsByteHitRate   float64 `json:"HttpsByteHitRate" xml:"HttpsByteHitRate"`
+			HttpsReqHitRate    float64 `json:"HttpsReqHitRate" xml:"HttpsReqHitRate"`
+			L1HttpsHitRate     float64 `json:"L1HttpsHitRate" xml:"L1HttpsHitRate"`
+			L1HttpsInnerAcc    float64 `json:"L1HttpsInner_acc" xml:"L1HttpsInner_acc"`
+			L1HttpsOutAcc      float64 `json:"L1HttpsOut_acc" xml:"L1HttpsOut_acc"`
+			L1HttpsTacc        float64 `json:"L1HttpsTacc" xml:"L1HttpsTacc"`
+			L1DyHttpsBps       float64 `json:"L1DyHttpsBps" xml:"L1DyHttpsBps"`
+			L1DyHttpsInnerBps  float64 `json:"L1DyHttpsInnerBps" xml:"L1DyHttpsInnerBps"`
+			L1DyHttpsOutBps    float64 `json:"L1DyHttpsOutBps" xml:"L1DyHttpsOutBps"`
+			L1StHttpsBps       float64 `json:"L1StHttpsBps" xml:"L1StHttpsBps"`
+			L1StHttpsInnerBps  float64 `json:"L1StHttpsInnerBps" xml:"L1StHttpsInnerBps"`
+			L1StHttpsOutBps    float64 `json:"L1StHttpsOutBps" xml:"L1StHttpsOutBps"`
+			L1DyHttpsTraf      float64 `json:"l1DyHttpsTraf" xml:"l1DyHttpsTraf"`
+			L1DyHttpsInnerTraf float64 `json:"L1DyHttpsInnerTraf" xml:"L1DyHttpsInnerTraf"`
+			L1DyHttpsOutTraf   float64 `json:"L1DyHttpsOutTraf" xml:"L1DyHttpsOutTraf"`
+			L1StHttpsTraf      float64 `json:"L1StHttpsTraf" xml:"L1StHttpsTraf"`
+			L1StHttpsInnerTraf float64 `json:"L1StHttpsInnerTraf" xml:"L1StHttpsInnerTraf"`
+			L1StHttpsOutTraf   float64 `json:"L1StHttpsOutTraf" xml:"L1StHttpsOutTraf"`
+			L1DyHttpsQps       float64 `json:"L1DyHttpsQps" xml:"L1DyHttpsQps"`
+			L1DyHttpsInnerQps  float64 `json:"L1DyHttpsInnerQps" xml:"L1DyHttpsInnerQps"`
+			L1DyHttpsOutQps    float64 `json:"L1DyHttpsOutQps" xml:"L1DyHttpsOutQps"`
+			L1StHttpsQps       float64 `json:"L1StHttpsQps" xml:"L1StHttpsQps"`
+			L1StHttpsInnerQps  float64 `json:"L1StHttpsInnerQps" xml:"L1StHttpsInnerQps"`
+			L1StHttpsOutQps    float64 `json:"L1StHttpsOutQps" xml:"L1StHttpsOutQps"`
+			L1DyHttpsAcc       float64 `json:"L1DyHttpsAcc" xml:"L1DyHttpsAcc"`
+			L1DyHttpsInnerAcc  float64 `json:"L1DyHttpsInnerAcc" xml:"L1DyHttpsInnerAcc"`
+			L1DyHttpsOutAcc    float64 `json:"L1DyHttpsOutAcc" xml:"L1DyHttpsOutAcc"`
+			L1StHttpsAcc       float64 `json:"L1StHttpsAcc" xml:"L1StHttpsAcc"`
+			L1StHttpsInnerAcc  float64 `json:"L1StHttpsInnerAcc" xml:"L1StHttpsInnerAcc"`
+			L1StHttpsOutAcc    float64 `json:"L1StHttpsOutAcc" xml:"L1StHttpsOutAcc"`
+		} `json:"HttpsStatisticsInfo" xml:"HttpsStatisticsInfo"`
+	} `json:"HttpsStatisticsInfos" xml:"HttpsStatisticsInfos"`
 }
 
 func CreateDescribeDomainHttpsDataRequest() (request *DescribeDomainHttpsDataRequest) {
-request = &DescribeDomainHttpsDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainHttpsData", "", "")
-return
+	request = &DescribeDomainHttpsDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainHttpsData", "", "")
+	return
 }
 
 func CreateDescribeDomainHttpsDataResponse() (response *DescribeDomainHttpsDataResponse) {
-response = &DescribeDomainHttpsDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainHttpsDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_i_s_p_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,101 +16,99 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainISPData(request *DescribeDomainISPDataRequest) (response *DescribeDomainISPDataResponse, err error) {
-response = CreateDescribeDomainISPDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainISPDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainISPDataWithChan(request *DescribeDomainISPDataRequest) (<-chan *DescribeDomainISPDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainISPDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainISPData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainISPDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainISPData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainISPDataWithCallback(request *DescribeDomainISPDataRequest, callback func(response *DescribeDomainISPDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainISPDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainISPData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainISPDataWithCallback(request *DescribeDomainISPDataRequest, callback func(response *DescribeDomainISPDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainISPDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainISPData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainISPDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainISPDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                Value struct {
-                    ISPProportionData []struct {
-            ISP     string `json:"ISP" xml:"ISP"`
-            Proportion     string `json:"Proportion" xml:"Proportion"`
-            IspEname     string `json:"IspEname" xml:"IspEname"`
-            AvgObjectSize     string `json:"AvgObjectSize" xml:"AvgObjectSize"`
-            AvgResponseTime     string `json:"AvgResponseTime" xml:"AvgResponseTime"`
-            Bps     string `json:"Bps" xml:"Bps"`
-            ByteHitRate     string `json:"ByteHitRate" xml:"ByteHitRate"`
-            Qps     string `json:"Qps" xml:"Qps"`
-            ReqErrRate     string `json:"ReqErrRate" xml:"ReqErrRate"`
-            ReqHitRate     string `json:"ReqHitRate" xml:"ReqHitRate"`
-            AvgResponseRate     string `json:"AvgResponseRate" xml:"AvgResponseRate"`
-            TotalBytes     string `json:"TotalBytes" xml:"TotalBytes"`
-            BytesProportion     string `json:"BytesProportion" xml:"BytesProportion"`
-            TotalQuery     string `json:"TotalQuery" xml:"TotalQuery"`
-                    }   `json:"ISPProportionData" xml:"ISPProportionData"`
-                } `json:"Value" xml:"Value"`
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	DomainName   string `json:"DomainName" xml:"DomainName"`
+	DataInterval string `json:"DataInterval" xml:"DataInterval"`
+	StartTime    string `json:"StartTime" xml:"StartTime"`
+	EndTime      string `json:"EndTime" xml:"EndTime"`
+	Value        struct {
+		ISPProportionData []struct {
+			ISP             string `json:"ISP" xml:"ISP"`
+			Proportion      string `json:"Proportion" xml:"Proportion"`
+			IspEname        string `json:"IspEname" xml:"IspEname"`
+			AvgObjectSize   string `json:"AvgObjectSize" xml:"AvgObjectSize"`
+			AvgResponseTime string `json:"AvgResponseTime" xml:"AvgResponseTime"`
+			Bps             string `json:"Bps" xml:"Bps"`
+			ByteHitRate     string `json:"ByteHitRate" xml:"ByteHitRate"`
+			Qps             string `json:"Qps" xml:"Qps"`
+			ReqErrRate      string `json:"ReqErrRate" xml:"ReqErrRate"`
+			ReqHitRate      string `json:"ReqHitRate" xml:"ReqHitRate"`
+			AvgResponseRate string `json:"AvgResponseRate" xml:"AvgResponseRate"`
+			TotalBytes      string `json:"TotalBytes" xml:"TotalBytes"`
+			BytesProportion string `json:"BytesProportion" xml:"BytesProportion"`
+			TotalQuery      string `json:"TotalQuery" xml:"TotalQuery"`
+		} `json:"ISPProportionData" xml:"ISPProportionData"`
+	} `json:"Value" xml:"Value"`
 }
 
 func CreateDescribeDomainISPDataRequest() (request *DescribeDomainISPDataRequest) {
-request = &DescribeDomainISPDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainISPData", "", "")
-return
+	request = &DescribeDomainISPDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainISPData", "", "")
+	return
 }
 
 func CreateDescribeDomainISPDataResponse() (response *DescribeDomainISPDataResponse) {
-response = &DescribeDomainISPDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainISPDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_max95_bps_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,85 +16,83 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainMax95BpsData(request *DescribeDomainMax95BpsDataRequest) (response *DescribeDomainMax95BpsDataResponse, err error) {
-response = CreateDescribeDomainMax95BpsDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainMax95BpsDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainMax95BpsDataWithChan(request *DescribeDomainMax95BpsDataRequest) (<-chan *DescribeDomainMax95BpsDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainMax95BpsDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainMax95BpsData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainMax95BpsDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainMax95BpsData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainMax95BpsDataWithCallback(request *DescribeDomainMax95BpsDataRequest, callback func(response *DescribeDomainMax95BpsDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainMax95BpsDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainMax95BpsData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainMax95BpsDataWithCallback(request *DescribeDomainMax95BpsDataRequest, callback func(response *DescribeDomainMax95BpsDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainMax95BpsDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainMax95BpsData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainMax95BpsDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainMax95BpsDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-            Max95Bps     string `json:"Max95Bps" xml:"Max95Bps"`
-            DomesticMax95Bps     string `json:"DomesticMax95Bps" xml:"DomesticMax95Bps"`
-            OverseasMax95Bps     string `json:"OverseasMax95Bps" xml:"OverseasMax95Bps"`
+	*responses.BaseResponse
+	RequestId        string `json:"RequestId" xml:"RequestId"`
+	DomainName       string `json:"DomainName" xml:"DomainName"`
+	StartTime        string `json:"StartTime" xml:"StartTime"`
+	EndTime          string `json:"EndTime" xml:"EndTime"`
+	Max95Bps         string `json:"Max95Bps" xml:"Max95Bps"`
+	DomesticMax95Bps string `json:"DomesticMax95Bps" xml:"DomesticMax95Bps"`
+	OverseasMax95Bps string `json:"OverseasMax95Bps" xml:"OverseasMax95Bps"`
 }
 
 func CreateDescribeDomainMax95BpsDataRequest() (request *DescribeDomainMax95BpsDataRequest) {
-request = &DescribeDomainMax95BpsDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainMax95BpsData", "", "")
-return
+	request = &DescribeDomainMax95BpsDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainMax95BpsData", "", "")
+	return
 }
 
 func CreateDescribeDomainMax95BpsDataResponse() (response *DescribeDomainMax95BpsDataResponse) {
-response = &DescribeDomainMax95BpsDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainMax95BpsDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_month_billing_bps_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,92 +16,90 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainMonthBillingBpsData(request *DescribeDomainMonthBillingBpsDataRequest) (response *DescribeDomainMonthBillingBpsDataResponse, err error) {
-response = CreateDescribeDomainMonthBillingBpsDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainMonthBillingBpsDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainMonthBillingBpsDataWithChan(request *DescribeDomainMonthBillingBpsDataRequest) (<-chan *DescribeDomainMonthBillingBpsDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainMonthBillingBpsDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainMonthBillingBpsData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainMonthBillingBpsDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainMonthBillingBpsData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainMonthBillingBpsDataWithCallback(request *DescribeDomainMonthBillingBpsDataRequest, callback func(response *DescribeDomainMonthBillingBpsDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainMonthBillingBpsDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainMonthBillingBpsData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainMonthBillingBpsDataWithCallback(request *DescribeDomainMonthBillingBpsDataRequest, callback func(response *DescribeDomainMonthBillingBpsDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainMonthBillingBpsDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainMonthBillingBpsData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainMonthBillingBpsDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                InternetChargeType  string `position:"Query" name:"InternetChargeType"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime            string `position:"Query" name:"EndTime"`
+	StartTime          string `position:"Query" name:"StartTime"`
+	DomainName         string `position:"Query" name:"DomainName"`
+	InternetChargeType string `position:"Query" name:"InternetChargeType"`
+	OwnerId            string `position:"Query" name:"OwnerId"`
+	SecurityToken      string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainMonthBillingBpsDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-            Bandwidth95Bps     float64 `json:"Bandwidth95Bps" xml:"Bandwidth95Bps"`
-            DomesticBandwidth95Bps     float64 `json:"DomesticBandwidth95Bps" xml:"DomesticBandwidth95Bps"`
-            OverseasBandwidth95Bps     float64 `json:"OverseasBandwidth95Bps" xml:"OverseasBandwidth95Bps"`
-            MonthavgBps     float64 `json:"MonthavgBps" xml:"MonthavgBps"`
-            DomesticMonthavgBps     float64 `json:"DomesticMonthavgBps" xml:"DomesticMonthavgBps"`
-            OverseasMonthavgBps     float64 `json:"OverseasMonthavgBps" xml:"OverseasMonthavgBps"`
-            Month4thBps     float64 `json:"Month4thBps" xml:"Month4thBps"`
-            DomesticMonth4thBps     float64 `json:"DomesticMonth4thBps" xml:"DomesticMonth4thBps"`
-            OverseasMonth4thBps     float64 `json:"OverseasMonth4thBps" xml:"OverseasMonth4thBps"`
+	*responses.BaseResponse
+	RequestId              string  `json:"RequestId" xml:"RequestId"`
+	DomainName             string  `json:"DomainName" xml:"DomainName"`
+	StartTime              string  `json:"StartTime" xml:"StartTime"`
+	EndTime                string  `json:"EndTime" xml:"EndTime"`
+	Bandwidth95Bps         float64 `json:"Bandwidth95Bps" xml:"Bandwidth95Bps"`
+	DomesticBandwidth95Bps float64 `json:"DomesticBandwidth95Bps" xml:"DomesticBandwidth95Bps"`
+	OverseasBandwidth95Bps float64 `json:"OverseasBandwidth95Bps" xml:"OverseasBandwidth95Bps"`
+	MonthavgBps            float64 `json:"MonthavgBps" xml:"MonthavgBps"`
+	DomesticMonthavgBps    float64 `json:"DomesticMonthavgBps" xml:"DomesticMonthavgBps"`
+	OverseasMonthavgBps    float64 `json:"OverseasMonthavgBps" xml:"OverseasMonthavgBps"`
+	Month4thBps            float64 `json:"Month4thBps" xml:"Month4thBps"`
+	DomesticMonth4thBps    float64 `json:"DomesticMonth4thBps" xml:"DomesticMonth4thBps"`
+	OverseasMonth4thBps    float64 `json:"OverseasMonth4thBps" xml:"OverseasMonth4thBps"`
 }
 
 func CreateDescribeDomainMonthBillingBpsDataRequest() (request *DescribeDomainMonthBillingBpsDataRequest) {
-request = &DescribeDomainMonthBillingBpsDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainMonthBillingBpsData", "", "")
-return
+	request = &DescribeDomainMonthBillingBpsDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainMonthBillingBpsData", "", "")
+	return
 }
 
 func CreateDescribeDomainMonthBillingBpsDataResponse() (response *DescribeDomainMonthBillingBpsDataResponse) {
-response = &DescribeDomainMonthBillingBpsDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainMonthBillingBpsDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_online_user_number.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,85 +16,83 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainOnlineUserNumber(request *DescribeDomainOnlineUserNumberRequest) (response *DescribeDomainOnlineUserNumberResponse, err error) {
-response = CreateDescribeDomainOnlineUserNumberResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainOnlineUserNumberResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainOnlineUserNumberWithChan(request *DescribeDomainOnlineUserNumberRequest) (<-chan *DescribeDomainOnlineUserNumberResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainOnlineUserNumberResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainOnlineUserNumber(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainOnlineUserNumberResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainOnlineUserNumber(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainOnlineUserNumberWithCallback(request *DescribeDomainOnlineUserNumberRequest, callback func(response *DescribeDomainOnlineUserNumberResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainOnlineUserNumberResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainOnlineUserNumber(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainOnlineUserNumberWithCallback(request *DescribeDomainOnlineUserNumberRequest, callback func(response *DescribeDomainOnlineUserNumberResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainOnlineUserNumberResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainOnlineUserNumber(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainOnlineUserNumberRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainOnlineUserNumberResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-                LiveStreamOnlineUserNumInfos struct {
-                    LiveStreamOnlineUserNumInfo []struct {
-            Time     string `json:"Time" xml:"Time"`
-            UserNumber     int64 `json:"UserNumber" xml:"UserNumber"`
-                    }   `json:"LiveStreamOnlineUserNumInfo" xml:"LiveStreamOnlineUserNumInfo"`
-                } `json:"LiveStreamOnlineUserNumInfos" xml:"LiveStreamOnlineUserNumInfos"`
+	*responses.BaseResponse
+	RequestId                    string `json:"RequestId" xml:"RequestId"`
+	LiveStreamOnlineUserNumInfos struct {
+		LiveStreamOnlineUserNumInfo []struct {
+			Time       string `json:"Time" xml:"Time"`
+			UserNumber int64  `json:"UserNumber" xml:"UserNumber"`
+		} `json:"LiveStreamOnlineUserNumInfo" xml:"LiveStreamOnlineUserNumInfo"`
+	} `json:"LiveStreamOnlineUserNumInfos" xml:"LiveStreamOnlineUserNumInfos"`
 }
 
 func CreateDescribeDomainOnlineUserNumberRequest() (request *DescribeDomainOnlineUserNumberRequest) {
-request = &DescribeDomainOnlineUserNumberRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainOnlineUserNumber", "", "")
-return
+	request = &DescribeDomainOnlineUserNumberRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainOnlineUserNumber", "", "")
+	return
 }
 
 func CreateDescribeDomainOnlineUserNumberResponse() (response *DescribeDomainOnlineUserNumberResponse) {
-response = &DescribeDomainOnlineUserNumberResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainOnlineUserNumberResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_path_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,97 +16,95 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainPathData(request *DescribeDomainPathDataRequest) (response *DescribeDomainPathDataResponse, err error) {
-response = CreateDescribeDomainPathDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainPathDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainPathDataWithChan(request *DescribeDomainPathDataRequest) (<-chan *DescribeDomainPathDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainPathDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainPathData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainPathDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainPathData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainPathDataWithCallback(request *DescribeDomainPathDataRequest, callback func(response *DescribeDomainPathDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainPathDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainPathData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainPathDataWithCallback(request *DescribeDomainPathDataRequest, callback func(response *DescribeDomainPathDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainPathDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainPathData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainPathDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                PageSize  string `position:"Query" name:"PageSize"`
-                Version  string `position:"Query" name:"Version"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                Path  string `position:"Query" name:"Path"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	PageSize      string `position:"Query" name:"PageSize"`
+	Version       string `position:"Query" name:"Version"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	Path          string `position:"Query" name:"Path"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	PageNumber    string `position:"Query" name:"PageNumber"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainPathDataResponse struct {
-*responses.BaseResponse
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-            PageSize     int `json:"PageSize" xml:"PageSize"`
-            PageNumber     int `json:"PageNumber" xml:"PageNumber"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            TotalCount     int `json:"TotalCount" xml:"TotalCount"`
-                PathDataPerInterval struct {
-                    UsageData []struct {
-            Traffic     int `json:"Traffic" xml:"Traffic"`
-            Acc     int `json:"Acc" xml:"Acc"`
-            Path     string `json:"Path" xml:"Path"`
-            Time     string `json:"Time" xml:"Time"`
-                    }   `json:"UsageData" xml:"UsageData"`
-                } `json:"PathDataPerInterval" xml:"PathDataPerInterval"`
+	*responses.BaseResponse
+	DomainName          string `json:"DomainName" xml:"DomainName"`
+	StartTime           string `json:"StartTime" xml:"StartTime"`
+	EndTime             string `json:"EndTime" xml:"EndTime"`
+	PageSize            int    `json:"PageSize" xml:"PageSize"`
+	PageNumber          int    `json:"PageNumber" xml:"PageNumber"`
+	DataInterval        string `json:"DataInterval" xml:"DataInterval"`
+	TotalCount          int    `json:"TotalCount" xml:"TotalCount"`
+	PathDataPerInterval struct {
+		UsageData []struct {
+			Traffic int    `json:"Traffic" xml:"Traffic"`
+			Acc     int    `json:"Acc" xml:"Acc"`
+			Path    string `json:"Path" xml:"Path"`
+			Time    string `json:"Time" xml:"Time"`
+		} `json:"UsageData" xml:"UsageData"`
+	} `json:"PathDataPerInterval" xml:"PathDataPerInterval"`
 }
 
 func CreateDescribeDomainPathDataRequest() (request *DescribeDomainPathDataRequest) {
-request = &DescribeDomainPathDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainPathData", "", "")
-return
+	request = &DescribeDomainPathDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainPathData", "", "")
+	return
 }
 
 func CreateDescribeDomainPathDataResponse() (response *DescribeDomainPathDataResponse) {
-response = &DescribeDomainPathDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainPathDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_pv_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,87 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainPvData(request *DescribeDomainPvDataRequest) (response *DescribeDomainPvDataResponse, err error) {
-response = CreateDescribeDomainPvDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainPvDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainPvDataWithChan(request *DescribeDomainPvDataRequest) (<-chan *DescribeDomainPvDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainPvDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainPvData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainPvDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainPvData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainPvDataWithCallback(request *DescribeDomainPvDataRequest, callback func(response *DescribeDomainPvDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainPvDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainPvData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainPvDataWithCallback(request *DescribeDomainPvDataRequest, callback func(response *DescribeDomainPvDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainPvDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainPvData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainPvDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainPvDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                PvDataInterval struct {
-                    UsageData []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-                    }   `json:"UsageData" xml:"UsageData"`
-                } `json:"PvDataInterval" xml:"PvDataInterval"`
+	*responses.BaseResponse
+	RequestId      string `json:"RequestId" xml:"RequestId"`
+	DomainName     string `json:"DomainName" xml:"DomainName"`
+	DataInterval   string `json:"DataInterval" xml:"DataInterval"`
+	StartTime      string `json:"StartTime" xml:"StartTime"`
+	EndTime        string `json:"EndTime" xml:"EndTime"`
+	PvDataInterval struct {
+		UsageData []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     string `json:"Value" xml:"Value"`
+		} `json:"UsageData" xml:"UsageData"`
+	} `json:"PvDataInterval" xml:"PvDataInterval"`
 }
 
 func CreateDescribeDomainPvDataRequest() (request *DescribeDomainPvDataRequest) {
-request = &DescribeDomainPvDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainPvData", "", "")
-return
+	request = &DescribeDomainPvDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainPvData", "", "")
+	return
 }
 
 func CreateDescribeDomainPvDataResponse() (response *DescribeDomainPvDataResponse) {
-response = &DescribeDomainPvDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainPvDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_qo_s_rt.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,91 +16,89 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainQoSRt(request *DescribeDomainQoSRtRequest) (response *DescribeDomainQoSRtResponse, err error) {
-response = CreateDescribeDomainQoSRtResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainQoSRtResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainQoSRtWithChan(request *DescribeDomainQoSRtRequest) (<-chan *DescribeDomainQoSRtResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainQoSRtResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainQoSRt(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainQoSRtResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainQoSRt(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainQoSRtWithCallback(request *DescribeDomainQoSRtRequest, callback func(response *DescribeDomainQoSRtResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainQoSRtResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainQoSRt(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainQoSRtWithCallback(request *DescribeDomainQoSRtRequest, callback func(response *DescribeDomainQoSRtResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainQoSRtResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainQoSRt(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainQoSRtRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                Ip  string `position:"Query" name:"Ip"`
-                Version  string `position:"Query" name:"Version"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	Ip            string `position:"Query" name:"Ip"`
+	Version       string `position:"Query" name:"Version"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainQoSRtResponse struct {
-*responses.BaseResponse
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-            Ip     string `json:"Ip" xml:"Ip"`
-                Content struct {
-                    Data []struct {
-            More5s     string `json:"More5s" xml:"More5s"`
-            Time     string `json:"Time" xml:"Time"`
-            More3s     string `json:"More3s" xml:"More3s"`
-                    }   `json:"Data" xml:"Data"`
-                } `json:"Content" xml:"Content"`
+	*responses.BaseResponse
+	DomainName string `json:"DomainName" xml:"DomainName"`
+	StartTime  string `json:"StartTime" xml:"StartTime"`
+	EndTime    string `json:"EndTime" xml:"EndTime"`
+	Ip         string `json:"Ip" xml:"Ip"`
+	Content    struct {
+		Data []struct {
+			More5s string `json:"More5s" xml:"More5s"`
+			Time   string `json:"Time" xml:"Time"`
+			More3s string `json:"More3s" xml:"More3s"`
+		} `json:"Data" xml:"Data"`
+	} `json:"Content" xml:"Content"`
 }
 
 func CreateDescribeDomainQoSRtRequest() (request *DescribeDomainQoSRtRequest) {
-request = &DescribeDomainQoSRtRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainQoSRt", "", "")
-return
+	request = &DescribeDomainQoSRtRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainQoSRt", "", "")
+	return
 }
 
 func CreateDescribeDomainQoSRtResponse() (response *DescribeDomainQoSRtResponse) {
-response = &DescribeDomainQoSRtResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainQoSRtResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_qps_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,106 +16,104 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainQpsData(request *DescribeDomainQpsDataRequest) (response *DescribeDomainQpsDataResponse, err error) {
-response = CreateDescribeDomainQpsDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainQpsDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainQpsDataWithChan(request *DescribeDomainQpsDataRequest) (<-chan *DescribeDomainQpsDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainQpsDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainQpsData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainQpsDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainQpsData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainQpsDataWithCallback(request *DescribeDomainQpsDataRequest, callback func(response *DescribeDomainQpsDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainQpsDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainQpsData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainQpsDataWithCallback(request *DescribeDomainQpsDataRequest, callback func(response *DescribeDomainQpsDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainQpsDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainQpsData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainQpsDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                Interval  string `position:"Query" name:"Interval"`
-                FixTimeGap  string `position:"Query" name:"FixTimeGap"`
-                LocationNameEn  string `position:"Query" name:"LocationNameEn"`
-                IspNameEn  string `position:"Query" name:"IspNameEn"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                DomainType  string `position:"Query" name:"DomainType"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                TimeMerge  string `position:"Query" name:"TimeMerge"`
+	*requests.RpcRequest
+	EndTime        string `position:"Query" name:"EndTime"`
+	StartTime      string `position:"Query" name:"StartTime"`
+	Interval       string `position:"Query" name:"Interval"`
+	FixTimeGap     string `position:"Query" name:"FixTimeGap"`
+	LocationNameEn string `position:"Query" name:"LocationNameEn"`
+	IspNameEn      string `position:"Query" name:"IspNameEn"`
+	OwnerId        string `position:"Query" name:"OwnerId"`
+	DomainType     string `position:"Query" name:"DomainType"`
+	DomainName     string `position:"Query" name:"DomainName"`
+	SecurityToken  string `position:"Query" name:"SecurityToken"`
+	TimeMerge      string `position:"Query" name:"TimeMerge"`
 }
 
-
 type DescribeDomainQpsDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                QpsDataInterval struct {
-                    DataModule []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-            DomesticValue     string `json:"DomesticValue" xml:"DomesticValue"`
-            OverseasValue     string `json:"OverseasValue" xml:"OverseasValue"`
-            AccValue     string `json:"AccValue" xml:"AccValue"`
-            AccDomesticValue     string `json:"AccDomesticValue" xml:"AccDomesticValue"`
-            AccOverseasValue     string `json:"AccOverseasValue" xml:"AccOverseasValue"`
-            DynamicValue     string `json:"DynamicValue" xml:"DynamicValue"`
-            DynamicDomesticValue     string `json:"DynamicDomesticValue" xml:"DynamicDomesticValue"`
-            DynamicOverseasValue     string `json:"DynamicOverseasValue" xml:"DynamicOverseasValue"`
-            StaticValue     string `json:"StaticValue" xml:"StaticValue"`
-            StaticDomesticValue     string `json:"StaticDomesticValue" xml:"StaticDomesticValue"`
-            StaticOverseasValue     string `json:"StaticOverseasValue" xml:"StaticOverseasValue"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"QpsDataInterval" xml:"QpsDataInterval"`
+	*responses.BaseResponse
+	RequestId       string `json:"RequestId" xml:"RequestId"`
+	DomainName      string `json:"DomainName" xml:"DomainName"`
+	DataInterval    string `json:"DataInterval" xml:"DataInterval"`
+	StartTime       string `json:"StartTime" xml:"StartTime"`
+	EndTime         string `json:"EndTime" xml:"EndTime"`
+	QpsDataInterval struct {
+		DataModule []struct {
+			TimeStamp            string `json:"TimeStamp" xml:"TimeStamp"`
+			Value                string `json:"Value" xml:"Value"`
+			DomesticValue        string `json:"DomesticValue" xml:"DomesticValue"`
+			OverseasValue        string `json:"OverseasValue" xml:"OverseasValue"`
+			AccValue             string `json:"AccValue" xml:"AccValue"`
+			AccDomesticValue     string `json:"AccDomesticValue" xml:"AccDomesticValue"`
+			AccOverseasValue     string `json:"AccOverseasValue" xml:"AccOverseasValue"`
+			DynamicValue         string `json:"DynamicValue" xml:"DynamicValue"`
+			DynamicDomesticValue string `json:"DynamicDomesticValue" xml:"DynamicDomesticValue"`
+			DynamicOverseasValue string `json:"DynamicOverseasValue" xml:"DynamicOverseasValue"`
+			StaticValue          string `json:"StaticValue" xml:"StaticValue"`
+			StaticDomesticValue  string `json:"StaticDomesticValue" xml:"StaticDomesticValue"`
+			StaticOverseasValue  string `json:"StaticOverseasValue" xml:"StaticOverseasValue"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"QpsDataInterval" xml:"QpsDataInterval"`
 }
 
 func CreateDescribeDomainQpsDataRequest() (request *DescribeDomainQpsDataRequest) {
-request = &DescribeDomainQpsDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainQpsData", "", "")
-return
+	request = &DescribeDomainQpsDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainQpsData", "", "")
+	return
 }
 
 func CreateDescribeDomainQpsDataResponse() (response *DescribeDomainQpsDataResponse) {
-response = &DescribeDomainQpsDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainQpsDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_real_time_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,90 +16,88 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainRealTimeData(request *DescribeDomainRealTimeDataRequest) (response *DescribeDomainRealTimeDataResponse, err error) {
-response = CreateDescribeDomainRealTimeDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainRealTimeDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainRealTimeDataWithChan(request *DescribeDomainRealTimeDataRequest) (<-chan *DescribeDomainRealTimeDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainRealTimeDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainRealTimeData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainRealTimeDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainRealTimeData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainRealTimeDataWithCallback(request *DescribeDomainRealTimeDataRequest, callback func(response *DescribeDomainRealTimeDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainRealTimeDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainRealTimeData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainRealTimeDataWithCallback(request *DescribeDomainRealTimeDataRequest, callback func(response *DescribeDomainRealTimeDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainRealTimeDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainRealTimeData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainRealTimeDataRequest struct {
-*requests.RpcRequest
-                Field  string `position:"Query" name:"Field"`
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	Field         string `position:"Query" name:"Field"`
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainRealTimeDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            Field     string `json:"Field" xml:"Field"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                DataPerInterval struct {
-                    DataModule []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"DataPerInterval" xml:"DataPerInterval"`
+	*responses.BaseResponse
+	RequestId       string `json:"RequestId" xml:"RequestId"`
+	DomainName      string `json:"DomainName" xml:"DomainName"`
+	Field           string `json:"Field" xml:"Field"`
+	StartTime       string `json:"StartTime" xml:"StartTime"`
+	EndTime         string `json:"EndTime" xml:"EndTime"`
+	DataPerInterval struct {
+		DataModule []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     string `json:"Value" xml:"Value"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"DataPerInterval" xml:"DataPerInterval"`
 }
 
 func CreateDescribeDomainRealTimeDataRequest() (request *DescribeDomainRealTimeDataRequest) {
-request = &DescribeDomainRealTimeDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainRealTimeData", "", "")
-return
+	request = &DescribeDomainRealTimeDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainRealTimeData", "", "")
+	return
 }
 
 func CreateDescribeDomainRealTimeDataResponse() (response *DescribeDomainRealTimeDataResponse) {
-response = &DescribeDomainRealTimeDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainRealTimeDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_region_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,101 +16,99 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainRegionData(request *DescribeDomainRegionDataRequest) (response *DescribeDomainRegionDataResponse, err error) {
-response = CreateDescribeDomainRegionDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainRegionDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainRegionDataWithChan(request *DescribeDomainRegionDataRequest) (<-chan *DescribeDomainRegionDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainRegionDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainRegionData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainRegionDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainRegionData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainRegionDataWithCallback(request *DescribeDomainRegionDataRequest, callback func(response *DescribeDomainRegionDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainRegionDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainRegionData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainRegionDataWithCallback(request *DescribeDomainRegionDataRequest, callback func(response *DescribeDomainRegionDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainRegionDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainRegionData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainRegionDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainRegionDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                Value struct {
-                    RegionProportionData []struct {
-            Region     string `json:"Region" xml:"Region"`
-            Proportion     string `json:"Proportion" xml:"Proportion"`
-            RegionEname     string `json:"RegionEname" xml:"RegionEname"`
-            AvgObjectSize     string `json:"AvgObjectSize" xml:"AvgObjectSize"`
-            AvgResponseTime     string `json:"AvgResponseTime" xml:"AvgResponseTime"`
-            Bps     string `json:"Bps" xml:"Bps"`
-            ByteHitRate     string `json:"ByteHitRate" xml:"ByteHitRate"`
-            Qps     string `json:"Qps" xml:"Qps"`
-            ReqErrRate     string `json:"ReqErrRate" xml:"ReqErrRate"`
-            ReqHitRate     string `json:"ReqHitRate" xml:"ReqHitRate"`
-            AvgResponseRate     string `json:"AvgResponseRate" xml:"AvgResponseRate"`
-            TotalBytes     string `json:"TotalBytes" xml:"TotalBytes"`
-            BytesProportion     string `json:"BytesProportion" xml:"BytesProportion"`
-            TotalQuery     string `json:"TotalQuery" xml:"TotalQuery"`
-                    }   `json:"RegionProportionData" xml:"RegionProportionData"`
-                } `json:"Value" xml:"Value"`
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	DomainName   string `json:"DomainName" xml:"DomainName"`
+	DataInterval string `json:"DataInterval" xml:"DataInterval"`
+	StartTime    string `json:"StartTime" xml:"StartTime"`
+	EndTime      string `json:"EndTime" xml:"EndTime"`
+	Value        struct {
+		RegionProportionData []struct {
+			Region          string `json:"Region" xml:"Region"`
+			Proportion      string `json:"Proportion" xml:"Proportion"`
+			RegionEname     string `json:"RegionEname" xml:"RegionEname"`
+			AvgObjectSize   string `json:"AvgObjectSize" xml:"AvgObjectSize"`
+			AvgResponseTime string `json:"AvgResponseTime" xml:"AvgResponseTime"`
+			Bps             string `json:"Bps" xml:"Bps"`
+			ByteHitRate     string `json:"ByteHitRate" xml:"ByteHitRate"`
+			Qps             string `json:"Qps" xml:"Qps"`
+			ReqErrRate      string `json:"ReqErrRate" xml:"ReqErrRate"`
+			ReqHitRate      string `json:"ReqHitRate" xml:"ReqHitRate"`
+			AvgResponseRate string `json:"AvgResponseRate" xml:"AvgResponseRate"`
+			TotalBytes      string `json:"TotalBytes" xml:"TotalBytes"`
+			BytesProportion string `json:"BytesProportion" xml:"BytesProportion"`
+			TotalQuery      string `json:"TotalQuery" xml:"TotalQuery"`
+		} `json:"RegionProportionData" xml:"RegionProportionData"`
+	} `json:"Value" xml:"Value"`
 }
 
 func CreateDescribeDomainRegionDataRequest() (request *DescribeDomainRegionDataRequest) {
-request = &DescribeDomainRegionDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainRegionData", "", "")
-return
+	request = &DescribeDomainRegionDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainRegionData", "", "")
+	return
 }
 
 func CreateDescribeDomainRegionDataResponse() (response *DescribeDomainRegionDataResponse) {
-response = &DescribeDomainRegionDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainRegionDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_req_hit_rate_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,90 +16,88 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainReqHitRateData(request *DescribeDomainReqHitRateDataRequest) (response *DescribeDomainReqHitRateDataResponse, err error) {
-response = CreateDescribeDomainReqHitRateDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainReqHitRateDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainReqHitRateDataWithChan(request *DescribeDomainReqHitRateDataRequest) (<-chan *DescribeDomainReqHitRateDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainReqHitRateDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainReqHitRateData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainReqHitRateDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainReqHitRateData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainReqHitRateDataWithCallback(request *DescribeDomainReqHitRateDataRequest, callback func(response *DescribeDomainReqHitRateDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainReqHitRateDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainReqHitRateData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainReqHitRateDataWithCallback(request *DescribeDomainReqHitRateDataRequest, callback func(response *DescribeDomainReqHitRateDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainReqHitRateDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainReqHitRateData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainReqHitRateDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                Interval  string `position:"Query" name:"Interval"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	Interval      string `position:"Query" name:"Interval"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainReqHitRateDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                ReqHitRateInterval struct {
-                    DataModule []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"ReqHitRateInterval" xml:"ReqHitRateInterval"`
+	*responses.BaseResponse
+	RequestId          string `json:"RequestId" xml:"RequestId"`
+	DomainName         string `json:"DomainName" xml:"DomainName"`
+	DataInterval       string `json:"DataInterval" xml:"DataInterval"`
+	StartTime          string `json:"StartTime" xml:"StartTime"`
+	EndTime            string `json:"EndTime" xml:"EndTime"`
+	ReqHitRateInterval struct {
+		DataModule []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     string `json:"Value" xml:"Value"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"ReqHitRateInterval" xml:"ReqHitRateInterval"`
 }
 
 func CreateDescribeDomainReqHitRateDataRequest() (request *DescribeDomainReqHitRateDataRequest) {
-request = &DescribeDomainReqHitRateDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainReqHitRateData", "", "")
-return
+	request = &DescribeDomainReqHitRateDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainReqHitRateData", "", "")
+	return
 }
 
 func CreateDescribeDomainReqHitRateDataResponse() (response *DescribeDomainReqHitRateDataResponse) {
-response = &DescribeDomainReqHitRateDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainReqHitRateDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_slow_ratio.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,99 +16,97 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainSlowRatio(request *DescribeDomainSlowRatioRequest) (response *DescribeDomainSlowRatioResponse, err error) {
-response = CreateDescribeDomainSlowRatioResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainSlowRatioResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainSlowRatioWithChan(request *DescribeDomainSlowRatioRequest) (<-chan *DescribeDomainSlowRatioResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainSlowRatioResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainSlowRatio(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainSlowRatioResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainSlowRatio(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainSlowRatioWithCallback(request *DescribeDomainSlowRatioRequest, callback func(response *DescribeDomainSlowRatioResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainSlowRatioResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainSlowRatio(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainSlowRatioWithCallback(request *DescribeDomainSlowRatioRequest, callback func(response *DescribeDomainSlowRatioResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainSlowRatioResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainSlowRatio(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainSlowRatioRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                PageSize  string `position:"Query" name:"PageSize"`
-                Version  string `position:"Query" name:"Version"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	PageSize      string `position:"Query" name:"PageSize"`
+	Version       string `position:"Query" name:"Version"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	PageNumber    string `position:"Query" name:"PageNumber"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainSlowRatioResponse struct {
-*responses.BaseResponse
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-            DataInterval     int `json:"DataInterval" xml:"DataInterval"`
-            PageNumber     int `json:"PageNumber" xml:"PageNumber"`
-            PageSize     int `json:"PageSize" xml:"PageSize"`
-            TotalCount     int `json:"TotalCount" xml:"TotalCount"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-                SlowRatioDataPerInterval struct {
-                    SlowRatioData []struct {
-            TotalUsers     int `json:"TotalUsers" xml:"TotalUsers"`
-            SlowUsers     int `json:"SlowUsers" xml:"SlowUsers"`
-            SlowRatio     float64 `json:"SlowRatio" xml:"SlowRatio"`
-            RegionNameZh     string `json:"RegionNameZh" xml:"RegionNameZh"`
-            RegionNameEn     string `json:"RegionNameEn" xml:"RegionNameEn"`
-            IspNameZh     string `json:"IspNameZh" xml:"IspNameZh"`
-            IspNameEn     string `json:"IspNameEn" xml:"IspNameEn"`
-            Time     string `json:"Time" xml:"Time"`
-                    }   `json:"SlowRatioData" xml:"SlowRatioData"`
-                } `json:"SlowRatioDataPerInterval" xml:"SlowRatioDataPerInterval"`
+	*responses.BaseResponse
+	EndTime                  string `json:"EndTime" xml:"EndTime"`
+	DataInterval             int    `json:"DataInterval" xml:"DataInterval"`
+	PageNumber               int    `json:"PageNumber" xml:"PageNumber"`
+	PageSize                 int    `json:"PageSize" xml:"PageSize"`
+	TotalCount               int    `json:"TotalCount" xml:"TotalCount"`
+	StartTime                string `json:"StartTime" xml:"StartTime"`
+	SlowRatioDataPerInterval struct {
+		SlowRatioData []struct {
+			TotalUsers   int     `json:"TotalUsers" xml:"TotalUsers"`
+			SlowUsers    int     `json:"SlowUsers" xml:"SlowUsers"`
+			SlowRatio    float64 `json:"SlowRatio" xml:"SlowRatio"`
+			RegionNameZh string  `json:"RegionNameZh" xml:"RegionNameZh"`
+			RegionNameEn string  `json:"RegionNameEn" xml:"RegionNameEn"`
+			IspNameZh    string  `json:"IspNameZh" xml:"IspNameZh"`
+			IspNameEn    string  `json:"IspNameEn" xml:"IspNameEn"`
+			Time         string  `json:"Time" xml:"Time"`
+		} `json:"SlowRatioData" xml:"SlowRatioData"`
+	} `json:"SlowRatioDataPerInterval" xml:"SlowRatioDataPerInterval"`
 }
 
 func CreateDescribeDomainSlowRatioRequest() (request *DescribeDomainSlowRatioRequest) {
-request = &DescribeDomainSlowRatioRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainSlowRatio", "", "")
-return
+	request = &DescribeDomainSlowRatioRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainSlowRatio", "", "")
+	return
 }
 
 func CreateDescribeDomainSlowRatioResponse() (response *DescribeDomainSlowRatioResponse) {
-response = &DescribeDomainSlowRatioResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainSlowRatioResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_src_bps_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,92 +16,90 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainSrcBpsData(request *DescribeDomainSrcBpsDataRequest) (response *DescribeDomainSrcBpsDataResponse, err error) {
-response = CreateDescribeDomainSrcBpsDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainSrcBpsDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainSrcBpsDataWithChan(request *DescribeDomainSrcBpsDataRequest) (<-chan *DescribeDomainSrcBpsDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainSrcBpsDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainSrcBpsData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainSrcBpsDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainSrcBpsData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainSrcBpsDataWithCallback(request *DescribeDomainSrcBpsDataRequest, callback func(response *DescribeDomainSrcBpsDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainSrcBpsDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainSrcBpsData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainSrcBpsDataWithCallback(request *DescribeDomainSrcBpsDataRequest, callback func(response *DescribeDomainSrcBpsDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainSrcBpsDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainSrcBpsData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainSrcBpsDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                Interval  string `position:"Query" name:"Interval"`
-                FixTimeGap  string `position:"Query" name:"FixTimeGap"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                TimeMerge  string `position:"Query" name:"TimeMerge"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	Interval      string `position:"Query" name:"Interval"`
+	FixTimeGap    string `position:"Query" name:"FixTimeGap"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
+	TimeMerge     string `position:"Query" name:"TimeMerge"`
 }
 
-
 type DescribeDomainSrcBpsDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                SrcBpsDataPerInterval struct {
-                    DataModule []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"SrcBpsDataPerInterval" xml:"SrcBpsDataPerInterval"`
+	*responses.BaseResponse
+	RequestId             string `json:"RequestId" xml:"RequestId"`
+	DomainName            string `json:"DomainName" xml:"DomainName"`
+	DataInterval          string `json:"DataInterval" xml:"DataInterval"`
+	StartTime             string `json:"StartTime" xml:"StartTime"`
+	EndTime               string `json:"EndTime" xml:"EndTime"`
+	SrcBpsDataPerInterval struct {
+		DataModule []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     string `json:"Value" xml:"Value"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"SrcBpsDataPerInterval" xml:"SrcBpsDataPerInterval"`
 }
 
 func CreateDescribeDomainSrcBpsDataRequest() (request *DescribeDomainSrcBpsDataRequest) {
-request = &DescribeDomainSrcBpsDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainSrcBpsData", "", "")
-return
+	request = &DescribeDomainSrcBpsDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainSrcBpsData", "", "")
+	return
 }
 
 func CreateDescribeDomainSrcBpsDataResponse() (response *DescribeDomainSrcBpsDataResponse) {
-response = &DescribeDomainSrcBpsDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainSrcBpsDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_src_flow_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,92 +16,90 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainSrcFlowData(request *DescribeDomainSrcFlowDataRequest) (response *DescribeDomainSrcFlowDataResponse, err error) {
-response = CreateDescribeDomainSrcFlowDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainSrcFlowDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainSrcFlowDataWithChan(request *DescribeDomainSrcFlowDataRequest) (<-chan *DescribeDomainSrcFlowDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainSrcFlowDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainSrcFlowData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainSrcFlowDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainSrcFlowData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainSrcFlowDataWithCallback(request *DescribeDomainSrcFlowDataRequest, callback func(response *DescribeDomainSrcFlowDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainSrcFlowDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainSrcFlowData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainSrcFlowDataWithCallback(request *DescribeDomainSrcFlowDataRequest, callback func(response *DescribeDomainSrcFlowDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainSrcFlowDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainSrcFlowData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainSrcFlowDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                Interval  string `position:"Query" name:"Interval"`
-                FixTimeGap  string `position:"Query" name:"FixTimeGap"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                TimeMerge  string `position:"Query" name:"TimeMerge"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	Interval      string `position:"Query" name:"Interval"`
+	FixTimeGap    string `position:"Query" name:"FixTimeGap"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
+	TimeMerge     string `position:"Query" name:"TimeMerge"`
 }
 
-
 type DescribeDomainSrcFlowDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                SrcFlowDataPerInterval struct {
-                    DataModule []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-                    }   `json:"DataModule" xml:"DataModule"`
-                } `json:"SrcFlowDataPerInterval" xml:"SrcFlowDataPerInterval"`
+	*responses.BaseResponse
+	RequestId              string `json:"RequestId" xml:"RequestId"`
+	DomainName             string `json:"DomainName" xml:"DomainName"`
+	DataInterval           string `json:"DataInterval" xml:"DataInterval"`
+	StartTime              string `json:"StartTime" xml:"StartTime"`
+	EndTime                string `json:"EndTime" xml:"EndTime"`
+	SrcFlowDataPerInterval struct {
+		DataModule []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     string `json:"Value" xml:"Value"`
+		} `json:"DataModule" xml:"DataModule"`
+	} `json:"SrcFlowDataPerInterval" xml:"SrcFlowDataPerInterval"`
 }
 
 func CreateDescribeDomainSrcFlowDataRequest() (request *DescribeDomainSrcFlowDataRequest) {
-request = &DescribeDomainSrcFlowDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainSrcFlowData", "", "")
-return
+	request = &DescribeDomainSrcFlowDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainSrcFlowData", "", "")
+	return
 }
 
 func CreateDescribeDomainSrcFlowDataResponse() (response *DescribeDomainSrcFlowDataResponse) {
-response = &DescribeDomainSrcFlowDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainSrcFlowDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_top_refer_visit.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,90 +16,88 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainTopReferVisit(request *DescribeDomainTopReferVisitRequest) (response *DescribeDomainTopReferVisitResponse, err error) {
-response = CreateDescribeDomainTopReferVisitResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainTopReferVisitResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainTopReferVisitWithChan(request *DescribeDomainTopReferVisitRequest) (<-chan *DescribeDomainTopReferVisitResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainTopReferVisitResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainTopReferVisit(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainTopReferVisitResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainTopReferVisit(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainTopReferVisitWithCallback(request *DescribeDomainTopReferVisitRequest, callback func(response *DescribeDomainTopReferVisitResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainTopReferVisitResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainTopReferVisit(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainTopReferVisitWithCallback(request *DescribeDomainTopReferVisitRequest, callback func(response *DescribeDomainTopReferVisitResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainTopReferVisitResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainTopReferVisit(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainTopReferVisitRequest struct {
-*requests.RpcRequest
-                SortBy  string `position:"Query" name:"SortBy"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	SortBy        string `position:"Query" name:"SortBy"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainTopReferVisitResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-                TopReferList struct {
-                    ReferList []struct {
-            ReferDetail     string `json:"ReferDetail" xml:"ReferDetail"`
-            VisitData     string `json:"VisitData" xml:"VisitData"`
-            VisitProportion     float64 `json:"VisitProportion" xml:"VisitProportion"`
-            Flow     string `json:"Flow" xml:"Flow"`
-            FlowProportion     float64 `json:"FlowProportion" xml:"FlowProportion"`
-                    }   `json:"ReferList" xml:"ReferList"`
-                } `json:"TopReferList" xml:"TopReferList"`
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	DomainName   string `json:"DomainName" xml:"DomainName"`
+	StartTime    string `json:"StartTime" xml:"StartTime"`
+	TopReferList struct {
+		ReferList []struct {
+			ReferDetail     string  `json:"ReferDetail" xml:"ReferDetail"`
+			VisitData       string  `json:"VisitData" xml:"VisitData"`
+			VisitProportion float64 `json:"VisitProportion" xml:"VisitProportion"`
+			Flow            string  `json:"Flow" xml:"Flow"`
+			FlowProportion  float64 `json:"FlowProportion" xml:"FlowProportion"`
+		} `json:"ReferList" xml:"ReferList"`
+	} `json:"TopReferList" xml:"TopReferList"`
 }
 
 func CreateDescribeDomainTopReferVisitRequest() (request *DescribeDomainTopReferVisitRequest) {
-request = &DescribeDomainTopReferVisitRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainTopReferVisit", "", "")
-return
+	request = &DescribeDomainTopReferVisitRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainTopReferVisit", "", "")
+	return
 }
 
 func CreateDescribeDomainTopReferVisitResponse() (response *DescribeDomainTopReferVisitResponse) {
-response = &DescribeDomainTopReferVisitResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainTopReferVisitResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_top_url_visit.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,126 +16,124 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainTopUrlVisit(request *DescribeDomainTopUrlVisitRequest) (response *DescribeDomainTopUrlVisitResponse, err error) {
-response = CreateDescribeDomainTopUrlVisitResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainTopUrlVisitResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainTopUrlVisitWithChan(request *DescribeDomainTopUrlVisitRequest) (<-chan *DescribeDomainTopUrlVisitResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainTopUrlVisitResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainTopUrlVisit(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainTopUrlVisitResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainTopUrlVisit(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainTopUrlVisitWithCallback(request *DescribeDomainTopUrlVisitRequest, callback func(response *DescribeDomainTopUrlVisitResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainTopUrlVisitResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainTopUrlVisit(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainTopUrlVisitWithCallback(request *DescribeDomainTopUrlVisitRequest, callback func(response *DescribeDomainTopUrlVisitResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainTopUrlVisitResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainTopUrlVisit(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainTopUrlVisitRequest struct {
-*requests.RpcRequest
-                SortBy  string `position:"Query" name:"SortBy"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	SortBy        string `position:"Query" name:"SortBy"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainTopUrlVisitResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-                AllUrlList struct {
-                    UrlList []struct {
-            UrlDetail     string `json:"UrlDetail" xml:"UrlDetail"`
-            VisitData     string `json:"VisitData" xml:"VisitData"`
-            VisitProportion     float64 `json:"VisitProportion" xml:"VisitProportion"`
-            Flow     string `json:"Flow" xml:"Flow"`
-            FlowProportion     float64 `json:"FlowProportion" xml:"FlowProportion"`
-                    }   `json:"UrlList" xml:"UrlList"`
-                } `json:"AllUrlList" xml:"AllUrlList"`
-                Url200List struct {
-                    UrlList []struct {
-            UrlDetail     string `json:"UrlDetail" xml:"UrlDetail"`
-            VisitData     string `json:"VisitData" xml:"VisitData"`
-            VisitProportion     float64 `json:"VisitProportion" xml:"VisitProportion"`
-            Flow     string `json:"Flow" xml:"Flow"`
-            FlowProportion     float64 `json:"FlowProportion" xml:"FlowProportion"`
-                    }   `json:"UrlList" xml:"UrlList"`
-                } `json:"Url200List" xml:"Url200List"`
-                Url300List struct {
-                    UrlList []struct {
-            UrlDetail     string `json:"UrlDetail" xml:"UrlDetail"`
-            VisitData     string `json:"VisitData" xml:"VisitData"`
-            VisitProportion     float64 `json:"VisitProportion" xml:"VisitProportion"`
-            Flow     string `json:"Flow" xml:"Flow"`
-            FlowProportion     float64 `json:"FlowProportion" xml:"FlowProportion"`
-                    }   `json:"UrlList" xml:"UrlList"`
-                } `json:"Url300List" xml:"Url300List"`
-                Url400List struct {
-                    UrlList []struct {
-            UrlDetail     string `json:"UrlDetail" xml:"UrlDetail"`
-            VisitData     string `json:"VisitData" xml:"VisitData"`
-            VisitProportion     float64 `json:"VisitProportion" xml:"VisitProportion"`
-            Flow     string `json:"Flow" xml:"Flow"`
-            FlowProportion     float64 `json:"FlowProportion" xml:"FlowProportion"`
-                    }   `json:"UrlList" xml:"UrlList"`
-                } `json:"Url400List" xml:"Url400List"`
-                Url500List struct {
-                    UrlList []struct {
-            UrlDetail     string `json:"UrlDetail" xml:"UrlDetail"`
-            VisitData     string `json:"VisitData" xml:"VisitData"`
-            VisitProportion     float64 `json:"VisitProportion" xml:"VisitProportion"`
-            Flow     string `json:"Flow" xml:"Flow"`
-            FlowProportion     float64 `json:"FlowProportion" xml:"FlowProportion"`
-                    }   `json:"UrlList" xml:"UrlList"`
-                } `json:"Url500List" xml:"Url500List"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	DomainName string `json:"DomainName" xml:"DomainName"`
+	StartTime  string `json:"StartTime" xml:"StartTime"`
+	AllUrlList struct {
+		UrlList []struct {
+			UrlDetail       string  `json:"UrlDetail" xml:"UrlDetail"`
+			VisitData       string  `json:"VisitData" xml:"VisitData"`
+			VisitProportion float64 `json:"VisitProportion" xml:"VisitProportion"`
+			Flow            string  `json:"Flow" xml:"Flow"`
+			FlowProportion  float64 `json:"FlowProportion" xml:"FlowProportion"`
+		} `json:"UrlList" xml:"UrlList"`
+	} `json:"AllUrlList" xml:"AllUrlList"`
+	Url200List struct {
+		UrlList []struct {
+			UrlDetail       string  `json:"UrlDetail" xml:"UrlDetail"`
+			VisitData       string  `json:"VisitData" xml:"VisitData"`
+			VisitProportion float64 `json:"VisitProportion" xml:"VisitProportion"`
+			Flow            string  `json:"Flow" xml:"Flow"`
+			FlowProportion  float64 `json:"FlowProportion" xml:"FlowProportion"`
+		} `json:"UrlList" xml:"UrlList"`
+	} `json:"Url200List" xml:"Url200List"`
+	Url300List struct {
+		UrlList []struct {
+			UrlDetail       string  `json:"UrlDetail" xml:"UrlDetail"`
+			VisitData       string  `json:"VisitData" xml:"VisitData"`
+			VisitProportion float64 `json:"VisitProportion" xml:"VisitProportion"`
+			Flow            string  `json:"Flow" xml:"Flow"`
+			FlowProportion  float64 `json:"FlowProportion" xml:"FlowProportion"`
+		} `json:"UrlList" xml:"UrlList"`
+	} `json:"Url300List" xml:"Url300List"`
+	Url400List struct {
+		UrlList []struct {
+			UrlDetail       string  `json:"UrlDetail" xml:"UrlDetail"`
+			VisitData       string  `json:"VisitData" xml:"VisitData"`
+			VisitProportion float64 `json:"VisitProportion" xml:"VisitProportion"`
+			Flow            string  `json:"Flow" xml:"Flow"`
+			FlowProportion  float64 `json:"FlowProportion" xml:"FlowProportion"`
+		} `json:"UrlList" xml:"UrlList"`
+	} `json:"Url400List" xml:"Url400List"`
+	Url500List struct {
+		UrlList []struct {
+			UrlDetail       string  `json:"UrlDetail" xml:"UrlDetail"`
+			VisitData       string  `json:"VisitData" xml:"VisitData"`
+			VisitProportion float64 `json:"VisitProportion" xml:"VisitProportion"`
+			Flow            string  `json:"Flow" xml:"Flow"`
+			FlowProportion  float64 `json:"FlowProportion" xml:"FlowProportion"`
+		} `json:"UrlList" xml:"UrlList"`
+	} `json:"Url500List" xml:"Url500List"`
 }
 
 func CreateDescribeDomainTopUrlVisitRequest() (request *DescribeDomainTopUrlVisitRequest) {
-request = &DescribeDomainTopUrlVisitRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainTopUrlVisit", "", "")
-return
+	request = &DescribeDomainTopUrlVisitRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainTopUrlVisit", "", "")
+	return
 }
 
 func CreateDescribeDomainTopUrlVisitResponse() (response *DescribeDomainTopUrlVisitResponse) {
-response = &DescribeDomainTopUrlVisitResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainTopUrlVisitResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_upstream_bps_of_edge.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,85 +16,83 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainUpstreamBpsOfEdge(request *DescribeDomainUpstreamBpsOfEdgeRequest) (response *DescribeDomainUpstreamBpsOfEdgeResponse, err error) {
-response = CreateDescribeDomainUpstreamBpsOfEdgeResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainUpstreamBpsOfEdgeResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainUpstreamBpsOfEdgeWithChan(request *DescribeDomainUpstreamBpsOfEdgeRequest) (<-chan *DescribeDomainUpstreamBpsOfEdgeResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainUpstreamBpsOfEdgeResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainUpstreamBpsOfEdge(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainUpstreamBpsOfEdgeResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainUpstreamBpsOfEdge(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainUpstreamBpsOfEdgeWithCallback(request *DescribeDomainUpstreamBpsOfEdgeRequest, callback func(response *DescribeDomainUpstreamBpsOfEdgeResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainUpstreamBpsOfEdgeResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainUpstreamBpsOfEdge(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainUpstreamBpsOfEdgeWithCallback(request *DescribeDomainUpstreamBpsOfEdgeRequest, callback func(response *DescribeDomainUpstreamBpsOfEdgeResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainUpstreamBpsOfEdgeResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainUpstreamBpsOfEdge(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainUpstreamBpsOfEdgeRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainUpstreamBpsOfEdgeResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-                BpsDatas struct {
-                    DomainBpsModel []struct {
-            Time     string `json:"Time" xml:"Time"`
-            Bps     float64 `json:"Bps" xml:"Bps"`
-                    }   `json:"DomainBpsModel" xml:"DomainBpsModel"`
-                } `json:"BpsDatas" xml:"BpsDatas"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	BpsDatas  struct {
+		DomainBpsModel []struct {
+			Time string  `json:"Time" xml:"Time"`
+			Bps  float64 `json:"Bps" xml:"Bps"`
+		} `json:"DomainBpsModel" xml:"DomainBpsModel"`
+	} `json:"BpsDatas" xml:"BpsDatas"`
 }
 
 func CreateDescribeDomainUpstreamBpsOfEdgeRequest() (request *DescribeDomainUpstreamBpsOfEdgeRequest) {
-request = &DescribeDomainUpstreamBpsOfEdgeRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainUpstreamBpsOfEdge", "", "")
-return
+	request = &DescribeDomainUpstreamBpsOfEdgeRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainUpstreamBpsOfEdge", "", "")
+	return
 }
 
 func CreateDescribeDomainUpstreamBpsOfEdgeResponse() (response *DescribeDomainUpstreamBpsOfEdgeResponse) {
-response = &DescribeDomainUpstreamBpsOfEdgeResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainUpstreamBpsOfEdgeResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_upstream_of_center.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,85 +16,83 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainUpstreamOfCenter(request *DescribeDomainUpstreamOfCenterRequest) (response *DescribeDomainUpstreamOfCenterResponse, err error) {
-response = CreateDescribeDomainUpstreamOfCenterResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainUpstreamOfCenterResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainUpstreamOfCenterWithChan(request *DescribeDomainUpstreamOfCenterRequest) (<-chan *DescribeDomainUpstreamOfCenterResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainUpstreamOfCenterResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainUpstreamOfCenter(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainUpstreamOfCenterResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainUpstreamOfCenter(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainUpstreamOfCenterWithCallback(request *DescribeDomainUpstreamOfCenterRequest, callback func(response *DescribeDomainUpstreamOfCenterResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainUpstreamOfCenterResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainUpstreamOfCenter(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainUpstreamOfCenterWithCallback(request *DescribeDomainUpstreamOfCenterRequest, callback func(response *DescribeDomainUpstreamOfCenterResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainUpstreamOfCenterResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainUpstreamOfCenter(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainUpstreamOfCenterRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainUpstreamOfCenterResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-                BpsDatas struct {
-                    DomainBpsModel []struct {
-            Time     string `json:"Time" xml:"Time"`
-            Bps     float64 `json:"Bps" xml:"Bps"`
-                    }   `json:"DomainBpsModel" xml:"DomainBpsModel"`
-                } `json:"BpsDatas" xml:"BpsDatas"`
+	*responses.BaseResponse
+	RequestId string `json:"RequestId" xml:"RequestId"`
+	BpsDatas  struct {
+		DomainBpsModel []struct {
+			Time string  `json:"Time" xml:"Time"`
+			Bps  float64 `json:"Bps" xml:"Bps"`
+		} `json:"DomainBpsModel" xml:"DomainBpsModel"`
+	} `json:"BpsDatas" xml:"BpsDatas"`
 }
 
 func CreateDescribeDomainUpstreamOfCenterRequest() (request *DescribeDomainUpstreamOfCenterRequest) {
-request = &DescribeDomainUpstreamOfCenterRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainUpstreamOfCenter", "", "")
-return
+	request = &DescribeDomainUpstreamOfCenterRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainUpstreamOfCenter", "", "")
+	return
 }
 
 func CreateDescribeDomainUpstreamOfCenterResponse() (response *DescribeDomainUpstreamOfCenterResponse) {
-response = &DescribeDomainUpstreamOfCenterResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainUpstreamOfCenterResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domain_uv_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,89 +16,87 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainUvData(request *DescribeDomainUvDataRequest) (response *DescribeDomainUvDataResponse, err error) {
-response = CreateDescribeDomainUvDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainUvDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainUvDataWithChan(request *DescribeDomainUvDataRequest) (<-chan *DescribeDomainUvDataResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainUvDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainUvData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainUvDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainUvData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainUvDataWithCallback(request *DescribeDomainUvDataRequest, callback func(response *DescribeDomainUvDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainUvDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainUvData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainUvDataWithCallback(request *DescribeDomainUvDataRequest, callback func(response *DescribeDomainUvDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainUvDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainUvData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainUvDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainUvDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-                UvDataInterval struct {
-                    UsageData []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Value     string `json:"Value" xml:"Value"`
-                    }   `json:"UsageData" xml:"UsageData"`
-                } `json:"UvDataInterval" xml:"UvDataInterval"`
+	*responses.BaseResponse
+	RequestId      string `json:"RequestId" xml:"RequestId"`
+	DomainName     string `json:"DomainName" xml:"DomainName"`
+	DataInterval   string `json:"DataInterval" xml:"DataInterval"`
+	StartTime      string `json:"StartTime" xml:"StartTime"`
+	EndTime        string `json:"EndTime" xml:"EndTime"`
+	UvDataInterval struct {
+		UsageData []struct {
+			TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
+			Value     string `json:"Value" xml:"Value"`
+		} `json:"UsageData" xml:"UsageData"`
+	} `json:"UvDataInterval" xml:"UvDataInterval"`
 }
 
 func CreateDescribeDomainUvDataRequest() (request *DescribeDomainUvDataRequest) {
-request = &DescribeDomainUvDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainUvData", "", "")
-return
+	request = &DescribeDomainUvDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainUvData", "", "")
+	return
 }
 
 func CreateDescribeDomainUvDataResponse() (response *DescribeDomainUvDataResponse) {
-response = &DescribeDomainUvDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainUvDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domains_by_source.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,95 +16,93 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainsBySource(request *DescribeDomainsBySourceRequest) (response *DescribeDomainsBySourceResponse, err error) {
-response = CreateDescribeDomainsBySourceResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainsBySourceResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainsBySourceWithChan(request *DescribeDomainsBySourceRequest) (<-chan *DescribeDomainsBySourceResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainsBySourceResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainsBySource(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainsBySourceResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainsBySource(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainsBySourceWithCallback(request *DescribeDomainsBySourceRequest, callback func(response *DescribeDomainsBySourceResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainsBySourceResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainsBySource(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainsBySourceWithCallback(request *DescribeDomainsBySourceRequest, callback func(response *DescribeDomainsBySourceResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainsBySourceResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainsBySource(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainsBySourceRequest struct {
-*requests.RpcRequest
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                Sources  string `position:"Query" name:"Sources"`
+	*requests.RpcRequest
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
+	Sources       string `position:"Query" name:"Sources"`
 }
 
-
 type DescribeDomainsBySourceResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            Sources     string `json:"Sources" xml:"Sources"`
-                DomainsList struct {
-                    DomainsData []struct {
-            Source     string `json:"Source" xml:"Source"`
-                Domains struct {
-                DomainNames []    string `json:"domainNames" xml:"domainNames"`
-                } `json:"Domains" xml:"Domains"`
-                DomainInfos struct {
-                    DomainInfo []struct {
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DomainCname     string `json:"DomainCname" xml:"DomainCname"`
-            CreateTime     string `json:"CreateTime" xml:"CreateTime"`
-            UpdateTime     string `json:"UpdateTime" xml:"UpdateTime"`
-            Status     string `json:"Status" xml:"Status"`
-                    }   `json:"domainInfo" xml:"domainInfo"`
-                } `json:"DomainInfos" xml:"DomainInfos"`
-                    }   `json:"DomainsData" xml:"DomainsData"`
-                } `json:"DomainsList" xml:"DomainsList"`
+	*responses.BaseResponse
+	RequestId   string `json:"RequestId" xml:"RequestId"`
+	Sources     string `json:"Sources" xml:"Sources"`
+	DomainsList struct {
+		DomainsData []struct {
+			Source  string `json:"Source" xml:"Source"`
+			Domains struct {
+				DomainNames []string `json:"domainNames" xml:"domainNames"`
+			} `json:"Domains" xml:"Domains"`
+			DomainInfos struct {
+				DomainInfo []struct {
+					DomainName  string `json:"DomainName" xml:"DomainName"`
+					DomainCname string `json:"DomainCname" xml:"DomainCname"`
+					CreateTime  string `json:"CreateTime" xml:"CreateTime"`
+					UpdateTime  string `json:"UpdateTime" xml:"UpdateTime"`
+					Status      string `json:"Status" xml:"Status"`
+				} `json:"domainInfo" xml:"domainInfo"`
+			} `json:"DomainInfos" xml:"DomainInfos"`
+		} `json:"DomainsData" xml:"DomainsData"`
+	} `json:"DomainsList" xml:"DomainsList"`
 }
 
 func CreateDescribeDomainsBySourceRequest() (request *DescribeDomainsBySourceRequest) {
-request = &DescribeDomainsBySourceRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainsBySource", "", "")
-return
+	request = &DescribeDomainsBySourceRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainsBySource", "", "")
+	return
 }
 
 func CreateDescribeDomainsBySourceResponse() (response *DescribeDomainsBySourceResponse) {
-response = &DescribeDomainsBySourceResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainsBySourceResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_domains_usage_by_day.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,107 +16,105 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeDomainsUsageByDay(request *DescribeDomainsUsageByDayRequest) (response *DescribeDomainsUsageByDayResponse, err error) {
-response = CreateDescribeDomainsUsageByDayResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeDomainsUsageByDayResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeDomainsUsageByDayWithChan(request *DescribeDomainsUsageByDayRequest) (<-chan *DescribeDomainsUsageByDayResponse, <-chan error) {
-responseChan := make(chan *DescribeDomainsUsageByDayResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeDomainsUsageByDay(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeDomainsUsageByDayResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeDomainsUsageByDay(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeDomainsUsageByDayWithCallback(request *DescribeDomainsUsageByDayRequest, callback func(response *DescribeDomainsUsageByDayResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeDomainsUsageByDayResponse
-var err error
-defer close(result)
-response, err = client.DescribeDomainsUsageByDay(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeDomainsUsageByDayWithCallback(request *DescribeDomainsUsageByDayRequest, callback func(response *DescribeDomainsUsageByDayResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeDomainsUsageByDayResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeDomainsUsageByDay(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeDomainsUsageByDayRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime       string `position:"Query" name:"EndTime"`
+	StartTime     string `position:"Query" name:"StartTime"`
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeDomainsUsageByDayResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-            UsageTotal struct {
-            BytesHitRate     string `json:"BytesHitRate" xml:"BytesHitRate"`
-            RequestHitRate     string `json:"RequestHitRate" xml:"RequestHitRate"`
-            MaxBps     string `json:"MaxBps" xml:"MaxBps"`
-            MaxBpsTime     string `json:"MaxBpsTime" xml:"MaxBpsTime"`
-            MaxSrcBps     string `json:"MaxSrcBps" xml:"MaxSrcBps"`
-            MaxSrcBpsTime     string `json:"MaxSrcBpsTime" xml:"MaxSrcBpsTime"`
-            TotalAccess     string `json:"TotalAccess" xml:"TotalAccess"`
-            TotalTraffic     string `json:"TotalTraffic" xml:"TotalTraffic"`
-            }  `json:"UsageTotal" xml:"UsageTotal"`
-                UsageByDays struct {
-                    UsageByDay []struct {
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Qps     string `json:"Qps" xml:"Qps"`
-            BytesHitRate     string `json:"BytesHitRate" xml:"BytesHitRate"`
-            RequestHitRate     string `json:"RequestHitRate" xml:"RequestHitRate"`
-            MaxBps     string `json:"MaxBps" xml:"MaxBps"`
-            MaxBpsTime     string `json:"MaxBpsTime" xml:"MaxBpsTime"`
-            MaxSrcBps     string `json:"MaxSrcBps" xml:"MaxSrcBps"`
-            MaxSrcBpsTime     string `json:"MaxSrcBpsTime" xml:"MaxSrcBpsTime"`
-            TotalAccess     string `json:"TotalAccess" xml:"TotalAccess"`
-            TotalTraffic     string `json:"TotalTraffic" xml:"TotalTraffic"`
-                    }   `json:"UsageByDay" xml:"UsageByDay"`
-                } `json:"UsageByDays" xml:"UsageByDays"`
+	*responses.BaseResponse
+	RequestId    string `json:"RequestId" xml:"RequestId"`
+	DomainName   string `json:"DomainName" xml:"DomainName"`
+	DataInterval string `json:"DataInterval" xml:"DataInterval"`
+	StartTime    string `json:"StartTime" xml:"StartTime"`
+	EndTime      string `json:"EndTime" xml:"EndTime"`
+	UsageTotal   struct {
+		BytesHitRate   string `json:"BytesHitRate" xml:"BytesHitRate"`
+		RequestHitRate string `json:"RequestHitRate" xml:"RequestHitRate"`
+		MaxBps         string `json:"MaxBps" xml:"MaxBps"`
+		MaxBpsTime     string `json:"MaxBpsTime" xml:"MaxBpsTime"`
+		MaxSrcBps      string `json:"MaxSrcBps" xml:"MaxSrcBps"`
+		MaxSrcBpsTime  string `json:"MaxSrcBpsTime" xml:"MaxSrcBpsTime"`
+		TotalAccess    string `json:"TotalAccess" xml:"TotalAccess"`
+		TotalTraffic   string `json:"TotalTraffic" xml:"TotalTraffic"`
+	} `json:"UsageTotal" xml:"UsageTotal"`
+	UsageByDays struct {
+		UsageByDay []struct {
+			TimeStamp      string `json:"TimeStamp" xml:"TimeStamp"`
+			Qps            string `json:"Qps" xml:"Qps"`
+			BytesHitRate   string `json:"BytesHitRate" xml:"BytesHitRate"`
+			RequestHitRate string `json:"RequestHitRate" xml:"RequestHitRate"`
+			MaxBps         string `json:"MaxBps" xml:"MaxBps"`
+			MaxBpsTime     string `json:"MaxBpsTime" xml:"MaxBpsTime"`
+			MaxSrcBps      string `json:"MaxSrcBps" xml:"MaxSrcBps"`
+			MaxSrcBpsTime  string `json:"MaxSrcBpsTime" xml:"MaxSrcBpsTime"`
+			TotalAccess    string `json:"TotalAccess" xml:"TotalAccess"`
+			TotalTraffic   string `json:"TotalTraffic" xml:"TotalTraffic"`
+		} `json:"UsageByDay" xml:"UsageByDay"`
+	} `json:"UsageByDays" xml:"UsageByDays"`
 }
 
 func CreateDescribeDomainsUsageByDayRequest() (request *DescribeDomainsUsageByDayRequest) {
-request = &DescribeDomainsUsageByDayRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainsUsageByDay", "", "")
-return
+	request = &DescribeDomainsUsageByDayRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeDomainsUsageByDay", "", "")
+	return
 }
 
 func CreateDescribeDomainsUsageByDayResponse() (response *DescribeDomainsUsageByDayResponse) {
-response = &DescribeDomainsUsageByDayResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeDomainsUsageByDayResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_extensive_domain_data.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,96 +16,94 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeExtensiveDomainData(request *DescribeExtensiveDomainDataRequest) (response *DescribeExtensiveDomainDataResponse, err error) {
-response = CreateDescribeExtensiveDomainDataResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeExtensiveDomainDataResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeExtensiveDomainDataWithChan(request *DescribeExtensiveDomainDataRequest) (<-chan *DescribeExtensiveDomainDataResponse, <-chan error) {
-responseChan := make(chan *DescribeExtensiveDomainDataResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeExtensiveDomainData(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeExtensiveDomainDataResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeExtensiveDomainData(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeExtensiveDomainDataWithCallback(request *DescribeExtensiveDomainDataRequest, callback func(response *DescribeExtensiveDomainDataResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeExtensiveDomainDataResponse
-var err error
-defer close(result)
-response, err = client.DescribeExtensiveDomainData(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeExtensiveDomainDataWithCallback(request *DescribeExtensiveDomainDataRequest, callback func(response *DescribeExtensiveDomainDataResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeExtensiveDomainDataResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeExtensiveDomainData(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeExtensiveDomainDataRequest struct {
-*requests.RpcRequest
-                EndTime  string `position:"Query" name:"EndTime"`
-                PageSize  string `position:"Query" name:"PageSize"`
-                StartTime  string `position:"Query" name:"StartTime"`
-                PageNumber  string `position:"Query" name:"PageNumber"`
-                ExtensiveDomain  string `position:"Query" name:"ExtensiveDomain"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	EndTime         string `position:"Query" name:"EndTime"`
+	PageSize        string `position:"Query" name:"PageSize"`
+	StartTime       string `position:"Query" name:"StartTime"`
+	PageNumber      string `position:"Query" name:"PageNumber"`
+	ExtensiveDomain string `position:"Query" name:"ExtensiveDomain"`
+	OwnerId         string `position:"Query" name:"OwnerId"`
+	SecurityToken   string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeExtensiveDomainDataResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            ExtensiveDomain     string `json:"ExtensiveDomain" xml:"ExtensiveDomain"`
-            DataInterval     string `json:"DataInterval" xml:"DataInterval"`
-            StartTime     string `json:"StartTime" xml:"StartTime"`
-            EndTime     string `json:"EndTime" xml:"EndTime"`
-            PageNumber     string `json:"PageNumber" xml:"PageNumber"`
-            TotalCount     string `json:"TotalCount" xml:"TotalCount"`
-            PageSize     string `json:"PageSize" xml:"PageSize"`
-                DataPerInterval struct {
-                    UsageData []struct {
-            ExactDomain     string `json:"ExactDomain" xml:"ExactDomain"`
-            TimeStamp     string `json:"TimeStamp" xml:"TimeStamp"`
-            Acc     string `json:"Acc" xml:"Acc"`
-            Flow     string `json:"Flow" xml:"Flow"`
-                    }   `json:"UsageData" xml:"UsageData"`
-                } `json:"DataPerInterval" xml:"DataPerInterval"`
+	*responses.BaseResponse
+	RequestId       string `json:"RequestId" xml:"RequestId"`
+	ExtensiveDomain string `json:"ExtensiveDomain" xml:"ExtensiveDomain"`
+	DataInterval    string `json:"DataInterval" xml:"DataInterval"`
+	StartTime       string `json:"StartTime" xml:"StartTime"`
+	EndTime         string `json:"EndTime" xml:"EndTime"`
+	PageNumber      string `json:"PageNumber" xml:"PageNumber"`
+	TotalCount      string `json:"TotalCount" xml:"TotalCount"`
+	PageSize        string `json:"PageSize" xml:"PageSize"`
+	DataPerInterval struct {
+		UsageData []struct {
+			ExactDomain string `json:"ExactDomain" xml:"ExactDomain"`
+			TimeStamp   string `json:"TimeStamp" xml:"TimeStamp"`
+			Acc         string `json:"Acc" xml:"Acc"`
+			Flow        string `json:"Flow" xml:"Flow"`
+		} `json:"UsageData" xml:"UsageData"`
+	} `json:"DataPerInterval" xml:"DataPerInterval"`
 }
 
 func CreateDescribeExtensiveDomainDataRequest() (request *DescribeExtensiveDomainDataRequest) {
-request = &DescribeExtensiveDomainDataRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeExtensiveDomainData", "", "")
-return
+	request = &DescribeExtensiveDomainDataRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeExtensiveDomainData", "", "")
+	return
 }
 
 func CreateDescribeExtensiveDomainDataResponse() (response *DescribeExtensiveDomainDataResponse) {
-response = &DescribeExtensiveDomainDataResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeExtensiveDomainDataResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_ip_info.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,82 +16,80 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeIpInfo(request *DescribeIpInfoRequest) (response *DescribeIpInfoResponse, err error) {
-response = CreateDescribeIpInfoResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeIpInfoResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeIpInfoWithChan(request *DescribeIpInfoRequest) (<-chan *DescribeIpInfoResponse, <-chan error) {
-responseChan := make(chan *DescribeIpInfoResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeIpInfo(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeIpInfoResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeIpInfo(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeIpInfoWithCallback(request *DescribeIpInfoRequest, callback func(response *DescribeIpInfoResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeIpInfoResponse
-var err error
-defer close(result)
-response, err = client.DescribeIpInfo(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeIpInfoWithCallback(request *DescribeIpInfoRequest, callback func(response *DescribeIpInfoResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeIpInfoResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeIpInfo(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeIpInfoRequest struct {
-*requests.RpcRequest
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
-                IP  string `position:"Query" name:"IP"`
+	*requests.RpcRequest
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
+	IP            string `position:"Query" name:"IP"`
 }
 
-
 type DescribeIpInfoResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            CdnIp     string `json:"CdnIp" xml:"CdnIp"`
-            ISP     string `json:"ISP" xml:"ISP"`
-            IspEname     string `json:"IspEname" xml:"IspEname"`
-            Region     string `json:"Region" xml:"Region"`
-            RegionEname     string `json:"RegionEname" xml:"RegionEname"`
+	*responses.BaseResponse
+	RequestId   string `json:"RequestId" xml:"RequestId"`
+	CdnIp       string `json:"CdnIp" xml:"CdnIp"`
+	ISP         string `json:"ISP" xml:"ISP"`
+	IspEname    string `json:"IspEname" xml:"IspEname"`
+	Region      string `json:"Region" xml:"Region"`
+	RegionEname string `json:"RegionEname" xml:"RegionEname"`
 }
 
 func CreateDescribeIpInfoRequest() (request *DescribeIpInfoRequest) {
-request = &DescribeIpInfoRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeIpInfo", "", "")
-return
+	request = &DescribeIpInfoRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeIpInfo", "", "")
+	return
 }
 
 func CreateDescribeIpInfoResponse() (response *DescribeIpInfoResponse) {
-response = &DescribeIpInfoResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeIpInfoResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-

services/cdn/describe_l2_vips_by_domain.go

@@ -1,4 +1,3 @@
-
 package cdn
 
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,81 +16,79 @@ package cdn
 // 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"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
+	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
 )
 
 func (client *Client) DescribeL2VipsByDomain(request *DescribeL2VipsByDomainRequest) (response *DescribeL2VipsByDomainResponse, err error) {
-response = CreateDescribeL2VipsByDomainResponse()
-err = client.DoAction(request, response)
-return
+	response = CreateDescribeL2VipsByDomainResponse()
+	err = client.DoAction(request, response)
+	return
 }
 
 func (client *Client) DescribeL2VipsByDomainWithChan(request *DescribeL2VipsByDomainRequest) (<-chan *DescribeL2VipsByDomainResponse, <-chan error) {
-responseChan := make(chan *DescribeL2VipsByDomainResponse, 1)
-errChan := make(chan error, 1)
-err := client.AddAsyncTask(func() {
-defer close(responseChan)
-defer close(errChan)
-response, err :=  client.DescribeL2VipsByDomain(request)
-responseChan <- response
-errChan <- err
-})
-if err != nil {
-errChan <- err
-close(responseChan)
-close(errChan)
-}
-return responseChan, errChan
+	responseChan := make(chan *DescribeL2VipsByDomainResponse, 1)
+	errChan := make(chan error, 1)
+	err := client.AddAsyncTask(func() {
+		defer close(responseChan)
+		defer close(errChan)
+		response, err := client.DescribeL2VipsByDomain(request)
+		responseChan <- response
+		errChan <- err
+	})
+	if err != nil {
+		errChan <- err
+		close(responseChan)
+		close(errChan)
+	}
+	return responseChan, errChan
 }
 
-func (client *Client) DescribeL2VipsByDomainWithCallback(request *DescribeL2VipsByDomainRequest, callback func(response *DescribeL2VipsByDomainResponse, err error)) (<-chan int) {
-result := make(chan int, 1)
-err := client.AddAsyncTask(func() {
-var response *DescribeL2VipsByDomainResponse
-var err error
-defer close(result)
-response, err = client.DescribeL2VipsByDomain(request)
-callback(response, err)
-result <- 1
-})
-if err != nil {
-defer close(result)
-callback(nil, err)
-result <- 0
-}
-return result
+func (client *Client) DescribeL2VipsByDomainWithCallback(request *DescribeL2VipsByDomainRequest, callback func(response *DescribeL2VipsByDomainResponse, err error)) <-chan int {
+	result := make(chan int, 1)
+	err := client.AddAsyncTask(func() {
+		var response *DescribeL2VipsByDomainResponse
+		var err error
+		defer close(result)
+		response, err = client.DescribeL2VipsByDomain(request)
+		callback(response, err)
+		result <- 1
+	})
+	if err != nil {
+		defer close(result)
+		callback(nil, err)
+		result <- 0
+	}
+	return result
 }
 
 type DescribeL2VipsByDomainRequest struct {
-*requests.RpcRequest
-                DomainName  string `position:"Query" name:"DomainName"`
-                OwnerId  string `position:"Query" name:"OwnerId"`
-                SecurityToken  string `position:"Query" name:"SecurityToken"`
+	*requests.RpcRequest
+	DomainName    string `position:"Query" name:"DomainName"`
+	OwnerId       string `position:"Query" name:"OwnerId"`
+	SecurityToken string `position:"Query" name:"SecurityToken"`
 }
 
-
 type DescribeL2VipsByDomainResponse struct {
-*responses.BaseResponse
-            RequestId     string `json:"RequestId" xml:"RequestId"`
-            DomainName     string `json:"DomainName" xml:"DomainName"`
-                Vips struct {
-                Vip []    string `json:"Vip" xml:"Vip"`
-                } `json:"Vips" xml:"Vips"`
+	*responses.BaseResponse
+	RequestId  string `json:"RequestId" xml:"RequestId"`
+	DomainName string `json:"DomainName" xml:"DomainName"`
+	Vips       struct {
+		Vip []string `json:"Vip" xml:"Vip"`
+	} `json:"Vips" xml:"Vips"`
 }
 
 func CreateDescribeL2VipsByDomainRequest() (request *DescribeL2VipsByDomainRequest) {
-request = &DescribeL2VipsByDomainRequest{
-RpcRequest: &requests.RpcRequest{},
-}
-request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeL2VipsByDomain", "", "")
-return
+	request = &DescribeL2VipsByDomainRequest{
+		RpcRequest: &requests.RpcRequest{},
+	}
+	request.InitWithApiInfo("Cdn", "2014-11-11", "DescribeL2VipsByDomain", "", "")
+	return
 }
 
 func CreateDescribeL2VipsByDomainResponse() (response *DescribeL2VipsByDomainResponse) {
-response = &DescribeL2VipsByDomainResponse{
-BaseResponse: &responses.BaseResponse{},
-}
-return
+	response = &DescribeL2VipsByDomainResponse{
+		BaseResponse: &responses.BaseResponse{},
+	}
+	return
 }
-