ahas_openapi

Documentation

Index

• Variables
• func GetEndpointMap() map[string]string
• func GetEndpointType() string
• func SetClientProperty(client *Client, propertyName string, propertyValue interface{})
• func SetEndpointDataToClient(client *Client)
• type Activities
• type ActivitiesItem
• type AppGroups
• type AppNameAndIdPairs
• type AppNameAndIdPairsItem
• type CheckExperimentRunnableRequest
  • func CreateCheckExperimentRunnableRequest() (request *CheckExperimentRunnableRequest)
• type CheckExperimentRunnableResponse
  • func CreateCheckExperimentRunnableResponse() (response *CheckExperimentRunnableResponse)
• type Client
  • func NewClient() (client *Client, err error)
  • func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error)
  • func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error)
  • func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error)
  • func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error)
  • func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error)
  • func NewClientWithRamRoleArnAndPolicy(regionId string, ...) (client *Client, err error)
  • func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error)
  • func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error)
  • func (client *Client) CheckExperimentRunnable(request *CheckExperimentRunnableRequest) (response *CheckExperimentRunnableResponse, err error)
  • func (client *Client) CheckExperimentRunnableWithCallback(request *CheckExperimentRunnableRequest, ...) <-chan int
  • func (client *Client) CheckExperimentRunnableWithChan(request *CheckExperimentRunnableRequest) (<-chan *CheckExperimentRunnableResponse, <-chan error)
  • func (client *Client) CreateDegradeRule(request *CreateDegradeRuleRequest) (response *CreateDegradeRuleResponse, err error)
  • func (client *Client) CreateDegradeRuleWithCallback(request *CreateDegradeRuleRequest, ...) <-chan int
  • func (client *Client) CreateDegradeRuleWithChan(request *CreateDegradeRuleRequest) (<-chan *CreateDegradeRuleResponse, <-chan error)
  • func (client *Client) CreateExperiment(request *CreateExperimentRequest) (response *CreateExperimentResponse, err error)
  • func (client *Client) CreateExperimentWithCallback(request *CreateExperimentRequest, ...) <-chan int
  • func (client *Client) CreateExperimentWithChan(request *CreateExperimentRequest) (<-chan *CreateExperimentResponse, <-chan error)
  • func (client *Client) CreateFlowRule(request *CreateFlowRuleRequest) (response *CreateFlowRuleResponse, err error)
  • func (client *Client) CreateFlowRuleWithCallback(request *CreateFlowRuleRequest, ...) <-chan int
  • func (client *Client) CreateFlowRuleWithChan(request *CreateFlowRuleRequest) (<-chan *CreateFlowRuleResponse, <-chan error)
  • func (client *Client) CreateHotParamItems(request *CreateHotParamItemsRequest) (response *CreateHotParamItemsResponse, err error)
  • func (client *Client) CreateHotParamItemsWithCallback(request *CreateHotParamItemsRequest, ...) <-chan int
  • func (client *Client) CreateHotParamItemsWithChan(request *CreateHotParamItemsRequest) (<-chan *CreateHotParamItemsResponse, <-chan error)
  • func (client *Client) CreateHotParamRule(request *CreateHotParamRuleRequest) (response *CreateHotParamRuleResponse, err error)
  • func (client *Client) CreateHotParamRuleWithCallback(request *CreateHotParamRuleRequest, ...) <-chan int
  • func (client *Client) CreateHotParamRuleWithChan(request *CreateHotParamRuleRequest) (<-chan *CreateHotParamRuleResponse, <-chan error)
  • func (client *Client) CreateIsolationRule(request *CreateIsolationRuleRequest) (response *CreateIsolationRuleResponse, err error)
  • func (client *Client) CreateIsolationRuleWithCallback(request *CreateIsolationRuleRequest, ...) <-chan int
  • func (client *Client) CreateIsolationRuleWithChan(request *CreateIsolationRuleRequest) (<-chan *CreateIsolationRuleResponse, <-chan error)
  • func (client *Client) CreateSystemRule(request *CreateSystemRuleRequest) (response *CreateSystemRuleResponse, err error)
  • func (client *Client) CreateSystemRuleWithCallback(request *CreateSystemRuleRequest, ...) <-chan int
  • func (client *Client) CreateSystemRuleWithChan(request *CreateSystemRuleRequest) (<-chan *CreateSystemRuleResponse, <-chan error)
  • func (client *Client) DeleteDegradeRule(request *DeleteDegradeRuleRequest) (response *DeleteDegradeRuleResponse, err error)
  • func (client *Client) DeleteDegradeRuleWithCallback(request *DeleteDegradeRuleRequest, ...) <-chan int
  • func (client *Client) DeleteDegradeRuleWithChan(request *DeleteDegradeRuleRequest) (<-chan *DeleteDegradeRuleResponse, <-chan error)
  • func (client *Client) DeleteFlowRule(request *DeleteFlowRuleRequest) (response *DeleteFlowRuleResponse, err error)
  • func (client *Client) DeleteFlowRuleWithCallback(request *DeleteFlowRuleRequest, ...) <-chan int
  • func (client *Client) DeleteFlowRuleWithChan(request *DeleteFlowRuleRequest) (<-chan *DeleteFlowRuleResponse, <-chan error)
  • func (client *Client) DeleteHotParamRule(request *DeleteHotParamRuleRequest) (response *DeleteHotParamRuleResponse, err error)
  • func (client *Client) DeleteHotParamRuleWithCallback(request *DeleteHotParamRuleRequest, ...) <-chan int
  • func (client *Client) DeleteHotParamRuleWithChan(request *DeleteHotParamRuleRequest) (<-chan *DeleteHotParamRuleResponse, <-chan error)
  • func (client *Client) DeleteIsolationRule(request *DeleteIsolationRuleRequest) (response *DeleteIsolationRuleResponse, err error)
  • func (client *Client) DeleteIsolationRuleWithCallback(request *DeleteIsolationRuleRequest, ...) <-chan int
  • func (client *Client) DeleteIsolationRuleWithChan(request *DeleteIsolationRuleRequest) (<-chan *DeleteIsolationRuleResponse, <-chan error)
  • func (client *Client) DeleteSystemRule(request *DeleteSystemRuleRequest) (response *DeleteSystemRuleResponse, err error)
  • func (client *Client) DeleteSystemRuleWithCallback(request *DeleteSystemRuleRequest, ...) <-chan int
  • func (client *Client) DeleteSystemRuleWithChan(request *DeleteSystemRuleRequest) (<-chan *DeleteSystemRuleResponse, <-chan error)
  • func (client *Client) DescribeRegions(request *DescribeRegionsRequest) (response *DescribeRegionsResponse, err error)
  • func (client *Client) DescribeRegionsWithCallback(request *DescribeRegionsRequest, ...) <-chan int
  • func (client *Client) DescribeRegionsWithChan(request *DescribeRegionsRequest) (<-chan *DescribeRegionsResponse, <-chan error)
  • func (client *Client) DisableDegradeRule(request *DisableDegradeRuleRequest) (response *DisableDegradeRuleResponse, err error)
  • func (client *Client) DisableDegradeRuleWithCallback(request *DisableDegradeRuleRequest, ...) <-chan int
  • func (client *Client) DisableDegradeRuleWithChan(request *DisableDegradeRuleRequest) (<-chan *DisableDegradeRuleResponse, <-chan error)
  • func (client *Client) DisableFlowRule(request *DisableFlowRuleRequest) (response *DisableFlowRuleResponse, err error)
  • func (client *Client) DisableFlowRuleWithCallback(request *DisableFlowRuleRequest, ...) <-chan int
  • func (client *Client) DisableFlowRuleWithChan(request *DisableFlowRuleRequest) (<-chan *DisableFlowRuleResponse, <-chan error)
  • func (client *Client) DisableHotParamRule(request *DisableHotParamRuleRequest) (response *DisableHotParamRuleResponse, err error)
  • func (client *Client) DisableHotParamRuleWithCallback(request *DisableHotParamRuleRequest, ...) <-chan int
  • func (client *Client) DisableHotParamRuleWithChan(request *DisableHotParamRuleRequest) (<-chan *DisableHotParamRuleResponse, <-chan error)
  • func (client *Client) DisableIsolationRule(request *DisableIsolationRuleRequest) (response *DisableIsolationRuleResponse, err error)
  • func (client *Client) DisableIsolationRuleWithCallback(request *DisableIsolationRuleRequest, ...) <-chan int
  • func (client *Client) DisableIsolationRuleWithChan(request *DisableIsolationRuleRequest) (<-chan *DisableIsolationRuleResponse, <-chan error)
  • func (client *Client) DisableSystemRule(request *DisableSystemRuleRequest) (response *DisableSystemRuleResponse, err error)
  • func (client *Client) DisableSystemRuleWithCallback(request *DisableSystemRuleRequest, ...) <-chan int
  • func (client *Client) DisableSystemRuleWithChan(request *DisableSystemRuleRequest) (<-chan *DisableSystemRuleResponse, <-chan error)
  • func (client *Client) EnableDegradeRule(request *EnableDegradeRuleRequest) (response *EnableDegradeRuleResponse, err error)
  • func (client *Client) EnableDegradeRuleWithCallback(request *EnableDegradeRuleRequest, ...) <-chan int
  • func (client *Client) EnableDegradeRuleWithChan(request *EnableDegradeRuleRequest) (<-chan *EnableDegradeRuleResponse, <-chan error)
  • func (client *Client) EnableFlowRule(request *EnableFlowRuleRequest) (response *EnableFlowRuleResponse, err error)
  • func (client *Client) EnableFlowRuleWithCallback(request *EnableFlowRuleRequest, ...) <-chan int
  • func (client *Client) EnableFlowRuleWithChan(request *EnableFlowRuleRequest) (<-chan *EnableFlowRuleResponse, <-chan error)
  • func (client *Client) EnableHotParamRule(request *EnableHotParamRuleRequest) (response *EnableHotParamRuleResponse, err error)
  • func (client *Client) EnableHotParamRuleWithCallback(request *EnableHotParamRuleRequest, ...) <-chan int
  • func (client *Client) EnableHotParamRuleWithChan(request *EnableHotParamRuleRequest) (<-chan *EnableHotParamRuleResponse, <-chan error)
  • func (client *Client) EnableIsolationRule(request *EnableIsolationRuleRequest) (response *EnableIsolationRuleResponse, err error)
  • func (client *Client) EnableIsolationRuleWithCallback(request *EnableIsolationRuleRequest, ...) <-chan int
  • func (client *Client) EnableIsolationRuleWithChan(request *EnableIsolationRuleRequest) (<-chan *EnableIsolationRuleResponse, <-chan error)
  • func (client *Client) EnableSystemRule(request *EnableSystemRuleRequest) (response *EnableSystemRuleResponse, err error)
  • func (client *Client) EnableSystemRuleWithCallback(request *EnableSystemRuleRequest, ...) <-chan int
  • func (client *Client) EnableSystemRuleWithChan(request *EnableSystemRuleRequest) (<-chan *EnableSystemRuleResponse, <-chan error)
  • func (client *Client) ExecuteExperiment(request *ExecuteExperimentRequest) (response *ExecuteExperimentResponse, err error)
  • func (client *Client) ExecuteExperimentWithCallback(request *ExecuteExperimentRequest, ...) <-chan int
  • func (client *Client) ExecuteExperimentWithChan(request *ExecuteExperimentRequest) (<-chan *ExecuteExperimentResponse, <-chan error)
  • func (client *Client) FinishExperimentTask(request *FinishExperimentTaskRequest) (response *FinishExperimentTaskResponse, err error)
  • func (client *Client) FinishExperimentTaskWithCallback(request *FinishExperimentTaskRequest, ...) <-chan int
  • func (client *Client) FinishExperimentTaskWithChan(request *FinishExperimentTaskRequest) (<-chan *FinishExperimentTaskResponse, <-chan error)
  • func (client *Client) GetActivityTask(request *GetActivityTaskRequest) (response *GetActivityTaskResponse, err error)
  • func (client *Client) GetActivityTaskWithCallback(request *GetActivityTaskRequest, ...) <-chan int
  • func (client *Client) GetActivityTaskWithChan(request *GetActivityTaskRequest) (<-chan *GetActivityTaskResponse, <-chan error)
  • func (client *Client) GetExperimentMeta(request *GetExperimentMetaRequest) (response *GetExperimentMetaResponse, err error)
  • func (client *Client) GetExperimentMetaWithCallback(request *GetExperimentMetaRequest, ...) <-chan int
  • func (client *Client) GetExperimentMetaWithChan(request *GetExperimentMetaRequest) (<-chan *GetExperimentMetaResponse, <-chan error)
  • func (client *Client) GetExperimentTask(request *GetExperimentTaskRequest) (response *GetExperimentTaskResponse, err error)
  • func (client *Client) GetExperimentTaskWithCallback(request *GetExperimentTaskRequest, ...) <-chan int
  • func (client *Client) GetExperimentTaskWithChan(request *GetExperimentTaskRequest) (<-chan *GetExperimentTaskResponse, <-chan error)
  • func (client *Client) GetLicenseKey(request *GetLicenseKeyRequest) (response *GetLicenseKeyResponse, err error)
  • func (client *Client) GetLicenseKeyWithCallback(request *GetLicenseKeyRequest, ...) <-chan int
  • func (client *Client) GetLicenseKeyWithChan(request *GetLicenseKeyRequest) (<-chan *GetLicenseKeyResponse, <-chan error)
  • func (client *Client) GetMetricsOfApp(request *GetMetricsOfAppRequest) (response *GetMetricsOfAppResponse, err error)
  • func (client *Client) GetMetricsOfAppWithCallback(request *GetMetricsOfAppRequest, ...) <-chan int
  • func (client *Client) GetMetricsOfAppWithChan(request *GetMetricsOfAppRequest) (<-chan *GetMetricsOfAppResponse, <-chan error)
  • func (client *Client) GetMetricsOfResource(request *GetMetricsOfResourceRequest) (response *GetMetricsOfResourceResponse, err error)
  • func (client *Client) GetMetricsOfResourceWithCallback(request *GetMetricsOfResourceRequest, ...) <-chan int
  • func (client *Client) GetMetricsOfResourceWithChan(request *GetMetricsOfResourceRequest) (<-chan *GetMetricsOfResourceResponse, <-chan error)
  • func (client *Client) GetSentinelAppSumMetric(request *GetSentinelAppSumMetricRequest) (response *GetSentinelAppSumMetricResponse, err error)
  • func (client *Client) GetSentinelAppSumMetricWithCallback(request *GetSentinelAppSumMetricRequest, ...) <-chan int
  • func (client *Client) GetSentinelAppSumMetricWithChan(request *GetSentinelAppSumMetricRequest) (<-chan *GetSentinelAppSumMetricResponse, <-chan error)
  • func (client *Client) GetUserApplicationGroups(request *GetUserApplicationGroupsRequest) (response *GetUserApplicationGroupsResponse, err error)
  • func (client *Client) GetUserApplicationGroupsWithCallback(request *GetUserApplicationGroupsRequest, ...) <-chan int
  • func (client *Client) GetUserApplicationGroupsWithChan(request *GetUserApplicationGroupsRequest) (<-chan *GetUserApplicationGroupsResponse, <-chan error)
  • func (client *Client) GetUserApplications(request *GetUserApplicationsRequest) (response *GetUserApplicationsResponse, err error)
  • func (client *Client) GetUserApplicationsWithCallback(request *GetUserApplicationsRequest, ...) <-chan int
  • func (client *Client) GetUserApplicationsWithChan(request *GetUserApplicationsRequest) (<-chan *GetUserApplicationsResponse, <-chan error)
  • func (client *Client) GetUserWorkspace(request *GetUserWorkspaceRequest) (response *GetUserWorkspaceResponse, err error)
  • func (client *Client) GetUserWorkspaceWithCallback(request *GetUserWorkspaceRequest, ...) <-chan int
  • func (client *Client) GetUserWorkspaceWithChan(request *GetUserWorkspaceRequest) (<-chan *GetUserWorkspaceResponse, <-chan error)
  • func (client *Client) ListActiveApps(request *ListActiveAppsRequest) (response *ListActiveAppsResponse, err error)
  • func (client *Client) ListActiveAppsWithCallback(request *ListActiveAppsRequest, ...) <-chan int
  • func (client *Client) ListActiveAppsWithChan(request *ListActiveAppsRequest) (<-chan *ListActiveAppsResponse, <-chan error)
  • func (client *Client) ListDegradeRulesOfApp(request *ListDegradeRulesOfAppRequest) (response *ListDegradeRulesOfAppResponse, err error)
  • func (client *Client) ListDegradeRulesOfAppWithCallback(request *ListDegradeRulesOfAppRequest, ...) <-chan int
  • func (client *Client) ListDegradeRulesOfAppWithChan(request *ListDegradeRulesOfAppRequest) (<-chan *ListDegradeRulesOfAppResponse, <-chan error)
  • func (client *Client) ListDegradeRulesOfResource(request *ListDegradeRulesOfResourceRequest) (response *ListDegradeRulesOfResourceResponse, err error)
  • func (client *Client) ListDegradeRulesOfResourceWithCallback(request *ListDegradeRulesOfResourceRequest, ...) <-chan int
  • func (client *Client) ListDegradeRulesOfResourceWithChan(request *ListDegradeRulesOfResourceRequest) (<-chan *ListDegradeRulesOfResourceResponse, <-chan error)
  • func (client *Client) ListExperimentMetas(request *ListExperimentMetasRequest) (response *ListExperimentMetasResponse, err error)
  • func (client *Client) ListExperimentMetasWithCallback(request *ListExperimentMetasRequest, ...) <-chan int
  • func (client *Client) ListExperimentMetasWithChan(request *ListExperimentMetasRequest) (<-chan *ListExperimentMetasResponse, <-chan error)
  • func (client *Client) ListFlowRulesOfApp(request *ListFlowRulesOfAppRequest) (response *ListFlowRulesOfAppResponse, err error)
  • func (client *Client) ListFlowRulesOfAppWithCallback(request *ListFlowRulesOfAppRequest, ...) <-chan int
  • func (client *Client) ListFlowRulesOfAppWithChan(request *ListFlowRulesOfAppRequest) (<-chan *ListFlowRulesOfAppResponse, <-chan error)
  • func (client *Client) ListFlowRulesOfResource(request *ListFlowRulesOfResourceRequest) (response *ListFlowRulesOfResourceResponse, err error)
  • func (client *Client) ListFlowRulesOfResourceWithCallback(request *ListFlowRulesOfResourceRequest, ...) <-chan int
  • func (client *Client) ListFlowRulesOfResourceWithChan(request *ListFlowRulesOfResourceRequest) (<-chan *ListFlowRulesOfResourceResponse, <-chan error)
  • func (client *Client) ListHotParamRulesOfApp(request *ListHotParamRulesOfAppRequest) (response *ListHotParamRulesOfAppResponse, err error)
  • func (client *Client) ListHotParamRulesOfAppWithCallback(request *ListHotParamRulesOfAppRequest, ...) <-chan int
  • func (client *Client) ListHotParamRulesOfAppWithChan(request *ListHotParamRulesOfAppRequest) (<-chan *ListHotParamRulesOfAppResponse, <-chan error)
  • func (client *Client) ListHotParamRulesOfResource(request *ListHotParamRulesOfResourceRequest) (response *ListHotParamRulesOfResourceResponse, err error)
  • func (client *Client) ListHotParamRulesOfResourceWithCallback(request *ListHotParamRulesOfResourceRequest, ...) <-chan int
  • func (client *Client) ListHotParamRulesOfResourceWithChan(request *ListHotParamRulesOfResourceRequest) (<-chan *ListHotParamRulesOfResourceResponse, <-chan error)
  • func (client *Client) ListIsolationRulesOfApp(request *ListIsolationRulesOfAppRequest) (response *ListIsolationRulesOfAppResponse, err error)
  • func (client *Client) ListIsolationRulesOfAppWithCallback(request *ListIsolationRulesOfAppRequest, ...) <-chan int
  • func (client *Client) ListIsolationRulesOfAppWithChan(request *ListIsolationRulesOfAppRequest) (<-chan *ListIsolationRulesOfAppResponse, <-chan error)
  • func (client *Client) ListIsolationRulesOfResource(request *ListIsolationRulesOfResourceRequest) (response *ListIsolationRulesOfResourceResponse, err error)
  • func (client *Client) ListIsolationRulesOfResourceWithCallback(request *ListIsolationRulesOfResourceRequest, ...) <-chan int
  • func (client *Client) ListIsolationRulesOfResourceWithChan(request *ListIsolationRulesOfResourceRequest) (<-chan *ListIsolationRulesOfResourceResponse, <-chan error)
  • func (client *Client) ListSystemRules(request *ListSystemRulesRequest) (response *ListSystemRulesResponse, err error)
  • func (client *Client) ListSystemRulesWithCallback(request *ListSystemRulesRequest, ...) <-chan int
  • func (client *Client) ListSystemRulesWithChan(request *ListSystemRulesRequest) (<-chan *ListSystemRulesResponse, <-chan error)
  • func (client *Client) ModifyDegradeRule(request *ModifyDegradeRuleRequest) (response *ModifyDegradeRuleResponse, err error)
  • func (client *Client) ModifyDegradeRuleWithCallback(request *ModifyDegradeRuleRequest, ...) <-chan int
  • func (client *Client) ModifyDegradeRuleWithChan(request *ModifyDegradeRuleRequest) (<-chan *ModifyDegradeRuleResponse, <-chan error)
  • func (client *Client) ModifyFlowRule(request *ModifyFlowRuleRequest) (response *ModifyFlowRuleResponse, err error)
  • func (client *Client) ModifyFlowRuleWithCallback(request *ModifyFlowRuleRequest, ...) <-chan int
  • func (client *Client) ModifyFlowRuleWithChan(request *ModifyFlowRuleRequest) (<-chan *ModifyFlowRuleResponse, <-chan error)
  • func (client *Client) ModifyHotParamRule(request *ModifyHotParamRuleRequest) (response *ModifyHotParamRuleResponse, err error)
  • func (client *Client) ModifyHotParamRuleWithCallback(request *ModifyHotParamRuleRequest, ...) <-chan int
  • func (client *Client) ModifyHotParamRuleWithChan(request *ModifyHotParamRuleRequest) (<-chan *ModifyHotParamRuleResponse, <-chan error)
  • func (client *Client) ModifyIsolationRule(request *ModifyIsolationRuleRequest) (response *ModifyIsolationRuleResponse, err error)
  • func (client *Client) ModifyIsolationRuleWithCallback(request *ModifyIsolationRuleRequest, ...) <-chan int
  • func (client *Client) ModifyIsolationRuleWithChan(request *ModifyIsolationRuleRequest) (<-chan *ModifyIsolationRuleResponse, <-chan error)
  • func (client *Client) ModifySystemRule(request *ModifySystemRuleRequest) (response *ModifySystemRuleResponse, err error)
  • func (client *Client) ModifySystemRuleWithCallback(request *ModifySystemRuleRequest, ...) <-chan int
  • func (client *Client) ModifySystemRuleWithChan(request *ModifySystemRuleRequest) (<-chan *ModifySystemRuleResponse, <-chan error)
  • func (client *Client) OpenAhasService(request *OpenAhasServiceRequest) (response *OpenAhasServiceResponse, err error)
  • func (client *Client) OpenAhasServiceWithCallback(request *OpenAhasServiceRequest, ...) <-chan int
  • func (client *Client) OpenAhasServiceWithChan(request *OpenAhasServiceRequest) (<-chan *OpenAhasServiceResponse, <-chan error)
  • func (client *Client) PageableQueryExperimentTaskByClusterId(request *PageableQueryExperimentTaskByClusterIdRequest) (response *PageableQueryExperimentTaskByClusterIdResponse, err error)
  • func (client *Client) PageableQueryExperimentTaskByClusterIdWithCallback(request *PageableQueryExperimentTaskByClusterIdRequest, ...) <-chan int
  • func (client *Client) PageableQueryExperimentTaskByClusterIdWithChan(request *PageableQueryExperimentTaskByClusterIdRequest) (<-chan *PageableQueryExperimentTaskByClusterIdResponse, <-chan error)
  • func (client *Client) PageableQueryExperimentTaskByExperimentId(request *PageableQueryExperimentTaskByExperimentIdRequest) (response *PageableQueryExperimentTaskByExperimentIdResponse, err error)
  • func (client *Client) PageableQueryExperimentTaskByExperimentIdWithCallback(request *PageableQueryExperimentTaskByExperimentIdRequest, ...) <-chan int
  • func (client *Client) PageableQueryExperimentTaskByExperimentIdWithChan(request *PageableQueryExperimentTaskByExperimentIdRequest) (<-chan *PageableQueryExperimentTaskByExperimentIdResponse, <-chan error)
  • func (client *Client) PageableQueryUserExperiment(request *PageableQueryUserExperimentRequest) (response *PageableQueryUserExperimentResponse, err error)
  • func (client *Client) PageableQueryUserExperimentWithCallback(request *PageableQueryUserExperimentRequest, ...) <-chan int
  • func (client *Client) PageableQueryUserExperimentWithChan(request *PageableQueryUserExperimentRequest) (<-chan *PageableQueryUserExperimentResponse, <-chan error)
  • func (client *Client) PushExperimentTask(request *PushExperimentTaskRequest) (response *PushExperimentTaskResponse, err error)
  • func (client *Client) PushExperimentTaskWithCallback(request *PushExperimentTaskRequest, ...) <-chan int
  • func (client *Client) PushExperimentTaskWithChan(request *PushExperimentTaskRequest) (<-chan *PushExperimentTaskResponse, <-chan error)
  • func (client *Client) UpdateExperiment(request *UpdateExperimentRequest) (response *UpdateExperimentResponse, err error)
  • func (client *Client) UpdateExperimentBasicInfo(request *UpdateExperimentBasicInfoRequest) (response *UpdateExperimentBasicInfoResponse, err error)
  • func (client *Client) UpdateExperimentBasicInfoWithCallback(request *UpdateExperimentBasicInfoRequest, ...) <-chan int
  • func (client *Client) UpdateExperimentBasicInfoWithChan(request *UpdateExperimentBasicInfoRequest) (<-chan *UpdateExperimentBasicInfoResponse, <-chan error)
  • func (client *Client) UpdateExperimentWithCallback(request *UpdateExperimentRequest, ...) <-chan int
  • func (client *Client) UpdateExperimentWithChan(request *UpdateExperimentRequest) (<-chan *UpdateExperimentResponse, <-chan error)
• type Content
• type ContentItem
• type CreateDegradeRuleRequest
  • func CreateCreateDegradeRuleRequest() (request *CreateDegradeRuleRequest)
• type CreateDegradeRuleResponse
  • func CreateCreateDegradeRuleResponse() (response *CreateDegradeRuleResponse)
• type CreateExperimentRequest
  • func CreateCreateExperimentRequest() (request *CreateExperimentRequest)
• type CreateExperimentResponse
  • func CreateCreateExperimentResponse() (response *CreateExperimentResponse)
• type CreateFlowRuleRequest
  • func CreateCreateFlowRuleRequest() (request *CreateFlowRuleRequest)
• type CreateFlowRuleResponse
  • func CreateCreateFlowRuleResponse() (response *CreateFlowRuleResponse)
• type CreateHotParamItemsRequest
  • func CreateCreateHotParamItemsRequest() (request *CreateHotParamItemsRequest)
• type CreateHotParamItemsResponse
  • func CreateCreateHotParamItemsResponse() (response *CreateHotParamItemsResponse)
• type CreateHotParamRuleRequest
  • func CreateCreateHotParamRuleRequest() (request *CreateHotParamRuleRequest)
• type CreateHotParamRuleResponse
  • func CreateCreateHotParamRuleResponse() (response *CreateHotParamRuleResponse)
• type CreateIsolationRuleRequest
  • func CreateCreateIsolationRuleRequest() (request *CreateIsolationRuleRequest)
• type CreateIsolationRuleResponse
  • func CreateCreateIsolationRuleResponse() (response *CreateIsolationRuleResponse)
• type CreateSystemRuleRequest
  • func CreateCreateSystemRuleRequest() (request *CreateSystemRuleRequest)
• type CreateSystemRuleResponse
  • func CreateCreateSystemRuleResponse() (response *CreateSystemRuleResponse)
• type Creator
• type Data
• type DataInListActiveApps
• type DataItem
• type DatasInListDegradeRulesOfApp
• type DatasInListDegradeRulesOfResource
• type DatasInListFlowRulesOfApp
• type DatasInListFlowRulesOfResource
• type DatasInListHotParamRulesOfApp
• type DatasInListHotParamRulesOfResource
• type DatasInListIsolationRulesOfApp
• type DatasInListIsolationRulesOfResource
• type DatasInListSystemRules
• type DatasItem
• type DeleteDegradeRuleRequest
  • func CreateDeleteDegradeRuleRequest() (request *DeleteDegradeRuleRequest)
• type DeleteDegradeRuleResponse
  • func CreateDeleteDegradeRuleResponse() (response *DeleteDegradeRuleResponse)
• type DeleteFlowRuleRequest
  • func CreateDeleteFlowRuleRequest() (request *DeleteFlowRuleRequest)
• type DeleteFlowRuleResponse
  • func CreateDeleteFlowRuleResponse() (response *DeleteFlowRuleResponse)
• type DeleteHotParamRuleRequest
  • func CreateDeleteHotParamRuleRequest() (request *DeleteHotParamRuleRequest)
• type DeleteHotParamRuleResponse
  • func CreateDeleteHotParamRuleResponse() (response *DeleteHotParamRuleResponse)
• type DeleteIsolationRuleRequest
  • func CreateDeleteIsolationRuleRequest() (request *DeleteIsolationRuleRequest)
• type DeleteIsolationRuleResponse
  • func CreateDeleteIsolationRuleResponse() (response *DeleteIsolationRuleResponse)
• type DeleteSystemRuleRequest
  • func CreateDeleteSystemRuleRequest() (request *DeleteSystemRuleRequest)
• type DeleteSystemRuleResponse
  • func CreateDeleteSystemRuleResponse() (response *DeleteSystemRuleResponse)
• type DescribeRegionsRequest
  • func CreateDescribeRegionsRequest() (request *DescribeRegionsRequest)
• type DescribeRegionsResponse
  • func CreateDescribeRegionsResponse() (response *DescribeRegionsResponse)
• type DisableDegradeRuleRequest
  • func CreateDisableDegradeRuleRequest() (request *DisableDegradeRuleRequest)
• type DisableDegradeRuleResponse
  • func CreateDisableDegradeRuleResponse() (response *DisableDegradeRuleResponse)
• type DisableFlowRuleRequest
  • func CreateDisableFlowRuleRequest() (request *DisableFlowRuleRequest)
• type DisableFlowRuleResponse
  • func CreateDisableFlowRuleResponse() (response *DisableFlowRuleResponse)
• type DisableHotParamRuleRequest
  • func CreateDisableHotParamRuleRequest() (request *DisableHotParamRuleRequest)
• type DisableHotParamRuleResponse
  • func CreateDisableHotParamRuleResponse() (response *DisableHotParamRuleResponse)
• type DisableIsolationRuleRequest
  • func CreateDisableIsolationRuleRequest() (request *DisableIsolationRuleRequest)
• type DisableIsolationRuleResponse
  • func CreateDisableIsolationRuleResponse() (response *DisableIsolationRuleResponse)
• type DisableSystemRuleRequest
  • func CreateDisableSystemRuleRequest() (request *DisableSystemRuleRequest)
• type DisableSystemRuleResponse
  • func CreateDisableSystemRuleResponse() (response *DisableSystemRuleResponse)
• type EnableDegradeRuleRequest
  • func CreateEnableDegradeRuleRequest() (request *EnableDegradeRuleRequest)
• type EnableDegradeRuleResponse
  • func CreateEnableDegradeRuleResponse() (response *EnableDegradeRuleResponse)
• type EnableFlowRuleRequest
  • func CreateEnableFlowRuleRequest() (request *EnableFlowRuleRequest)
• type EnableFlowRuleResponse
  • func CreateEnableFlowRuleResponse() (response *EnableFlowRuleResponse)
• type EnableHotParamRuleRequest
  • func CreateEnableHotParamRuleRequest() (request *EnableHotParamRuleRequest)
• type EnableHotParamRuleResponse
  • func CreateEnableHotParamRuleResponse() (response *EnableHotParamRuleResponse)
• type EnableIsolationRuleRequest
  • func CreateEnableIsolationRuleRequest() (request *EnableIsolationRuleRequest)
• type EnableIsolationRuleResponse
  • func CreateEnableIsolationRuleResponse() (response *EnableIsolationRuleResponse)
• type EnableSystemRuleRequest
  • func CreateEnableSystemRuleRequest() (request *EnableSystemRuleRequest)
• type EnableSystemRuleResponse
  • func CreateEnableSystemRuleResponse() (response *EnableSystemRuleResponse)
• type ExecuteExperimentRequest
  • func CreateExecuteExperimentRequest() (request *ExecuteExperimentRequest)
• type ExecuteExperimentResponse
  • func CreateExecuteExperimentResponse() (response *ExecuteExperimentResponse)
• type ExperimentInfo
• type ExperimentList
• type ExperimentTaskInfo
• type ExperimentTasksInPageableQueryExperimentTaskByClusterId
• type ExperimentTasksInPageableQueryExperimentTaskByExperimentId
• type ExtInfo
• type FinishExperimentTaskRequest
  • func CreateFinishExperimentTaskRequest() (request *FinishExperimentTaskRequest)
• type FinishExperimentTaskResponse
  • func CreateFinishExperimentTaskResponse() (response *FinishExperimentTaskResponse)
• type GetActivityTaskRequest
  • func CreateGetActivityTaskRequest() (request *GetActivityTaskRequest)
• type GetActivityTaskResponse
  • func CreateGetActivityTaskResponse() (response *GetActivityTaskResponse)
• type GetExperimentMetaRequest
  • func CreateGetExperimentMetaRequest() (request *GetExperimentMetaRequest)
• type GetExperimentMetaResponse
  • func CreateGetExperimentMetaResponse() (response *GetExperimentMetaResponse)
• type GetExperimentTaskRequest
  • func CreateGetExperimentTaskRequest() (request *GetExperimentTaskRequest)
• type GetExperimentTaskResponse
  • func CreateGetExperimentTaskResponse() (response *GetExperimentTaskResponse)
• type GetLicenseKeyRequest
  • func CreateGetLicenseKeyRequest() (request *GetLicenseKeyRequest)
• type GetLicenseKeyResponse
  • func CreateGetLicenseKeyResponse() (response *GetLicenseKeyResponse)
• type GetMetricsOfAppRequest
  • func CreateGetMetricsOfAppRequest() (request *GetMetricsOfAppRequest)
• type GetMetricsOfAppResponse
  • func CreateGetMetricsOfAppResponse() (response *GetMetricsOfAppResponse)
• type GetMetricsOfResourceRequest
  • func CreateGetMetricsOfResourceRequest() (request *GetMetricsOfResourceRequest)
• type GetMetricsOfResourceResponse
  • func CreateGetMetricsOfResourceResponse() (response *GetMetricsOfResourceResponse)
• type GetSentinelAppSumMetricRequest
  • func CreateGetSentinelAppSumMetricRequest() (request *GetSentinelAppSumMetricRequest)
• type GetSentinelAppSumMetricResponse
  • func CreateGetSentinelAppSumMetricResponse() (response *GetSentinelAppSumMetricResponse)
• type GetUserApplicationGroupsRequest
  • func CreateGetUserApplicationGroupsRequest() (request *GetUserApplicationGroupsRequest)
• type GetUserApplicationGroupsResponse
  • func CreateGetUserApplicationGroupsResponse() (response *GetUserApplicationGroupsResponse)
• type GetUserApplicationsRequest
  • func CreateGetUserApplicationsRequest() (request *GetUserApplicationsRequest)
• type GetUserApplicationsResponse
  • func CreateGetUserApplicationsResponse() (response *GetUserApplicationsResponse)
• type GetUserWorkspaceRequest
  • func CreateGetUserWorkspaceRequest() (request *GetUserWorkspaceRequest)
• type GetUserWorkspaceResponse
  • func CreateGetUserWorkspaceResponse() (response *GetUserWorkspaceResponse)
• type Hosts
• type HostsItem
• type InnerMetricsInGetMetricsOfApp
• type InnerMetricsInGetMetricsOfResource
• type InnerMetricsItem
• type ListActiveAppsRequest
  • func CreateListActiveAppsRequest() (request *ListActiveAppsRequest)
• type ListActiveAppsResponse
  • func CreateListActiveAppsResponse() (response *ListActiveAppsResponse)
• type ListDegradeRulesOfAppRequest
  • func CreateListDegradeRulesOfAppRequest() (request *ListDegradeRulesOfAppRequest)
• type ListDegradeRulesOfAppResponse
  • func CreateListDegradeRulesOfAppResponse() (response *ListDegradeRulesOfAppResponse)
• type ListDegradeRulesOfResourceRequest
  • func CreateListDegradeRulesOfResourceRequest() (request *ListDegradeRulesOfResourceRequest)
• type ListDegradeRulesOfResourceResponse
  • func CreateListDegradeRulesOfResourceResponse() (response *ListDegradeRulesOfResourceResponse)
• type ListExperimentMetasRequest
  • func CreateListExperimentMetasRequest() (request *ListExperimentMetasRequest)
• type ListExperimentMetasResponse
  • func CreateListExperimentMetasResponse() (response *ListExperimentMetasResponse)
• type ListFlowRulesOfAppRequest
  • func CreateListFlowRulesOfAppRequest() (request *ListFlowRulesOfAppRequest)
• type ListFlowRulesOfAppResponse
  • func CreateListFlowRulesOfAppResponse() (response *ListFlowRulesOfAppResponse)
• type ListFlowRulesOfResourceRequest
  • func CreateListFlowRulesOfResourceRequest() (request *ListFlowRulesOfResourceRequest)
• type ListFlowRulesOfResourceResponse
  • func CreateListFlowRulesOfResourceResponse() (response *ListFlowRulesOfResourceResponse)
• type ListHotParamRulesOfAppRequest
  • func CreateListHotParamRulesOfAppRequest() (request *ListHotParamRulesOfAppRequest)
• type ListHotParamRulesOfAppResponse
  • func CreateListHotParamRulesOfAppResponse() (response *ListHotParamRulesOfAppResponse)
• type ListHotParamRulesOfResourceRequest
  • func CreateListHotParamRulesOfResourceRequest() (request *ListHotParamRulesOfResourceRequest)
• type ListHotParamRulesOfResourceResponse
  • func CreateListHotParamRulesOfResourceResponse() (response *ListHotParamRulesOfResourceResponse)
• type ListIsolationRulesOfAppRequest
  • func CreateListIsolationRulesOfAppRequest() (request *ListIsolationRulesOfAppRequest)
• type ListIsolationRulesOfAppResponse
  • func CreateListIsolationRulesOfAppResponse() (response *ListIsolationRulesOfAppResponse)
• type ListIsolationRulesOfResourceRequest
  • func CreateListIsolationRulesOfResourceRequest() (request *ListIsolationRulesOfResourceRequest)
• type ListIsolationRulesOfResourceResponse
  • func CreateListIsolationRulesOfResourceResponse() (response *ListIsolationRulesOfResourceResponse)
• type ListSystemRulesRequest
  • func CreateListSystemRulesRequest() (request *ListSystemRulesRequest)
• type ListSystemRulesResponse
  • func CreateListSystemRulesResponse() (response *ListSystemRulesResponse)
• type MetricData
• type MiniApps
• type ModifyDegradeRuleRequest
  • func CreateModifyDegradeRuleRequest() (request *ModifyDegradeRuleRequest)
• type ModifyDegradeRuleResponse
  • func CreateModifyDegradeRuleResponse() (response *ModifyDegradeRuleResponse)
• type ModifyFlowRuleRequest
  • func CreateModifyFlowRuleRequest() (request *ModifyFlowRuleRequest)
• type ModifyFlowRuleResponse
  • func CreateModifyFlowRuleResponse() (response *ModifyFlowRuleResponse)
• type ModifyHotParamRuleRequest
  • func CreateModifyHotParamRuleRequest() (request *ModifyHotParamRuleRequest)
• type ModifyHotParamRuleResponse
  • func CreateModifyHotParamRuleResponse() (response *ModifyHotParamRuleResponse)
• type ModifyIsolationRuleRequest
  • func CreateModifyIsolationRuleRequest() (request *ModifyIsolationRuleRequest)
• type ModifyIsolationRuleResponse
  • func CreateModifyIsolationRuleResponse() (response *ModifyIsolationRuleResponse)
• type ModifySystemRuleRequest
  • func CreateModifySystemRuleRequest() (request *ModifySystemRuleRequest)
• type ModifySystemRuleResponse
  • func CreateModifySystemRuleResponse() (response *ModifySystemRuleResponse)
• type OpenAhasServiceRequest
  • func CreateOpenAhasServiceRequest() (request *OpenAhasServiceRequest)
• type OpenAhasServiceResponse
  • func CreateOpenAhasServiceResponse() (response *OpenAhasServiceResponse)
• type PageableQueryExperimentTaskByClusterIdRequest
  • func CreatePageableQueryExperimentTaskByClusterIdRequest() (request *PageableQueryExperimentTaskByClusterIdRequest)
• type PageableQueryExperimentTaskByClusterIdResponse
  • func CreatePageableQueryExperimentTaskByClusterIdResponse() (response *PageableQueryExperimentTaskByClusterIdResponse)
• type PageableQueryExperimentTaskByExperimentIdRequest
  • func CreatePageableQueryExperimentTaskByExperimentIdRequest() (request *PageableQueryExperimentTaskByExperimentIdRequest)
• type PageableQueryExperimentTaskByExperimentIdResponse
  • func CreatePageableQueryExperimentTaskByExperimentIdResponse() (response *PageableQueryExperimentTaskByExperimentIdResponse)
• type PageableQueryUserExperimentRequest
  • func CreatePageableQueryUserExperimentRequest() (request *PageableQueryUserExperimentRequest)
• type PageableQueryUserExperimentResponse
  • func CreatePageableQueryUserExperimentResponse() (response *PageableQueryUserExperimentResponse)
• type ParamFlowItemListInCreateHotParamItems
• type ParamFlowItemListInCreateHotParamRule
• type ParamFlowItemListInDisableHotParamRule
• type ParamFlowItemListInEnableHotParamRule
• type ParamFlowItemListInListHotParamRulesOfApp
• type ParamFlowItemListInListHotParamRulesOfResource
• type ParamFlowItemListInModifyHotParamRule
• type ParamFlowItemListItem
• type PushExperimentTaskRequest
  • func CreatePushExperimentTaskRequest() (request *PushExperimentTaskRequest)
• type PushExperimentTaskResponse
  • func CreatePushExperimentTaskResponse() (response *PushExperimentTaskResponse)
• type Regions
• type SchedulerConfig
• type TagsInGetExperimentMeta
• type TagsInListExperimentMetas
• type TagsInPageableQueryUserExperiment
• type UpdateExperimentBasicInfoRequest
  • func CreateUpdateExperimentBasicInfoRequest() (request *UpdateExperimentBasicInfoRequest)
• type UpdateExperimentBasicInfoResponse
  • func CreateUpdateExperimentBasicInfoResponse() (response *UpdateExperimentBasicInfoResponse)
• type UpdateExperimentRequest
  • func CreateUpdateExperimentRequest() (request *UpdateExperimentRequest)
• type UpdateExperimentResponse
  • func CreateUpdateExperimentResponse() (response *UpdateExperimentResponse)
• type WorkspaceInfo
• type WorkspaceList

Variables

var EndpointMap map[string]string

EndpointMap Endpoint Data

var EndpointType = "regional"

EndpointType regional or central

Functions

func GetEndpointMap

func GetEndpointMap() map[string]string

GetEndpointMap Get Endpoint Data Map

func GetEndpointType

func GetEndpointType() string

GetEndpointType Get Endpoint Type Value

func SetClientProperty

func SetClientProperty(client *Client, propertyName string, propertyValue interface{})

SetClientProperty Set Property by Reflect

func SetEndpointDataToClient

func SetEndpointDataToClient(client *Client)

SetEndpointDataToClient Set EndpointMap and ENdpointType

Types

type Activities

type Activities struct {
	ActivitiesItem []ActivitiesItem `json:"Activities" xml:"Activities"`
}

Activities is a nested struct in ahas_openapi response

type ActivitiesItem

type ActivitiesItem struct {
	EndTime          int64  `json:"EndTime" xml:"EndTime"`
	StartTime        int64  `json:"StartTime" xml:"StartTime"`
	CheckState       string `json:"CheckState" xml:"CheckState"`
	RunResult        string `json:"RunResult" xml:"RunResult"`
	State            string `json:"State" xml:"State"`
	ActivityId       string `json:"ActivityId" xml:"ActivityId"`
	Phase            string `json:"Phase" xml:"Phase"`
	ActivityName     string `json:"ActivityName" xml:"ActivityName"`
	ExperimentTaskId string `json:"ExperimentTaskId" xml:"ExperimentTaskId"`
	TaskId           string `json:"TaskId" xml:"TaskId"`
}

ActivitiesItem is a nested struct in ahas_openapi response

type AppGroups

type AppGroups struct {
	AppGroup []string `json:"appGroup" xml:"appGroup"`
}

AppGroups is a nested struct in ahas_openapi response

type AppNameAndIdPairs

type AppNameAndIdPairs struct {
	AppNameAndIdPairsItem []AppNameAndIdPairsItem `json:"AppNameAndIdPairs" xml:"AppNameAndIdPairs"`
}

AppNameAndIdPairs is a nested struct in ahas_openapi response

type AppNameAndIdPairsItem

type AppNameAndIdPairsItem struct {
	AppName   string `json:"AppName" xml:"AppName"`
	AppId     string `json:"AppId" xml:"AppId"`
	ScopeType int    `json:"ScopeType" xml:"ScopeType"`
	AppType   int    `json:"AppType" xml:"AppType"`
}

AppNameAndIdPairsItem is a nested struct in ahas_openapi response

type CheckExperimentRunnableRequest

type CheckExperimentRunnableRequest struct {
	*requests.RpcRequest
	AhasRegionId string `position:"Query" name:"AhasRegionId"`
	NameSpace    string `position:"Query" name:"NameSpace"`
	ExperimentId string `position:"Query" name:"ExperimentId"`
}

CheckExperimentRunnableRequest is the request struct for api CheckExperimentRunnable

func CreateCheckExperimentRunnableRequest

func CreateCheckExperimentRunnableRequest() (request *CheckExperimentRunnableRequest)

CreateCheckExperimentRunnableRequest creates a request to invoke CheckExperimentRunnable API

type CheckExperimentRunnableResponse

type CheckExperimentRunnableResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
}

CheckExperimentRunnableResponse is the response struct for api CheckExperimentRunnable

func CreateCheckExperimentRunnableResponse

func CreateCheckExperimentRunnableResponse() (response *CheckExperimentRunnableResponse)

CreateCheckExperimentRunnableResponse creates a response to parse from CheckExperimentRunnable response

type Client

type Client struct {
	sdk.Client
}

Client is the sdk client struct, each func corresponds to an OpenAPI

func NewClient

func NewClient() (client *Client, err error)

NewClient creates a sdk client with environment variables

func NewClientWithAccessKey

func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error)

NewClientWithAccessKey is a shortcut to create sdk client with accesskey usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithEcsRamRole

func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error)

NewClientWithEcsRamRole is a shortcut to create sdk client with ecs ram role usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithOptions

func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error)

NewClientWithOptions creates a sdk client with regionId/sdkConfig/credential this is the common api to create a sdk client

func NewClientWithProvider

func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error)

NewClientWithProvider creates a sdk client with providers usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArn

func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArnAndPolicy

func NewClientWithRamRoleArnAndPolicy(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn and policy usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRsaKeyPair

func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error)

NewClientWithRsaKeyPair is a shortcut to create sdk client with rsa key pair usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithStsToken

func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error)

NewClientWithStsToken is a shortcut to create sdk client with sts token usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func (*Client) CheckExperimentRunnable

func (client *Client) CheckExperimentRunnable(request *CheckExperimentRunnableRequest) (response *CheckExperimentRunnableResponse, err error)

CheckExperimentRunnable invokes the ahas_openapi.CheckExperimentRunnable API synchronously

func (*Client) CheckExperimentRunnableWithCallback

func (client *Client) CheckExperimentRunnableWithCallback(request *CheckExperimentRunnableRequest, callback func(response *CheckExperimentRunnableResponse, err error)) <-chan int

CheckExperimentRunnableWithCallback invokes the ahas_openapi.CheckExperimentRunnable API asynchronously

func (*Client) CheckExperimentRunnableWithChan

func (client *Client) CheckExperimentRunnableWithChan(request *CheckExperimentRunnableRequest) (<-chan *CheckExperimentRunnableResponse, <-chan error)

CheckExperimentRunnableWithChan invokes the ahas_openapi.CheckExperimentRunnable API asynchronously

func (*Client) CreateDegradeRule

func (client *Client) CreateDegradeRule(request *CreateDegradeRuleRequest) (response *CreateDegradeRuleResponse, err error)

CreateDegradeRule invokes the ahas_openapi.CreateDegradeRule API synchronously

func (*Client) CreateDegradeRuleWithCallback

func (client *Client) CreateDegradeRuleWithCallback(request *CreateDegradeRuleRequest, callback func(response *CreateDegradeRuleResponse, err error)) <-chan int

CreateDegradeRuleWithCallback invokes the ahas_openapi.CreateDegradeRule API asynchronously

func (*Client) CreateDegradeRuleWithChan

func (client *Client) CreateDegradeRuleWithChan(request *CreateDegradeRuleRequest) (<-chan *CreateDegradeRuleResponse, <-chan error)

CreateDegradeRuleWithChan invokes the ahas_openapi.CreateDegradeRule API asynchronously

func (*Client) CreateExperiment

func (client *Client) CreateExperiment(request *CreateExperimentRequest) (response *CreateExperimentResponse, err error)

CreateExperiment invokes the ahas_openapi.CreateExperiment API synchronously

func (*Client) CreateExperimentWithCallback

func (client *Client) CreateExperimentWithCallback(request *CreateExperimentRequest, callback func(response *CreateExperimentResponse, err error)) <-chan int

CreateExperimentWithCallback invokes the ahas_openapi.CreateExperiment API asynchronously

func (*Client) CreateExperimentWithChan

func (client *Client) CreateExperimentWithChan(request *CreateExperimentRequest) (<-chan *CreateExperimentResponse, <-chan error)

CreateExperimentWithChan invokes the ahas_openapi.CreateExperiment API asynchronously

func (*Client) CreateFlowRule

func (client *Client) CreateFlowRule(request *CreateFlowRuleRequest) (response *CreateFlowRuleResponse, err error)

CreateFlowRule invokes the ahas_openapi.CreateFlowRule API synchronously

func (*Client) CreateFlowRuleWithCallback

func (client *Client) CreateFlowRuleWithCallback(request *CreateFlowRuleRequest, callback func(response *CreateFlowRuleResponse, err error)) <-chan int

CreateFlowRuleWithCallback invokes the ahas_openapi.CreateFlowRule API asynchronously

func (*Client) CreateFlowRuleWithChan

func (client *Client) CreateFlowRuleWithChan(request *CreateFlowRuleRequest) (<-chan *CreateFlowRuleResponse, <-chan error)

CreateFlowRuleWithChan invokes the ahas_openapi.CreateFlowRule API asynchronously

func (*Client) CreateHotParamItems

func (client *Client) CreateHotParamItems(request *CreateHotParamItemsRequest) (response *CreateHotParamItemsResponse, err error)

CreateHotParamItems invokes the ahas_openapi.CreateHotParamItems API synchronously

func (*Client) CreateHotParamItemsWithCallback

func (client *Client) CreateHotParamItemsWithCallback(request *CreateHotParamItemsRequest, callback func(response *CreateHotParamItemsResponse, err error)) <-chan int

CreateHotParamItemsWithCallback invokes the ahas_openapi.CreateHotParamItems API asynchronously

func (*Client) CreateHotParamItemsWithChan

func (client *Client) CreateHotParamItemsWithChan(request *CreateHotParamItemsRequest) (<-chan *CreateHotParamItemsResponse, <-chan error)

CreateHotParamItemsWithChan invokes the ahas_openapi.CreateHotParamItems API asynchronously

func (*Client) CreateHotParamRule

func (client *Client) CreateHotParamRule(request *CreateHotParamRuleRequest) (response *CreateHotParamRuleResponse, err error)

CreateHotParamRule invokes the ahas_openapi.CreateHotParamRule API synchronously

func (*Client) CreateHotParamRuleWithCallback

func (client *Client) CreateHotParamRuleWithCallback(request *CreateHotParamRuleRequest, callback func(response *CreateHotParamRuleResponse, err error)) <-chan int

CreateHotParamRuleWithCallback invokes the ahas_openapi.CreateHotParamRule API asynchronously

func (*Client) CreateHotParamRuleWithChan

func (client *Client) CreateHotParamRuleWithChan(request *CreateHotParamRuleRequest) (<-chan *CreateHotParamRuleResponse, <-chan error)

CreateHotParamRuleWithChan invokes the ahas_openapi.CreateHotParamRule API asynchronously

func (*Client) CreateIsolationRule

func (client *Client) CreateIsolationRule(request *CreateIsolationRuleRequest) (response *CreateIsolationRuleResponse, err error)

CreateIsolationRule invokes the ahas_openapi.CreateIsolationRule API synchronously

func (*Client) CreateIsolationRuleWithCallback

func (client *Client) CreateIsolationRuleWithCallback(request *CreateIsolationRuleRequest, callback func(response *CreateIsolationRuleResponse, err error)) <-chan int

CreateIsolationRuleWithCallback invokes the ahas_openapi.CreateIsolationRule API asynchronously

func (*Client) CreateIsolationRuleWithChan

func (client *Client) CreateIsolationRuleWithChan(request *CreateIsolationRuleRequest) (<-chan *CreateIsolationRuleResponse, <-chan error)

CreateIsolationRuleWithChan invokes the ahas_openapi.CreateIsolationRule API asynchronously

func (*Client) CreateSystemRule

func (client *Client) CreateSystemRule(request *CreateSystemRuleRequest) (response *CreateSystemRuleResponse, err error)

CreateSystemRule invokes the ahas_openapi.CreateSystemRule API synchronously

func (*Client) CreateSystemRuleWithCallback

func (client *Client) CreateSystemRuleWithCallback(request *CreateSystemRuleRequest, callback func(response *CreateSystemRuleResponse, err error)) <-chan int

CreateSystemRuleWithCallback invokes the ahas_openapi.CreateSystemRule API asynchronously

func (*Client) CreateSystemRuleWithChan

func (client *Client) CreateSystemRuleWithChan(request *CreateSystemRuleRequest) (<-chan *CreateSystemRuleResponse, <-chan error)

CreateSystemRuleWithChan invokes the ahas_openapi.CreateSystemRule API asynchronously

func (*Client) DeleteDegradeRule

func (client *Client) DeleteDegradeRule(request *DeleteDegradeRuleRequest) (response *DeleteDegradeRuleResponse, err error)

DeleteDegradeRule invokes the ahas_openapi.DeleteDegradeRule API synchronously

func (*Client) DeleteDegradeRuleWithCallback

func (client *Client) DeleteDegradeRuleWithCallback(request *DeleteDegradeRuleRequest, callback func(response *DeleteDegradeRuleResponse, err error)) <-chan int

DeleteDegradeRuleWithCallback invokes the ahas_openapi.DeleteDegradeRule API asynchronously

func (*Client) DeleteDegradeRuleWithChan

func (client *Client) DeleteDegradeRuleWithChan(request *DeleteDegradeRuleRequest) (<-chan *DeleteDegradeRuleResponse, <-chan error)

DeleteDegradeRuleWithChan invokes the ahas_openapi.DeleteDegradeRule API asynchronously

func (*Client) DeleteFlowRule

func (client *Client) DeleteFlowRule(request *DeleteFlowRuleRequest) (response *DeleteFlowRuleResponse, err error)

DeleteFlowRule invokes the ahas_openapi.DeleteFlowRule API synchronously

func (*Client) DeleteFlowRuleWithCallback

func (client *Client) DeleteFlowRuleWithCallback(request *DeleteFlowRuleRequest, callback func(response *DeleteFlowRuleResponse, err error)) <-chan int

DeleteFlowRuleWithCallback invokes the ahas_openapi.DeleteFlowRule API asynchronously

func (*Client) DeleteFlowRuleWithChan

func (client *Client) DeleteFlowRuleWithChan(request *DeleteFlowRuleRequest) (<-chan *DeleteFlowRuleResponse, <-chan error)

DeleteFlowRuleWithChan invokes the ahas_openapi.DeleteFlowRule API asynchronously

func (*Client) DeleteHotParamRule

func (client *Client) DeleteHotParamRule(request *DeleteHotParamRuleRequest) (response *DeleteHotParamRuleResponse, err error)

DeleteHotParamRule invokes the ahas_openapi.DeleteHotParamRule API synchronously

func (*Client) DeleteHotParamRuleWithCallback

func (client *Client) DeleteHotParamRuleWithCallback(request *DeleteHotParamRuleRequest, callback func(response *DeleteHotParamRuleResponse, err error)) <-chan int

DeleteHotParamRuleWithCallback invokes the ahas_openapi.DeleteHotParamRule API asynchronously

func (*Client) DeleteHotParamRuleWithChan

func (client *Client) DeleteHotParamRuleWithChan(request *DeleteHotParamRuleRequest) (<-chan *DeleteHotParamRuleResponse, <-chan error)

DeleteHotParamRuleWithChan invokes the ahas_openapi.DeleteHotParamRule API asynchronously

func (*Client) DeleteIsolationRule

func (client *Client) DeleteIsolationRule(request *DeleteIsolationRuleRequest) (response *DeleteIsolationRuleResponse, err error)

DeleteIsolationRule invokes the ahas_openapi.DeleteIsolationRule API synchronously

func (*Client) DeleteIsolationRuleWithCallback

func (client *Client) DeleteIsolationRuleWithCallback(request *DeleteIsolationRuleRequest, callback func(response *DeleteIsolationRuleResponse, err error)) <-chan int

DeleteIsolationRuleWithCallback invokes the ahas_openapi.DeleteIsolationRule API asynchronously

func (*Client) DeleteIsolationRuleWithChan

func (client *Client) DeleteIsolationRuleWithChan(request *DeleteIsolationRuleRequest) (<-chan *DeleteIsolationRuleResponse, <-chan error)

DeleteIsolationRuleWithChan invokes the ahas_openapi.DeleteIsolationRule API asynchronously

func (*Client) DeleteSystemRule

func (client *Client) DeleteSystemRule(request *DeleteSystemRuleRequest) (response *DeleteSystemRuleResponse, err error)

DeleteSystemRule invokes the ahas_openapi.DeleteSystemRule API synchronously

func (*Client) DeleteSystemRuleWithCallback

func (client *Client) DeleteSystemRuleWithCallback(request *DeleteSystemRuleRequest, callback func(response *DeleteSystemRuleResponse, err error)) <-chan int

DeleteSystemRuleWithCallback invokes the ahas_openapi.DeleteSystemRule API asynchronously

func (*Client) DeleteSystemRuleWithChan

func (client *Client) DeleteSystemRuleWithChan(request *DeleteSystemRuleRequest) (<-chan *DeleteSystemRuleResponse, <-chan error)

DeleteSystemRuleWithChan invokes the ahas_openapi.DeleteSystemRule API asynchronously

func (*Client) DescribeRegions

func (client *Client) DescribeRegions(request *DescribeRegionsRequest) (response *DescribeRegionsResponse, err error)

DescribeRegions invokes the ahas_openapi.DescribeRegions API synchronously

func (*Client) DescribeRegionsWithCallback

func (client *Client) DescribeRegionsWithCallback(request *DescribeRegionsRequest, callback func(response *DescribeRegionsResponse, err error)) <-chan int

DescribeRegionsWithCallback invokes the ahas_openapi.DescribeRegions API asynchronously

func (*Client) DescribeRegionsWithChan

func (client *Client) DescribeRegionsWithChan(request *DescribeRegionsRequest) (<-chan *DescribeRegionsResponse, <-chan error)

DescribeRegionsWithChan invokes the ahas_openapi.DescribeRegions API asynchronously

func (*Client) DisableDegradeRule

func (client *Client) DisableDegradeRule(request *DisableDegradeRuleRequest) (response *DisableDegradeRuleResponse, err error)

DisableDegradeRule invokes the ahas_openapi.DisableDegradeRule API synchronously

func (*Client) DisableDegradeRuleWithCallback

func (client *Client) DisableDegradeRuleWithCallback(request *DisableDegradeRuleRequest, callback func(response *DisableDegradeRuleResponse, err error)) <-chan int

DisableDegradeRuleWithCallback invokes the ahas_openapi.DisableDegradeRule API asynchronously

func (*Client) DisableDegradeRuleWithChan

func (client *Client) DisableDegradeRuleWithChan(request *DisableDegradeRuleRequest) (<-chan *DisableDegradeRuleResponse, <-chan error)

DisableDegradeRuleWithChan invokes the ahas_openapi.DisableDegradeRule API asynchronously

func (*Client) DisableFlowRule

func (client *Client) DisableFlowRule(request *DisableFlowRuleRequest) (response *DisableFlowRuleResponse, err error)

DisableFlowRule invokes the ahas_openapi.DisableFlowRule API synchronously

func (*Client) DisableFlowRuleWithCallback

func (client *Client) DisableFlowRuleWithCallback(request *DisableFlowRuleRequest, callback func(response *DisableFlowRuleResponse, err error)) <-chan int

DisableFlowRuleWithCallback invokes the ahas_openapi.DisableFlowRule API asynchronously

func (*Client) DisableFlowRuleWithChan

func (client *Client) DisableFlowRuleWithChan(request *DisableFlowRuleRequest) (<-chan *DisableFlowRuleResponse, <-chan error)

DisableFlowRuleWithChan invokes the ahas_openapi.DisableFlowRule API asynchronously

func (*Client) DisableHotParamRule

func (client *Client) DisableHotParamRule(request *DisableHotParamRuleRequest) (response *DisableHotParamRuleResponse, err error)

DisableHotParamRule invokes the ahas_openapi.DisableHotParamRule API synchronously

func (*Client) DisableHotParamRuleWithCallback

func (client *Client) DisableHotParamRuleWithCallback(request *DisableHotParamRuleRequest, callback func(response *DisableHotParamRuleResponse, err error)) <-chan int

DisableHotParamRuleWithCallback invokes the ahas_openapi.DisableHotParamRule API asynchronously

func (*Client) DisableHotParamRuleWithChan

func (client *Client) DisableHotParamRuleWithChan(request *DisableHotParamRuleRequest) (<-chan *DisableHotParamRuleResponse, <-chan error)

DisableHotParamRuleWithChan invokes the ahas_openapi.DisableHotParamRule API asynchronously

func (*Client) DisableIsolationRule

func (client *Client) DisableIsolationRule(request *DisableIsolationRuleRequest) (response *DisableIsolationRuleResponse, err error)

DisableIsolationRule invokes the ahas_openapi.DisableIsolationRule API synchronously

func (*Client) DisableIsolationRuleWithCallback

func (client *Client) DisableIsolationRuleWithCallback(request *DisableIsolationRuleRequest, callback func(response *DisableIsolationRuleResponse, err error)) <-chan int

DisableIsolationRuleWithCallback invokes the ahas_openapi.DisableIsolationRule API asynchronously

func (*Client) DisableIsolationRuleWithChan

func (client *Client) DisableIsolationRuleWithChan(request *DisableIsolationRuleRequest) (<-chan *DisableIsolationRuleResponse, <-chan error)

DisableIsolationRuleWithChan invokes the ahas_openapi.DisableIsolationRule API asynchronously

func (*Client) DisableSystemRule

func (client *Client) DisableSystemRule(request *DisableSystemRuleRequest) (response *DisableSystemRuleResponse, err error)

DisableSystemRule invokes the ahas_openapi.DisableSystemRule API synchronously

func (*Client) DisableSystemRuleWithCallback

func (client *Client) DisableSystemRuleWithCallback(request *DisableSystemRuleRequest, callback func(response *DisableSystemRuleResponse, err error)) <-chan int

DisableSystemRuleWithCallback invokes the ahas_openapi.DisableSystemRule API asynchronously

func (*Client) DisableSystemRuleWithChan

func (client *Client) DisableSystemRuleWithChan(request *DisableSystemRuleRequest) (<-chan *DisableSystemRuleResponse, <-chan error)

DisableSystemRuleWithChan invokes the ahas_openapi.DisableSystemRule API asynchronously

func (*Client) EnableDegradeRule

func (client *Client) EnableDegradeRule(request *EnableDegradeRuleRequest) (response *EnableDegradeRuleResponse, err error)

EnableDegradeRule invokes the ahas_openapi.EnableDegradeRule API synchronously

func (*Client) EnableDegradeRuleWithCallback

func (client *Client) EnableDegradeRuleWithCallback(request *EnableDegradeRuleRequest, callback func(response *EnableDegradeRuleResponse, err error)) <-chan int

EnableDegradeRuleWithCallback invokes the ahas_openapi.EnableDegradeRule API asynchronously

func (*Client) EnableDegradeRuleWithChan

func (client *Client) EnableDegradeRuleWithChan(request *EnableDegradeRuleRequest) (<-chan *EnableDegradeRuleResponse, <-chan error)

EnableDegradeRuleWithChan invokes the ahas_openapi.EnableDegradeRule API asynchronously

func (*Client) EnableFlowRule

func (client *Client) EnableFlowRule(request *EnableFlowRuleRequest) (response *EnableFlowRuleResponse, err error)

EnableFlowRule invokes the ahas_openapi.EnableFlowRule API synchronously

func (*Client) EnableFlowRuleWithCallback

func (client *Client) EnableFlowRuleWithCallback(request *EnableFlowRuleRequest, callback func(response *EnableFlowRuleResponse, err error)) <-chan int

EnableFlowRuleWithCallback invokes the ahas_openapi.EnableFlowRule API asynchronously

func (*Client) EnableFlowRuleWithChan

func (client *Client) EnableFlowRuleWithChan(request *EnableFlowRuleRequest) (<-chan *EnableFlowRuleResponse, <-chan error)

EnableFlowRuleWithChan invokes the ahas_openapi.EnableFlowRule API asynchronously

func (*Client) EnableHotParamRule

func (client *Client) EnableHotParamRule(request *EnableHotParamRuleRequest) (response *EnableHotParamRuleResponse, err error)

EnableHotParamRule invokes the ahas_openapi.EnableHotParamRule API synchronously

func (*Client) EnableHotParamRuleWithCallback

func (client *Client) EnableHotParamRuleWithCallback(request *EnableHotParamRuleRequest, callback func(response *EnableHotParamRuleResponse, err error)) <-chan int

EnableHotParamRuleWithCallback invokes the ahas_openapi.EnableHotParamRule API asynchronously

func (*Client) EnableHotParamRuleWithChan

func (client *Client) EnableHotParamRuleWithChan(request *EnableHotParamRuleRequest) (<-chan *EnableHotParamRuleResponse, <-chan error)

EnableHotParamRuleWithChan invokes the ahas_openapi.EnableHotParamRule API asynchronously

func (*Client) EnableIsolationRule

func (client *Client) EnableIsolationRule(request *EnableIsolationRuleRequest) (response *EnableIsolationRuleResponse, err error)

EnableIsolationRule invokes the ahas_openapi.EnableIsolationRule API synchronously

func (*Client) EnableIsolationRuleWithCallback

func (client *Client) EnableIsolationRuleWithCallback(request *EnableIsolationRuleRequest, callback func(response *EnableIsolationRuleResponse, err error)) <-chan int

EnableIsolationRuleWithCallback invokes the ahas_openapi.EnableIsolationRule API asynchronously

func (*Client) EnableIsolationRuleWithChan

func (client *Client) EnableIsolationRuleWithChan(request *EnableIsolationRuleRequest) (<-chan *EnableIsolationRuleResponse, <-chan error)

EnableIsolationRuleWithChan invokes the ahas_openapi.EnableIsolationRule API asynchronously

func (*Client) EnableSystemRule

func (client *Client) EnableSystemRule(request *EnableSystemRuleRequest) (response *EnableSystemRuleResponse, err error)

EnableSystemRule invokes the ahas_openapi.EnableSystemRule API synchronously

func (*Client) EnableSystemRuleWithCallback

func (client *Client) EnableSystemRuleWithCallback(request *EnableSystemRuleRequest, callback func(response *EnableSystemRuleResponse, err error)) <-chan int

EnableSystemRuleWithCallback invokes the ahas_openapi.EnableSystemRule API asynchronously

func (*Client) EnableSystemRuleWithChan

func (client *Client) EnableSystemRuleWithChan(request *EnableSystemRuleRequest) (<-chan *EnableSystemRuleResponse, <-chan error)

EnableSystemRuleWithChan invokes the ahas_openapi.EnableSystemRule API asynchronously

func (*Client) ExecuteExperiment

func (client *Client) ExecuteExperiment(request *ExecuteExperimentRequest) (response *ExecuteExperimentResponse, err error)

ExecuteExperiment invokes the ahas_openapi.ExecuteExperiment API synchronously

func (*Client) ExecuteExperimentWithCallback

func (client *Client) ExecuteExperimentWithCallback(request *ExecuteExperimentRequest, callback func(response *ExecuteExperimentResponse, err error)) <-chan int

ExecuteExperimentWithCallback invokes the ahas_openapi.ExecuteExperiment API asynchronously

func (*Client) ExecuteExperimentWithChan

func (client *Client) ExecuteExperimentWithChan(request *ExecuteExperimentRequest) (<-chan *ExecuteExperimentResponse, <-chan error)

ExecuteExperimentWithChan invokes the ahas_openapi.ExecuteExperiment API asynchronously

func (*Client) FinishExperimentTask

func (client *Client) FinishExperimentTask(request *FinishExperimentTaskRequest) (response *FinishExperimentTaskResponse, err error)

FinishExperimentTask invokes the ahas_openapi.FinishExperimentTask API synchronously

func (*Client) FinishExperimentTaskWithCallback

func (client *Client) FinishExperimentTaskWithCallback(request *FinishExperimentTaskRequest, callback func(response *FinishExperimentTaskResponse, err error)) <-chan int

FinishExperimentTaskWithCallback invokes the ahas_openapi.FinishExperimentTask API asynchronously

func (*Client) FinishExperimentTaskWithChan

func (client *Client) FinishExperimentTaskWithChan(request *FinishExperimentTaskRequest) (<-chan *FinishExperimentTaskResponse, <-chan error)

FinishExperimentTaskWithChan invokes the ahas_openapi.FinishExperimentTask API asynchronously

func (*Client) GetActivityTask

func (client *Client) GetActivityTask(request *GetActivityTaskRequest) (response *GetActivityTaskResponse, err error)

GetActivityTask invokes the ahas_openapi.GetActivityTask API synchronously

func (*Client) GetActivityTaskWithCallback

func (client *Client) GetActivityTaskWithCallback(request *GetActivityTaskRequest, callback func(response *GetActivityTaskResponse, err error)) <-chan int

GetActivityTaskWithCallback invokes the ahas_openapi.GetActivityTask API asynchronously

func (*Client) GetActivityTaskWithChan

func (client *Client) GetActivityTaskWithChan(request *GetActivityTaskRequest) (<-chan *GetActivityTaskResponse, <-chan error)

GetActivityTaskWithChan invokes the ahas_openapi.GetActivityTask API asynchronously

func (*Client) GetExperimentMeta

func (client *Client) GetExperimentMeta(request *GetExperimentMetaRequest) (response *GetExperimentMetaResponse, err error)

GetExperimentMeta invokes the ahas_openapi.GetExperimentMeta API synchronously

func (*Client) GetExperimentMetaWithCallback

func (client *Client) GetExperimentMetaWithCallback(request *GetExperimentMetaRequest, callback func(response *GetExperimentMetaResponse, err error)) <-chan int

GetExperimentMetaWithCallback invokes the ahas_openapi.GetExperimentMeta API asynchronously

func (*Client) GetExperimentMetaWithChan

func (client *Client) GetExperimentMetaWithChan(request *GetExperimentMetaRequest) (<-chan *GetExperimentMetaResponse, <-chan error)

GetExperimentMetaWithChan invokes the ahas_openapi.GetExperimentMeta API asynchronously

func (*Client) GetExperimentTask

func (client *Client) GetExperimentTask(request *GetExperimentTaskRequest) (response *GetExperimentTaskResponse, err error)

GetExperimentTask invokes the ahas_openapi.GetExperimentTask API synchronously

func (*Client) GetExperimentTaskWithCallback

func (client *Client) GetExperimentTaskWithCallback(request *GetExperimentTaskRequest, callback func(response *GetExperimentTaskResponse, err error)) <-chan int

GetExperimentTaskWithCallback invokes the ahas_openapi.GetExperimentTask API asynchronously

func (*Client) GetExperimentTaskWithChan

func (client *Client) GetExperimentTaskWithChan(request *GetExperimentTaskRequest) (<-chan *GetExperimentTaskResponse, <-chan error)

GetExperimentTaskWithChan invokes the ahas_openapi.GetExperimentTask API asynchronously

func (*Client) GetLicenseKey

func (client *Client) GetLicenseKey(request *GetLicenseKeyRequest) (response *GetLicenseKeyResponse, err error)

GetLicenseKey invokes the ahas_openapi.GetLicenseKey API synchronously

func (*Client) GetLicenseKeyWithCallback

func (client *Client) GetLicenseKeyWithCallback(request *GetLicenseKeyRequest, callback func(response *GetLicenseKeyResponse, err error)) <-chan int

GetLicenseKeyWithCallback invokes the ahas_openapi.GetLicenseKey API asynchronously

func (*Client) GetLicenseKeyWithChan

func (client *Client) GetLicenseKeyWithChan(request *GetLicenseKeyRequest) (<-chan *GetLicenseKeyResponse, <-chan error)

GetLicenseKeyWithChan invokes the ahas_openapi.GetLicenseKey API asynchronously

func (*Client) GetMetricsOfApp

func (client *Client) GetMetricsOfApp(request *GetMetricsOfAppRequest) (response *GetMetricsOfAppResponse, err error)

GetMetricsOfApp invokes the ahas_openapi.GetMetricsOfApp API synchronously

func (*Client) GetMetricsOfAppWithCallback

func (client *Client) GetMetricsOfAppWithCallback(request *GetMetricsOfAppRequest, callback func(response *GetMetricsOfAppResponse, err error)) <-chan int

GetMetricsOfAppWithCallback invokes the ahas_openapi.GetMetricsOfApp API asynchronously

func (*Client) GetMetricsOfAppWithChan

func (client *Client) GetMetricsOfAppWithChan(request *GetMetricsOfAppRequest) (<-chan *GetMetricsOfAppResponse, <-chan error)

GetMetricsOfAppWithChan invokes the ahas_openapi.GetMetricsOfApp API asynchronously

func (*Client) GetMetricsOfResource

func (client *Client) GetMetricsOfResource(request *GetMetricsOfResourceRequest) (response *GetMetricsOfResourceResponse, err error)

GetMetricsOfResource invokes the ahas_openapi.GetMetricsOfResource API synchronously

func (*Client) GetMetricsOfResourceWithCallback

func (client *Client) GetMetricsOfResourceWithCallback(request *GetMetricsOfResourceRequest, callback func(response *GetMetricsOfResourceResponse, err error)) <-chan int

GetMetricsOfResourceWithCallback invokes the ahas_openapi.GetMetricsOfResource API asynchronously

func (*Client) GetMetricsOfResourceWithChan

func (client *Client) GetMetricsOfResourceWithChan(request *GetMetricsOfResourceRequest) (<-chan *GetMetricsOfResourceResponse, <-chan error)

GetMetricsOfResourceWithChan invokes the ahas_openapi.GetMetricsOfResource API asynchronously

func (*Client) GetSentinelAppSumMetric

func (client *Client) GetSentinelAppSumMetric(request *GetSentinelAppSumMetricRequest) (response *GetSentinelAppSumMetricResponse, err error)

GetSentinelAppSumMetric invokes the ahas_openapi.GetSentinelAppSumMetric API synchronously

func (*Client) GetSentinelAppSumMetricWithCallback

func (client *Client) GetSentinelAppSumMetricWithCallback(request *GetSentinelAppSumMetricRequest, callback func(response *GetSentinelAppSumMetricResponse, err error)) <-chan int

GetSentinelAppSumMetricWithCallback invokes the ahas_openapi.GetSentinelAppSumMetric API asynchronously

func (*Client) GetSentinelAppSumMetricWithChan

func (client *Client) GetSentinelAppSumMetricWithChan(request *GetSentinelAppSumMetricRequest) (<-chan *GetSentinelAppSumMetricResponse, <-chan error)

GetSentinelAppSumMetricWithChan invokes the ahas_openapi.GetSentinelAppSumMetric API asynchronously

func (*Client) GetUserApplicationGroups

func (client *Client) GetUserApplicationGroups(request *GetUserApplicationGroupsRequest) (response *GetUserApplicationGroupsResponse, err error)

GetUserApplicationGroups invokes the ahas_openapi.GetUserApplicationGroups API synchronously

func (*Client) GetUserApplicationGroupsWithCallback

func (client *Client) GetUserApplicationGroupsWithCallback(request *GetUserApplicationGroupsRequest, callback func(response *GetUserApplicationGroupsResponse, err error)) <-chan int

GetUserApplicationGroupsWithCallback invokes the ahas_openapi.GetUserApplicationGroups API asynchronously

func (*Client) GetUserApplicationGroupsWithChan

func (client *Client) GetUserApplicationGroupsWithChan(request *GetUserApplicationGroupsRequest) (<-chan *GetUserApplicationGroupsResponse, <-chan error)

GetUserApplicationGroupsWithChan invokes the ahas_openapi.GetUserApplicationGroups API asynchronously

func (*Client) GetUserApplications

func (client *Client) GetUserApplications(request *GetUserApplicationsRequest) (response *GetUserApplicationsResponse, err error)

GetUserApplications invokes the ahas_openapi.GetUserApplications API synchronously

func (*Client) GetUserApplicationsWithCallback

func (client *Client) GetUserApplicationsWithCallback(request *GetUserApplicationsRequest, callback func(response *GetUserApplicationsResponse, err error)) <-chan int

GetUserApplicationsWithCallback invokes the ahas_openapi.GetUserApplications API asynchronously

func (*Client) GetUserApplicationsWithChan

func (client *Client) GetUserApplicationsWithChan(request *GetUserApplicationsRequest) (<-chan *GetUserApplicationsResponse, <-chan error)

GetUserApplicationsWithChan invokes the ahas_openapi.GetUserApplications API asynchronously

func (*Client) GetUserWorkspace

func (client *Client) GetUserWorkspace(request *GetUserWorkspaceRequest) (response *GetUserWorkspaceResponse, err error)

GetUserWorkspace invokes the ahas_openapi.GetUserWorkspace API synchronously

func (*Client) GetUserWorkspaceWithCallback

func (client *Client) GetUserWorkspaceWithCallback(request *GetUserWorkspaceRequest, callback func(response *GetUserWorkspaceResponse, err error)) <-chan int

GetUserWorkspaceWithCallback invokes the ahas_openapi.GetUserWorkspace API asynchronously

func (*Client) GetUserWorkspaceWithChan

func (client *Client) GetUserWorkspaceWithChan(request *GetUserWorkspaceRequest) (<-chan *GetUserWorkspaceResponse, <-chan error)

GetUserWorkspaceWithChan invokes the ahas_openapi.GetUserWorkspace API asynchronously

func (*Client) ListActiveApps

func (client *Client) ListActiveApps(request *ListActiveAppsRequest) (response *ListActiveAppsResponse, err error)

ListActiveApps invokes the ahas_openapi.ListActiveApps API synchronously

func (*Client) ListActiveAppsWithCallback

func (client *Client) ListActiveAppsWithCallback(request *ListActiveAppsRequest, callback func(response *ListActiveAppsResponse, err error)) <-chan int

ListActiveAppsWithCallback invokes the ahas_openapi.ListActiveApps API asynchronously

func (*Client) ListActiveAppsWithChan

func (client *Client) ListActiveAppsWithChan(request *ListActiveAppsRequest) (<-chan *ListActiveAppsResponse, <-chan error)

ListActiveAppsWithChan invokes the ahas_openapi.ListActiveApps API asynchronously

func (*Client) ListDegradeRulesOfApp

func (client *Client) ListDegradeRulesOfApp(request *ListDegradeRulesOfAppRequest) (response *ListDegradeRulesOfAppResponse, err error)

ListDegradeRulesOfApp invokes the ahas_openapi.ListDegradeRulesOfApp API synchronously

func (*Client) ListDegradeRulesOfAppWithCallback

func (client *Client) ListDegradeRulesOfAppWithCallback(request *ListDegradeRulesOfAppRequest, callback func(response *ListDegradeRulesOfAppResponse, err error)) <-chan int

ListDegradeRulesOfAppWithCallback invokes the ahas_openapi.ListDegradeRulesOfApp API asynchronously

func (*Client) ListDegradeRulesOfAppWithChan

func (client *Client) ListDegradeRulesOfAppWithChan(request *ListDegradeRulesOfAppRequest) (<-chan *ListDegradeRulesOfAppResponse, <-chan error)

ListDegradeRulesOfAppWithChan invokes the ahas_openapi.ListDegradeRulesOfApp API asynchronously

func (*Client) ListDegradeRulesOfResource

func (client *Client) ListDegradeRulesOfResource(request *ListDegradeRulesOfResourceRequest) (response *ListDegradeRulesOfResourceResponse, err error)

ListDegradeRulesOfResource invokes the ahas_openapi.ListDegradeRulesOfResource API synchronously

func (*Client) ListDegradeRulesOfResourceWithCallback

func (client *Client) ListDegradeRulesOfResourceWithCallback(request *ListDegradeRulesOfResourceRequest, callback func(response *ListDegradeRulesOfResourceResponse, err error)) <-chan int

ListDegradeRulesOfResourceWithCallback invokes the ahas_openapi.ListDegradeRulesOfResource API asynchronously

func (*Client) ListDegradeRulesOfResourceWithChan

func (client *Client) ListDegradeRulesOfResourceWithChan(request *ListDegradeRulesOfResourceRequest) (<-chan *ListDegradeRulesOfResourceResponse, <-chan error)

ListDegradeRulesOfResourceWithChan invokes the ahas_openapi.ListDegradeRulesOfResource API asynchronously

func (*Client) ListExperimentMetas

func (client *Client) ListExperimentMetas(request *ListExperimentMetasRequest) (response *ListExperimentMetasResponse, err error)

ListExperimentMetas invokes the ahas_openapi.ListExperimentMetas API synchronously

func (*Client) ListExperimentMetasWithCallback

func (client *Client) ListExperimentMetasWithCallback(request *ListExperimentMetasRequest, callback func(response *ListExperimentMetasResponse, err error)) <-chan int

ListExperimentMetasWithCallback invokes the ahas_openapi.ListExperimentMetas API asynchronously

func (*Client) ListExperimentMetasWithChan

func (client *Client) ListExperimentMetasWithChan(request *ListExperimentMetasRequest) (<-chan *ListExperimentMetasResponse, <-chan error)

ListExperimentMetasWithChan invokes the ahas_openapi.ListExperimentMetas API asynchronously

func (*Client) ListFlowRulesOfApp

func (client *Client) ListFlowRulesOfApp(request *ListFlowRulesOfAppRequest) (response *ListFlowRulesOfAppResponse, err error)

ListFlowRulesOfApp invokes the ahas_openapi.ListFlowRulesOfApp API synchronously

func (*Client) ListFlowRulesOfAppWithCallback

func (client *Client) ListFlowRulesOfAppWithCallback(request *ListFlowRulesOfAppRequest, callback func(response *ListFlowRulesOfAppResponse, err error)) <-chan int

ListFlowRulesOfAppWithCallback invokes the ahas_openapi.ListFlowRulesOfApp API asynchronously

func (*Client) ListFlowRulesOfAppWithChan

func (client *Client) ListFlowRulesOfAppWithChan(request *ListFlowRulesOfAppRequest) (<-chan *ListFlowRulesOfAppResponse, <-chan error)

ListFlowRulesOfAppWithChan invokes the ahas_openapi.ListFlowRulesOfApp API asynchronously

func (*Client) ListFlowRulesOfResource

func (client *Client) ListFlowRulesOfResource(request *ListFlowRulesOfResourceRequest) (response *ListFlowRulesOfResourceResponse, err error)

ListFlowRulesOfResource invokes the ahas_openapi.ListFlowRulesOfResource API synchronously

func (*Client) ListFlowRulesOfResourceWithCallback

func (client *Client) ListFlowRulesOfResourceWithCallback(request *ListFlowRulesOfResourceRequest, callback func(response *ListFlowRulesOfResourceResponse, err error)) <-chan int

ListFlowRulesOfResourceWithCallback invokes the ahas_openapi.ListFlowRulesOfResource API asynchronously

func (*Client) ListFlowRulesOfResourceWithChan

func (client *Client) ListFlowRulesOfResourceWithChan(request *ListFlowRulesOfResourceRequest) (<-chan *ListFlowRulesOfResourceResponse, <-chan error)

ListFlowRulesOfResourceWithChan invokes the ahas_openapi.ListFlowRulesOfResource API asynchronously

func (*Client) ListHotParamRulesOfApp

func (client *Client) ListHotParamRulesOfApp(request *ListHotParamRulesOfAppRequest) (response *ListHotParamRulesOfAppResponse, err error)

ListHotParamRulesOfApp invokes the ahas_openapi.ListHotParamRulesOfApp API synchronously

func (*Client) ListHotParamRulesOfAppWithCallback

func (client *Client) ListHotParamRulesOfAppWithCallback(request *ListHotParamRulesOfAppRequest, callback func(response *ListHotParamRulesOfAppResponse, err error)) <-chan int

ListHotParamRulesOfAppWithCallback invokes the ahas_openapi.ListHotParamRulesOfApp API asynchronously

func (*Client) ListHotParamRulesOfAppWithChan

func (client *Client) ListHotParamRulesOfAppWithChan(request *ListHotParamRulesOfAppRequest) (<-chan *ListHotParamRulesOfAppResponse, <-chan error)

ListHotParamRulesOfAppWithChan invokes the ahas_openapi.ListHotParamRulesOfApp API asynchronously

func (*Client) ListHotParamRulesOfResource

func (client *Client) ListHotParamRulesOfResource(request *ListHotParamRulesOfResourceRequest) (response *ListHotParamRulesOfResourceResponse, err error)

ListHotParamRulesOfResource invokes the ahas_openapi.ListHotParamRulesOfResource API synchronously

func (*Client) ListHotParamRulesOfResourceWithCallback

func (client *Client) ListHotParamRulesOfResourceWithCallback(request *ListHotParamRulesOfResourceRequest, callback func(response *ListHotParamRulesOfResourceResponse, err error)) <-chan int

ListHotParamRulesOfResourceWithCallback invokes the ahas_openapi.ListHotParamRulesOfResource API asynchronously

func (*Client) ListHotParamRulesOfResourceWithChan

func (client *Client) ListHotParamRulesOfResourceWithChan(request *ListHotParamRulesOfResourceRequest) (<-chan *ListHotParamRulesOfResourceResponse, <-chan error)

ListHotParamRulesOfResourceWithChan invokes the ahas_openapi.ListHotParamRulesOfResource API asynchronously

func (*Client) ListIsolationRulesOfApp

func (client *Client) ListIsolationRulesOfApp(request *ListIsolationRulesOfAppRequest) (response *ListIsolationRulesOfAppResponse, err error)

ListIsolationRulesOfApp invokes the ahas_openapi.ListIsolationRulesOfApp API synchronously

func (*Client) ListIsolationRulesOfAppWithCallback

func (client *Client) ListIsolationRulesOfAppWithCallback(request *ListIsolationRulesOfAppRequest, callback func(response *ListIsolationRulesOfAppResponse, err error)) <-chan int

ListIsolationRulesOfAppWithCallback invokes the ahas_openapi.ListIsolationRulesOfApp API asynchronously

func (*Client) ListIsolationRulesOfAppWithChan

func (client *Client) ListIsolationRulesOfAppWithChan(request *ListIsolationRulesOfAppRequest) (<-chan *ListIsolationRulesOfAppResponse, <-chan error)

ListIsolationRulesOfAppWithChan invokes the ahas_openapi.ListIsolationRulesOfApp API asynchronously

func (*Client) ListIsolationRulesOfResource

func (client *Client) ListIsolationRulesOfResource(request *ListIsolationRulesOfResourceRequest) (response *ListIsolationRulesOfResourceResponse, err error)

ListIsolationRulesOfResource invokes the ahas_openapi.ListIsolationRulesOfResource API synchronously

func (*Client) ListIsolationRulesOfResourceWithCallback

func (client *Client) ListIsolationRulesOfResourceWithCallback(request *ListIsolationRulesOfResourceRequest, callback func(response *ListIsolationRulesOfResourceResponse, err error)) <-chan int

ListIsolationRulesOfResourceWithCallback invokes the ahas_openapi.ListIsolationRulesOfResource API asynchronously

func (*Client) ListIsolationRulesOfResourceWithChan

func (client *Client) ListIsolationRulesOfResourceWithChan(request *ListIsolationRulesOfResourceRequest) (<-chan *ListIsolationRulesOfResourceResponse, <-chan error)

ListIsolationRulesOfResourceWithChan invokes the ahas_openapi.ListIsolationRulesOfResource API asynchronously

func (*Client) ListSystemRules

func (client *Client) ListSystemRules(request *ListSystemRulesRequest) (response *ListSystemRulesResponse, err error)

ListSystemRules invokes the ahas_openapi.ListSystemRules API synchronously

func (*Client) ListSystemRulesWithCallback

func (client *Client) ListSystemRulesWithCallback(request *ListSystemRulesRequest, callback func(response *ListSystemRulesResponse, err error)) <-chan int

ListSystemRulesWithCallback invokes the ahas_openapi.ListSystemRules API asynchronously

func (*Client) ListSystemRulesWithChan

func (client *Client) ListSystemRulesWithChan(request *ListSystemRulesRequest) (<-chan *ListSystemRulesResponse, <-chan error)

ListSystemRulesWithChan invokes the ahas_openapi.ListSystemRules API asynchronously

func (*Client) ModifyDegradeRule

func (client *Client) ModifyDegradeRule(request *ModifyDegradeRuleRequest) (response *ModifyDegradeRuleResponse, err error)

ModifyDegradeRule invokes the ahas_openapi.ModifyDegradeRule API synchronously

func (*Client) ModifyDegradeRuleWithCallback

func (client *Client) ModifyDegradeRuleWithCallback(request *ModifyDegradeRuleRequest, callback func(response *ModifyDegradeRuleResponse, err error)) <-chan int

ModifyDegradeRuleWithCallback invokes the ahas_openapi.ModifyDegradeRule API asynchronously

func (*Client) ModifyDegradeRuleWithChan

func (client *Client) ModifyDegradeRuleWithChan(request *ModifyDegradeRuleRequest) (<-chan *ModifyDegradeRuleResponse, <-chan error)

ModifyDegradeRuleWithChan invokes the ahas_openapi.ModifyDegradeRule API asynchronously

func (*Client) ModifyFlowRule

func (client *Client) ModifyFlowRule(request *ModifyFlowRuleRequest) (response *ModifyFlowRuleResponse, err error)

ModifyFlowRule invokes the ahas_openapi.ModifyFlowRule API synchronously

func (*Client) ModifyFlowRuleWithCallback

func (client *Client) ModifyFlowRuleWithCallback(request *ModifyFlowRuleRequest, callback func(response *ModifyFlowRuleResponse, err error)) <-chan int

ModifyFlowRuleWithCallback invokes the ahas_openapi.ModifyFlowRule API asynchronously

func (*Client) ModifyFlowRuleWithChan

func (client *Client) ModifyFlowRuleWithChan(request *ModifyFlowRuleRequest) (<-chan *ModifyFlowRuleResponse, <-chan error)

ModifyFlowRuleWithChan invokes the ahas_openapi.ModifyFlowRule API asynchronously

func (*Client) ModifyHotParamRule

func (client *Client) ModifyHotParamRule(request *ModifyHotParamRuleRequest) (response *ModifyHotParamRuleResponse, err error)

ModifyHotParamRule invokes the ahas_openapi.ModifyHotParamRule API synchronously

func (*Client) ModifyHotParamRuleWithCallback

func (client *Client) ModifyHotParamRuleWithCallback(request *ModifyHotParamRuleRequest, callback func(response *ModifyHotParamRuleResponse, err error)) <-chan int

ModifyHotParamRuleWithCallback invokes the ahas_openapi.ModifyHotParamRule API asynchronously

func (*Client) ModifyHotParamRuleWithChan

func (client *Client) ModifyHotParamRuleWithChan(request *ModifyHotParamRuleRequest) (<-chan *ModifyHotParamRuleResponse, <-chan error)

ModifyHotParamRuleWithChan invokes the ahas_openapi.ModifyHotParamRule API asynchronously

func (*Client) ModifyIsolationRule

func (client *Client) ModifyIsolationRule(request *ModifyIsolationRuleRequest) (response *ModifyIsolationRuleResponse, err error)

ModifyIsolationRule invokes the ahas_openapi.ModifyIsolationRule API synchronously

func (*Client) ModifyIsolationRuleWithCallback

func (client *Client) ModifyIsolationRuleWithCallback(request *ModifyIsolationRuleRequest, callback func(response *ModifyIsolationRuleResponse, err error)) <-chan int

ModifyIsolationRuleWithCallback invokes the ahas_openapi.ModifyIsolationRule API asynchronously

func (*Client) ModifyIsolationRuleWithChan

func (client *Client) ModifyIsolationRuleWithChan(request *ModifyIsolationRuleRequest) (<-chan *ModifyIsolationRuleResponse, <-chan error)

ModifyIsolationRuleWithChan invokes the ahas_openapi.ModifyIsolationRule API asynchronously

func (*Client) ModifySystemRule

func (client *Client) ModifySystemRule(request *ModifySystemRuleRequest) (response *ModifySystemRuleResponse, err error)

ModifySystemRule invokes the ahas_openapi.ModifySystemRule API synchronously

func (*Client) ModifySystemRuleWithCallback

func (client *Client) ModifySystemRuleWithCallback(request *ModifySystemRuleRequest, callback func(response *ModifySystemRuleResponse, err error)) <-chan int

ModifySystemRuleWithCallback invokes the ahas_openapi.ModifySystemRule API asynchronously

func (*Client) ModifySystemRuleWithChan

func (client *Client) ModifySystemRuleWithChan(request *ModifySystemRuleRequest) (<-chan *ModifySystemRuleResponse, <-chan error)

ModifySystemRuleWithChan invokes the ahas_openapi.ModifySystemRule API asynchronously

func (*Client) OpenAhasService

func (client *Client) OpenAhasService(request *OpenAhasServiceRequest) (response *OpenAhasServiceResponse, err error)

OpenAhasService invokes the ahas_openapi.OpenAhasService API synchronously

func (*Client) OpenAhasServiceWithCallback

func (client *Client) OpenAhasServiceWithCallback(request *OpenAhasServiceRequest, callback func(response *OpenAhasServiceResponse, err error)) <-chan int

OpenAhasServiceWithCallback invokes the ahas_openapi.OpenAhasService API asynchronously

func (*Client) OpenAhasServiceWithChan

func (client *Client) OpenAhasServiceWithChan(request *OpenAhasServiceRequest) (<-chan *OpenAhasServiceResponse, <-chan error)

OpenAhasServiceWithChan invokes the ahas_openapi.OpenAhasService API asynchronously

func (*Client) PageableQueryExperimentTaskByClusterId

func (client *Client) PageableQueryExperimentTaskByClusterId(request *PageableQueryExperimentTaskByClusterIdRequest) (response *PageableQueryExperimentTaskByClusterIdResponse, err error)

PageableQueryExperimentTaskByClusterId invokes the ahas_openapi.PageableQueryExperimentTaskByClusterId API synchronously

func (*Client) PageableQueryExperimentTaskByClusterIdWithCallback

func (client *Client) PageableQueryExperimentTaskByClusterIdWithCallback(request *PageableQueryExperimentTaskByClusterIdRequest, callback func(response *PageableQueryExperimentTaskByClusterIdResponse, err error)) <-chan int

PageableQueryExperimentTaskByClusterIdWithCallback invokes the ahas_openapi.PageableQueryExperimentTaskByClusterId API asynchronously

func (*Client) PageableQueryExperimentTaskByClusterIdWithChan

func (client *Client) PageableQueryExperimentTaskByClusterIdWithChan(request *PageableQueryExperimentTaskByClusterIdRequest) (<-chan *PageableQueryExperimentTaskByClusterIdResponse, <-chan error)

PageableQueryExperimentTaskByClusterIdWithChan invokes the ahas_openapi.PageableQueryExperimentTaskByClusterId API asynchronously

func (*Client) PageableQueryExperimentTaskByExperimentId

func (client *Client) PageableQueryExperimentTaskByExperimentId(request *PageableQueryExperimentTaskByExperimentIdRequest) (response *PageableQueryExperimentTaskByExperimentIdResponse, err error)

PageableQueryExperimentTaskByExperimentId invokes the ahas_openapi.PageableQueryExperimentTaskByExperimentId API synchronously

func (*Client) PageableQueryExperimentTaskByExperimentIdWithCallback

func (client *Client) PageableQueryExperimentTaskByExperimentIdWithCallback(request *PageableQueryExperimentTaskByExperimentIdRequest, callback func(response *PageableQueryExperimentTaskByExperimentIdResponse, err error)) <-chan int

PageableQueryExperimentTaskByExperimentIdWithCallback invokes the ahas_openapi.PageableQueryExperimentTaskByExperimentId API asynchronously

func (*Client) PageableQueryExperimentTaskByExperimentIdWithChan

func (client *Client) PageableQueryExperimentTaskByExperimentIdWithChan(request *PageableQueryExperimentTaskByExperimentIdRequest) (<-chan *PageableQueryExperimentTaskByExperimentIdResponse, <-chan error)

PageableQueryExperimentTaskByExperimentIdWithChan invokes the ahas_openapi.PageableQueryExperimentTaskByExperimentId API asynchronously

func (*Client) PageableQueryUserExperiment

func (client *Client) PageableQueryUserExperiment(request *PageableQueryUserExperimentRequest) (response *PageableQueryUserExperimentResponse, err error)

PageableQueryUserExperiment invokes the ahas_openapi.PageableQueryUserExperiment API synchronously

func (*Client) PageableQueryUserExperimentWithCallback

func (client *Client) PageableQueryUserExperimentWithCallback(request *PageableQueryUserExperimentRequest, callback func(response *PageableQueryUserExperimentResponse, err error)) <-chan int

PageableQueryUserExperimentWithCallback invokes the ahas_openapi.PageableQueryUserExperiment API asynchronously

func (*Client) PageableQueryUserExperimentWithChan

func (client *Client) PageableQueryUserExperimentWithChan(request *PageableQueryUserExperimentRequest) (<-chan *PageableQueryUserExperimentResponse, <-chan error)

PageableQueryUserExperimentWithChan invokes the ahas_openapi.PageableQueryUserExperiment API asynchronously

func (*Client) PushExperimentTask

func (client *Client) PushExperimentTask(request *PushExperimentTaskRequest) (response *PushExperimentTaskResponse, err error)

PushExperimentTask invokes the ahas_openapi.PushExperimentTask API synchronously

func (*Client) PushExperimentTaskWithCallback

func (client *Client) PushExperimentTaskWithCallback(request *PushExperimentTaskRequest, callback func(response *PushExperimentTaskResponse, err error)) <-chan int

PushExperimentTaskWithCallback invokes the ahas_openapi.PushExperimentTask API asynchronously

func (*Client) PushExperimentTaskWithChan

func (client *Client) PushExperimentTaskWithChan(request *PushExperimentTaskRequest) (<-chan *PushExperimentTaskResponse, <-chan error)

PushExperimentTaskWithChan invokes the ahas_openapi.PushExperimentTask API asynchronously

func (*Client) UpdateExperiment

func (client *Client) UpdateExperiment(request *UpdateExperimentRequest) (response *UpdateExperimentResponse, err error)

UpdateExperiment invokes the ahas_openapi.UpdateExperiment API synchronously

func (*Client) UpdateExperimentBasicInfo

func (client *Client) UpdateExperimentBasicInfo(request *UpdateExperimentBasicInfoRequest) (response *UpdateExperimentBasicInfoResponse, err error)

UpdateExperimentBasicInfo invokes the ahas_openapi.UpdateExperimentBasicInfo API synchronously

func (*Client) UpdateExperimentBasicInfoWithCallback

func (client *Client) UpdateExperimentBasicInfoWithCallback(request *UpdateExperimentBasicInfoRequest, callback func(response *UpdateExperimentBasicInfoResponse, err error)) <-chan int

UpdateExperimentBasicInfoWithCallback invokes the ahas_openapi.UpdateExperimentBasicInfo API asynchronously

func (*Client) UpdateExperimentBasicInfoWithChan

func (client *Client) UpdateExperimentBasicInfoWithChan(request *UpdateExperimentBasicInfoRequest) (<-chan *UpdateExperimentBasicInfoResponse, <-chan error)

UpdateExperimentBasicInfoWithChan invokes the ahas_openapi.UpdateExperimentBasicInfo API asynchronously

func (*Client) UpdateExperimentWithCallback

func (client *Client) UpdateExperimentWithCallback(request *UpdateExperimentRequest, callback func(response *UpdateExperimentResponse, err error)) <-chan int

UpdateExperimentWithCallback invokes the ahas_openapi.UpdateExperiment API asynchronously

func (*Client) UpdateExperimentWithChan

func (client *Client) UpdateExperimentWithChan(request *UpdateExperimentRequest) (<-chan *UpdateExperimentResponse, <-chan error)

UpdateExperimentWithChan invokes the ahas_openapi.UpdateExperiment API asynchronously

type Content

type Content struct {
	ContentItem []ContentItem `json:"Content" xml:"Content"`
}

Content is a nested struct in ahas_openapi response

type ContentItem

type ContentItem struct {
	State        string   `json:"State" xml:"State"`
	CreateTime   int64    `json:"CreateTime" xml:"CreateTime"`
	ExperimentId string   `json:"ExperimentId" xml:"ExperimentId"`
	Name         string   `json:"Name" xml:"Name"`
	Tags         []string `json:"Tags" xml:"Tags"`
}

ContentItem is a nested struct in ahas_openapi response

type CreateDegradeRuleRequest

type CreateDegradeRuleRequest struct {
	*requests.RpcRequest
	RecoveryTimeoutMs         requests.Integer `position:"Query" name:"RecoveryTimeoutMs"`
	Threshold                 requests.Float   `position:"Query" name:"Threshold"`
	AhasRegionId              string           `position:"Query" name:"AhasRegionId"`
	HalfOpenBaseAmountPerStep requests.Integer `position:"Query" name:"HalfOpenBaseAmountPerStep"`
	AppName                   string           `position:"Query" name:"AppName"`
	Enable                    requests.Boolean `position:"Query" name:"Enable"`
	StatDurationMs            requests.Integer `position:"Query" name:"StatDurationMs"`
	MinRequestAmount          requests.Integer `position:"Query" name:"MinRequestAmount"`
	SlowRtMs                  requests.Integer `position:"Query" name:"SlowRtMs"`
	Resource                  string           `position:"Query" name:"Resource"`
	Namespace                 string           `position:"Query" name:"Namespace"`
	HalfOpenRecoveryStepNum   requests.Integer `position:"Query" name:"HalfOpenRecoveryStepNum"`
	Strategy                  requests.Integer `position:"Query" name:"Strategy"`
}

CreateDegradeRuleRequest is the request struct for api CreateDegradeRule

func CreateCreateDegradeRuleRequest

func CreateCreateDegradeRuleRequest() (request *CreateDegradeRuleRequest)

CreateCreateDegradeRuleRequest creates a request to invoke CreateDegradeRule API

type CreateDegradeRuleResponse

type CreateDegradeRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateDegradeRuleResponse is the response struct for api CreateDegradeRule

func CreateCreateDegradeRuleResponse

func CreateCreateDegradeRuleResponse() (response *CreateDegradeRuleResponse)

CreateCreateDegradeRuleResponse creates a response to parse from CreateDegradeRule response

type CreateExperimentRequest

type CreateExperimentRequest struct {
	*requests.RpcRequest
	Description  string    `position:"Query" name:"Description"`
	AhasRegionId string    `position:"Query" name:"AhasRegionId"`
	Tags         *[]string `position:"Query" name:"Tags"  type:"Repeated"`
	Name         string    `position:"Query" name:"Name"`
	NameSpace    string    `position:"Query" name:"NameSpace"`
	Definition   string    `position:"Query" name:"Definition"`
}

CreateExperimentRequest is the request struct for api CreateExperiment

func CreateCreateExperimentRequest

func CreateCreateExperimentRequest() (request *CreateExperimentRequest)

CreateCreateExperimentRequest creates a request to invoke CreateExperiment API

type CreateExperimentResponse

type CreateExperimentResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Message        string `json:"Message" xml:"Message"`
	ExperimentId   string `json:"ExperimentId" xml:"ExperimentId"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           string `json:"Code" xml:"Code"`
	Success        bool   `json:"Success" xml:"Success"`
}

CreateExperimentResponse is the response struct for api CreateExperiment

func CreateCreateExperimentResponse

func CreateCreateExperimentResponse() (response *CreateExperimentResponse)

CreateCreateExperimentResponse creates a response to parse from CreateExperiment response

type CreateFlowRuleRequest

type CreateFlowRuleRequest struct {
	*requests.RpcRequest
	ControlBehavior   requests.Integer `position:"Query" name:"ControlBehavior"`
	Threshold         requests.Float   `position:"Query" name:"Threshold"`
	AhasRegionId      string           `position:"Query" name:"AhasRegionId"`
	AppName           string           `position:"Query" name:"AppName"`
	Enable            requests.Boolean `position:"Query" name:"Enable"`
	RefResource       string           `position:"Query" name:"RefResource"`
	WarmUpPeriodSec   requests.Integer `position:"Query" name:"WarmUpPeriodSec"`
	Resource          string           `position:"Query" name:"Resource"`
	ThresholdMode     requests.Integer `position:"Query" name:"ThresholdMode"`
	LimitOrigin       string           `position:"Query" name:"LimitOrigin"`
	Namespace         string           `position:"Query" name:"Namespace"`
	RelationStrategy  requests.Integer `position:"Query" name:"RelationStrategy"`
	MaxQueueingTimeMs requests.Integer `position:"Query" name:"MaxQueueingTimeMs"`
}

CreateFlowRuleRequest is the request struct for api CreateFlowRule

func CreateCreateFlowRuleRequest

func CreateCreateFlowRuleRequest() (request *CreateFlowRuleRequest)

CreateCreateFlowRuleRequest creates a request to invoke CreateFlowRule API

type CreateFlowRuleResponse

type CreateFlowRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateFlowRuleResponse is the response struct for api CreateFlowRule

func CreateCreateFlowRuleResponse

func CreateCreateFlowRuleResponse() (response *CreateFlowRuleResponse)

CreateCreateFlowRuleResponse creates a response to parse from CreateFlowRule response

type CreateHotParamItemsRequest

type CreateHotParamItemsRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
	Items        string           `position:"Query" name:"Items"`
}

CreateHotParamItemsRequest is the request struct for api CreateHotParamItems

func CreateCreateHotParamItemsRequest

func CreateCreateHotParamItemsRequest() (request *CreateHotParamItemsRequest)

CreateCreateHotParamItemsRequest creates a request to invoke CreateHotParamItems API

type CreateHotParamItemsResponse

type CreateHotParamItemsResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateHotParamItemsResponse is the response struct for api CreateHotParamItems

func CreateCreateHotParamItemsResponse

func CreateCreateHotParamItemsResponse() (response *CreateHotParamItemsResponse)

CreateCreateHotParamItemsResponse creates a response to parse from CreateHotParamItems response

type CreateHotParamRuleRequest

type CreateHotParamRuleRequest struct {
	*requests.RpcRequest
	MetricType        requests.Integer `position:"Query" name:"MetricType"`
	ParamIdx          requests.Integer `position:"Query" name:"ParamIdx"`
	ControlBehavior   requests.Integer `position:"Query" name:"ControlBehavior"`
	Resource          string           `position:"Query" name:"Resource"`
	Threshold         requests.Float   `position:"Query" name:"Threshold"`
	AhasRegionId      string           `position:"Query" name:"AhasRegionId"`
	AppName           string           `position:"Query" name:"AppName"`
	Enable            requests.Boolean `position:"Query" name:"Enable"`
	Namespace         string           `position:"Query" name:"Namespace"`
	MaxQueueingTimeMs requests.Integer `position:"Query" name:"MaxQueueingTimeMs"`
	StatDurationSec   requests.Integer `position:"Query" name:"StatDurationSec"`
	BurstCount        requests.Integer `position:"Query" name:"BurstCount"`
}

CreateHotParamRuleRequest is the request struct for api CreateHotParamRule

func CreateCreateHotParamRuleRequest

func CreateCreateHotParamRuleRequest() (request *CreateHotParamRuleRequest)

CreateCreateHotParamRuleRequest creates a request to invoke CreateHotParamRule API

type CreateHotParamRuleResponse

type CreateHotParamRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateHotParamRuleResponse is the response struct for api CreateHotParamRule

func CreateCreateHotParamRuleResponse

func CreateCreateHotParamRuleResponse() (response *CreateHotParamRuleResponse)

CreateCreateHotParamRuleResponse creates a response to parse from CreateHotParamRule response

type CreateIsolationRuleRequest

type CreateIsolationRuleRequest struct {
	*requests.RpcRequest
	RefResource      string           `position:"Query" name:"RefResource"`
	Resource         string           `position:"Query" name:"Resource"`
	Threshold        requests.Float   `position:"Query" name:"Threshold"`
	AhasRegionId     string           `position:"Query" name:"AhasRegionId"`
	LimitOrigin      string           `position:"Query" name:"LimitOrigin"`
	AppName          string           `position:"Query" name:"AppName"`
	Enable           requests.Boolean `position:"Query" name:"Enable"`
	Namespace        string           `position:"Query" name:"Namespace"`
	RelationStrategy requests.Integer `position:"Query" name:"RelationStrategy"`
}

CreateIsolationRuleRequest is the request struct for api CreateIsolationRule

func CreateCreateIsolationRuleRequest

func CreateCreateIsolationRuleRequest() (request *CreateIsolationRuleRequest)

CreateCreateIsolationRuleRequest creates a request to invoke CreateIsolationRule API

type CreateIsolationRuleResponse

type CreateIsolationRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateIsolationRuleResponse is the response struct for api CreateIsolationRule

func CreateCreateIsolationRuleResponse

func CreateCreateIsolationRuleResponse() (response *CreateIsolationRuleResponse)

CreateCreateIsolationRuleResponse creates a response to parse from CreateIsolationRule response

type CreateSystemRuleRequest

type CreateSystemRuleRequest struct {
	*requests.RpcRequest
	MetricType   requests.Integer `position:"Query" name:"MetricType"`
	Threshold    requests.Float   `position:"Query" name:"Threshold"`
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Enable       requests.Boolean `position:"Query" name:"Enable"`
	Namespace    string           `position:"Query" name:"Namespace"`
}

CreateSystemRuleRequest is the request struct for api CreateSystemRule

func CreateCreateSystemRuleRequest

func CreateCreateSystemRuleRequest() (request *CreateSystemRuleRequest)

CreateCreateSystemRuleRequest creates a request to invoke CreateSystemRule API

type CreateSystemRuleResponse

type CreateSystemRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

CreateSystemRuleResponse is the response struct for api CreateSystemRule

func CreateCreateSystemRuleResponse

func CreateCreateSystemRuleResponse() (response *CreateSystemRuleResponse)

CreateCreateSystemRuleResponse creates a response to parse from CreateSystemRule response

type Creator

type Creator struct {
	UserId    string `json:"UserId" xml:"UserId"`
	SubUserId string `json:"SubUserId" xml:"SubUserId"`
}

Creator is a nested struct in ahas_openapi response

type Data

type Data struct {
	TotalPage                 int                     `json:"TotalPage" xml:"TotalPage"`
	RelationStrategy          int                     `json:"RelationStrategy" xml:"RelationStrategy"`
	LimitOrigin               string                  `json:"LimitOrigin" xml:"LimitOrigin"`
	Strategy                  int                     `json:"Strategy" xml:"Strategy"`
	LocalName                 string                  `json:"LocalName" xml:"LocalName"`
	ParamIdx                  int                     `json:"ParamIdx" xml:"ParamIdx"`
	PageSize                  int                     `json:"PageSize" xml:"PageSize"`
	ClusterEstimatedMaxQps    float64                 `json:"ClusterEstimatedMaxQps" xml:"ClusterEstimatedMaxQps"`
	Threshold                 float64                 `json:"Threshold" xml:"Threshold"`
	StatDurationSec           int64                   `json:"StatDurationSec" xml:"StatDurationSec"`
	HalfOpenBaseAmountPerStep int                     `json:"HalfOpenBaseAmountPerStep" xml:"HalfOpenBaseAmountPerStep"`
	ControlBehavior           int                     `json:"ControlBehavior" xml:"ControlBehavior"`
	RegionId                  string                  `json:"RegionId" xml:"RegionId"`
	HalfOpenRecoveryStepNum   int                     `json:"HalfOpenRecoveryStepNum" xml:"HalfOpenRecoveryStepNum"`
	TotalCount                int                     `json:"TotalCount" xml:"TotalCount"`
	RuleId                    int64                   `json:"RuleId" xml:"RuleId"`
	BurstCount                int                     `json:"BurstCount" xml:"BurstCount"`
	MetricType                int                     `json:"MetricType" xml:"MetricType"`
	ClusterFallbackStrategy   int                     `json:"ClusterFallbackStrategy" xml:"ClusterFallbackStrategy"`
	Resource                  string                  `json:"Resource" xml:"Resource"`
	RegionEndpoint            string                  `json:"RegionEndpoint" xml:"RegionEndpoint"`
	ClusterThresholdType      int                     `json:"ClusterThresholdType" xml:"ClusterThresholdType"`
	RefResource               string                  `json:"RefResource" xml:"RefResource"`
	WarmUpPeriodSec           int                     `json:"WarmUpPeriodSec" xml:"WarmUpPeriodSec"`
	PageIndex                 int                     `json:"PageIndex" xml:"PageIndex"`
	SlowRtMs                  int                     `json:"SlowRtMs" xml:"SlowRtMs"`
	MinRequestAmount          int                     `json:"MinRequestAmount" xml:"MinRequestAmount"`
	StatDurationMs            int                     `json:"StatDurationMs" xml:"StatDurationMs"`
	MaxQueueingTimeMs         int                     `json:"MaxQueueingTimeMs" xml:"MaxQueueingTimeMs"`
	RecoveryTimeoutMs         int                     `json:"RecoveryTimeoutMs" xml:"RecoveryTimeoutMs"`
	Namespace                 string                  `json:"Namespace" xml:"Namespace"`
	Enable                    bool                    `json:"Enable" xml:"Enable"`
	ClusterFallbackThreshold  int                     `json:"ClusterFallbackThreshold" xml:"ClusterFallbackThreshold"`
	ClusterMode               bool                    `json:"ClusterMode" xml:"ClusterMode"`
	ThresholdMode             int                     `json:"ThresholdMode" xml:"ThresholdMode"`
	AppName                   string                  `json:"AppName" xml:"AppName"`
	ParamFlowItemList         []ParamFlowItemListItem `json:"ParamFlowItemList" xml:"ParamFlowItemList"`
	Datas                     []DatasItem             `json:"Datas" xml:"Datas"`
	InnerMetrics              []InnerMetricsItem      `json:"InnerMetrics" xml:"InnerMetrics"`
}

Data is a nested struct in ahas_openapi response

type DataInListActiveApps

type DataInListActiveApps struct {
	DataItem []DataItem `json:"Data" xml:"Data"`
}

DataInListActiveApps is a nested struct in ahas_openapi response

type DataItem

type DataItem struct {
	AppName            string `json:"AppName" xml:"AppName"`
	LastHealthPingTime int64  `json:"LastHealthPingTime" xml:"LastHealthPingTime"`
	CurrentLevel       int    `json:"CurrentLevel" xml:"CurrentLevel"`
	Namespace          string `json:"Namespace" xml:"Namespace"`
	AppType            int    `json:"AppType" xml:"AppType"`
	DirtyLevel         int    `json:"DirtyLevel" xml:"DirtyLevel"`
	AhasAppName        string `json:"AhasAppName" xml:"AhasAppName"`
}

DataItem is a nested struct in ahas_openapi response

type DatasInListDegradeRulesOfApp

type DatasInListDegradeRulesOfApp struct {
	DatasItem []DatasItem `json:"Datas" xml:"Datas"`
}

DatasInListDegradeRulesOfApp is a nested struct in ahas_openapi response

type DatasInListDegradeRulesOfResource

type DatasInListDegradeRulesOfResource struct {
	DatasItem []DatasItem `json:"Datas" xml:"Datas"`
}

DatasInListDegradeRulesOfResource is a nested struct in ahas_openapi response

type DatasInListFlowRulesOfApp

type DatasInListFlowRulesOfApp struct {
	DatasItem []DatasItem `json:"Datas" xml:"Datas"`
}

DatasInListFlowRulesOfApp is a nested struct in ahas_openapi response

type DatasInListFlowRulesOfResource

type DatasInListFlowRulesOfResource struct {
	DatasItem []DatasItem `json:"Datas" xml:"Datas"`
}

DatasInListFlowRulesOfResource is a nested struct in ahas_openapi response

type DatasInListHotParamRulesOfApp

type DatasInListHotParamRulesOfApp struct {
	DatasItem []DatasItem `json:"Datas" xml:"Datas"`
}

DatasInListHotParamRulesOfApp is a nested struct in ahas_openapi response

type DatasInListHotParamRulesOfResource

type DatasInListHotParamRulesOfResource struct {
	DatasItem []DatasItem `json:"Datas" xml:"Datas"`
}

DatasInListHotParamRulesOfResource is a nested struct in ahas_openapi response

type DatasInListIsolationRulesOfApp

type DatasInListIsolationRulesOfApp struct {
	DatasItem []DatasItem `json:"Datas" xml:"Datas"`
}

DatasInListIsolationRulesOfApp is a nested struct in ahas_openapi response

type DatasInListIsolationRulesOfResource

type DatasInListIsolationRulesOfResource struct {
	DatasItem []DatasItem `json:"Datas" xml:"Datas"`
}

DatasInListIsolationRulesOfResource is a nested struct in ahas_openapi response

type DatasInListSystemRules

type DatasInListSystemRules struct {
	DatasItem []DatasItem `json:"Datas" xml:"Datas"`
}

DatasInListSystemRules is a nested struct in ahas_openapi response

type DatasItem

type DatasItem struct {
	RelationStrategy          int                     `json:"RelationStrategy" xml:"RelationStrategy"`
	LimitOrigin               string                  `json:"LimitOrigin" xml:"LimitOrigin"`
	Strategy                  int                     `json:"Strategy" xml:"Strategy"`
	ParamIdx                  int                     `json:"ParamIdx" xml:"ParamIdx"`
	ClusterEstimatedMaxQps    float64                 `json:"ClusterEstimatedMaxQps" xml:"ClusterEstimatedMaxQps"`
	Threshold                 float64                 `json:"Threshold" xml:"Threshold"`
	StatDurationSec           int64                   `json:"StatDurationSec" xml:"StatDurationSec"`
	HalfOpenBaseAmountPerStep int                     `json:"HalfOpenBaseAmountPerStep" xml:"HalfOpenBaseAmountPerStep"`
	ControlBehavior           int                     `json:"ControlBehavior" xml:"ControlBehavior"`
	HalfOpenRecoveryStepNum   int                     `json:"HalfOpenRecoveryStepNum" xml:"HalfOpenRecoveryStepNum"`
	RuleId                    int64                   `json:"RuleId" xml:"RuleId"`
	BurstCount                int                     `json:"BurstCount" xml:"BurstCount"`
	MetricType                int                     `json:"MetricType" xml:"MetricType"`
	ClusterFallbackStrategy   int                     `json:"ClusterFallbackStrategy" xml:"ClusterFallbackStrategy"`
	Resource                  string                  `json:"Resource" xml:"Resource"`
	ClusterThresholdType      int                     `json:"ClusterThresholdType" xml:"ClusterThresholdType"`
	RefResource               string                  `json:"RefResource" xml:"RefResource"`
	WarmUpPeriodSec           int                     `json:"WarmUpPeriodSec" xml:"WarmUpPeriodSec"`
	SlowRtMs                  int                     `json:"SlowRtMs" xml:"SlowRtMs"`
	MinRequestAmount          int                     `json:"MinRequestAmount" xml:"MinRequestAmount"`
	StatDurationMs            int                     `json:"StatDurationMs" xml:"StatDurationMs"`
	MaxQueueingTimeMs         int                     `json:"MaxQueueingTimeMs" xml:"MaxQueueingTimeMs"`
	RecoveryTimeoutMs         int                     `json:"RecoveryTimeoutMs" xml:"RecoveryTimeoutMs"`
	Namespace                 string                  `json:"Namespace" xml:"Namespace"`
	Enable                    bool                    `json:"Enable" xml:"Enable"`
	ClusterFallbackThreshold  int                     `json:"ClusterFallbackThreshold" xml:"ClusterFallbackThreshold"`
	ClusterMode               bool                    `json:"ClusterMode" xml:"ClusterMode"`
	ThresholdMode             int                     `json:"ThresholdMode" xml:"ThresholdMode"`
	AppName                   string                  `json:"AppName" xml:"AppName"`
	ParamFlowItemList         []ParamFlowItemListItem `json:"ParamFlowItemList" xml:"ParamFlowItemList"`
}

DatasItem is a nested struct in ahas_openapi response

type DeleteDegradeRuleRequest

type DeleteDegradeRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

DeleteDegradeRuleRequest is the request struct for api DeleteDegradeRule

func CreateDeleteDegradeRuleRequest

func CreateDeleteDegradeRuleRequest() (request *DeleteDegradeRuleRequest)

CreateDeleteDegradeRuleRequest creates a request to invoke DeleteDegradeRule API

type DeleteDegradeRuleResponse

type DeleteDegradeRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteDegradeRuleResponse is the response struct for api DeleteDegradeRule

func CreateDeleteDegradeRuleResponse

func CreateDeleteDegradeRuleResponse() (response *DeleteDegradeRuleResponse)

CreateDeleteDegradeRuleResponse creates a response to parse from DeleteDegradeRule response

type DeleteFlowRuleRequest

type DeleteFlowRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

DeleteFlowRuleRequest is the request struct for api DeleteFlowRule

func CreateDeleteFlowRuleRequest

func CreateDeleteFlowRuleRequest() (request *DeleteFlowRuleRequest)

CreateDeleteFlowRuleRequest creates a request to invoke DeleteFlowRule API

type DeleteFlowRuleResponse

type DeleteFlowRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteFlowRuleResponse is the response struct for api DeleteFlowRule

func CreateDeleteFlowRuleResponse

func CreateDeleteFlowRuleResponse() (response *DeleteFlowRuleResponse)

CreateDeleteFlowRuleResponse creates a response to parse from DeleteFlowRule response

type DeleteHotParamRuleRequest

type DeleteHotParamRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

DeleteHotParamRuleRequest is the request struct for api DeleteHotParamRule

func CreateDeleteHotParamRuleRequest

func CreateDeleteHotParamRuleRequest() (request *DeleteHotParamRuleRequest)

CreateDeleteHotParamRuleRequest creates a request to invoke DeleteHotParamRule API

type DeleteHotParamRuleResponse

type DeleteHotParamRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteHotParamRuleResponse is the response struct for api DeleteHotParamRule

func CreateDeleteHotParamRuleResponse

func CreateDeleteHotParamRuleResponse() (response *DeleteHotParamRuleResponse)

CreateDeleteHotParamRuleResponse creates a response to parse from DeleteHotParamRule response

type DeleteIsolationRuleRequest

type DeleteIsolationRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

DeleteIsolationRuleRequest is the request struct for api DeleteIsolationRule

func CreateDeleteIsolationRuleRequest

func CreateDeleteIsolationRuleRequest() (request *DeleteIsolationRuleRequest)

CreateDeleteIsolationRuleRequest creates a request to invoke DeleteIsolationRule API

type DeleteIsolationRuleResponse

type DeleteIsolationRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteIsolationRuleResponse is the response struct for api DeleteIsolationRule

func CreateDeleteIsolationRuleResponse

func CreateDeleteIsolationRuleResponse() (response *DeleteIsolationRuleResponse)

CreateDeleteIsolationRuleResponse creates a response to parse from DeleteIsolationRule response

type DeleteSystemRuleRequest

type DeleteSystemRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

DeleteSystemRuleRequest is the request struct for api DeleteSystemRule

func CreateDeleteSystemRuleRequest

func CreateDeleteSystemRuleRequest() (request *DeleteSystemRuleRequest)

CreateDeleteSystemRuleRequest creates a request to invoke DeleteSystemRule API

type DeleteSystemRuleResponse

type DeleteSystemRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

DeleteSystemRuleResponse is the response struct for api DeleteSystemRule

func CreateDeleteSystemRuleResponse

func CreateDeleteSystemRuleResponse() (response *DeleteSystemRuleResponse)

CreateDeleteSystemRuleResponse creates a response to parse from DeleteSystemRule response

type DescribeRegionsRequest

type DescribeRegionsRequest struct {
	*requests.RpcRequest
	AcceptLanguage string `position:"Query" name:"AcceptLanguage"`
}

DescribeRegionsRequest is the request struct for api DescribeRegions

func CreateDescribeRegionsRequest

func CreateDescribeRegionsRequest() (request *DescribeRegionsRequest)

CreateDescribeRegionsRequest creates a request to invoke DescribeRegions API

type DescribeRegionsResponse

type DescribeRegionsResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Regions   []Data `json:"Regions" xml:"Regions"`
}

DescribeRegionsResponse is the response struct for api DescribeRegions

func CreateDescribeRegionsResponse

func CreateDescribeRegionsResponse() (response *DescribeRegionsResponse)

CreateDescribeRegionsResponse creates a response to parse from DescribeRegions response

type DisableDegradeRuleRequest

type DisableDegradeRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

DisableDegradeRuleRequest is the request struct for api DisableDegradeRule

func CreateDisableDegradeRuleRequest

func CreateDisableDegradeRuleRequest() (request *DisableDegradeRuleRequest)

CreateDisableDegradeRuleRequest creates a request to invoke DisableDegradeRule API

type DisableDegradeRuleResponse

type DisableDegradeRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

DisableDegradeRuleResponse is the response struct for api DisableDegradeRule

func CreateDisableDegradeRuleResponse

func CreateDisableDegradeRuleResponse() (response *DisableDegradeRuleResponse)

CreateDisableDegradeRuleResponse creates a response to parse from DisableDegradeRule response

type DisableFlowRuleRequest

type DisableFlowRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

DisableFlowRuleRequest is the request struct for api DisableFlowRule

func CreateDisableFlowRuleRequest

func CreateDisableFlowRuleRequest() (request *DisableFlowRuleRequest)

CreateDisableFlowRuleRequest creates a request to invoke DisableFlowRule API

type DisableFlowRuleResponse

type DisableFlowRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

DisableFlowRuleResponse is the response struct for api DisableFlowRule

func CreateDisableFlowRuleResponse

func CreateDisableFlowRuleResponse() (response *DisableFlowRuleResponse)

CreateDisableFlowRuleResponse creates a response to parse from DisableFlowRule response

type DisableHotParamRuleRequest

type DisableHotParamRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

DisableHotParamRuleRequest is the request struct for api DisableHotParamRule

func CreateDisableHotParamRuleRequest

func CreateDisableHotParamRuleRequest() (request *DisableHotParamRuleRequest)

CreateDisableHotParamRuleRequest creates a request to invoke DisableHotParamRule API

type DisableHotParamRuleResponse

type DisableHotParamRuleResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

DisableHotParamRuleResponse is the response struct for api DisableHotParamRule

func CreateDisableHotParamRuleResponse

func CreateDisableHotParamRuleResponse() (response *DisableHotParamRuleResponse)

CreateDisableHotParamRuleResponse creates a response to parse from DisableHotParamRule response

type DisableIsolationRuleRequest

type DisableIsolationRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

DisableIsolationRuleRequest is the request struct for api DisableIsolationRule

func CreateDisableIsolationRuleRequest

func CreateDisableIsolationRuleRequest() (request *DisableIsolationRuleRequest)

CreateDisableIsolationRuleRequest creates a request to invoke DisableIsolationRule API

type DisableIsolationRuleResponse

type DisableIsolationRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

DisableIsolationRuleResponse is the response struct for api DisableIsolationRule

func CreateDisableIsolationRuleResponse

func CreateDisableIsolationRuleResponse() (response *DisableIsolationRuleResponse)

CreateDisableIsolationRuleResponse creates a response to parse from DisableIsolationRule response

type DisableSystemRuleRequest

type DisableSystemRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

DisableSystemRuleRequest is the request struct for api DisableSystemRule

func CreateDisableSystemRuleRequest

func CreateDisableSystemRuleRequest() (request *DisableSystemRuleRequest)

CreateDisableSystemRuleRequest creates a request to invoke DisableSystemRule API

type DisableSystemRuleResponse

type DisableSystemRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

DisableSystemRuleResponse is the response struct for api DisableSystemRule

func CreateDisableSystemRuleResponse

func CreateDisableSystemRuleResponse() (response *DisableSystemRuleResponse)

CreateDisableSystemRuleResponse creates a response to parse from DisableSystemRule response

type EnableDegradeRuleRequest

type EnableDegradeRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

EnableDegradeRuleRequest is the request struct for api EnableDegradeRule

func CreateEnableDegradeRuleRequest

func CreateEnableDegradeRuleRequest() (request *EnableDegradeRuleRequest)

CreateEnableDegradeRuleRequest creates a request to invoke EnableDegradeRule API

type EnableDegradeRuleResponse

type EnableDegradeRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

EnableDegradeRuleResponse is the response struct for api EnableDegradeRule

func CreateEnableDegradeRuleResponse

func CreateEnableDegradeRuleResponse() (response *EnableDegradeRuleResponse)

CreateEnableDegradeRuleResponse creates a response to parse from EnableDegradeRule response

type EnableFlowRuleRequest

type EnableFlowRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

EnableFlowRuleRequest is the request struct for api EnableFlowRule

func CreateEnableFlowRuleRequest

func CreateEnableFlowRuleRequest() (request *EnableFlowRuleRequest)

CreateEnableFlowRuleRequest creates a request to invoke EnableFlowRule API

type EnableFlowRuleResponse

type EnableFlowRuleResponse struct {
	*responses.BaseResponse
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

EnableFlowRuleResponse is the response struct for api EnableFlowRule

func CreateEnableFlowRuleResponse

func CreateEnableFlowRuleResponse() (response *EnableFlowRuleResponse)

CreateEnableFlowRuleResponse creates a response to parse from EnableFlowRule response

type EnableHotParamRuleRequest

type EnableHotParamRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

EnableHotParamRuleRequest is the request struct for api EnableHotParamRule

func CreateEnableHotParamRuleRequest

func CreateEnableHotParamRuleRequest() (request *EnableHotParamRuleRequest)

CreateEnableHotParamRuleRequest creates a request to invoke EnableHotParamRule API

type EnableHotParamRuleResponse

type EnableHotParamRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

EnableHotParamRuleResponse is the response struct for api EnableHotParamRule

func CreateEnableHotParamRuleResponse

func CreateEnableHotParamRuleResponse() (response *EnableHotParamRuleResponse)

CreateEnableHotParamRuleResponse creates a response to parse from EnableHotParamRule response

type EnableIsolationRuleRequest

type EnableIsolationRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

EnableIsolationRuleRequest is the request struct for api EnableIsolationRule

func CreateEnableIsolationRuleRequest

func CreateEnableIsolationRuleRequest() (request *EnableIsolationRuleRequest)

CreateEnableIsolationRuleRequest creates a request to invoke EnableIsolationRule API

type EnableIsolationRuleResponse

type EnableIsolationRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

EnableIsolationRuleResponse is the response struct for api EnableIsolationRule

func CreateEnableIsolationRuleResponse

func CreateEnableIsolationRuleResponse() (response *EnableIsolationRuleResponse)

CreateEnableIsolationRuleResponse creates a response to parse from EnableIsolationRule response

type EnableSystemRuleRequest

type EnableSystemRuleRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

EnableSystemRuleRequest is the request struct for api EnableSystemRule

func CreateEnableSystemRuleRequest

func CreateEnableSystemRuleRequest() (request *EnableSystemRuleRequest)

CreateEnableSystemRuleRequest creates a request to invoke EnableSystemRule API

type EnableSystemRuleResponse

type EnableSystemRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

EnableSystemRuleResponse is the response struct for api EnableSystemRule

func CreateEnableSystemRuleResponse

func CreateEnableSystemRuleResponse() (response *EnableSystemRuleResponse)

CreateEnableSystemRuleResponse creates a response to parse from EnableSystemRule response

type ExecuteExperimentRequest

type ExecuteExperimentRequest struct {
	*requests.RpcRequest
	AhasRegionId string `position:"Query" name:"AhasRegionId"`
	NameSpace    string `position:"Query" name:"NameSpace"`
	ExperimentId string `position:"Query" name:"ExperimentId"`
	Definition   string `position:"Query" name:"Definition"`
}

ExecuteExperimentRequest is the request struct for api ExecuteExperiment

func CreateExecuteExperimentRequest

func CreateExecuteExperimentRequest() (request *ExecuteExperimentRequest)

CreateExecuteExperimentRequest creates a request to invoke ExecuteExperiment API

type ExecuteExperimentResponse

type ExecuteExperimentResponse struct {
	*responses.BaseResponse
	TaskId    string `json:"TaskId" xml:"TaskId"`
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
}

ExecuteExperimentResponse is the response struct for api ExecuteExperiment

func CreateExecuteExperimentResponse

func CreateExecuteExperimentResponse() (response *ExecuteExperimentResponse)

CreateExecuteExperimentResponse creates a response to parse from ExecuteExperiment response

type ExperimentInfo

type ExperimentInfo struct {
	Permission   int      `json:"Permission" xml:"Permission"`
	Result       string   `json:"Result" xml:"Result"`
	State        string   `json:"State" xml:"State"`
	CreateTime   int64    `json:"CreateTime" xml:"CreateTime"`
	ExperimentId string   `json:"ExperimentId" xml:"ExperimentId"`
	Name         string   `json:"Name" xml:"Name"`
	Creator      string   `json:"Creator" xml:"Creator"`
	Tags         []string `json:"Tags" xml:"Tags"`
	MiniApps     []string `json:"MiniApps" xml:"MiniApps"`
}

ExperimentInfo is a nested struct in ahas_openapi response

type ExperimentList

type ExperimentList struct {
	ExperimentInfo []ExperimentInfo `json:"ExperimentInfo" xml:"ExperimentInfo"`
}

ExperimentList is a nested struct in ahas_openapi response

type ExperimentTaskInfo

type ExperimentTaskInfo struct {
	StartTime      int64   `json:"StartTime" xml:"StartTime"`
	Message        string  `json:"Message" xml:"Message"`
	State          string  `json:"State" xml:"State"`
	TaskId         string  `json:"TaskId" xml:"TaskId"`
	Result         string  `json:"Result" xml:"Result"`
	ExperimentId   string  `json:"ExperimentId" xml:"ExperimentId"`
	ExperimentName string  `json:"ExperimentName" xml:"ExperimentName"`
	Namespace      string  `json:"Namespace" xml:"Namespace"`
	CurrentPhase   string  `json:"CurrentPhase" xml:"CurrentPhase"`
	EndTime        int64   `json:"EndTime" xml:"EndTime"`
	Creator        Creator `json:"Creator" xml:"Creator"`
	ExtInfo        ExtInfo `json:"ExtInfo" xml:"ExtInfo"`
}

ExperimentTaskInfo is a nested struct in ahas_openapi response

type ExperimentTasksInPageableQueryExperimentTaskByClusterId

type ExperimentTasksInPageableQueryExperimentTaskByClusterId struct {
	ExperimentTaskInfo []ExperimentTaskInfo `json:"ExperimentTaskInfo" xml:"ExperimentTaskInfo"`
}

ExperimentTasksInPageableQueryExperimentTaskByClusterId is a nested struct in ahas_openapi response

type ExperimentTasksInPageableQueryExperimentTaskByExperimentId

type ExperimentTasksInPageableQueryExperimentTaskByExperimentId struct {
	ExperimentTaskInfo []ExperimentTaskInfo `json:"ExperimentTaskInfo" xml:"ExperimentTaskInfo"`
}

ExperimentTasksInPageableQueryExperimentTaskByExperimentId is a nested struct in ahas_openapi response

type ExtInfo

type ExtInfo struct {
	SchedulerConfig SchedulerConfig `json:"SchedulerConfig" xml:"SchedulerConfig"`
}

ExtInfo is a nested struct in ahas_openapi response

type FinishExperimentTaskRequest

type FinishExperimentTaskRequest struct {
	*requests.RpcRequest
	AhasRegionId     string `position:"Query" name:"AhasRegionId"`
	NameSpace        string `position:"Query" name:"NameSpace"`
	ExperimentTaskId string `position:"Query" name:"ExperimentTaskId"`
}

FinishExperimentTaskRequest is the request struct for api FinishExperimentTask

func CreateFinishExperimentTaskRequest

func CreateFinishExperimentTaskRequest() (request *FinishExperimentTaskRequest)

CreateFinishExperimentTaskRequest creates a request to invoke FinishExperimentTask API

type FinishExperimentTaskResponse

type FinishExperimentTaskResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
}

FinishExperimentTaskResponse is the response struct for api FinishExperimentTask

func CreateFinishExperimentTaskResponse

func CreateFinishExperimentTaskResponse() (response *FinishExperimentTaskResponse)

CreateFinishExperimentTaskResponse creates a response to parse from FinishExperimentTask response

type GetActivityTaskRequest

type GetActivityTaskRequest struct {
	*requests.RpcRequest
	ActivityTaskId   string `position:"Query" name:"ActivityTaskId"`
	AhasRegionId     string `position:"Query" name:"AhasRegionId"`
	NameSpace        string `position:"Query" name:"NameSpace"`
	ExperimentTaskId string `position:"Query" name:"ExperimentTaskId"`
}

GetActivityTaskRequest is the request struct for api GetActivityTask

func CreateGetActivityTaskRequest

func CreateGetActivityTaskRequest() (request *GetActivityTaskRequest)

CreateGetActivityTaskRequest creates a request to invoke GetActivityTask API

type GetActivityTaskResponse

type GetActivityTaskResponse struct {
	*responses.BaseResponse
	Phase            string      `json:"Phase" xml:"Phase"`
	EndTime          int64       `json:"EndTime" xml:"EndTime"`
	RequestId        string      `json:"RequestId" xml:"RequestId"`
	ActivityName     string      `json:"ActivityName" xml:"ActivityName"`
	State            string      `json:"State" xml:"State"`
	ActivityId       string      `json:"ActivityId" xml:"ActivityId"`
	ExperimentTaskId string      `json:"ExperimentTaskId" xml:"ExperimentTaskId"`
	HttpStatusCode   int         `json:"HttpStatusCode" xml:"HttpStatusCode"`
	StartTime        int64       `json:"StartTime" xml:"StartTime"`
	RunResult        string      `json:"RunResult" xml:"RunResult"`
	Success          bool        `json:"Success" xml:"Success"`
	Hosts            []HostsItem `json:"Hosts" xml:"Hosts"`
}

GetActivityTaskResponse is the response struct for api GetActivityTask

func CreateGetActivityTaskResponse

func CreateGetActivityTaskResponse() (response *GetActivityTaskResponse)

CreateGetActivityTaskResponse creates a response to parse from GetActivityTask response

type GetExperimentMetaRequest

type GetExperimentMetaRequest struct {
	*requests.RpcRequest
	NameSpace    string `position:"Query" name:"NameSpace"`
	ExperimentId string `position:"Query" name:"ExperimentId"`
}

GetExperimentMetaRequest is the request struct for api GetExperimentMeta

func CreateGetExperimentMetaRequest

func CreateGetExperimentMetaRequest() (request *GetExperimentMetaRequest)

CreateGetExperimentMetaRequest creates a request to invoke GetExperimentMeta API

type GetExperimentMetaResponse

type GetExperimentMetaResponse struct {
	*responses.BaseResponse
	RequestId    string   `json:"RequestId" xml:"RequestId"`
	Message      string   `json:"Message" xml:"Message"`
	State        string   `json:"State" xml:"State"`
	ExperimentId string   `json:"ExperimentId" xml:"ExperimentId"`
	CreateTime   string   `json:"CreateTime" xml:"CreateTime"`
	Code         string   `json:"Code" xml:"Code"`
	Success      bool     `json:"Success" xml:"Success"`
	Name         string   `json:"Name" xml:"Name"`
	Tags         []string `json:"Tags" xml:"Tags"`
}

GetExperimentMetaResponse is the response struct for api GetExperimentMeta

func CreateGetExperimentMetaResponse

func CreateGetExperimentMetaResponse() (response *GetExperimentMetaResponse)

CreateGetExperimentMetaResponse creates a response to parse from GetExperimentMeta response

type GetExperimentTaskRequest

type GetExperimentTaskRequest struct {
	*requests.RpcRequest
	AhasRegionId     string `position:"Query" name:"AhasRegionId"`
	NameSpace        string `position:"Query" name:"NameSpace"`
	ExperimentTaskId string `position:"Query" name:"ExperimentTaskId"`
}

GetExperimentTaskRequest is the request struct for api GetExperimentTask

func CreateGetExperimentTaskRequest

func CreateGetExperimentTaskRequest() (request *GetExperimentTaskRequest)

CreateGetExperimentTaskRequest creates a request to invoke GetExperimentTask API

type GetExperimentTaskResponse

type GetExperimentTaskResponse struct {
	*responses.BaseResponse
	TaskId         string           `json:"TaskId" xml:"TaskId"`
	RequestId      string           `json:"RequestId" xml:"RequestId"`
	ExperimentName string           `json:"ExperimentName" xml:"ExperimentName"`
	State          string           `json:"State" xml:"State"`
	ExperimentId   string           `json:"ExperimentId" xml:"ExperimentId"`
	HttpStatusCode int              `json:"HttpStatusCode" xml:"HttpStatusCode"`
	StartTime      int64            `json:"StartTime" xml:"StartTime"`
	Success        bool             `json:"Success" xml:"Success"`
	Result         string           `json:"Result" xml:"Result"`
	Namespace      string           `json:"Namespace" xml:"Namespace"`
	Activities     []ActivitiesItem `json:"Activities" xml:"Activities"`
}

GetExperimentTaskResponse is the response struct for api GetExperimentTask

func CreateGetExperimentTaskResponse

func CreateGetExperimentTaskResponse() (response *GetExperimentTaskResponse)

CreateGetExperimentTaskResponse creates a response to parse from GetExperimentTask response

type GetLicenseKeyRequest

type GetLicenseKeyRequest struct {
	*requests.RpcRequest
	AhasRegionId string `position:"Query" name:"AhasRegionId"`
	Namespace    string `position:"Query" name:"Namespace"`
}

GetLicenseKeyRequest is the request struct for api GetLicenseKey

func CreateGetLicenseKeyRequest

func CreateGetLicenseKeyRequest() (request *GetLicenseKeyRequest)

CreateGetLicenseKeyRequest creates a request to invoke GetLicenseKey API

type GetLicenseKeyResponse

type GetLicenseKeyResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Data      string `json:"Data" xml:"Data"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
}

GetLicenseKeyResponse is the response struct for api GetLicenseKey

func CreateGetLicenseKeyResponse

func CreateGetLicenseKeyResponse() (response *GetLicenseKeyResponse)

CreateGetLicenseKeyResponse creates a response to parse from GetLicenseKey response

type GetMetricsOfAppRequest

type GetMetricsOfAppRequest struct {
	*requests.RpcRequest
	EndTime      requests.Integer `position:"Query" name:"EndTime"`
	StartTime    requests.Integer `position:"Query" name:"StartTime"`
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
}

GetMetricsOfAppRequest is the request struct for api GetMetricsOfApp

func CreateGetMetricsOfAppRequest

func CreateGetMetricsOfAppRequest() (request *GetMetricsOfAppRequest)

CreateGetMetricsOfAppRequest creates a request to invoke GetMetricsOfApp API

type GetMetricsOfAppResponse

type GetMetricsOfAppResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetMetricsOfAppResponse is the response struct for api GetMetricsOfApp

func CreateGetMetricsOfAppResponse

func CreateGetMetricsOfAppResponse() (response *GetMetricsOfAppResponse)

CreateGetMetricsOfAppResponse creates a response to parse from GetMetricsOfApp response

type GetMetricsOfResourceRequest

type GetMetricsOfResourceRequest struct {
	*requests.RpcRequest
	Resource     string           `position:"Query" name:"Resource"`
	EndTime      requests.Integer `position:"Query" name:"EndTime"`
	StartTime    requests.Integer `position:"Query" name:"StartTime"`
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
}

GetMetricsOfResourceRequest is the request struct for api GetMetricsOfResource

func CreateGetMetricsOfResourceRequest

func CreateGetMetricsOfResourceRequest() (request *GetMetricsOfResourceRequest)

CreateGetMetricsOfResourceRequest creates a request to invoke GetMetricsOfResource API

type GetMetricsOfResourceResponse

type GetMetricsOfResourceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

GetMetricsOfResourceResponse is the response struct for api GetMetricsOfResource

func CreateGetMetricsOfResourceResponse

func CreateGetMetricsOfResourceResponse() (response *GetMetricsOfResourceResponse)

CreateGetMetricsOfResourceResponse creates a response to parse from GetMetricsOfResource response

type GetSentinelAppSumMetricRequest

type GetSentinelAppSumMetricRequest struct {
	*requests.RpcRequest
	EndTime        string `position:"Query" name:"EndTime"`
	StartTime      string `position:"Query" name:"StartTime"`
	AhasRegionId   string `position:"Query" name:"AhasRegionId"`
	AppName        string `position:"Query" name:"AppName"`
	AcceptLanguage string `position:"Query" name:"AcceptLanguage"`
	Namespace      string `position:"Query" name:"Namespace"`
}

GetSentinelAppSumMetricRequest is the request struct for api GetSentinelAppSumMetric

func CreateGetSentinelAppSumMetricRequest

func CreateGetSentinelAppSumMetricRequest() (request *GetSentinelAppSumMetricRequest)

CreateGetSentinelAppSumMetricRequest creates a request to invoke GetSentinelAppSumMetric API

type GetSentinelAppSumMetricResponse

type GetSentinelAppSumMetricResponse struct {
	*responses.BaseResponse
	Message    string     `json:"Message" xml:"Message"`
	RequestId  string     `json:"RequestId" xml:"RequestId"`
	Code       string     `json:"Code" xml:"Code"`
	Success    bool       `json:"Success" xml:"Success"`
	MetricData MetricData `json:"MetricData" xml:"MetricData"`
}

GetSentinelAppSumMetricResponse is the response struct for api GetSentinelAppSumMetric

func CreateGetSentinelAppSumMetricResponse

func CreateGetSentinelAppSumMetricResponse() (response *GetSentinelAppSumMetricResponse)

CreateGetSentinelAppSumMetricResponse creates a response to parse from GetSentinelAppSumMetric response

type GetUserApplicationGroupsRequest

type GetUserApplicationGroupsRequest struct {
	*requests.RpcRequest
	AhasRegionId  string `position:"Query" name:"AhasRegionId"`
	NameSpace     string `position:"Query" name:"NameSpace"`
	ApplicationId string `position:"Query" name:"ApplicationId"`
}

GetUserApplicationGroupsRequest is the request struct for api GetUserApplicationGroups

func CreateGetUserApplicationGroupsRequest

func CreateGetUserApplicationGroupsRequest() (request *GetUserApplicationGroupsRequest)

CreateGetUserApplicationGroupsRequest creates a request to invoke GetUserApplicationGroups API

type GetUserApplicationGroupsResponse

type GetUserApplicationGroupsResponse struct {
	*responses.BaseResponse
	RequestId      string   `json:"RequestId" xml:"RequestId"`
	HttpStatusCode int      `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Success        bool     `json:"Success" xml:"Success"`
	Message        string   `json:"Message" xml:"Message"`
	Code           string   `json:"Code" xml:"Code"`
	AppGroups      []string `json:"AppGroups" xml:"AppGroups"`
}

GetUserApplicationGroupsResponse is the response struct for api GetUserApplicationGroups

func CreateGetUserApplicationGroupsResponse

func CreateGetUserApplicationGroupsResponse() (response *GetUserApplicationGroupsResponse)

CreateGetUserApplicationGroupsResponse creates a response to parse from GetUserApplicationGroups response

type GetUserApplicationsRequest

type GetUserApplicationsRequest struct {
	*requests.RpcRequest
	AhasRegionId string `position:"Query" name:"AhasRegionId"`
	Namespace    string `position:"Query" name:"Namespace"`
}

GetUserApplicationsRequest is the request struct for api GetUserApplications

func CreateGetUserApplicationsRequest

func CreateGetUserApplicationsRequest() (request *GetUserApplicationsRequest)

CreateGetUserApplicationsRequest creates a request to invoke GetUserApplications API

type GetUserApplicationsResponse

type GetUserApplicationsResponse struct {
	*responses.BaseResponse
	Message           string                  `json:"Message" xml:"Message"`
	RequestId         string                  `json:"RequestId" xml:"RequestId"`
	HttpStatusCode    int                     `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code              string                  `json:"Code" xml:"Code"`
	Success           bool                    `json:"Success" xml:"Success"`
	AppNameAndIdPairs []AppNameAndIdPairsItem `json:"AppNameAndIdPairs" xml:"AppNameAndIdPairs"`
}

GetUserApplicationsResponse is the response struct for api GetUserApplications

func CreateGetUserApplicationsResponse

func CreateGetUserApplicationsResponse() (response *GetUserApplicationsResponse)

CreateGetUserApplicationsResponse creates a response to parse from GetUserApplications response

type GetUserWorkspaceRequest

type GetUserWorkspaceRequest struct {
	*requests.RpcRequest
	AhasRegionId string `position:"Query" name:"AhasRegionId"`
	Namespace    string `position:"Query" name:"Namespace"`
}

GetUserWorkspaceRequest is the request struct for api GetUserWorkspace

func CreateGetUserWorkspaceRequest

func CreateGetUserWorkspaceRequest() (request *GetUserWorkspaceRequest)

CreateGetUserWorkspaceRequest creates a request to invoke GetUserWorkspace API

type GetUserWorkspaceResponse

type GetUserWorkspaceResponse struct {
	*responses.BaseResponse
	Message        string          `json:"Message" xml:"Message"`
	RequestId      string          `json:"RequestId" xml:"RequestId"`
	HttpStatusCode int             `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           string          `json:"Code" xml:"Code"`
	Success        bool            `json:"Success" xml:"Success"`
	WorkspaceList  []WorkspaceInfo `json:"WorkspaceList" xml:"WorkspaceList"`
}

GetUserWorkspaceResponse is the response struct for api GetUserWorkspace

func CreateGetUserWorkspaceResponse

func CreateGetUserWorkspaceResponse() (response *GetUserWorkspaceResponse)

CreateGetUserWorkspaceResponse creates a response to parse from GetUserWorkspace response

type Hosts

type Hosts struct {
	HostsItem []HostsItem `json:"Hosts" xml:"Hosts"`
}

Hosts is a nested struct in ahas_openapi response

type HostsItem

type HostsItem struct {
	HostIp       string `json:"HostIp" xml:"HostIp"`
	EndTime      int64  `json:"EndTime" xml:"EndTime"`
	StartTime    int64  `json:"StartTime" xml:"StartTime"`
	Data         string `json:"Data" xml:"Data"`
	ErrorMessage string `json:"ErrorMessage" xml:"ErrorMessage"`
	ExpId        string `json:"ExpId" xml:"ExpId"`
	Result       string `json:"Result" xml:"Result"`
	State        string `json:"State" xml:"State"`
	TaskId       string `json:"TaskId" xml:"TaskId"`
}

HostsItem is a nested struct in ahas_openapi response

type InnerMetricsInGetMetricsOfApp

type InnerMetricsInGetMetricsOfApp struct {
	InnerMetricsItem []InnerMetricsItem `json:"InnerMetrics" xml:"InnerMetrics"`
}

InnerMetricsInGetMetricsOfApp is a nested struct in ahas_openapi response

type InnerMetricsInGetMetricsOfResource

type InnerMetricsInGetMetricsOfResource struct {
	InnerMetricsItem []InnerMetricsItem `json:"InnerMetrics" xml:"InnerMetrics"`
}

InnerMetricsInGetMetricsOfResource is a nested struct in ahas_openapi response

type InnerMetricsItem

type InnerMetricsItem struct {
	ExceptionStd  float64 `json:"ExceptionStd" xml:"ExceptionStd"`
	SuccessQpsP95 float64 `json:"SuccessQpsP95" xml:"SuccessQpsP95"`
	RtP95         float64 `json:"RtP95" xml:"RtP95"`
	BlockedQpsMax float64 `json:"BlockedQpsMax" xml:"BlockedQpsMax"`
	BlockedQpsStd float64 `json:"BlockedQpsStd" xml:"BlockedQpsStd"`
	PassedQpsStd  float64 `json:"PassedQpsStd" xml:"PassedQpsStd"`
	ThreadMax     float64 `json:"ThreadMax" xml:"ThreadMax"`
	PassedQps     float64 `json:"PassedQps" xml:"PassedQps"`
	Thread        float64 `json:"Thread" xml:"Thread"`
	SuccessQpsP75 float64 `json:"SuccessQpsP75" xml:"SuccessQpsP75"`
	RtAvg         float64 `json:"RtAvg" xml:"RtAvg"`
	ThreadAvg     float64 `json:"ThreadAvg" xml:"ThreadAvg"`
	PassedQpsP95  float64 `json:"PassedQpsP95" xml:"PassedQpsP95"`
	Timestamp     int64   `json:"Timestamp" xml:"Timestamp"`
	ExceptionMax  float64 `json:"ExceptionMax" xml:"ExceptionMax"`
	RtMin         float64 `json:"RtMin" xml:"RtMin"`
	RtP99         float64 `json:"RtP99" xml:"RtP99"`
	SuccessQps    float64 `json:"SuccessQps" xml:"SuccessQps"`
	ThreadP99     float64 `json:"ThreadP99" xml:"ThreadP99"`
	PassedQpsP75  float64 `json:"PassedQpsP75" xml:"PassedQpsP75"`
	RtP75         float64 `json:"RtP75" xml:"RtP75"`
	ThreadMin     float64 `json:"ThreadMin" xml:"ThreadMin"`
	ExceptionP99  float64 `json:"ExceptionP99" xml:"ExceptionP99"`
	Rt            float64 `json:"Rt" xml:"Rt"`
	BlockedQps    float64 `json:"BlockedQps" xml:"BlockedQps"`
	PassedQpsAvg  float64 `json:"PassedQpsAvg" xml:"PassedQpsAvg"`
	SuccessQpsMax float64 `json:"SuccessQpsMax" xml:"SuccessQpsMax"`
	BlockedQpsP75 float64 `json:"BlockedQpsP75" xml:"BlockedQpsP75"`
	PassedQpsMin  float64 `json:"PassedQpsMin" xml:"PassedQpsMin"`
	ThreadP75     float64 `json:"ThreadP75" xml:"ThreadP75"`
	ExceptionP75  float64 `json:"ExceptionP75" xml:"ExceptionP75"`
	BlockedQpsP99 float64 `json:"BlockedQpsP99" xml:"BlockedQpsP99"`
	PassedQpsP99  float64 `json:"PassedQpsP99" xml:"PassedQpsP99"`
	SuccessQpsStd float64 `json:"SuccessQpsStd" xml:"SuccessQpsStd"`
	RtMax         float64 `json:"RtMax" xml:"RtMax"`
	ExceptionAvg  float64 `json:"ExceptionAvg" xml:"ExceptionAvg"`
	ThreadP95     float64 `json:"ThreadP95" xml:"ThreadP95"`
	ExceptionMin  float64 `json:"ExceptionMin" xml:"ExceptionMin"`
	Count         int     `json:"Count" xml:"Count"`
	Exception     float64 `json:"Exception" xml:"Exception"`
	BlockedQpsMin float64 `json:"BlockedQpsMin" xml:"BlockedQpsMin"`
	SuccessQpsP99 float64 `json:"SuccessQpsP99" xml:"SuccessQpsP99"`
	SuccessQpsAvg float64 `json:"SuccessQpsAvg" xml:"SuccessQpsAvg"`
	PassedQpsMax  float64 `json:"PassedQpsMax" xml:"PassedQpsMax"`
	SuccessQpsMin float64 `json:"SuccessQpsMin" xml:"SuccessQpsMin"`
	BlockedQpsAvg float64 `json:"BlockedQpsAvg" xml:"BlockedQpsAvg"`
	ThreadStd     float64 `json:"ThreadStd" xml:"ThreadStd"`
	RtStd         float64 `json:"RtStd" xml:"RtStd"`
	BlockedQpsP95 float64 `json:"BlockedQpsP95" xml:"BlockedQpsP95"`
	ExceptionP95  float64 `json:"ExceptionP95" xml:"ExceptionP95"`
}

InnerMetricsItem is a nested struct in ahas_openapi response

type ListActiveAppsRequest

type ListActiveAppsRequest struct {
	*requests.RpcRequest
	AppType      requests.Integer `position:"Query" name:"AppType"`
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	Namespace    string           `position:"Query" name:"Namespace"`
}

ListActiveAppsRequest is the request struct for api ListActiveApps

func CreateListActiveAppsRequest

func CreateListActiveAppsRequest() (request *ListActiveAppsRequest)

CreateListActiveAppsRequest creates a request to invoke ListActiveApps API

type ListActiveAppsResponse

type ListActiveAppsResponse struct {
	*responses.BaseResponse
	Message   string     `json:"Message" xml:"Message"`
	RequestId string     `json:"RequestId" xml:"RequestId"`
	Code      string     `json:"Code" xml:"Code"`
	Success   bool       `json:"Success" xml:"Success"`
	Data      []DataItem `json:"Data" xml:"Data"`
}

ListActiveAppsResponse is the response struct for api ListActiveApps

func CreateListActiveAppsResponse

func CreateListActiveAppsResponse() (response *ListActiveAppsResponse)

CreateListActiveAppsResponse creates a response to parse from ListActiveApps response

type ListDegradeRulesOfAppRequest

type ListDegradeRulesOfAppRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	PageIndex    requests.Integer `position:"Query" name:"PageIndex"`
}

ListDegradeRulesOfAppRequest is the request struct for api ListDegradeRulesOfApp

func CreateListDegradeRulesOfAppRequest

func CreateListDegradeRulesOfAppRequest() (request *ListDegradeRulesOfAppRequest)

CreateListDegradeRulesOfAppRequest creates a request to invoke ListDegradeRulesOfApp API

type ListDegradeRulesOfAppResponse

type ListDegradeRulesOfAppResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ListDegradeRulesOfAppResponse is the response struct for api ListDegradeRulesOfApp

func CreateListDegradeRulesOfAppResponse

func CreateListDegradeRulesOfAppResponse() (response *ListDegradeRulesOfAppResponse)

CreateListDegradeRulesOfAppResponse creates a response to parse from ListDegradeRulesOfApp response

type ListDegradeRulesOfResourceRequest

type ListDegradeRulesOfResourceRequest struct {
	*requests.RpcRequest
	Resource     string           `position:"Query" name:"Resource"`
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	PageIndex    requests.Integer `position:"Query" name:"PageIndex"`
}

ListDegradeRulesOfResourceRequest is the request struct for api ListDegradeRulesOfResource

func CreateListDegradeRulesOfResourceRequest

func CreateListDegradeRulesOfResourceRequest() (request *ListDegradeRulesOfResourceRequest)

CreateListDegradeRulesOfResourceRequest creates a request to invoke ListDegradeRulesOfResource API

type ListDegradeRulesOfResourceResponse

type ListDegradeRulesOfResourceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ListDegradeRulesOfResourceResponse is the response struct for api ListDegradeRulesOfResource

func CreateListDegradeRulesOfResourceResponse

func CreateListDegradeRulesOfResourceResponse() (response *ListDegradeRulesOfResourceResponse)

CreateListDegradeRulesOfResourceResponse creates a response to parse from ListDegradeRulesOfResource response

type ListExperimentMetasRequest

type ListExperimentMetasRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	Size         requests.Integer `position:"Query" name:"Size"`
	NameSpace    string           `position:"Query" name:"NameSpace"`
	Page         requests.Integer `position:"Query" name:"Page"`
}

ListExperimentMetasRequest is the request struct for api ListExperimentMetas

func CreateListExperimentMetasRequest

func CreateListExperimentMetasRequest() (request *ListExperimentMetasRequest)

CreateListExperimentMetasRequest creates a request to invoke ListExperimentMetas API

type ListExperimentMetasResponse

type ListExperimentMetasResponse struct {
	*responses.BaseResponse
	Pages       int           `json:"Pages" xml:"Pages"`
	RequestId   string        `json:"RequestId" xml:"RequestId"`
	Message     string        `json:"Message" xml:"Message"`
	PageSize    int           `json:"PageSize" xml:"PageSize"`
	CurrentPage int           `json:"CurrentPage" xml:"CurrentPage"`
	Total       int           `json:"Total" xml:"Total"`
	Code        string        `json:"Code" xml:"Code"`
	Success     bool          `json:"Success" xml:"Success"`
	Content     []ContentItem `json:"Content" xml:"Content"`
}

ListExperimentMetasResponse is the response struct for api ListExperimentMetas

func CreateListExperimentMetasResponse

func CreateListExperimentMetasResponse() (response *ListExperimentMetasResponse)

CreateListExperimentMetasResponse creates a response to parse from ListExperimentMetas response

type ListFlowRulesOfAppRequest

type ListFlowRulesOfAppRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	PageIndex    requests.Integer `position:"Query" name:"PageIndex"`
}

ListFlowRulesOfAppRequest is the request struct for api ListFlowRulesOfApp

func CreateListFlowRulesOfAppRequest

func CreateListFlowRulesOfAppRequest() (request *ListFlowRulesOfAppRequest)

CreateListFlowRulesOfAppRequest creates a request to invoke ListFlowRulesOfApp API

type ListFlowRulesOfAppResponse

type ListFlowRulesOfAppResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ListFlowRulesOfAppResponse is the response struct for api ListFlowRulesOfApp

func CreateListFlowRulesOfAppResponse

func CreateListFlowRulesOfAppResponse() (response *ListFlowRulesOfAppResponse)

CreateListFlowRulesOfAppResponse creates a response to parse from ListFlowRulesOfApp response

type ListFlowRulesOfResourceRequest

type ListFlowRulesOfResourceRequest struct {
	*requests.RpcRequest
	Resource     string           `position:"Query" name:"Resource"`
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	PageIndex    requests.Integer `position:"Query" name:"PageIndex"`
}

ListFlowRulesOfResourceRequest is the request struct for api ListFlowRulesOfResource

func CreateListFlowRulesOfResourceRequest

func CreateListFlowRulesOfResourceRequest() (request *ListFlowRulesOfResourceRequest)

CreateListFlowRulesOfResourceRequest creates a request to invoke ListFlowRulesOfResource API

type ListFlowRulesOfResourceResponse

type ListFlowRulesOfResourceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ListFlowRulesOfResourceResponse is the response struct for api ListFlowRulesOfResource

func CreateListFlowRulesOfResourceResponse

func CreateListFlowRulesOfResourceResponse() (response *ListFlowRulesOfResourceResponse)

CreateListFlowRulesOfResourceResponse creates a response to parse from ListFlowRulesOfResource response

type ListHotParamRulesOfAppRequest

type ListHotParamRulesOfAppRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	PageIndex    requests.Integer `position:"Query" name:"PageIndex"`
}

ListHotParamRulesOfAppRequest is the request struct for api ListHotParamRulesOfApp

func CreateListHotParamRulesOfAppRequest

func CreateListHotParamRulesOfAppRequest() (request *ListHotParamRulesOfAppRequest)

CreateListHotParamRulesOfAppRequest creates a request to invoke ListHotParamRulesOfApp API

type ListHotParamRulesOfAppResponse

type ListHotParamRulesOfAppResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ListHotParamRulesOfAppResponse is the response struct for api ListHotParamRulesOfApp

func CreateListHotParamRulesOfAppResponse

func CreateListHotParamRulesOfAppResponse() (response *ListHotParamRulesOfAppResponse)

CreateListHotParamRulesOfAppResponse creates a response to parse from ListHotParamRulesOfApp response

type ListHotParamRulesOfResourceRequest

type ListHotParamRulesOfResourceRequest struct {
	*requests.RpcRequest
	Resource     string           `position:"Query" name:"Resource"`
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	PageIndex    requests.Integer `position:"Query" name:"PageIndex"`
}

ListHotParamRulesOfResourceRequest is the request struct for api ListHotParamRulesOfResource

func CreateListHotParamRulesOfResourceRequest

func CreateListHotParamRulesOfResourceRequest() (request *ListHotParamRulesOfResourceRequest)

CreateListHotParamRulesOfResourceRequest creates a request to invoke ListHotParamRulesOfResource API

type ListHotParamRulesOfResourceResponse

type ListHotParamRulesOfResourceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ListHotParamRulesOfResourceResponse is the response struct for api ListHotParamRulesOfResource

func CreateListHotParamRulesOfResourceResponse

func CreateListHotParamRulesOfResourceResponse() (response *ListHotParamRulesOfResourceResponse)

CreateListHotParamRulesOfResourceResponse creates a response to parse from ListHotParamRulesOfResource response

type ListIsolationRulesOfAppRequest

type ListIsolationRulesOfAppRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	PageIndex    requests.Integer `position:"Query" name:"PageIndex"`
}

ListIsolationRulesOfAppRequest is the request struct for api ListIsolationRulesOfApp

func CreateListIsolationRulesOfAppRequest

func CreateListIsolationRulesOfAppRequest() (request *ListIsolationRulesOfAppRequest)

CreateListIsolationRulesOfAppRequest creates a request to invoke ListIsolationRulesOfApp API

type ListIsolationRulesOfAppResponse

type ListIsolationRulesOfAppResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ListIsolationRulesOfAppResponse is the response struct for api ListIsolationRulesOfApp

func CreateListIsolationRulesOfAppResponse

func CreateListIsolationRulesOfAppResponse() (response *ListIsolationRulesOfAppResponse)

CreateListIsolationRulesOfAppResponse creates a response to parse from ListIsolationRulesOfApp response

type ListIsolationRulesOfResourceRequest

type ListIsolationRulesOfResourceRequest struct {
	*requests.RpcRequest
	Resource     string           `position:"Query" name:"Resource"`
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	PageIndex    requests.Integer `position:"Query" name:"PageIndex"`
}

ListIsolationRulesOfResourceRequest is the request struct for api ListIsolationRulesOfResource

func CreateListIsolationRulesOfResourceRequest

func CreateListIsolationRulesOfResourceRequest() (request *ListIsolationRulesOfResourceRequest)

CreateListIsolationRulesOfResourceRequest creates a request to invoke ListIsolationRulesOfResource API

type ListIsolationRulesOfResourceResponse

type ListIsolationRulesOfResourceResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ListIsolationRulesOfResourceResponse is the response struct for api ListIsolationRulesOfResource

func CreateListIsolationRulesOfResourceResponse

func CreateListIsolationRulesOfResourceResponse() (response *ListIsolationRulesOfResourceResponse)

CreateListIsolationRulesOfResourceResponse creates a response to parse from ListIsolationRulesOfResource response

type ListSystemRulesRequest

type ListSystemRulesRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	AppName      string           `position:"Query" name:"AppName"`
	Namespace    string           `position:"Query" name:"Namespace"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	PageIndex    requests.Integer `position:"Query" name:"PageIndex"`
}

ListSystemRulesRequest is the request struct for api ListSystemRules

func CreateListSystemRulesRequest

func CreateListSystemRulesRequest() (request *ListSystemRulesRequest)

CreateListSystemRulesRequest creates a request to invoke ListSystemRules API

type ListSystemRulesResponse

type ListSystemRulesResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ListSystemRulesResponse is the response struct for api ListSystemRules

func CreateListSystemRulesResponse

func CreateListSystemRulesResponse() (response *ListSystemRulesResponse)

CreateListSystemRulesResponse creates a response to parse from ListSystemRules response

type MetricData

type MetricData struct {
	AppName      string  `json:"AppName" xml:"AppName"`
	PassCount    float64 `json:"PassCount" xml:"PassCount"`
	MachineCount int64   `json:"MachineCount" xml:"MachineCount"`
	AvgRt        float64 `json:"AvgRt" xml:"AvgRt"`
	UserId       string  `json:"UserId" xml:"UserId"`
	Namespace    string  `json:"Namespace" xml:"Namespace"`
	TotalCount   float64 `json:"TotalCount" xml:"TotalCount"`
	BlockCount   float64 `json:"BlockCount" xml:"BlockCount"`
}

MetricData is a nested struct in ahas_openapi response

type MiniApps

type MiniApps struct {
	MiniApps []string `json:"MiniApps" xml:"MiniApps"`
}

MiniApps is a nested struct in ahas_openapi response

type ModifyDegradeRuleRequest

type ModifyDegradeRuleRequest struct {
	*requests.RpcRequest
	RecoveryTimeoutMs         requests.Integer `position:"Query" name:"RecoveryTimeoutMs"`
	Threshold                 requests.Float   `position:"Query" name:"Threshold"`
	AhasRegionId              string           `position:"Query" name:"AhasRegionId"`
	HalfOpenBaseAmountPerStep requests.Integer `position:"Query" name:"HalfOpenBaseAmountPerStep"`
	StatDurationMs            requests.Integer `position:"Query" name:"StatDurationMs"`
	MinRequestAmount          requests.Integer `position:"Query" name:"MinRequestAmount"`
	HalfOpenRecoveryStepNum   requests.Integer `position:"Query" name:"HalfOpenRecoveryStepNum"`
	Strategy                  requests.Integer `position:"Query" name:"Strategy"`
	RuleId                    requests.Integer `position:"Query" name:"RuleId"`
	SlowRtMs                  requests.Integer `position:"Query" name:"SlowRtMs"`
}

ModifyDegradeRuleRequest is the request struct for api ModifyDegradeRule

func CreateModifyDegradeRuleRequest

func CreateModifyDegradeRuleRequest() (request *ModifyDegradeRuleRequest)

CreateModifyDegradeRuleRequest creates a request to invoke ModifyDegradeRule API

type ModifyDegradeRuleResponse

type ModifyDegradeRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ModifyDegradeRuleResponse is the response struct for api ModifyDegradeRule

func CreateModifyDegradeRuleResponse

func CreateModifyDegradeRuleResponse() (response *ModifyDegradeRuleResponse)

CreateModifyDegradeRuleResponse creates a response to parse from ModifyDegradeRule response

type ModifyFlowRuleRequest

type ModifyFlowRuleRequest struct {
	*requests.RpcRequest
	RefResource       string           `position:"Query" name:"RefResource"`
	WarmUpPeriodSec   requests.Integer `position:"Query" name:"WarmUpPeriodSec"`
	ControlBehavior   string           `position:"Query" name:"ControlBehavior"`
	ThresholdMode     requests.Integer `position:"Query" name:"ThresholdMode"`
	Threshold         requests.Float   `position:"Query" name:"Threshold"`
	AhasRegionId      string           `position:"Query" name:"AhasRegionId"`
	LimitOrigin       string           `position:"Query" name:"LimitOrigin"`
	Namespace         string           `position:"Query" name:"Namespace"`
	RelationStrategy  requests.Integer `position:"Query" name:"RelationStrategy"`
	MaxQueueingTimeMs requests.Integer `position:"Query" name:"MaxQueueingTimeMs"`
	RuleId            requests.Integer `position:"Query" name:"RuleId"`
}

ModifyFlowRuleRequest is the request struct for api ModifyFlowRule

func CreateModifyFlowRuleRequest

func CreateModifyFlowRuleRequest() (request *ModifyFlowRuleRequest)

CreateModifyFlowRuleRequest creates a request to invoke ModifyFlowRule API

type ModifyFlowRuleResponse

type ModifyFlowRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ModifyFlowRuleResponse is the response struct for api ModifyFlowRule

func CreateModifyFlowRuleResponse

func CreateModifyFlowRuleResponse() (response *ModifyFlowRuleResponse)

CreateModifyFlowRuleResponse creates a response to parse from ModifyFlowRule response

type ModifyHotParamRuleRequest

type ModifyHotParamRuleRequest struct {
	*requests.RpcRequest
	MetricType        requests.Integer `position:"Query" name:"MetricType"`
	ParamIdx          requests.Integer `position:"Query" name:"ParamIdx"`
	ControlBehavior   requests.Integer `position:"Query" name:"ControlBehavior"`
	Threshold         requests.Float   `position:"Query" name:"Threshold"`
	AhasRegionId      string           `position:"Query" name:"AhasRegionId"`
	Enable            requests.Boolean `position:"Query" name:"Enable"`
	MaxQueueingTimeMs requests.Integer `position:"Query" name:"MaxQueueingTimeMs"`
	RuleId            requests.Integer `position:"Query" name:"RuleId"`
	StatDurationSec   requests.Integer `position:"Query" name:"StatDurationSec"`
	BurstCount        requests.Integer `position:"Query" name:"BurstCount"`
}

ModifyHotParamRuleRequest is the request struct for api ModifyHotParamRule

func CreateModifyHotParamRuleRequest

func CreateModifyHotParamRuleRequest() (request *ModifyHotParamRuleRequest)

CreateModifyHotParamRuleRequest creates a request to invoke ModifyHotParamRule API

type ModifyHotParamRuleResponse

type ModifyHotParamRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ModifyHotParamRuleResponse is the response struct for api ModifyHotParamRule

func CreateModifyHotParamRuleResponse

func CreateModifyHotParamRuleResponse() (response *ModifyHotParamRuleResponse)

CreateModifyHotParamRuleResponse creates a response to parse from ModifyHotParamRule response

type ModifyIsolationRuleRequest

type ModifyIsolationRuleRequest struct {
	*requests.RpcRequest
	RefResource      string           `position:"Query" name:"RefResource"`
	Threshold        requests.Float   `position:"Query" name:"Threshold"`
	AhasRegionId     string           `position:"Query" name:"AhasRegionId"`
	LimitOrigin      string           `position:"Query" name:"LimitOrigin"`
	RelationStrategy requests.Integer `position:"Query" name:"RelationStrategy"`
	RuleId           requests.Integer `position:"Query" name:"RuleId"`
}

ModifyIsolationRuleRequest is the request struct for api ModifyIsolationRule

func CreateModifyIsolationRuleRequest

func CreateModifyIsolationRuleRequest() (request *ModifyIsolationRuleRequest)

CreateModifyIsolationRuleRequest creates a request to invoke ModifyIsolationRule API

type ModifyIsolationRuleResponse

type ModifyIsolationRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ModifyIsolationRuleResponse is the response struct for api ModifyIsolationRule

func CreateModifyIsolationRuleResponse

func CreateModifyIsolationRuleResponse() (response *ModifyIsolationRuleResponse)

CreateModifyIsolationRuleResponse creates a response to parse from ModifyIsolationRule response

type ModifySystemRuleRequest

type ModifySystemRuleRequest struct {
	*requests.RpcRequest
	Threshold    requests.Float   `position:"Query" name:"Threshold"`
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	RuleId       requests.Integer `position:"Query" name:"RuleId"`
}

ModifySystemRuleRequest is the request struct for api ModifySystemRule

func CreateModifySystemRuleRequest

func CreateModifySystemRuleRequest() (request *ModifySystemRuleRequest)

CreateModifySystemRuleRequest creates a request to invoke ModifySystemRule API

type ModifySystemRuleResponse

type ModifySystemRuleResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
	Data      Data   `json:"Data" xml:"Data"`
}

ModifySystemRuleResponse is the response struct for api ModifySystemRule

func CreateModifySystemRuleResponse

func CreateModifySystemRuleResponse() (response *ModifySystemRuleResponse)

CreateModifySystemRuleResponse creates a response to parse from ModifySystemRule response

type OpenAhasServiceRequest

type OpenAhasServiceRequest struct {
	*requests.RpcRequest
	OwnerId requests.Integer `position:"Query" name:"OwnerId"`
}

OpenAhasServiceRequest is the request struct for api OpenAhasService

func CreateOpenAhasServiceRequest

func CreateOpenAhasServiceRequest() (request *OpenAhasServiceRequest)

CreateOpenAhasServiceRequest creates a request to invoke OpenAhasService API

type OpenAhasServiceResponse

type OpenAhasServiceResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	OrderId   string `json:"OrderId" xml:"OrderId"`
}

OpenAhasServiceResponse is the response struct for api OpenAhasService

func CreateOpenAhasServiceResponse

func CreateOpenAhasServiceResponse() (response *OpenAhasServiceResponse)

CreateOpenAhasServiceResponse creates a response to parse from OpenAhasService response

type PageableQueryExperimentTaskByClusterIdRequest

type PageableQueryExperimentTaskByClusterIdRequest struct {
	*requests.RpcRequest
	ClusterId          string           `position:"Query" name:"ClusterId"`
	AhasRegionId       string           `position:"Query" name:"AhasRegionId"`
	IncludeInvalidHost requests.Boolean `position:"Query" name:"IncludeInvalidHost"`
	Size               requests.Integer `position:"Query" name:"Size"`
	Namespace          string           `position:"Query" name:"Namespace"`
	Page               requests.Integer `position:"Query" name:"Page"`
}

PageableQueryExperimentTaskByClusterIdRequest is the request struct for api PageableQueryExperimentTaskByClusterId

func CreatePageableQueryExperimentTaskByClusterIdRequest

func CreatePageableQueryExperimentTaskByClusterIdRequest() (request *PageableQueryExperimentTaskByClusterIdRequest)

CreatePageableQueryExperimentTaskByClusterIdRequest creates a request to invoke PageableQueryExperimentTaskByClusterId API

type PageableQueryExperimentTaskByClusterIdResponse

type PageableQueryExperimentTaskByClusterIdResponse struct {
	*responses.BaseResponse
	Pages           int                  `json:"Pages" xml:"Pages"`
	RequestId       string               `json:"RequestId" xml:"RequestId"`
	Message         string               `json:"Message" xml:"Message"`
	PageSize        int                  `json:"PageSize" xml:"PageSize"`
	CurrentPage     int                  `json:"CurrentPage" xml:"CurrentPage"`
	Total           int                  `json:"Total" xml:"Total"`
	HttpStatusCode  int                  `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code            string               `json:"Code" xml:"Code"`
	Success         bool                 `json:"Success" xml:"Success"`
	ExperimentTasks []ExperimentTaskInfo `json:"ExperimentTasks" xml:"ExperimentTasks"`
}

PageableQueryExperimentTaskByClusterIdResponse is the response struct for api PageableQueryExperimentTaskByClusterId

func CreatePageableQueryExperimentTaskByClusterIdResponse

func CreatePageableQueryExperimentTaskByClusterIdResponse() (response *PageableQueryExperimentTaskByClusterIdResponse)

CreatePageableQueryExperimentTaskByClusterIdResponse creates a response to parse from PageableQueryExperimentTaskByClusterId response

type PageableQueryExperimentTaskByExperimentIdRequest

type PageableQueryExperimentTaskByExperimentIdRequest struct {
	*requests.RpcRequest
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	Size         requests.Integer `position:"Query" name:"Size"`
	Namespace    string           `position:"Query" name:"Namespace"`
	ExperimentId string           `position:"Query" name:"ExperimentId"`
	Page         requests.Integer `position:"Query" name:"Page"`
}

PageableQueryExperimentTaskByExperimentIdRequest is the request struct for api PageableQueryExperimentTaskByExperimentId

func CreatePageableQueryExperimentTaskByExperimentIdRequest

func CreatePageableQueryExperimentTaskByExperimentIdRequest() (request *PageableQueryExperimentTaskByExperimentIdRequest)

CreatePageableQueryExperimentTaskByExperimentIdRequest creates a request to invoke PageableQueryExperimentTaskByExperimentId API

type PageableQueryExperimentTaskByExperimentIdResponse

type PageableQueryExperimentTaskByExperimentIdResponse struct {
	*responses.BaseResponse
	Pages           int                  `json:"Pages" xml:"Pages"`
	RequestId       string               `json:"RequestId" xml:"RequestId"`
	Message         string               `json:"Message" xml:"Message"`
	PageSize        int                  `json:"PageSize" xml:"PageSize"`
	CurrentPage     int                  `json:"CurrentPage" xml:"CurrentPage"`
	Total           int                  `json:"Total" xml:"Total"`
	HttpStatusCode  int                  `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code            string               `json:"Code" xml:"Code"`
	Success         bool                 `json:"Success" xml:"Success"`
	ExperimentTasks []ExperimentTaskInfo `json:"ExperimentTasks" xml:"ExperimentTasks"`
}

PageableQueryExperimentTaskByExperimentIdResponse is the response struct for api PageableQueryExperimentTaskByExperimentId

func CreatePageableQueryExperimentTaskByExperimentIdResponse

func CreatePageableQueryExperimentTaskByExperimentIdResponse() (response *PageableQueryExperimentTaskByExperimentIdResponse)

CreatePageableQueryExperimentTaskByExperimentIdResponse creates a response to parse from PageableQueryExperimentTaskByExperimentId response

type PageableQueryUserExperimentRequest

type PageableQueryUserExperimentRequest struct {
	*requests.RpcRequest
	SearchKey    string           `position:"Query" name:"SearchKey"`
	AhasRegionId string           `position:"Query" name:"AhasRegionId"`
	Tags         *[]string        `position:"Query" name:"Tags"  type:"Repeated"`
	Size         requests.Integer `position:"Query" name:"Size"`
	Namespace    string           `position:"Query" name:"Namespace"`
	State        string           `position:"Query" name:"State"`
	Page         requests.Integer `position:"Query" name:"Page"`
	Results      *[]string        `position:"Query" name:"Results"  type:"Repeated"`
	WorkspaceId  string           `position:"Query" name:"WorkspaceId"`
}

PageableQueryUserExperimentRequest is the request struct for api PageableQueryUserExperiment

func CreatePageableQueryUserExperimentRequest

func CreatePageableQueryUserExperimentRequest() (request *PageableQueryUserExperimentRequest)

CreatePageableQueryUserExperimentRequest creates a request to invoke PageableQueryUserExperiment API

type PageableQueryUserExperimentResponse

type PageableQueryUserExperimentResponse struct {
	*responses.BaseResponse
	Pages          int              `json:"Pages" xml:"Pages"`
	RequestId      string           `json:"RequestId" xml:"RequestId"`
	Message        string           `json:"Message" xml:"Message"`
	PageSize       int              `json:"PageSize" xml:"PageSize"`
	CurrentPage    int              `json:"CurrentPage" xml:"CurrentPage"`
	Total          int              `json:"Total" xml:"Total"`
	HttpStatusCode int              `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           string           `json:"Code" xml:"Code"`
	Success        bool             `json:"Success" xml:"Success"`
	ExperimentList []ExperimentInfo `json:"ExperimentList" xml:"ExperimentList"`
}

PageableQueryUserExperimentResponse is the response struct for api PageableQueryUserExperiment

func CreatePageableQueryUserExperimentResponse

func CreatePageableQueryUserExperimentResponse() (response *PageableQueryUserExperimentResponse)

CreatePageableQueryUserExperimentResponse creates a response to parse from PageableQueryUserExperiment response

type ParamFlowItemListInCreateHotParamItems

type ParamFlowItemListInCreateHotParamItems struct {
	ParamFlowItemListItem []ParamFlowItemListItem `json:"ParamFlowItemList" xml:"ParamFlowItemList"`
}

ParamFlowItemListInCreateHotParamItems is a nested struct in ahas_openapi response

type ParamFlowItemListInCreateHotParamRule

type ParamFlowItemListInCreateHotParamRule struct {
	ParamFlowItemListItem []ParamFlowItemListItem `json:"ParamFlowItemList" xml:"ParamFlowItemList"`
}

ParamFlowItemListInCreateHotParamRule is a nested struct in ahas_openapi response

type ParamFlowItemListInDisableHotParamRule

type ParamFlowItemListInDisableHotParamRule struct {
	ParamFlowItemListItem []ParamFlowItemListItem `json:"ParamFlowItemList" xml:"ParamFlowItemList"`
}

ParamFlowItemListInDisableHotParamRule is a nested struct in ahas_openapi response

type ParamFlowItemListInEnableHotParamRule

type ParamFlowItemListInEnableHotParamRule struct {
	ParamFlowItemListItem []ParamFlowItemListItem `json:"ParamFlowItemList" xml:"ParamFlowItemList"`
}

ParamFlowItemListInEnableHotParamRule is a nested struct in ahas_openapi response

type ParamFlowItemListInListHotParamRulesOfApp

type ParamFlowItemListInListHotParamRulesOfApp struct {
	ParamFlowItemListItem []ParamFlowItemListItem `json:"ParamFlowItemList" xml:"ParamFlowItemList"`
}

ParamFlowItemListInListHotParamRulesOfApp is a nested struct in ahas_openapi response

type ParamFlowItemListInListHotParamRulesOfResource

type ParamFlowItemListInListHotParamRulesOfResource struct {
	ParamFlowItemListItem []ParamFlowItemListItem `json:"ParamFlowItemList" xml:"ParamFlowItemList"`
}

ParamFlowItemListInListHotParamRulesOfResource is a nested struct in ahas_openapi response

type ParamFlowItemListInModifyHotParamRule

type ParamFlowItemListInModifyHotParamRule struct {
	ParamFlowItemListItem []ParamFlowItemListItem `json:"ParamFlowItemList" xml:"ParamFlowItemList"`
}

ParamFlowItemListInModifyHotParamRule is a nested struct in ahas_openapi response

type ParamFlowItemListItem

type ParamFlowItemListItem struct {
	ItemValue string  `json:"ItemValue" xml:"ItemValue"`
	ItemType  string  `json:"ItemType" xml:"ItemType"`
	Threshold float64 `json:"Threshold" xml:"Threshold"`
}

ParamFlowItemListItem is a nested struct in ahas_openapi response

type PushExperimentTaskRequest

type PushExperimentTaskRequest struct {
	*requests.RpcRequest
	AhasRegionId     string `position:"Query" name:"AhasRegionId"`
	NameSpace        string `position:"Query" name:"NameSpace"`
	ExperimentTaskId string `position:"Query" name:"ExperimentTaskId"`
}

PushExperimentTaskRequest is the request struct for api PushExperimentTask

func CreatePushExperimentTaskRequest

func CreatePushExperimentTaskRequest() (request *PushExperimentTaskRequest)

CreatePushExperimentTaskRequest creates a request to invoke PushExperimentTask API

type PushExperimentTaskResponse

type PushExperimentTaskResponse struct {
	*responses.BaseResponse
	Message   string `json:"Message" xml:"Message"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Code      string `json:"Code" xml:"Code"`
	Success   bool   `json:"Success" xml:"Success"`
}

PushExperimentTaskResponse is the response struct for api PushExperimentTask

func CreatePushExperimentTaskResponse

func CreatePushExperimentTaskResponse() (response *PushExperimentTaskResponse)

CreatePushExperimentTaskResponse creates a response to parse from PushExperimentTask response

type Regions

type Regions struct {
	Data []Data `json:"Data" xml:"Data"`
}

Regions is a nested struct in ahas_openapi response

type SchedulerConfig

type SchedulerConfig struct {
	FixedTime      string `json:"FixedTime" xml:"FixedTime"`
	CronExpression string `json:"CronExpression" xml:"CronExpression"`
}

SchedulerConfig is a nested struct in ahas_openapi response

type TagsInGetExperimentMeta

type TagsInGetExperimentMeta struct {
	Tags []string `json:"Tags" xml:"Tags"`
}

TagsInGetExperimentMeta is a nested struct in ahas_openapi response

type TagsInListExperimentMetas

type TagsInListExperimentMetas struct {
	Tags []string `json:"Tags" xml:"Tags"`
}

TagsInListExperimentMetas is a nested struct in ahas_openapi response

type TagsInPageableQueryUserExperiment

type TagsInPageableQueryUserExperiment struct {
	Tags []string `json:"Tags" xml:"Tags"`
}

TagsInPageableQueryUserExperiment is a nested struct in ahas_openapi response

type UpdateExperimentBasicInfoRequest

type UpdateExperimentBasicInfoRequest struct {
	*requests.RpcRequest
	Description  string    `position:"Query" name:"Description"`
	AhasRegionId string    `position:"Query" name:"AhasRegionId"`
	Tags         *[]string `position:"Query" name:"Tags"  type:"Repeated"`
	NameSpace    string    `position:"Query" name:"NameSpace"`
	Name         string    `position:"Query" name:"Name"`
	ExperimentId string    `position:"Query" name:"ExperimentId"`
}

UpdateExperimentBasicInfoRequest is the request struct for api UpdateExperimentBasicInfo

func CreateUpdateExperimentBasicInfoRequest

func CreateUpdateExperimentBasicInfoRequest() (request *UpdateExperimentBasicInfoRequest)

CreateUpdateExperimentBasicInfoRequest creates a request to invoke UpdateExperimentBasicInfo API

type UpdateExperimentBasicInfoResponse

type UpdateExperimentBasicInfoResponse struct {
	*responses.BaseResponse
	Message        string `json:"Message" xml:"Message"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           string `json:"Code" xml:"Code"`
	Success        bool   `json:"Success" xml:"Success"`
}

UpdateExperimentBasicInfoResponse is the response struct for api UpdateExperimentBasicInfo

func CreateUpdateExperimentBasicInfoResponse

func CreateUpdateExperimentBasicInfoResponse() (response *UpdateExperimentBasicInfoResponse)

CreateUpdateExperimentBasicInfoResponse creates a response to parse from UpdateExperimentBasicInfo response

type UpdateExperimentRequest

type UpdateExperimentRequest struct {
	*requests.RpcRequest
	Description  string    `position:"Query" name:"Description"`
	AhasRegionId string    `position:"Query" name:"AhasRegionId"`
	Tags         *[]string `position:"Query" name:"Tags"  type:"Repeated"`
	Name         string    `position:"Query" name:"Name"`
	NameSpace    string    `position:"Query" name:"NameSpace"`
	Definition   string    `position:"Query" name:"Definition"`
	ExperimentId string    `position:"Query" name:"ExperimentId"`
}

UpdateExperimentRequest is the request struct for api UpdateExperiment

func CreateUpdateExperimentRequest

func CreateUpdateExperimentRequest() (request *UpdateExperimentRequest)

CreateUpdateExperimentRequest creates a request to invoke UpdateExperiment API

type UpdateExperimentResponse

type UpdateExperimentResponse struct {
	*responses.BaseResponse
	Message        string `json:"Message" xml:"Message"`
	RequestId      string `json:"RequestId" xml:"RequestId"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	Code           string `json:"Code" xml:"Code"`
	Success        bool   `json:"Success" xml:"Success"`
}

UpdateExperimentResponse is the response struct for api UpdateExperiment

func CreateUpdateExperimentResponse

func CreateUpdateExperimentResponse() (response *UpdateExperimentResponse)

CreateUpdateExperimentResponse creates a response to parse from UpdateExperiment response

type WorkspaceInfo

type WorkspaceInfo struct {
	Type        int    `json:"Type" xml:"Type"`
	WorkspaceId string `json:"WorkspaceId" xml:"WorkspaceId"`
	Description string `json:"Description" xml:"Description"`
	Name        string `json:"Name" xml:"Name"`
}

WorkspaceInfo is a nested struct in ahas_openapi response

type WorkspaceList

type WorkspaceList struct {
	WorkspaceInfo []WorkspaceInfo `json:"WorkspaceInfo" xml:"WorkspaceInfo"`
}

WorkspaceList is a nested struct in ahas_openapi response