Source file src/github.com/alibabacloud-go/darabonba-openapi/client/client.go

Documentation: github.com/alibabacloud-go/darabonba-openapi/client

     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  type GlobalParameters struct {
    19  	Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty"`
    20  	Queries map[string]*string `json:"queries,omitempty" xml:"queries,omitempty"`
    21  }
    22  
    23  func (s GlobalParameters) String() string {
    24  	return tea.Prettify(s)
    25  }
    26  
    27  func (s GlobalParameters) GoString() string {
    28  	return s.String()
    29  }
    30  
    31  func (s *GlobalParameters) SetHeaders(v map[string]*string) *GlobalParameters {
    32  	s.Headers = v
    33  	return s
    34  }
    35  
    36  func (s *GlobalParameters) SetQueries(v map[string]*string) *GlobalParameters {
    37  	s.Queries = v
    38  	return s
    39  }
    40  
    41  /**
    42   * Model for initing client
    43   */
    44  type Config struct {
    45  	// accesskey id
    46  	AccessKeyId *string `json:"accessKeyId,omitempty" xml:"accessKeyId,omitempty"`
    47  	// accesskey secret
    48  	AccessKeySecret *string `json:"accessKeySecret,omitempty" xml:"accessKeySecret,omitempty"`
    49  	// security token
    50  	SecurityToken *string `json:"securityToken,omitempty" xml:"securityToken,omitempty"`
    51  	// http protocol
    52  	Protocol *string `json:"protocol,omitempty" xml:"protocol,omitempty"`
    53  	// http method
    54  	Method *string `json:"method,omitempty" xml:"method,omitempty"`
    55  	// region id
    56  	RegionId *string `json:"regionId,omitempty" xml:"regionId,omitempty"`
    57  	// read timeout
    58  	ReadTimeout *int `json:"readTimeout,omitempty" xml:"readTimeout,omitempty"`
    59  	// connect timeout
    60  	ConnectTimeout *int `json:"connectTimeout,omitempty" xml:"connectTimeout,omitempty"`
    61  	// http proxy
    62  	HttpProxy *string `json:"httpProxy,omitempty" xml:"httpProxy,omitempty"`
    63  	// https proxy
    64  	HttpsProxy *string `json:"httpsProxy,omitempty" xml:"httpsProxy,omitempty"`
    65  	// credential
    66  	Credential credential.Credential `json:"credential,omitempty" xml:"credential,omitempty"`
    67  	// endpoint
    68  	Endpoint *string `json:"endpoint,omitempty" xml:"endpoint,omitempty"`
    69  	// proxy white list
    70  	NoProxy *string `json:"noProxy,omitempty" xml:"noProxy,omitempty"`
    71  	// max idle conns
    72  	MaxIdleConns *int `json:"maxIdleConns,omitempty" xml:"maxIdleConns,omitempty"`
    73  	// network for endpoint
    74  	Network *string `json:"network,omitempty" xml:"network,omitempty"`
    75  	// user agent
    76  	UserAgent *string `json:"userAgent,omitempty" xml:"userAgent,omitempty"`
    77  	// suffix for endpoint
    78  	Suffix *string `json:"suffix,omitempty" xml:"suffix,omitempty"`
    79  	// socks5 proxy
    80  	Socks5Proxy *string `json:"socks5Proxy,omitempty" xml:"socks5Proxy,omitempty"`
    81  	// socks5 network
    82  	Socks5NetWork *string `json:"socks5NetWork,omitempty" xml:"socks5NetWork,omitempty"`
    83  	// endpoint type
    84  	EndpointType *string `json:"endpointType,omitempty" xml:"endpointType,omitempty"`
    85  	// OpenPlatform endpoint
    86  	OpenPlatformEndpoint *string `json:"openPlatformEndpoint,omitempty" xml:"openPlatformEndpoint,omitempty"`
    87  	// Deprecated
    88  	// credential type
    89  	Type *string `json:"type,omitempty" xml:"type,omitempty"`
    90  	// Signature Version
    91  	SignatureVersion *string `json:"signatureVersion,omitempty" xml:"signatureVersion,omitempty"`
    92  	// Signature Algorithm
    93  	SignatureAlgorithm *string `json:"signatureAlgorithm,omitempty" xml:"signatureAlgorithm,omitempty"`
    94  	// Global Parameters
    95  	GlobalParameters *GlobalParameters `json:"globalParameters,omitempty" xml:"globalParameters,omitempty"`
    96  }
    97  
    98  func (s Config) String() string {
    99  	return tea.Prettify(s)
   100  }
   101  
   102  func (s Config) GoString() string {
   103  	return s.String()
   104  }
   105  
   106  func (s *Config) SetAccessKeyId(v string) *Config {
   107  	s.AccessKeyId = &v
   108  	return s
   109  }
   110  
   111  func (s *Config) SetAccessKeySecret(v string) *Config {
   112  	s.AccessKeySecret = &v
   113  	return s
   114  }
   115  
   116  func (s *Config) SetSecurityToken(v string) *Config {
   117  	s.SecurityToken = &v
   118  	return s
   119  }
   120  
   121  func (s *Config) SetProtocol(v string) *Config {
   122  	s.Protocol = &v
   123  	return s
   124  }
   125  
   126  func (s *Config) SetMethod(v string) *Config {
   127  	s.Method = &v
   128  	return s
   129  }
   130  
   131  func (s *Config) SetRegionId(v string) *Config {
   132  	s.RegionId = &v
   133  	return s
   134  }
   135  
   136  func (s *Config) SetReadTimeout(v int) *Config {
   137  	s.ReadTimeout = &v
   138  	return s
   139  }
   140  
   141  func (s *Config) SetConnectTimeout(v int) *Config {
   142  	s.ConnectTimeout = &v
   143  	return s
   144  }
   145  
   146  func (s *Config) SetHttpProxy(v string) *Config {
   147  	s.HttpProxy = &v
   148  	return s
   149  }
   150  
   151  func (s *Config) SetHttpsProxy(v string) *Config {
   152  	s.HttpsProxy = &v
   153  	return s
   154  }
   155  
   156  func (s *Config) SetCredential(v credential.Credential) *Config {
   157  	s.Credential = v
   158  	return s
   159  }
   160  
   161  func (s *Config) SetEndpoint(v string) *Config {
   162  	s.Endpoint = &v
   163  	return s
   164  }
   165  
   166  func (s *Config) SetNoProxy(v string) *Config {
   167  	s.NoProxy = &v
   168  	return s
   169  }
   170  
   171  func (s *Config) SetMaxIdleConns(v int) *Config {
   172  	s.MaxIdleConns = &v
   173  	return s
   174  }
   175  
   176  func (s *Config) SetNetwork(v string) *Config {
   177  	s.Network = &v
   178  	return s
   179  }
   180  
   181  func (s *Config) SetUserAgent(v string) *Config {
   182  	s.UserAgent = &v
   183  	return s
   184  }
   185  
   186  func (s *Config) SetSuffix(v string) *Config {
   187  	s.Suffix = &v
   188  	return s
   189  }
   190  
   191  func (s *Config) SetSocks5Proxy(v string) *Config {
   192  	s.Socks5Proxy = &v
   193  	return s
   194  }
   195  
   196  func (s *Config) SetSocks5NetWork(v string) *Config {
   197  	s.Socks5NetWork = &v
   198  	return s
   199  }
   200  
   201  func (s *Config) SetEndpointType(v string) *Config {
   202  	s.EndpointType = &v
   203  	return s
   204  }
   205  
   206  func (s *Config) SetOpenPlatformEndpoint(v string) *Config {
   207  	s.OpenPlatformEndpoint = &v
   208  	return s
   209  }
   210  
   211  func (s *Config) SetType(v string) *Config {
   212  	s.Type = &v
   213  	return s
   214  }
   215  
   216  func (s *Config) SetSignatureVersion(v string) *Config {
   217  	s.SignatureVersion = &v
   218  	return s
   219  }
   220  
   221  func (s *Config) SetSignatureAlgorithm(v string) *Config {
   222  	s.SignatureAlgorithm = &v
   223  	return s
   224  }
   225  
   226  func (s *Config) SetGlobalParameters(v *GlobalParameters) *Config {
   227  	s.GlobalParameters = v
   228  	return s
   229  }
   230  
   231  type OpenApiRequest struct {
   232  	Headers          map[string]*string `json:"headers,omitempty" xml:"headers,omitempty"`
   233  	Query            map[string]*string `json:"query,omitempty" xml:"query,omitempty"`
   234  	Body             interface{}        `json:"body,omitempty" xml:"body,omitempty"`
   235  	Stream           io.Reader          `json:"stream,omitempty" xml:"stream,omitempty"`
   236  	HostMap          map[string]*string `json:"hostMap,omitempty" xml:"hostMap,omitempty"`
   237  	EndpointOverride *string            `json:"endpointOverride,omitempty" xml:"endpointOverride,omitempty"`
   238  }
   239  
   240  func (s OpenApiRequest) String() string {
   241  	return tea.Prettify(s)
   242  }
   243  
   244  func (s OpenApiRequest) GoString() string {
   245  	return s.String()
   246  }
   247  
   248  func (s *OpenApiRequest) SetHeaders(v map[string]*string) *OpenApiRequest {
   249  	s.Headers = v
   250  	return s
   251  }
   252  
   253  func (s *OpenApiRequest) SetQuery(v map[string]*string) *OpenApiRequest {
   254  	s.Query = v
   255  	return s
   256  }
   257  
   258  func (s *OpenApiRequest) SetBody(v interface{}) *OpenApiRequest {
   259  	s.Body = v
   260  	return s
   261  }
   262  
   263  func (s *OpenApiRequest) SetStream(v io.Reader) *OpenApiRequest {
   264  	s.Stream = v
   265  	return s
   266  }
   267  
   268  func (s *OpenApiRequest) SetHostMap(v map[string]*string) *OpenApiRequest {
   269  	s.HostMap = v
   270  	return s
   271  }
   272  
   273  func (s *OpenApiRequest) SetEndpointOverride(v string) *OpenApiRequest {
   274  	s.EndpointOverride = &v
   275  	return s
   276  }
   277  
   278  type Params struct {
   279  	Action      *string `json:"action,omitempty" xml:"action,omitempty" require:"true"`
   280  	Version     *string `json:"version,omitempty" xml:"version,omitempty" require:"true"`
   281  	Protocol    *string `json:"protocol,omitempty" xml:"protocol,omitempty" require:"true"`
   282  	Pathname    *string `json:"pathname,omitempty" xml:"pathname,omitempty" require:"true"`
   283  	Method      *string `json:"method,omitempty" xml:"method,omitempty" require:"true"`
   284  	AuthType    *string `json:"authType,omitempty" xml:"authType,omitempty" require:"true"`
   285  	BodyType    *string `json:"bodyType,omitempty" xml:"bodyType,omitempty" require:"true"`
   286  	ReqBodyType *string `json:"reqBodyType,omitempty" xml:"reqBodyType,omitempty" require:"true"`
   287  	Style       *string `json:"style,omitempty" xml:"style,omitempty"`
   288  }
   289  
   290  func (s Params) String() string {
   291  	return tea.Prettify(s)
   292  }
   293  
   294  func (s Params) GoString() string {
   295  	return s.String()
   296  }
   297  
   298  func (s *Params) SetAction(v string) *Params {
   299  	s.Action = &v
   300  	return s
   301  }
   302  
   303  func (s *Params) SetVersion(v string) *Params {
   304  	s.Version = &v
   305  	return s
   306  }
   307  
   308  func (s *Params) SetProtocol(v string) *Params {
   309  	s.Protocol = &v
   310  	return s
   311  }
   312  
   313  func (s *Params) SetPathname(v string) *Params {
   314  	s.Pathname = &v
   315  	return s
   316  }
   317  
   318  func (s *Params) SetMethod(v string) *Params {
   319  	s.Method = &v
   320  	return s
   321  }
   322  
   323  func (s *Params) SetAuthType(v string) *Params {
   324  	s.AuthType = &v
   325  	return s
   326  }
   327  
   328  func (s *Params) SetBodyType(v string) *Params {
   329  	s.BodyType = &v
   330  	return s
   331  }
   332  
   333  func (s *Params) SetReqBodyType(v string) *Params {
   334  	s.ReqBodyType = &v
   335  	return s
   336  }
   337  
   338  func (s *Params) SetStyle(v string) *Params {
   339  	s.Style = &v
   340  	return s
   341  }
   342  
   343  type Client struct {
   344  	Endpoint             *string
   345  	RegionId             *string
   346  	Protocol             *string
   347  	Method               *string
   348  	UserAgent            *string
   349  	EndpointRule         *string
   350  	EndpointMap          map[string]*string
   351  	Suffix               *string
   352  	ReadTimeout          *int
   353  	ConnectTimeout       *int
   354  	HttpProxy            *string
   355  	HttpsProxy           *string
   356  	Socks5Proxy          *string
   357  	Socks5NetWork        *string
   358  	NoProxy              *string
   359  	Network              *string
   360  	ProductId            *string
   361  	MaxIdleConns         *int
   362  	EndpointType         *string
   363  	OpenPlatformEndpoint *string
   364  	Credential           credential.Credential
   365  	SignatureVersion     *string
   366  	SignatureAlgorithm   *string
   367  	Headers              map[string]*string
   368  	Spi                  spi.ClientInterface
   369  	GlobalParameters     *GlobalParameters
   370  }
   371  
   372  /**
   373   * Init client with Config
   374   * @param config config contains the necessary information to create a client
   375   */
   376  func NewClient(config *Config) (*Client, error) {
   377  	client := new(Client)
   378  	err := client.Init(config)
   379  	return client, err
   380  }
   381  
   382  func (client *Client) Init(config *Config) (_err error) {
   383  	if tea.BoolValue(util.IsUnset(tea.ToMap(config))) {
   384  		_err = tea.NewSDKError(map[string]interface{}{
   385  			"code":    "ParameterMissing",
   386  			"message": "'config' can not be unset",
   387  		})
   388  		return _err
   389  	}
   390  
   391  	if !tea.BoolValue(util.Empty(config.AccessKeyId)) && !tea.BoolValue(util.Empty(config.AccessKeySecret)) {
   392  		if !tea.BoolValue(util.Empty(config.SecurityToken)) {
   393  			config.Type = tea.String("sts")
   394  		} else {
   395  			config.Type = tea.String("access_key")
   396  		}
   397  
   398  		credentialConfig := &credential.Config{
   399  			AccessKeyId:     config.AccessKeyId,
   400  			Type:            config.Type,
   401  			AccessKeySecret: config.AccessKeySecret,
   402  			SecurityToken:   config.SecurityToken,
   403  		}
   404  		client.Credential, _err = credential.NewCredential(credentialConfig)
   405  		if _err != nil {
   406  			return _err
   407  		}
   408  
   409  	} else if !tea.BoolValue(util.IsUnset(config.Credential)) {
   410  		client.Credential = config.Credential
   411  	}
   412  
   413  	client.Endpoint = config.Endpoint
   414  	client.EndpointType = config.EndpointType
   415  	client.Network = config.Network
   416  	client.Suffix = config.Suffix
   417  	client.Protocol = config.Protocol
   418  	client.Method = config.Method
   419  	client.RegionId = config.RegionId
   420  	client.UserAgent = config.UserAgent
   421  	client.ReadTimeout = config.ReadTimeout
   422  	client.ConnectTimeout = config.ConnectTimeout
   423  	client.HttpProxy = config.HttpProxy
   424  	client.HttpsProxy = config.HttpsProxy
   425  	client.NoProxy = config.NoProxy
   426  	client.Socks5Proxy = config.Socks5Proxy
   427  	client.Socks5NetWork = config.Socks5NetWork
   428  	client.MaxIdleConns = config.MaxIdleConns
   429  	client.SignatureVersion = config.SignatureVersion
   430  	client.SignatureAlgorithm = config.SignatureAlgorithm
   431  	client.GlobalParameters = config.GlobalParameters
   432  	return nil
   433  }
   434  
   435  /**
   436   * Encapsulate the request and invoke the network
   437   * @param action api name
   438   * @param version product version
   439   * @param protocol http or https
   440   * @param method e.g. GET
   441   * @param authType authorization type e.g. AK
   442   * @param bodyType response body type e.g. String
   443   * @param request object of OpenApiRequest
   444   * @param runtime which controls some details of call api, such as retry times
   445   * @return the response
   446   */
   447  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) {
   448  	_err = tea.Validate(request)
   449  	if _err != nil {
   450  		return _result, _err
   451  	}
   452  	_err = tea.Validate(runtime)
   453  	if _err != nil {
   454  		return _result, _err
   455  	}
   456  	_runtime := map[string]interface{}{
   457  		"timeouted":      "retry",
   458  		"readTimeout":    tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),
   459  		"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),
   460  		"httpProxy":      tea.StringValue(util.DefaultString(runtime.HttpProxy, client.HttpProxy)),
   461  		"httpsProxy":     tea.StringValue(util.DefaultString(runtime.HttpsProxy, client.HttpsProxy)),
   462  		"noProxy":        tea.StringValue(util.DefaultString(runtime.NoProxy, client.NoProxy)),
   463  		"socks5Proxy":    tea.StringValue(util.DefaultString(runtime.Socks5Proxy, client.Socks5Proxy)),
   464  		"socks5NetWork":  tea.StringValue(util.DefaultString(runtime.Socks5NetWork, client.Socks5NetWork)),
   465  		"maxIdleConns":   tea.IntValue(util.DefaultNumber(runtime.MaxIdleConns, client.MaxIdleConns)),
   466  		"retry": map[string]interface{}{
   467  			"retryable":   tea.BoolValue(runtime.Autoretry),
   468  			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),
   469  		},
   470  		"backoff": map[string]interface{}{
   471  			"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),
   472  			"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),
   473  		},
   474  		"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),
   475  	}
   476  
   477  	_resp := make(map[string]interface{})
   478  	for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {
   479  		if _retryTimes > 0 {
   480  			_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))
   481  			if tea.IntValue(_backoffTime) > 0 {
   482  				tea.Sleep(_backoffTime)
   483  			}
   484  		}
   485  
   486  		_resp, _err = func() (map[string]interface{}, error) {
   487  			request_ := tea.NewRequest()
   488  			request_.Protocol = util.DefaultString(client.Protocol, protocol)
   489  			request_.Method = method
   490  			request_.Pathname = tea.String("/")
   491  			request_.Query = tea.Merge(map[string]*string{
   492  				"Action":         action,
   493  				"Format":         tea.String("json"),
   494  				"Version":        version,
   495  				"Timestamp":      openapiutil.GetTimestamp(),
   496  				"SignatureNonce": util.GetNonce(),
   497  			}, request.Query)
   498  			headers, _err := client.GetRpcHeaders()
   499  			if _err != nil {
   500  				return _result, _err
   501  			}
   502  
   503  			if tea.BoolValue(util.IsUnset(headers)) {
   504  				// endpoint is setted in product client
   505  				request_.Headers = map[string]*string{
   506  					"host":          client.Endpoint,
   507  					"x-acs-version": version,
   508  					"x-acs-action":  action,
   509  					"user-agent":    client.GetUserAgent(),
   510  				}
   511  			} else {
   512  				request_.Headers = tea.Merge(map[string]*string{
   513  					"host":          client.Endpoint,
   514  					"x-acs-version": version,
   515  					"x-acs-action":  action,
   516  					"user-agent":    client.GetUserAgent(),
   517  				}, headers)
   518  			}
   519  
   520  			if !tea.BoolValue(util.IsUnset(request.Body)) {
   521  				m := util.AssertAsMap(request.Body)
   522  				tmp := util.AnyifyMapValue(openapiutil.Query(m))
   523  				request_.Body = tea.ToReader(util.ToFormString(tmp))
   524  				request_.Headers["content-type"] = tea.String("application/x-www-form-urlencoded")
   525  			}
   526  
   527  			if !tea.BoolValue(util.EqualString(authType, tea.String("Anonymous"))) {
   528  				accessKeyId, _err := client.GetAccessKeyId()
   529  				if _err != nil {
   530  					return _result, _err
   531  				}
   532  
   533  				accessKeySecret, _err := client.GetAccessKeySecret()
   534  				if _err != nil {
   535  					return _result, _err
   536  				}
   537  
   538  				securityToken, _err := client.GetSecurityToken()
   539  				if _err != nil {
   540  					return _result, _err
   541  				}
   542  
   543  				if !tea.BoolValue(util.Empty(securityToken)) {
   544  					request_.Query["SecurityToken"] = securityToken
   545  				}
   546  
   547  				request_.Query["SignatureMethod"] = tea.String("HMAC-SHA1")
   548  				request_.Query["SignatureVersion"] = tea.String("1.0")
   549  				request_.Query["AccessKeyId"] = accessKeyId
   550  				var t map[string]interface{}
   551  				if !tea.BoolValue(util.IsUnset(request.Body)) {
   552  					t = util.AssertAsMap(request.Body)
   553  				}
   554  
   555  				signedParam := tea.Merge(request_.Query,
   556  					openapiutil.Query(t))
   557  				request_.Query["Signature"] = openapiutil.GetRPCSignature(signedParam, request_.Method, accessKeySecret)
   558  			}
   559  
   560  			response_, _err := tea.DoRequest(request_, _runtime)
   561  			if _err != nil {
   562  				return _result, _err
   563  			}
   564  			if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {
   565  				_res, _err := util.ReadAsJSON(response_.Body)
   566  				if _err != nil {
   567  					return _result, _err
   568  				}
   569  
   570  				err := util.AssertAsMap(_res)
   571  				requestId := DefaultAny(err["RequestId"], err["requestId"])
   572  				_err = tea.NewSDKError(map[string]interface{}{
   573  					"code":    tea.ToString(DefaultAny(err["Code"], err["code"])),
   574  					"message": "code: " + tea.ToString(tea.IntValue(response_.StatusCode)) + ", " + tea.ToString(DefaultAny(err["Message"], err["message"])) + " request id: " + tea.ToString(requestId),
   575  					"data":    err,
   576  				})
   577  				return _result, _err
   578  			}
   579  
   580  			if tea.BoolValue(util.EqualString(bodyType, tea.String("binary"))) {
   581  				resp := map[string]interface{}{
   582  					"body":    response_.Body,
   583  					"headers": response_.Headers,
   584  				}
   585  				_result = resp
   586  				return _result, _err
   587  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("byte"))) {
   588  				byt, _err := util.ReadAsBytes(response_.Body)
   589  				if _err != nil {
   590  					return _result, _err
   591  				}
   592  
   593  				_result = make(map[string]interface{})
   594  				_err = tea.Convert(map[string]interface{}{
   595  					"body":    byt,
   596  					"headers": response_.Headers,
   597  				}, &_result)
   598  				return _result, _err
   599  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("string"))) {
   600  				str, _err := util.ReadAsString(response_.Body)
   601  				if _err != nil {
   602  					return _result, _err
   603  				}
   604  
   605  				_result = make(map[string]interface{})
   606  				_err = tea.Convert(map[string]interface{}{
   607  					"body":    tea.StringValue(str),
   608  					"headers": response_.Headers,
   609  				}, &_result)
   610  				return _result, _err
   611  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("json"))) {
   612  				obj, _err := util.ReadAsJSON(response_.Body)
   613  				if _err != nil {
   614  					return _result, _err
   615  				}
   616  
   617  				res := util.AssertAsMap(obj)
   618  				_result = make(map[string]interface{})
   619  				_err = tea.Convert(map[string]interface{}{
   620  					"body":    res,
   621  					"headers": response_.Headers,
   622  				}, &_result)
   623  				return _result, _err
   624  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("array"))) {
   625  				arr, _err := util.ReadAsJSON(response_.Body)
   626  				if _err != nil {
   627  					return _result, _err
   628  				}
   629  
   630  				_result = make(map[string]interface{})
   631  				_err = tea.Convert(map[string]interface{}{
   632  					"body":    arr,
   633  					"headers": response_.Headers,
   634  				}, &_result)
   635  				return _result, _err
   636  			} else {
   637  				_result = make(map[string]interface{})
   638  				_err = tea.Convert(map[string]map[string]*string{
   639  					"headers": response_.Headers,
   640  				}, &_result)
   641  				return _result, _err
   642  			}
   643  
   644  		}()
   645  		if !tea.BoolValue(tea.Retryable(_err)) {
   646  			break
   647  		}
   648  	}
   649  
   650  	return _resp, _err
   651  }
   652  
   653  /**
   654   * Encapsulate the request and invoke the network
   655   * @param action api name
   656   * @param version product version
   657   * @param protocol http or https
   658   * @param method e.g. GET
   659   * @param authType authorization type e.g. AK
   660   * @param pathname pathname of every api
   661   * @param bodyType response body type e.g. String
   662   * @param request object of OpenApiRequest
   663   * @param runtime which controls some details of call api, such as retry times
   664   * @return the response
   665   */
   666  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) {
   667  	_err = tea.Validate(request)
   668  	if _err != nil {
   669  		return _result, _err
   670  	}
   671  	_err = tea.Validate(runtime)
   672  	if _err != nil {
   673  		return _result, _err
   674  	}
   675  	_runtime := map[string]interface{}{
   676  		"timeouted":      "retry",
   677  		"readTimeout":    tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),
   678  		"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),
   679  		"httpProxy":      tea.StringValue(util.DefaultString(runtime.HttpProxy, client.HttpProxy)),
   680  		"httpsProxy":     tea.StringValue(util.DefaultString(runtime.HttpsProxy, client.HttpsProxy)),
   681  		"noProxy":        tea.StringValue(util.DefaultString(runtime.NoProxy, client.NoProxy)),
   682  		"socks5Proxy":    tea.StringValue(util.DefaultString(runtime.Socks5Proxy, client.Socks5Proxy)),
   683  		"socks5NetWork":  tea.StringValue(util.DefaultString(runtime.Socks5NetWork, client.Socks5NetWork)),
   684  		"maxIdleConns":   tea.IntValue(util.DefaultNumber(runtime.MaxIdleConns, client.MaxIdleConns)),
   685  		"retry": map[string]interface{}{
   686  			"retryable":   tea.BoolValue(runtime.Autoretry),
   687  			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),
   688  		},
   689  		"backoff": map[string]interface{}{
   690  			"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),
   691  			"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),
   692  		},
   693  		"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),
   694  	}
   695  
   696  	_resp := make(map[string]interface{})
   697  	for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {
   698  		if _retryTimes > 0 {
   699  			_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))
   700  			if tea.IntValue(_backoffTime) > 0 {
   701  				tea.Sleep(_backoffTime)
   702  			}
   703  		}
   704  
   705  		_resp, _err = func() (map[string]interface{}, error) {
   706  			request_ := tea.NewRequest()
   707  			request_.Protocol = util.DefaultString(client.Protocol, protocol)
   708  			request_.Method = method
   709  			request_.Pathname = pathname
   710  			request_.Headers = tea.Merge(map[string]*string{
   711  				"date":                    util.GetDateUTCString(),
   712  				"host":                    client.Endpoint,
   713  				"accept":                  tea.String("application/json"),
   714  				"x-acs-signature-nonce":   util.GetNonce(),
   715  				"x-acs-signature-method":  tea.String("HMAC-SHA1"),
   716  				"x-acs-signature-version": tea.String("1.0"),
   717  				"x-acs-version":           version,
   718  				"x-acs-action":            action,
   719  				"user-agent":              util.GetUserAgent(client.UserAgent),
   720  			}, request.Headers)
   721  			if !tea.BoolValue(util.IsUnset(request.Body)) {
   722  				request_.Body = tea.ToReader(util.ToJSONString(request.Body))
   723  				request_.Headers["content-type"] = tea.String("application/json; charset=utf-8")
   724  			}
   725  
   726  			if !tea.BoolValue(util.IsUnset(request.Query)) {
   727  				request_.Query = request.Query
   728  			}
   729  
   730  			if !tea.BoolValue(util.EqualString(authType, tea.String("Anonymous"))) {
   731  				accessKeyId, _err := client.GetAccessKeyId()
   732  				if _err != nil {
   733  					return _result, _err
   734  				}
   735  
   736  				accessKeySecret, _err := client.GetAccessKeySecret()
   737  				if _err != nil {
   738  					return _result, _err
   739  				}
   740  
   741  				securityToken, _err := client.GetSecurityToken()
   742  				if _err != nil {
   743  					return _result, _err
   744  				}
   745  
   746  				if !tea.BoolValue(util.Empty(securityToken)) {
   747  					request_.Headers["x-acs-accesskey-id"] = accessKeyId
   748  					request_.Headers["x-acs-security-token"] = securityToken
   749  				}
   750  
   751  				stringToSign := openapiutil.GetStringToSign(request_)
   752  				request_.Headers["authorization"] = tea.String("acs " + tea.StringValue(accessKeyId) + ":" + tea.StringValue(openapiutil.GetROASignature(stringToSign, accessKeySecret)))
   753  			}
   754  
   755  			response_, _err := tea.DoRequest(request_, _runtime)
   756  			if _err != nil {
   757  				return _result, _err
   758  			}
   759  			if tea.BoolValue(util.EqualNumber(response_.StatusCode, tea.Int(204))) {
   760  				_result = make(map[string]interface{})
   761  				_err = tea.Convert(map[string]map[string]*string{
   762  					"headers": response_.Headers,
   763  				}, &_result)
   764  				return _result, _err
   765  			}
   766  
   767  			if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {
   768  				_res, _err := util.ReadAsJSON(response_.Body)
   769  				if _err != nil {
   770  					return _result, _err
   771  				}
   772  
   773  				err := util.AssertAsMap(_res)
   774  				requestId := DefaultAny(err["RequestId"], err["requestId"])
   775  				requestId = DefaultAny(requestId, err["requestid"])
   776  				_err = tea.NewSDKError(map[string]interface{}{
   777  					"code":    tea.ToString(DefaultAny(err["Code"], err["code"])),
   778  					"message": "code: " + tea.ToString(tea.IntValue(response_.StatusCode)) + ", " + tea.ToString(DefaultAny(err["Message"], err["message"])) + " request id: " + tea.ToString(requestId),
   779  					"data":    err,
   780  				})
   781  				return _result, _err
   782  			}
   783  
   784  			if tea.BoolValue(util.EqualString(bodyType, tea.String("binary"))) {
   785  				resp := map[string]interface{}{
   786  					"body":    response_.Body,
   787  					"headers": response_.Headers,
   788  				}
   789  				_result = resp
   790  				return _result, _err
   791  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("byte"))) {
   792  				byt, _err := util.ReadAsBytes(response_.Body)
   793  				if _err != nil {
   794  					return _result, _err
   795  				}
   796  
   797  				_result = make(map[string]interface{})
   798  				_err = tea.Convert(map[string]interface{}{
   799  					"body":    byt,
   800  					"headers": response_.Headers,
   801  				}, &_result)
   802  				return _result, _err
   803  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("string"))) {
   804  				str, _err := util.ReadAsString(response_.Body)
   805  				if _err != nil {
   806  					return _result, _err
   807  				}
   808  
   809  				_result = make(map[string]interface{})
   810  				_err = tea.Convert(map[string]interface{}{
   811  					"body":    tea.StringValue(str),
   812  					"headers": response_.Headers,
   813  				}, &_result)
   814  				return _result, _err
   815  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("json"))) {
   816  				obj, _err := util.ReadAsJSON(response_.Body)
   817  				if _err != nil {
   818  					return _result, _err
   819  				}
   820  
   821  				res := util.AssertAsMap(obj)
   822  				_result = make(map[string]interface{})
   823  				_err = tea.Convert(map[string]interface{}{
   824  					"body":    res,
   825  					"headers": response_.Headers,
   826  				}, &_result)
   827  				return _result, _err
   828  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("array"))) {
   829  				arr, _err := util.ReadAsJSON(response_.Body)
   830  				if _err != nil {
   831  					return _result, _err
   832  				}
   833  
   834  				_result = make(map[string]interface{})
   835  				_err = tea.Convert(map[string]interface{}{
   836  					"body":    arr,
   837  					"headers": response_.Headers,
   838  				}, &_result)
   839  				return _result, _err
   840  			} else {
   841  				_result = make(map[string]interface{})
   842  				_err = tea.Convert(map[string]map[string]*string{
   843  					"headers": response_.Headers,
   844  				}, &_result)
   845  				return _result, _err
   846  			}
   847  
   848  		}()
   849  		if !tea.BoolValue(tea.Retryable(_err)) {
   850  			break
   851  		}
   852  	}
   853  
   854  	return _resp, _err
   855  }
   856  
   857  /**
   858   * Encapsulate the request and invoke the network with form body
   859   * @param action api name
   860   * @param version product version
   861   * @param protocol http or https
   862   * @param method e.g. GET
   863   * @param authType authorization type e.g. AK
   864   * @param pathname pathname of every api
   865   * @param bodyType response body type e.g. String
   866   * @param request object of OpenApiRequest
   867   * @param runtime which controls some details of call api, such as retry times
   868   * @return the response
   869   */
   870  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) {
   871  	_err = tea.Validate(request)
   872  	if _err != nil {
   873  		return _result, _err
   874  	}
   875  	_err = tea.Validate(runtime)
   876  	if _err != nil {
   877  		return _result, _err
   878  	}
   879  	_runtime := map[string]interface{}{
   880  		"timeouted":      "retry",
   881  		"readTimeout":    tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),
   882  		"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),
   883  		"httpProxy":      tea.StringValue(util.DefaultString(runtime.HttpProxy, client.HttpProxy)),
   884  		"httpsProxy":     tea.StringValue(util.DefaultString(runtime.HttpsProxy, client.HttpsProxy)),
   885  		"noProxy":        tea.StringValue(util.DefaultString(runtime.NoProxy, client.NoProxy)),
   886  		"socks5Proxy":    tea.StringValue(util.DefaultString(runtime.Socks5Proxy, client.Socks5Proxy)),
   887  		"socks5NetWork":  tea.StringValue(util.DefaultString(runtime.Socks5NetWork, client.Socks5NetWork)),
   888  		"maxIdleConns":   tea.IntValue(util.DefaultNumber(runtime.MaxIdleConns, client.MaxIdleConns)),
   889  		"retry": map[string]interface{}{
   890  			"retryable":   tea.BoolValue(runtime.Autoretry),
   891  			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),
   892  		},
   893  		"backoff": map[string]interface{}{
   894  			"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),
   895  			"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),
   896  		},
   897  		"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),
   898  	}
   899  
   900  	_resp := make(map[string]interface{})
   901  	for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {
   902  		if _retryTimes > 0 {
   903  			_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))
   904  			if tea.IntValue(_backoffTime) > 0 {
   905  				tea.Sleep(_backoffTime)
   906  			}
   907  		}
   908  
   909  		_resp, _err = func() (map[string]interface{}, error) {
   910  			request_ := tea.NewRequest()
   911  			request_.Protocol = util.DefaultString(client.Protocol, protocol)
   912  			request_.Method = method
   913  			request_.Pathname = pathname
   914  			request_.Headers = tea.Merge(map[string]*string{
   915  				"date":                    util.GetDateUTCString(),
   916  				"host":                    client.Endpoint,
   917  				"accept":                  tea.String("application/json"),
   918  				"x-acs-signature-nonce":   util.GetNonce(),
   919  				"x-acs-signature-method":  tea.String("HMAC-SHA1"),
   920  				"x-acs-signature-version": tea.String("1.0"),
   921  				"x-acs-version":           version,
   922  				"x-acs-action":            action,
   923  				"user-agent":              util.GetUserAgent(client.UserAgent),
   924  			}, request.Headers)
   925  			if !tea.BoolValue(util.IsUnset(request.Body)) {
   926  				m := util.AssertAsMap(request.Body)
   927  				request_.Body = tea.ToReader(openapiutil.ToForm(m))
   928  				request_.Headers["content-type"] = tea.String("application/x-www-form-urlencoded")
   929  			}
   930  
   931  			if !tea.BoolValue(util.IsUnset(request.Query)) {
   932  				request_.Query = request.Query
   933  			}
   934  
   935  			if !tea.BoolValue(util.EqualString(authType, tea.String("Anonymous"))) {
   936  				accessKeyId, _err := client.GetAccessKeyId()
   937  				if _err != nil {
   938  					return _result, _err
   939  				}
   940  
   941  				accessKeySecret, _err := client.GetAccessKeySecret()
   942  				if _err != nil {
   943  					return _result, _err
   944  				}
   945  
   946  				securityToken, _err := client.GetSecurityToken()
   947  				if _err != nil {
   948  					return _result, _err
   949  				}
   950  
   951  				if !tea.BoolValue(util.Empty(securityToken)) {
   952  					request_.Headers["x-acs-accesskey-id"] = accessKeyId
   953  					request_.Headers["x-acs-security-token"] = securityToken
   954  				}
   955  
   956  				stringToSign := openapiutil.GetStringToSign(request_)
   957  				request_.Headers["authorization"] = tea.String("acs " + tea.StringValue(accessKeyId) + ":" + tea.StringValue(openapiutil.GetROASignature(stringToSign, accessKeySecret)))
   958  			}
   959  
   960  			response_, _err := tea.DoRequest(request_, _runtime)
   961  			if _err != nil {
   962  				return _result, _err
   963  			}
   964  			if tea.BoolValue(util.EqualNumber(response_.StatusCode, tea.Int(204))) {
   965  				_result = make(map[string]interface{})
   966  				_err = tea.Convert(map[string]map[string]*string{
   967  					"headers": response_.Headers,
   968  				}, &_result)
   969  				return _result, _err
   970  			}
   971  
   972  			if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {
   973  				_res, _err := util.ReadAsJSON(response_.Body)
   974  				if _err != nil {
   975  					return _result, _err
   976  				}
   977  
   978  				err := util.AssertAsMap(_res)
   979  				_err = tea.NewSDKError(map[string]interface{}{
   980  					"code":    tea.ToString(DefaultAny(err["Code"], err["code"])),
   981  					"message": "code: " + tea.ToString(tea.IntValue(response_.StatusCode)) + ", " + tea.ToString(DefaultAny(err["Message"], err["message"])) + " request id: " + tea.ToString(DefaultAny(err["RequestId"], err["requestId"])),
   982  					"data":    err,
   983  				})
   984  				return _result, _err
   985  			}
   986  
   987  			if tea.BoolValue(util.EqualString(bodyType, tea.String("binary"))) {
   988  				resp := map[string]interface{}{
   989  					"body":    response_.Body,
   990  					"headers": response_.Headers,
   991  				}
   992  				_result = resp
   993  				return _result, _err
   994  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("byte"))) {
   995  				byt, _err := util.ReadAsBytes(response_.Body)
   996  				if _err != nil {
   997  					return _result, _err
   998  				}
   999  
  1000  				_result = make(map[string]interface{})
  1001  				_err = tea.Convert(map[string]interface{}{
  1002  					"body":    byt,
  1003  					"headers": response_.Headers,
  1004  				}, &_result)
  1005  				return _result, _err
  1006  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("string"))) {
  1007  				str, _err := util.ReadAsString(response_.Body)
  1008  				if _err != nil {
  1009  					return _result, _err
  1010  				}
  1011  
  1012  				_result = make(map[string]interface{})
  1013  				_err = tea.Convert(map[string]interface{}{
  1014  					"body":    tea.StringValue(str),
  1015  					"headers": response_.Headers,
  1016  				}, &_result)
  1017  				return _result, _err
  1018  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("json"))) {
  1019  				obj, _err := util.ReadAsJSON(response_.Body)
  1020  				if _err != nil {
  1021  					return _result, _err
  1022  				}
  1023  
  1024  				res := util.AssertAsMap(obj)
  1025  				_result = make(map[string]interface{})
  1026  				_err = tea.Convert(map[string]interface{}{
  1027  					"body":    res,
  1028  					"headers": response_.Headers,
  1029  				}, &_result)
  1030  				return _result, _err
  1031  			} else if tea.BoolValue(util.EqualString(bodyType, tea.String("array"))) {
  1032  				arr, _err := util.ReadAsJSON(response_.Body)
  1033  				if _err != nil {
  1034  					return _result, _err
  1035  				}
  1036  
  1037  				_result = make(map[string]interface{})
  1038  				_err = tea.Convert(map[string]interface{}{
  1039  					"body":    arr,
  1040  					"headers": response_.Headers,
  1041  				}, &_result)
  1042  				return _result, _err
  1043  			} else {
  1044  				_result = make(map[string]interface{})
  1045  				_err = tea.Convert(map[string]map[string]*string{
  1046  					"headers": response_.Headers,
  1047  				}, &_result)
  1048  				return _result, _err
  1049  			}
  1050  
  1051  		}()
  1052  		if !tea.BoolValue(tea.Retryable(_err)) {
  1053  			break
  1054  		}
  1055  	}
  1056  
  1057  	return _resp, _err
  1058  }
  1059  
  1060  /**
  1061   * Encapsulate the request and invoke the network
  1062   * @param action api name
  1063   * @param version product version
  1064   * @param protocol http or https
  1065   * @param method e.g. GET
  1066   * @param authType authorization type e.g. AK
  1067   * @param bodyType response body type e.g. String
  1068   * @param request object of OpenApiRequest
  1069   * @param runtime which controls some details of call api, such as retry times
  1070   * @return the response
  1071   */
  1072  func (client *Client) DoRequest(params *Params, request *OpenApiRequest, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {
  1073  	_err = tea.Validate(params)
  1074  	if _err != nil {
  1075  		return _result, _err
  1076  	}
  1077  	_err = tea.Validate(request)
  1078  	if _err != nil {
  1079  		return _result, _err
  1080  	}
  1081  	_err = tea.Validate(runtime)
  1082  	if _err != nil {
  1083  		return _result, _err
  1084  	}
  1085  	_runtime := map[string]interface{}{
  1086  		"timeouted":      "retry",
  1087  		"readTimeout":    tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),
  1088  		"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),
  1089  		"httpProxy":      tea.StringValue(util.DefaultString(runtime.HttpProxy, client.HttpProxy)),
  1090  		"httpsProxy":     tea.StringValue(util.DefaultString(runtime.HttpsProxy, client.HttpsProxy)),
  1091  		"noProxy":        tea.StringValue(util.DefaultString(runtime.NoProxy, client.NoProxy)),
  1092  		"socks5Proxy":    tea.StringValue(util.DefaultString(runtime.Socks5Proxy, client.Socks5Proxy)),
  1093  		"socks5NetWork":  tea.StringValue(util.DefaultString(runtime.Socks5NetWork, client.Socks5NetWork)),
  1094  		"maxIdleConns":   tea.IntValue(util.DefaultNumber(runtime.MaxIdleConns, client.MaxIdleConns)),
  1095  		"retry": map[string]interface{}{
  1096  			"retryable":   tea.BoolValue(runtime.Autoretry),
  1097  			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),
  1098  		},
  1099  		"backoff": map[string]interface{}{
  1100  			"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),
  1101  			"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),
  1102  		},
  1103  		"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),
  1104  	}
  1105  
  1106  	_resp := make(map[string]interface{})
  1107  	for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {
  1108  		if _retryTimes > 0 {
  1109  			_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))
  1110  			if tea.IntValue(_backoffTime) > 0 {
  1111  				tea.Sleep(_backoffTime)
  1112  			}
  1113  		}
  1114  
  1115  		_resp, _err = func() (map[string]interface{}, error) {
  1116  			request_ := tea.NewRequest()
  1117  			request_.Protocol = util.DefaultString(client.Protocol, params.Protocol)
  1118  			request_.Method = params.Method
  1119  			request_.Pathname = params.Pathname
  1120  			globalQueries := make(map[string]*string)
  1121  			globalHeaders := make(map[string]*string)
  1122  			if !tea.BoolValue(util.IsUnset(tea.ToMap(client.GlobalParameters))) {
  1123  				globalParams := client.GlobalParameters
  1124  				if !tea.BoolValue(util.IsUnset(globalParams.Queries)) {
  1125  					globalQueries = globalParams.Queries
  1126  				}
  1127  
  1128  				if !tea.BoolValue(util.IsUnset(globalParams.Headers)) {
  1129  					globalHeaders = globalParams.Headers
  1130  				}
  1131  
  1132  			}
  1133  
  1134  			request_.Query = tea.Merge(globalQueries,
  1135  				request.Query)
  1136  			// endpoint is setted in product client
  1137  			request_.Headers = tea.Merge(map[string]*string{
  1138  				"host":                  client.Endpoint,
  1139  				"x-acs-version":         params.Version,
  1140  				"x-acs-action":          params.Action,
  1141  				"user-agent":            client.GetUserAgent(),
  1142  				"x-acs-date":            openapiutil.GetTimestamp(),
  1143  				"x-acs-signature-nonce": util.GetNonce(),
  1144  				"accept":                tea.String("application/json"),
  1145  			}, globalHeaders,
  1146  				request.Headers)
  1147  			if tea.BoolValue(util.EqualString(params.Style, tea.String("RPC"))) {
  1148  				headers, _err := client.GetRpcHeaders()
  1149  				if _err != nil {
  1150  					return _result, _err
  1151  				}
  1152  
  1153  				if !tea.BoolValue(util.IsUnset(headers)) {
  1154  					request_.Headers = tea.Merge(request_.Headers,
  1155  						headers)
  1156  				}
  1157  
  1158  			}
  1159  
  1160  			signatureAlgorithm := util.DefaultString(client.SignatureAlgorithm, tea.String("ACS3-HMAC-SHA256"))
  1161  			hashedRequestPayload := openapiutil.HexEncode(openapiutil.Hash(util.ToBytes(tea.String("")), signatureAlgorithm))
  1162  			if !tea.BoolValue(util.IsUnset(request.Stream)) {
  1163  				tmp, _err := util.ReadAsBytes(request.Stream)
  1164  				if _err != nil {
  1165  					return _result, _err
  1166  				}
  1167  
  1168  				hashedRequestPayload = openapiutil.HexEncode(openapiutil.Hash(tmp, signatureAlgorithm))
  1169  				request_.Body = tea.ToReader(tmp)
  1170  				request_.Headers["content-type"] = tea.String("application/octet-stream")
  1171  			} else {
  1172  				if !tea.BoolValue(util.IsUnset(request.Body)) {
  1173  					if tea.BoolValue(util.EqualString(params.ReqBodyType, tea.String("json"))) {
  1174  						jsonObj := util.ToJSONString(request.Body)
  1175  						hashedRequestPayload = openapiutil.HexEncode(openapiutil.Hash(util.ToBytes(jsonObj), signatureAlgorithm))
  1176  						request_.Body = tea.ToReader(jsonObj)
  1177  						request_.Headers["content-type"] = tea.String("application/json; charset=utf-8")
  1178  					} else {
  1179  						m := util.AssertAsMap(request.Body)
  1180  						formObj := openapiutil.ToForm(m)
  1181  						hashedRequestPayload = openapiutil.HexEncode(openapiutil.Hash(util.ToBytes(formObj), signatureAlgorithm))
  1182  						request_.Body = tea.ToReader(formObj)
  1183  						request_.Headers["content-type"] = tea.String("application/x-www-form-urlencoded")
  1184  					}
  1185  
  1186  				}
  1187  
  1188  			}
  1189  
  1190  			request_.Headers["x-acs-content-sha256"] = hashedRequestPayload
  1191  			if !tea.BoolValue(util.EqualString(params.AuthType, tea.String("Anonymous"))) {
  1192  				authType, _err := client.GetType()
  1193  				if _err != nil {
  1194  					return _result, _err
  1195  				}
  1196  
  1197  				if tea.BoolValue(util.EqualString(authType, tea.String("bearer"))) {
  1198  					bearerToken, _err := client.GetBearerToken()
  1199  					if _err != nil {
  1200  						return _result, _err
  1201  					}
  1202  
  1203  					request_.Headers["x-acs-bearer-token"] = bearerToken
  1204  				} else {
  1205  					accessKeyId, _err := client.GetAccessKeyId()
  1206  					if _err != nil {
  1207  						return _result, _err
  1208  					}
  1209  
  1210  					accessKeySecret, _err := client.GetAccessKeySecret()
  1211  					if _err != nil {
  1212  						return _result, _err
  1213  					}
  1214  
  1215  					securityToken, _err := client.GetSecurityToken()
  1216  					if _err != nil {
  1217  						return _result, _err
  1218  					}
  1219  
  1220  					if !tea.BoolValue(util.Empty(securityToken)) {
  1221  						request_.Headers["x-acs-accesskey-id"] = accessKeyId
  1222  						request_.Headers["x-acs-security-token"] = securityToken
  1223  					}
  1224  
  1225  					request_.Headers["Authorization"] = openapiutil.GetAuthorization(request_, signatureAlgorithm, hashedRequestPayload, accessKeyId, accessKeySecret)
  1226  				}
  1227  
  1228  			}
  1229  
  1230  			response_, _err := tea.DoRequest(request_, _runtime)
  1231  			if _err != nil {
  1232  				return _result, _err
  1233  			}
  1234  			if tea.BoolValue(util.Is4xx(response_.StatusCode)) || tea.BoolValue(util.Is5xx(response_.StatusCode)) {
  1235  				err := map[string]interface{}{}
  1236  				if !tea.BoolValue(util.IsUnset(response_.Headers["content-type"])) && tea.BoolValue(util.EqualString(response_.Headers["content-type"], tea.String("text/xml;charset=utf-8"))) {
  1237  					_str, _err := util.ReadAsString(response_.Body)
  1238  					if _err != nil {
  1239  						return _result, _err
  1240  					}
  1241  
  1242  					respMap := xml.ParseXml(_str, nil)
  1243  					err = util.AssertAsMap(respMap["Error"])
  1244  				} else {
  1245  					_res, _err := util.ReadAsJSON(response_.Body)
  1246  					if _err != nil {
  1247  						return _result, _err
  1248  					}
  1249  
  1250  					err = util.AssertAsMap(_res)
  1251  				}
  1252  
  1253  				err["statusCode"] = response_.StatusCode
  1254  				_err = tea.NewSDKError(map[string]interface{}{
  1255  					"code":    tea.ToString(DefaultAny(err["Code"], err["code"])),
  1256  					"message": "code: " + tea.ToString(tea.IntValue(response_.StatusCode)) + ", " + tea.ToString(DefaultAny(err["Message"], err["message"])) + " request id: " + tea.ToString(DefaultAny(err["RequestId"], err["requestId"])),
  1257  					"data":    err,
  1258  				})
  1259  				return _result, _err
  1260  			}
  1261  
  1262  			if tea.BoolValue(util.EqualString(params.BodyType, tea.String("binary"))) {
  1263  				resp := map[string]interface{}{
  1264  					"body":       response_.Body,
  1265  					"headers":    response_.Headers,
  1266  					"statusCode": tea.IntValue(response_.StatusCode),
  1267  				}
  1268  				_result = resp
  1269  				return _result, _err
  1270  			} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("byte"))) {
  1271  				byt, _err := util.ReadAsBytes(response_.Body)
  1272  				if _err != nil {
  1273  					return _result, _err
  1274  				}
  1275  
  1276  				_result = make(map[string]interface{})
  1277  				_err = tea.Convert(map[string]interface{}{
  1278  					"body":       byt,
  1279  					"headers":    response_.Headers,
  1280  					"statusCode": tea.IntValue(response_.StatusCode),
  1281  				}, &_result)
  1282  				return _result, _err
  1283  			} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("string"))) {
  1284  				str, _err := util.ReadAsString(response_.Body)
  1285  				if _err != nil {
  1286  					return _result, _err
  1287  				}
  1288  
  1289  				_result = make(map[string]interface{})
  1290  				_err = tea.Convert(map[string]interface{}{
  1291  					"body":       tea.StringValue(str),
  1292  					"headers":    response_.Headers,
  1293  					"statusCode": tea.IntValue(response_.StatusCode),
  1294  				}, &_result)
  1295  				return _result, _err
  1296  			} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("json"))) {
  1297  				obj, _err := util.ReadAsJSON(response_.Body)
  1298  				if _err != nil {
  1299  					return _result, _err
  1300  				}
  1301  
  1302  				res := util.AssertAsMap(obj)
  1303  				_result = make(map[string]interface{})
  1304  				_err = tea.Convert(map[string]interface{}{
  1305  					"body":       res,
  1306  					"headers":    response_.Headers,
  1307  					"statusCode": tea.IntValue(response_.StatusCode),
  1308  				}, &_result)
  1309  				return _result, _err
  1310  			} else if tea.BoolValue(util.EqualString(params.BodyType, tea.String("array"))) {
  1311  				arr, _err := util.ReadAsJSON(response_.Body)
  1312  				if _err != nil {
  1313  					return _result, _err
  1314  				}
  1315  
  1316  				_result = make(map[string]interface{})
  1317  				_err = tea.Convert(map[string]interface{}{
  1318  					"body":       arr,
  1319  					"headers":    response_.Headers,
  1320  					"statusCode": tea.IntValue(response_.StatusCode),
  1321  				}, &_result)
  1322  				return _result, _err
  1323  			} else {
  1324  				_result = make(map[string]interface{})
  1325  				_err = tea.Convert(map[string]interface{}{
  1326  					"headers":    response_.Headers,
  1327  					"statusCode": tea.IntValue(response_.StatusCode),
  1328  				}, &_result)
  1329  				return _result, _err
  1330  			}
  1331  
  1332  		}()
  1333  		if !tea.BoolValue(tea.Retryable(_err)) {
  1334  			break
  1335  		}
  1336  	}
  1337  
  1338  	return _resp, _err
  1339  }
  1340  
  1341  /**
  1342   * Encapsulate the request and invoke the network
  1343   * @param action api name
  1344   * @param version product version
  1345   * @param protocol http or https
  1346   * @param method e.g. GET
  1347   * @param authType authorization type e.g. AK
  1348   * @param bodyType response body type e.g. String
  1349   * @param request object of OpenApiRequest
  1350   * @param runtime which controls some details of call api, such as retry times
  1351   * @return the response
  1352   */
  1353  func (client *Client) Execute(params *Params, request *OpenApiRequest, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {
  1354  	_err = tea.Validate(params)
  1355  	if _err != nil {
  1356  		return _result, _err
  1357  	}
  1358  	_err = tea.Validate(request)
  1359  	if _err != nil {
  1360  		return _result, _err
  1361  	}
  1362  	_err = tea.Validate(runtime)
  1363  	if _err != nil {
  1364  		return _result, _err
  1365  	}
  1366  	_runtime := map[string]interface{}{
  1367  		"timeouted":      "retry",
  1368  		"readTimeout":    tea.IntValue(util.DefaultNumber(runtime.ReadTimeout, client.ReadTimeout)),
  1369  		"connectTimeout": tea.IntValue(util.DefaultNumber(runtime.ConnectTimeout, client.ConnectTimeout)),
  1370  		"httpProxy":      tea.StringValue(util.DefaultString(runtime.HttpProxy, client.HttpProxy)),
  1371  		"httpsProxy":     tea.StringValue(util.DefaultString(runtime.HttpsProxy, client.HttpsProxy)),
  1372  		"noProxy":        tea.StringValue(util.DefaultString(runtime.NoProxy, client.NoProxy)),
  1373  		"socks5Proxy":    tea.StringValue(util.DefaultString(runtime.Socks5Proxy, client.Socks5Proxy)),
  1374  		"socks5NetWork":  tea.StringValue(util.DefaultString(runtime.Socks5NetWork, client.Socks5NetWork)),
  1375  		"maxIdleConns":   tea.IntValue(util.DefaultNumber(runtime.MaxIdleConns, client.MaxIdleConns)),
  1376  		"retry": map[string]interface{}{
  1377  			"retryable":   tea.BoolValue(runtime.Autoretry),
  1378  			"maxAttempts": tea.IntValue(util.DefaultNumber(runtime.MaxAttempts, tea.Int(3))),
  1379  		},
  1380  		"backoff": map[string]interface{}{
  1381  			"policy": tea.StringValue(util.DefaultString(runtime.BackoffPolicy, tea.String("no"))),
  1382  			"period": tea.IntValue(util.DefaultNumber(runtime.BackoffPeriod, tea.Int(1))),
  1383  		},
  1384  		"ignoreSSL": tea.BoolValue(runtime.IgnoreSSL),
  1385  	}
  1386  
  1387  	_resp := make(map[string]interface{})
  1388  	for _retryTimes := 0; tea.BoolValue(tea.AllowRetry(_runtime["retry"], tea.Int(_retryTimes))); _retryTimes++ {
  1389  		if _retryTimes > 0 {
  1390  			_backoffTime := tea.GetBackoffTime(_runtime["backoff"], tea.Int(_retryTimes))
  1391  			if tea.IntValue(_backoffTime) > 0 {
  1392  				tea.Sleep(_backoffTime)
  1393  			}
  1394  		}
  1395  
  1396  		_resp, _err = func() (map[string]interface{}, error) {
  1397  			request_ := tea.NewRequest()
  1398  			// spi = new Gateway();//Gateway implements SPI，这一步在产品 SDK 中实例化
  1399  			headers, _err := client.GetRpcHeaders()
  1400  			if _err != nil {
  1401  				return _result, _err
  1402  			}
  1403  
  1404  			globalQueries := make(map[string]*string)
  1405  			globalHeaders := make(map[string]*string)
  1406  			if !tea.BoolValue(util.IsUnset(tea.ToMap(client.GlobalParameters))) {
  1407  				globalParams := client.GlobalParameters
  1408  				if !tea.BoolValue(util.IsUnset(globalParams.Queries)) {
  1409  					globalQueries = globalParams.Queries
  1410  				}
  1411  
  1412  				if !tea.BoolValue(util.IsUnset(globalParams.Headers)) {
  1413  					globalHeaders = globalParams.Headers
  1414  				}
  1415  
  1416  			}
  1417  
  1418  			requestContext := &spi.InterceptorContextRequest{
  1419  				Headers: tea.Merge(globalHeaders,
  1420  					request.Headers,
  1421  					headers),
  1422  				Query: tea.Merge(globalQueries,
  1423  					request.Query),
  1424  				Body:               request.Body,
  1425  				Stream:             request.Stream,
  1426  				HostMap:            request.HostMap,
  1427  				Pathname:           params.Pathname,
  1428  				ProductId:          client.ProductId,
  1429  				Action:             params.Action,
  1430  				Version:            params.Version,
  1431  				Protocol:           util.DefaultString(client.Protocol, params.Protocol),
  1432  				Method:             util.DefaultString(client.Method, params.Method),
  1433  				AuthType:           params.AuthType,
  1434  				BodyType:           params.BodyType,
  1435  				ReqBodyType:        params.ReqBodyType,
  1436  				Style:              params.Style,
  1437  				Credential:         client.Credential,
  1438  				SignatureVersion:   client.SignatureVersion,
  1439  				SignatureAlgorithm: client.SignatureAlgorithm,
  1440  				UserAgent:          client.GetUserAgent(),
  1441  			}
  1442  			configurationContext := &spi.InterceptorContextConfiguration{
  1443  				RegionId:     client.RegionId,
  1444  				Endpoint:     util.DefaultString(request.EndpointOverride, client.Endpoint),
  1445  				EndpointRule: client.EndpointRule,
  1446  				EndpointMap:  client.EndpointMap,
  1447  				EndpointType: client.EndpointType,
  1448  				Network:      client.Network,
  1449  				Suffix:       client.Suffix,
  1450  			}
  1451  			interceptorContext := &spi.InterceptorContext{
  1452  				Request:       requestContext,
  1453  				Configuration: configurationContext,
  1454  			}
  1455  			attributeMap := &spi.AttributeMap{}
  1456  			// 1. spi.modifyConfiguration(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
  1457  			_err = client.Spi.ModifyConfiguration(interceptorContext, attributeMap)
  1458  			if _err != nil {
  1459  				return _result, _err
  1460  			}
  1461  			// 2. spi.modifyRequest(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
  1462  			_err = client.Spi.ModifyRequest(interceptorContext, attributeMap)
  1463  			if _err != nil {
  1464  				return _result, _err
  1465  			}
  1466  			request_.Protocol = interceptorContext.Request.Protocol
  1467  			request_.Method = interceptorContext.Request.Method
  1468  			request_.Pathname = interceptorContext.Request.Pathname
  1469  			request_.Query = interceptorContext.Request.Query
  1470  			request_.Body = interceptorContext.Request.Stream
  1471  			request_.Headers = interceptorContext.Request.Headers
  1472  			response_, _err := tea.DoRequest(request_, _runtime)
  1473  			if _err != nil {
  1474  				return _result, _err
  1475  			}
  1476  			responseContext := &spi.InterceptorContextResponse{
  1477  				StatusCode: response_.StatusCode,
  1478  				Headers:    response_.Headers,
  1479  				Body:       response_.Body,
  1480  			}
  1481  			interceptorContext.Response = responseContext
  1482  			// 3. spi.modifyResponse(context: SPI.InterceptorContext, attributeMap: SPI.AttributeMap);
  1483  			_err = client.Spi.ModifyResponse(interceptorContext, attributeMap)
  1484  			if _err != nil {
  1485  				return _result, _err
  1486  			}
  1487  			_result = make(map[string]interface{})
  1488  			_err = tea.Convert(map[string]interface{}{
  1489  				"headers":    interceptorContext.Response.Headers,
  1490  				"statusCode": tea.IntValue(interceptorContext.Response.StatusCode),
  1491  				"body":       interceptorContext.Response.DeserializedBody,
  1492  			}, &_result)
  1493  			return _result, _err
  1494  		}()
  1495  		if !tea.BoolValue(tea.Retryable(_err)) {
  1496  			break
  1497  		}
  1498  	}
  1499  
  1500  	return _resp, _err
  1501  }
  1502  
  1503  func (client *Client) CallApi(params *Params, request *OpenApiRequest, runtime *util.RuntimeOptions) (_result map[string]interface{}, _err error) {
  1504  	if tea.BoolValue(util.IsUnset(tea.ToMap(params))) {
  1505  		_err = tea.NewSDKError(map[string]interface{}{
  1506  			"code":    "ParameterMissing",
  1507  			"message": "'params' can not be unset",
  1508  		})
  1509  		return _result, _err
  1510  	}
  1511  
  1512  	if tea.BoolValue(util.IsUnset(client.SignatureAlgorithm)) || !tea.BoolValue(util.EqualString(client.SignatureAlgorithm, tea.String("v2"))) {
  1513  		_result = make(map[string]interface{})
  1514  		_body, _err := client.DoRequest(params, request, runtime)
  1515  		if _err != nil {
  1516  			return _result, _err
  1517  		}
  1518  		_result = _body
  1519  		return _result, _err
  1520  	} else if tea.BoolValue(util.EqualString(params.Style, tea.String("ROA"))) && tea.BoolValue(util.EqualString(params.ReqBodyType, tea.String("json"))) {
  1521  		_result = make(map[string]interface{})
  1522  		_body, _err := client.DoROARequest(params.Action, params.Version, params.Protocol, params.Method, params.AuthType, params.Pathname, params.BodyType, request, runtime)
  1523  		if _err != nil {
  1524  			return _result, _err
  1525  		}
  1526  		_result = _body
  1527  		return _result, _err
  1528  	} else if tea.BoolValue(util.EqualString(params.Style, tea.String("ROA"))) {
  1529  		_result = make(map[string]interface{})
  1530  		_body, _err := client.DoROARequestWithForm(params.Action, params.Version, params.Protocol, params.Method, params.AuthType, params.Pathname, params.BodyType, request, runtime)
  1531  		if _err != nil {
  1532  			return _result, _err
  1533  		}
  1534  		_result = _body
  1535  		return _result, _err
  1536  	} else {
  1537  		_result = make(map[string]interface{})
  1538  		_body, _err := client.DoRPCRequest(params.Action, params.Version, params.Protocol, params.Method, params.AuthType, params.BodyType, request, runtime)
  1539  		if _err != nil {
  1540  			return _result, _err
  1541  		}
  1542  		_result = _body
  1543  		return _result, _err
  1544  	}
  1545  
  1546  }
  1547  
  1548  /**
  1549   * Get user agent
  1550   * @return user agent
  1551   */
  1552  func (client *Client) GetUserAgent() (_result *string) {
  1553  	userAgent := util.GetUserAgent(client.UserAgent)
  1554  	_result = userAgent
  1555  	return _result
  1556  }
  1557  
  1558  /**
  1559   * Get accesskey id by using credential
  1560   * @return accesskey id
  1561   */
  1562  func (client *Client) GetAccessKeyId() (_result *string, _err error) {
  1563  	if tea.BoolValue(util.IsUnset(client.Credential)) {
  1564  		_result = tea.String("")
  1565  		return _result, _err
  1566  	}
  1567  
  1568  	accessKeyId, _err := client.Credential.GetAccessKeyId()
  1569  	if _err != nil {
  1570  		return _result, _err
  1571  	}
  1572  
  1573  	_result = accessKeyId
  1574  	return _result, _err
  1575  }
  1576  
  1577  /**
  1578   * Get accesskey secret by using credential
  1579   * @return accesskey secret
  1580   */
  1581  func (client *Client) GetAccessKeySecret() (_result *string, _err error) {
  1582  	if tea.BoolValue(util.IsUnset(client.Credential)) {
  1583  		_result = tea.String("")
  1584  		return _result, _err
  1585  	}
  1586  
  1587  	secret, _err := client.Credential.GetAccessKeySecret()
  1588  	if _err != nil {
  1589  		return _result, _err
  1590  	}
  1591  
  1592  	_result = secret
  1593  	return _result, _err
  1594  }
  1595  
  1596  /**
  1597   * Get security token by using credential
  1598   * @return security token
  1599   */
  1600  func (client *Client) GetSecurityToken() (_result *string, _err error) {
  1601  	if tea.BoolValue(util.IsUnset(client.Credential)) {
  1602  		_result = tea.String("")
  1603  		return _result, _err
  1604  	}
  1605  
  1606  	token, _err := client.Credential.GetSecurityToken()
  1607  	if _err != nil {
  1608  		return _result, _err
  1609  	}
  1610  
  1611  	_result = token
  1612  	return _result, _err
  1613  }
  1614  
  1615  /**
  1616   * Get bearer token by credential
  1617   * @return bearer token
  1618   */
  1619  func (client *Client) GetBearerToken() (_result *string, _err error) {
  1620  	if tea.BoolValue(util.IsUnset(client.Credential)) {
  1621  		_result = tea.String("")
  1622  		return _result, _err
  1623  	}
  1624  
  1625  	token := client.Credential.GetBearerToken()
  1626  	_result = token
  1627  	return _result, _err
  1628  }
  1629  
  1630  /**
  1631   * Get credential type by credential
  1632   * @return credential type e.g. access_key
  1633   */
  1634  func (client *Client) GetType() (_result *string, _err error) {
  1635  	if tea.BoolValue(util.IsUnset(client.Credential)) {
  1636  		_result = tea.String("")
  1637  		return _result, _err
  1638  	}
  1639  
  1640  	authType := client.Credential.GetType()
  1641  	_result = authType
  1642  	return _result, _err
  1643  }
  1644  
  1645  /**
  1646   * If inputValue is not null, return it or return defaultValue
  1647   * @param inputValue  users input value
  1648   * @param defaultValue default value
  1649   * @return the final result
  1650   */
  1651  func DefaultAny(inputValue interface{}, defaultValue interface{}) (_result interface{}) {
  1652  	if tea.BoolValue(util.IsUnset(inputValue)) {
  1653  		_result = defaultValue
  1654  		return _result
  1655  	}
  1656  
  1657  	_result = inputValue
  1658  	return _result
  1659  }
  1660  
  1661  /**
  1662   * If the endpointRule and config.endpoint are empty, throw error
  1663   * @param config config contains the necessary information to create a client
  1664   */
  1665  func (client *Client) CheckConfig(config *Config) (_err error) {
  1666  	if tea.BoolValue(util.Empty(client.EndpointRule)) && tea.BoolValue(util.Empty(config.Endpoint)) {
  1667  		_err = tea.NewSDKError(map[string]interface{}{
  1668  			"code":    "ParameterMissing",
  1669  			"message": "'config.endpoint' can not be empty",
  1670  		})
  1671  		return _err
  1672  	}
  1673  
  1674  	return _err
  1675  }
  1676  
  1677  /**
  1678   * set RPC header for debug
  1679   * @param headers headers for debug, this header can be used only once.
  1680   */
  1681  func (client *Client) SetRpcHeaders(headers map[string]*string) (_err error) {
  1682  	client.Headers = headers
  1683  	return _err
  1684  }
  1685  
  1686  /**
  1687   * get RPC header for debug
  1688   */
  1689  func (client *Client) GetRpcHeaders() (_result map[string]*string, _err error) {
  1690  	headers := client.Headers
  1691  	client.Headers = nil
  1692  	_result = headers
  1693  	return _result, _err
  1694  }
  1695  

View as plain text