OpenI
/
aiforge
Not watched
1
0
Fork 0
Code
Releases 128 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 9529203724
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9529203724'
${ noResults }
aiforge/vendor/github.com/alibabacloud-go/darabonba-openapi/client/client.go

1624 lines
54 kB
Raw Blame History 

  1. // This file is auto-generated, don't edit it. Thanks.

  2. /**

  3.  * This is for OpenApi SDK

  4.  */

  5. package client

  6. 

  7. import (

  8. 	"io"

  9. 

  10. 	spi "github.com/alibabacloud-go/alibabacloud-gateway-spi/client"

  11. 	openapiutil "github.com/alibabacloud-go/openapi-util/service"

  12. 	util "github.com/alibabacloud-go/tea-utils/service"

  13. 	xml "github.com/alibabacloud-go/tea-xml/service"

  14. 	"github.com/alibabacloud-go/tea/tea"

  15. 	credential "github.com/aliyun/credentials-go/credentials"

  16. )

  17. 

  18. /**

  19.  * Model for initing client

  20.  */

  21. type Config struct {

  22. 	// accesskey id

  23. 	AccessKeyId *string `json:"accessKeyId,omitempty" xml:"accessKeyId,omitempty"`

  24. 	// accesskey secret

  25. 	AccessKeySecret *string `json:"accessKeySecret,omitempty" xml:"accessKeySecret,omitempty"`

  26. 	// security token

  27. 	SecurityToken *string `json:"securityToken,omitempty" xml:"securityToken,omitempty"`

  28. 	// http protocol

  29. 	Protocol *string `json:"protocol,omitempty" xml:"protocol,omitempty"`

  30. 	// http method

  31. 	Method *string `json:"method,omitempty" xml:"method,omitempty"`

  32. 	// region id

  33. 	RegionId *string `json:"regionId,omitempty" xml:"regionId,omitempty"`

  34. 	// read timeout

  35. 	ReadTimeout *int `json:"readTimeout,omitempty" xml:"readTimeout,omitempty"`

  36. 	// connect timeout

  37. 	ConnectTimeout *int `json:"connectTimeout,omitempty" xml:"connectTimeout,omitempty"`

  38. 	// http proxy

  39. 	HttpProxy *string `json:"httpProxy,omitempty" xml:"httpProxy,omitempty"`

  40. 	// https proxy

  41. 	HttpsProxy *string `json:"httpsProxy,omitempty" xml:"httpsProxy,omitempty"`

  42. 	// credential

  43. 	Credential credential.Credential `json:"credential,omitempty" xml:"credential,omitempty"`

  44. 	// endpoint

  45. 	Endpoint *string `json:"endpoint,omitempty" xml:"endpoint,omitempty"`

  46. 	// proxy white list

  47. 	NoProxy *string `json:"noProxy,omitempty" xml:"noProxy,omitempty"`

  48. 	// max idle conns

  49. 	MaxIdleConns *int `json:"maxIdleConns,omitempty" xml:"maxIdleConns,omitempty"`

  50. 	// network for endpoint

  51. 	Network *string `json:"network,omitempty" xml:"network,omitempty"`

  52. 	// user agent

  53. 	UserAgent *string `json:"userAgent,omitempty" xml:"userAgent,omitempty"`

  54. 	// suffix for endpoint

  55. 	Suffix *string `json:"suffix,omitempty" xml:"suffix,omitempty"`

  56. 	// socks5 proxy

  57. 	Socks5Proxy *string `json:"socks5Proxy,omitempty" xml:"socks5Proxy,omitempty"`

  58. 	// socks5 network

  59. 	Socks5NetWork *string `json:"socks5NetWork,omitempty" xml:"socks5NetWork,omitempty"`

  60. 	// endpoint type

  61. 	EndpointType *string `json:"endpointType,omitempty" xml:"endpointType,omitempty"`

  62. 	// OpenPlatform endpoint

  63. 	OpenPlatformEndpoint *string `json:"openPlatformEndpoint,omitempty" xml:"openPlatformEndpoint,omitempty"`

  64. 	// Deprecated

  65. 	// credential type

  66. 	Type *string `json:"type,omitempty" xml:"type,omitempty"`

  67. 	// Signature Version

  68. 	SignatureVersion *string `json:"signatureVersion,omitempty" xml:"signatureVersion,omitempty"`

  69. 	// Signature Algorithm

  70. 	SignatureAlgorithm *string `json:"signatureAlgorithm,omitempty" xml:"signatureAlgorithm,omitempty"`

  71. }

  72. 

  73. func (s Config) String() string {

  74. 	return tea.Prettify(s)

  75. }

  76. 

  77. func (s Config) GoString() string {

  78. 	return s.String()

  79. }

  80. 

  81. func (s *Config) SetAccessKeyId(v string) *Config {

  82. 	s.AccessKeyId = &v

  83. 	return s

  84. }

  85. 

  86. func (s *Config) SetAccessKeySecret(v string) *Config {

  87. 	s.AccessKeySecret = &v

  88. 	return s

  89. }

  90. 

  91. func (s *Config) SetSecurityToken(v string) *Config {

  92. 	s.SecurityToken = &v

  93. 	return s

  94. }

  95. 

  96. func (s *Config) SetProtocol(v string) *Config {

  97. 	s.Protocol = &v

  98. 	return s

  99. }

  100. 

  101. func (s *Config) SetMethod(v string) *Config {

  102. 	s.Method = &v

  103. 	return s

  104. }

  105. 

  106. func (s *Config) SetRegionId(v string) *Config {

  107. 	s.RegionId = &v

  108. 	return s

  109. }

  110. 

  111. func (s *Config) SetReadTimeout(v int) *Config {

  112. 	s.ReadTimeout = &v

  113. 	return s

  114. }

  115. 

  116. func (s *Config) SetConnectTimeout(v int) *Config {

  117. 	s.ConnectTimeout = &v

  118. 	return s

  119. }

  120. 

  121. func (s *Config) SetHttpProxy(v string) *Config {

  122. 	s.HttpProxy = &v

  123. 	return s

  124. }

  125. 

  126. func (s *Config) SetHttpsProxy(v string) *Config {

  127. 	s.HttpsProxy = &v

  128. 	return s

  129. }

  130. 

  131. func (s *Config) SetCredential(v credential.Credential) *Config {

  132. 	s.Credential = v

  133. 	return s

  134. }

  135. 

  136. func (s *Config) SetEndpoint(v string) *Config {

  137. 	s.Endpoint = &v

  138. 	return s

  139. }

  140. 

  141. func (s *Config) SetNoProxy(v string) *Config {

  142. 	s.NoProxy = &v

  143. 	return s

  144. }

  145. 

  146. func (s *Config) SetMaxIdleConns(v int) *Config {

  147. 	s.MaxIdleConns = &v

  148. 	return s

  149. }

  150. 

  151. func (s *Config) SetNetwork(v string) *Config {

  152. 	s.Network = &v

  153. 	return s

  154. }

  155. 

  156. func (s *Config) SetUserAgent(v string) *Config {

  157. 	s.UserAgent = &v

  158. 	return s

  159. }

  160. 

  161. func (s *Config) SetSuffix(v string) *Config {

  162. 	s.Suffix = &v

  163. 	return s

  164. }

  165. 

  166. func (s *Config) SetSocks5Proxy(v string) *Config {

  167. 	s.Socks5Proxy = &v

  168. 	return s

  169. }

  170. 

  171. func (s *Config) SetSocks5NetWork(v string) *Config {

  172. 	s.Socks5NetWork = &v

  173. 	return s

  174. }

  175. 

  176. func (s *Config) SetEndpointType(v string) *Config {

  177. 	s.EndpointType = &v

  178. 	return s

  179. }

  180. 

  181. func (s *Config) SetOpenPlatformEndpoint(v string) *Config {

  182. 	s.OpenPlatformEndpoint = &v

  183. 	return s

  184. }

  185. 

  186. func (s *Config) SetType(v string) *Config {

  187. 	s.Type = &v

  188. 	return s

  189. }

  190. 

  191. func (s *Config) SetSignatureVersion(v string) *Config {

  192. 	s.SignatureVersion = &v

  193. 	return s

  194. }

  195. 

  196. func (s *Config) SetSignatureAlgorithm(v string) *Config {

  197. 	s.SignatureAlgorithm = &v

  198. 	return s

  199. }

  200. 

  201. type OpenApiRequest struct {

  202. 	Headers          map[string]*string `json:"headers,omitempty" xml:"headers,omitempty"`

  203. 	Query            map[string]*string `json:"query,omitempty" xml:"query,omitempty"`

  204. 	Body             interface{}        `json:"body,omitempty" xml:"body,omitempty"`

  205. 	Stream           io.Reader          `json:"stream,omitempty" xml:"stream,omitempty"`

  206. 	HostMap          map[string]*string `json:"hostMap,omitempty" xml:"hostMap,omitempty"`

  207. 	EndpointOverride *string            `json:"endpointOverride,omitempty" xml:"endpointOverride,omitempty"`

  208. }

  209. 

  210. func (s OpenApiRequest) String() string {

  211. 	return tea.Prettify(s)

  212. }

  213. 

  214. func (s OpenApiRequest) GoString() string {

  215. 	return s.String()

  216. }

  217. 

  218. func (s *OpenApiRequest) SetHeaders(v map[string]*string) *OpenApiRequest {

  219. 	s.Headers = v

  220. 	return s

  221. }

  222. 

  223. func (s *OpenApiRequest) SetQuery(v map[string]*string) *OpenApiRequest {

  224. 	s.Query = v

  225. 	return s

  226. }

  227. 

  228. func (s *OpenApiRequest) SetBody(v interface{}) *OpenApiRequest {

  229. 	s.Body = v

  230. 	return s

  231. }

  232. 

  233. func (s *OpenApiRequest) SetStream(v io.Reader) *OpenApiRequest {

  234. 	s.Stream = v

  235. 	return s

  236. }

  237. 

  238. func (s *OpenApiRequest) SetHostMap(v map[string]*string) *OpenApiRequest {

  239. 	s.HostMap = v

  240. 	return s

  241. }

  242. 

  243. func (s *OpenApiRequest) SetEndpointOverride(v string) *OpenApiRequest {

  244. 	s.EndpointOverride = &v

  245. 	return s

  246. }

  247. 

  248. type Params struct {

  249. 	Action      *string `json:"action,omitempty" xml:"action,omitempty" require:"true"`

  250. 	Version     *string `json:"version,omitempty" xml:"version,omitempty" require:"true"`

  251. 	Protocol    *string `json:"protocol,omitempty" xml:"protocol,omitempty" require:"true"`

  252. 	Pathname    *string `json:"pathname,omitempty" xml:"pathname,omitempty" require:"true"`

  253. 	Method      *string `json:"method,omitempty" xml:"method,omitempty" require:"true"`

  254. 	AuthType    *string `json:"authType,omitempty" xml:"authType,omitempty" require:"true"`

  255. 	BodyType    *string `json:"bodyType,omitempty" xml:"bodyType,omitempty" require:"true"`

  256. 	ReqBodyType *string `json:"reqBodyType,omitempty" xml:"reqBodyType,omitempty" require:"true"`

  257. 	Style       *string `json:"style,omitempty" xml:"style,omitempty"`

  258. }

  259. 

  260. func (s Params) String() string {

  261. 	return tea.Prettify(s)

  262. }

  263. 

  264. func (s Params) GoString() string {

  265. 	return s.String()

  266. }

  267. 

  268. func (s *Params) SetAction(v string) *Params {

  269. 	s.Action = &v

  270. 	return s

  271. }

  272. 

  273. func (s *Params) SetVersion(v string) *Params {

  274. 	s.Version = &v

  275. 	return s

  276. }

  277. 

  278. func (s *Params) SetProtocol(v string) *Params {

  279. 	s.Protocol = &v

  280. 	return s

  281. }

  282. 

  283. func (s *Params) SetPathname(v string) *Params {

  284. 	s.Pathname = &v

  285. 	return s

  286. }

  287. 

  288. func (s *Params) SetMethod(v string) *Params {

  289. 	s.Method = &v

  290. 	return s

  291. }

  292. 

  293. func (s *Params) SetAuthType(v string) *Params {

  294. 	s.AuthType = &v

  295. 	return s

  296. }

  297. 

  298. func (s *Params) SetBodyType(v string) *Params {

  299. 	s.BodyType = &v

  300. 	return s

  301. }

  302. 

  303. func (s *Params) SetReqBodyType(v string) *Params {

  304. 	s.ReqBodyType = &v

  305. 	return s

  306. }

  307. 

  308. func (s *Params) SetStyle(v string) *Params {

  309. 	s.Style = &v

  310. 	return s

  311. }

  312. 

  313. type Client struct {

  314. 	Endpoint             *string

  315. 	RegionId             *string

  316. 	Protocol             *string

  317. 	Method               *string

  318. 	UserAgent            *string

  319. 	EndpointRule         *string

  320. 	EndpointMap          map[string]*string

  321. 	Suffix               *string

  322. 	ReadTimeout          *int

  323. 	ConnectTimeout       *int

  324. 	HttpProxy            *string

  325. 	HttpsProxy           *string

  326. 	Socks5Proxy          *string

  327. 	Socks5NetWork        *string

  328. 	NoProxy              *string

  329. 	Network              *string

  330. 	ProductId            *string

  331. 	MaxIdleConns         *int

  332. 	EndpointType         *string

  333. 	OpenPlatformEndpoint *string

  334. 	Credential           credential.Credential

  335. 	SignatureVersion     *string

  336. 	SignatureAlgorithm   *string

  337. 	Headers              map[string]*string

  338. 	Spi                  spi.ClientInterface

  339. }

  340. 

  341. /**

  342.  * Init client with Config

  343.  * @param config config contains the necessary information to create a client

  344.  */

  345. func NewClient(config *Config) (*Client, error) {

  346. 	client := new(Client)

  347. 	err := client.Init(config)

  348. 	return client, err

  349. }

  350. 

  351. func (client *Client) Init(config *Config) (_err error) {

  352. 	if tea.BoolValue(util.IsUnset(tea.ToMap(config))) {

  353. 		_err = tea.NewSDKError(map[string]interface{}{

  354. 			"code":    "ParameterMissing",

  355. 			"message": "'config' can not be unset",

  356. 		})

  357. 		return _err

  358. 	}

  359. 

  360. 	if !tea.BoolValue(util.Empty(config.AccessKeyId)) && !tea.BoolValue(util.Empty(config.AccessKeySecret)) {

  361. 		if !tea.BoolValue(util.Empty(config.SecurityToken)) {

  362. 			config.Type = tea.String("sts")

  363. 		} else {

  364. 			config.Type = tea.String("access_key")

  365. 		}

  366. 

  367. 		credentialConfig := &credential.Config{

  368. 			AccessKeyId:     config.AccessKeyId,

  369. 			Type:            config.Type,

  370. 			AccessKeySecret: config.AccessKeySecret,

  371. 			SecurityToken:   config.SecurityToken,

  372. 		}

  373. 		client.Credential, _err = credential.NewCredential(credentialConfig)

  374. 		if _err != nil {

  375. 			return _err

  376. 		}

  377. 

  378. 	} else if !tea.BoolValue(util.IsUnset(config.Credential)) {

  379. 		client.Credential = config.Credential

  380. 	}

  381. 

  382. 	client.Endpoint = config.Endpoint

  383. 	client.EndpointType = config.EndpointType

  384. 	client.Network = config.Network

  385. 	client.Suffix = config.Suffix

  386. 	client.Protocol = config.Protocol

  387. 	client.Method = config.Method

  388. 	client.RegionId = config.RegionId

  389. 	client.UserAgent = config.UserAgent

  390. 	client.ReadTimeout = config.ReadTimeout

  391. 	client.ConnectTimeout = config.ConnectTimeout

  392. 	client.HttpProxy = config.HttpProxy

  393. 	client.HttpsProxy = config.HttpsProxy

  394. 	client.NoProxy = config.NoProxy

  395. 	client.Socks5Proxy = config.Socks5Proxy

  396. 	client.Socks5NetWork = config.Socks5NetWork

  397. 	client.MaxIdleConns = config.MaxIdleConns

  398. 	client.SignatureVersion = config.SignatureVersion

  399. 	client.SignatureAlgorithm = config.SignatureAlgorithm

  400. 	return nil

  401. }

  402. 

  403. /**

  404.  * Encapsulate the request and invoke the network

  405.  * @param action api name

  406.  * @param version product version

  407.  * @param protocol http or https

  408.  * @param method e.g. GET

  409.  * @param authType authorization type e.g. AK

  410.  * @param bodyType response body type e.g. String

  411.  * @param request object of OpenApiRequest

  412.  * @param runtime which controls some details of call api, such as retry times

  413.  * @return the response

  414.  */

  415. func (client *Client) DoRPCRequest(action *string, version *string, protocol *string, method *string, authType *string, bodyType *string, request *OpenApiRequest, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {

  416. 	_err = tea.Validate(request)

  417. 	if _err != nil {

  418. 		return _result, _err

  419. 	}

  420. 	_err = tea.Validate(runtime)

  421. 	if _err != nil {

  422. 		return _result, _err

  423. 	}

  424. 	_runtime := map[string]interface{}{

  425. 		"timeouted":      "retry",

  426. 		"readTimeout":    tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),

  427. 		"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),

  428. 		"httpProxy":      tea.StringValue(util.DefaultString(runtime.HttpProxy, client.HttpProxy)),

  429. 		"httpsProxy":     tea.StringValue(util.DefaultString(runtime.HttpsProxy, client.HttpsProxy)),

  430. 		"noProxy":        tea.StringValue(util.DefaultString(runtime.NoProxy, client.NoProxy)),

  431. 		"socks5Proxy":    tea.StringValue(util.DefaultString(runtime.Socks5Proxy, client.Socks5Proxy)),

  432. 		"socks5NetWork":  tea.StringValue(util.DefaultString(runtime.Socks5NetWork, client.Socks5NetWork)),

  433. 		"maxIdleConns":   tea.IntValue(util.DefaultNumber(runtime.MaxIdleConns, client.MaxIdleConns)),

  434. 		"retry": map[string]interface{}{

  435. 			"retryable":   tea.BoolValue(runtime.Autoretry),

  436. 			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),

  437. 		},

  438. 		"backoff": map[string]interface{}{

  439. 			"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),

  440. 			"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),

  441. 		},

  442. 		"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),

  443. 	}

  444. 

  445. 	_resp := make(map[string]interface{})

  446. 	for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {

  447. 		if _retryTimes > 0 {

  448. 			_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))

  449. 			if tea.IntValue(_backoffTime) > 0 {

  450. 				tea.Sleep(_backoffTime)

  451. 			}

  452. 		}

  453. 

  454. 		_resp, _err = func() (map[string]interface{}, error) {

  455. 			request_ := tea.NewRequest()

  456. 			request_.Protocol = util.DefaultString(client.Protocol, protocol)

  457. 			request_.Method = method

  458. 			request_.Pathname = tea.String("/")

  459. 			request_.Query = tea.Merge(map[string]*string{

  460. 				"Action":         action,

  461. 				"Format":         tea.String("json"),

  462. 				"Version":        version,

  463. 				"Timestamp":      openapiutil.GetTimestamp(),

  464. 				"SignatureNonce": util.GetNonce(),

  465. 			}, request.Query)

  466. 			headers, _err := client.GetRpcHeaders()

  467. 			if _err != nil {

  468. 				return _result, _err

  469. 			}

  470. 

  471. 			if tea.BoolValue(util.IsUnset(headers)) {

  472. 				// endpoint is setted in product client

  473. 				request_.Headers = map[string]*string{

  474. 					"host":          client.Endpoint,

  475. 					"x-acs-version": version,

  476. 					"x-acs-action":  action,

  477. 					"user-agent":    client.GetUserAgent(),

  478. 				}

  479. 			} else {

  480. 				request_.Headers = tea.Merge(map[string]*string{

  481. 					"host":          client.Endpoint,

  482. 					"x-acs-version": version,

  483. 					"x-acs-action":  action,

  484. 					"user-agent":    client.GetUserAgent(),

  485. 				}, headers)

  486. 			}

  487. 

  488. 			if !tea.BoolValue(util.IsUnset(request.Body)) {

  489. 				m := util.AssertAsMap(request.Body)

  490. 				tmp := util.AnyifyMapValue(openapiutil.Query(m))

  491. 				request_.Body = tea.ToReader(util.ToFormString(tmp))

  492. 				request_.Headers["content-type"] = tea.String("application/x-www-form-urlencoded")

  493. 			}

  494. 

  495. 			if !tea.BoolValue(util.EqualString(authType, tea.String("Anonymous"))) {

  496. 				accessKeyId, _err := client.GetAccessKeyId()

  497. 				if _err != nil {

  498. 					return _result, _err

  499. 				}

  500. 

  501. 				accessKeySecret, _err := client.GetAccessKeySecret()

  502. 				if _err != nil {

  503. 					return _result, _err

  504. 				}

  505. 

  506. 				securityToken, _err := client.GetSecurityToken()

  507. 				if _err != nil {

  508. 					return _result, _err

  509. 				}

  510. 

  511. 				if !tea.BoolValue(util.Empty(securityToken)) {

  512. 					request_.Query["SecurityToken"] = securityToken

  513. 				}

  514. 

  515. 				request_.Query["SignatureMethod"] = tea.String("HMAC-SHA1")

  516. 				request_.Query["SignatureVersion"] = tea.String("1.0")

  517. 				request_.Query["AccessKeyId"] = accessKeyId

  518. 				var t map[string]interface{}

  519. 				if !tea.BoolValue(util.IsUnset(request.Body)) {

  520. 					t = util.AssertAsMap(request.Body)

  521. 				}

  522. 

  523. 				signedParam := tea.Merge(request_.Query,

  524. 					openapiutil.Query(t))

  525. 				request_.Query["Signature"] = openapiutil.GetRPCSignature(signedParam, request_.Method, accessKeySecret)

  526. 			}

  527. 

  528. 			response_, _err := tea.DoRequest(request_, _runtime)

  529. 			if _err != nil {

  530. 				return _result, _err

  531. 			}

  532. 			if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {

  533. 				_res, _err := util.ReadAsJSON(response_.Body)

  534. 				if _err != nil {

  535. 					return _result, _err

  536. 				}

  537. 

  538. 				err := util.AssertAsMap(_res)

  539. 				requestId := DefaultAny(err["RequestId"], err["requestId"])

  540. 				_err = tea.NewSDKError(map[string]interface{}{

  541. 					"code":    tea.ToString(DefaultAny(err["Code"], err["code"])),

  542. 					"message": "code: " + tea.ToString(tea.IntValue(response_.StatusCode)) + ", " + tea.ToString(DefaultAny(err["Message"], err["message"])) + " request id: " + tea.ToString(requestId),

  543. 					"data":    err,

  544. 				})

  545. 				return _result, _err

  546. 			}

  547. 

  548. 			if tea.BoolValue(util.EqualString(bodyType, tea.String("binary"))) {

  549. 				resp := map[string]interface{}{

  550. 					"body":    response_.Body,

  551. 					"headers": response_.Headers,

  552. 				}

  553. 				_result = resp

  554. 				return _result, _err

  555. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("byte"))) {

  556. 				byt, _err := util.ReadAsBytes(response_.Body)

  557. 				if _err != nil {

  558. 					return _result, _err

  559. 				}

  560. 

  561. 				_result = make(map[string]interface{})

  562. 				_err = tea.Convert(map[string]interface{}{

  563. 					"body":    byt,

  564. 					"headers": response_.Headers,

  565. 				}, &_result)

  566. 				return _result, _err

  567. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("string"))) {

  568. 				str, _err := util.ReadAsString(response_.Body)

  569. 				if _err != nil {

  570. 					return _result, _err

  571. 				}

  572. 

  573. 				_result = make(map[string]interface{})

  574. 				_err = tea.Convert(map[string]interface{}{

  575. 					"body":    tea.StringValue(str),

  576. 					"headers": response_.Headers,

  577. 				}, &_result)

  578. 				return _result, _err

  579. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("json"))) {

  580. 				obj, _err := util.ReadAsJSON(response_.Body)

  581. 				if _err != nil {

  582. 					return _result, _err

  583. 				}

  584. 

  585. 				res := util.AssertAsMap(obj)

  586. 				_result = make(map[string]interface{})

  587. 				_err = tea.Convert(map[string]interface{}{

  588. 					"body":    res,

  589. 					"headers": response_.Headers,

  590. 				}, &_result)

  591. 				return _result, _err

  592. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("array"))) {

  593. 				arr, _err := util.ReadAsJSON(response_.Body)

  594. 				if _err != nil {

  595. 					return _result, _err

  596. 				}

  597. 

  598. 				_result = make(map[string]interface{})

  599. 				_err = tea.Convert(map[string]interface{}{

  600. 					"body":    arr,

  601. 					"headers": response_.Headers,

  602. 				}, &_result)

  603. 				return _result, _err

  604. 			} else {

  605. 				_result = make(map[string]interface{})

  606. 				_err = tea.Convert(map[string]map[string]*string{

  607. 					"headers": response_.Headers,

  608. 				}, &_result)

  609. 				return _result, _err

  610. 			}

  611. 

  612. 		}()

  613. 		if !tea.BoolValue(tea.Retryable(_err)) {

  614. 			break

  615. 		}

  616. 	}

  617. 

  618. 	return _resp, _err

  619. }

  620. 

  621. /**

  622.  * Encapsulate the request and invoke the network

  623.  * @param action api name

  624.  * @param version product version

  625.  * @param protocol http or https

  626.  * @param method e.g. GET

  627.  * @param authType authorization type e.g. AK

  628.  * @param pathname pathname of every api

  629.  * @param bodyType response body type e.g. String

  630.  * @param request object of OpenApiRequest

  631.  * @param runtime which controls some details of call api, such as retry times

  632.  * @return the response

  633.  */

  634. func (client *Client) DoROARequest(action *string, version *string, protocol *string, method *string, authType *string, pathname *string, bodyType *string, request *OpenApiRequest, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {

  635. 	_err = tea.Validate(request)

  636. 	if _err != nil {

  637. 		return _result, _err

  638. 	}

  639. 	_err = tea.Validate(runtime)

  640. 	if _err != nil {

  641. 		return _result, _err

  642. 	}

  643. 	_runtime := map[string]interface{}{

  644. 		"timeouted":      "retry",

  645. 		"readTimeout":    tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),

  646. 		"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),

  647. 		"httpProxy":      tea.StringValue(util.DefaultString(runtime.HttpProxy, client.HttpProxy)),

  648. 		"httpsProxy":     tea.StringValue(util.DefaultString(runtime.HttpsProxy, client.HttpsProxy)),

  649. 		"noProxy":        tea.StringValue(util.DefaultString(runtime.NoProxy, client.NoProxy)),

  650. 		"socks5Proxy":    tea.StringValue(util.DefaultString(runtime.Socks5Proxy, client.Socks5Proxy)),

  651. 		"socks5NetWork":  tea.StringValue(util.DefaultString(runtime.Socks5NetWork, client.Socks5NetWork)),

  652. 		"maxIdleConns":   tea.IntValue(util.DefaultNumber(runtime.MaxIdleConns, client.MaxIdleConns)),

  653. 		"retry": map[string]interface{}{

  654. 			"retryable":   tea.BoolValue(runtime.Autoretry),

  655. 			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),

  656. 		},

  657. 		"backoff": map[string]interface{}{

  658. 			"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),

  659. 			"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),

  660. 		},

  661. 		"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),

  662. 	}

  663. 

  664. 	_resp := make(map[string]interface{})

  665. 	for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {

  666. 		if _retryTimes > 0 {

  667. 			_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))

  668. 			if tea.IntValue(_backoffTime) > 0 {

  669. 				tea.Sleep(_backoffTime)

  670. 			}

  671. 		}

  672. 

  673. 		_resp, _err = func() (map[string]interface{}, error) {

  674. 			request_ := tea.NewRequest()

  675. 			request_.Protocol = util.DefaultString(client.Protocol, protocol)

  676. 			request_.Method = method

  677. 			request_.Pathname = pathname

  678. 			request_.Headers = tea.Merge(map[string]*string{

  679. 				"date":                    util.GetDateUTCString(),

  680. 				"host":                    client.Endpoint,

  681. 				"accept":                  tea.String("application/json"),

  682. 				"x-acs-signature-nonce":   util.GetNonce(),

  683. 				"x-acs-signature-method":  tea.String("HMAC-SHA1"),

  684. 				"x-acs-signature-version": tea.String("1.0"),

  685. 				"x-acs-version":           version,

  686. 				"x-acs-action":            action,

  687. 				"user-agent":              util.GetUserAgent(client.UserAgent),

  688. 			}, request.Headers)

  689. 			if !tea.BoolValue(util.IsUnset(request.Body)) {

  690. 				request_.Body = tea.ToReader(util.ToJSONString(request.Body))

  691. 				request_.Headers["content-type"] = tea.String("application/json; charset=utf-8")

  692. 			}

  693. 

  694. 			if !tea.BoolValue(util.IsUnset(request.Query)) {

  695. 				request_.Query = request.Query

  696. 			}

  697. 

  698. 			if !tea.BoolValue(util.EqualString(authType, tea.String("Anonymous"))) {

  699. 				accessKeyId, _err := client.GetAccessKeyId()

  700. 				if _err != nil {

  701. 					return _result, _err

  702. 				}

  703. 

  704. 				accessKeySecret, _err := client.GetAccessKeySecret()

  705. 				if _err != nil {

  706. 					return _result, _err

  707. 				}

  708. 

  709. 				securityToken, _err := client.GetSecurityToken()

  710. 				if _err != nil {

  711. 					return _result, _err

  712. 				}

  713. 

  714. 				if !tea.BoolValue(util.Empty(securityToken)) {

  715. 					request_.Headers["x-acs-accesskey-id"] = accessKeyId

  716. 					request_.Headers["x-acs-security-token"] = securityToken

  717. 				}

  718. 

  719. 				stringToSign := openapiutil.GetStringToSign(request_)

  720. 				request_.Headers["authorization"] = tea.String("acs " + tea.StringValue(accessKeyId) + ":" + tea.StringValue(openapiutil.GetROASignature(stringToSign, accessKeySecret)))

  721. 			}

  722. 

  723. 			response_, _err := tea.DoRequest(request_, _runtime)

  724. 			if _err != nil {

  725. 				return _result, _err

  726. 			}

  727. 			if tea.BoolValue(util.EqualNumber(response_.StatusCode, tea.Int(204))) {

  728. 				_result = make(map[string]interface{})

  729. 				_err = tea.Convert(map[string]map[string]*string{

  730. 					"headers": response_.Headers,

  731. 				}, &_result)

  732. 				return _result, _err

  733. 			}

  734. 

  735. 			if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {

  736. 				_res, _err := util.ReadAsJSON(response_.Body)

  737. 				if _err != nil {

  738. 					return _result, _err

  739. 				}

  740. 

  741. 				err := util.AssertAsMap(_res)

  742. 				requestId := DefaultAny(err["RequestId"], err["requestId"])

  743. 				requestId = DefaultAny(requestId, err["requestid"])

  744. 				_err = tea.NewSDKError(map[string]interface{}{

  745. 					"code":    tea.ToString(DefaultAny(err["Code"], err["code"])),

  746. 					"message": "code: " + tea.ToString(tea.IntValue(response_.StatusCode)) + ", " + tea.ToString(DefaultAny(err["Message"], err["message"])) + " request id: " + tea.ToString(requestId),

  747. 					"data":    err,

  748. 				})

  749. 				return _result, _err

  750. 			}

  751. 

  752. 			if tea.BoolValue(util.EqualString(bodyType, tea.String("binary"))) {

  753. 				resp := map[string]interface{}{

  754. 					"body":    response_.Body,

  755. 					"headers": response_.Headers,

  756. 				}

  757. 				_result = resp

  758. 				return _result, _err

  759. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("byte"))) {

  760. 				byt, _err := util.ReadAsBytes(response_.Body)

  761. 				if _err != nil {

  762. 					return _result, _err

  763. 				}

  764. 

  765. 				_result = make(map[string]interface{})

  766. 				_err = tea.Convert(map[string]interface{}{

  767. 					"body":    byt,

  768. 					"headers": response_.Headers,

  769. 				}, &_result)

  770. 				return _result, _err

  771. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("string"))) {

  772. 				str, _err := util.ReadAsString(response_.Body)

  773. 				if _err != nil {

  774. 					return _result, _err

  775. 				}

  776. 

  777. 				_result = make(map[string]interface{})

  778. 				_err = tea.Convert(map[string]interface{}{

  779. 					"body":    tea.StringValue(str),

  780. 					"headers": response_.Headers,

  781. 				}, &_result)

  782. 				return _result, _err

  783. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("json"))) {

  784. 				obj, _err := util.ReadAsJSON(response_.Body)

  785. 				if _err != nil {

  786. 					return _result, _err

  787. 				}

  788. 

  789. 				res := util.AssertAsMap(obj)

  790. 				_result = make(map[string]interface{})

  791. 				_err = tea.Convert(map[string]interface{}{

  792. 					"body":    res,

  793. 					"headers": response_.Headers,

  794. 				}, &_result)

  795. 				return _result, _err

  796. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("array"))) {

  797. 				arr, _err := util.ReadAsJSON(response_.Body)

  798. 				if _err != nil {

  799. 					return _result, _err

  800. 				}

  801. 

  802. 				_result = make(map[string]interface{})

  803. 				_err = tea.Convert(map[string]interface{}{

  804. 					"body":    arr,

  805. 					"headers": response_.Headers,

  806. 				}, &_result)

  807. 				return _result, _err

  808. 			} else {

  809. 				_result = make(map[string]interface{})

  810. 				_err = tea.Convert(map[string]map[string]*string{

  811. 					"headers": response_.Headers,

  812. 				}, &_result)

  813. 				return _result, _err

  814. 			}

  815. 

  816. 		}()

  817. 		if !tea.BoolValue(tea.Retryable(_err)) {

  818. 			break

  819. 		}

  820. 	}

  821. 

  822. 	return _resp, _err

  823. }

  824. 

  825. /**

  826.  * Encapsulate the request and invoke the network with form body

  827.  * @param action api name

  828.  * @param version product version

  829.  * @param protocol http or https

  830.  * @param method e.g. GET

  831.  * @param authType authorization type e.g. AK

  832.  * @param pathname pathname of every api

  833.  * @param bodyType response body type e.g. String

  834.  * @param request object of OpenApiRequest

  835.  * @param runtime which controls some details of call api, such as retry times

  836.  * @return the response

  837.  */

  838. func (client *Client) DoROARequestWithForm(action *string, version *string, protocol *string, method *string, authType *string, pathname *string, bodyType *string, request *OpenApiRequest, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {

  839. 	_err = tea.Validate(request)

  840. 	if _err != nil {

  841. 		return _result, _err

  842. 	}

  843. 	_err = tea.Validate(runtime)

  844. 	if _err != nil {

  845. 		return _result, _err

  846. 	}

  847. 	_runtime := map[string]interface{}{

  848. 		"timeouted":      "retry",

  849. 		"readTimeout":    tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),

  850. 		"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),

  851. 		"httpProxy":      tea.StringValue(util.DefaultString(runtime.HttpProxy, client.HttpProxy)),

  852. 		"httpsProxy":     tea.StringValue(util.DefaultString(runtime.HttpsProxy, client.HttpsProxy)),

  853. 		"noProxy":        tea.StringValue(util.DefaultString(runtime.NoProxy, client.NoProxy)),

  854. 		"socks5Proxy":    tea.StringValue(util.DefaultString(runtime.Socks5Proxy, client.Socks5Proxy)),

  855. 		"socks5NetWork":  tea.StringValue(util.DefaultString(runtime.Socks5NetWork, client.Socks5NetWork)),

  856. 		"maxIdleConns":   tea.IntValue(util.DefaultNumber(runtime.MaxIdleConns, client.MaxIdleConns)),

  857. 		"retry": map[string]interface{}{

  858. 			"retryable":   tea.BoolValue(runtime.Autoretry),

  859. 			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),

  860. 		},

  861. 		"backoff": map[string]interface{}{

  862. 			"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),

  863. 			"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),

  864. 		},

  865. 		"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),

  866. 	}

  867. 

  868. 	_resp := make(map[string]interface{})

  869. 	for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {

  870. 		if _retryTimes > 0 {

  871. 			_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))

  872. 			if tea.IntValue(_backoffTime) > 0 {

  873. 				tea.Sleep(_backoffTime)

  874. 			}

  875. 		}

  876. 

  877. 		_resp, _err = func() (map[string]interface{}, error) {

  878. 			request_ := tea.NewRequest()

  879. 			request_.Protocol = util.DefaultString(client.Protocol, protocol)

  880. 			request_.Method = method

  881. 			request_.Pathname = pathname

  882. 			request_.Headers = tea.Merge(map[string]*string{

  883. 				"date":                    util.GetDateUTCString(),

  884. 				"host":                    client.Endpoint,

  885. 				"accept":                  tea.String("application/json"),

  886. 				"x-acs-signature-nonce":   util.GetNonce(),

  887. 				"x-acs-signature-method":  tea.String("HMAC-SHA1"),

  888. 				"x-acs-signature-version": tea.String("1.0"),

  889. 				"x-acs-version":           version,

  890. 				"x-acs-action":            action,

  891. 				"user-agent":              util.GetUserAgent(client.UserAgent),

  892. 			}, request.Headers)

  893. 			if !tea.BoolValue(util.IsUnset(request.Body)) {

  894. 				m := util.AssertAsMap(request.Body)

  895. 				request_.Body = tea.ToReader(openapiutil.ToForm(m))

  896. 				request_.Headers["content-type"] = tea.String("application/x-www-form-urlencoded")

  897. 			}

  898. 

  899. 			if !tea.BoolValue(util.IsUnset(request.Query)) {

  900. 				request_.Query = request.Query

  901. 			}

  902. 

  903. 			if !tea.BoolValue(util.EqualString(authType, tea.String("Anonymous"))) {

  904. 				accessKeyId, _err := client.GetAccessKeyId()

  905. 				if _err != nil {

  906. 					return _result, _err

  907. 				}

  908. 

  909. 				accessKeySecret, _err := client.GetAccessKeySecret()

  910. 				if _err != nil {

  911. 					return _result, _err

  912. 				}

  913. 

  914. 				securityToken, _err := client.GetSecurityToken()

  915. 				if _err != nil {

  916. 					return _result, _err

  917. 				}

  918. 

  919. 				if !tea.BoolValue(util.Empty(securityToken)) {

  920. 					request_.Headers["x-acs-accesskey-id"] = accessKeyId

  921. 					request_.Headers["x-acs-security-token"] = securityToken

  922. 				}

  923. 

  924. 				stringToSign := openapiutil.GetStringToSign(request_)

  925. 				request_.Headers["authorization"] = tea.String("acs " + tea.StringValue(accessKeyId) + ":" + tea.StringValue(openapiutil.GetROASignature(stringToSign, accessKeySecret)))

  926. 			}

  927. 

  928. 			response_, _err := tea.DoRequest(request_, _runtime)

  929. 			if _err != nil {

  930. 				return _result, _err

  931. 			}

  932. 			if tea.BoolValue(util.EqualNumber(response_.StatusCode, tea.Int(204))) {

  933. 				_result = make(map[string]interface{})

  934. 				_err = tea.Convert(map[string]map[string]*string{

  935. 					"headers": response_.Headers,

  936. 				}, &_result)

  937. 				return _result, _err

  938. 			}

  939. 

  940. 			if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {

  941. 				_res, _err := util.ReadAsJSON(response_.Body)

  942. 				if _err != nil {

  943. 					return _result, _err

  944. 				}

  945. 

  946. 				err := util.AssertAsMap(_res)

  947. 				_err = tea.NewSDKError(map[string]interface{}{

  948. 					"code":    tea.ToString(DefaultAny(err["Code"], err["code"])),

  949. 					"message": "code: " + tea.ToString(tea.IntValue(response_.StatusCode)) + ", " + tea.ToString(DefaultAny(err["Message"], err["message"])) + " request id: " + tea.ToString(DefaultAny(err["RequestId"], err["requestId"])),

  950. 					"data":    err,

  951. 				})

  952. 				return _result, _err

  953. 			}

  954. 

  955. 			if tea.BoolValue(util.EqualString(bodyType, tea.String("binary"))) {

  956. 				resp := map[string]interface{}{

  957. 					"body":    response_.Body,

  958. 					"headers": response_.Headers,

  959. 				}

  960. 				_result = resp

  961. 				return _result, _err

  962. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("byte"))) {

  963. 				byt, _err := util.ReadAsBytes(response_.Body)

  964. 				if _err != nil {

  965. 					return _result, _err

  966. 				}

  967. 

  968. 				_result = make(map[string]interface{})

  969. 				_err = tea.Convert(map[string]interface{}{

  970. 					"body":    byt,

  971. 					"headers": response_.Headers,

  972. 				}, &_result)

  973. 				return _result, _err

  974. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("string"))) {

  975. 				str, _err := util.ReadAsString(response_.Body)

  976. 				if _err != nil {

  977. 					return _result, _err

  978. 				}

  979. 

  980. 				_result = make(map[string]interface{})

  981. 				_err = tea.Convert(map[string]interface{}{

  982. 					"body":    tea.StringValue(str),

  983. 					"headers": response_.Headers,

  984. 				}, &_result)

  985. 				return _result, _err

  986. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("json"))) {

  987. 				obj, _err := util.ReadAsJSON(response_.Body)

  988. 				if _err != nil {

  989. 					return _result, _err

  990. 				}

  991. 

  992. 				res := util.AssertAsMap(obj)

  993. 				_result = make(map[string]interface{})

  994. 				_err = tea.Convert(map[string]interface{}{

  995. 					"body":    res,

  996. 					"headers": response_.Headers,

  997. 				}, &_result)

  998. 				return _result, _err

  999. 			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("array"))) {

  1000. 				arr, _err := util.ReadAsJSON(response_.Body)

  1001. 				if _err != nil {

  1002. 					return _result, _err

  1003. 				}

  1004. 

  1005. 				_result = make(map[string]interface{})

  1006. 				_err = tea.Convert(map[string]interface{}{

  1007. 					"body":    arr,

  1008. 					"headers": response_.Headers,

  1009. 				}, &_result)

  1010. 				return _result, _err

  1011. 			} else {

  1012. 				_result = make(map[string]interface{})

  1013. 				_err = tea.Convert(map[string]map[string]*string{

  1014. 					"headers": response_.Headers,

  1015. 				}, &_result)

  1016. 				return _result, _err

  1017. 			}

  1018. 

  1019. 		}()

  1020. 		if !tea.BoolValue(tea.Retryable(_err)) {

  1021. 			break

  1022. 		}

  1023. 	}

  1024. 

  1025. 	return _resp, _err

  1026. }

  1027. 

  1028. /**

  1029.  * Encapsulate the request and invoke the network

  1030.  * @param action api name

  1031.  * @param version product version

  1032.  * @param protocol http or https

  1033.  * @param method e.g. GET

  1034.  * @param authType authorization type e.g. AK

  1035.  * @param bodyType response body type e.g. String

  1036.  * @param request object of OpenApiRequest

  1037.  * @param runtime which controls some details of call api, such as retry times

  1038.  * @return the response

  1039.  */

  1040. func (client *Client) DoRequest(params *Params, request *OpenApiRequest, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {

  1041. 	_err = tea.Validate(params)

  1042. 	if _err != nil {

  1043. 		return _result, _err

  1044. 	}

  1045. 	_err = tea.Validate(request)

  1046. 	if _err != nil {

  1047. 		return _result, _err

  1048. 	}

  1049. 	_err = tea.Validate(runtime)

  1050. 	if _err != nil {

  1051. 		return _result, _err

  1052. 	}

  1053. 	_runtime := map[string]interface{}{

  1054. 		"timeouted":      "retry",

  1055. 		"readTimeout":    tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),

  1056. 		"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),

  1057. 		"httpProxy":      tea.StringValue(util.DefaultString(runtime.HttpProxy, client.HttpProxy)),

  1058. 		"httpsProxy":     tea.StringValue(util.DefaultString(runtime.HttpsProxy, client.HttpsProxy)),

  1059. 		"noProxy":        tea.StringValue(util.DefaultString(runtime.NoProxy, client.NoProxy)),

  1060. 		"socks5Proxy":    tea.StringValue(util.DefaultString(runtime.Socks5Proxy, client.Socks5Proxy)),

  1061. 		"socks5NetWork":  tea.StringValue(util.DefaultString(runtime.Socks5NetWork, client.Socks5NetWork)),

  1062. 		"maxIdleConns":   tea.IntValue(util.DefaultNumber(runtime.MaxIdleConns, client.MaxIdleConns)),

  1063. 		"retry": map[string]interface{}{

  1064. 			"retryable":   tea.BoolValue(runtime.Autoretry),

  1065. 			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),

  1066. 		},

  1067. 		"backoff": map[string]interface{}{

  1068. 			"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),

  1069. 			"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),

  1070. 		},

  1071. 		"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),

  1072. 	}

  1073. 

  1074. 	_resp := make(map[string]interface{})

  1075. 	for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {

  1076. 		if _retryTimes > 0 {

  1077. 			_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))

  1078. 			if tea.IntValue(_backoffTime) > 0 {

  1079. 				tea.Sleep(_backoffTime)

  1080. 			}

  1081. 		}

  1082. 

  1083. 		_resp, _err = func() (map[string]interface{}, error) {

  1084. 			request_ := tea.NewRequest()

  1085. 			request_.Protocol = util.DefaultString(client.Protocol, params.Protocol)

  1086. 			request_.Method = params.Method

  1087. 			request_.Pathname = params.Pathname

  1088. 			request_.Query = request.Query

  1089. 			// endpoint is setted in product client

  1090. 			request_.Headers = tea.Merge(map[string]*string{

  1091. 				"host":                  client.Endpoint,

  1092. 				"x-acs-version":         params.Version,

  1093. 				"x-acs-action":          params.Action,

  1094. 				"user-agent":            client.GetUserAgent(),

  1095. 				"x-acs-date":            openapiutil.GetTimestamp(),

  1096. 				"x-acs-signature-nonce": util.GetNonce(),

  1097. 				"accept":                tea.String("application/json"),

  1098. 			}, request.Headers)

  1099. 			if tea.BoolValue(util.EqualString(params.Style, tea.String("RPC"))) {

  1100. 				headers, _err := client.GetRpcHeaders()

  1101. 				if _err != nil {

  1102. 					return _result, _err

  1103. 				}

  1104. 

  1105. 				if !tea.BoolValue(util.IsUnset(headers)) {

  1106. 					request_.Headers = tea.Merge(request_.Headers,

  1107. 						headers)

  1108. 				}

  1109. 

  1110. 			}

  1111. 

  1112. 			signatureAlgorithm := util.DefaultString(client.SignatureAlgorithm, tea.String("ACS3-HMAC-SHA256"))

  1113. 			hashedRequestPayload := openapiutil.HexEncode(openapiutil.Hash(util.ToBytes(tea.String("")), signatureAlgorithm))

  1114. 			if !tea.BoolValue(util.IsUnset(request.Stream)) {

  1115. 				tmp, _err := util.ReadAsBytes(request.Stream)

  1116. 				if _err != nil {

  1117. 					return _result, _err

  1118. 				}

  1119. 

  1120. 				hashedRequestPayload = openapiutil.HexEncode(openapiutil.Hash(tmp, signatureAlgorithm))

  1121. 				request_.Body = tea.ToReader(tmp)

  1122. 				request_.Headers["content-type"] = tea.String("application/octet-stream")

  1123. 			} else {

  1124. 				if !tea.BoolValue(util.IsUnset(request.Body)) {

  1125. 					if tea.BoolValue(util.EqualString(params.ReqBodyType, tea.String("json"))) {

  1126. 						jsonObj := util.ToJSONString(request.Body)

  1127. 						hashedRequestPayload = openapiutil.HexEncode(openapiutil.Hash(util.ToBytes(jsonObj), signatureAlgorithm))

  1128. 						request_.Body = tea.ToReader(jsonObj)

  1129. 						request_.Headers["content-type"] = tea.String("application/json; charset=utf-8")

  1130. 					} else {

  1131. 						m := util.AssertAsMap(request.Body)

  1132. 						formObj := openapiutil.ToForm(m)

  1133. 						hashedRequestPayload = openapiutil.HexEncode(openapiutil.Hash(util.ToBytes(formObj), signatureAlgorithm))

  1134. 						request_.Body = tea.ToReader(formObj)

  1135. 						request_.Headers["content-type"] = tea.String("application/x-www-form-urlencoded")

  1136. 					}

  1137. 

  1138. 				}

  1139. 

  1140. 			}

  1141. 

  1142. 			request_.Headers["x-acs-content-sha256"] = hashedRequestPayload

  1143. 			if !tea.BoolValue(util.EqualString(params.AuthType, tea.String("Anonymous"))) {

  1144. 				authType, _err := client.GetType()

  1145. 				if _err != nil {

  1146. 					return _result, _err

  1147. 				}

  1148. 

  1149. 				if tea.BoolValue(util.EqualString(authType, tea.String("bearer"))) {

  1150. 					bearerToken, _err := client.GetBearerToken()

  1151. 					if _err != nil {

  1152. 						return _result, _err

  1153. 					}

  1154. 

  1155. 					request_.Headers["x-acs-bearer-token"] = bearerToken

  1156. 				} else {

  1157. 					accessKeyId, _err := client.GetAccessKeyId()

  1158. 					if _err != nil {

  1159. 						return _result, _err

  1160. 					}

  1161. 

  1162. 					accessKeySecret, _err := client.GetAccessKeySecret()

  1163. 					if _err != nil {

  1164. 						return _result, _err

  1165. 					}

  1166. 

  1167. 					securityToken, _err := client.GetSecurityToken()

  1168. 					if _err != nil {

  1169. 						return _result, _err

  1170. 					}

  1171. 

  1172. 					if !tea.BoolValue(util.Empty(securityToken)) {

  1173. 						request_.Headers["x-acs-accesskey-id"] = accessKeyId

  1174. 						request_.Headers["x-acs-security-token"] = securityToken

  1175. 					}

  1176. 

  1177. 					request_.Headers["Authorization"] = openapiutil.GetAuthorization(request_, signatureAlgorithm, hashedRequestPayload, accessKeyId, accessKeySecret)

  1178. 				}

  1179. 

  1180. 			}

  1181. 

  1182. 			response_, _err := tea.DoRequest(request_, _runtime)

  1183. 			if _err != nil {

  1184. 				return _result, _err

  1185. 			}

  1186. 			if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {

  1187. 				err := map[string]interface{}{}

  1188. 				if !tea.BoolValue(util.IsUnset(response_.Headers["content-type"])) && tea.BoolValue(util.EqualString(response_.Headers["content-type"], tea.String("text/xml;charset=utf-8"))) {

  1189. 					_str, _err := util.ReadAsString(response_.Body)

  1190. 					if _err != nil {

  1191. 						return _result, _err

  1192. 					}

  1193. 

  1194. 					respMap := xml.ParseXml(_str, nil)

  1195. 					err = util.AssertAsMap(respMap["Error"])

  1196. 				} else {

  1197. 					_res, _err := util.ReadAsJSON(response_.Body)

  1198. 					if _err != nil {

  1199. 						return _result, _err

  1200. 					}

  1201. 

  1202. 					err = util.AssertAsMap(_res)

  1203. 				}

  1204. 

  1205. 				err["statusCode"] = response_.StatusCode

  1206. 				_err = tea.NewSDKError(map[string]interface{}{

  1207. 					"code":    tea.ToString(DefaultAny(err["Code"], err["code"])),

  1208. 					"message": "code: " + tea.ToString(tea.IntValue(response_.StatusCode)) + ", " + tea.ToString(DefaultAny(err["Message"], err["message"])) + " request id: " + tea.ToString(DefaultAny(err["RequestId"], err["requestId"])),

  1209. 					"data":    err,

  1210. 				})

  1211. 				return _result, _err

  1212. 			}

  1213. 

  1214. 			if tea.BoolValue(util.EqualString(params.BodyType, tea.String("binary"))) {

  1215. 				resp := map[string]interface{}{

  1216. 					"body":    response_.Body,

  1217. 					"headers": response_.Headers,

  1218. 				}

  1219. 				_result = resp

  1220. 				return _result, _err

  1221. 			} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("byte"))) {

  1222. 				byt, _err := util.ReadAsBytes(response_.Body)

  1223. 				if _err != nil {

  1224. 					return _result, _err

  1225. 				}

  1226. 

  1227. 				_result = make(map[string]interface{})

  1228. 				_err = tea.Convert(map[string]interface{}{

  1229. 					"body":    byt,

  1230. 					"headers": response_.Headers,

  1231. 				}, &_result)

  1232. 				return _result, _err

  1233. 			} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("string"))) {

  1234. 				str, _err := util.ReadAsString(response_.Body)

  1235. 				if _err != nil {

  1236. 					return _result, _err

  1237. 				}

  1238. 

  1239. 				_result = make(map[string]interface{})

  1240. 				_err = tea.Convert(map[string]interface{}{

  1241. 					"body":    tea.StringValue(str),

  1242. 					"headers": response_.Headers,

  1243. 				}, &_result)

  1244. 				return _result, _err

  1245. 			} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("json"))) {

  1246. 				obj, _err := util.ReadAsJSON(response_.Body)

  1247. 				if _err != nil {

  1248. 					return _result, _err

  1249. 				}

  1250. 

  1251. 				res := util.AssertAsMap(obj)

  1252. 				_result = make(map[string]interface{})

  1253. 				_err = tea.Convert(map[string]interface{}{

  1254. 					"body":    res,

  1255. 					"headers": response_.Headers,

  1256. 				}, &_result)

  1257. 				return _result, _err

  1258. 			} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("array"))) {

  1259. 				arr, _err := util.ReadAsJSON(response_.Body)

  1260. 				if _err != nil {

  1261. 					return _result, _err

  1262. 				}

  1263. 

  1264. 				_result = make(map[string]interface{})

  1265. 				_err = tea.Convert(map[string]interface{}{

  1266. 					"body":    arr,

  1267. 					"headers": response_.Headers,

  1268. 				}, &_result)

  1269. 				return _result, _err

  1270. 			} else {

  1271. 				_result = make(map[string]interface{})

  1272. 				_err = tea.Convert(map[string]map[string]*string{

  1273. 					"headers": response_.Headers,

  1274. 				}, &_result)

  1275. 				return _result, _err

  1276. 			}

  1277. 

  1278. 		}()

  1279. 		if !tea.BoolValue(tea.Retryable(_err)) {

  1280. 			break

  1281. 		}

  1282. 	}

  1283. 

  1284. 	return _resp, _err

  1285. }

  1286. 

  1287. /**

  1288.  * Encapsulate the request and invoke the network

  1289.  * @param action api name

  1290.  * @param version product version

  1291.  * @param protocol http or https

  1292.  * @param method e.g. GET

  1293.  * @param authType authorization type e.g. AK

  1294.  * @param bodyType response body type e.g. String

  1295.  * @param request object of OpenApiRequest

  1296.  * @param runtime which controls some details of call api, such as retry times

  1297.  * @return the response

  1298.  */

  1299. func (client *Client) Execute(params *Params, request *OpenApiRequest, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {

  1300. 	_err = tea.Validate(params)

  1301. 	if _err != nil {

  1302. 		return _result, _err

  1303. 	}

  1304. 	_err = tea.Validate(request)

  1305. 	if _err != nil {

  1306. 		return _result, _err

  1307. 	}

  1308. 	_err = tea.Validate(runtime)

  1309. 	if _err != nil {

  1310. 		return _result, _err

  1311. 	}

  1312. 	_runtime := map[string]interface{}{

  1313. 		"timeouted":      "retry",

  1314. 		"readTimeout":    tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),

  1315. 		"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),

  1316. 		"httpProxy":      tea.StringValue(util.DefaultString(runtime.HttpProxy, client.HttpProxy)),

  1317. 		"httpsProxy":     tea.StringValue(util.DefaultString(runtime.HttpsProxy, client.HttpsProxy)),

  1318. 		"noProxy":        tea.StringValue(util.DefaultString(runtime.NoProxy, client.NoProxy)),

  1319. 		"socks5Proxy":    tea.StringValue(util.DefaultString(runtime.Socks5Proxy, client.Socks5Proxy)),

  1320. 		"socks5NetWork":  tea.StringValue(util.DefaultString(runtime.Socks5NetWork, client.Socks5NetWork)),

  1321. 		"maxIdleConns":   tea.IntValue(util.DefaultNumber(runtime.MaxIdleConns, client.MaxIdleConns)),

  1322. 		"retry": map[string]interface{}{

  1323. 			"retryable":   tea.BoolValue(runtime.Autoretry),

  1324. 			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),

  1325. 		},

  1326. 		"backoff": map[string]interface{}{

  1327. 			"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),

  1328. 			"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),

  1329. 		},

  1330. 		"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),

  1331. 	}

  1332. 

  1333. 	_resp := make(map[string]interface{})

  1334. 	for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {

  1335. 		if _retryTimes > 0 {

  1336. 			_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))

  1337. 			if tea.IntValue(_backoffTime) > 0 {

  1338. 				tea.Sleep(_backoffTime)

  1339. 			}

  1340. 		}

  1341. 

  1342. 		_resp, _err = func() (map[string]interface{}, error) {

  1343. 			request_ := tea.NewRequest()

  1344. 			// spi = new Gateway();//Gateway implements SPI，这一步在产品 SDK 中实例化

  1345. 			headers, _err := client.GetRpcHeaders()

  1346. 			if _err != nil {

  1347. 				return _result, _err

  1348. 			}

  1349. 

  1350. 			requestContext := &spi.InterceptorContextRequest{

  1351. 				Headers: tea.Merge(request.Headers,

  1352. 					headers),

  1353. 				Query:              request.Query,

  1354. 				Body:               request.Body,

  1355. 				Stream:             request.Stream,

  1356. 				HostMap:            request.HostMap,

  1357. 				Pathname:           params.Pathname,

  1358. 				ProductId:          client.ProductId,

  1359. 				Action:             params.Action,

  1360. 				Version:            params.Version,

  1361. 				Protocol:           util.DefaultString(client.Protocol, params.Protocol),

  1362. 				Method:             util.DefaultString(client.Method, params.Method),

  1363. 				AuthType:           params.AuthType,

  1364. 				BodyType:           params.BodyType,

  1365. 				ReqBodyType:        params.ReqBodyType,

  1366. 				Style:              params.Style,

  1367. 				Credential:         client.Credential,

  1368. 				SignatureVersion:   client.SignatureVersion,

  1369. 				SignatureAlgorithm: client.SignatureAlgorithm,

  1370. 				UserAgent:          client.GetUserAgent(),

  1371. 			}

  1372. 			configurationContext := &spi.InterceptorContextConfiguration{

  1373. 				RegionId:     client.RegionId,

  1374. 				Endpoint:     util.DefaultString(request.EndpointOverride, client.Endpoint),

  1375. 				EndpointRule: client.EndpointRule,

  1376. 				EndpointMap:  client.EndpointMap,

  1377. 				EndpointType: client.EndpointType,

  1378. 				Network:      client.Network,

  1379. 				Suffix:       client.Suffix,

  1380. 			}

  1381. 			interceptorContext := &spi.InterceptorContext{

  1382. 				Request:       requestContext,

  1383. 				Configuration: configurationContext,

  1384. 			}

  1385. 			attributeMap := &spi.AttributeMap{}

  1386. 			// 1. spi.modifyConfiguration(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);

  1387. 			_err = client.Spi.ModifyConfiguration(interceptorContext, attributeMap)

  1388. 			if _err != nil {

  1389. 				return _result, _err

  1390. 			}

  1391. 			// 2. spi.modifyRequest(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);

  1392. 			_err = client.Spi.ModifyRequest(interceptorContext, attributeMap)

  1393. 			if _err != nil {

  1394. 				return _result, _err

  1395. 			}

  1396. 			request_.Protocol = interceptorContext.Request.Protocol

  1397. 			request_.Method = interceptorContext.Request.Method

  1398. 			request_.Pathname = interceptorContext.Request.Pathname

  1399. 			request_.Query = interceptorContext.Request.Query

  1400. 			request_.Body = interceptorContext.Request.Stream

  1401. 			request_.Headers = interceptorContext.Request.Headers

  1402. 			response_, _err := tea.DoRequest(request_, _runtime)

  1403. 			if _err != nil {

  1404. 				return _result, _err

  1405. 			}

  1406. 			responseContext := &spi.InterceptorContextResponse{

  1407. 				StatusCode: response_.StatusCode,

  1408. 				Headers:    response_.Headers,

  1409. 				Body:       response_.Body,

  1410. 			}

  1411. 			interceptorContext.Response = responseContext

  1412. 			// 3. spi.modifyResponse(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);

  1413. 			_err = client.Spi.ModifyResponse(interceptorContext, attributeMap)

  1414. 			if _err != nil {

  1415. 				return _result, _err

  1416. 			}

  1417. 			_result = make(map[string]interface{})

  1418. 			_err = tea.Convert(map[string]interface{}{

  1419. 				"headers": interceptorContext.Response.Headers,

  1420. 				"body":    interceptorContext.Response.DeserializedBody,

  1421. 			}, &_result)

  1422. 			return _result, _err

  1423. 		}()

  1424. 		if !tea.BoolValue(tea.Retryable(_err)) {

  1425. 			break

  1426. 		}

  1427. 	}

  1428. 

  1429. 	return _resp, _err

  1430. }

  1431. 

  1432. func (client *Client) CallApi(params *Params, request *OpenApiRequest, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {

  1433. 	if tea.BoolValue(util.IsUnset(tea.ToMap(params))) {

  1434. 		_err = tea.NewSDKError(map[string]interface{}{

  1435. 			"code":    "ParameterMissing",

  1436. 			"message": "'params' can not be unset",

  1437. 		})

  1438. 		return _result, _err

  1439. 	}

  1440. 

  1441. 	if tea.BoolValue(util.IsUnset(client.SignatureAlgorithm)) || !tea.BoolValue(util.EqualString(client.SignatureAlgorithm, tea.String("v2"))) {

  1442. 		_result = make(map[string]interface{})

  1443. 		_body, _err := client.DoRequest(params, request, runtime)

  1444. 		if _err != nil {

  1445. 			return _result, _err

  1446. 		}

  1447. 		_result = _body

  1448. 		return _result, _err

  1449. 	} else if tea.BoolValue(util.EqualString(params.Style, tea.String("ROA"))) && tea.BoolValue(util.EqualString(params.ReqBodyType, tea.String("json"))) {

  1450. 		_result = make(map[string]interface{})

  1451. 		_body, _err := client.DoROARequest(params.Action, params.Version, params.Protocol, params.Method, params.AuthType, params.Pathname, params.BodyType, request, runtime)

  1452. 		if _err != nil {

  1453. 			return _result, _err

  1454. 		}

  1455. 		_result = _body

  1456. 		return _result, _err

  1457. 	} else if tea.BoolValue(util.EqualString(params.Style, tea.String("ROA"))) {

  1458. 		_result = make(map[string]interface{})

  1459. 		_body, _err := client.DoROARequestWithForm(params.Action, params.Version, params.Protocol, params.Method, params.AuthType, params.Pathname, params.BodyType, request, runtime)

  1460. 		if _err != nil {

  1461. 			return _result, _err

  1462. 		}

  1463. 		_result = _body

  1464. 		return _result, _err

  1465. 	} else {

  1466. 		_result = make(map[string]interface{})

  1467. 		_body, _err := client.DoRPCRequest(params.Action, params.Version, params.Protocol, params.Method, params.AuthType, params.BodyType, request, runtime)

  1468. 		if _err != nil {

  1469. 			return _result, _err

  1470. 		}

  1471. 		_result = _body

  1472. 		return _result, _err

  1473. 	}

  1474. 

  1475. }

  1476. 

  1477. /**

  1478.  * Get user agent

  1479.  * @return user agent

  1480.  */

  1481. func (client *Client) GetUserAgent() (_result *string) {

  1482. 	userAgent := util.GetUserAgent(client.UserAgent)

  1483. 	_result = userAgent

  1484. 	return _result

  1485. }

  1486. 

  1487. /**

  1488.  * Get accesskey id by using credential

  1489.  * @return accesskey id

  1490.  */

  1491. func (client *Client) GetAccessKeyId() (_result *string, _err error) {

  1492. 	if tea.BoolValue(util.IsUnset(client.Credential)) {

  1493. 		_result = tea.String("")

  1494. 		return _result, _err

  1495. 	}

  1496. 

  1497. 	accessKeyId, _err := client.Credential.GetAccessKeyId()

  1498. 	if _err != nil {

  1499. 		return _result, _err

  1500. 	}

  1501. 

  1502. 	_result = accessKeyId

  1503. 	return _result, _err

  1504. }

  1505. 

  1506. /**

  1507.  * Get accesskey secret by using credential

  1508.  * @return accesskey secret

  1509.  */

  1510. func (client *Client) GetAccessKeySecret() (_result *string, _err error) {

  1511. 	if tea.BoolValue(util.IsUnset(client.Credential)) {

  1512. 		_result = tea.String("")

  1513. 		return _result, _err

  1514. 	}

  1515. 

  1516. 	secret, _err := client.Credential.GetAccessKeySecret()

  1517. 	if _err != nil {

  1518. 		return _result, _err

  1519. 	}

  1520. 

  1521. 	_result = secret

  1522. 	return _result, _err

  1523. }

  1524. 

  1525. /**

  1526.  * Get security token by using credential

  1527.  * @return security token

  1528.  */

  1529. func (client *Client) GetSecurityToken() (_result *string, _err error) {

  1530. 	if tea.BoolValue(util.IsUnset(client.Credential)) {

  1531. 		_result = tea.String("")

  1532. 		return _result, _err

  1533. 	}

  1534. 

  1535. 	token, _err := client.Credential.GetSecurityToken()

  1536. 	if _err != nil {

  1537. 		return _result, _err

  1538. 	}

  1539. 

  1540. 	_result = token

  1541. 	return _result, _err

  1542. }

  1543. 

  1544. /**

  1545.  * Get bearer token by credential

  1546.  * @return bearer token

  1547.  */

  1548. func (client *Client) GetBearerToken() (_result *string, _err error) {

  1549. 	if tea.BoolValue(util.IsUnset(client.Credential)) {

  1550. 		_result = tea.String("")

  1551. 		return _result, _err

  1552. 	}

  1553. 

  1554. 	token := client.Credential.GetBearerToken()

  1555. 	_result = token

  1556. 	return _result, _err

  1557. }

  1558. 

  1559. /**

  1560.  * Get credential type by credential

  1561.  * @return credential type e.g. access_key

  1562.  */

  1563. func (client *Client) GetType() (_result *string, _err error) {

  1564. 	if tea.BoolValue(util.IsUnset(client.Credential)) {

  1565. 		_result = tea.String("")

  1566. 		return _result, _err

  1567. 	}

  1568. 

  1569. 	authType := client.Credential.GetType()

  1570. 	_result = authType

  1571. 	return _result, _err

  1572. }

  1573. 

  1574. /**

  1575.  * If inputValue is not null, return it or return defaultValue

  1576.  * @param inputValue  users input value

  1577.  * @param defaultValue default value

  1578.  * @return the final result

  1579.  */

  1580. func DefaultAny(inputValue interface{}, defaultValue interface{}) (_result interface{}) {

  1581. 	if tea.BoolValue(util.IsUnset(inputValue)) {

  1582. 		_result = defaultValue

  1583. 		return _result

  1584. 	}

  1585. 

  1586. 	_result = inputValue

  1587. 	return _result

  1588. }

  1589. 

  1590. /**

  1591.  * If the endpointRule and config.endpoint are empty, throw error

  1592.  * @param config config contains the necessary information to create a client

  1593.  */

  1594. func (client *Client) CheckConfig(config *Config) (_err error) {

  1595. 	if tea.BoolValue(util.Empty(client.EndpointRule)) && tea.BoolValue(util.Empty(config.Endpoint)) {

  1596. 		_err = tea.NewSDKError(map[string]interface{}{

  1597. 			"code":    "ParameterMissing",

  1598. 			"message": "'config.endpoint' can not be empty",

  1599. 		})

  1600. 		return _err

  1601. 	}

  1602. 

  1603. 	return _err

  1604. }

  1605. 

  1606. /**

  1607.  * set RPC header for debug

  1608.  * @param headers headers for debug, this header can be used only once.

  1609.  */

  1610. func (client *Client) SetRpcHeaders(headers map[string]*string) (_err error) {

  1611. 	client.Headers = headers

  1612. 	return _err

  1613. }

  1614. 

  1615. /**

  1616.  * get RPC header for debug

  1617.  */

  1618. func (client *Client) GetRpcHeaders() (_result map[string]*string, _err error) {

  1619. 	headers := client.Headers

  1620. 	client.Headers = nil

  1621. 	_result = headers

  1622. 	return _result, _err

  1623. }